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 if self.join_encoding_type != 0 {
1035 len += 1;
1036 }
1037 let mut struct_ser = serializer.serialize_struct("stream_plan.AsOfJoinNode", len)?;
1038 if self.join_type != 0 {
1039 let v = super::plan_common::AsOfJoinType::try_from(self.join_type)
1040 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
1041 struct_ser.serialize_field("joinType", &v)?;
1042 }
1043 if !self.left_key.is_empty() {
1044 struct_ser.serialize_field("leftKey", &self.left_key)?;
1045 }
1046 if !self.right_key.is_empty() {
1047 struct_ser.serialize_field("rightKey", &self.right_key)?;
1048 }
1049 if let Some(v) = self.left_table.as_ref() {
1050 struct_ser.serialize_field("leftTable", v)?;
1051 }
1052 if let Some(v) = self.right_table.as_ref() {
1053 struct_ser.serialize_field("rightTable", v)?;
1054 }
1055 if !self.output_indices.is_empty() {
1056 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
1057 }
1058 if !self.left_deduped_input_pk_indices.is_empty() {
1059 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
1060 }
1061 if !self.right_deduped_input_pk_indices.is_empty() {
1062 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
1063 }
1064 if !self.null_safe.is_empty() {
1065 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
1066 }
1067 if let Some(v) = self.asof_desc.as_ref() {
1068 struct_ser.serialize_field("asofDesc", v)?;
1069 }
1070 if self.join_encoding_type != 0 {
1071 let v = JoinEncodingType::try_from(self.join_encoding_type)
1072 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
1073 struct_ser.serialize_field("joinEncodingType", &v)?;
1074 }
1075 struct_ser.end()
1076 }
1077}
1078impl<'de> serde::Deserialize<'de> for AsOfJoinNode {
1079 #[allow(deprecated)]
1080 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1081 where
1082 D: serde::Deserializer<'de>,
1083 {
1084 const FIELDS: &[&str] = &[
1085 "join_type",
1086 "joinType",
1087 "left_key",
1088 "leftKey",
1089 "right_key",
1090 "rightKey",
1091 "left_table",
1092 "leftTable",
1093 "right_table",
1094 "rightTable",
1095 "output_indices",
1096 "outputIndices",
1097 "left_deduped_input_pk_indices",
1098 "leftDedupedInputPkIndices",
1099 "right_deduped_input_pk_indices",
1100 "rightDedupedInputPkIndices",
1101 "null_safe",
1102 "nullSafe",
1103 "asof_desc",
1104 "asofDesc",
1105 "join_encoding_type",
1106 "joinEncodingType",
1107 ];
1108
1109 #[allow(clippy::enum_variant_names)]
1110 enum GeneratedField {
1111 JoinType,
1112 LeftKey,
1113 RightKey,
1114 LeftTable,
1115 RightTable,
1116 OutputIndices,
1117 LeftDedupedInputPkIndices,
1118 RightDedupedInputPkIndices,
1119 NullSafe,
1120 AsofDesc,
1121 JoinEncodingType,
1122 }
1123 impl<'de> serde::Deserialize<'de> for GeneratedField {
1124 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1125 where
1126 D: serde::Deserializer<'de>,
1127 {
1128 struct GeneratedVisitor;
1129
1130 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1131 type Value = GeneratedField;
1132
1133 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1134 write!(formatter, "expected one of: {:?}", &FIELDS)
1135 }
1136
1137 #[allow(unused_variables)]
1138 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1139 where
1140 E: serde::de::Error,
1141 {
1142 match value {
1143 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
1144 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
1145 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
1146 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
1147 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
1148 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
1149 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
1150 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
1151 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
1152 "asofDesc" | "asof_desc" => Ok(GeneratedField::AsofDesc),
1153 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
1154 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1155 }
1156 }
1157 }
1158 deserializer.deserialize_identifier(GeneratedVisitor)
1159 }
1160 }
1161 struct GeneratedVisitor;
1162 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1163 type Value = AsOfJoinNode;
1164
1165 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1166 formatter.write_str("struct stream_plan.AsOfJoinNode")
1167 }
1168
1169 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AsOfJoinNode, V::Error>
1170 where
1171 V: serde::de::MapAccess<'de>,
1172 {
1173 let mut join_type__ = None;
1174 let mut left_key__ = None;
1175 let mut right_key__ = None;
1176 let mut left_table__ = None;
1177 let mut right_table__ = None;
1178 let mut output_indices__ = None;
1179 let mut left_deduped_input_pk_indices__ = None;
1180 let mut right_deduped_input_pk_indices__ = None;
1181 let mut null_safe__ = None;
1182 let mut asof_desc__ = None;
1183 let mut join_encoding_type__ = None;
1184 while let Some(k) = map_.next_key()? {
1185 match k {
1186 GeneratedField::JoinType => {
1187 if join_type__.is_some() {
1188 return Err(serde::de::Error::duplicate_field("joinType"));
1189 }
1190 join_type__ = Some(map_.next_value::<super::plan_common::AsOfJoinType>()? as i32);
1191 }
1192 GeneratedField::LeftKey => {
1193 if left_key__.is_some() {
1194 return Err(serde::de::Error::duplicate_field("leftKey"));
1195 }
1196 left_key__ =
1197 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1198 .into_iter().map(|x| x.0).collect())
1199 ;
1200 }
1201 GeneratedField::RightKey => {
1202 if right_key__.is_some() {
1203 return Err(serde::de::Error::duplicate_field("rightKey"));
1204 }
1205 right_key__ =
1206 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1207 .into_iter().map(|x| x.0).collect())
1208 ;
1209 }
1210 GeneratedField::LeftTable => {
1211 if left_table__.is_some() {
1212 return Err(serde::de::Error::duplicate_field("leftTable"));
1213 }
1214 left_table__ = map_.next_value()?;
1215 }
1216 GeneratedField::RightTable => {
1217 if right_table__.is_some() {
1218 return Err(serde::de::Error::duplicate_field("rightTable"));
1219 }
1220 right_table__ = map_.next_value()?;
1221 }
1222 GeneratedField::OutputIndices => {
1223 if output_indices__.is_some() {
1224 return Err(serde::de::Error::duplicate_field("outputIndices"));
1225 }
1226 output_indices__ =
1227 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1228 .into_iter().map(|x| x.0).collect())
1229 ;
1230 }
1231 GeneratedField::LeftDedupedInputPkIndices => {
1232 if left_deduped_input_pk_indices__.is_some() {
1233 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
1234 }
1235 left_deduped_input_pk_indices__ =
1236 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1237 .into_iter().map(|x| x.0).collect())
1238 ;
1239 }
1240 GeneratedField::RightDedupedInputPkIndices => {
1241 if right_deduped_input_pk_indices__.is_some() {
1242 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
1243 }
1244 right_deduped_input_pk_indices__ =
1245 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1246 .into_iter().map(|x| x.0).collect())
1247 ;
1248 }
1249 GeneratedField::NullSafe => {
1250 if null_safe__.is_some() {
1251 return Err(serde::de::Error::duplicate_field("nullSafe"));
1252 }
1253 null_safe__ = Some(map_.next_value()?);
1254 }
1255 GeneratedField::AsofDesc => {
1256 if asof_desc__.is_some() {
1257 return Err(serde::de::Error::duplicate_field("asofDesc"));
1258 }
1259 asof_desc__ = map_.next_value()?;
1260 }
1261 GeneratedField::JoinEncodingType => {
1262 if join_encoding_type__.is_some() {
1263 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
1264 }
1265 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
1266 }
1267 }
1268 }
1269 Ok(AsOfJoinNode {
1270 join_type: join_type__.unwrap_or_default(),
1271 left_key: left_key__.unwrap_or_default(),
1272 right_key: right_key__.unwrap_or_default(),
1273 left_table: left_table__,
1274 right_table: right_table__,
1275 output_indices: output_indices__.unwrap_or_default(),
1276 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
1277 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
1278 null_safe: null_safe__.unwrap_or_default(),
1279 asof_desc: asof_desc__,
1280 join_encoding_type: join_encoding_type__.unwrap_or_default(),
1281 })
1282 }
1283 }
1284 deserializer.deserialize_struct("stream_plan.AsOfJoinNode", FIELDS, GeneratedVisitor)
1285 }
1286}
1287impl serde::Serialize for BackfillOrder {
1288 #[allow(deprecated)]
1289 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1290 where
1291 S: serde::Serializer,
1292 {
1293 use serde::ser::SerializeStruct;
1294 let mut len = 0;
1295 if !self.order.is_empty() {
1296 len += 1;
1297 }
1298 let mut struct_ser = serializer.serialize_struct("stream_plan.BackfillOrder", len)?;
1299 if !self.order.is_empty() {
1300 struct_ser.serialize_field("order", &self.order)?;
1301 }
1302 struct_ser.end()
1303 }
1304}
1305impl<'de> serde::Deserialize<'de> for BackfillOrder {
1306 #[allow(deprecated)]
1307 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1308 where
1309 D: serde::Deserializer<'de>,
1310 {
1311 const FIELDS: &[&str] = &[
1312 "order",
1313 ];
1314
1315 #[allow(clippy::enum_variant_names)]
1316 enum GeneratedField {
1317 Order,
1318 }
1319 impl<'de> serde::Deserialize<'de> for GeneratedField {
1320 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1321 where
1322 D: serde::Deserializer<'de>,
1323 {
1324 struct GeneratedVisitor;
1325
1326 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1327 type Value = GeneratedField;
1328
1329 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1330 write!(formatter, "expected one of: {:?}", &FIELDS)
1331 }
1332
1333 #[allow(unused_variables)]
1334 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1335 where
1336 E: serde::de::Error,
1337 {
1338 match value {
1339 "order" => Ok(GeneratedField::Order),
1340 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1341 }
1342 }
1343 }
1344 deserializer.deserialize_identifier(GeneratedVisitor)
1345 }
1346 }
1347 struct GeneratedVisitor;
1348 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1349 type Value = BackfillOrder;
1350
1351 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1352 formatter.write_str("struct stream_plan.BackfillOrder")
1353 }
1354
1355 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BackfillOrder, V::Error>
1356 where
1357 V: serde::de::MapAccess<'de>,
1358 {
1359 let mut order__ = None;
1360 while let Some(k) = map_.next_key()? {
1361 match k {
1362 GeneratedField::Order => {
1363 if order__.is_some() {
1364 return Err(serde::de::Error::duplicate_field("order"));
1365 }
1366 order__ = Some(
1367 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1368 .into_iter().map(|(k,v)| (k.0, v)).collect()
1369 );
1370 }
1371 }
1372 }
1373 Ok(BackfillOrder {
1374 order: order__.unwrap_or_default(),
1375 })
1376 }
1377 }
1378 deserializer.deserialize_struct("stream_plan.BackfillOrder", FIELDS, GeneratedVisitor)
1379 }
1380}
1381impl serde::Serialize for Barrier {
1382 #[allow(deprecated)]
1383 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1384 where
1385 S: serde::Serializer,
1386 {
1387 use serde::ser::SerializeStruct;
1388 let mut len = 0;
1389 if self.epoch.is_some() {
1390 len += 1;
1391 }
1392 if self.mutation.is_some() {
1393 len += 1;
1394 }
1395 if !self.tracing_context.is_empty() {
1396 len += 1;
1397 }
1398 if self.kind != 0 {
1399 len += 1;
1400 }
1401 if !self.passed_actors.is_empty() {
1402 len += 1;
1403 }
1404 let mut struct_ser = serializer.serialize_struct("stream_plan.Barrier", len)?;
1405 if let Some(v) = self.epoch.as_ref() {
1406 struct_ser.serialize_field("epoch", v)?;
1407 }
1408 if let Some(v) = self.mutation.as_ref() {
1409 struct_ser.serialize_field("mutation", v)?;
1410 }
1411 if !self.tracing_context.is_empty() {
1412 struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
1413 }
1414 if self.kind != 0 {
1415 let v = barrier::BarrierKind::try_from(self.kind)
1416 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
1417 struct_ser.serialize_field("kind", &v)?;
1418 }
1419 if !self.passed_actors.is_empty() {
1420 struct_ser.serialize_field("passedActors", &self.passed_actors)?;
1421 }
1422 struct_ser.end()
1423 }
1424}
1425impl<'de> serde::Deserialize<'de> for Barrier {
1426 #[allow(deprecated)]
1427 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1428 where
1429 D: serde::Deserializer<'de>,
1430 {
1431 const FIELDS: &[&str] = &[
1432 "epoch",
1433 "mutation",
1434 "tracing_context",
1435 "tracingContext",
1436 "kind",
1437 "passed_actors",
1438 "passedActors",
1439 ];
1440
1441 #[allow(clippy::enum_variant_names)]
1442 enum GeneratedField {
1443 Epoch,
1444 Mutation,
1445 TracingContext,
1446 Kind,
1447 PassedActors,
1448 }
1449 impl<'de> serde::Deserialize<'de> for GeneratedField {
1450 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1451 where
1452 D: serde::Deserializer<'de>,
1453 {
1454 struct GeneratedVisitor;
1455
1456 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1457 type Value = GeneratedField;
1458
1459 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1460 write!(formatter, "expected one of: {:?}", &FIELDS)
1461 }
1462
1463 #[allow(unused_variables)]
1464 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1465 where
1466 E: serde::de::Error,
1467 {
1468 match value {
1469 "epoch" => Ok(GeneratedField::Epoch),
1470 "mutation" => Ok(GeneratedField::Mutation),
1471 "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
1472 "kind" => Ok(GeneratedField::Kind),
1473 "passedActors" | "passed_actors" => Ok(GeneratedField::PassedActors),
1474 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1475 }
1476 }
1477 }
1478 deserializer.deserialize_identifier(GeneratedVisitor)
1479 }
1480 }
1481 struct GeneratedVisitor;
1482 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1483 type Value = Barrier;
1484
1485 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1486 formatter.write_str("struct stream_plan.Barrier")
1487 }
1488
1489 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Barrier, V::Error>
1490 where
1491 V: serde::de::MapAccess<'de>,
1492 {
1493 let mut epoch__ = None;
1494 let mut mutation__ = None;
1495 let mut tracing_context__ = None;
1496 let mut kind__ = None;
1497 let mut passed_actors__ = None;
1498 while let Some(k) = map_.next_key()? {
1499 match k {
1500 GeneratedField::Epoch => {
1501 if epoch__.is_some() {
1502 return Err(serde::de::Error::duplicate_field("epoch"));
1503 }
1504 epoch__ = map_.next_value()?;
1505 }
1506 GeneratedField::Mutation => {
1507 if mutation__.is_some() {
1508 return Err(serde::de::Error::duplicate_field("mutation"));
1509 }
1510 mutation__ = map_.next_value()?;
1511 }
1512 GeneratedField::TracingContext => {
1513 if tracing_context__.is_some() {
1514 return Err(serde::de::Error::duplicate_field("tracingContext"));
1515 }
1516 tracing_context__ = Some(
1517 map_.next_value::<std::collections::HashMap<_, _>>()?
1518 );
1519 }
1520 GeneratedField::Kind => {
1521 if kind__.is_some() {
1522 return Err(serde::de::Error::duplicate_field("kind"));
1523 }
1524 kind__ = Some(map_.next_value::<barrier::BarrierKind>()? as i32);
1525 }
1526 GeneratedField::PassedActors => {
1527 if passed_actors__.is_some() {
1528 return Err(serde::de::Error::duplicate_field("passedActors"));
1529 }
1530 passed_actors__ =
1531 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1532 .into_iter().map(|x| x.0).collect())
1533 ;
1534 }
1535 }
1536 }
1537 Ok(Barrier {
1538 epoch: epoch__,
1539 mutation: mutation__,
1540 tracing_context: tracing_context__.unwrap_or_default(),
1541 kind: kind__.unwrap_or_default(),
1542 passed_actors: passed_actors__.unwrap_or_default(),
1543 })
1544 }
1545 }
1546 deserializer.deserialize_struct("stream_plan.Barrier", FIELDS, GeneratedVisitor)
1547 }
1548}
1549impl serde::Serialize for barrier::BarrierKind {
1550 #[allow(deprecated)]
1551 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1552 where
1553 S: serde::Serializer,
1554 {
1555 let variant = match self {
1556 Self::Unspecified => "BARRIER_KIND_UNSPECIFIED",
1557 Self::Initial => "BARRIER_KIND_INITIAL",
1558 Self::Barrier => "BARRIER_KIND_BARRIER",
1559 Self::Checkpoint => "BARRIER_KIND_CHECKPOINT",
1560 };
1561 serializer.serialize_str(variant)
1562 }
1563}
1564impl<'de> serde::Deserialize<'de> for barrier::BarrierKind {
1565 #[allow(deprecated)]
1566 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1567 where
1568 D: serde::Deserializer<'de>,
1569 {
1570 const FIELDS: &[&str] = &[
1571 "BARRIER_KIND_UNSPECIFIED",
1572 "BARRIER_KIND_INITIAL",
1573 "BARRIER_KIND_BARRIER",
1574 "BARRIER_KIND_CHECKPOINT",
1575 ];
1576
1577 struct GeneratedVisitor;
1578
1579 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1580 type Value = barrier::BarrierKind;
1581
1582 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1583 write!(formatter, "expected one of: {:?}", &FIELDS)
1584 }
1585
1586 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1587 where
1588 E: serde::de::Error,
1589 {
1590 i32::try_from(v)
1591 .ok()
1592 .and_then(|x| x.try_into().ok())
1593 .ok_or_else(|| {
1594 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1595 })
1596 }
1597
1598 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1599 where
1600 E: serde::de::Error,
1601 {
1602 i32::try_from(v)
1603 .ok()
1604 .and_then(|x| x.try_into().ok())
1605 .ok_or_else(|| {
1606 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1607 })
1608 }
1609
1610 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1611 where
1612 E: serde::de::Error,
1613 {
1614 match value {
1615 "BARRIER_KIND_UNSPECIFIED" => Ok(barrier::BarrierKind::Unspecified),
1616 "BARRIER_KIND_INITIAL" => Ok(barrier::BarrierKind::Initial),
1617 "BARRIER_KIND_BARRIER" => Ok(barrier::BarrierKind::Barrier),
1618 "BARRIER_KIND_CHECKPOINT" => Ok(barrier::BarrierKind::Checkpoint),
1619 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1620 }
1621 }
1622 }
1623 deserializer.deserialize_any(GeneratedVisitor)
1624 }
1625}
1626impl serde::Serialize for BarrierMutation {
1627 #[allow(deprecated)]
1628 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1629 where
1630 S: serde::Serializer,
1631 {
1632 use serde::ser::SerializeStruct;
1633 let mut len = 0;
1634 if self.mutation.is_some() {
1635 len += 1;
1636 }
1637 let mut struct_ser = serializer.serialize_struct("stream_plan.BarrierMutation", len)?;
1638 if let Some(v) = self.mutation.as_ref() {
1639 match v {
1640 barrier_mutation::Mutation::Add(v) => {
1641 struct_ser.serialize_field("add", v)?;
1642 }
1643 barrier_mutation::Mutation::Stop(v) => {
1644 struct_ser.serialize_field("stop", v)?;
1645 }
1646 barrier_mutation::Mutation::Update(v) => {
1647 struct_ser.serialize_field("update", v)?;
1648 }
1649 barrier_mutation::Mutation::Splits(v) => {
1650 struct_ser.serialize_field("splits", v)?;
1651 }
1652 barrier_mutation::Mutation::Pause(v) => {
1653 struct_ser.serialize_field("pause", v)?;
1654 }
1655 barrier_mutation::Mutation::Resume(v) => {
1656 struct_ser.serialize_field("resume", v)?;
1657 }
1658 barrier_mutation::Mutation::Throttle(v) => {
1659 struct_ser.serialize_field("throttle", v)?;
1660 }
1661 barrier_mutation::Mutation::DropSubscriptions(v) => {
1662 struct_ser.serialize_field("dropSubscriptions", v)?;
1663 }
1664 barrier_mutation::Mutation::ConnectorPropsChange(v) => {
1665 struct_ser.serialize_field("connectorPropsChange", v)?;
1666 }
1667 barrier_mutation::Mutation::StartFragmentBackfill(v) => {
1668 struct_ser.serialize_field("startFragmentBackfill", v)?;
1669 }
1670 barrier_mutation::Mutation::Combined(v) => {
1671 struct_ser.serialize_field("combined", v)?;
1672 }
1673 }
1674 }
1675 struct_ser.end()
1676 }
1677}
1678impl<'de> serde::Deserialize<'de> for BarrierMutation {
1679 #[allow(deprecated)]
1680 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1681 where
1682 D: serde::Deserializer<'de>,
1683 {
1684 const FIELDS: &[&str] = &[
1685 "add",
1686 "stop",
1687 "update",
1688 "splits",
1689 "pause",
1690 "resume",
1691 "throttle",
1692 "drop_subscriptions",
1693 "dropSubscriptions",
1694 "connector_props_change",
1695 "connectorPropsChange",
1696 "start_fragment_backfill",
1697 "startFragmentBackfill",
1698 "combined",
1699 ];
1700
1701 #[allow(clippy::enum_variant_names)]
1702 enum GeneratedField {
1703 Add,
1704 Stop,
1705 Update,
1706 Splits,
1707 Pause,
1708 Resume,
1709 Throttle,
1710 DropSubscriptions,
1711 ConnectorPropsChange,
1712 StartFragmentBackfill,
1713 Combined,
1714 }
1715 impl<'de> serde::Deserialize<'de> for GeneratedField {
1716 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1717 where
1718 D: serde::Deserializer<'de>,
1719 {
1720 struct GeneratedVisitor;
1721
1722 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1723 type Value = GeneratedField;
1724
1725 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1726 write!(formatter, "expected one of: {:?}", &FIELDS)
1727 }
1728
1729 #[allow(unused_variables)]
1730 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1731 where
1732 E: serde::de::Error,
1733 {
1734 match value {
1735 "add" => Ok(GeneratedField::Add),
1736 "stop" => Ok(GeneratedField::Stop),
1737 "update" => Ok(GeneratedField::Update),
1738 "splits" => Ok(GeneratedField::Splits),
1739 "pause" => Ok(GeneratedField::Pause),
1740 "resume" => Ok(GeneratedField::Resume),
1741 "throttle" => Ok(GeneratedField::Throttle),
1742 "dropSubscriptions" | "drop_subscriptions" => Ok(GeneratedField::DropSubscriptions),
1743 "connectorPropsChange" | "connector_props_change" => Ok(GeneratedField::ConnectorPropsChange),
1744 "startFragmentBackfill" | "start_fragment_backfill" => Ok(GeneratedField::StartFragmentBackfill),
1745 "combined" => Ok(GeneratedField::Combined),
1746 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1747 }
1748 }
1749 }
1750 deserializer.deserialize_identifier(GeneratedVisitor)
1751 }
1752 }
1753 struct GeneratedVisitor;
1754 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1755 type Value = BarrierMutation;
1756
1757 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1758 formatter.write_str("struct stream_plan.BarrierMutation")
1759 }
1760
1761 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierMutation, V::Error>
1762 where
1763 V: serde::de::MapAccess<'de>,
1764 {
1765 let mut mutation__ = None;
1766 while let Some(k) = map_.next_key()? {
1767 match k {
1768 GeneratedField::Add => {
1769 if mutation__.is_some() {
1770 return Err(serde::de::Error::duplicate_field("add"));
1771 }
1772 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Add)
1773;
1774 }
1775 GeneratedField::Stop => {
1776 if mutation__.is_some() {
1777 return Err(serde::de::Error::duplicate_field("stop"));
1778 }
1779 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Stop)
1780;
1781 }
1782 GeneratedField::Update => {
1783 if mutation__.is_some() {
1784 return Err(serde::de::Error::duplicate_field("update"));
1785 }
1786 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Update)
1787;
1788 }
1789 GeneratedField::Splits => {
1790 if mutation__.is_some() {
1791 return Err(serde::de::Error::duplicate_field("splits"));
1792 }
1793 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Splits)
1794;
1795 }
1796 GeneratedField::Pause => {
1797 if mutation__.is_some() {
1798 return Err(serde::de::Error::duplicate_field("pause"));
1799 }
1800 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Pause)
1801;
1802 }
1803 GeneratedField::Resume => {
1804 if mutation__.is_some() {
1805 return Err(serde::de::Error::duplicate_field("resume"));
1806 }
1807 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Resume)
1808;
1809 }
1810 GeneratedField::Throttle => {
1811 if mutation__.is_some() {
1812 return Err(serde::de::Error::duplicate_field("throttle"));
1813 }
1814 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Throttle)
1815;
1816 }
1817 GeneratedField::DropSubscriptions => {
1818 if mutation__.is_some() {
1819 return Err(serde::de::Error::duplicate_field("dropSubscriptions"));
1820 }
1821 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::DropSubscriptions)
1822;
1823 }
1824 GeneratedField::ConnectorPropsChange => {
1825 if mutation__.is_some() {
1826 return Err(serde::de::Error::duplicate_field("connectorPropsChange"));
1827 }
1828 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ConnectorPropsChange)
1829;
1830 }
1831 GeneratedField::StartFragmentBackfill => {
1832 if mutation__.is_some() {
1833 return Err(serde::de::Error::duplicate_field("startFragmentBackfill"));
1834 }
1835 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::StartFragmentBackfill)
1836;
1837 }
1838 GeneratedField::Combined => {
1839 if mutation__.is_some() {
1840 return Err(serde::de::Error::duplicate_field("combined"));
1841 }
1842 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Combined)
1843;
1844 }
1845 }
1846 }
1847 Ok(BarrierMutation {
1848 mutation: mutation__,
1849 })
1850 }
1851 }
1852 deserializer.deserialize_struct("stream_plan.BarrierMutation", FIELDS, GeneratedVisitor)
1853 }
1854}
1855impl serde::Serialize for BarrierRecvNode {
1856 #[allow(deprecated)]
1857 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1858 where
1859 S: serde::Serializer,
1860 {
1861 use serde::ser::SerializeStruct;
1862 let len = 0;
1863 let struct_ser = serializer.serialize_struct("stream_plan.BarrierRecvNode", len)?;
1864 struct_ser.end()
1865 }
1866}
1867impl<'de> serde::Deserialize<'de> for BarrierRecvNode {
1868 #[allow(deprecated)]
1869 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1870 where
1871 D: serde::Deserializer<'de>,
1872 {
1873 const FIELDS: &[&str] = &[
1874 ];
1875
1876 #[allow(clippy::enum_variant_names)]
1877 enum GeneratedField {
1878 }
1879 impl<'de> serde::Deserialize<'de> for GeneratedField {
1880 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1881 where
1882 D: serde::Deserializer<'de>,
1883 {
1884 struct GeneratedVisitor;
1885
1886 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1887 type Value = GeneratedField;
1888
1889 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1890 write!(formatter, "expected one of: {:?}", &FIELDS)
1891 }
1892
1893 #[allow(unused_variables)]
1894 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1895 where
1896 E: serde::de::Error,
1897 {
1898 Err(serde::de::Error::unknown_field(value, FIELDS))
1899 }
1900 }
1901 deserializer.deserialize_identifier(GeneratedVisitor)
1902 }
1903 }
1904 struct GeneratedVisitor;
1905 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1906 type Value = BarrierRecvNode;
1907
1908 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1909 formatter.write_str("struct stream_plan.BarrierRecvNode")
1910 }
1911
1912 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierRecvNode, V::Error>
1913 where
1914 V: serde::de::MapAccess<'de>,
1915 {
1916 while map_.next_key::<GeneratedField>()?.is_some() {
1917 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1918 }
1919 Ok(BarrierRecvNode {
1920 })
1921 }
1922 }
1923 deserializer.deserialize_struct("stream_plan.BarrierRecvNode", FIELDS, GeneratedVisitor)
1924 }
1925}
1926impl serde::Serialize for BatchPlanNode {
1927 #[allow(deprecated)]
1928 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1929 where
1930 S: serde::Serializer,
1931 {
1932 use serde::ser::SerializeStruct;
1933 let mut len = 0;
1934 if self.table_desc.is_some() {
1935 len += 1;
1936 }
1937 if !self.column_ids.is_empty() {
1938 len += 1;
1939 }
1940 let mut struct_ser = serializer.serialize_struct("stream_plan.BatchPlanNode", len)?;
1941 if let Some(v) = self.table_desc.as_ref() {
1942 struct_ser.serialize_field("tableDesc", v)?;
1943 }
1944 if !self.column_ids.is_empty() {
1945 struct_ser.serialize_field("columnIds", &self.column_ids)?;
1946 }
1947 struct_ser.end()
1948 }
1949}
1950impl<'de> serde::Deserialize<'de> for BatchPlanNode {
1951 #[allow(deprecated)]
1952 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1953 where
1954 D: serde::Deserializer<'de>,
1955 {
1956 const FIELDS: &[&str] = &[
1957 "table_desc",
1958 "tableDesc",
1959 "column_ids",
1960 "columnIds",
1961 ];
1962
1963 #[allow(clippy::enum_variant_names)]
1964 enum GeneratedField {
1965 TableDesc,
1966 ColumnIds,
1967 }
1968 impl<'de> serde::Deserialize<'de> for GeneratedField {
1969 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1970 where
1971 D: serde::Deserializer<'de>,
1972 {
1973 struct GeneratedVisitor;
1974
1975 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1976 type Value = GeneratedField;
1977
1978 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1979 write!(formatter, "expected one of: {:?}", &FIELDS)
1980 }
1981
1982 #[allow(unused_variables)]
1983 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1984 where
1985 E: serde::de::Error,
1986 {
1987 match value {
1988 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
1989 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
1990 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1991 }
1992 }
1993 }
1994 deserializer.deserialize_identifier(GeneratedVisitor)
1995 }
1996 }
1997 struct GeneratedVisitor;
1998 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1999 type Value = BatchPlanNode;
2000
2001 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2002 formatter.write_str("struct stream_plan.BatchPlanNode")
2003 }
2004
2005 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BatchPlanNode, V::Error>
2006 where
2007 V: serde::de::MapAccess<'de>,
2008 {
2009 let mut table_desc__ = None;
2010 let mut column_ids__ = None;
2011 while let Some(k) = map_.next_key()? {
2012 match k {
2013 GeneratedField::TableDesc => {
2014 if table_desc__.is_some() {
2015 return Err(serde::de::Error::duplicate_field("tableDesc"));
2016 }
2017 table_desc__ = map_.next_value()?;
2018 }
2019 GeneratedField::ColumnIds => {
2020 if column_ids__.is_some() {
2021 return Err(serde::de::Error::duplicate_field("columnIds"));
2022 }
2023 column_ids__ =
2024 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2025 .into_iter().map(|x| x.0).collect())
2026 ;
2027 }
2028 }
2029 }
2030 Ok(BatchPlanNode {
2031 table_desc: table_desc__,
2032 column_ids: column_ids__.unwrap_or_default(),
2033 })
2034 }
2035 }
2036 deserializer.deserialize_struct("stream_plan.BatchPlanNode", FIELDS, GeneratedVisitor)
2037 }
2038}
2039impl serde::Serialize for CdcFilterNode {
2040 #[allow(deprecated)]
2041 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2042 where
2043 S: serde::Serializer,
2044 {
2045 use serde::ser::SerializeStruct;
2046 let mut len = 0;
2047 if self.search_condition.is_some() {
2048 len += 1;
2049 }
2050 if self.upstream_source_id != 0 {
2051 len += 1;
2052 }
2053 let mut struct_ser = serializer.serialize_struct("stream_plan.CdcFilterNode", len)?;
2054 if let Some(v) = self.search_condition.as_ref() {
2055 struct_ser.serialize_field("searchCondition", v)?;
2056 }
2057 if self.upstream_source_id != 0 {
2058 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
2059 }
2060 struct_ser.end()
2061 }
2062}
2063impl<'de> serde::Deserialize<'de> for CdcFilterNode {
2064 #[allow(deprecated)]
2065 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2066 where
2067 D: serde::Deserializer<'de>,
2068 {
2069 const FIELDS: &[&str] = &[
2070 "search_condition",
2071 "searchCondition",
2072 "upstream_source_id",
2073 "upstreamSourceId",
2074 ];
2075
2076 #[allow(clippy::enum_variant_names)]
2077 enum GeneratedField {
2078 SearchCondition,
2079 UpstreamSourceId,
2080 }
2081 impl<'de> serde::Deserialize<'de> for GeneratedField {
2082 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2083 where
2084 D: serde::Deserializer<'de>,
2085 {
2086 struct GeneratedVisitor;
2087
2088 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2089 type Value = GeneratedField;
2090
2091 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2092 write!(formatter, "expected one of: {:?}", &FIELDS)
2093 }
2094
2095 #[allow(unused_variables)]
2096 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2097 where
2098 E: serde::de::Error,
2099 {
2100 match value {
2101 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
2102 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
2103 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2104 }
2105 }
2106 }
2107 deserializer.deserialize_identifier(GeneratedVisitor)
2108 }
2109 }
2110 struct GeneratedVisitor;
2111 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2112 type Value = CdcFilterNode;
2113
2114 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2115 formatter.write_str("struct stream_plan.CdcFilterNode")
2116 }
2117
2118 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcFilterNode, V::Error>
2119 where
2120 V: serde::de::MapAccess<'de>,
2121 {
2122 let mut search_condition__ = None;
2123 let mut upstream_source_id__ = None;
2124 while let Some(k) = map_.next_key()? {
2125 match k {
2126 GeneratedField::SearchCondition => {
2127 if search_condition__.is_some() {
2128 return Err(serde::de::Error::duplicate_field("searchCondition"));
2129 }
2130 search_condition__ = map_.next_value()?;
2131 }
2132 GeneratedField::UpstreamSourceId => {
2133 if upstream_source_id__.is_some() {
2134 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
2135 }
2136 upstream_source_id__ =
2137 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2138 ;
2139 }
2140 }
2141 }
2142 Ok(CdcFilterNode {
2143 search_condition: search_condition__,
2144 upstream_source_id: upstream_source_id__.unwrap_or_default(),
2145 })
2146 }
2147 }
2148 deserializer.deserialize_struct("stream_plan.CdcFilterNode", FIELDS, GeneratedVisitor)
2149 }
2150}
2151impl serde::Serialize for ChangeLogNode {
2152 #[allow(deprecated)]
2153 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2154 where
2155 S: serde::Serializer,
2156 {
2157 use serde::ser::SerializeStruct;
2158 let mut len = 0;
2159 if self.need_op {
2160 len += 1;
2161 }
2162 let mut struct_ser = serializer.serialize_struct("stream_plan.ChangeLogNode", len)?;
2163 if self.need_op {
2164 struct_ser.serialize_field("needOp", &self.need_op)?;
2165 }
2166 struct_ser.end()
2167 }
2168}
2169impl<'de> serde::Deserialize<'de> for ChangeLogNode {
2170 #[allow(deprecated)]
2171 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2172 where
2173 D: serde::Deserializer<'de>,
2174 {
2175 const FIELDS: &[&str] = &[
2176 "need_op",
2177 "needOp",
2178 ];
2179
2180 #[allow(clippy::enum_variant_names)]
2181 enum GeneratedField {
2182 NeedOp,
2183 }
2184 impl<'de> serde::Deserialize<'de> for GeneratedField {
2185 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2186 where
2187 D: serde::Deserializer<'de>,
2188 {
2189 struct GeneratedVisitor;
2190
2191 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2192 type Value = GeneratedField;
2193
2194 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2195 write!(formatter, "expected one of: {:?}", &FIELDS)
2196 }
2197
2198 #[allow(unused_variables)]
2199 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2200 where
2201 E: serde::de::Error,
2202 {
2203 match value {
2204 "needOp" | "need_op" => Ok(GeneratedField::NeedOp),
2205 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2206 }
2207 }
2208 }
2209 deserializer.deserialize_identifier(GeneratedVisitor)
2210 }
2211 }
2212 struct GeneratedVisitor;
2213 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2214 type Value = ChangeLogNode;
2215
2216 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2217 formatter.write_str("struct stream_plan.ChangeLogNode")
2218 }
2219
2220 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ChangeLogNode, V::Error>
2221 where
2222 V: serde::de::MapAccess<'de>,
2223 {
2224 let mut need_op__ = None;
2225 while let Some(k) = map_.next_key()? {
2226 match k {
2227 GeneratedField::NeedOp => {
2228 if need_op__.is_some() {
2229 return Err(serde::de::Error::duplicate_field("needOp"));
2230 }
2231 need_op__ = Some(map_.next_value()?);
2232 }
2233 }
2234 }
2235 Ok(ChangeLogNode {
2236 need_op: need_op__.unwrap_or_default(),
2237 })
2238 }
2239 }
2240 deserializer.deserialize_struct("stream_plan.ChangeLogNode", FIELDS, GeneratedVisitor)
2241 }
2242}
2243impl serde::Serialize for CombinedMutation {
2244 #[allow(deprecated)]
2245 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2246 where
2247 S: serde::Serializer,
2248 {
2249 use serde::ser::SerializeStruct;
2250 let mut len = 0;
2251 if !self.mutations.is_empty() {
2252 len += 1;
2253 }
2254 let mut struct_ser = serializer.serialize_struct("stream_plan.CombinedMutation", len)?;
2255 if !self.mutations.is_empty() {
2256 struct_ser.serialize_field("mutations", &self.mutations)?;
2257 }
2258 struct_ser.end()
2259 }
2260}
2261impl<'de> serde::Deserialize<'de> for CombinedMutation {
2262 #[allow(deprecated)]
2263 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2264 where
2265 D: serde::Deserializer<'de>,
2266 {
2267 const FIELDS: &[&str] = &[
2268 "mutations",
2269 ];
2270
2271 #[allow(clippy::enum_variant_names)]
2272 enum GeneratedField {
2273 Mutations,
2274 }
2275 impl<'de> serde::Deserialize<'de> for GeneratedField {
2276 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2277 where
2278 D: serde::Deserializer<'de>,
2279 {
2280 struct GeneratedVisitor;
2281
2282 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2283 type Value = GeneratedField;
2284
2285 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2286 write!(formatter, "expected one of: {:?}", &FIELDS)
2287 }
2288
2289 #[allow(unused_variables)]
2290 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2291 where
2292 E: serde::de::Error,
2293 {
2294 match value {
2295 "mutations" => Ok(GeneratedField::Mutations),
2296 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2297 }
2298 }
2299 }
2300 deserializer.deserialize_identifier(GeneratedVisitor)
2301 }
2302 }
2303 struct GeneratedVisitor;
2304 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2305 type Value = CombinedMutation;
2306
2307 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2308 formatter.write_str("struct stream_plan.CombinedMutation")
2309 }
2310
2311 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CombinedMutation, V::Error>
2312 where
2313 V: serde::de::MapAccess<'de>,
2314 {
2315 let mut mutations__ = None;
2316 while let Some(k) = map_.next_key()? {
2317 match k {
2318 GeneratedField::Mutations => {
2319 if mutations__.is_some() {
2320 return Err(serde::de::Error::duplicate_field("mutations"));
2321 }
2322 mutations__ = Some(map_.next_value()?);
2323 }
2324 }
2325 }
2326 Ok(CombinedMutation {
2327 mutations: mutations__.unwrap_or_default(),
2328 })
2329 }
2330 }
2331 deserializer.deserialize_struct("stream_plan.CombinedMutation", FIELDS, GeneratedVisitor)
2332 }
2333}
2334impl serde::Serialize for ConnectorPropsChangeMutation {
2335 #[allow(deprecated)]
2336 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2337 where
2338 S: serde::Serializer,
2339 {
2340 use serde::ser::SerializeStruct;
2341 let mut len = 0;
2342 if !self.connector_props_infos.is_empty() {
2343 len += 1;
2344 }
2345 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation", len)?;
2346 if !self.connector_props_infos.is_empty() {
2347 struct_ser.serialize_field("connectorPropsInfos", &self.connector_props_infos)?;
2348 }
2349 struct_ser.end()
2350 }
2351}
2352impl<'de> serde::Deserialize<'de> for ConnectorPropsChangeMutation {
2353 #[allow(deprecated)]
2354 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2355 where
2356 D: serde::Deserializer<'de>,
2357 {
2358 const FIELDS: &[&str] = &[
2359 "connector_props_infos",
2360 "connectorPropsInfos",
2361 ];
2362
2363 #[allow(clippy::enum_variant_names)]
2364 enum GeneratedField {
2365 ConnectorPropsInfos,
2366 }
2367 impl<'de> serde::Deserialize<'de> for GeneratedField {
2368 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2369 where
2370 D: serde::Deserializer<'de>,
2371 {
2372 struct GeneratedVisitor;
2373
2374 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2375 type Value = GeneratedField;
2376
2377 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2378 write!(formatter, "expected one of: {:?}", &FIELDS)
2379 }
2380
2381 #[allow(unused_variables)]
2382 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2383 where
2384 E: serde::de::Error,
2385 {
2386 match value {
2387 "connectorPropsInfos" | "connector_props_infos" => Ok(GeneratedField::ConnectorPropsInfos),
2388 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2389 }
2390 }
2391 }
2392 deserializer.deserialize_identifier(GeneratedVisitor)
2393 }
2394 }
2395 struct GeneratedVisitor;
2396 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2397 type Value = ConnectorPropsChangeMutation;
2398
2399 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2400 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation")
2401 }
2402
2403 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectorPropsChangeMutation, V::Error>
2404 where
2405 V: serde::de::MapAccess<'de>,
2406 {
2407 let mut connector_props_infos__ = None;
2408 while let Some(k) = map_.next_key()? {
2409 match k {
2410 GeneratedField::ConnectorPropsInfos => {
2411 if connector_props_infos__.is_some() {
2412 return Err(serde::de::Error::duplicate_field("connectorPropsInfos"));
2413 }
2414 connector_props_infos__ = Some(
2415 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
2416 .into_iter().map(|(k,v)| (k.0, v)).collect()
2417 );
2418 }
2419 }
2420 }
2421 Ok(ConnectorPropsChangeMutation {
2422 connector_props_infos: connector_props_infos__.unwrap_or_default(),
2423 })
2424 }
2425 }
2426 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation", FIELDS, GeneratedVisitor)
2427 }
2428}
2429impl serde::Serialize for connector_props_change_mutation::ConnectorPropsInfo {
2430 #[allow(deprecated)]
2431 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2432 where
2433 S: serde::Serializer,
2434 {
2435 use serde::ser::SerializeStruct;
2436 let mut len = 0;
2437 if !self.connector_props_info.is_empty() {
2438 len += 1;
2439 }
2440 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", len)?;
2441 if !self.connector_props_info.is_empty() {
2442 struct_ser.serialize_field("connectorPropsInfo", &self.connector_props_info)?;
2443 }
2444 struct_ser.end()
2445 }
2446}
2447impl<'de> serde::Deserialize<'de> for connector_props_change_mutation::ConnectorPropsInfo {
2448 #[allow(deprecated)]
2449 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2450 where
2451 D: serde::Deserializer<'de>,
2452 {
2453 const FIELDS: &[&str] = &[
2454 "connector_props_info",
2455 "connectorPropsInfo",
2456 ];
2457
2458 #[allow(clippy::enum_variant_names)]
2459 enum GeneratedField {
2460 ConnectorPropsInfo,
2461 }
2462 impl<'de> serde::Deserialize<'de> for GeneratedField {
2463 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2464 where
2465 D: serde::Deserializer<'de>,
2466 {
2467 struct GeneratedVisitor;
2468
2469 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2470 type Value = GeneratedField;
2471
2472 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2473 write!(formatter, "expected one of: {:?}", &FIELDS)
2474 }
2475
2476 #[allow(unused_variables)]
2477 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2478 where
2479 E: serde::de::Error,
2480 {
2481 match value {
2482 "connectorPropsInfo" | "connector_props_info" => Ok(GeneratedField::ConnectorPropsInfo),
2483 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2484 }
2485 }
2486 }
2487 deserializer.deserialize_identifier(GeneratedVisitor)
2488 }
2489 }
2490 struct GeneratedVisitor;
2491 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2492 type Value = connector_props_change_mutation::ConnectorPropsInfo;
2493
2494 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2495 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo")
2496 }
2497
2498 fn visit_map<V>(self, mut map_: V) -> std::result::Result<connector_props_change_mutation::ConnectorPropsInfo, V::Error>
2499 where
2500 V: serde::de::MapAccess<'de>,
2501 {
2502 let mut connector_props_info__ = None;
2503 while let Some(k) = map_.next_key()? {
2504 match k {
2505 GeneratedField::ConnectorPropsInfo => {
2506 if connector_props_info__.is_some() {
2507 return Err(serde::de::Error::duplicate_field("connectorPropsInfo"));
2508 }
2509 connector_props_info__ = Some(
2510 map_.next_value::<std::collections::HashMap<_, _>>()?
2511 );
2512 }
2513 }
2514 }
2515 Ok(connector_props_change_mutation::ConnectorPropsInfo {
2516 connector_props_info: connector_props_info__.unwrap_or_default(),
2517 })
2518 }
2519 }
2520 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", FIELDS, GeneratedVisitor)
2521 }
2522}
2523impl serde::Serialize for DedupNode {
2524 #[allow(deprecated)]
2525 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2526 where
2527 S: serde::Serializer,
2528 {
2529 use serde::ser::SerializeStruct;
2530 let mut len = 0;
2531 if self.state_table.is_some() {
2532 len += 1;
2533 }
2534 if !self.dedup_column_indices.is_empty() {
2535 len += 1;
2536 }
2537 let mut struct_ser = serializer.serialize_struct("stream_plan.DedupNode", len)?;
2538 if let Some(v) = self.state_table.as_ref() {
2539 struct_ser.serialize_field("stateTable", v)?;
2540 }
2541 if !self.dedup_column_indices.is_empty() {
2542 struct_ser.serialize_field("dedupColumnIndices", &self.dedup_column_indices)?;
2543 }
2544 struct_ser.end()
2545 }
2546}
2547impl<'de> serde::Deserialize<'de> for DedupNode {
2548 #[allow(deprecated)]
2549 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2550 where
2551 D: serde::Deserializer<'de>,
2552 {
2553 const FIELDS: &[&str] = &[
2554 "state_table",
2555 "stateTable",
2556 "dedup_column_indices",
2557 "dedupColumnIndices",
2558 ];
2559
2560 #[allow(clippy::enum_variant_names)]
2561 enum GeneratedField {
2562 StateTable,
2563 DedupColumnIndices,
2564 }
2565 impl<'de> serde::Deserialize<'de> for GeneratedField {
2566 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2567 where
2568 D: serde::Deserializer<'de>,
2569 {
2570 struct GeneratedVisitor;
2571
2572 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2573 type Value = GeneratedField;
2574
2575 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2576 write!(formatter, "expected one of: {:?}", &FIELDS)
2577 }
2578
2579 #[allow(unused_variables)]
2580 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2581 where
2582 E: serde::de::Error,
2583 {
2584 match value {
2585 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
2586 "dedupColumnIndices" | "dedup_column_indices" => Ok(GeneratedField::DedupColumnIndices),
2587 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2588 }
2589 }
2590 }
2591 deserializer.deserialize_identifier(GeneratedVisitor)
2592 }
2593 }
2594 struct GeneratedVisitor;
2595 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2596 type Value = DedupNode;
2597
2598 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2599 formatter.write_str("struct stream_plan.DedupNode")
2600 }
2601
2602 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DedupNode, V::Error>
2603 where
2604 V: serde::de::MapAccess<'de>,
2605 {
2606 let mut state_table__ = None;
2607 let mut dedup_column_indices__ = None;
2608 while let Some(k) = map_.next_key()? {
2609 match k {
2610 GeneratedField::StateTable => {
2611 if state_table__.is_some() {
2612 return Err(serde::de::Error::duplicate_field("stateTable"));
2613 }
2614 state_table__ = map_.next_value()?;
2615 }
2616 GeneratedField::DedupColumnIndices => {
2617 if dedup_column_indices__.is_some() {
2618 return Err(serde::de::Error::duplicate_field("dedupColumnIndices"));
2619 }
2620 dedup_column_indices__ =
2621 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2622 .into_iter().map(|x| x.0).collect())
2623 ;
2624 }
2625 }
2626 }
2627 Ok(DedupNode {
2628 state_table: state_table__,
2629 dedup_column_indices: dedup_column_indices__.unwrap_or_default(),
2630 })
2631 }
2632 }
2633 deserializer.deserialize_struct("stream_plan.DedupNode", FIELDS, GeneratedVisitor)
2634 }
2635}
2636impl serde::Serialize for DeltaExpression {
2637 #[allow(deprecated)]
2638 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2639 where
2640 S: serde::Serializer,
2641 {
2642 use serde::ser::SerializeStruct;
2643 let mut len = 0;
2644 if self.delta_type != 0 {
2645 len += 1;
2646 }
2647 if self.delta.is_some() {
2648 len += 1;
2649 }
2650 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaExpression", len)?;
2651 if self.delta_type != 0 {
2652 let v = super::expr::expr_node::Type::try_from(self.delta_type)
2653 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.delta_type)))?;
2654 struct_ser.serialize_field("deltaType", &v)?;
2655 }
2656 if let Some(v) = self.delta.as_ref() {
2657 struct_ser.serialize_field("delta", v)?;
2658 }
2659 struct_ser.end()
2660 }
2661}
2662impl<'de> serde::Deserialize<'de> for DeltaExpression {
2663 #[allow(deprecated)]
2664 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2665 where
2666 D: serde::Deserializer<'de>,
2667 {
2668 const FIELDS: &[&str] = &[
2669 "delta_type",
2670 "deltaType",
2671 "delta",
2672 ];
2673
2674 #[allow(clippy::enum_variant_names)]
2675 enum GeneratedField {
2676 DeltaType,
2677 Delta,
2678 }
2679 impl<'de> serde::Deserialize<'de> for GeneratedField {
2680 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2681 where
2682 D: serde::Deserializer<'de>,
2683 {
2684 struct GeneratedVisitor;
2685
2686 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2687 type Value = GeneratedField;
2688
2689 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2690 write!(formatter, "expected one of: {:?}", &FIELDS)
2691 }
2692
2693 #[allow(unused_variables)]
2694 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2695 where
2696 E: serde::de::Error,
2697 {
2698 match value {
2699 "deltaType" | "delta_type" => Ok(GeneratedField::DeltaType),
2700 "delta" => Ok(GeneratedField::Delta),
2701 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2702 }
2703 }
2704 }
2705 deserializer.deserialize_identifier(GeneratedVisitor)
2706 }
2707 }
2708 struct GeneratedVisitor;
2709 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2710 type Value = DeltaExpression;
2711
2712 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2713 formatter.write_str("struct stream_plan.DeltaExpression")
2714 }
2715
2716 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaExpression, V::Error>
2717 where
2718 V: serde::de::MapAccess<'de>,
2719 {
2720 let mut delta_type__ = None;
2721 let mut delta__ = None;
2722 while let Some(k) = map_.next_key()? {
2723 match k {
2724 GeneratedField::DeltaType => {
2725 if delta_type__.is_some() {
2726 return Err(serde::de::Error::duplicate_field("deltaType"));
2727 }
2728 delta_type__ = Some(map_.next_value::<super::expr::expr_node::Type>()? as i32);
2729 }
2730 GeneratedField::Delta => {
2731 if delta__.is_some() {
2732 return Err(serde::de::Error::duplicate_field("delta"));
2733 }
2734 delta__ = map_.next_value()?;
2735 }
2736 }
2737 }
2738 Ok(DeltaExpression {
2739 delta_type: delta_type__.unwrap_or_default(),
2740 delta: delta__,
2741 })
2742 }
2743 }
2744 deserializer.deserialize_struct("stream_plan.DeltaExpression", FIELDS, GeneratedVisitor)
2745 }
2746}
2747impl serde::Serialize for DeltaIndexJoinNode {
2748 #[allow(deprecated)]
2749 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2750 where
2751 S: serde::Serializer,
2752 {
2753 use serde::ser::SerializeStruct;
2754 let mut len = 0;
2755 if self.join_type != 0 {
2756 len += 1;
2757 }
2758 if !self.left_key.is_empty() {
2759 len += 1;
2760 }
2761 if !self.right_key.is_empty() {
2762 len += 1;
2763 }
2764 if self.condition.is_some() {
2765 len += 1;
2766 }
2767 if self.left_table_id != 0 {
2768 len += 1;
2769 }
2770 if self.right_table_id != 0 {
2771 len += 1;
2772 }
2773 if self.left_info.is_some() {
2774 len += 1;
2775 }
2776 if self.right_info.is_some() {
2777 len += 1;
2778 }
2779 if !self.output_indices.is_empty() {
2780 len += 1;
2781 }
2782 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaIndexJoinNode", len)?;
2783 if self.join_type != 0 {
2784 let v = super::plan_common::JoinType::try_from(self.join_type)
2785 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
2786 struct_ser.serialize_field("joinType", &v)?;
2787 }
2788 if !self.left_key.is_empty() {
2789 struct_ser.serialize_field("leftKey", &self.left_key)?;
2790 }
2791 if !self.right_key.is_empty() {
2792 struct_ser.serialize_field("rightKey", &self.right_key)?;
2793 }
2794 if let Some(v) = self.condition.as_ref() {
2795 struct_ser.serialize_field("condition", v)?;
2796 }
2797 if self.left_table_id != 0 {
2798 struct_ser.serialize_field("leftTableId", &self.left_table_id)?;
2799 }
2800 if self.right_table_id != 0 {
2801 struct_ser.serialize_field("rightTableId", &self.right_table_id)?;
2802 }
2803 if let Some(v) = self.left_info.as_ref() {
2804 struct_ser.serialize_field("leftInfo", v)?;
2805 }
2806 if let Some(v) = self.right_info.as_ref() {
2807 struct_ser.serialize_field("rightInfo", v)?;
2808 }
2809 if !self.output_indices.is_empty() {
2810 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
2811 }
2812 struct_ser.end()
2813 }
2814}
2815impl<'de> serde::Deserialize<'de> for DeltaIndexJoinNode {
2816 #[allow(deprecated)]
2817 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2818 where
2819 D: serde::Deserializer<'de>,
2820 {
2821 const FIELDS: &[&str] = &[
2822 "join_type",
2823 "joinType",
2824 "left_key",
2825 "leftKey",
2826 "right_key",
2827 "rightKey",
2828 "condition",
2829 "left_table_id",
2830 "leftTableId",
2831 "right_table_id",
2832 "rightTableId",
2833 "left_info",
2834 "leftInfo",
2835 "right_info",
2836 "rightInfo",
2837 "output_indices",
2838 "outputIndices",
2839 ];
2840
2841 #[allow(clippy::enum_variant_names)]
2842 enum GeneratedField {
2843 JoinType,
2844 LeftKey,
2845 RightKey,
2846 Condition,
2847 LeftTableId,
2848 RightTableId,
2849 LeftInfo,
2850 RightInfo,
2851 OutputIndices,
2852 }
2853 impl<'de> serde::Deserialize<'de> for GeneratedField {
2854 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2855 where
2856 D: serde::Deserializer<'de>,
2857 {
2858 struct GeneratedVisitor;
2859
2860 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2861 type Value = GeneratedField;
2862
2863 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2864 write!(formatter, "expected one of: {:?}", &FIELDS)
2865 }
2866
2867 #[allow(unused_variables)]
2868 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2869 where
2870 E: serde::de::Error,
2871 {
2872 match value {
2873 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
2874 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
2875 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
2876 "condition" => Ok(GeneratedField::Condition),
2877 "leftTableId" | "left_table_id" => Ok(GeneratedField::LeftTableId),
2878 "rightTableId" | "right_table_id" => Ok(GeneratedField::RightTableId),
2879 "leftInfo" | "left_info" => Ok(GeneratedField::LeftInfo),
2880 "rightInfo" | "right_info" => Ok(GeneratedField::RightInfo),
2881 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
2882 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2883 }
2884 }
2885 }
2886 deserializer.deserialize_identifier(GeneratedVisitor)
2887 }
2888 }
2889 struct GeneratedVisitor;
2890 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2891 type Value = DeltaIndexJoinNode;
2892
2893 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2894 formatter.write_str("struct stream_plan.DeltaIndexJoinNode")
2895 }
2896
2897 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaIndexJoinNode, V::Error>
2898 where
2899 V: serde::de::MapAccess<'de>,
2900 {
2901 let mut join_type__ = None;
2902 let mut left_key__ = None;
2903 let mut right_key__ = None;
2904 let mut condition__ = None;
2905 let mut left_table_id__ = None;
2906 let mut right_table_id__ = None;
2907 let mut left_info__ = None;
2908 let mut right_info__ = None;
2909 let mut output_indices__ = None;
2910 while let Some(k) = map_.next_key()? {
2911 match k {
2912 GeneratedField::JoinType => {
2913 if join_type__.is_some() {
2914 return Err(serde::de::Error::duplicate_field("joinType"));
2915 }
2916 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
2917 }
2918 GeneratedField::LeftKey => {
2919 if left_key__.is_some() {
2920 return Err(serde::de::Error::duplicate_field("leftKey"));
2921 }
2922 left_key__ =
2923 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2924 .into_iter().map(|x| x.0).collect())
2925 ;
2926 }
2927 GeneratedField::RightKey => {
2928 if right_key__.is_some() {
2929 return Err(serde::de::Error::duplicate_field("rightKey"));
2930 }
2931 right_key__ =
2932 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2933 .into_iter().map(|x| x.0).collect())
2934 ;
2935 }
2936 GeneratedField::Condition => {
2937 if condition__.is_some() {
2938 return Err(serde::de::Error::duplicate_field("condition"));
2939 }
2940 condition__ = map_.next_value()?;
2941 }
2942 GeneratedField::LeftTableId => {
2943 if left_table_id__.is_some() {
2944 return Err(serde::de::Error::duplicate_field("leftTableId"));
2945 }
2946 left_table_id__ =
2947 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2948 ;
2949 }
2950 GeneratedField::RightTableId => {
2951 if right_table_id__.is_some() {
2952 return Err(serde::de::Error::duplicate_field("rightTableId"));
2953 }
2954 right_table_id__ =
2955 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2956 ;
2957 }
2958 GeneratedField::LeftInfo => {
2959 if left_info__.is_some() {
2960 return Err(serde::de::Error::duplicate_field("leftInfo"));
2961 }
2962 left_info__ = map_.next_value()?;
2963 }
2964 GeneratedField::RightInfo => {
2965 if right_info__.is_some() {
2966 return Err(serde::de::Error::duplicate_field("rightInfo"));
2967 }
2968 right_info__ = map_.next_value()?;
2969 }
2970 GeneratedField::OutputIndices => {
2971 if output_indices__.is_some() {
2972 return Err(serde::de::Error::duplicate_field("outputIndices"));
2973 }
2974 output_indices__ =
2975 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2976 .into_iter().map(|x| x.0).collect())
2977 ;
2978 }
2979 }
2980 }
2981 Ok(DeltaIndexJoinNode {
2982 join_type: join_type__.unwrap_or_default(),
2983 left_key: left_key__.unwrap_or_default(),
2984 right_key: right_key__.unwrap_or_default(),
2985 condition: condition__,
2986 left_table_id: left_table_id__.unwrap_or_default(),
2987 right_table_id: right_table_id__.unwrap_or_default(),
2988 left_info: left_info__,
2989 right_info: right_info__,
2990 output_indices: output_indices__.unwrap_or_default(),
2991 })
2992 }
2993 }
2994 deserializer.deserialize_struct("stream_plan.DeltaIndexJoinNode", FIELDS, GeneratedVisitor)
2995 }
2996}
2997impl serde::Serialize for DispatchOutputMapping {
2998 #[allow(deprecated)]
2999 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3000 where
3001 S: serde::Serializer,
3002 {
3003 use serde::ser::SerializeStruct;
3004 let mut len = 0;
3005 if !self.indices.is_empty() {
3006 len += 1;
3007 }
3008 if !self.types.is_empty() {
3009 len += 1;
3010 }
3011 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping", len)?;
3012 if !self.indices.is_empty() {
3013 struct_ser.serialize_field("indices", &self.indices)?;
3014 }
3015 if !self.types.is_empty() {
3016 struct_ser.serialize_field("types", &self.types)?;
3017 }
3018 struct_ser.end()
3019 }
3020}
3021impl<'de> serde::Deserialize<'de> for DispatchOutputMapping {
3022 #[allow(deprecated)]
3023 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3024 where
3025 D: serde::Deserializer<'de>,
3026 {
3027 const FIELDS: &[&str] = &[
3028 "indices",
3029 "types",
3030 ];
3031
3032 #[allow(clippy::enum_variant_names)]
3033 enum GeneratedField {
3034 Indices,
3035 Types,
3036 }
3037 impl<'de> serde::Deserialize<'de> for GeneratedField {
3038 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3039 where
3040 D: serde::Deserializer<'de>,
3041 {
3042 struct GeneratedVisitor;
3043
3044 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3045 type Value = GeneratedField;
3046
3047 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3048 write!(formatter, "expected one of: {:?}", &FIELDS)
3049 }
3050
3051 #[allow(unused_variables)]
3052 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3053 where
3054 E: serde::de::Error,
3055 {
3056 match value {
3057 "indices" => Ok(GeneratedField::Indices),
3058 "types" => Ok(GeneratedField::Types),
3059 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3060 }
3061 }
3062 }
3063 deserializer.deserialize_identifier(GeneratedVisitor)
3064 }
3065 }
3066 struct GeneratedVisitor;
3067 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3068 type Value = DispatchOutputMapping;
3069
3070 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3071 formatter.write_str("struct stream_plan.DispatchOutputMapping")
3072 }
3073
3074 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchOutputMapping, V::Error>
3075 where
3076 V: serde::de::MapAccess<'de>,
3077 {
3078 let mut indices__ = None;
3079 let mut types__ = None;
3080 while let Some(k) = map_.next_key()? {
3081 match k {
3082 GeneratedField::Indices => {
3083 if indices__.is_some() {
3084 return Err(serde::de::Error::duplicate_field("indices"));
3085 }
3086 indices__ =
3087 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3088 .into_iter().map(|x| x.0).collect())
3089 ;
3090 }
3091 GeneratedField::Types => {
3092 if types__.is_some() {
3093 return Err(serde::de::Error::duplicate_field("types"));
3094 }
3095 types__ = Some(map_.next_value()?);
3096 }
3097 }
3098 }
3099 Ok(DispatchOutputMapping {
3100 indices: indices__.unwrap_or_default(),
3101 types: types__.unwrap_or_default(),
3102 })
3103 }
3104 }
3105 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping", FIELDS, GeneratedVisitor)
3106 }
3107}
3108impl serde::Serialize for dispatch_output_mapping::TypePair {
3109 #[allow(deprecated)]
3110 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3111 where
3112 S: serde::Serializer,
3113 {
3114 use serde::ser::SerializeStruct;
3115 let mut len = 0;
3116 if self.upstream.is_some() {
3117 len += 1;
3118 }
3119 if self.downstream.is_some() {
3120 len += 1;
3121 }
3122 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping.TypePair", len)?;
3123 if let Some(v) = self.upstream.as_ref() {
3124 struct_ser.serialize_field("upstream", v)?;
3125 }
3126 if let Some(v) = self.downstream.as_ref() {
3127 struct_ser.serialize_field("downstream", v)?;
3128 }
3129 struct_ser.end()
3130 }
3131}
3132impl<'de> serde::Deserialize<'de> for dispatch_output_mapping::TypePair {
3133 #[allow(deprecated)]
3134 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3135 where
3136 D: serde::Deserializer<'de>,
3137 {
3138 const FIELDS: &[&str] = &[
3139 "upstream",
3140 "downstream",
3141 ];
3142
3143 #[allow(clippy::enum_variant_names)]
3144 enum GeneratedField {
3145 Upstream,
3146 Downstream,
3147 }
3148 impl<'de> serde::Deserialize<'de> for GeneratedField {
3149 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3150 where
3151 D: serde::Deserializer<'de>,
3152 {
3153 struct GeneratedVisitor;
3154
3155 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3156 type Value = GeneratedField;
3157
3158 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3159 write!(formatter, "expected one of: {:?}", &FIELDS)
3160 }
3161
3162 #[allow(unused_variables)]
3163 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3164 where
3165 E: serde::de::Error,
3166 {
3167 match value {
3168 "upstream" => Ok(GeneratedField::Upstream),
3169 "downstream" => Ok(GeneratedField::Downstream),
3170 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3171 }
3172 }
3173 }
3174 deserializer.deserialize_identifier(GeneratedVisitor)
3175 }
3176 }
3177 struct GeneratedVisitor;
3178 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3179 type Value = dispatch_output_mapping::TypePair;
3180
3181 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3182 formatter.write_str("struct stream_plan.DispatchOutputMapping.TypePair")
3183 }
3184
3185 fn visit_map<V>(self, mut map_: V) -> std::result::Result<dispatch_output_mapping::TypePair, V::Error>
3186 where
3187 V: serde::de::MapAccess<'de>,
3188 {
3189 let mut upstream__ = None;
3190 let mut downstream__ = None;
3191 while let Some(k) = map_.next_key()? {
3192 match k {
3193 GeneratedField::Upstream => {
3194 if upstream__.is_some() {
3195 return Err(serde::de::Error::duplicate_field("upstream"));
3196 }
3197 upstream__ = map_.next_value()?;
3198 }
3199 GeneratedField::Downstream => {
3200 if downstream__.is_some() {
3201 return Err(serde::de::Error::duplicate_field("downstream"));
3202 }
3203 downstream__ = map_.next_value()?;
3204 }
3205 }
3206 }
3207 Ok(dispatch_output_mapping::TypePair {
3208 upstream: upstream__,
3209 downstream: downstream__,
3210 })
3211 }
3212 }
3213 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping.TypePair", FIELDS, GeneratedVisitor)
3214 }
3215}
3216impl serde::Serialize for DispatchStrategy {
3217 #[allow(deprecated)]
3218 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3219 where
3220 S: serde::Serializer,
3221 {
3222 use serde::ser::SerializeStruct;
3223 let mut len = 0;
3224 if self.r#type != 0 {
3225 len += 1;
3226 }
3227 if !self.dist_key_indices.is_empty() {
3228 len += 1;
3229 }
3230 if self.output_mapping.is_some() {
3231 len += 1;
3232 }
3233 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchStrategy", len)?;
3234 if self.r#type != 0 {
3235 let v = DispatcherType::try_from(self.r#type)
3236 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3237 struct_ser.serialize_field("type", &v)?;
3238 }
3239 if !self.dist_key_indices.is_empty() {
3240 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3241 }
3242 if let Some(v) = self.output_mapping.as_ref() {
3243 struct_ser.serialize_field("outputMapping", v)?;
3244 }
3245 struct_ser.end()
3246 }
3247}
3248impl<'de> serde::Deserialize<'de> for DispatchStrategy {
3249 #[allow(deprecated)]
3250 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3251 where
3252 D: serde::Deserializer<'de>,
3253 {
3254 const FIELDS: &[&str] = &[
3255 "type",
3256 "dist_key_indices",
3257 "distKeyIndices",
3258 "output_mapping",
3259 "outputMapping",
3260 ];
3261
3262 #[allow(clippy::enum_variant_names)]
3263 enum GeneratedField {
3264 Type,
3265 DistKeyIndices,
3266 OutputMapping,
3267 }
3268 impl<'de> serde::Deserialize<'de> for GeneratedField {
3269 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3270 where
3271 D: serde::Deserializer<'de>,
3272 {
3273 struct GeneratedVisitor;
3274
3275 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3276 type Value = GeneratedField;
3277
3278 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3279 write!(formatter, "expected one of: {:?}", &FIELDS)
3280 }
3281
3282 #[allow(unused_variables)]
3283 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3284 where
3285 E: serde::de::Error,
3286 {
3287 match value {
3288 "type" => Ok(GeneratedField::Type),
3289 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3290 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3291 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3292 }
3293 }
3294 }
3295 deserializer.deserialize_identifier(GeneratedVisitor)
3296 }
3297 }
3298 struct GeneratedVisitor;
3299 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3300 type Value = DispatchStrategy;
3301
3302 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3303 formatter.write_str("struct stream_plan.DispatchStrategy")
3304 }
3305
3306 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchStrategy, V::Error>
3307 where
3308 V: serde::de::MapAccess<'de>,
3309 {
3310 let mut r#type__ = None;
3311 let mut dist_key_indices__ = None;
3312 let mut output_mapping__ = None;
3313 while let Some(k) = map_.next_key()? {
3314 match k {
3315 GeneratedField::Type => {
3316 if r#type__.is_some() {
3317 return Err(serde::de::Error::duplicate_field("type"));
3318 }
3319 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3320 }
3321 GeneratedField::DistKeyIndices => {
3322 if dist_key_indices__.is_some() {
3323 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3324 }
3325 dist_key_indices__ =
3326 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3327 .into_iter().map(|x| x.0).collect())
3328 ;
3329 }
3330 GeneratedField::OutputMapping => {
3331 if output_mapping__.is_some() {
3332 return Err(serde::de::Error::duplicate_field("outputMapping"));
3333 }
3334 output_mapping__ = map_.next_value()?;
3335 }
3336 }
3337 }
3338 Ok(DispatchStrategy {
3339 r#type: r#type__.unwrap_or_default(),
3340 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3341 output_mapping: output_mapping__,
3342 })
3343 }
3344 }
3345 deserializer.deserialize_struct("stream_plan.DispatchStrategy", FIELDS, GeneratedVisitor)
3346 }
3347}
3348impl serde::Serialize for Dispatcher {
3349 #[allow(deprecated)]
3350 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3351 where
3352 S: serde::Serializer,
3353 {
3354 use serde::ser::SerializeStruct;
3355 let mut len = 0;
3356 if self.r#type != 0 {
3357 len += 1;
3358 }
3359 if !self.dist_key_indices.is_empty() {
3360 len += 1;
3361 }
3362 if self.output_mapping.is_some() {
3363 len += 1;
3364 }
3365 if self.hash_mapping.is_some() {
3366 len += 1;
3367 }
3368 if self.dispatcher_id != 0 {
3369 len += 1;
3370 }
3371 if !self.downstream_actor_id.is_empty() {
3372 len += 1;
3373 }
3374 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatcher", len)?;
3375 if self.r#type != 0 {
3376 let v = DispatcherType::try_from(self.r#type)
3377 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3378 struct_ser.serialize_field("type", &v)?;
3379 }
3380 if !self.dist_key_indices.is_empty() {
3381 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3382 }
3383 if let Some(v) = self.output_mapping.as_ref() {
3384 struct_ser.serialize_field("outputMapping", v)?;
3385 }
3386 if let Some(v) = self.hash_mapping.as_ref() {
3387 struct_ser.serialize_field("hashMapping", v)?;
3388 }
3389 if self.dispatcher_id != 0 {
3390 #[allow(clippy::needless_borrow)]
3391 #[allow(clippy::needless_borrows_for_generic_args)]
3392 struct_ser.serialize_field("dispatcherId", ToString::to_string(&self.dispatcher_id).as_str())?;
3393 }
3394 if !self.downstream_actor_id.is_empty() {
3395 struct_ser.serialize_field("downstreamActorId", &self.downstream_actor_id)?;
3396 }
3397 struct_ser.end()
3398 }
3399}
3400impl<'de> serde::Deserialize<'de> for Dispatcher {
3401 #[allow(deprecated)]
3402 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3403 where
3404 D: serde::Deserializer<'de>,
3405 {
3406 const FIELDS: &[&str] = &[
3407 "type",
3408 "dist_key_indices",
3409 "distKeyIndices",
3410 "output_mapping",
3411 "outputMapping",
3412 "hash_mapping",
3413 "hashMapping",
3414 "dispatcher_id",
3415 "dispatcherId",
3416 "downstream_actor_id",
3417 "downstreamActorId",
3418 ];
3419
3420 #[allow(clippy::enum_variant_names)]
3421 enum GeneratedField {
3422 Type,
3423 DistKeyIndices,
3424 OutputMapping,
3425 HashMapping,
3426 DispatcherId,
3427 DownstreamActorId,
3428 }
3429 impl<'de> serde::Deserialize<'de> for GeneratedField {
3430 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3431 where
3432 D: serde::Deserializer<'de>,
3433 {
3434 struct GeneratedVisitor;
3435
3436 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3437 type Value = GeneratedField;
3438
3439 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3440 write!(formatter, "expected one of: {:?}", &FIELDS)
3441 }
3442
3443 #[allow(unused_variables)]
3444 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3445 where
3446 E: serde::de::Error,
3447 {
3448 match value {
3449 "type" => Ok(GeneratedField::Type),
3450 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3451 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3452 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
3453 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
3454 "downstreamActorId" | "downstream_actor_id" => Ok(GeneratedField::DownstreamActorId),
3455 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3456 }
3457 }
3458 }
3459 deserializer.deserialize_identifier(GeneratedVisitor)
3460 }
3461 }
3462 struct GeneratedVisitor;
3463 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3464 type Value = Dispatcher;
3465
3466 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3467 formatter.write_str("struct stream_plan.Dispatcher")
3468 }
3469
3470 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatcher, V::Error>
3471 where
3472 V: serde::de::MapAccess<'de>,
3473 {
3474 let mut r#type__ = None;
3475 let mut dist_key_indices__ = None;
3476 let mut output_mapping__ = None;
3477 let mut hash_mapping__ = None;
3478 let mut dispatcher_id__ = None;
3479 let mut downstream_actor_id__ = None;
3480 while let Some(k) = map_.next_key()? {
3481 match k {
3482 GeneratedField::Type => {
3483 if r#type__.is_some() {
3484 return Err(serde::de::Error::duplicate_field("type"));
3485 }
3486 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3487 }
3488 GeneratedField::DistKeyIndices => {
3489 if dist_key_indices__.is_some() {
3490 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3491 }
3492 dist_key_indices__ =
3493 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3494 .into_iter().map(|x| x.0).collect())
3495 ;
3496 }
3497 GeneratedField::OutputMapping => {
3498 if output_mapping__.is_some() {
3499 return Err(serde::de::Error::duplicate_field("outputMapping"));
3500 }
3501 output_mapping__ = map_.next_value()?;
3502 }
3503 GeneratedField::HashMapping => {
3504 if hash_mapping__.is_some() {
3505 return Err(serde::de::Error::duplicate_field("hashMapping"));
3506 }
3507 hash_mapping__ = map_.next_value()?;
3508 }
3509 GeneratedField::DispatcherId => {
3510 if dispatcher_id__.is_some() {
3511 return Err(serde::de::Error::duplicate_field("dispatcherId"));
3512 }
3513 dispatcher_id__ =
3514 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3515 ;
3516 }
3517 GeneratedField::DownstreamActorId => {
3518 if downstream_actor_id__.is_some() {
3519 return Err(serde::de::Error::duplicate_field("downstreamActorId"));
3520 }
3521 downstream_actor_id__ =
3522 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3523 .into_iter().map(|x| x.0).collect())
3524 ;
3525 }
3526 }
3527 }
3528 Ok(Dispatcher {
3529 r#type: r#type__.unwrap_or_default(),
3530 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3531 output_mapping: output_mapping__,
3532 hash_mapping: hash_mapping__,
3533 dispatcher_id: dispatcher_id__.unwrap_or_default(),
3534 downstream_actor_id: downstream_actor_id__.unwrap_or_default(),
3535 })
3536 }
3537 }
3538 deserializer.deserialize_struct("stream_plan.Dispatcher", FIELDS, GeneratedVisitor)
3539 }
3540}
3541impl serde::Serialize for DispatcherType {
3542 #[allow(deprecated)]
3543 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3544 where
3545 S: serde::Serializer,
3546 {
3547 let variant = match self {
3548 Self::Unspecified => "DISPATCHER_TYPE_UNSPECIFIED",
3549 Self::Hash => "DISPATCHER_TYPE_HASH",
3550 Self::Broadcast => "DISPATCHER_TYPE_BROADCAST",
3551 Self::Simple => "DISPATCHER_TYPE_SIMPLE",
3552 Self::NoShuffle => "DISPATCHER_TYPE_NO_SHUFFLE",
3553 };
3554 serializer.serialize_str(variant)
3555 }
3556}
3557impl<'de> serde::Deserialize<'de> for DispatcherType {
3558 #[allow(deprecated)]
3559 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3560 where
3561 D: serde::Deserializer<'de>,
3562 {
3563 const FIELDS: &[&str] = &[
3564 "DISPATCHER_TYPE_UNSPECIFIED",
3565 "DISPATCHER_TYPE_HASH",
3566 "DISPATCHER_TYPE_BROADCAST",
3567 "DISPATCHER_TYPE_SIMPLE",
3568 "DISPATCHER_TYPE_NO_SHUFFLE",
3569 ];
3570
3571 struct GeneratedVisitor;
3572
3573 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3574 type Value = DispatcherType;
3575
3576 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3577 write!(formatter, "expected one of: {:?}", &FIELDS)
3578 }
3579
3580 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3581 where
3582 E: serde::de::Error,
3583 {
3584 i32::try_from(v)
3585 .ok()
3586 .and_then(|x| x.try_into().ok())
3587 .ok_or_else(|| {
3588 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3589 })
3590 }
3591
3592 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3593 where
3594 E: serde::de::Error,
3595 {
3596 i32::try_from(v)
3597 .ok()
3598 .and_then(|x| x.try_into().ok())
3599 .ok_or_else(|| {
3600 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3601 })
3602 }
3603
3604 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3605 where
3606 E: serde::de::Error,
3607 {
3608 match value {
3609 "DISPATCHER_TYPE_UNSPECIFIED" => Ok(DispatcherType::Unspecified),
3610 "DISPATCHER_TYPE_HASH" => Ok(DispatcherType::Hash),
3611 "DISPATCHER_TYPE_BROADCAST" => Ok(DispatcherType::Broadcast),
3612 "DISPATCHER_TYPE_SIMPLE" => Ok(DispatcherType::Simple),
3613 "DISPATCHER_TYPE_NO_SHUFFLE" => Ok(DispatcherType::NoShuffle),
3614 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3615 }
3616 }
3617 }
3618 deserializer.deserialize_any(GeneratedVisitor)
3619 }
3620}
3621impl serde::Serialize for Dispatchers {
3622 #[allow(deprecated)]
3623 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3624 where
3625 S: serde::Serializer,
3626 {
3627 use serde::ser::SerializeStruct;
3628 let mut len = 0;
3629 if !self.dispatchers.is_empty() {
3630 len += 1;
3631 }
3632 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatchers", len)?;
3633 if !self.dispatchers.is_empty() {
3634 struct_ser.serialize_field("dispatchers", &self.dispatchers)?;
3635 }
3636 struct_ser.end()
3637 }
3638}
3639impl<'de> serde::Deserialize<'de> for Dispatchers {
3640 #[allow(deprecated)]
3641 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3642 where
3643 D: serde::Deserializer<'de>,
3644 {
3645 const FIELDS: &[&str] = &[
3646 "dispatchers",
3647 ];
3648
3649 #[allow(clippy::enum_variant_names)]
3650 enum GeneratedField {
3651 Dispatchers,
3652 }
3653 impl<'de> serde::Deserialize<'de> for GeneratedField {
3654 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3655 where
3656 D: serde::Deserializer<'de>,
3657 {
3658 struct GeneratedVisitor;
3659
3660 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3661 type Value = GeneratedField;
3662
3663 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3664 write!(formatter, "expected one of: {:?}", &FIELDS)
3665 }
3666
3667 #[allow(unused_variables)]
3668 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3669 where
3670 E: serde::de::Error,
3671 {
3672 match value {
3673 "dispatchers" => Ok(GeneratedField::Dispatchers),
3674 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3675 }
3676 }
3677 }
3678 deserializer.deserialize_identifier(GeneratedVisitor)
3679 }
3680 }
3681 struct GeneratedVisitor;
3682 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3683 type Value = Dispatchers;
3684
3685 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3686 formatter.write_str("struct stream_plan.Dispatchers")
3687 }
3688
3689 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatchers, V::Error>
3690 where
3691 V: serde::de::MapAccess<'de>,
3692 {
3693 let mut dispatchers__ = None;
3694 while let Some(k) = map_.next_key()? {
3695 match k {
3696 GeneratedField::Dispatchers => {
3697 if dispatchers__.is_some() {
3698 return Err(serde::de::Error::duplicate_field("dispatchers"));
3699 }
3700 dispatchers__ = Some(map_.next_value()?);
3701 }
3702 }
3703 }
3704 Ok(Dispatchers {
3705 dispatchers: dispatchers__.unwrap_or_default(),
3706 })
3707 }
3708 }
3709 deserializer.deserialize_struct("stream_plan.Dispatchers", FIELDS, GeneratedVisitor)
3710 }
3711}
3712impl serde::Serialize for DmlNode {
3713 #[allow(deprecated)]
3714 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3715 where
3716 S: serde::Serializer,
3717 {
3718 use serde::ser::SerializeStruct;
3719 let mut len = 0;
3720 if self.table_id != 0 {
3721 len += 1;
3722 }
3723 if self.table_version_id != 0 {
3724 len += 1;
3725 }
3726 if !self.column_descs.is_empty() {
3727 len += 1;
3728 }
3729 if self.rate_limit.is_some() {
3730 len += 1;
3731 }
3732 let mut struct_ser = serializer.serialize_struct("stream_plan.DmlNode", len)?;
3733 if self.table_id != 0 {
3734 struct_ser.serialize_field("tableId", &self.table_id)?;
3735 }
3736 if self.table_version_id != 0 {
3737 #[allow(clippy::needless_borrow)]
3738 #[allow(clippy::needless_borrows_for_generic_args)]
3739 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
3740 }
3741 if !self.column_descs.is_empty() {
3742 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
3743 }
3744 if let Some(v) = self.rate_limit.as_ref() {
3745 struct_ser.serialize_field("rateLimit", v)?;
3746 }
3747 struct_ser.end()
3748 }
3749}
3750impl<'de> serde::Deserialize<'de> for DmlNode {
3751 #[allow(deprecated)]
3752 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3753 where
3754 D: serde::Deserializer<'de>,
3755 {
3756 const FIELDS: &[&str] = &[
3757 "table_id",
3758 "tableId",
3759 "table_version_id",
3760 "tableVersionId",
3761 "column_descs",
3762 "columnDescs",
3763 "rate_limit",
3764 "rateLimit",
3765 ];
3766
3767 #[allow(clippy::enum_variant_names)]
3768 enum GeneratedField {
3769 TableId,
3770 TableVersionId,
3771 ColumnDescs,
3772 RateLimit,
3773 }
3774 impl<'de> serde::Deserialize<'de> for GeneratedField {
3775 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3776 where
3777 D: serde::Deserializer<'de>,
3778 {
3779 struct GeneratedVisitor;
3780
3781 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3782 type Value = GeneratedField;
3783
3784 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3785 write!(formatter, "expected one of: {:?}", &FIELDS)
3786 }
3787
3788 #[allow(unused_variables)]
3789 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3790 where
3791 E: serde::de::Error,
3792 {
3793 match value {
3794 "tableId" | "table_id" => Ok(GeneratedField::TableId),
3795 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
3796 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
3797 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
3798 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3799 }
3800 }
3801 }
3802 deserializer.deserialize_identifier(GeneratedVisitor)
3803 }
3804 }
3805 struct GeneratedVisitor;
3806 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3807 type Value = DmlNode;
3808
3809 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3810 formatter.write_str("struct stream_plan.DmlNode")
3811 }
3812
3813 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DmlNode, V::Error>
3814 where
3815 V: serde::de::MapAccess<'de>,
3816 {
3817 let mut table_id__ = None;
3818 let mut table_version_id__ = None;
3819 let mut column_descs__ = None;
3820 let mut rate_limit__ = None;
3821 while let Some(k) = map_.next_key()? {
3822 match k {
3823 GeneratedField::TableId => {
3824 if table_id__.is_some() {
3825 return Err(serde::de::Error::duplicate_field("tableId"));
3826 }
3827 table_id__ =
3828 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3829 ;
3830 }
3831 GeneratedField::TableVersionId => {
3832 if table_version_id__.is_some() {
3833 return Err(serde::de::Error::duplicate_field("tableVersionId"));
3834 }
3835 table_version_id__ =
3836 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3837 ;
3838 }
3839 GeneratedField::ColumnDescs => {
3840 if column_descs__.is_some() {
3841 return Err(serde::de::Error::duplicate_field("columnDescs"));
3842 }
3843 column_descs__ = Some(map_.next_value()?);
3844 }
3845 GeneratedField::RateLimit => {
3846 if rate_limit__.is_some() {
3847 return Err(serde::de::Error::duplicate_field("rateLimit"));
3848 }
3849 rate_limit__ =
3850 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3851 ;
3852 }
3853 }
3854 }
3855 Ok(DmlNode {
3856 table_id: table_id__.unwrap_or_default(),
3857 table_version_id: table_version_id__.unwrap_or_default(),
3858 column_descs: column_descs__.unwrap_or_default(),
3859 rate_limit: rate_limit__,
3860 })
3861 }
3862 }
3863 deserializer.deserialize_struct("stream_plan.DmlNode", FIELDS, GeneratedVisitor)
3864 }
3865}
3866impl serde::Serialize for DropSubscriptionsMutation {
3867 #[allow(deprecated)]
3868 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3869 where
3870 S: serde::Serializer,
3871 {
3872 use serde::ser::SerializeStruct;
3873 let mut len = 0;
3874 if !self.info.is_empty() {
3875 len += 1;
3876 }
3877 let mut struct_ser = serializer.serialize_struct("stream_plan.DropSubscriptionsMutation", len)?;
3878 if !self.info.is_empty() {
3879 struct_ser.serialize_field("info", &self.info)?;
3880 }
3881 struct_ser.end()
3882 }
3883}
3884impl<'de> serde::Deserialize<'de> for DropSubscriptionsMutation {
3885 #[allow(deprecated)]
3886 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3887 where
3888 D: serde::Deserializer<'de>,
3889 {
3890 const FIELDS: &[&str] = &[
3891 "info",
3892 ];
3893
3894 #[allow(clippy::enum_variant_names)]
3895 enum GeneratedField {
3896 Info,
3897 }
3898 impl<'de> serde::Deserialize<'de> for GeneratedField {
3899 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3900 where
3901 D: serde::Deserializer<'de>,
3902 {
3903 struct GeneratedVisitor;
3904
3905 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3906 type Value = GeneratedField;
3907
3908 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3909 write!(formatter, "expected one of: {:?}", &FIELDS)
3910 }
3911
3912 #[allow(unused_variables)]
3913 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3914 where
3915 E: serde::de::Error,
3916 {
3917 match value {
3918 "info" => Ok(GeneratedField::Info),
3919 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3920 }
3921 }
3922 }
3923 deserializer.deserialize_identifier(GeneratedVisitor)
3924 }
3925 }
3926 struct GeneratedVisitor;
3927 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3928 type Value = DropSubscriptionsMutation;
3929
3930 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3931 formatter.write_str("struct stream_plan.DropSubscriptionsMutation")
3932 }
3933
3934 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionsMutation, V::Error>
3935 where
3936 V: serde::de::MapAccess<'de>,
3937 {
3938 let mut info__ = None;
3939 while let Some(k) = map_.next_key()? {
3940 match k {
3941 GeneratedField::Info => {
3942 if info__.is_some() {
3943 return Err(serde::de::Error::duplicate_field("info"));
3944 }
3945 info__ = Some(map_.next_value()?);
3946 }
3947 }
3948 }
3949 Ok(DropSubscriptionsMutation {
3950 info: info__.unwrap_or_default(),
3951 })
3952 }
3953 }
3954 deserializer.deserialize_struct("stream_plan.DropSubscriptionsMutation", FIELDS, GeneratedVisitor)
3955 }
3956}
3957impl serde::Serialize for DynamicFilterNode {
3958 #[allow(deprecated)]
3959 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3960 where
3961 S: serde::Serializer,
3962 {
3963 use serde::ser::SerializeStruct;
3964 let mut len = 0;
3965 if self.left_key != 0 {
3966 len += 1;
3967 }
3968 if self.condition.is_some() {
3969 len += 1;
3970 }
3971 if self.left_table.is_some() {
3972 len += 1;
3973 }
3974 if self.right_table.is_some() {
3975 len += 1;
3976 }
3977 if self.condition_always_relax {
3978 len += 1;
3979 }
3980 let mut struct_ser = serializer.serialize_struct("stream_plan.DynamicFilterNode", len)?;
3981 if self.left_key != 0 {
3982 struct_ser.serialize_field("leftKey", &self.left_key)?;
3983 }
3984 if let Some(v) = self.condition.as_ref() {
3985 struct_ser.serialize_field("condition", v)?;
3986 }
3987 if let Some(v) = self.left_table.as_ref() {
3988 struct_ser.serialize_field("leftTable", v)?;
3989 }
3990 if let Some(v) = self.right_table.as_ref() {
3991 struct_ser.serialize_field("rightTable", v)?;
3992 }
3993 if self.condition_always_relax {
3994 struct_ser.serialize_field("conditionAlwaysRelax", &self.condition_always_relax)?;
3995 }
3996 struct_ser.end()
3997 }
3998}
3999impl<'de> serde::Deserialize<'de> for DynamicFilterNode {
4000 #[allow(deprecated)]
4001 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4002 where
4003 D: serde::Deserializer<'de>,
4004 {
4005 const FIELDS: &[&str] = &[
4006 "left_key",
4007 "leftKey",
4008 "condition",
4009 "left_table",
4010 "leftTable",
4011 "right_table",
4012 "rightTable",
4013 "condition_always_relax",
4014 "conditionAlwaysRelax",
4015 ];
4016
4017 #[allow(clippy::enum_variant_names)]
4018 enum GeneratedField {
4019 LeftKey,
4020 Condition,
4021 LeftTable,
4022 RightTable,
4023 ConditionAlwaysRelax,
4024 }
4025 impl<'de> serde::Deserialize<'de> for GeneratedField {
4026 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4027 where
4028 D: serde::Deserializer<'de>,
4029 {
4030 struct GeneratedVisitor;
4031
4032 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4033 type Value = GeneratedField;
4034
4035 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4036 write!(formatter, "expected one of: {:?}", &FIELDS)
4037 }
4038
4039 #[allow(unused_variables)]
4040 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4041 where
4042 E: serde::de::Error,
4043 {
4044 match value {
4045 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
4046 "condition" => Ok(GeneratedField::Condition),
4047 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
4048 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
4049 "conditionAlwaysRelax" | "condition_always_relax" => Ok(GeneratedField::ConditionAlwaysRelax),
4050 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4051 }
4052 }
4053 }
4054 deserializer.deserialize_identifier(GeneratedVisitor)
4055 }
4056 }
4057 struct GeneratedVisitor;
4058 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4059 type Value = DynamicFilterNode;
4060
4061 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4062 formatter.write_str("struct stream_plan.DynamicFilterNode")
4063 }
4064
4065 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DynamicFilterNode, V::Error>
4066 where
4067 V: serde::de::MapAccess<'de>,
4068 {
4069 let mut left_key__ = None;
4070 let mut condition__ = None;
4071 let mut left_table__ = None;
4072 let mut right_table__ = None;
4073 let mut condition_always_relax__ = None;
4074 while let Some(k) = map_.next_key()? {
4075 match k {
4076 GeneratedField::LeftKey => {
4077 if left_key__.is_some() {
4078 return Err(serde::de::Error::duplicate_field("leftKey"));
4079 }
4080 left_key__ =
4081 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4082 ;
4083 }
4084 GeneratedField::Condition => {
4085 if condition__.is_some() {
4086 return Err(serde::de::Error::duplicate_field("condition"));
4087 }
4088 condition__ = map_.next_value()?;
4089 }
4090 GeneratedField::LeftTable => {
4091 if left_table__.is_some() {
4092 return Err(serde::de::Error::duplicate_field("leftTable"));
4093 }
4094 left_table__ = map_.next_value()?;
4095 }
4096 GeneratedField::RightTable => {
4097 if right_table__.is_some() {
4098 return Err(serde::de::Error::duplicate_field("rightTable"));
4099 }
4100 right_table__ = map_.next_value()?;
4101 }
4102 GeneratedField::ConditionAlwaysRelax => {
4103 if condition_always_relax__.is_some() {
4104 return Err(serde::de::Error::duplicate_field("conditionAlwaysRelax"));
4105 }
4106 condition_always_relax__ = Some(map_.next_value()?);
4107 }
4108 }
4109 }
4110 Ok(DynamicFilterNode {
4111 left_key: left_key__.unwrap_or_default(),
4112 condition: condition__,
4113 left_table: left_table__,
4114 right_table: right_table__,
4115 condition_always_relax: condition_always_relax__.unwrap_or_default(),
4116 })
4117 }
4118 }
4119 deserializer.deserialize_struct("stream_plan.DynamicFilterNode", FIELDS, GeneratedVisitor)
4120 }
4121}
4122impl serde::Serialize for EowcOverWindowNode {
4123 #[allow(deprecated)]
4124 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4125 where
4126 S: serde::Serializer,
4127 {
4128 use serde::ser::SerializeStruct;
4129 let mut len = 0;
4130 if !self.calls.is_empty() {
4131 len += 1;
4132 }
4133 if !self.partition_by.is_empty() {
4134 len += 1;
4135 }
4136 if !self.order_by.is_empty() {
4137 len += 1;
4138 }
4139 if self.state_table.is_some() {
4140 len += 1;
4141 }
4142 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcOverWindowNode", len)?;
4143 if !self.calls.is_empty() {
4144 struct_ser.serialize_field("calls", &self.calls)?;
4145 }
4146 if !self.partition_by.is_empty() {
4147 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
4148 }
4149 if !self.order_by.is_empty() {
4150 struct_ser.serialize_field("orderBy", &self.order_by)?;
4151 }
4152 if let Some(v) = self.state_table.as_ref() {
4153 struct_ser.serialize_field("stateTable", v)?;
4154 }
4155 struct_ser.end()
4156 }
4157}
4158impl<'de> serde::Deserialize<'de> for EowcOverWindowNode {
4159 #[allow(deprecated)]
4160 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4161 where
4162 D: serde::Deserializer<'de>,
4163 {
4164 const FIELDS: &[&str] = &[
4165 "calls",
4166 "partition_by",
4167 "partitionBy",
4168 "order_by",
4169 "orderBy",
4170 "state_table",
4171 "stateTable",
4172 ];
4173
4174 #[allow(clippy::enum_variant_names)]
4175 enum GeneratedField {
4176 Calls,
4177 PartitionBy,
4178 OrderBy,
4179 StateTable,
4180 }
4181 impl<'de> serde::Deserialize<'de> for GeneratedField {
4182 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4183 where
4184 D: serde::Deserializer<'de>,
4185 {
4186 struct GeneratedVisitor;
4187
4188 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4189 type Value = GeneratedField;
4190
4191 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4192 write!(formatter, "expected one of: {:?}", &FIELDS)
4193 }
4194
4195 #[allow(unused_variables)]
4196 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4197 where
4198 E: serde::de::Error,
4199 {
4200 match value {
4201 "calls" => Ok(GeneratedField::Calls),
4202 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
4203 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
4204 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
4205 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4206 }
4207 }
4208 }
4209 deserializer.deserialize_identifier(GeneratedVisitor)
4210 }
4211 }
4212 struct GeneratedVisitor;
4213 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4214 type Value = EowcOverWindowNode;
4215
4216 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4217 formatter.write_str("struct stream_plan.EowcOverWindowNode")
4218 }
4219
4220 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcOverWindowNode, V::Error>
4221 where
4222 V: serde::de::MapAccess<'de>,
4223 {
4224 let mut calls__ = None;
4225 let mut partition_by__ = None;
4226 let mut order_by__ = None;
4227 let mut state_table__ = None;
4228 while let Some(k) = map_.next_key()? {
4229 match k {
4230 GeneratedField::Calls => {
4231 if calls__.is_some() {
4232 return Err(serde::de::Error::duplicate_field("calls"));
4233 }
4234 calls__ = Some(map_.next_value()?);
4235 }
4236 GeneratedField::PartitionBy => {
4237 if partition_by__.is_some() {
4238 return Err(serde::de::Error::duplicate_field("partitionBy"));
4239 }
4240 partition_by__ =
4241 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4242 .into_iter().map(|x| x.0).collect())
4243 ;
4244 }
4245 GeneratedField::OrderBy => {
4246 if order_by__.is_some() {
4247 return Err(serde::de::Error::duplicate_field("orderBy"));
4248 }
4249 order_by__ = Some(map_.next_value()?);
4250 }
4251 GeneratedField::StateTable => {
4252 if state_table__.is_some() {
4253 return Err(serde::de::Error::duplicate_field("stateTable"));
4254 }
4255 state_table__ = map_.next_value()?;
4256 }
4257 }
4258 }
4259 Ok(EowcOverWindowNode {
4260 calls: calls__.unwrap_or_default(),
4261 partition_by: partition_by__.unwrap_or_default(),
4262 order_by: order_by__.unwrap_or_default(),
4263 state_table: state_table__,
4264 })
4265 }
4266 }
4267 deserializer.deserialize_struct("stream_plan.EowcOverWindowNode", FIELDS, GeneratedVisitor)
4268 }
4269}
4270impl serde::Serialize for ExchangeNode {
4271 #[allow(deprecated)]
4272 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4273 where
4274 S: serde::Serializer,
4275 {
4276 use serde::ser::SerializeStruct;
4277 let mut len = 0;
4278 if self.strategy.is_some() {
4279 len += 1;
4280 }
4281 let mut struct_ser = serializer.serialize_struct("stream_plan.ExchangeNode", len)?;
4282 if let Some(v) = self.strategy.as_ref() {
4283 struct_ser.serialize_field("strategy", v)?;
4284 }
4285 struct_ser.end()
4286 }
4287}
4288impl<'de> serde::Deserialize<'de> for ExchangeNode {
4289 #[allow(deprecated)]
4290 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4291 where
4292 D: serde::Deserializer<'de>,
4293 {
4294 const FIELDS: &[&str] = &[
4295 "strategy",
4296 ];
4297
4298 #[allow(clippy::enum_variant_names)]
4299 enum GeneratedField {
4300 Strategy,
4301 }
4302 impl<'de> serde::Deserialize<'de> for GeneratedField {
4303 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4304 where
4305 D: serde::Deserializer<'de>,
4306 {
4307 struct GeneratedVisitor;
4308
4309 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4310 type Value = GeneratedField;
4311
4312 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4313 write!(formatter, "expected one of: {:?}", &FIELDS)
4314 }
4315
4316 #[allow(unused_variables)]
4317 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4318 where
4319 E: serde::de::Error,
4320 {
4321 match value {
4322 "strategy" => Ok(GeneratedField::Strategy),
4323 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4324 }
4325 }
4326 }
4327 deserializer.deserialize_identifier(GeneratedVisitor)
4328 }
4329 }
4330 struct GeneratedVisitor;
4331 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4332 type Value = ExchangeNode;
4333
4334 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4335 formatter.write_str("struct stream_plan.ExchangeNode")
4336 }
4337
4338 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExchangeNode, V::Error>
4339 where
4340 V: serde::de::MapAccess<'de>,
4341 {
4342 let mut strategy__ = None;
4343 while let Some(k) = map_.next_key()? {
4344 match k {
4345 GeneratedField::Strategy => {
4346 if strategy__.is_some() {
4347 return Err(serde::de::Error::duplicate_field("strategy"));
4348 }
4349 strategy__ = map_.next_value()?;
4350 }
4351 }
4352 }
4353 Ok(ExchangeNode {
4354 strategy: strategy__,
4355 })
4356 }
4357 }
4358 deserializer.deserialize_struct("stream_plan.ExchangeNode", FIELDS, GeneratedVisitor)
4359 }
4360}
4361impl serde::Serialize for ExpandNode {
4362 #[allow(deprecated)]
4363 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4364 where
4365 S: serde::Serializer,
4366 {
4367 use serde::ser::SerializeStruct;
4368 let mut len = 0;
4369 if !self.column_subsets.is_empty() {
4370 len += 1;
4371 }
4372 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode", len)?;
4373 if !self.column_subsets.is_empty() {
4374 struct_ser.serialize_field("columnSubsets", &self.column_subsets)?;
4375 }
4376 struct_ser.end()
4377 }
4378}
4379impl<'de> serde::Deserialize<'de> for ExpandNode {
4380 #[allow(deprecated)]
4381 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4382 where
4383 D: serde::Deserializer<'de>,
4384 {
4385 const FIELDS: &[&str] = &[
4386 "column_subsets",
4387 "columnSubsets",
4388 ];
4389
4390 #[allow(clippy::enum_variant_names)]
4391 enum GeneratedField {
4392 ColumnSubsets,
4393 }
4394 impl<'de> serde::Deserialize<'de> for GeneratedField {
4395 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4396 where
4397 D: serde::Deserializer<'de>,
4398 {
4399 struct GeneratedVisitor;
4400
4401 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4402 type Value = GeneratedField;
4403
4404 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4405 write!(formatter, "expected one of: {:?}", &FIELDS)
4406 }
4407
4408 #[allow(unused_variables)]
4409 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4410 where
4411 E: serde::de::Error,
4412 {
4413 match value {
4414 "columnSubsets" | "column_subsets" => Ok(GeneratedField::ColumnSubsets),
4415 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4416 }
4417 }
4418 }
4419 deserializer.deserialize_identifier(GeneratedVisitor)
4420 }
4421 }
4422 struct GeneratedVisitor;
4423 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4424 type Value = ExpandNode;
4425
4426 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4427 formatter.write_str("struct stream_plan.ExpandNode")
4428 }
4429
4430 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpandNode, V::Error>
4431 where
4432 V: serde::de::MapAccess<'de>,
4433 {
4434 let mut column_subsets__ = None;
4435 while let Some(k) = map_.next_key()? {
4436 match k {
4437 GeneratedField::ColumnSubsets => {
4438 if column_subsets__.is_some() {
4439 return Err(serde::de::Error::duplicate_field("columnSubsets"));
4440 }
4441 column_subsets__ = Some(map_.next_value()?);
4442 }
4443 }
4444 }
4445 Ok(ExpandNode {
4446 column_subsets: column_subsets__.unwrap_or_default(),
4447 })
4448 }
4449 }
4450 deserializer.deserialize_struct("stream_plan.ExpandNode", FIELDS, GeneratedVisitor)
4451 }
4452}
4453impl serde::Serialize for expand_node::Subset {
4454 #[allow(deprecated)]
4455 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4456 where
4457 S: serde::Serializer,
4458 {
4459 use serde::ser::SerializeStruct;
4460 let mut len = 0;
4461 if !self.column_indices.is_empty() {
4462 len += 1;
4463 }
4464 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode.Subset", len)?;
4465 if !self.column_indices.is_empty() {
4466 struct_ser.serialize_field("columnIndices", &self.column_indices)?;
4467 }
4468 struct_ser.end()
4469 }
4470}
4471impl<'de> serde::Deserialize<'de> for expand_node::Subset {
4472 #[allow(deprecated)]
4473 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4474 where
4475 D: serde::Deserializer<'de>,
4476 {
4477 const FIELDS: &[&str] = &[
4478 "column_indices",
4479 "columnIndices",
4480 ];
4481
4482 #[allow(clippy::enum_variant_names)]
4483 enum GeneratedField {
4484 ColumnIndices,
4485 }
4486 impl<'de> serde::Deserialize<'de> for GeneratedField {
4487 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4488 where
4489 D: serde::Deserializer<'de>,
4490 {
4491 struct GeneratedVisitor;
4492
4493 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4494 type Value = GeneratedField;
4495
4496 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4497 write!(formatter, "expected one of: {:?}", &FIELDS)
4498 }
4499
4500 #[allow(unused_variables)]
4501 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4502 where
4503 E: serde::de::Error,
4504 {
4505 match value {
4506 "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
4507 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4508 }
4509 }
4510 }
4511 deserializer.deserialize_identifier(GeneratedVisitor)
4512 }
4513 }
4514 struct GeneratedVisitor;
4515 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4516 type Value = expand_node::Subset;
4517
4518 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4519 formatter.write_str("struct stream_plan.ExpandNode.Subset")
4520 }
4521
4522 fn visit_map<V>(self, mut map_: V) -> std::result::Result<expand_node::Subset, V::Error>
4523 where
4524 V: serde::de::MapAccess<'de>,
4525 {
4526 let mut column_indices__ = None;
4527 while let Some(k) = map_.next_key()? {
4528 match k {
4529 GeneratedField::ColumnIndices => {
4530 if column_indices__.is_some() {
4531 return Err(serde::de::Error::duplicate_field("columnIndices"));
4532 }
4533 column_indices__ =
4534 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4535 .into_iter().map(|x| x.0).collect())
4536 ;
4537 }
4538 }
4539 }
4540 Ok(expand_node::Subset {
4541 column_indices: column_indices__.unwrap_or_default(),
4542 })
4543 }
4544 }
4545 deserializer.deserialize_struct("stream_plan.ExpandNode.Subset", FIELDS, GeneratedVisitor)
4546 }
4547}
4548impl serde::Serialize for FilterNode {
4549 #[allow(deprecated)]
4550 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4551 where
4552 S: serde::Serializer,
4553 {
4554 use serde::ser::SerializeStruct;
4555 let mut len = 0;
4556 if self.search_condition.is_some() {
4557 len += 1;
4558 }
4559 let mut struct_ser = serializer.serialize_struct("stream_plan.FilterNode", len)?;
4560 if let Some(v) = self.search_condition.as_ref() {
4561 struct_ser.serialize_field("searchCondition", v)?;
4562 }
4563 struct_ser.end()
4564 }
4565}
4566impl<'de> serde::Deserialize<'de> for FilterNode {
4567 #[allow(deprecated)]
4568 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4569 where
4570 D: serde::Deserializer<'de>,
4571 {
4572 const FIELDS: &[&str] = &[
4573 "search_condition",
4574 "searchCondition",
4575 ];
4576
4577 #[allow(clippy::enum_variant_names)]
4578 enum GeneratedField {
4579 SearchCondition,
4580 }
4581 impl<'de> serde::Deserialize<'de> for GeneratedField {
4582 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4583 where
4584 D: serde::Deserializer<'de>,
4585 {
4586 struct GeneratedVisitor;
4587
4588 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4589 type Value = GeneratedField;
4590
4591 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4592 write!(formatter, "expected one of: {:?}", &FIELDS)
4593 }
4594
4595 #[allow(unused_variables)]
4596 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4597 where
4598 E: serde::de::Error,
4599 {
4600 match value {
4601 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
4602 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4603 }
4604 }
4605 }
4606 deserializer.deserialize_identifier(GeneratedVisitor)
4607 }
4608 }
4609 struct GeneratedVisitor;
4610 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4611 type Value = FilterNode;
4612
4613 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4614 formatter.write_str("struct stream_plan.FilterNode")
4615 }
4616
4617 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FilterNode, V::Error>
4618 where
4619 V: serde::de::MapAccess<'de>,
4620 {
4621 let mut search_condition__ = None;
4622 while let Some(k) = map_.next_key()? {
4623 match k {
4624 GeneratedField::SearchCondition => {
4625 if search_condition__.is_some() {
4626 return Err(serde::de::Error::duplicate_field("searchCondition"));
4627 }
4628 search_condition__ = map_.next_value()?;
4629 }
4630 }
4631 }
4632 Ok(FilterNode {
4633 search_condition: search_condition__,
4634 })
4635 }
4636 }
4637 deserializer.deserialize_struct("stream_plan.FilterNode", FIELDS, GeneratedVisitor)
4638 }
4639}
4640impl serde::Serialize for GlobalApproxPercentileNode {
4641 #[allow(deprecated)]
4642 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4643 where
4644 S: serde::Serializer,
4645 {
4646 use serde::ser::SerializeStruct;
4647 let mut len = 0;
4648 if self.base != 0. {
4649 len += 1;
4650 }
4651 if self.quantile != 0. {
4652 len += 1;
4653 }
4654 if self.bucket_state_table.is_some() {
4655 len += 1;
4656 }
4657 if self.count_state_table.is_some() {
4658 len += 1;
4659 }
4660 let mut struct_ser = serializer.serialize_struct("stream_plan.GlobalApproxPercentileNode", len)?;
4661 if self.base != 0. {
4662 struct_ser.serialize_field("base", &self.base)?;
4663 }
4664 if self.quantile != 0. {
4665 struct_ser.serialize_field("quantile", &self.quantile)?;
4666 }
4667 if let Some(v) = self.bucket_state_table.as_ref() {
4668 struct_ser.serialize_field("bucketStateTable", v)?;
4669 }
4670 if let Some(v) = self.count_state_table.as_ref() {
4671 struct_ser.serialize_field("countStateTable", v)?;
4672 }
4673 struct_ser.end()
4674 }
4675}
4676impl<'de> serde::Deserialize<'de> for GlobalApproxPercentileNode {
4677 #[allow(deprecated)]
4678 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4679 where
4680 D: serde::Deserializer<'de>,
4681 {
4682 const FIELDS: &[&str] = &[
4683 "base",
4684 "quantile",
4685 "bucket_state_table",
4686 "bucketStateTable",
4687 "count_state_table",
4688 "countStateTable",
4689 ];
4690
4691 #[allow(clippy::enum_variant_names)]
4692 enum GeneratedField {
4693 Base,
4694 Quantile,
4695 BucketStateTable,
4696 CountStateTable,
4697 }
4698 impl<'de> serde::Deserialize<'de> for GeneratedField {
4699 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4700 where
4701 D: serde::Deserializer<'de>,
4702 {
4703 struct GeneratedVisitor;
4704
4705 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4706 type Value = GeneratedField;
4707
4708 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4709 write!(formatter, "expected one of: {:?}", &FIELDS)
4710 }
4711
4712 #[allow(unused_variables)]
4713 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4714 where
4715 E: serde::de::Error,
4716 {
4717 match value {
4718 "base" => Ok(GeneratedField::Base),
4719 "quantile" => Ok(GeneratedField::Quantile),
4720 "bucketStateTable" | "bucket_state_table" => Ok(GeneratedField::BucketStateTable),
4721 "countStateTable" | "count_state_table" => Ok(GeneratedField::CountStateTable),
4722 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4723 }
4724 }
4725 }
4726 deserializer.deserialize_identifier(GeneratedVisitor)
4727 }
4728 }
4729 struct GeneratedVisitor;
4730 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4731 type Value = GlobalApproxPercentileNode;
4732
4733 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4734 formatter.write_str("struct stream_plan.GlobalApproxPercentileNode")
4735 }
4736
4737 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GlobalApproxPercentileNode, V::Error>
4738 where
4739 V: serde::de::MapAccess<'de>,
4740 {
4741 let mut base__ = None;
4742 let mut quantile__ = None;
4743 let mut bucket_state_table__ = None;
4744 let mut count_state_table__ = None;
4745 while let Some(k) = map_.next_key()? {
4746 match k {
4747 GeneratedField::Base => {
4748 if base__.is_some() {
4749 return Err(serde::de::Error::duplicate_field("base"));
4750 }
4751 base__ =
4752 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4753 ;
4754 }
4755 GeneratedField::Quantile => {
4756 if quantile__.is_some() {
4757 return Err(serde::de::Error::duplicate_field("quantile"));
4758 }
4759 quantile__ =
4760 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4761 ;
4762 }
4763 GeneratedField::BucketStateTable => {
4764 if bucket_state_table__.is_some() {
4765 return Err(serde::de::Error::duplicate_field("bucketStateTable"));
4766 }
4767 bucket_state_table__ = map_.next_value()?;
4768 }
4769 GeneratedField::CountStateTable => {
4770 if count_state_table__.is_some() {
4771 return Err(serde::de::Error::duplicate_field("countStateTable"));
4772 }
4773 count_state_table__ = map_.next_value()?;
4774 }
4775 }
4776 }
4777 Ok(GlobalApproxPercentileNode {
4778 base: base__.unwrap_or_default(),
4779 quantile: quantile__.unwrap_or_default(),
4780 bucket_state_table: bucket_state_table__,
4781 count_state_table: count_state_table__,
4782 })
4783 }
4784 }
4785 deserializer.deserialize_struct("stream_plan.GlobalApproxPercentileNode", FIELDS, GeneratedVisitor)
4786 }
4787}
4788impl serde::Serialize for GroupTopNNode {
4789 #[allow(deprecated)]
4790 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4791 where
4792 S: serde::Serializer,
4793 {
4794 use serde::ser::SerializeStruct;
4795 let mut len = 0;
4796 if self.limit != 0 {
4797 len += 1;
4798 }
4799 if self.offset != 0 {
4800 len += 1;
4801 }
4802 if !self.group_key.is_empty() {
4803 len += 1;
4804 }
4805 if self.table.is_some() {
4806 len += 1;
4807 }
4808 if !self.order_by.is_empty() {
4809 len += 1;
4810 }
4811 if self.with_ties {
4812 len += 1;
4813 }
4814 let mut struct_ser = serializer.serialize_struct("stream_plan.GroupTopNNode", len)?;
4815 if self.limit != 0 {
4816 #[allow(clippy::needless_borrow)]
4817 #[allow(clippy::needless_borrows_for_generic_args)]
4818 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
4819 }
4820 if self.offset != 0 {
4821 #[allow(clippy::needless_borrow)]
4822 #[allow(clippy::needless_borrows_for_generic_args)]
4823 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
4824 }
4825 if !self.group_key.is_empty() {
4826 struct_ser.serialize_field("groupKey", &self.group_key)?;
4827 }
4828 if let Some(v) = self.table.as_ref() {
4829 struct_ser.serialize_field("table", v)?;
4830 }
4831 if !self.order_by.is_empty() {
4832 struct_ser.serialize_field("orderBy", &self.order_by)?;
4833 }
4834 if self.with_ties {
4835 struct_ser.serialize_field("withTies", &self.with_ties)?;
4836 }
4837 struct_ser.end()
4838 }
4839}
4840impl<'de> serde::Deserialize<'de> for GroupTopNNode {
4841 #[allow(deprecated)]
4842 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4843 where
4844 D: serde::Deserializer<'de>,
4845 {
4846 const FIELDS: &[&str] = &[
4847 "limit",
4848 "offset",
4849 "group_key",
4850 "groupKey",
4851 "table",
4852 "order_by",
4853 "orderBy",
4854 "with_ties",
4855 "withTies",
4856 ];
4857
4858 #[allow(clippy::enum_variant_names)]
4859 enum GeneratedField {
4860 Limit,
4861 Offset,
4862 GroupKey,
4863 Table,
4864 OrderBy,
4865 WithTies,
4866 }
4867 impl<'de> serde::Deserialize<'de> for GeneratedField {
4868 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4869 where
4870 D: serde::Deserializer<'de>,
4871 {
4872 struct GeneratedVisitor;
4873
4874 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4875 type Value = GeneratedField;
4876
4877 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4878 write!(formatter, "expected one of: {:?}", &FIELDS)
4879 }
4880
4881 #[allow(unused_variables)]
4882 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4883 where
4884 E: serde::de::Error,
4885 {
4886 match value {
4887 "limit" => Ok(GeneratedField::Limit),
4888 "offset" => Ok(GeneratedField::Offset),
4889 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
4890 "table" => Ok(GeneratedField::Table),
4891 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
4892 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
4893 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4894 }
4895 }
4896 }
4897 deserializer.deserialize_identifier(GeneratedVisitor)
4898 }
4899 }
4900 struct GeneratedVisitor;
4901 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4902 type Value = GroupTopNNode;
4903
4904 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4905 formatter.write_str("struct stream_plan.GroupTopNNode")
4906 }
4907
4908 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupTopNNode, V::Error>
4909 where
4910 V: serde::de::MapAccess<'de>,
4911 {
4912 let mut limit__ = None;
4913 let mut offset__ = None;
4914 let mut group_key__ = None;
4915 let mut table__ = None;
4916 let mut order_by__ = None;
4917 let mut with_ties__ = None;
4918 while let Some(k) = map_.next_key()? {
4919 match k {
4920 GeneratedField::Limit => {
4921 if limit__.is_some() {
4922 return Err(serde::de::Error::duplicate_field("limit"));
4923 }
4924 limit__ =
4925 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4926 ;
4927 }
4928 GeneratedField::Offset => {
4929 if offset__.is_some() {
4930 return Err(serde::de::Error::duplicate_field("offset"));
4931 }
4932 offset__ =
4933 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4934 ;
4935 }
4936 GeneratedField::GroupKey => {
4937 if group_key__.is_some() {
4938 return Err(serde::de::Error::duplicate_field("groupKey"));
4939 }
4940 group_key__ =
4941 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4942 .into_iter().map(|x| x.0).collect())
4943 ;
4944 }
4945 GeneratedField::Table => {
4946 if table__.is_some() {
4947 return Err(serde::de::Error::duplicate_field("table"));
4948 }
4949 table__ = map_.next_value()?;
4950 }
4951 GeneratedField::OrderBy => {
4952 if order_by__.is_some() {
4953 return Err(serde::de::Error::duplicate_field("orderBy"));
4954 }
4955 order_by__ = Some(map_.next_value()?);
4956 }
4957 GeneratedField::WithTies => {
4958 if with_ties__.is_some() {
4959 return Err(serde::de::Error::duplicate_field("withTies"));
4960 }
4961 with_ties__ = Some(map_.next_value()?);
4962 }
4963 }
4964 }
4965 Ok(GroupTopNNode {
4966 limit: limit__.unwrap_or_default(),
4967 offset: offset__.unwrap_or_default(),
4968 group_key: group_key__.unwrap_or_default(),
4969 table: table__,
4970 order_by: order_by__.unwrap_or_default(),
4971 with_ties: with_ties__.unwrap_or_default(),
4972 })
4973 }
4974 }
4975 deserializer.deserialize_struct("stream_plan.GroupTopNNode", FIELDS, GeneratedVisitor)
4976 }
4977}
4978impl serde::Serialize for HashAggNode {
4979 #[allow(deprecated)]
4980 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4981 where
4982 S: serde::Serializer,
4983 {
4984 use serde::ser::SerializeStruct;
4985 let mut len = 0;
4986 if !self.group_key.is_empty() {
4987 len += 1;
4988 }
4989 if !self.agg_calls.is_empty() {
4990 len += 1;
4991 }
4992 if !self.agg_call_states.is_empty() {
4993 len += 1;
4994 }
4995 if self.intermediate_state_table.is_some() {
4996 len += 1;
4997 }
4998 if self.is_append_only {
4999 len += 1;
5000 }
5001 if !self.distinct_dedup_tables.is_empty() {
5002 len += 1;
5003 }
5004 if self.row_count_index != 0 {
5005 len += 1;
5006 }
5007 if self.emit_on_window_close {
5008 len += 1;
5009 }
5010 if self.version != 0 {
5011 len += 1;
5012 }
5013 let mut struct_ser = serializer.serialize_struct("stream_plan.HashAggNode", len)?;
5014 if !self.group_key.is_empty() {
5015 struct_ser.serialize_field("groupKey", &self.group_key)?;
5016 }
5017 if !self.agg_calls.is_empty() {
5018 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
5019 }
5020 if !self.agg_call_states.is_empty() {
5021 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
5022 }
5023 if let Some(v) = self.intermediate_state_table.as_ref() {
5024 struct_ser.serialize_field("intermediateStateTable", v)?;
5025 }
5026 if self.is_append_only {
5027 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5028 }
5029 if !self.distinct_dedup_tables.is_empty() {
5030 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
5031 }
5032 if self.row_count_index != 0 {
5033 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
5034 }
5035 if self.emit_on_window_close {
5036 struct_ser.serialize_field("emitOnWindowClose", &self.emit_on_window_close)?;
5037 }
5038 if self.version != 0 {
5039 let v = AggNodeVersion::try_from(self.version)
5040 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
5041 struct_ser.serialize_field("version", &v)?;
5042 }
5043 struct_ser.end()
5044 }
5045}
5046impl<'de> serde::Deserialize<'de> for HashAggNode {
5047 #[allow(deprecated)]
5048 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5049 where
5050 D: serde::Deserializer<'de>,
5051 {
5052 const FIELDS: &[&str] = &[
5053 "group_key",
5054 "groupKey",
5055 "agg_calls",
5056 "aggCalls",
5057 "agg_call_states",
5058 "aggCallStates",
5059 "intermediate_state_table",
5060 "intermediateStateTable",
5061 "is_append_only",
5062 "isAppendOnly",
5063 "distinct_dedup_tables",
5064 "distinctDedupTables",
5065 "row_count_index",
5066 "rowCountIndex",
5067 "emit_on_window_close",
5068 "emitOnWindowClose",
5069 "version",
5070 ];
5071
5072 #[allow(clippy::enum_variant_names)]
5073 enum GeneratedField {
5074 GroupKey,
5075 AggCalls,
5076 AggCallStates,
5077 IntermediateStateTable,
5078 IsAppendOnly,
5079 DistinctDedupTables,
5080 RowCountIndex,
5081 EmitOnWindowClose,
5082 Version,
5083 }
5084 impl<'de> serde::Deserialize<'de> for GeneratedField {
5085 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5086 where
5087 D: serde::Deserializer<'de>,
5088 {
5089 struct GeneratedVisitor;
5090
5091 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5092 type Value = GeneratedField;
5093
5094 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5095 write!(formatter, "expected one of: {:?}", &FIELDS)
5096 }
5097
5098 #[allow(unused_variables)]
5099 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5100 where
5101 E: serde::de::Error,
5102 {
5103 match value {
5104 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5105 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
5106 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
5107 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
5108 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5109 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
5110 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
5111 "emitOnWindowClose" | "emit_on_window_close" => Ok(GeneratedField::EmitOnWindowClose),
5112 "version" => Ok(GeneratedField::Version),
5113 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5114 }
5115 }
5116 }
5117 deserializer.deserialize_identifier(GeneratedVisitor)
5118 }
5119 }
5120 struct GeneratedVisitor;
5121 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5122 type Value = HashAggNode;
5123
5124 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5125 formatter.write_str("struct stream_plan.HashAggNode")
5126 }
5127
5128 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashAggNode, V::Error>
5129 where
5130 V: serde::de::MapAccess<'de>,
5131 {
5132 let mut group_key__ = None;
5133 let mut agg_calls__ = None;
5134 let mut agg_call_states__ = None;
5135 let mut intermediate_state_table__ = None;
5136 let mut is_append_only__ = None;
5137 let mut distinct_dedup_tables__ = None;
5138 let mut row_count_index__ = None;
5139 let mut emit_on_window_close__ = None;
5140 let mut version__ = None;
5141 while let Some(k) = map_.next_key()? {
5142 match k {
5143 GeneratedField::GroupKey => {
5144 if group_key__.is_some() {
5145 return Err(serde::de::Error::duplicate_field("groupKey"));
5146 }
5147 group_key__ =
5148 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5149 .into_iter().map(|x| x.0).collect())
5150 ;
5151 }
5152 GeneratedField::AggCalls => {
5153 if agg_calls__.is_some() {
5154 return Err(serde::de::Error::duplicate_field("aggCalls"));
5155 }
5156 agg_calls__ = Some(map_.next_value()?);
5157 }
5158 GeneratedField::AggCallStates => {
5159 if agg_call_states__.is_some() {
5160 return Err(serde::de::Error::duplicate_field("aggCallStates"));
5161 }
5162 agg_call_states__ = Some(map_.next_value()?);
5163 }
5164 GeneratedField::IntermediateStateTable => {
5165 if intermediate_state_table__.is_some() {
5166 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
5167 }
5168 intermediate_state_table__ = map_.next_value()?;
5169 }
5170 GeneratedField::IsAppendOnly => {
5171 if is_append_only__.is_some() {
5172 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
5173 }
5174 is_append_only__ = Some(map_.next_value()?);
5175 }
5176 GeneratedField::DistinctDedupTables => {
5177 if distinct_dedup_tables__.is_some() {
5178 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
5179 }
5180 distinct_dedup_tables__ = Some(
5181 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5182 .into_iter().map(|(k,v)| (k.0, v)).collect()
5183 );
5184 }
5185 GeneratedField::RowCountIndex => {
5186 if row_count_index__.is_some() {
5187 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
5188 }
5189 row_count_index__ =
5190 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5191 ;
5192 }
5193 GeneratedField::EmitOnWindowClose => {
5194 if emit_on_window_close__.is_some() {
5195 return Err(serde::de::Error::duplicate_field("emitOnWindowClose"));
5196 }
5197 emit_on_window_close__ = Some(map_.next_value()?);
5198 }
5199 GeneratedField::Version => {
5200 if version__.is_some() {
5201 return Err(serde::de::Error::duplicate_field("version"));
5202 }
5203 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
5204 }
5205 }
5206 }
5207 Ok(HashAggNode {
5208 group_key: group_key__.unwrap_or_default(),
5209 agg_calls: agg_calls__.unwrap_or_default(),
5210 agg_call_states: agg_call_states__.unwrap_or_default(),
5211 intermediate_state_table: intermediate_state_table__,
5212 is_append_only: is_append_only__.unwrap_or_default(),
5213 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
5214 row_count_index: row_count_index__.unwrap_or_default(),
5215 emit_on_window_close: emit_on_window_close__.unwrap_or_default(),
5216 version: version__.unwrap_or_default(),
5217 })
5218 }
5219 }
5220 deserializer.deserialize_struct("stream_plan.HashAggNode", FIELDS, GeneratedVisitor)
5221 }
5222}
5223impl serde::Serialize for HashJoinNode {
5224 #[allow(deprecated)]
5225 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5226 where
5227 S: serde::Serializer,
5228 {
5229 use serde::ser::SerializeStruct;
5230 let mut len = 0;
5231 if self.join_type != 0 {
5232 len += 1;
5233 }
5234 if !self.left_key.is_empty() {
5235 len += 1;
5236 }
5237 if !self.right_key.is_empty() {
5238 len += 1;
5239 }
5240 if self.condition.is_some() {
5241 len += 1;
5242 }
5243 if !self.inequality_pairs.is_empty() {
5244 len += 1;
5245 }
5246 if self.left_table.is_some() {
5247 len += 1;
5248 }
5249 if self.right_table.is_some() {
5250 len += 1;
5251 }
5252 if self.left_degree_table.is_some() {
5253 len += 1;
5254 }
5255 if self.right_degree_table.is_some() {
5256 len += 1;
5257 }
5258 if !self.output_indices.is_empty() {
5259 len += 1;
5260 }
5261 if !self.left_deduped_input_pk_indices.is_empty() {
5262 len += 1;
5263 }
5264 if !self.right_deduped_input_pk_indices.is_empty() {
5265 len += 1;
5266 }
5267 if !self.null_safe.is_empty() {
5268 len += 1;
5269 }
5270 if self.is_append_only {
5271 len += 1;
5272 }
5273 if self.join_encoding_type != 0 {
5274 len += 1;
5275 }
5276 let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinNode", len)?;
5277 if self.join_type != 0 {
5278 let v = super::plan_common::JoinType::try_from(self.join_type)
5279 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
5280 struct_ser.serialize_field("joinType", &v)?;
5281 }
5282 if !self.left_key.is_empty() {
5283 struct_ser.serialize_field("leftKey", &self.left_key)?;
5284 }
5285 if !self.right_key.is_empty() {
5286 struct_ser.serialize_field("rightKey", &self.right_key)?;
5287 }
5288 if let Some(v) = self.condition.as_ref() {
5289 struct_ser.serialize_field("condition", v)?;
5290 }
5291 if !self.inequality_pairs.is_empty() {
5292 struct_ser.serialize_field("inequalityPairs", &self.inequality_pairs)?;
5293 }
5294 if let Some(v) = self.left_table.as_ref() {
5295 struct_ser.serialize_field("leftTable", v)?;
5296 }
5297 if let Some(v) = self.right_table.as_ref() {
5298 struct_ser.serialize_field("rightTable", v)?;
5299 }
5300 if let Some(v) = self.left_degree_table.as_ref() {
5301 struct_ser.serialize_field("leftDegreeTable", v)?;
5302 }
5303 if let Some(v) = self.right_degree_table.as_ref() {
5304 struct_ser.serialize_field("rightDegreeTable", v)?;
5305 }
5306 if !self.output_indices.is_empty() {
5307 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
5308 }
5309 if !self.left_deduped_input_pk_indices.is_empty() {
5310 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
5311 }
5312 if !self.right_deduped_input_pk_indices.is_empty() {
5313 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
5314 }
5315 if !self.null_safe.is_empty() {
5316 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
5317 }
5318 if self.is_append_only {
5319 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5320 }
5321 if self.join_encoding_type != 0 {
5322 let v = JoinEncodingType::try_from(self.join_encoding_type)
5323 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
5324 struct_ser.serialize_field("joinEncodingType", &v)?;
5325 }
5326 struct_ser.end()
5327 }
5328}
5329impl<'de> serde::Deserialize<'de> for HashJoinNode {
5330 #[allow(deprecated)]
5331 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5332 where
5333 D: serde::Deserializer<'de>,
5334 {
5335 const FIELDS: &[&str] = &[
5336 "join_type",
5337 "joinType",
5338 "left_key",
5339 "leftKey",
5340 "right_key",
5341 "rightKey",
5342 "condition",
5343 "inequality_pairs",
5344 "inequalityPairs",
5345 "left_table",
5346 "leftTable",
5347 "right_table",
5348 "rightTable",
5349 "left_degree_table",
5350 "leftDegreeTable",
5351 "right_degree_table",
5352 "rightDegreeTable",
5353 "output_indices",
5354 "outputIndices",
5355 "left_deduped_input_pk_indices",
5356 "leftDedupedInputPkIndices",
5357 "right_deduped_input_pk_indices",
5358 "rightDedupedInputPkIndices",
5359 "null_safe",
5360 "nullSafe",
5361 "is_append_only",
5362 "isAppendOnly",
5363 "join_encoding_type",
5364 "joinEncodingType",
5365 ];
5366
5367 #[allow(clippy::enum_variant_names)]
5368 enum GeneratedField {
5369 JoinType,
5370 LeftKey,
5371 RightKey,
5372 Condition,
5373 InequalityPairs,
5374 LeftTable,
5375 RightTable,
5376 LeftDegreeTable,
5377 RightDegreeTable,
5378 OutputIndices,
5379 LeftDedupedInputPkIndices,
5380 RightDedupedInputPkIndices,
5381 NullSafe,
5382 IsAppendOnly,
5383 JoinEncodingType,
5384 }
5385 impl<'de> serde::Deserialize<'de> for GeneratedField {
5386 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5387 where
5388 D: serde::Deserializer<'de>,
5389 {
5390 struct GeneratedVisitor;
5391
5392 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5393 type Value = GeneratedField;
5394
5395 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5396 write!(formatter, "expected one of: {:?}", &FIELDS)
5397 }
5398
5399 #[allow(unused_variables)]
5400 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5401 where
5402 E: serde::de::Error,
5403 {
5404 match value {
5405 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
5406 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
5407 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
5408 "condition" => Ok(GeneratedField::Condition),
5409 "inequalityPairs" | "inequality_pairs" => Ok(GeneratedField::InequalityPairs),
5410 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
5411 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
5412 "leftDegreeTable" | "left_degree_table" => Ok(GeneratedField::LeftDegreeTable),
5413 "rightDegreeTable" | "right_degree_table" => Ok(GeneratedField::RightDegreeTable),
5414 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
5415 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
5416 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
5417 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
5418 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5419 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
5420 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5421 }
5422 }
5423 }
5424 deserializer.deserialize_identifier(GeneratedVisitor)
5425 }
5426 }
5427 struct GeneratedVisitor;
5428 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5429 type Value = HashJoinNode;
5430
5431 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5432 formatter.write_str("struct stream_plan.HashJoinNode")
5433 }
5434
5435 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinNode, V::Error>
5436 where
5437 V: serde::de::MapAccess<'de>,
5438 {
5439 let mut join_type__ = None;
5440 let mut left_key__ = None;
5441 let mut right_key__ = None;
5442 let mut condition__ = None;
5443 let mut inequality_pairs__ = None;
5444 let mut left_table__ = None;
5445 let mut right_table__ = None;
5446 let mut left_degree_table__ = None;
5447 let mut right_degree_table__ = None;
5448 let mut output_indices__ = None;
5449 let mut left_deduped_input_pk_indices__ = None;
5450 let mut right_deduped_input_pk_indices__ = None;
5451 let mut null_safe__ = None;
5452 let mut is_append_only__ = None;
5453 let mut join_encoding_type__ = None;
5454 while let Some(k) = map_.next_key()? {
5455 match k {
5456 GeneratedField::JoinType => {
5457 if join_type__.is_some() {
5458 return Err(serde::de::Error::duplicate_field("joinType"));
5459 }
5460 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
5461 }
5462 GeneratedField::LeftKey => {
5463 if left_key__.is_some() {
5464 return Err(serde::de::Error::duplicate_field("leftKey"));
5465 }
5466 left_key__ =
5467 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5468 .into_iter().map(|x| x.0).collect())
5469 ;
5470 }
5471 GeneratedField::RightKey => {
5472 if right_key__.is_some() {
5473 return Err(serde::de::Error::duplicate_field("rightKey"));
5474 }
5475 right_key__ =
5476 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5477 .into_iter().map(|x| x.0).collect())
5478 ;
5479 }
5480 GeneratedField::Condition => {
5481 if condition__.is_some() {
5482 return Err(serde::de::Error::duplicate_field("condition"));
5483 }
5484 condition__ = map_.next_value()?;
5485 }
5486 GeneratedField::InequalityPairs => {
5487 if inequality_pairs__.is_some() {
5488 return Err(serde::de::Error::duplicate_field("inequalityPairs"));
5489 }
5490 inequality_pairs__ = Some(map_.next_value()?);
5491 }
5492 GeneratedField::LeftTable => {
5493 if left_table__.is_some() {
5494 return Err(serde::de::Error::duplicate_field("leftTable"));
5495 }
5496 left_table__ = map_.next_value()?;
5497 }
5498 GeneratedField::RightTable => {
5499 if right_table__.is_some() {
5500 return Err(serde::de::Error::duplicate_field("rightTable"));
5501 }
5502 right_table__ = map_.next_value()?;
5503 }
5504 GeneratedField::LeftDegreeTable => {
5505 if left_degree_table__.is_some() {
5506 return Err(serde::de::Error::duplicate_field("leftDegreeTable"));
5507 }
5508 left_degree_table__ = map_.next_value()?;
5509 }
5510 GeneratedField::RightDegreeTable => {
5511 if right_degree_table__.is_some() {
5512 return Err(serde::de::Error::duplicate_field("rightDegreeTable"));
5513 }
5514 right_degree_table__ = map_.next_value()?;
5515 }
5516 GeneratedField::OutputIndices => {
5517 if output_indices__.is_some() {
5518 return Err(serde::de::Error::duplicate_field("outputIndices"));
5519 }
5520 output_indices__ =
5521 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5522 .into_iter().map(|x| x.0).collect())
5523 ;
5524 }
5525 GeneratedField::LeftDedupedInputPkIndices => {
5526 if left_deduped_input_pk_indices__.is_some() {
5527 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
5528 }
5529 left_deduped_input_pk_indices__ =
5530 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5531 .into_iter().map(|x| x.0).collect())
5532 ;
5533 }
5534 GeneratedField::RightDedupedInputPkIndices => {
5535 if right_deduped_input_pk_indices__.is_some() {
5536 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
5537 }
5538 right_deduped_input_pk_indices__ =
5539 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5540 .into_iter().map(|x| x.0).collect())
5541 ;
5542 }
5543 GeneratedField::NullSafe => {
5544 if null_safe__.is_some() {
5545 return Err(serde::de::Error::duplicate_field("nullSafe"));
5546 }
5547 null_safe__ = Some(map_.next_value()?);
5548 }
5549 GeneratedField::IsAppendOnly => {
5550 if is_append_only__.is_some() {
5551 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
5552 }
5553 is_append_only__ = Some(map_.next_value()?);
5554 }
5555 GeneratedField::JoinEncodingType => {
5556 if join_encoding_type__.is_some() {
5557 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
5558 }
5559 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
5560 }
5561 }
5562 }
5563 Ok(HashJoinNode {
5564 join_type: join_type__.unwrap_or_default(),
5565 left_key: left_key__.unwrap_or_default(),
5566 right_key: right_key__.unwrap_or_default(),
5567 condition: condition__,
5568 inequality_pairs: inequality_pairs__.unwrap_or_default(),
5569 left_table: left_table__,
5570 right_table: right_table__,
5571 left_degree_table: left_degree_table__,
5572 right_degree_table: right_degree_table__,
5573 output_indices: output_indices__.unwrap_or_default(),
5574 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
5575 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
5576 null_safe: null_safe__.unwrap_or_default(),
5577 is_append_only: is_append_only__.unwrap_or_default(),
5578 join_encoding_type: join_encoding_type__.unwrap_or_default(),
5579 })
5580 }
5581 }
5582 deserializer.deserialize_struct("stream_plan.HashJoinNode", FIELDS, GeneratedVisitor)
5583 }
5584}
5585impl serde::Serialize for HopWindowNode {
5586 #[allow(deprecated)]
5587 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5588 where
5589 S: serde::Serializer,
5590 {
5591 use serde::ser::SerializeStruct;
5592 let mut len = 0;
5593 if self.time_col != 0 {
5594 len += 1;
5595 }
5596 if self.window_slide.is_some() {
5597 len += 1;
5598 }
5599 if self.window_size.is_some() {
5600 len += 1;
5601 }
5602 if !self.output_indices.is_empty() {
5603 len += 1;
5604 }
5605 if !self.window_start_exprs.is_empty() {
5606 len += 1;
5607 }
5608 if !self.window_end_exprs.is_empty() {
5609 len += 1;
5610 }
5611 let mut struct_ser = serializer.serialize_struct("stream_plan.HopWindowNode", len)?;
5612 if self.time_col != 0 {
5613 struct_ser.serialize_field("timeCol", &self.time_col)?;
5614 }
5615 if let Some(v) = self.window_slide.as_ref() {
5616 struct_ser.serialize_field("windowSlide", v)?;
5617 }
5618 if let Some(v) = self.window_size.as_ref() {
5619 struct_ser.serialize_field("windowSize", v)?;
5620 }
5621 if !self.output_indices.is_empty() {
5622 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
5623 }
5624 if !self.window_start_exprs.is_empty() {
5625 struct_ser.serialize_field("windowStartExprs", &self.window_start_exprs)?;
5626 }
5627 if !self.window_end_exprs.is_empty() {
5628 struct_ser.serialize_field("windowEndExprs", &self.window_end_exprs)?;
5629 }
5630 struct_ser.end()
5631 }
5632}
5633impl<'de> serde::Deserialize<'de> for HopWindowNode {
5634 #[allow(deprecated)]
5635 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5636 where
5637 D: serde::Deserializer<'de>,
5638 {
5639 const FIELDS: &[&str] = &[
5640 "time_col",
5641 "timeCol",
5642 "window_slide",
5643 "windowSlide",
5644 "window_size",
5645 "windowSize",
5646 "output_indices",
5647 "outputIndices",
5648 "window_start_exprs",
5649 "windowStartExprs",
5650 "window_end_exprs",
5651 "windowEndExprs",
5652 ];
5653
5654 #[allow(clippy::enum_variant_names)]
5655 enum GeneratedField {
5656 TimeCol,
5657 WindowSlide,
5658 WindowSize,
5659 OutputIndices,
5660 WindowStartExprs,
5661 WindowEndExprs,
5662 }
5663 impl<'de> serde::Deserialize<'de> for GeneratedField {
5664 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5665 where
5666 D: serde::Deserializer<'de>,
5667 {
5668 struct GeneratedVisitor;
5669
5670 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5671 type Value = GeneratedField;
5672
5673 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5674 write!(formatter, "expected one of: {:?}", &FIELDS)
5675 }
5676
5677 #[allow(unused_variables)]
5678 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5679 where
5680 E: serde::de::Error,
5681 {
5682 match value {
5683 "timeCol" | "time_col" => Ok(GeneratedField::TimeCol),
5684 "windowSlide" | "window_slide" => Ok(GeneratedField::WindowSlide),
5685 "windowSize" | "window_size" => Ok(GeneratedField::WindowSize),
5686 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
5687 "windowStartExprs" | "window_start_exprs" => Ok(GeneratedField::WindowStartExprs),
5688 "windowEndExprs" | "window_end_exprs" => Ok(GeneratedField::WindowEndExprs),
5689 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5690 }
5691 }
5692 }
5693 deserializer.deserialize_identifier(GeneratedVisitor)
5694 }
5695 }
5696 struct GeneratedVisitor;
5697 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5698 type Value = HopWindowNode;
5699
5700 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5701 formatter.write_str("struct stream_plan.HopWindowNode")
5702 }
5703
5704 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HopWindowNode, V::Error>
5705 where
5706 V: serde::de::MapAccess<'de>,
5707 {
5708 let mut time_col__ = None;
5709 let mut window_slide__ = None;
5710 let mut window_size__ = None;
5711 let mut output_indices__ = None;
5712 let mut window_start_exprs__ = None;
5713 let mut window_end_exprs__ = None;
5714 while let Some(k) = map_.next_key()? {
5715 match k {
5716 GeneratedField::TimeCol => {
5717 if time_col__.is_some() {
5718 return Err(serde::de::Error::duplicate_field("timeCol"));
5719 }
5720 time_col__ =
5721 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5722 ;
5723 }
5724 GeneratedField::WindowSlide => {
5725 if window_slide__.is_some() {
5726 return Err(serde::de::Error::duplicate_field("windowSlide"));
5727 }
5728 window_slide__ = map_.next_value()?;
5729 }
5730 GeneratedField::WindowSize => {
5731 if window_size__.is_some() {
5732 return Err(serde::de::Error::duplicate_field("windowSize"));
5733 }
5734 window_size__ = map_.next_value()?;
5735 }
5736 GeneratedField::OutputIndices => {
5737 if output_indices__.is_some() {
5738 return Err(serde::de::Error::duplicate_field("outputIndices"));
5739 }
5740 output_indices__ =
5741 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5742 .into_iter().map(|x| x.0).collect())
5743 ;
5744 }
5745 GeneratedField::WindowStartExprs => {
5746 if window_start_exprs__.is_some() {
5747 return Err(serde::de::Error::duplicate_field("windowStartExprs"));
5748 }
5749 window_start_exprs__ = Some(map_.next_value()?);
5750 }
5751 GeneratedField::WindowEndExprs => {
5752 if window_end_exprs__.is_some() {
5753 return Err(serde::de::Error::duplicate_field("windowEndExprs"));
5754 }
5755 window_end_exprs__ = Some(map_.next_value()?);
5756 }
5757 }
5758 }
5759 Ok(HopWindowNode {
5760 time_col: time_col__.unwrap_or_default(),
5761 window_slide: window_slide__,
5762 window_size: window_size__,
5763 output_indices: output_indices__.unwrap_or_default(),
5764 window_start_exprs: window_start_exprs__.unwrap_or_default(),
5765 window_end_exprs: window_end_exprs__.unwrap_or_default(),
5766 })
5767 }
5768 }
5769 deserializer.deserialize_struct("stream_plan.HopWindowNode", FIELDS, GeneratedVisitor)
5770 }
5771}
5772impl serde::Serialize for InequalityPair {
5773 #[allow(deprecated)]
5774 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5775 where
5776 S: serde::Serializer,
5777 {
5778 use serde::ser::SerializeStruct;
5779 let mut len = 0;
5780 if self.key_required_larger != 0 {
5781 len += 1;
5782 }
5783 if self.key_required_smaller != 0 {
5784 len += 1;
5785 }
5786 if self.clean_state {
5787 len += 1;
5788 }
5789 if self.delta_expression.is_some() {
5790 len += 1;
5791 }
5792 let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPair", len)?;
5793 if self.key_required_larger != 0 {
5794 struct_ser.serialize_field("keyRequiredLarger", &self.key_required_larger)?;
5795 }
5796 if self.key_required_smaller != 0 {
5797 struct_ser.serialize_field("keyRequiredSmaller", &self.key_required_smaller)?;
5798 }
5799 if self.clean_state {
5800 struct_ser.serialize_field("cleanState", &self.clean_state)?;
5801 }
5802 if let Some(v) = self.delta_expression.as_ref() {
5803 struct_ser.serialize_field("deltaExpression", v)?;
5804 }
5805 struct_ser.end()
5806 }
5807}
5808impl<'de> serde::Deserialize<'de> for InequalityPair {
5809 #[allow(deprecated)]
5810 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5811 where
5812 D: serde::Deserializer<'de>,
5813 {
5814 const FIELDS: &[&str] = &[
5815 "key_required_larger",
5816 "keyRequiredLarger",
5817 "key_required_smaller",
5818 "keyRequiredSmaller",
5819 "clean_state",
5820 "cleanState",
5821 "delta_expression",
5822 "deltaExpression",
5823 ];
5824
5825 #[allow(clippy::enum_variant_names)]
5826 enum GeneratedField {
5827 KeyRequiredLarger,
5828 KeyRequiredSmaller,
5829 CleanState,
5830 DeltaExpression,
5831 }
5832 impl<'de> serde::Deserialize<'de> for GeneratedField {
5833 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5834 where
5835 D: serde::Deserializer<'de>,
5836 {
5837 struct GeneratedVisitor;
5838
5839 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5840 type Value = GeneratedField;
5841
5842 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5843 write!(formatter, "expected one of: {:?}", &FIELDS)
5844 }
5845
5846 #[allow(unused_variables)]
5847 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5848 where
5849 E: serde::de::Error,
5850 {
5851 match value {
5852 "keyRequiredLarger" | "key_required_larger" => Ok(GeneratedField::KeyRequiredLarger),
5853 "keyRequiredSmaller" | "key_required_smaller" => Ok(GeneratedField::KeyRequiredSmaller),
5854 "cleanState" | "clean_state" => Ok(GeneratedField::CleanState),
5855 "deltaExpression" | "delta_expression" => Ok(GeneratedField::DeltaExpression),
5856 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5857 }
5858 }
5859 }
5860 deserializer.deserialize_identifier(GeneratedVisitor)
5861 }
5862 }
5863 struct GeneratedVisitor;
5864 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5865 type Value = InequalityPair;
5866
5867 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5868 formatter.write_str("struct stream_plan.InequalityPair")
5869 }
5870
5871 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPair, V::Error>
5872 where
5873 V: serde::de::MapAccess<'de>,
5874 {
5875 let mut key_required_larger__ = None;
5876 let mut key_required_smaller__ = None;
5877 let mut clean_state__ = None;
5878 let mut delta_expression__ = None;
5879 while let Some(k) = map_.next_key()? {
5880 match k {
5881 GeneratedField::KeyRequiredLarger => {
5882 if key_required_larger__.is_some() {
5883 return Err(serde::de::Error::duplicate_field("keyRequiredLarger"));
5884 }
5885 key_required_larger__ =
5886 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5887 ;
5888 }
5889 GeneratedField::KeyRequiredSmaller => {
5890 if key_required_smaller__.is_some() {
5891 return Err(serde::de::Error::duplicate_field("keyRequiredSmaller"));
5892 }
5893 key_required_smaller__ =
5894 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5895 ;
5896 }
5897 GeneratedField::CleanState => {
5898 if clean_state__.is_some() {
5899 return Err(serde::de::Error::duplicate_field("cleanState"));
5900 }
5901 clean_state__ = Some(map_.next_value()?);
5902 }
5903 GeneratedField::DeltaExpression => {
5904 if delta_expression__.is_some() {
5905 return Err(serde::de::Error::duplicate_field("deltaExpression"));
5906 }
5907 delta_expression__ = map_.next_value()?;
5908 }
5909 }
5910 }
5911 Ok(InequalityPair {
5912 key_required_larger: key_required_larger__.unwrap_or_default(),
5913 key_required_smaller: key_required_smaller__.unwrap_or_default(),
5914 clean_state: clean_state__.unwrap_or_default(),
5915 delta_expression: delta_expression__,
5916 })
5917 }
5918 }
5919 deserializer.deserialize_struct("stream_plan.InequalityPair", FIELDS, GeneratedVisitor)
5920 }
5921}
5922impl serde::Serialize for JoinEncodingType {
5923 #[allow(deprecated)]
5924 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5925 where
5926 S: serde::Serializer,
5927 {
5928 let variant = match self {
5929 Self::Unspecified => "UNSPECIFIED",
5930 Self::MemoryOptimized => "MEMORY_OPTIMIZED",
5931 Self::CpuOptimized => "CPU_OPTIMIZED",
5932 };
5933 serializer.serialize_str(variant)
5934 }
5935}
5936impl<'de> serde::Deserialize<'de> for JoinEncodingType {
5937 #[allow(deprecated)]
5938 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5939 where
5940 D: serde::Deserializer<'de>,
5941 {
5942 const FIELDS: &[&str] = &[
5943 "UNSPECIFIED",
5944 "MEMORY_OPTIMIZED",
5945 "CPU_OPTIMIZED",
5946 ];
5947
5948 struct GeneratedVisitor;
5949
5950 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5951 type Value = JoinEncodingType;
5952
5953 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5954 write!(formatter, "expected one of: {:?}", &FIELDS)
5955 }
5956
5957 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
5958 where
5959 E: serde::de::Error,
5960 {
5961 i32::try_from(v)
5962 .ok()
5963 .and_then(|x| x.try_into().ok())
5964 .ok_or_else(|| {
5965 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
5966 })
5967 }
5968
5969 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
5970 where
5971 E: serde::de::Error,
5972 {
5973 i32::try_from(v)
5974 .ok()
5975 .and_then(|x| x.try_into().ok())
5976 .ok_or_else(|| {
5977 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
5978 })
5979 }
5980
5981 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
5982 where
5983 E: serde::de::Error,
5984 {
5985 match value {
5986 "UNSPECIFIED" => Ok(JoinEncodingType::Unspecified),
5987 "MEMORY_OPTIMIZED" => Ok(JoinEncodingType::MemoryOptimized),
5988 "CPU_OPTIMIZED" => Ok(JoinEncodingType::CpuOptimized),
5989 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
5990 }
5991 }
5992 }
5993 deserializer.deserialize_any(GeneratedVisitor)
5994 }
5995}
5996impl serde::Serialize for LocalApproxPercentileNode {
5997 #[allow(deprecated)]
5998 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5999 where
6000 S: serde::Serializer,
6001 {
6002 use serde::ser::SerializeStruct;
6003 let mut len = 0;
6004 if self.base != 0. {
6005 len += 1;
6006 }
6007 if self.percentile_index != 0 {
6008 len += 1;
6009 }
6010 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalApproxPercentileNode", len)?;
6011 if self.base != 0. {
6012 struct_ser.serialize_field("base", &self.base)?;
6013 }
6014 if self.percentile_index != 0 {
6015 struct_ser.serialize_field("percentileIndex", &self.percentile_index)?;
6016 }
6017 struct_ser.end()
6018 }
6019}
6020impl<'de> serde::Deserialize<'de> for LocalApproxPercentileNode {
6021 #[allow(deprecated)]
6022 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6023 where
6024 D: serde::Deserializer<'de>,
6025 {
6026 const FIELDS: &[&str] = &[
6027 "base",
6028 "percentile_index",
6029 "percentileIndex",
6030 ];
6031
6032 #[allow(clippy::enum_variant_names)]
6033 enum GeneratedField {
6034 Base,
6035 PercentileIndex,
6036 }
6037 impl<'de> serde::Deserialize<'de> for GeneratedField {
6038 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6039 where
6040 D: serde::Deserializer<'de>,
6041 {
6042 struct GeneratedVisitor;
6043
6044 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6045 type Value = GeneratedField;
6046
6047 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6048 write!(formatter, "expected one of: {:?}", &FIELDS)
6049 }
6050
6051 #[allow(unused_variables)]
6052 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6053 where
6054 E: serde::de::Error,
6055 {
6056 match value {
6057 "base" => Ok(GeneratedField::Base),
6058 "percentileIndex" | "percentile_index" => Ok(GeneratedField::PercentileIndex),
6059 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6060 }
6061 }
6062 }
6063 deserializer.deserialize_identifier(GeneratedVisitor)
6064 }
6065 }
6066 struct GeneratedVisitor;
6067 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6068 type Value = LocalApproxPercentileNode;
6069
6070 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6071 formatter.write_str("struct stream_plan.LocalApproxPercentileNode")
6072 }
6073
6074 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalApproxPercentileNode, V::Error>
6075 where
6076 V: serde::de::MapAccess<'de>,
6077 {
6078 let mut base__ = None;
6079 let mut percentile_index__ = None;
6080 while let Some(k) = map_.next_key()? {
6081 match k {
6082 GeneratedField::Base => {
6083 if base__.is_some() {
6084 return Err(serde::de::Error::duplicate_field("base"));
6085 }
6086 base__ =
6087 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6088 ;
6089 }
6090 GeneratedField::PercentileIndex => {
6091 if percentile_index__.is_some() {
6092 return Err(serde::de::Error::duplicate_field("percentileIndex"));
6093 }
6094 percentile_index__ =
6095 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6096 ;
6097 }
6098 }
6099 }
6100 Ok(LocalApproxPercentileNode {
6101 base: base__.unwrap_or_default(),
6102 percentile_index: percentile_index__.unwrap_or_default(),
6103 })
6104 }
6105 }
6106 deserializer.deserialize_struct("stream_plan.LocalApproxPercentileNode", FIELDS, GeneratedVisitor)
6107 }
6108}
6109impl serde::Serialize for LookupNode {
6110 #[allow(deprecated)]
6111 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6112 where
6113 S: serde::Serializer,
6114 {
6115 use serde::ser::SerializeStruct;
6116 let mut len = 0;
6117 if !self.arrange_key.is_empty() {
6118 len += 1;
6119 }
6120 if !self.stream_key.is_empty() {
6121 len += 1;
6122 }
6123 if self.use_current_epoch {
6124 len += 1;
6125 }
6126 if !self.column_mapping.is_empty() {
6127 len += 1;
6128 }
6129 if self.arrangement_table_info.is_some() {
6130 len += 1;
6131 }
6132 if self.arrangement_table_id.is_some() {
6133 len += 1;
6134 }
6135 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupNode", len)?;
6136 if !self.arrange_key.is_empty() {
6137 struct_ser.serialize_field("arrangeKey", &self.arrange_key)?;
6138 }
6139 if !self.stream_key.is_empty() {
6140 struct_ser.serialize_field("streamKey", &self.stream_key)?;
6141 }
6142 if self.use_current_epoch {
6143 struct_ser.serialize_field("useCurrentEpoch", &self.use_current_epoch)?;
6144 }
6145 if !self.column_mapping.is_empty() {
6146 struct_ser.serialize_field("columnMapping", &self.column_mapping)?;
6147 }
6148 if let Some(v) = self.arrangement_table_info.as_ref() {
6149 struct_ser.serialize_field("arrangementTableInfo", v)?;
6150 }
6151 if let Some(v) = self.arrangement_table_id.as_ref() {
6152 match v {
6153 lookup_node::ArrangementTableId::TableId(v) => {
6154 struct_ser.serialize_field("tableId", v)?;
6155 }
6156 lookup_node::ArrangementTableId::IndexId(v) => {
6157 struct_ser.serialize_field("indexId", v)?;
6158 }
6159 }
6160 }
6161 struct_ser.end()
6162 }
6163}
6164impl<'de> serde::Deserialize<'de> for LookupNode {
6165 #[allow(deprecated)]
6166 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6167 where
6168 D: serde::Deserializer<'de>,
6169 {
6170 const FIELDS: &[&str] = &[
6171 "arrange_key",
6172 "arrangeKey",
6173 "stream_key",
6174 "streamKey",
6175 "use_current_epoch",
6176 "useCurrentEpoch",
6177 "column_mapping",
6178 "columnMapping",
6179 "arrangement_table_info",
6180 "arrangementTableInfo",
6181 "table_id",
6182 "tableId",
6183 "index_id",
6184 "indexId",
6185 ];
6186
6187 #[allow(clippy::enum_variant_names)]
6188 enum GeneratedField {
6189 ArrangeKey,
6190 StreamKey,
6191 UseCurrentEpoch,
6192 ColumnMapping,
6193 ArrangementTableInfo,
6194 TableId,
6195 IndexId,
6196 }
6197 impl<'de> serde::Deserialize<'de> for GeneratedField {
6198 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6199 where
6200 D: serde::Deserializer<'de>,
6201 {
6202 struct GeneratedVisitor;
6203
6204 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6205 type Value = GeneratedField;
6206
6207 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6208 write!(formatter, "expected one of: {:?}", &FIELDS)
6209 }
6210
6211 #[allow(unused_variables)]
6212 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6213 where
6214 E: serde::de::Error,
6215 {
6216 match value {
6217 "arrangeKey" | "arrange_key" => Ok(GeneratedField::ArrangeKey),
6218 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
6219 "useCurrentEpoch" | "use_current_epoch" => Ok(GeneratedField::UseCurrentEpoch),
6220 "columnMapping" | "column_mapping" => Ok(GeneratedField::ColumnMapping),
6221 "arrangementTableInfo" | "arrangement_table_info" => Ok(GeneratedField::ArrangementTableInfo),
6222 "tableId" | "table_id" => Ok(GeneratedField::TableId),
6223 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
6224 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6225 }
6226 }
6227 }
6228 deserializer.deserialize_identifier(GeneratedVisitor)
6229 }
6230 }
6231 struct GeneratedVisitor;
6232 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6233 type Value = LookupNode;
6234
6235 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6236 formatter.write_str("struct stream_plan.LookupNode")
6237 }
6238
6239 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupNode, V::Error>
6240 where
6241 V: serde::de::MapAccess<'de>,
6242 {
6243 let mut arrange_key__ = None;
6244 let mut stream_key__ = None;
6245 let mut use_current_epoch__ = None;
6246 let mut column_mapping__ = None;
6247 let mut arrangement_table_info__ = None;
6248 let mut arrangement_table_id__ = None;
6249 while let Some(k) = map_.next_key()? {
6250 match k {
6251 GeneratedField::ArrangeKey => {
6252 if arrange_key__.is_some() {
6253 return Err(serde::de::Error::duplicate_field("arrangeKey"));
6254 }
6255 arrange_key__ =
6256 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6257 .into_iter().map(|x| x.0).collect())
6258 ;
6259 }
6260 GeneratedField::StreamKey => {
6261 if stream_key__.is_some() {
6262 return Err(serde::de::Error::duplicate_field("streamKey"));
6263 }
6264 stream_key__ =
6265 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6266 .into_iter().map(|x| x.0).collect())
6267 ;
6268 }
6269 GeneratedField::UseCurrentEpoch => {
6270 if use_current_epoch__.is_some() {
6271 return Err(serde::de::Error::duplicate_field("useCurrentEpoch"));
6272 }
6273 use_current_epoch__ = Some(map_.next_value()?);
6274 }
6275 GeneratedField::ColumnMapping => {
6276 if column_mapping__.is_some() {
6277 return Err(serde::de::Error::duplicate_field("columnMapping"));
6278 }
6279 column_mapping__ =
6280 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6281 .into_iter().map(|x| x.0).collect())
6282 ;
6283 }
6284 GeneratedField::ArrangementTableInfo => {
6285 if arrangement_table_info__.is_some() {
6286 return Err(serde::de::Error::duplicate_field("arrangementTableInfo"));
6287 }
6288 arrangement_table_info__ = map_.next_value()?;
6289 }
6290 GeneratedField::TableId => {
6291 if arrangement_table_id__.is_some() {
6292 return Err(serde::de::Error::duplicate_field("tableId"));
6293 }
6294 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::TableId(x.0));
6295 }
6296 GeneratedField::IndexId => {
6297 if arrangement_table_id__.is_some() {
6298 return Err(serde::de::Error::duplicate_field("indexId"));
6299 }
6300 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::IndexId(x.0));
6301 }
6302 }
6303 }
6304 Ok(LookupNode {
6305 arrange_key: arrange_key__.unwrap_or_default(),
6306 stream_key: stream_key__.unwrap_or_default(),
6307 use_current_epoch: use_current_epoch__.unwrap_or_default(),
6308 column_mapping: column_mapping__.unwrap_or_default(),
6309 arrangement_table_info: arrangement_table_info__,
6310 arrangement_table_id: arrangement_table_id__,
6311 })
6312 }
6313 }
6314 deserializer.deserialize_struct("stream_plan.LookupNode", FIELDS, GeneratedVisitor)
6315 }
6316}
6317impl serde::Serialize for LookupUnionNode {
6318 #[allow(deprecated)]
6319 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6320 where
6321 S: serde::Serializer,
6322 {
6323 use serde::ser::SerializeStruct;
6324 let mut len = 0;
6325 if !self.order.is_empty() {
6326 len += 1;
6327 }
6328 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupUnionNode", len)?;
6329 if !self.order.is_empty() {
6330 struct_ser.serialize_field("order", &self.order)?;
6331 }
6332 struct_ser.end()
6333 }
6334}
6335impl<'de> serde::Deserialize<'de> for LookupUnionNode {
6336 #[allow(deprecated)]
6337 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6338 where
6339 D: serde::Deserializer<'de>,
6340 {
6341 const FIELDS: &[&str] = &[
6342 "order",
6343 ];
6344
6345 #[allow(clippy::enum_variant_names)]
6346 enum GeneratedField {
6347 Order,
6348 }
6349 impl<'de> serde::Deserialize<'de> for GeneratedField {
6350 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6351 where
6352 D: serde::Deserializer<'de>,
6353 {
6354 struct GeneratedVisitor;
6355
6356 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6357 type Value = GeneratedField;
6358
6359 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6360 write!(formatter, "expected one of: {:?}", &FIELDS)
6361 }
6362
6363 #[allow(unused_variables)]
6364 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6365 where
6366 E: serde::de::Error,
6367 {
6368 match value {
6369 "order" => Ok(GeneratedField::Order),
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 = LookupUnionNode;
6380
6381 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6382 formatter.write_str("struct stream_plan.LookupUnionNode")
6383 }
6384
6385 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupUnionNode, V::Error>
6386 where
6387 V: serde::de::MapAccess<'de>,
6388 {
6389 let mut order__ = None;
6390 while let Some(k) = map_.next_key()? {
6391 match k {
6392 GeneratedField::Order => {
6393 if order__.is_some() {
6394 return Err(serde::de::Error::duplicate_field("order"));
6395 }
6396 order__ =
6397 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6398 .into_iter().map(|x| x.0).collect())
6399 ;
6400 }
6401 }
6402 }
6403 Ok(LookupUnionNode {
6404 order: order__.unwrap_or_default(),
6405 })
6406 }
6407 }
6408 deserializer.deserialize_struct("stream_plan.LookupUnionNode", FIELDS, GeneratedVisitor)
6409 }
6410}
6411impl serde::Serialize for MaterializeNode {
6412 #[allow(deprecated)]
6413 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6414 where
6415 S: serde::Serializer,
6416 {
6417 use serde::ser::SerializeStruct;
6418 let mut len = 0;
6419 if self.table_id != 0 {
6420 len += 1;
6421 }
6422 if !self.column_orders.is_empty() {
6423 len += 1;
6424 }
6425 if self.table.is_some() {
6426 len += 1;
6427 }
6428 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializeNode", len)?;
6429 if self.table_id != 0 {
6430 struct_ser.serialize_field("tableId", &self.table_id)?;
6431 }
6432 if !self.column_orders.is_empty() {
6433 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
6434 }
6435 if let Some(v) = self.table.as_ref() {
6436 struct_ser.serialize_field("table", v)?;
6437 }
6438 struct_ser.end()
6439 }
6440}
6441impl<'de> serde::Deserialize<'de> for MaterializeNode {
6442 #[allow(deprecated)]
6443 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6444 where
6445 D: serde::Deserializer<'de>,
6446 {
6447 const FIELDS: &[&str] = &[
6448 "table_id",
6449 "tableId",
6450 "column_orders",
6451 "columnOrders",
6452 "table",
6453 ];
6454
6455 #[allow(clippy::enum_variant_names)]
6456 enum GeneratedField {
6457 TableId,
6458 ColumnOrders,
6459 Table,
6460 }
6461 impl<'de> serde::Deserialize<'de> for GeneratedField {
6462 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6463 where
6464 D: serde::Deserializer<'de>,
6465 {
6466 struct GeneratedVisitor;
6467
6468 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6469 type Value = GeneratedField;
6470
6471 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6472 write!(formatter, "expected one of: {:?}", &FIELDS)
6473 }
6474
6475 #[allow(unused_variables)]
6476 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6477 where
6478 E: serde::de::Error,
6479 {
6480 match value {
6481 "tableId" | "table_id" => Ok(GeneratedField::TableId),
6482 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
6483 "table" => Ok(GeneratedField::Table),
6484 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6485 }
6486 }
6487 }
6488 deserializer.deserialize_identifier(GeneratedVisitor)
6489 }
6490 }
6491 struct GeneratedVisitor;
6492 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6493 type Value = MaterializeNode;
6494
6495 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6496 formatter.write_str("struct stream_plan.MaterializeNode")
6497 }
6498
6499 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializeNode, V::Error>
6500 where
6501 V: serde::de::MapAccess<'de>,
6502 {
6503 let mut table_id__ = None;
6504 let mut column_orders__ = None;
6505 let mut table__ = None;
6506 while let Some(k) = map_.next_key()? {
6507 match k {
6508 GeneratedField::TableId => {
6509 if table_id__.is_some() {
6510 return Err(serde::de::Error::duplicate_field("tableId"));
6511 }
6512 table_id__ =
6513 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6514 ;
6515 }
6516 GeneratedField::ColumnOrders => {
6517 if column_orders__.is_some() {
6518 return Err(serde::de::Error::duplicate_field("columnOrders"));
6519 }
6520 column_orders__ = Some(map_.next_value()?);
6521 }
6522 GeneratedField::Table => {
6523 if table__.is_some() {
6524 return Err(serde::de::Error::duplicate_field("table"));
6525 }
6526 table__ = map_.next_value()?;
6527 }
6528 }
6529 }
6530 Ok(MaterializeNode {
6531 table_id: table_id__.unwrap_or_default(),
6532 column_orders: column_orders__.unwrap_or_default(),
6533 table: table__,
6534 })
6535 }
6536 }
6537 deserializer.deserialize_struct("stream_plan.MaterializeNode", FIELDS, GeneratedVisitor)
6538 }
6539}
6540impl serde::Serialize for MaterializedExprsNode {
6541 #[allow(deprecated)]
6542 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6543 where
6544 S: serde::Serializer,
6545 {
6546 use serde::ser::SerializeStruct;
6547 let mut len = 0;
6548 if !self.exprs.is_empty() {
6549 len += 1;
6550 }
6551 if self.state_table.is_some() {
6552 len += 1;
6553 }
6554 if self.state_clean_col_idx.is_some() {
6555 len += 1;
6556 }
6557 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializedExprsNode", len)?;
6558 if !self.exprs.is_empty() {
6559 struct_ser.serialize_field("exprs", &self.exprs)?;
6560 }
6561 if let Some(v) = self.state_table.as_ref() {
6562 struct_ser.serialize_field("stateTable", v)?;
6563 }
6564 if let Some(v) = self.state_clean_col_idx.as_ref() {
6565 struct_ser.serialize_field("stateCleanColIdx", v)?;
6566 }
6567 struct_ser.end()
6568 }
6569}
6570impl<'de> serde::Deserialize<'de> for MaterializedExprsNode {
6571 #[allow(deprecated)]
6572 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6573 where
6574 D: serde::Deserializer<'de>,
6575 {
6576 const FIELDS: &[&str] = &[
6577 "exprs",
6578 "state_table",
6579 "stateTable",
6580 "state_clean_col_idx",
6581 "stateCleanColIdx",
6582 ];
6583
6584 #[allow(clippy::enum_variant_names)]
6585 enum GeneratedField {
6586 Exprs,
6587 StateTable,
6588 StateCleanColIdx,
6589 }
6590 impl<'de> serde::Deserialize<'de> for GeneratedField {
6591 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6592 where
6593 D: serde::Deserializer<'de>,
6594 {
6595 struct GeneratedVisitor;
6596
6597 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6598 type Value = GeneratedField;
6599
6600 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6601 write!(formatter, "expected one of: {:?}", &FIELDS)
6602 }
6603
6604 #[allow(unused_variables)]
6605 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6606 where
6607 E: serde::de::Error,
6608 {
6609 match value {
6610 "exprs" => Ok(GeneratedField::Exprs),
6611 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
6612 "stateCleanColIdx" | "state_clean_col_idx" => Ok(GeneratedField::StateCleanColIdx),
6613 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6614 }
6615 }
6616 }
6617 deserializer.deserialize_identifier(GeneratedVisitor)
6618 }
6619 }
6620 struct GeneratedVisitor;
6621 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6622 type Value = MaterializedExprsNode;
6623
6624 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6625 formatter.write_str("struct stream_plan.MaterializedExprsNode")
6626 }
6627
6628 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializedExprsNode, V::Error>
6629 where
6630 V: serde::de::MapAccess<'de>,
6631 {
6632 let mut exprs__ = None;
6633 let mut state_table__ = None;
6634 let mut state_clean_col_idx__ = None;
6635 while let Some(k) = map_.next_key()? {
6636 match k {
6637 GeneratedField::Exprs => {
6638 if exprs__.is_some() {
6639 return Err(serde::de::Error::duplicate_field("exprs"));
6640 }
6641 exprs__ = Some(map_.next_value()?);
6642 }
6643 GeneratedField::StateTable => {
6644 if state_table__.is_some() {
6645 return Err(serde::de::Error::duplicate_field("stateTable"));
6646 }
6647 state_table__ = map_.next_value()?;
6648 }
6649 GeneratedField::StateCleanColIdx => {
6650 if state_clean_col_idx__.is_some() {
6651 return Err(serde::de::Error::duplicate_field("stateCleanColIdx"));
6652 }
6653 state_clean_col_idx__ =
6654 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6655 ;
6656 }
6657 }
6658 }
6659 Ok(MaterializedExprsNode {
6660 exprs: exprs__.unwrap_or_default(),
6661 state_table: state_table__,
6662 state_clean_col_idx: state_clean_col_idx__,
6663 })
6664 }
6665 }
6666 deserializer.deserialize_struct("stream_plan.MaterializedExprsNode", FIELDS, GeneratedVisitor)
6667 }
6668}
6669impl serde::Serialize for MergeNode {
6670 #[allow(deprecated)]
6671 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6672 where
6673 S: serde::Serializer,
6674 {
6675 use serde::ser::SerializeStruct;
6676 let mut len = 0;
6677 if !self.upstream_actor_id.is_empty() {
6678 len += 1;
6679 }
6680 if self.upstream_fragment_id != 0 {
6681 len += 1;
6682 }
6683 if self.upstream_dispatcher_type != 0 {
6684 len += 1;
6685 }
6686 if !self.fields.is_empty() {
6687 len += 1;
6688 }
6689 let mut struct_ser = serializer.serialize_struct("stream_plan.MergeNode", len)?;
6690 if !self.upstream_actor_id.is_empty() {
6691 struct_ser.serialize_field("upstreamActorId", &self.upstream_actor_id)?;
6692 }
6693 if self.upstream_fragment_id != 0 {
6694 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
6695 }
6696 if self.upstream_dispatcher_type != 0 {
6697 let v = DispatcherType::try_from(self.upstream_dispatcher_type)
6698 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.upstream_dispatcher_type)))?;
6699 struct_ser.serialize_field("upstreamDispatcherType", &v)?;
6700 }
6701 if !self.fields.is_empty() {
6702 struct_ser.serialize_field("fields", &self.fields)?;
6703 }
6704 struct_ser.end()
6705 }
6706}
6707impl<'de> serde::Deserialize<'de> for MergeNode {
6708 #[allow(deprecated)]
6709 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6710 where
6711 D: serde::Deserializer<'de>,
6712 {
6713 const FIELDS: &[&str] = &[
6714 "upstream_actor_id",
6715 "upstreamActorId",
6716 "upstream_fragment_id",
6717 "upstreamFragmentId",
6718 "upstream_dispatcher_type",
6719 "upstreamDispatcherType",
6720 "fields",
6721 ];
6722
6723 #[allow(clippy::enum_variant_names)]
6724 enum GeneratedField {
6725 UpstreamActorId,
6726 UpstreamFragmentId,
6727 UpstreamDispatcherType,
6728 Fields,
6729 }
6730 impl<'de> serde::Deserialize<'de> for GeneratedField {
6731 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6732 where
6733 D: serde::Deserializer<'de>,
6734 {
6735 struct GeneratedVisitor;
6736
6737 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6738 type Value = GeneratedField;
6739
6740 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6741 write!(formatter, "expected one of: {:?}", &FIELDS)
6742 }
6743
6744 #[allow(unused_variables)]
6745 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6746 where
6747 E: serde::de::Error,
6748 {
6749 match value {
6750 "upstreamActorId" | "upstream_actor_id" => Ok(GeneratedField::UpstreamActorId),
6751 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
6752 "upstreamDispatcherType" | "upstream_dispatcher_type" => Ok(GeneratedField::UpstreamDispatcherType),
6753 "fields" => Ok(GeneratedField::Fields),
6754 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6755 }
6756 }
6757 }
6758 deserializer.deserialize_identifier(GeneratedVisitor)
6759 }
6760 }
6761 struct GeneratedVisitor;
6762 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6763 type Value = MergeNode;
6764
6765 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6766 formatter.write_str("struct stream_plan.MergeNode")
6767 }
6768
6769 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeNode, V::Error>
6770 where
6771 V: serde::de::MapAccess<'de>,
6772 {
6773 let mut upstream_actor_id__ = None;
6774 let mut upstream_fragment_id__ = None;
6775 let mut upstream_dispatcher_type__ = None;
6776 let mut fields__ = None;
6777 while let Some(k) = map_.next_key()? {
6778 match k {
6779 GeneratedField::UpstreamActorId => {
6780 if upstream_actor_id__.is_some() {
6781 return Err(serde::de::Error::duplicate_field("upstreamActorId"));
6782 }
6783 upstream_actor_id__ =
6784 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6785 .into_iter().map(|x| x.0).collect())
6786 ;
6787 }
6788 GeneratedField::UpstreamFragmentId => {
6789 if upstream_fragment_id__.is_some() {
6790 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
6791 }
6792 upstream_fragment_id__ =
6793 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6794 ;
6795 }
6796 GeneratedField::UpstreamDispatcherType => {
6797 if upstream_dispatcher_type__.is_some() {
6798 return Err(serde::de::Error::duplicate_field("upstreamDispatcherType"));
6799 }
6800 upstream_dispatcher_type__ = Some(map_.next_value::<DispatcherType>()? as i32);
6801 }
6802 GeneratedField::Fields => {
6803 if fields__.is_some() {
6804 return Err(serde::de::Error::duplicate_field("fields"));
6805 }
6806 fields__ = Some(map_.next_value()?);
6807 }
6808 }
6809 }
6810 Ok(MergeNode {
6811 upstream_actor_id: upstream_actor_id__.unwrap_or_default(),
6812 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
6813 upstream_dispatcher_type: upstream_dispatcher_type__.unwrap_or_default(),
6814 fields: fields__.unwrap_or_default(),
6815 })
6816 }
6817 }
6818 deserializer.deserialize_struct("stream_plan.MergeNode", FIELDS, GeneratedVisitor)
6819 }
6820}
6821impl serde::Serialize for NoOpNode {
6822 #[allow(deprecated)]
6823 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6824 where
6825 S: serde::Serializer,
6826 {
6827 use serde::ser::SerializeStruct;
6828 let len = 0;
6829 let struct_ser = serializer.serialize_struct("stream_plan.NoOpNode", len)?;
6830 struct_ser.end()
6831 }
6832}
6833impl<'de> serde::Deserialize<'de> for NoOpNode {
6834 #[allow(deprecated)]
6835 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6836 where
6837 D: serde::Deserializer<'de>,
6838 {
6839 const FIELDS: &[&str] = &[
6840 ];
6841
6842 #[allow(clippy::enum_variant_names)]
6843 enum GeneratedField {
6844 }
6845 impl<'de> serde::Deserialize<'de> for GeneratedField {
6846 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6847 where
6848 D: serde::Deserializer<'de>,
6849 {
6850 struct GeneratedVisitor;
6851
6852 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6853 type Value = GeneratedField;
6854
6855 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6856 write!(formatter, "expected one of: {:?}", &FIELDS)
6857 }
6858
6859 #[allow(unused_variables)]
6860 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6861 where
6862 E: serde::de::Error,
6863 {
6864 Err(serde::de::Error::unknown_field(value, FIELDS))
6865 }
6866 }
6867 deserializer.deserialize_identifier(GeneratedVisitor)
6868 }
6869 }
6870 struct GeneratedVisitor;
6871 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6872 type Value = NoOpNode;
6873
6874 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6875 formatter.write_str("struct stream_plan.NoOpNode")
6876 }
6877
6878 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NoOpNode, V::Error>
6879 where
6880 V: serde::de::MapAccess<'de>,
6881 {
6882 while map_.next_key::<GeneratedField>()?.is_some() {
6883 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6884 }
6885 Ok(NoOpNode {
6886 })
6887 }
6888 }
6889 deserializer.deserialize_struct("stream_plan.NoOpNode", FIELDS, GeneratedVisitor)
6890 }
6891}
6892impl serde::Serialize for NowModeGenerateSeries {
6893 #[allow(deprecated)]
6894 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6895 where
6896 S: serde::Serializer,
6897 {
6898 use serde::ser::SerializeStruct;
6899 let mut len = 0;
6900 if self.start_timestamp.is_some() {
6901 len += 1;
6902 }
6903 if self.interval.is_some() {
6904 len += 1;
6905 }
6906 let mut struct_ser = serializer.serialize_struct("stream_plan.NowModeGenerateSeries", len)?;
6907 if let Some(v) = self.start_timestamp.as_ref() {
6908 struct_ser.serialize_field("startTimestamp", v)?;
6909 }
6910 if let Some(v) = self.interval.as_ref() {
6911 struct_ser.serialize_field("interval", v)?;
6912 }
6913 struct_ser.end()
6914 }
6915}
6916impl<'de> serde::Deserialize<'de> for NowModeGenerateSeries {
6917 #[allow(deprecated)]
6918 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6919 where
6920 D: serde::Deserializer<'de>,
6921 {
6922 const FIELDS: &[&str] = &[
6923 "start_timestamp",
6924 "startTimestamp",
6925 "interval",
6926 ];
6927
6928 #[allow(clippy::enum_variant_names)]
6929 enum GeneratedField {
6930 StartTimestamp,
6931 Interval,
6932 }
6933 impl<'de> serde::Deserialize<'de> for GeneratedField {
6934 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6935 where
6936 D: serde::Deserializer<'de>,
6937 {
6938 struct GeneratedVisitor;
6939
6940 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6941 type Value = GeneratedField;
6942
6943 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6944 write!(formatter, "expected one of: {:?}", &FIELDS)
6945 }
6946
6947 #[allow(unused_variables)]
6948 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6949 where
6950 E: serde::de::Error,
6951 {
6952 match value {
6953 "startTimestamp" | "start_timestamp" => Ok(GeneratedField::StartTimestamp),
6954 "interval" => Ok(GeneratedField::Interval),
6955 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6956 }
6957 }
6958 }
6959 deserializer.deserialize_identifier(GeneratedVisitor)
6960 }
6961 }
6962 struct GeneratedVisitor;
6963 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6964 type Value = NowModeGenerateSeries;
6965
6966 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6967 formatter.write_str("struct stream_plan.NowModeGenerateSeries")
6968 }
6969
6970 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeGenerateSeries, V::Error>
6971 where
6972 V: serde::de::MapAccess<'de>,
6973 {
6974 let mut start_timestamp__ = None;
6975 let mut interval__ = None;
6976 while let Some(k) = map_.next_key()? {
6977 match k {
6978 GeneratedField::StartTimestamp => {
6979 if start_timestamp__.is_some() {
6980 return Err(serde::de::Error::duplicate_field("startTimestamp"));
6981 }
6982 start_timestamp__ = map_.next_value()?;
6983 }
6984 GeneratedField::Interval => {
6985 if interval__.is_some() {
6986 return Err(serde::de::Error::duplicate_field("interval"));
6987 }
6988 interval__ = map_.next_value()?;
6989 }
6990 }
6991 }
6992 Ok(NowModeGenerateSeries {
6993 start_timestamp: start_timestamp__,
6994 interval: interval__,
6995 })
6996 }
6997 }
6998 deserializer.deserialize_struct("stream_plan.NowModeGenerateSeries", FIELDS, GeneratedVisitor)
6999 }
7000}
7001impl serde::Serialize for NowModeUpdateCurrent {
7002 #[allow(deprecated)]
7003 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7004 where
7005 S: serde::Serializer,
7006 {
7007 use serde::ser::SerializeStruct;
7008 let len = 0;
7009 let struct_ser = serializer.serialize_struct("stream_plan.NowModeUpdateCurrent", len)?;
7010 struct_ser.end()
7011 }
7012}
7013impl<'de> serde::Deserialize<'de> for NowModeUpdateCurrent {
7014 #[allow(deprecated)]
7015 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7016 where
7017 D: serde::Deserializer<'de>,
7018 {
7019 const FIELDS: &[&str] = &[
7020 ];
7021
7022 #[allow(clippy::enum_variant_names)]
7023 enum GeneratedField {
7024 }
7025 impl<'de> serde::Deserialize<'de> for GeneratedField {
7026 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7027 where
7028 D: serde::Deserializer<'de>,
7029 {
7030 struct GeneratedVisitor;
7031
7032 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7033 type Value = GeneratedField;
7034
7035 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7036 write!(formatter, "expected one of: {:?}", &FIELDS)
7037 }
7038
7039 #[allow(unused_variables)]
7040 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7041 where
7042 E: serde::de::Error,
7043 {
7044 Err(serde::de::Error::unknown_field(value, FIELDS))
7045 }
7046 }
7047 deserializer.deserialize_identifier(GeneratedVisitor)
7048 }
7049 }
7050 struct GeneratedVisitor;
7051 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7052 type Value = NowModeUpdateCurrent;
7053
7054 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7055 formatter.write_str("struct stream_plan.NowModeUpdateCurrent")
7056 }
7057
7058 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeUpdateCurrent, V::Error>
7059 where
7060 V: serde::de::MapAccess<'de>,
7061 {
7062 while map_.next_key::<GeneratedField>()?.is_some() {
7063 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7064 }
7065 Ok(NowModeUpdateCurrent {
7066 })
7067 }
7068 }
7069 deserializer.deserialize_struct("stream_plan.NowModeUpdateCurrent", FIELDS, GeneratedVisitor)
7070 }
7071}
7072impl serde::Serialize for NowNode {
7073 #[allow(deprecated)]
7074 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7075 where
7076 S: serde::Serializer,
7077 {
7078 use serde::ser::SerializeStruct;
7079 let mut len = 0;
7080 if self.state_table.is_some() {
7081 len += 1;
7082 }
7083 if self.mode.is_some() {
7084 len += 1;
7085 }
7086 let mut struct_ser = serializer.serialize_struct("stream_plan.NowNode", len)?;
7087 if let Some(v) = self.state_table.as_ref() {
7088 struct_ser.serialize_field("stateTable", v)?;
7089 }
7090 if let Some(v) = self.mode.as_ref() {
7091 match v {
7092 now_node::Mode::UpdateCurrent(v) => {
7093 struct_ser.serialize_field("updateCurrent", v)?;
7094 }
7095 now_node::Mode::GenerateSeries(v) => {
7096 struct_ser.serialize_field("generateSeries", v)?;
7097 }
7098 }
7099 }
7100 struct_ser.end()
7101 }
7102}
7103impl<'de> serde::Deserialize<'de> for NowNode {
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 "state_table",
7111 "stateTable",
7112 "update_current",
7113 "updateCurrent",
7114 "generate_series",
7115 "generateSeries",
7116 ];
7117
7118 #[allow(clippy::enum_variant_names)]
7119 enum GeneratedField {
7120 StateTable,
7121 UpdateCurrent,
7122 GenerateSeries,
7123 }
7124 impl<'de> serde::Deserialize<'de> for GeneratedField {
7125 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7126 where
7127 D: serde::Deserializer<'de>,
7128 {
7129 struct GeneratedVisitor;
7130
7131 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7132 type Value = GeneratedField;
7133
7134 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7135 write!(formatter, "expected one of: {:?}", &FIELDS)
7136 }
7137
7138 #[allow(unused_variables)]
7139 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7140 where
7141 E: serde::de::Error,
7142 {
7143 match value {
7144 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7145 "updateCurrent" | "update_current" => Ok(GeneratedField::UpdateCurrent),
7146 "generateSeries" | "generate_series" => Ok(GeneratedField::GenerateSeries),
7147 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7148 }
7149 }
7150 }
7151 deserializer.deserialize_identifier(GeneratedVisitor)
7152 }
7153 }
7154 struct GeneratedVisitor;
7155 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7156 type Value = NowNode;
7157
7158 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7159 formatter.write_str("struct stream_plan.NowNode")
7160 }
7161
7162 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowNode, V::Error>
7163 where
7164 V: serde::de::MapAccess<'de>,
7165 {
7166 let mut state_table__ = None;
7167 let mut mode__ = None;
7168 while let Some(k) = map_.next_key()? {
7169 match k {
7170 GeneratedField::StateTable => {
7171 if state_table__.is_some() {
7172 return Err(serde::de::Error::duplicate_field("stateTable"));
7173 }
7174 state_table__ = map_.next_value()?;
7175 }
7176 GeneratedField::UpdateCurrent => {
7177 if mode__.is_some() {
7178 return Err(serde::de::Error::duplicate_field("updateCurrent"));
7179 }
7180 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::UpdateCurrent)
7181;
7182 }
7183 GeneratedField::GenerateSeries => {
7184 if mode__.is_some() {
7185 return Err(serde::de::Error::duplicate_field("generateSeries"));
7186 }
7187 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::GenerateSeries)
7188;
7189 }
7190 }
7191 }
7192 Ok(NowNode {
7193 state_table: state_table__,
7194 mode: mode__,
7195 })
7196 }
7197 }
7198 deserializer.deserialize_struct("stream_plan.NowNode", FIELDS, GeneratedVisitor)
7199 }
7200}
7201impl serde::Serialize for OverWindowCachePolicy {
7202 #[allow(deprecated)]
7203 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7204 where
7205 S: serde::Serializer,
7206 {
7207 let variant = match self {
7208 Self::Unspecified => "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
7209 Self::Full => "OVER_WINDOW_CACHE_POLICY_FULL",
7210 Self::Recent => "OVER_WINDOW_CACHE_POLICY_RECENT",
7211 Self::RecentFirstN => "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
7212 Self::RecentLastN => "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
7213 };
7214 serializer.serialize_str(variant)
7215 }
7216}
7217impl<'de> serde::Deserialize<'de> for OverWindowCachePolicy {
7218 #[allow(deprecated)]
7219 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7220 where
7221 D: serde::Deserializer<'de>,
7222 {
7223 const FIELDS: &[&str] = &[
7224 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
7225 "OVER_WINDOW_CACHE_POLICY_FULL",
7226 "OVER_WINDOW_CACHE_POLICY_RECENT",
7227 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
7228 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
7229 ];
7230
7231 struct GeneratedVisitor;
7232
7233 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7234 type Value = OverWindowCachePolicy;
7235
7236 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7237 write!(formatter, "expected one of: {:?}", &FIELDS)
7238 }
7239
7240 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
7241 where
7242 E: serde::de::Error,
7243 {
7244 i32::try_from(v)
7245 .ok()
7246 .and_then(|x| x.try_into().ok())
7247 .ok_or_else(|| {
7248 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
7249 })
7250 }
7251
7252 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
7253 where
7254 E: serde::de::Error,
7255 {
7256 i32::try_from(v)
7257 .ok()
7258 .and_then(|x| x.try_into().ok())
7259 .ok_or_else(|| {
7260 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
7261 })
7262 }
7263
7264 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
7265 where
7266 E: serde::de::Error,
7267 {
7268 match value {
7269 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED" => Ok(OverWindowCachePolicy::Unspecified),
7270 "OVER_WINDOW_CACHE_POLICY_FULL" => Ok(OverWindowCachePolicy::Full),
7271 "OVER_WINDOW_CACHE_POLICY_RECENT" => Ok(OverWindowCachePolicy::Recent),
7272 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N" => Ok(OverWindowCachePolicy::RecentFirstN),
7273 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N" => Ok(OverWindowCachePolicy::RecentLastN),
7274 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
7275 }
7276 }
7277 }
7278 deserializer.deserialize_any(GeneratedVisitor)
7279 }
7280}
7281impl serde::Serialize for OverWindowNode {
7282 #[allow(deprecated)]
7283 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7284 where
7285 S: serde::Serializer,
7286 {
7287 use serde::ser::SerializeStruct;
7288 let mut len = 0;
7289 if !self.calls.is_empty() {
7290 len += 1;
7291 }
7292 if !self.partition_by.is_empty() {
7293 len += 1;
7294 }
7295 if !self.order_by.is_empty() {
7296 len += 1;
7297 }
7298 if self.state_table.is_some() {
7299 len += 1;
7300 }
7301 if self.cache_policy != 0 {
7302 len += 1;
7303 }
7304 let mut struct_ser = serializer.serialize_struct("stream_plan.OverWindowNode", len)?;
7305 if !self.calls.is_empty() {
7306 struct_ser.serialize_field("calls", &self.calls)?;
7307 }
7308 if !self.partition_by.is_empty() {
7309 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
7310 }
7311 if !self.order_by.is_empty() {
7312 struct_ser.serialize_field("orderBy", &self.order_by)?;
7313 }
7314 if let Some(v) = self.state_table.as_ref() {
7315 struct_ser.serialize_field("stateTable", v)?;
7316 }
7317 if self.cache_policy != 0 {
7318 let v = OverWindowCachePolicy::try_from(self.cache_policy)
7319 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cache_policy)))?;
7320 struct_ser.serialize_field("cachePolicy", &v)?;
7321 }
7322 struct_ser.end()
7323 }
7324}
7325impl<'de> serde::Deserialize<'de> for OverWindowNode {
7326 #[allow(deprecated)]
7327 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7328 where
7329 D: serde::Deserializer<'de>,
7330 {
7331 const FIELDS: &[&str] = &[
7332 "calls",
7333 "partition_by",
7334 "partitionBy",
7335 "order_by",
7336 "orderBy",
7337 "state_table",
7338 "stateTable",
7339 "cache_policy",
7340 "cachePolicy",
7341 ];
7342
7343 #[allow(clippy::enum_variant_names)]
7344 enum GeneratedField {
7345 Calls,
7346 PartitionBy,
7347 OrderBy,
7348 StateTable,
7349 CachePolicy,
7350 }
7351 impl<'de> serde::Deserialize<'de> for GeneratedField {
7352 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7353 where
7354 D: serde::Deserializer<'de>,
7355 {
7356 struct GeneratedVisitor;
7357
7358 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7359 type Value = GeneratedField;
7360
7361 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7362 write!(formatter, "expected one of: {:?}", &FIELDS)
7363 }
7364
7365 #[allow(unused_variables)]
7366 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7367 where
7368 E: serde::de::Error,
7369 {
7370 match value {
7371 "calls" => Ok(GeneratedField::Calls),
7372 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
7373 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
7374 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7375 "cachePolicy" | "cache_policy" => Ok(GeneratedField::CachePolicy),
7376 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7377 }
7378 }
7379 }
7380 deserializer.deserialize_identifier(GeneratedVisitor)
7381 }
7382 }
7383 struct GeneratedVisitor;
7384 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7385 type Value = OverWindowNode;
7386
7387 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7388 formatter.write_str("struct stream_plan.OverWindowNode")
7389 }
7390
7391 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverWindowNode, V::Error>
7392 where
7393 V: serde::de::MapAccess<'de>,
7394 {
7395 let mut calls__ = None;
7396 let mut partition_by__ = None;
7397 let mut order_by__ = None;
7398 let mut state_table__ = None;
7399 let mut cache_policy__ = None;
7400 while let Some(k) = map_.next_key()? {
7401 match k {
7402 GeneratedField::Calls => {
7403 if calls__.is_some() {
7404 return Err(serde::de::Error::duplicate_field("calls"));
7405 }
7406 calls__ = Some(map_.next_value()?);
7407 }
7408 GeneratedField::PartitionBy => {
7409 if partition_by__.is_some() {
7410 return Err(serde::de::Error::duplicate_field("partitionBy"));
7411 }
7412 partition_by__ =
7413 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7414 .into_iter().map(|x| x.0).collect())
7415 ;
7416 }
7417 GeneratedField::OrderBy => {
7418 if order_by__.is_some() {
7419 return Err(serde::de::Error::duplicate_field("orderBy"));
7420 }
7421 order_by__ = Some(map_.next_value()?);
7422 }
7423 GeneratedField::StateTable => {
7424 if state_table__.is_some() {
7425 return Err(serde::de::Error::duplicate_field("stateTable"));
7426 }
7427 state_table__ = map_.next_value()?;
7428 }
7429 GeneratedField::CachePolicy => {
7430 if cache_policy__.is_some() {
7431 return Err(serde::de::Error::duplicate_field("cachePolicy"));
7432 }
7433 cache_policy__ = Some(map_.next_value::<OverWindowCachePolicy>()? as i32);
7434 }
7435 }
7436 }
7437 Ok(OverWindowNode {
7438 calls: calls__.unwrap_or_default(),
7439 partition_by: partition_by__.unwrap_or_default(),
7440 order_by: order_by__.unwrap_or_default(),
7441 state_table: state_table__,
7442 cache_policy: cache_policy__.unwrap_or_default(),
7443 })
7444 }
7445 }
7446 deserializer.deserialize_struct("stream_plan.OverWindowNode", FIELDS, GeneratedVisitor)
7447 }
7448}
7449impl serde::Serialize for PauseMutation {
7450 #[allow(deprecated)]
7451 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7452 where
7453 S: serde::Serializer,
7454 {
7455 use serde::ser::SerializeStruct;
7456 let len = 0;
7457 let struct_ser = serializer.serialize_struct("stream_plan.PauseMutation", len)?;
7458 struct_ser.end()
7459 }
7460}
7461impl<'de> serde::Deserialize<'de> for PauseMutation {
7462 #[allow(deprecated)]
7463 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7464 where
7465 D: serde::Deserializer<'de>,
7466 {
7467 const FIELDS: &[&str] = &[
7468 ];
7469
7470 #[allow(clippy::enum_variant_names)]
7471 enum GeneratedField {
7472 }
7473 impl<'de> serde::Deserialize<'de> for GeneratedField {
7474 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7475 where
7476 D: serde::Deserializer<'de>,
7477 {
7478 struct GeneratedVisitor;
7479
7480 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7481 type Value = GeneratedField;
7482
7483 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7484 write!(formatter, "expected one of: {:?}", &FIELDS)
7485 }
7486
7487 #[allow(unused_variables)]
7488 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7489 where
7490 E: serde::de::Error,
7491 {
7492 Err(serde::de::Error::unknown_field(value, FIELDS))
7493 }
7494 }
7495 deserializer.deserialize_identifier(GeneratedVisitor)
7496 }
7497 }
7498 struct GeneratedVisitor;
7499 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7500 type Value = PauseMutation;
7501
7502 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7503 formatter.write_str("struct stream_plan.PauseMutation")
7504 }
7505
7506 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseMutation, V::Error>
7507 where
7508 V: serde::de::MapAccess<'de>,
7509 {
7510 while map_.next_key::<GeneratedField>()?.is_some() {
7511 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7512 }
7513 Ok(PauseMutation {
7514 })
7515 }
7516 }
7517 deserializer.deserialize_struct("stream_plan.PauseMutation", FIELDS, GeneratedVisitor)
7518 }
7519}
7520impl serde::Serialize for ProjectNode {
7521 #[allow(deprecated)]
7522 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7523 where
7524 S: serde::Serializer,
7525 {
7526 use serde::ser::SerializeStruct;
7527 let mut len = 0;
7528 if !self.select_list.is_empty() {
7529 len += 1;
7530 }
7531 if !self.watermark_input_cols.is_empty() {
7532 len += 1;
7533 }
7534 if !self.watermark_output_cols.is_empty() {
7535 len += 1;
7536 }
7537 if !self.nondecreasing_exprs.is_empty() {
7538 len += 1;
7539 }
7540 if self.noop_update_hint {
7541 len += 1;
7542 }
7543 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectNode", len)?;
7544 if !self.select_list.is_empty() {
7545 struct_ser.serialize_field("selectList", &self.select_list)?;
7546 }
7547 if !self.watermark_input_cols.is_empty() {
7548 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
7549 }
7550 if !self.watermark_output_cols.is_empty() {
7551 struct_ser.serialize_field("watermarkOutputCols", &self.watermark_output_cols)?;
7552 }
7553 if !self.nondecreasing_exprs.is_empty() {
7554 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
7555 }
7556 if self.noop_update_hint {
7557 struct_ser.serialize_field("noopUpdateHint", &self.noop_update_hint)?;
7558 }
7559 struct_ser.end()
7560 }
7561}
7562impl<'de> serde::Deserialize<'de> for ProjectNode {
7563 #[allow(deprecated)]
7564 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7565 where
7566 D: serde::Deserializer<'de>,
7567 {
7568 const FIELDS: &[&str] = &[
7569 "select_list",
7570 "selectList",
7571 "watermark_input_cols",
7572 "watermarkInputCols",
7573 "watermark_output_cols",
7574 "watermarkOutputCols",
7575 "nondecreasing_exprs",
7576 "nondecreasingExprs",
7577 "noop_update_hint",
7578 "noopUpdateHint",
7579 ];
7580
7581 #[allow(clippy::enum_variant_names)]
7582 enum GeneratedField {
7583 SelectList,
7584 WatermarkInputCols,
7585 WatermarkOutputCols,
7586 NondecreasingExprs,
7587 NoopUpdateHint,
7588 }
7589 impl<'de> serde::Deserialize<'de> for GeneratedField {
7590 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7591 where
7592 D: serde::Deserializer<'de>,
7593 {
7594 struct GeneratedVisitor;
7595
7596 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7597 type Value = GeneratedField;
7598
7599 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7600 write!(formatter, "expected one of: {:?}", &FIELDS)
7601 }
7602
7603 #[allow(unused_variables)]
7604 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7605 where
7606 E: serde::de::Error,
7607 {
7608 match value {
7609 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
7610 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
7611 "watermarkOutputCols" | "watermark_output_cols" => Ok(GeneratedField::WatermarkOutputCols),
7612 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
7613 "noopUpdateHint" | "noop_update_hint" => Ok(GeneratedField::NoopUpdateHint),
7614 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7615 }
7616 }
7617 }
7618 deserializer.deserialize_identifier(GeneratedVisitor)
7619 }
7620 }
7621 struct GeneratedVisitor;
7622 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7623 type Value = ProjectNode;
7624
7625 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7626 formatter.write_str("struct stream_plan.ProjectNode")
7627 }
7628
7629 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
7630 where
7631 V: serde::de::MapAccess<'de>,
7632 {
7633 let mut select_list__ = None;
7634 let mut watermark_input_cols__ = None;
7635 let mut watermark_output_cols__ = None;
7636 let mut nondecreasing_exprs__ = None;
7637 let mut noop_update_hint__ = None;
7638 while let Some(k) = map_.next_key()? {
7639 match k {
7640 GeneratedField::SelectList => {
7641 if select_list__.is_some() {
7642 return Err(serde::de::Error::duplicate_field("selectList"));
7643 }
7644 select_list__ = Some(map_.next_value()?);
7645 }
7646 GeneratedField::WatermarkInputCols => {
7647 if watermark_input_cols__.is_some() {
7648 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
7649 }
7650 watermark_input_cols__ =
7651 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7652 .into_iter().map(|x| x.0).collect())
7653 ;
7654 }
7655 GeneratedField::WatermarkOutputCols => {
7656 if watermark_output_cols__.is_some() {
7657 return Err(serde::de::Error::duplicate_field("watermarkOutputCols"));
7658 }
7659 watermark_output_cols__ =
7660 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7661 .into_iter().map(|x| x.0).collect())
7662 ;
7663 }
7664 GeneratedField::NondecreasingExprs => {
7665 if nondecreasing_exprs__.is_some() {
7666 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
7667 }
7668 nondecreasing_exprs__ =
7669 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7670 .into_iter().map(|x| x.0).collect())
7671 ;
7672 }
7673 GeneratedField::NoopUpdateHint => {
7674 if noop_update_hint__.is_some() {
7675 return Err(serde::de::Error::duplicate_field("noopUpdateHint"));
7676 }
7677 noop_update_hint__ = Some(map_.next_value()?);
7678 }
7679 }
7680 }
7681 Ok(ProjectNode {
7682 select_list: select_list__.unwrap_or_default(),
7683 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
7684 watermark_output_cols: watermark_output_cols__.unwrap_or_default(),
7685 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
7686 noop_update_hint: noop_update_hint__.unwrap_or_default(),
7687 })
7688 }
7689 }
7690 deserializer.deserialize_struct("stream_plan.ProjectNode", FIELDS, GeneratedVisitor)
7691 }
7692}
7693impl serde::Serialize for ProjectSetNode {
7694 #[allow(deprecated)]
7695 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7696 where
7697 S: serde::Serializer,
7698 {
7699 use serde::ser::SerializeStruct;
7700 let mut len = 0;
7701 if !self.select_list.is_empty() {
7702 len += 1;
7703 }
7704 if !self.watermark_input_cols.is_empty() {
7705 len += 1;
7706 }
7707 if !self.watermark_expr_indices.is_empty() {
7708 len += 1;
7709 }
7710 if !self.nondecreasing_exprs.is_empty() {
7711 len += 1;
7712 }
7713 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectSetNode", len)?;
7714 if !self.select_list.is_empty() {
7715 struct_ser.serialize_field("selectList", &self.select_list)?;
7716 }
7717 if !self.watermark_input_cols.is_empty() {
7718 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
7719 }
7720 if !self.watermark_expr_indices.is_empty() {
7721 struct_ser.serialize_field("watermarkExprIndices", &self.watermark_expr_indices)?;
7722 }
7723 if !self.nondecreasing_exprs.is_empty() {
7724 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
7725 }
7726 struct_ser.end()
7727 }
7728}
7729impl<'de> serde::Deserialize<'de> for ProjectSetNode {
7730 #[allow(deprecated)]
7731 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7732 where
7733 D: serde::Deserializer<'de>,
7734 {
7735 const FIELDS: &[&str] = &[
7736 "select_list",
7737 "selectList",
7738 "watermark_input_cols",
7739 "watermarkInputCols",
7740 "watermark_expr_indices",
7741 "watermarkExprIndices",
7742 "nondecreasing_exprs",
7743 "nondecreasingExprs",
7744 ];
7745
7746 #[allow(clippy::enum_variant_names)]
7747 enum GeneratedField {
7748 SelectList,
7749 WatermarkInputCols,
7750 WatermarkExprIndices,
7751 NondecreasingExprs,
7752 }
7753 impl<'de> serde::Deserialize<'de> for GeneratedField {
7754 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7755 where
7756 D: serde::Deserializer<'de>,
7757 {
7758 struct GeneratedVisitor;
7759
7760 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7761 type Value = GeneratedField;
7762
7763 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7764 write!(formatter, "expected one of: {:?}", &FIELDS)
7765 }
7766
7767 #[allow(unused_variables)]
7768 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7769 where
7770 E: serde::de::Error,
7771 {
7772 match value {
7773 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
7774 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
7775 "watermarkExprIndices" | "watermark_expr_indices" => Ok(GeneratedField::WatermarkExprIndices),
7776 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
7777 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7778 }
7779 }
7780 }
7781 deserializer.deserialize_identifier(GeneratedVisitor)
7782 }
7783 }
7784 struct GeneratedVisitor;
7785 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7786 type Value = ProjectSetNode;
7787
7788 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7789 formatter.write_str("struct stream_plan.ProjectSetNode")
7790 }
7791
7792 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
7793 where
7794 V: serde::de::MapAccess<'de>,
7795 {
7796 let mut select_list__ = None;
7797 let mut watermark_input_cols__ = None;
7798 let mut watermark_expr_indices__ = None;
7799 let mut nondecreasing_exprs__ = None;
7800 while let Some(k) = map_.next_key()? {
7801 match k {
7802 GeneratedField::SelectList => {
7803 if select_list__.is_some() {
7804 return Err(serde::de::Error::duplicate_field("selectList"));
7805 }
7806 select_list__ = Some(map_.next_value()?);
7807 }
7808 GeneratedField::WatermarkInputCols => {
7809 if watermark_input_cols__.is_some() {
7810 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
7811 }
7812 watermark_input_cols__ =
7813 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7814 .into_iter().map(|x| x.0).collect())
7815 ;
7816 }
7817 GeneratedField::WatermarkExprIndices => {
7818 if watermark_expr_indices__.is_some() {
7819 return Err(serde::de::Error::duplicate_field("watermarkExprIndices"));
7820 }
7821 watermark_expr_indices__ =
7822 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7823 .into_iter().map(|x| x.0).collect())
7824 ;
7825 }
7826 GeneratedField::NondecreasingExprs => {
7827 if nondecreasing_exprs__.is_some() {
7828 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
7829 }
7830 nondecreasing_exprs__ =
7831 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7832 .into_iter().map(|x| x.0).collect())
7833 ;
7834 }
7835 }
7836 }
7837 Ok(ProjectSetNode {
7838 select_list: select_list__.unwrap_or_default(),
7839 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
7840 watermark_expr_indices: watermark_expr_indices__.unwrap_or_default(),
7841 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
7842 })
7843 }
7844 }
7845 deserializer.deserialize_struct("stream_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
7846 }
7847}
7848impl serde::Serialize for ResumeMutation {
7849 #[allow(deprecated)]
7850 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7851 where
7852 S: serde::Serializer,
7853 {
7854 use serde::ser::SerializeStruct;
7855 let len = 0;
7856 let struct_ser = serializer.serialize_struct("stream_plan.ResumeMutation", len)?;
7857 struct_ser.end()
7858 }
7859}
7860impl<'de> serde::Deserialize<'de> for ResumeMutation {
7861 #[allow(deprecated)]
7862 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7863 where
7864 D: serde::Deserializer<'de>,
7865 {
7866 const FIELDS: &[&str] = &[
7867 ];
7868
7869 #[allow(clippy::enum_variant_names)]
7870 enum GeneratedField {
7871 }
7872 impl<'de> serde::Deserialize<'de> for GeneratedField {
7873 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7874 where
7875 D: serde::Deserializer<'de>,
7876 {
7877 struct GeneratedVisitor;
7878
7879 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7880 type Value = GeneratedField;
7881
7882 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7883 write!(formatter, "expected one of: {:?}", &FIELDS)
7884 }
7885
7886 #[allow(unused_variables)]
7887 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7888 where
7889 E: serde::de::Error,
7890 {
7891 Err(serde::de::Error::unknown_field(value, FIELDS))
7892 }
7893 }
7894 deserializer.deserialize_identifier(GeneratedVisitor)
7895 }
7896 }
7897 struct GeneratedVisitor;
7898 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7899 type Value = ResumeMutation;
7900
7901 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7902 formatter.write_str("struct stream_plan.ResumeMutation")
7903 }
7904
7905 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeMutation, V::Error>
7906 where
7907 V: serde::de::MapAccess<'de>,
7908 {
7909 while map_.next_key::<GeneratedField>()?.is_some() {
7910 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7911 }
7912 Ok(ResumeMutation {
7913 })
7914 }
7915 }
7916 deserializer.deserialize_struct("stream_plan.ResumeMutation", FIELDS, GeneratedVisitor)
7917 }
7918}
7919impl serde::Serialize for RowIdGenNode {
7920 #[allow(deprecated)]
7921 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7922 where
7923 S: serde::Serializer,
7924 {
7925 use serde::ser::SerializeStruct;
7926 let mut len = 0;
7927 if self.row_id_index != 0 {
7928 len += 1;
7929 }
7930 let mut struct_ser = serializer.serialize_struct("stream_plan.RowIdGenNode", len)?;
7931 if self.row_id_index != 0 {
7932 #[allow(clippy::needless_borrow)]
7933 #[allow(clippy::needless_borrows_for_generic_args)]
7934 struct_ser.serialize_field("rowIdIndex", ToString::to_string(&self.row_id_index).as_str())?;
7935 }
7936 struct_ser.end()
7937 }
7938}
7939impl<'de> serde::Deserialize<'de> for RowIdGenNode {
7940 #[allow(deprecated)]
7941 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7942 where
7943 D: serde::Deserializer<'de>,
7944 {
7945 const FIELDS: &[&str] = &[
7946 "row_id_index",
7947 "rowIdIndex",
7948 ];
7949
7950 #[allow(clippy::enum_variant_names)]
7951 enum GeneratedField {
7952 RowIdIndex,
7953 }
7954 impl<'de> serde::Deserialize<'de> for GeneratedField {
7955 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7956 where
7957 D: serde::Deserializer<'de>,
7958 {
7959 struct GeneratedVisitor;
7960
7961 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7962 type Value = GeneratedField;
7963
7964 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7965 write!(formatter, "expected one of: {:?}", &FIELDS)
7966 }
7967
7968 #[allow(unused_variables)]
7969 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7970 where
7971 E: serde::de::Error,
7972 {
7973 match value {
7974 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
7975 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7976 }
7977 }
7978 }
7979 deserializer.deserialize_identifier(GeneratedVisitor)
7980 }
7981 }
7982 struct GeneratedVisitor;
7983 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7984 type Value = RowIdGenNode;
7985
7986 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7987 formatter.write_str("struct stream_plan.RowIdGenNode")
7988 }
7989
7990 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowIdGenNode, V::Error>
7991 where
7992 V: serde::de::MapAccess<'de>,
7993 {
7994 let mut row_id_index__ = None;
7995 while let Some(k) = map_.next_key()? {
7996 match k {
7997 GeneratedField::RowIdIndex => {
7998 if row_id_index__.is_some() {
7999 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
8000 }
8001 row_id_index__ =
8002 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8003 ;
8004 }
8005 }
8006 }
8007 Ok(RowIdGenNode {
8008 row_id_index: row_id_index__.unwrap_or_default(),
8009 })
8010 }
8011 }
8012 deserializer.deserialize_struct("stream_plan.RowIdGenNode", FIELDS, GeneratedVisitor)
8013 }
8014}
8015impl serde::Serialize for RowMergeNode {
8016 #[allow(deprecated)]
8017 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8018 where
8019 S: serde::Serializer,
8020 {
8021 use serde::ser::SerializeStruct;
8022 let mut len = 0;
8023 if self.lhs_mapping.is_some() {
8024 len += 1;
8025 }
8026 if self.rhs_mapping.is_some() {
8027 len += 1;
8028 }
8029 let mut struct_ser = serializer.serialize_struct("stream_plan.RowMergeNode", len)?;
8030 if let Some(v) = self.lhs_mapping.as_ref() {
8031 struct_ser.serialize_field("lhsMapping", v)?;
8032 }
8033 if let Some(v) = self.rhs_mapping.as_ref() {
8034 struct_ser.serialize_field("rhsMapping", v)?;
8035 }
8036 struct_ser.end()
8037 }
8038}
8039impl<'de> serde::Deserialize<'de> for RowMergeNode {
8040 #[allow(deprecated)]
8041 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8042 where
8043 D: serde::Deserializer<'de>,
8044 {
8045 const FIELDS: &[&str] = &[
8046 "lhs_mapping",
8047 "lhsMapping",
8048 "rhs_mapping",
8049 "rhsMapping",
8050 ];
8051
8052 #[allow(clippy::enum_variant_names)]
8053 enum GeneratedField {
8054 LhsMapping,
8055 RhsMapping,
8056 }
8057 impl<'de> serde::Deserialize<'de> for GeneratedField {
8058 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8059 where
8060 D: serde::Deserializer<'de>,
8061 {
8062 struct GeneratedVisitor;
8063
8064 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8065 type Value = GeneratedField;
8066
8067 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8068 write!(formatter, "expected one of: {:?}", &FIELDS)
8069 }
8070
8071 #[allow(unused_variables)]
8072 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8073 where
8074 E: serde::de::Error,
8075 {
8076 match value {
8077 "lhsMapping" | "lhs_mapping" => Ok(GeneratedField::LhsMapping),
8078 "rhsMapping" | "rhs_mapping" => Ok(GeneratedField::RhsMapping),
8079 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8080 }
8081 }
8082 }
8083 deserializer.deserialize_identifier(GeneratedVisitor)
8084 }
8085 }
8086 struct GeneratedVisitor;
8087 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8088 type Value = RowMergeNode;
8089
8090 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8091 formatter.write_str("struct stream_plan.RowMergeNode")
8092 }
8093
8094 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowMergeNode, V::Error>
8095 where
8096 V: serde::de::MapAccess<'de>,
8097 {
8098 let mut lhs_mapping__ = None;
8099 let mut rhs_mapping__ = None;
8100 while let Some(k) = map_.next_key()? {
8101 match k {
8102 GeneratedField::LhsMapping => {
8103 if lhs_mapping__.is_some() {
8104 return Err(serde::de::Error::duplicate_field("lhsMapping"));
8105 }
8106 lhs_mapping__ = map_.next_value()?;
8107 }
8108 GeneratedField::RhsMapping => {
8109 if rhs_mapping__.is_some() {
8110 return Err(serde::de::Error::duplicate_field("rhsMapping"));
8111 }
8112 rhs_mapping__ = map_.next_value()?;
8113 }
8114 }
8115 }
8116 Ok(RowMergeNode {
8117 lhs_mapping: lhs_mapping__,
8118 rhs_mapping: rhs_mapping__,
8119 })
8120 }
8121 }
8122 deserializer.deserialize_struct("stream_plan.RowMergeNode", FIELDS, GeneratedVisitor)
8123 }
8124}
8125impl serde::Serialize for SimpleAggNode {
8126 #[allow(deprecated)]
8127 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8128 where
8129 S: serde::Serializer,
8130 {
8131 use serde::ser::SerializeStruct;
8132 let mut len = 0;
8133 if !self.agg_calls.is_empty() {
8134 len += 1;
8135 }
8136 if !self.distribution_key.is_empty() {
8137 len += 1;
8138 }
8139 if !self.agg_call_states.is_empty() {
8140 len += 1;
8141 }
8142 if self.intermediate_state_table.is_some() {
8143 len += 1;
8144 }
8145 if self.is_append_only {
8146 len += 1;
8147 }
8148 if !self.distinct_dedup_tables.is_empty() {
8149 len += 1;
8150 }
8151 if self.row_count_index != 0 {
8152 len += 1;
8153 }
8154 if self.version != 0 {
8155 len += 1;
8156 }
8157 if self.must_output_per_barrier {
8158 len += 1;
8159 }
8160 let mut struct_ser = serializer.serialize_struct("stream_plan.SimpleAggNode", len)?;
8161 if !self.agg_calls.is_empty() {
8162 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
8163 }
8164 if !self.distribution_key.is_empty() {
8165 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
8166 }
8167 if !self.agg_call_states.is_empty() {
8168 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
8169 }
8170 if let Some(v) = self.intermediate_state_table.as_ref() {
8171 struct_ser.serialize_field("intermediateStateTable", v)?;
8172 }
8173 if self.is_append_only {
8174 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
8175 }
8176 if !self.distinct_dedup_tables.is_empty() {
8177 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
8178 }
8179 if self.row_count_index != 0 {
8180 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
8181 }
8182 if self.version != 0 {
8183 let v = AggNodeVersion::try_from(self.version)
8184 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
8185 struct_ser.serialize_field("version", &v)?;
8186 }
8187 if self.must_output_per_barrier {
8188 struct_ser.serialize_field("mustOutputPerBarrier", &self.must_output_per_barrier)?;
8189 }
8190 struct_ser.end()
8191 }
8192}
8193impl<'de> serde::Deserialize<'de> for SimpleAggNode {
8194 #[allow(deprecated)]
8195 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8196 where
8197 D: serde::Deserializer<'de>,
8198 {
8199 const FIELDS: &[&str] = &[
8200 "agg_calls",
8201 "aggCalls",
8202 "distribution_key",
8203 "distributionKey",
8204 "agg_call_states",
8205 "aggCallStates",
8206 "intermediate_state_table",
8207 "intermediateStateTable",
8208 "is_append_only",
8209 "isAppendOnly",
8210 "distinct_dedup_tables",
8211 "distinctDedupTables",
8212 "row_count_index",
8213 "rowCountIndex",
8214 "version",
8215 "must_output_per_barrier",
8216 "mustOutputPerBarrier",
8217 ];
8218
8219 #[allow(clippy::enum_variant_names)]
8220 enum GeneratedField {
8221 AggCalls,
8222 DistributionKey,
8223 AggCallStates,
8224 IntermediateStateTable,
8225 IsAppendOnly,
8226 DistinctDedupTables,
8227 RowCountIndex,
8228 Version,
8229 MustOutputPerBarrier,
8230 }
8231 impl<'de> serde::Deserialize<'de> for GeneratedField {
8232 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8233 where
8234 D: serde::Deserializer<'de>,
8235 {
8236 struct GeneratedVisitor;
8237
8238 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8239 type Value = GeneratedField;
8240
8241 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8242 write!(formatter, "expected one of: {:?}", &FIELDS)
8243 }
8244
8245 #[allow(unused_variables)]
8246 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8247 where
8248 E: serde::de::Error,
8249 {
8250 match value {
8251 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
8252 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
8253 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
8254 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
8255 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
8256 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
8257 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
8258 "version" => Ok(GeneratedField::Version),
8259 "mustOutputPerBarrier" | "must_output_per_barrier" => Ok(GeneratedField::MustOutputPerBarrier),
8260 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8261 }
8262 }
8263 }
8264 deserializer.deserialize_identifier(GeneratedVisitor)
8265 }
8266 }
8267 struct GeneratedVisitor;
8268 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8269 type Value = SimpleAggNode;
8270
8271 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8272 formatter.write_str("struct stream_plan.SimpleAggNode")
8273 }
8274
8275 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SimpleAggNode, V::Error>
8276 where
8277 V: serde::de::MapAccess<'de>,
8278 {
8279 let mut agg_calls__ = None;
8280 let mut distribution_key__ = None;
8281 let mut agg_call_states__ = None;
8282 let mut intermediate_state_table__ = None;
8283 let mut is_append_only__ = None;
8284 let mut distinct_dedup_tables__ = None;
8285 let mut row_count_index__ = None;
8286 let mut version__ = None;
8287 let mut must_output_per_barrier__ = None;
8288 while let Some(k) = map_.next_key()? {
8289 match k {
8290 GeneratedField::AggCalls => {
8291 if agg_calls__.is_some() {
8292 return Err(serde::de::Error::duplicate_field("aggCalls"));
8293 }
8294 agg_calls__ = Some(map_.next_value()?);
8295 }
8296 GeneratedField::DistributionKey => {
8297 if distribution_key__.is_some() {
8298 return Err(serde::de::Error::duplicate_field("distributionKey"));
8299 }
8300 distribution_key__ =
8301 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8302 .into_iter().map(|x| x.0).collect())
8303 ;
8304 }
8305 GeneratedField::AggCallStates => {
8306 if agg_call_states__.is_some() {
8307 return Err(serde::de::Error::duplicate_field("aggCallStates"));
8308 }
8309 agg_call_states__ = Some(map_.next_value()?);
8310 }
8311 GeneratedField::IntermediateStateTable => {
8312 if intermediate_state_table__.is_some() {
8313 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
8314 }
8315 intermediate_state_table__ = map_.next_value()?;
8316 }
8317 GeneratedField::IsAppendOnly => {
8318 if is_append_only__.is_some() {
8319 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
8320 }
8321 is_append_only__ = Some(map_.next_value()?);
8322 }
8323 GeneratedField::DistinctDedupTables => {
8324 if distinct_dedup_tables__.is_some() {
8325 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
8326 }
8327 distinct_dedup_tables__ = Some(
8328 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8329 .into_iter().map(|(k,v)| (k.0, v)).collect()
8330 );
8331 }
8332 GeneratedField::RowCountIndex => {
8333 if row_count_index__.is_some() {
8334 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
8335 }
8336 row_count_index__ =
8337 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8338 ;
8339 }
8340 GeneratedField::Version => {
8341 if version__.is_some() {
8342 return Err(serde::de::Error::duplicate_field("version"));
8343 }
8344 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
8345 }
8346 GeneratedField::MustOutputPerBarrier => {
8347 if must_output_per_barrier__.is_some() {
8348 return Err(serde::de::Error::duplicate_field("mustOutputPerBarrier"));
8349 }
8350 must_output_per_barrier__ = Some(map_.next_value()?);
8351 }
8352 }
8353 }
8354 Ok(SimpleAggNode {
8355 agg_calls: agg_calls__.unwrap_or_default(),
8356 distribution_key: distribution_key__.unwrap_or_default(),
8357 agg_call_states: agg_call_states__.unwrap_or_default(),
8358 intermediate_state_table: intermediate_state_table__,
8359 is_append_only: is_append_only__.unwrap_or_default(),
8360 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
8361 row_count_index: row_count_index__.unwrap_or_default(),
8362 version: version__.unwrap_or_default(),
8363 must_output_per_barrier: must_output_per_barrier__.unwrap_or_default(),
8364 })
8365 }
8366 }
8367 deserializer.deserialize_struct("stream_plan.SimpleAggNode", FIELDS, GeneratedVisitor)
8368 }
8369}
8370impl serde::Serialize for SinkDesc {
8371 #[allow(deprecated)]
8372 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8373 where
8374 S: serde::Serializer,
8375 {
8376 use serde::ser::SerializeStruct;
8377 let mut len = 0;
8378 if self.id != 0 {
8379 len += 1;
8380 }
8381 if !self.name.is_empty() {
8382 len += 1;
8383 }
8384 if !self.definition.is_empty() {
8385 len += 1;
8386 }
8387 if !self.plan_pk.is_empty() {
8388 len += 1;
8389 }
8390 if !self.downstream_pk.is_empty() {
8391 len += 1;
8392 }
8393 if !self.distribution_key.is_empty() {
8394 len += 1;
8395 }
8396 if !self.properties.is_empty() {
8397 len += 1;
8398 }
8399 if self.sink_type != 0 {
8400 len += 1;
8401 }
8402 if !self.column_catalogs.is_empty() {
8403 len += 1;
8404 }
8405 if !self.db_name.is_empty() {
8406 len += 1;
8407 }
8408 if !self.sink_from_name.is_empty() {
8409 len += 1;
8410 }
8411 if self.format_desc.is_some() {
8412 len += 1;
8413 }
8414 if self.target_table.is_some() {
8415 len += 1;
8416 }
8417 if self.extra_partition_col_idx.is_some() {
8418 len += 1;
8419 }
8420 if !self.secret_refs.is_empty() {
8421 len += 1;
8422 }
8423 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDesc", len)?;
8424 if self.id != 0 {
8425 struct_ser.serialize_field("id", &self.id)?;
8426 }
8427 if !self.name.is_empty() {
8428 struct_ser.serialize_field("name", &self.name)?;
8429 }
8430 if !self.definition.is_empty() {
8431 struct_ser.serialize_field("definition", &self.definition)?;
8432 }
8433 if !self.plan_pk.is_empty() {
8434 struct_ser.serialize_field("planPk", &self.plan_pk)?;
8435 }
8436 if !self.downstream_pk.is_empty() {
8437 struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
8438 }
8439 if !self.distribution_key.is_empty() {
8440 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
8441 }
8442 if !self.properties.is_empty() {
8443 struct_ser.serialize_field("properties", &self.properties)?;
8444 }
8445 if self.sink_type != 0 {
8446 let v = super::catalog::SinkType::try_from(self.sink_type)
8447 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
8448 struct_ser.serialize_field("sinkType", &v)?;
8449 }
8450 if !self.column_catalogs.is_empty() {
8451 struct_ser.serialize_field("columnCatalogs", &self.column_catalogs)?;
8452 }
8453 if !self.db_name.is_empty() {
8454 struct_ser.serialize_field("dbName", &self.db_name)?;
8455 }
8456 if !self.sink_from_name.is_empty() {
8457 struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
8458 }
8459 if let Some(v) = self.format_desc.as_ref() {
8460 struct_ser.serialize_field("formatDesc", v)?;
8461 }
8462 if let Some(v) = self.target_table.as_ref() {
8463 struct_ser.serialize_field("targetTable", v)?;
8464 }
8465 if let Some(v) = self.extra_partition_col_idx.as_ref() {
8466 #[allow(clippy::needless_borrow)]
8467 #[allow(clippy::needless_borrows_for_generic_args)]
8468 struct_ser.serialize_field("extraPartitionColIdx", ToString::to_string(&v).as_str())?;
8469 }
8470 if !self.secret_refs.is_empty() {
8471 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
8472 }
8473 struct_ser.end()
8474 }
8475}
8476impl<'de> serde::Deserialize<'de> for SinkDesc {
8477 #[allow(deprecated)]
8478 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8479 where
8480 D: serde::Deserializer<'de>,
8481 {
8482 const FIELDS: &[&str] = &[
8483 "id",
8484 "name",
8485 "definition",
8486 "plan_pk",
8487 "planPk",
8488 "downstream_pk",
8489 "downstreamPk",
8490 "distribution_key",
8491 "distributionKey",
8492 "properties",
8493 "sink_type",
8494 "sinkType",
8495 "column_catalogs",
8496 "columnCatalogs",
8497 "db_name",
8498 "dbName",
8499 "sink_from_name",
8500 "sinkFromName",
8501 "format_desc",
8502 "formatDesc",
8503 "target_table",
8504 "targetTable",
8505 "extra_partition_col_idx",
8506 "extraPartitionColIdx",
8507 "secret_refs",
8508 "secretRefs",
8509 ];
8510
8511 #[allow(clippy::enum_variant_names)]
8512 enum GeneratedField {
8513 Id,
8514 Name,
8515 Definition,
8516 PlanPk,
8517 DownstreamPk,
8518 DistributionKey,
8519 Properties,
8520 SinkType,
8521 ColumnCatalogs,
8522 DbName,
8523 SinkFromName,
8524 FormatDesc,
8525 TargetTable,
8526 ExtraPartitionColIdx,
8527 SecretRefs,
8528 }
8529 impl<'de> serde::Deserialize<'de> for GeneratedField {
8530 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8531 where
8532 D: serde::Deserializer<'de>,
8533 {
8534 struct GeneratedVisitor;
8535
8536 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8537 type Value = GeneratedField;
8538
8539 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8540 write!(formatter, "expected one of: {:?}", &FIELDS)
8541 }
8542
8543 #[allow(unused_variables)]
8544 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8545 where
8546 E: serde::de::Error,
8547 {
8548 match value {
8549 "id" => Ok(GeneratedField::Id),
8550 "name" => Ok(GeneratedField::Name),
8551 "definition" => Ok(GeneratedField::Definition),
8552 "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
8553 "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
8554 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
8555 "properties" => Ok(GeneratedField::Properties),
8556 "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
8557 "columnCatalogs" | "column_catalogs" => Ok(GeneratedField::ColumnCatalogs),
8558 "dbName" | "db_name" => Ok(GeneratedField::DbName),
8559 "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
8560 "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
8561 "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
8562 "extraPartitionColIdx" | "extra_partition_col_idx" => Ok(GeneratedField::ExtraPartitionColIdx),
8563 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
8564 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8565 }
8566 }
8567 }
8568 deserializer.deserialize_identifier(GeneratedVisitor)
8569 }
8570 }
8571 struct GeneratedVisitor;
8572 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8573 type Value = SinkDesc;
8574
8575 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8576 formatter.write_str("struct stream_plan.SinkDesc")
8577 }
8578
8579 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDesc, V::Error>
8580 where
8581 V: serde::de::MapAccess<'de>,
8582 {
8583 let mut id__ = None;
8584 let mut name__ = None;
8585 let mut definition__ = None;
8586 let mut plan_pk__ = None;
8587 let mut downstream_pk__ = None;
8588 let mut distribution_key__ = None;
8589 let mut properties__ = None;
8590 let mut sink_type__ = None;
8591 let mut column_catalogs__ = None;
8592 let mut db_name__ = None;
8593 let mut sink_from_name__ = None;
8594 let mut format_desc__ = None;
8595 let mut target_table__ = None;
8596 let mut extra_partition_col_idx__ = None;
8597 let mut secret_refs__ = None;
8598 while let Some(k) = map_.next_key()? {
8599 match k {
8600 GeneratedField::Id => {
8601 if id__.is_some() {
8602 return Err(serde::de::Error::duplicate_field("id"));
8603 }
8604 id__ =
8605 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8606 ;
8607 }
8608 GeneratedField::Name => {
8609 if name__.is_some() {
8610 return Err(serde::de::Error::duplicate_field("name"));
8611 }
8612 name__ = Some(map_.next_value()?);
8613 }
8614 GeneratedField::Definition => {
8615 if definition__.is_some() {
8616 return Err(serde::de::Error::duplicate_field("definition"));
8617 }
8618 definition__ = Some(map_.next_value()?);
8619 }
8620 GeneratedField::PlanPk => {
8621 if plan_pk__.is_some() {
8622 return Err(serde::de::Error::duplicate_field("planPk"));
8623 }
8624 plan_pk__ = Some(map_.next_value()?);
8625 }
8626 GeneratedField::DownstreamPk => {
8627 if downstream_pk__.is_some() {
8628 return Err(serde::de::Error::duplicate_field("downstreamPk"));
8629 }
8630 downstream_pk__ =
8631 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8632 .into_iter().map(|x| x.0).collect())
8633 ;
8634 }
8635 GeneratedField::DistributionKey => {
8636 if distribution_key__.is_some() {
8637 return Err(serde::de::Error::duplicate_field("distributionKey"));
8638 }
8639 distribution_key__ =
8640 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8641 .into_iter().map(|x| x.0).collect())
8642 ;
8643 }
8644 GeneratedField::Properties => {
8645 if properties__.is_some() {
8646 return Err(serde::de::Error::duplicate_field("properties"));
8647 }
8648 properties__ = Some(
8649 map_.next_value::<std::collections::BTreeMap<_, _>>()?
8650 );
8651 }
8652 GeneratedField::SinkType => {
8653 if sink_type__.is_some() {
8654 return Err(serde::de::Error::duplicate_field("sinkType"));
8655 }
8656 sink_type__ = Some(map_.next_value::<super::catalog::SinkType>()? as i32);
8657 }
8658 GeneratedField::ColumnCatalogs => {
8659 if column_catalogs__.is_some() {
8660 return Err(serde::de::Error::duplicate_field("columnCatalogs"));
8661 }
8662 column_catalogs__ = Some(map_.next_value()?);
8663 }
8664 GeneratedField::DbName => {
8665 if db_name__.is_some() {
8666 return Err(serde::de::Error::duplicate_field("dbName"));
8667 }
8668 db_name__ = Some(map_.next_value()?);
8669 }
8670 GeneratedField::SinkFromName => {
8671 if sink_from_name__.is_some() {
8672 return Err(serde::de::Error::duplicate_field("sinkFromName"));
8673 }
8674 sink_from_name__ = Some(map_.next_value()?);
8675 }
8676 GeneratedField::FormatDesc => {
8677 if format_desc__.is_some() {
8678 return Err(serde::de::Error::duplicate_field("formatDesc"));
8679 }
8680 format_desc__ = map_.next_value()?;
8681 }
8682 GeneratedField::TargetTable => {
8683 if target_table__.is_some() {
8684 return Err(serde::de::Error::duplicate_field("targetTable"));
8685 }
8686 target_table__ =
8687 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
8688 ;
8689 }
8690 GeneratedField::ExtraPartitionColIdx => {
8691 if extra_partition_col_idx__.is_some() {
8692 return Err(serde::de::Error::duplicate_field("extraPartitionColIdx"));
8693 }
8694 extra_partition_col_idx__ =
8695 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
8696 ;
8697 }
8698 GeneratedField::SecretRefs => {
8699 if secret_refs__.is_some() {
8700 return Err(serde::de::Error::duplicate_field("secretRefs"));
8701 }
8702 secret_refs__ = Some(
8703 map_.next_value::<std::collections::BTreeMap<_, _>>()?
8704 );
8705 }
8706 }
8707 }
8708 Ok(SinkDesc {
8709 id: id__.unwrap_or_default(),
8710 name: name__.unwrap_or_default(),
8711 definition: definition__.unwrap_or_default(),
8712 plan_pk: plan_pk__.unwrap_or_default(),
8713 downstream_pk: downstream_pk__.unwrap_or_default(),
8714 distribution_key: distribution_key__.unwrap_or_default(),
8715 properties: properties__.unwrap_or_default(),
8716 sink_type: sink_type__.unwrap_or_default(),
8717 column_catalogs: column_catalogs__.unwrap_or_default(),
8718 db_name: db_name__.unwrap_or_default(),
8719 sink_from_name: sink_from_name__.unwrap_or_default(),
8720 format_desc: format_desc__,
8721 target_table: target_table__,
8722 extra_partition_col_idx: extra_partition_col_idx__,
8723 secret_refs: secret_refs__.unwrap_or_default(),
8724 })
8725 }
8726 }
8727 deserializer.deserialize_struct("stream_plan.SinkDesc", FIELDS, GeneratedVisitor)
8728 }
8729}
8730impl serde::Serialize for SinkLogStoreType {
8731 #[allow(deprecated)]
8732 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8733 where
8734 S: serde::Serializer,
8735 {
8736 let variant = match self {
8737 Self::Unspecified => "SINK_LOG_STORE_TYPE_UNSPECIFIED",
8738 Self::KvLogStore => "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
8739 Self::InMemoryLogStore => "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
8740 };
8741 serializer.serialize_str(variant)
8742 }
8743}
8744impl<'de> serde::Deserialize<'de> for SinkLogStoreType {
8745 #[allow(deprecated)]
8746 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8747 where
8748 D: serde::Deserializer<'de>,
8749 {
8750 const FIELDS: &[&str] = &[
8751 "SINK_LOG_STORE_TYPE_UNSPECIFIED",
8752 "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
8753 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
8754 ];
8755
8756 struct GeneratedVisitor;
8757
8758 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8759 type Value = SinkLogStoreType;
8760
8761 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8762 write!(formatter, "expected one of: {:?}", &FIELDS)
8763 }
8764
8765 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8766 where
8767 E: serde::de::Error,
8768 {
8769 i32::try_from(v)
8770 .ok()
8771 .and_then(|x| x.try_into().ok())
8772 .ok_or_else(|| {
8773 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8774 })
8775 }
8776
8777 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8778 where
8779 E: serde::de::Error,
8780 {
8781 i32::try_from(v)
8782 .ok()
8783 .and_then(|x| x.try_into().ok())
8784 .ok_or_else(|| {
8785 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8786 })
8787 }
8788
8789 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8790 where
8791 E: serde::de::Error,
8792 {
8793 match value {
8794 "SINK_LOG_STORE_TYPE_UNSPECIFIED" => Ok(SinkLogStoreType::Unspecified),
8795 "SINK_LOG_STORE_TYPE_KV_LOG_STORE" => Ok(SinkLogStoreType::KvLogStore),
8796 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE" => Ok(SinkLogStoreType::InMemoryLogStore),
8797 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8798 }
8799 }
8800 }
8801 deserializer.deserialize_any(GeneratedVisitor)
8802 }
8803}
8804impl serde::Serialize for SinkNode {
8805 #[allow(deprecated)]
8806 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8807 where
8808 S: serde::Serializer,
8809 {
8810 use serde::ser::SerializeStruct;
8811 let mut len = 0;
8812 if self.sink_desc.is_some() {
8813 len += 1;
8814 }
8815 if self.table.is_some() {
8816 len += 1;
8817 }
8818 if self.log_store_type != 0 {
8819 len += 1;
8820 }
8821 if self.rate_limit.is_some() {
8822 len += 1;
8823 }
8824 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkNode", len)?;
8825 if let Some(v) = self.sink_desc.as_ref() {
8826 struct_ser.serialize_field("sinkDesc", v)?;
8827 }
8828 if let Some(v) = self.table.as_ref() {
8829 struct_ser.serialize_field("table", v)?;
8830 }
8831 if self.log_store_type != 0 {
8832 let v = SinkLogStoreType::try_from(self.log_store_type)
8833 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.log_store_type)))?;
8834 struct_ser.serialize_field("logStoreType", &v)?;
8835 }
8836 if let Some(v) = self.rate_limit.as_ref() {
8837 struct_ser.serialize_field("rateLimit", v)?;
8838 }
8839 struct_ser.end()
8840 }
8841}
8842impl<'de> serde::Deserialize<'de> for SinkNode {
8843 #[allow(deprecated)]
8844 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8845 where
8846 D: serde::Deserializer<'de>,
8847 {
8848 const FIELDS: &[&str] = &[
8849 "sink_desc",
8850 "sinkDesc",
8851 "table",
8852 "log_store_type",
8853 "logStoreType",
8854 "rate_limit",
8855 "rateLimit",
8856 ];
8857
8858 #[allow(clippy::enum_variant_names)]
8859 enum GeneratedField {
8860 SinkDesc,
8861 Table,
8862 LogStoreType,
8863 RateLimit,
8864 }
8865 impl<'de> serde::Deserialize<'de> for GeneratedField {
8866 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8867 where
8868 D: serde::Deserializer<'de>,
8869 {
8870 struct GeneratedVisitor;
8871
8872 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8873 type Value = GeneratedField;
8874
8875 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8876 write!(formatter, "expected one of: {:?}", &FIELDS)
8877 }
8878
8879 #[allow(unused_variables)]
8880 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8881 where
8882 E: serde::de::Error,
8883 {
8884 match value {
8885 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
8886 "table" => Ok(GeneratedField::Table),
8887 "logStoreType" | "log_store_type" => Ok(GeneratedField::LogStoreType),
8888 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
8889 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8890 }
8891 }
8892 }
8893 deserializer.deserialize_identifier(GeneratedVisitor)
8894 }
8895 }
8896 struct GeneratedVisitor;
8897 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8898 type Value = SinkNode;
8899
8900 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8901 formatter.write_str("struct stream_plan.SinkNode")
8902 }
8903
8904 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkNode, V::Error>
8905 where
8906 V: serde::de::MapAccess<'de>,
8907 {
8908 let mut sink_desc__ = None;
8909 let mut table__ = None;
8910 let mut log_store_type__ = None;
8911 let mut rate_limit__ = None;
8912 while let Some(k) = map_.next_key()? {
8913 match k {
8914 GeneratedField::SinkDesc => {
8915 if sink_desc__.is_some() {
8916 return Err(serde::de::Error::duplicate_field("sinkDesc"));
8917 }
8918 sink_desc__ = map_.next_value()?;
8919 }
8920 GeneratedField::Table => {
8921 if table__.is_some() {
8922 return Err(serde::de::Error::duplicate_field("table"));
8923 }
8924 table__ = map_.next_value()?;
8925 }
8926 GeneratedField::LogStoreType => {
8927 if log_store_type__.is_some() {
8928 return Err(serde::de::Error::duplicate_field("logStoreType"));
8929 }
8930 log_store_type__ = Some(map_.next_value::<SinkLogStoreType>()? as i32);
8931 }
8932 GeneratedField::RateLimit => {
8933 if rate_limit__.is_some() {
8934 return Err(serde::de::Error::duplicate_field("rateLimit"));
8935 }
8936 rate_limit__ =
8937 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
8938 ;
8939 }
8940 }
8941 }
8942 Ok(SinkNode {
8943 sink_desc: sink_desc__,
8944 table: table__,
8945 log_store_type: log_store_type__.unwrap_or_default(),
8946 rate_limit: rate_limit__,
8947 })
8948 }
8949 }
8950 deserializer.deserialize_struct("stream_plan.SinkNode", FIELDS, GeneratedVisitor)
8951 }
8952}
8953impl serde::Serialize for SortNode {
8954 #[allow(deprecated)]
8955 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8956 where
8957 S: serde::Serializer,
8958 {
8959 use serde::ser::SerializeStruct;
8960 let mut len = 0;
8961 if self.state_table.is_some() {
8962 len += 1;
8963 }
8964 if self.sort_column_index != 0 {
8965 len += 1;
8966 }
8967 let mut struct_ser = serializer.serialize_struct("stream_plan.SortNode", len)?;
8968 if let Some(v) = self.state_table.as_ref() {
8969 struct_ser.serialize_field("stateTable", v)?;
8970 }
8971 if self.sort_column_index != 0 {
8972 struct_ser.serialize_field("sortColumnIndex", &self.sort_column_index)?;
8973 }
8974 struct_ser.end()
8975 }
8976}
8977impl<'de> serde::Deserialize<'de> for SortNode {
8978 #[allow(deprecated)]
8979 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8980 where
8981 D: serde::Deserializer<'de>,
8982 {
8983 const FIELDS: &[&str] = &[
8984 "state_table",
8985 "stateTable",
8986 "sort_column_index",
8987 "sortColumnIndex",
8988 ];
8989
8990 #[allow(clippy::enum_variant_names)]
8991 enum GeneratedField {
8992 StateTable,
8993 SortColumnIndex,
8994 }
8995 impl<'de> serde::Deserialize<'de> for GeneratedField {
8996 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8997 where
8998 D: serde::Deserializer<'de>,
8999 {
9000 struct GeneratedVisitor;
9001
9002 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9003 type Value = GeneratedField;
9004
9005 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9006 write!(formatter, "expected one of: {:?}", &FIELDS)
9007 }
9008
9009 #[allow(unused_variables)]
9010 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9011 where
9012 E: serde::de::Error,
9013 {
9014 match value {
9015 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9016 "sortColumnIndex" | "sort_column_index" => Ok(GeneratedField::SortColumnIndex),
9017 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9018 }
9019 }
9020 }
9021 deserializer.deserialize_identifier(GeneratedVisitor)
9022 }
9023 }
9024 struct GeneratedVisitor;
9025 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9026 type Value = SortNode;
9027
9028 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9029 formatter.write_str("struct stream_plan.SortNode")
9030 }
9031
9032 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
9033 where
9034 V: serde::de::MapAccess<'de>,
9035 {
9036 let mut state_table__ = None;
9037 let mut sort_column_index__ = None;
9038 while let Some(k) = map_.next_key()? {
9039 match k {
9040 GeneratedField::StateTable => {
9041 if state_table__.is_some() {
9042 return Err(serde::de::Error::duplicate_field("stateTable"));
9043 }
9044 state_table__ = map_.next_value()?;
9045 }
9046 GeneratedField::SortColumnIndex => {
9047 if sort_column_index__.is_some() {
9048 return Err(serde::de::Error::duplicate_field("sortColumnIndex"));
9049 }
9050 sort_column_index__ =
9051 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9052 ;
9053 }
9054 }
9055 }
9056 Ok(SortNode {
9057 state_table: state_table__,
9058 sort_column_index: sort_column_index__.unwrap_or_default(),
9059 })
9060 }
9061 }
9062 deserializer.deserialize_struct("stream_plan.SortNode", FIELDS, GeneratedVisitor)
9063 }
9064}
9065impl serde::Serialize for SourceBackfillNode {
9066 #[allow(deprecated)]
9067 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9068 where
9069 S: serde::Serializer,
9070 {
9071 use serde::ser::SerializeStruct;
9072 let mut len = 0;
9073 if self.upstream_source_id != 0 {
9074 len += 1;
9075 }
9076 if self.row_id_index.is_some() {
9077 len += 1;
9078 }
9079 if !self.columns.is_empty() {
9080 len += 1;
9081 }
9082 if self.info.is_some() {
9083 len += 1;
9084 }
9085 if !self.source_name.is_empty() {
9086 len += 1;
9087 }
9088 if !self.with_properties.is_empty() {
9089 len += 1;
9090 }
9091 if self.rate_limit.is_some() {
9092 len += 1;
9093 }
9094 if self.state_table.is_some() {
9095 len += 1;
9096 }
9097 if !self.secret_refs.is_empty() {
9098 len += 1;
9099 }
9100 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceBackfillNode", len)?;
9101 if self.upstream_source_id != 0 {
9102 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
9103 }
9104 if let Some(v) = self.row_id_index.as_ref() {
9105 struct_ser.serialize_field("rowIdIndex", v)?;
9106 }
9107 if !self.columns.is_empty() {
9108 struct_ser.serialize_field("columns", &self.columns)?;
9109 }
9110 if let Some(v) = self.info.as_ref() {
9111 struct_ser.serialize_field("info", v)?;
9112 }
9113 if !self.source_name.is_empty() {
9114 struct_ser.serialize_field("sourceName", &self.source_name)?;
9115 }
9116 if !self.with_properties.is_empty() {
9117 struct_ser.serialize_field("withProperties", &self.with_properties)?;
9118 }
9119 if let Some(v) = self.rate_limit.as_ref() {
9120 struct_ser.serialize_field("rateLimit", v)?;
9121 }
9122 if let Some(v) = self.state_table.as_ref() {
9123 struct_ser.serialize_field("stateTable", v)?;
9124 }
9125 if !self.secret_refs.is_empty() {
9126 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
9127 }
9128 struct_ser.end()
9129 }
9130}
9131impl<'de> serde::Deserialize<'de> for SourceBackfillNode {
9132 #[allow(deprecated)]
9133 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9134 where
9135 D: serde::Deserializer<'de>,
9136 {
9137 const FIELDS: &[&str] = &[
9138 "upstream_source_id",
9139 "upstreamSourceId",
9140 "row_id_index",
9141 "rowIdIndex",
9142 "columns",
9143 "info",
9144 "source_name",
9145 "sourceName",
9146 "with_properties",
9147 "withProperties",
9148 "rate_limit",
9149 "rateLimit",
9150 "state_table",
9151 "stateTable",
9152 "secret_refs",
9153 "secretRefs",
9154 ];
9155
9156 #[allow(clippy::enum_variant_names)]
9157 enum GeneratedField {
9158 UpstreamSourceId,
9159 RowIdIndex,
9160 Columns,
9161 Info,
9162 SourceName,
9163 WithProperties,
9164 RateLimit,
9165 StateTable,
9166 SecretRefs,
9167 }
9168 impl<'de> serde::Deserialize<'de> for GeneratedField {
9169 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9170 where
9171 D: serde::Deserializer<'de>,
9172 {
9173 struct GeneratedVisitor;
9174
9175 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9176 type Value = GeneratedField;
9177
9178 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9179 write!(formatter, "expected one of: {:?}", &FIELDS)
9180 }
9181
9182 #[allow(unused_variables)]
9183 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9184 where
9185 E: serde::de::Error,
9186 {
9187 match value {
9188 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
9189 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
9190 "columns" => Ok(GeneratedField::Columns),
9191 "info" => Ok(GeneratedField::Info),
9192 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
9193 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
9194 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
9195 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9196 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
9197 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9198 }
9199 }
9200 }
9201 deserializer.deserialize_identifier(GeneratedVisitor)
9202 }
9203 }
9204 struct GeneratedVisitor;
9205 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9206 type Value = SourceBackfillNode;
9207
9208 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9209 formatter.write_str("struct stream_plan.SourceBackfillNode")
9210 }
9211
9212 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceBackfillNode, V::Error>
9213 where
9214 V: serde::de::MapAccess<'de>,
9215 {
9216 let mut upstream_source_id__ = None;
9217 let mut row_id_index__ = None;
9218 let mut columns__ = None;
9219 let mut info__ = None;
9220 let mut source_name__ = None;
9221 let mut with_properties__ = None;
9222 let mut rate_limit__ = None;
9223 let mut state_table__ = None;
9224 let mut secret_refs__ = None;
9225 while let Some(k) = map_.next_key()? {
9226 match k {
9227 GeneratedField::UpstreamSourceId => {
9228 if upstream_source_id__.is_some() {
9229 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
9230 }
9231 upstream_source_id__ =
9232 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9233 ;
9234 }
9235 GeneratedField::RowIdIndex => {
9236 if row_id_index__.is_some() {
9237 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
9238 }
9239 row_id_index__ =
9240 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9241 ;
9242 }
9243 GeneratedField::Columns => {
9244 if columns__.is_some() {
9245 return Err(serde::de::Error::duplicate_field("columns"));
9246 }
9247 columns__ = Some(map_.next_value()?);
9248 }
9249 GeneratedField::Info => {
9250 if info__.is_some() {
9251 return Err(serde::de::Error::duplicate_field("info"));
9252 }
9253 info__ = map_.next_value()?;
9254 }
9255 GeneratedField::SourceName => {
9256 if source_name__.is_some() {
9257 return Err(serde::de::Error::duplicate_field("sourceName"));
9258 }
9259 source_name__ = Some(map_.next_value()?);
9260 }
9261 GeneratedField::WithProperties => {
9262 if with_properties__.is_some() {
9263 return Err(serde::de::Error::duplicate_field("withProperties"));
9264 }
9265 with_properties__ = Some(
9266 map_.next_value::<std::collections::BTreeMap<_, _>>()?
9267 );
9268 }
9269 GeneratedField::RateLimit => {
9270 if rate_limit__.is_some() {
9271 return Err(serde::de::Error::duplicate_field("rateLimit"));
9272 }
9273 rate_limit__ =
9274 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9275 ;
9276 }
9277 GeneratedField::StateTable => {
9278 if state_table__.is_some() {
9279 return Err(serde::de::Error::duplicate_field("stateTable"));
9280 }
9281 state_table__ = map_.next_value()?;
9282 }
9283 GeneratedField::SecretRefs => {
9284 if secret_refs__.is_some() {
9285 return Err(serde::de::Error::duplicate_field("secretRefs"));
9286 }
9287 secret_refs__ = Some(
9288 map_.next_value::<std::collections::BTreeMap<_, _>>()?
9289 );
9290 }
9291 }
9292 }
9293 Ok(SourceBackfillNode {
9294 upstream_source_id: upstream_source_id__.unwrap_or_default(),
9295 row_id_index: row_id_index__,
9296 columns: columns__.unwrap_or_default(),
9297 info: info__,
9298 source_name: source_name__.unwrap_or_default(),
9299 with_properties: with_properties__.unwrap_or_default(),
9300 rate_limit: rate_limit__,
9301 state_table: state_table__,
9302 secret_refs: secret_refs__.unwrap_or_default(),
9303 })
9304 }
9305 }
9306 deserializer.deserialize_struct("stream_plan.SourceBackfillNode", FIELDS, GeneratedVisitor)
9307 }
9308}
9309impl serde::Serialize for SourceChangeSplitMutation {
9310 #[allow(deprecated)]
9311 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9312 where
9313 S: serde::Serializer,
9314 {
9315 use serde::ser::SerializeStruct;
9316 let mut len = 0;
9317 if !self.actor_splits.is_empty() {
9318 len += 1;
9319 }
9320 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceChangeSplitMutation", len)?;
9321 if !self.actor_splits.is_empty() {
9322 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
9323 }
9324 struct_ser.end()
9325 }
9326}
9327impl<'de> serde::Deserialize<'de> for SourceChangeSplitMutation {
9328 #[allow(deprecated)]
9329 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9330 where
9331 D: serde::Deserializer<'de>,
9332 {
9333 const FIELDS: &[&str] = &[
9334 "actor_splits",
9335 "actorSplits",
9336 ];
9337
9338 #[allow(clippy::enum_variant_names)]
9339 enum GeneratedField {
9340 ActorSplits,
9341 }
9342 impl<'de> serde::Deserialize<'de> for GeneratedField {
9343 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9344 where
9345 D: serde::Deserializer<'de>,
9346 {
9347 struct GeneratedVisitor;
9348
9349 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9350 type Value = GeneratedField;
9351
9352 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9353 write!(formatter, "expected one of: {:?}", &FIELDS)
9354 }
9355
9356 #[allow(unused_variables)]
9357 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9358 where
9359 E: serde::de::Error,
9360 {
9361 match value {
9362 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
9363 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9364 }
9365 }
9366 }
9367 deserializer.deserialize_identifier(GeneratedVisitor)
9368 }
9369 }
9370 struct GeneratedVisitor;
9371 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9372 type Value = SourceChangeSplitMutation;
9373
9374 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9375 formatter.write_str("struct stream_plan.SourceChangeSplitMutation")
9376 }
9377
9378 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceChangeSplitMutation, V::Error>
9379 where
9380 V: serde::de::MapAccess<'de>,
9381 {
9382 let mut actor_splits__ = None;
9383 while let Some(k) = map_.next_key()? {
9384 match k {
9385 GeneratedField::ActorSplits => {
9386 if actor_splits__.is_some() {
9387 return Err(serde::de::Error::duplicate_field("actorSplits"));
9388 }
9389 actor_splits__ = Some(
9390 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
9391 .into_iter().map(|(k,v)| (k.0, v)).collect()
9392 );
9393 }
9394 }
9395 }
9396 Ok(SourceChangeSplitMutation {
9397 actor_splits: actor_splits__.unwrap_or_default(),
9398 })
9399 }
9400 }
9401 deserializer.deserialize_struct("stream_plan.SourceChangeSplitMutation", FIELDS, GeneratedVisitor)
9402 }
9403}
9404impl serde::Serialize for SourceNode {
9405 #[allow(deprecated)]
9406 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9407 where
9408 S: serde::Serializer,
9409 {
9410 use serde::ser::SerializeStruct;
9411 let mut len = 0;
9412 if self.source_inner.is_some() {
9413 len += 1;
9414 }
9415 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceNode", len)?;
9416 if let Some(v) = self.source_inner.as_ref() {
9417 struct_ser.serialize_field("sourceInner", v)?;
9418 }
9419 struct_ser.end()
9420 }
9421}
9422impl<'de> serde::Deserialize<'de> for SourceNode {
9423 #[allow(deprecated)]
9424 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9425 where
9426 D: serde::Deserializer<'de>,
9427 {
9428 const FIELDS: &[&str] = &[
9429 "source_inner",
9430 "sourceInner",
9431 ];
9432
9433 #[allow(clippy::enum_variant_names)]
9434 enum GeneratedField {
9435 SourceInner,
9436 }
9437 impl<'de> serde::Deserialize<'de> for GeneratedField {
9438 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9439 where
9440 D: serde::Deserializer<'de>,
9441 {
9442 struct GeneratedVisitor;
9443
9444 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9445 type Value = GeneratedField;
9446
9447 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9448 write!(formatter, "expected one of: {:?}", &FIELDS)
9449 }
9450
9451 #[allow(unused_variables)]
9452 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9453 where
9454 E: serde::de::Error,
9455 {
9456 match value {
9457 "sourceInner" | "source_inner" => Ok(GeneratedField::SourceInner),
9458 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9459 }
9460 }
9461 }
9462 deserializer.deserialize_identifier(GeneratedVisitor)
9463 }
9464 }
9465 struct GeneratedVisitor;
9466 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9467 type Value = SourceNode;
9468
9469 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9470 formatter.write_str("struct stream_plan.SourceNode")
9471 }
9472
9473 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
9474 where
9475 V: serde::de::MapAccess<'de>,
9476 {
9477 let mut source_inner__ = None;
9478 while let Some(k) = map_.next_key()? {
9479 match k {
9480 GeneratedField::SourceInner => {
9481 if source_inner__.is_some() {
9482 return Err(serde::de::Error::duplicate_field("sourceInner"));
9483 }
9484 source_inner__ = map_.next_value()?;
9485 }
9486 }
9487 }
9488 Ok(SourceNode {
9489 source_inner: source_inner__,
9490 })
9491 }
9492 }
9493 deserializer.deserialize_struct("stream_plan.SourceNode", FIELDS, GeneratedVisitor)
9494 }
9495}
9496impl serde::Serialize for StartFragmentBackfillMutation {
9497 #[allow(deprecated)]
9498 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9499 where
9500 S: serde::Serializer,
9501 {
9502 use serde::ser::SerializeStruct;
9503 let mut len = 0;
9504 if !self.fragment_ids.is_empty() {
9505 len += 1;
9506 }
9507 let mut struct_ser = serializer.serialize_struct("stream_plan.StartFragmentBackfillMutation", len)?;
9508 if !self.fragment_ids.is_empty() {
9509 struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
9510 }
9511 struct_ser.end()
9512 }
9513}
9514impl<'de> serde::Deserialize<'de> for StartFragmentBackfillMutation {
9515 #[allow(deprecated)]
9516 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9517 where
9518 D: serde::Deserializer<'de>,
9519 {
9520 const FIELDS: &[&str] = &[
9521 "fragment_ids",
9522 "fragmentIds",
9523 ];
9524
9525 #[allow(clippy::enum_variant_names)]
9526 enum GeneratedField {
9527 FragmentIds,
9528 }
9529 impl<'de> serde::Deserialize<'de> for GeneratedField {
9530 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9531 where
9532 D: serde::Deserializer<'de>,
9533 {
9534 struct GeneratedVisitor;
9535
9536 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9537 type Value = GeneratedField;
9538
9539 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9540 write!(formatter, "expected one of: {:?}", &FIELDS)
9541 }
9542
9543 #[allow(unused_variables)]
9544 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9545 where
9546 E: serde::de::Error,
9547 {
9548 match value {
9549 "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
9550 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9551 }
9552 }
9553 }
9554 deserializer.deserialize_identifier(GeneratedVisitor)
9555 }
9556 }
9557 struct GeneratedVisitor;
9558 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9559 type Value = StartFragmentBackfillMutation;
9560
9561 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9562 formatter.write_str("struct stream_plan.StartFragmentBackfillMutation")
9563 }
9564
9565 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StartFragmentBackfillMutation, V::Error>
9566 where
9567 V: serde::de::MapAccess<'de>,
9568 {
9569 let mut fragment_ids__ = None;
9570 while let Some(k) = map_.next_key()? {
9571 match k {
9572 GeneratedField::FragmentIds => {
9573 if fragment_ids__.is_some() {
9574 return Err(serde::de::Error::duplicate_field("fragmentIds"));
9575 }
9576 fragment_ids__ =
9577 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9578 .into_iter().map(|x| x.0).collect())
9579 ;
9580 }
9581 }
9582 }
9583 Ok(StartFragmentBackfillMutation {
9584 fragment_ids: fragment_ids__.unwrap_or_default(),
9585 })
9586 }
9587 }
9588 deserializer.deserialize_struct("stream_plan.StartFragmentBackfillMutation", FIELDS, GeneratedVisitor)
9589 }
9590}
9591impl serde::Serialize for StopMutation {
9592 #[allow(deprecated)]
9593 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9594 where
9595 S: serde::Serializer,
9596 {
9597 use serde::ser::SerializeStruct;
9598 let mut len = 0;
9599 if !self.actors.is_empty() {
9600 len += 1;
9601 }
9602 let mut struct_ser = serializer.serialize_struct("stream_plan.StopMutation", len)?;
9603 if !self.actors.is_empty() {
9604 struct_ser.serialize_field("actors", &self.actors)?;
9605 }
9606 struct_ser.end()
9607 }
9608}
9609impl<'de> serde::Deserialize<'de> for StopMutation {
9610 #[allow(deprecated)]
9611 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9612 where
9613 D: serde::Deserializer<'de>,
9614 {
9615 const FIELDS: &[&str] = &[
9616 "actors",
9617 ];
9618
9619 #[allow(clippy::enum_variant_names)]
9620 enum GeneratedField {
9621 Actors,
9622 }
9623 impl<'de> serde::Deserialize<'de> for GeneratedField {
9624 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9625 where
9626 D: serde::Deserializer<'de>,
9627 {
9628 struct GeneratedVisitor;
9629
9630 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9631 type Value = GeneratedField;
9632
9633 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9634 write!(formatter, "expected one of: {:?}", &FIELDS)
9635 }
9636
9637 #[allow(unused_variables)]
9638 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9639 where
9640 E: serde::de::Error,
9641 {
9642 match value {
9643 "actors" => Ok(GeneratedField::Actors),
9644 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9645 }
9646 }
9647 }
9648 deserializer.deserialize_identifier(GeneratedVisitor)
9649 }
9650 }
9651 struct GeneratedVisitor;
9652 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9653 type Value = StopMutation;
9654
9655 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9656 formatter.write_str("struct stream_plan.StopMutation")
9657 }
9658
9659 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopMutation, V::Error>
9660 where
9661 V: serde::de::MapAccess<'de>,
9662 {
9663 let mut actors__ = None;
9664 while let Some(k) = map_.next_key()? {
9665 match k {
9666 GeneratedField::Actors => {
9667 if actors__.is_some() {
9668 return Err(serde::de::Error::duplicate_field("actors"));
9669 }
9670 actors__ =
9671 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9672 .into_iter().map(|x| x.0).collect())
9673 ;
9674 }
9675 }
9676 }
9677 Ok(StopMutation {
9678 actors: actors__.unwrap_or_default(),
9679 })
9680 }
9681 }
9682 deserializer.deserialize_struct("stream_plan.StopMutation", FIELDS, GeneratedVisitor)
9683 }
9684}
9685impl serde::Serialize for StreamActor {
9686 #[allow(deprecated)]
9687 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9688 where
9689 S: serde::Serializer,
9690 {
9691 use serde::ser::SerializeStruct;
9692 let mut len = 0;
9693 if self.actor_id != 0 {
9694 len += 1;
9695 }
9696 if self.fragment_id != 0 {
9697 len += 1;
9698 }
9699 if !self.dispatcher.is_empty() {
9700 len += 1;
9701 }
9702 if self.vnode_bitmap.is_some() {
9703 len += 1;
9704 }
9705 if !self.mview_definition.is_empty() {
9706 len += 1;
9707 }
9708 if self.expr_context.is_some() {
9709 len += 1;
9710 }
9711 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamActor", len)?;
9712 if self.actor_id != 0 {
9713 struct_ser.serialize_field("actorId", &self.actor_id)?;
9714 }
9715 if self.fragment_id != 0 {
9716 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
9717 }
9718 if !self.dispatcher.is_empty() {
9719 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
9720 }
9721 if let Some(v) = self.vnode_bitmap.as_ref() {
9722 struct_ser.serialize_field("vnodeBitmap", v)?;
9723 }
9724 if !self.mview_definition.is_empty() {
9725 struct_ser.serialize_field("mviewDefinition", &self.mview_definition)?;
9726 }
9727 if let Some(v) = self.expr_context.as_ref() {
9728 struct_ser.serialize_field("exprContext", v)?;
9729 }
9730 struct_ser.end()
9731 }
9732}
9733impl<'de> serde::Deserialize<'de> for StreamActor {
9734 #[allow(deprecated)]
9735 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9736 where
9737 D: serde::Deserializer<'de>,
9738 {
9739 const FIELDS: &[&str] = &[
9740 "actor_id",
9741 "actorId",
9742 "fragment_id",
9743 "fragmentId",
9744 "dispatcher",
9745 "vnode_bitmap",
9746 "vnodeBitmap",
9747 "mview_definition",
9748 "mviewDefinition",
9749 "expr_context",
9750 "exprContext",
9751 ];
9752
9753 #[allow(clippy::enum_variant_names)]
9754 enum GeneratedField {
9755 ActorId,
9756 FragmentId,
9757 Dispatcher,
9758 VnodeBitmap,
9759 MviewDefinition,
9760 ExprContext,
9761 }
9762 impl<'de> serde::Deserialize<'de> for GeneratedField {
9763 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9764 where
9765 D: serde::Deserializer<'de>,
9766 {
9767 struct GeneratedVisitor;
9768
9769 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9770 type Value = GeneratedField;
9771
9772 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9773 write!(formatter, "expected one of: {:?}", &FIELDS)
9774 }
9775
9776 #[allow(unused_variables)]
9777 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9778 where
9779 E: serde::de::Error,
9780 {
9781 match value {
9782 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
9783 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
9784 "dispatcher" => Ok(GeneratedField::Dispatcher),
9785 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
9786 "mviewDefinition" | "mview_definition" => Ok(GeneratedField::MviewDefinition),
9787 "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
9788 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9789 }
9790 }
9791 }
9792 deserializer.deserialize_identifier(GeneratedVisitor)
9793 }
9794 }
9795 struct GeneratedVisitor;
9796 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9797 type Value = StreamActor;
9798
9799 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9800 formatter.write_str("struct stream_plan.StreamActor")
9801 }
9802
9803 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamActor, V::Error>
9804 where
9805 V: serde::de::MapAccess<'de>,
9806 {
9807 let mut actor_id__ = None;
9808 let mut fragment_id__ = None;
9809 let mut dispatcher__ = None;
9810 let mut vnode_bitmap__ = None;
9811 let mut mview_definition__ = None;
9812 let mut expr_context__ = None;
9813 while let Some(k) = map_.next_key()? {
9814 match k {
9815 GeneratedField::ActorId => {
9816 if actor_id__.is_some() {
9817 return Err(serde::de::Error::duplicate_field("actorId"));
9818 }
9819 actor_id__ =
9820 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9821 ;
9822 }
9823 GeneratedField::FragmentId => {
9824 if fragment_id__.is_some() {
9825 return Err(serde::de::Error::duplicate_field("fragmentId"));
9826 }
9827 fragment_id__ =
9828 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9829 ;
9830 }
9831 GeneratedField::Dispatcher => {
9832 if dispatcher__.is_some() {
9833 return Err(serde::de::Error::duplicate_field("dispatcher"));
9834 }
9835 dispatcher__ = Some(map_.next_value()?);
9836 }
9837 GeneratedField::VnodeBitmap => {
9838 if vnode_bitmap__.is_some() {
9839 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
9840 }
9841 vnode_bitmap__ = map_.next_value()?;
9842 }
9843 GeneratedField::MviewDefinition => {
9844 if mview_definition__.is_some() {
9845 return Err(serde::de::Error::duplicate_field("mviewDefinition"));
9846 }
9847 mview_definition__ = Some(map_.next_value()?);
9848 }
9849 GeneratedField::ExprContext => {
9850 if expr_context__.is_some() {
9851 return Err(serde::de::Error::duplicate_field("exprContext"));
9852 }
9853 expr_context__ = map_.next_value()?;
9854 }
9855 }
9856 }
9857 Ok(StreamActor {
9858 actor_id: actor_id__.unwrap_or_default(),
9859 fragment_id: fragment_id__.unwrap_or_default(),
9860 dispatcher: dispatcher__.unwrap_or_default(),
9861 vnode_bitmap: vnode_bitmap__,
9862 mview_definition: mview_definition__.unwrap_or_default(),
9863 expr_context: expr_context__,
9864 })
9865 }
9866 }
9867 deserializer.deserialize_struct("stream_plan.StreamActor", FIELDS, GeneratedVisitor)
9868 }
9869}
9870impl serde::Serialize for StreamCdcScanNode {
9871 #[allow(deprecated)]
9872 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9873 where
9874 S: serde::Serializer,
9875 {
9876 use serde::ser::SerializeStruct;
9877 let mut len = 0;
9878 if self.table_id != 0 {
9879 len += 1;
9880 }
9881 if !self.upstream_column_ids.is_empty() {
9882 len += 1;
9883 }
9884 if !self.output_indices.is_empty() {
9885 len += 1;
9886 }
9887 if self.state_table.is_some() {
9888 len += 1;
9889 }
9890 if self.cdc_table_desc.is_some() {
9891 len += 1;
9892 }
9893 if self.rate_limit.is_some() {
9894 len += 1;
9895 }
9896 if self.disable_backfill {
9897 len += 1;
9898 }
9899 if self.options.is_some() {
9900 len += 1;
9901 }
9902 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanNode", len)?;
9903 if self.table_id != 0 {
9904 struct_ser.serialize_field("tableId", &self.table_id)?;
9905 }
9906 if !self.upstream_column_ids.is_empty() {
9907 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
9908 }
9909 if !self.output_indices.is_empty() {
9910 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
9911 }
9912 if let Some(v) = self.state_table.as_ref() {
9913 struct_ser.serialize_field("stateTable", v)?;
9914 }
9915 if let Some(v) = self.cdc_table_desc.as_ref() {
9916 struct_ser.serialize_field("cdcTableDesc", v)?;
9917 }
9918 if let Some(v) = self.rate_limit.as_ref() {
9919 struct_ser.serialize_field("rateLimit", v)?;
9920 }
9921 if self.disable_backfill {
9922 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
9923 }
9924 if let Some(v) = self.options.as_ref() {
9925 struct_ser.serialize_field("options", v)?;
9926 }
9927 struct_ser.end()
9928 }
9929}
9930impl<'de> serde::Deserialize<'de> for StreamCdcScanNode {
9931 #[allow(deprecated)]
9932 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9933 where
9934 D: serde::Deserializer<'de>,
9935 {
9936 const FIELDS: &[&str] = &[
9937 "table_id",
9938 "tableId",
9939 "upstream_column_ids",
9940 "upstreamColumnIds",
9941 "output_indices",
9942 "outputIndices",
9943 "state_table",
9944 "stateTable",
9945 "cdc_table_desc",
9946 "cdcTableDesc",
9947 "rate_limit",
9948 "rateLimit",
9949 "disable_backfill",
9950 "disableBackfill",
9951 "options",
9952 ];
9953
9954 #[allow(clippy::enum_variant_names)]
9955 enum GeneratedField {
9956 TableId,
9957 UpstreamColumnIds,
9958 OutputIndices,
9959 StateTable,
9960 CdcTableDesc,
9961 RateLimit,
9962 DisableBackfill,
9963 Options,
9964 }
9965 impl<'de> serde::Deserialize<'de> for GeneratedField {
9966 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9967 where
9968 D: serde::Deserializer<'de>,
9969 {
9970 struct GeneratedVisitor;
9971
9972 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9973 type Value = GeneratedField;
9974
9975 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9976 write!(formatter, "expected one of: {:?}", &FIELDS)
9977 }
9978
9979 #[allow(unused_variables)]
9980 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9981 where
9982 E: serde::de::Error,
9983 {
9984 match value {
9985 "tableId" | "table_id" => Ok(GeneratedField::TableId),
9986 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
9987 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
9988 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9989 "cdcTableDesc" | "cdc_table_desc" => Ok(GeneratedField::CdcTableDesc),
9990 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
9991 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
9992 "options" => Ok(GeneratedField::Options),
9993 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9994 }
9995 }
9996 }
9997 deserializer.deserialize_identifier(GeneratedVisitor)
9998 }
9999 }
10000 struct GeneratedVisitor;
10001 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10002 type Value = StreamCdcScanNode;
10003
10004 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10005 formatter.write_str("struct stream_plan.StreamCdcScanNode")
10006 }
10007
10008 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanNode, V::Error>
10009 where
10010 V: serde::de::MapAccess<'de>,
10011 {
10012 let mut table_id__ = None;
10013 let mut upstream_column_ids__ = None;
10014 let mut output_indices__ = None;
10015 let mut state_table__ = None;
10016 let mut cdc_table_desc__ = None;
10017 let mut rate_limit__ = None;
10018 let mut disable_backfill__ = None;
10019 let mut options__ = None;
10020 while let Some(k) = map_.next_key()? {
10021 match k {
10022 GeneratedField::TableId => {
10023 if table_id__.is_some() {
10024 return Err(serde::de::Error::duplicate_field("tableId"));
10025 }
10026 table_id__ =
10027 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10028 ;
10029 }
10030 GeneratedField::UpstreamColumnIds => {
10031 if upstream_column_ids__.is_some() {
10032 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
10033 }
10034 upstream_column_ids__ =
10035 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10036 .into_iter().map(|x| x.0).collect())
10037 ;
10038 }
10039 GeneratedField::OutputIndices => {
10040 if output_indices__.is_some() {
10041 return Err(serde::de::Error::duplicate_field("outputIndices"));
10042 }
10043 output_indices__ =
10044 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10045 .into_iter().map(|x| x.0).collect())
10046 ;
10047 }
10048 GeneratedField::StateTable => {
10049 if state_table__.is_some() {
10050 return Err(serde::de::Error::duplicate_field("stateTable"));
10051 }
10052 state_table__ = map_.next_value()?;
10053 }
10054 GeneratedField::CdcTableDesc => {
10055 if cdc_table_desc__.is_some() {
10056 return Err(serde::de::Error::duplicate_field("cdcTableDesc"));
10057 }
10058 cdc_table_desc__ = map_.next_value()?;
10059 }
10060 GeneratedField::RateLimit => {
10061 if rate_limit__.is_some() {
10062 return Err(serde::de::Error::duplicate_field("rateLimit"));
10063 }
10064 rate_limit__ =
10065 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10066 ;
10067 }
10068 GeneratedField::DisableBackfill => {
10069 if disable_backfill__.is_some() {
10070 return Err(serde::de::Error::duplicate_field("disableBackfill"));
10071 }
10072 disable_backfill__ = Some(map_.next_value()?);
10073 }
10074 GeneratedField::Options => {
10075 if options__.is_some() {
10076 return Err(serde::de::Error::duplicate_field("options"));
10077 }
10078 options__ = map_.next_value()?;
10079 }
10080 }
10081 }
10082 Ok(StreamCdcScanNode {
10083 table_id: table_id__.unwrap_or_default(),
10084 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
10085 output_indices: output_indices__.unwrap_or_default(),
10086 state_table: state_table__,
10087 cdc_table_desc: cdc_table_desc__,
10088 rate_limit: rate_limit__,
10089 disable_backfill: disable_backfill__.unwrap_or_default(),
10090 options: options__,
10091 })
10092 }
10093 }
10094 deserializer.deserialize_struct("stream_plan.StreamCdcScanNode", FIELDS, GeneratedVisitor)
10095 }
10096}
10097impl serde::Serialize for StreamCdcScanOptions {
10098 #[allow(deprecated)]
10099 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10100 where
10101 S: serde::Serializer,
10102 {
10103 use serde::ser::SerializeStruct;
10104 let mut len = 0;
10105 if self.disable_backfill {
10106 len += 1;
10107 }
10108 if self.snapshot_barrier_interval != 0 {
10109 len += 1;
10110 }
10111 if self.snapshot_batch_size != 0 {
10112 len += 1;
10113 }
10114 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanOptions", len)?;
10115 if self.disable_backfill {
10116 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
10117 }
10118 if self.snapshot_barrier_interval != 0 {
10119 struct_ser.serialize_field("snapshotBarrierInterval", &self.snapshot_barrier_interval)?;
10120 }
10121 if self.snapshot_batch_size != 0 {
10122 struct_ser.serialize_field("snapshotBatchSize", &self.snapshot_batch_size)?;
10123 }
10124 struct_ser.end()
10125 }
10126}
10127impl<'de> serde::Deserialize<'de> for StreamCdcScanOptions {
10128 #[allow(deprecated)]
10129 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10130 where
10131 D: serde::Deserializer<'de>,
10132 {
10133 const FIELDS: &[&str] = &[
10134 "disable_backfill",
10135 "disableBackfill",
10136 "snapshot_barrier_interval",
10137 "snapshotBarrierInterval",
10138 "snapshot_batch_size",
10139 "snapshotBatchSize",
10140 ];
10141
10142 #[allow(clippy::enum_variant_names)]
10143 enum GeneratedField {
10144 DisableBackfill,
10145 SnapshotBarrierInterval,
10146 SnapshotBatchSize,
10147 }
10148 impl<'de> serde::Deserialize<'de> for GeneratedField {
10149 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10150 where
10151 D: serde::Deserializer<'de>,
10152 {
10153 struct GeneratedVisitor;
10154
10155 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10156 type Value = GeneratedField;
10157
10158 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10159 write!(formatter, "expected one of: {:?}", &FIELDS)
10160 }
10161
10162 #[allow(unused_variables)]
10163 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10164 where
10165 E: serde::de::Error,
10166 {
10167 match value {
10168 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
10169 "snapshotBarrierInterval" | "snapshot_barrier_interval" => Ok(GeneratedField::SnapshotBarrierInterval),
10170 "snapshotBatchSize" | "snapshot_batch_size" => Ok(GeneratedField::SnapshotBatchSize),
10171 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10172 }
10173 }
10174 }
10175 deserializer.deserialize_identifier(GeneratedVisitor)
10176 }
10177 }
10178 struct GeneratedVisitor;
10179 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10180 type Value = StreamCdcScanOptions;
10181
10182 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10183 formatter.write_str("struct stream_plan.StreamCdcScanOptions")
10184 }
10185
10186 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanOptions, V::Error>
10187 where
10188 V: serde::de::MapAccess<'de>,
10189 {
10190 let mut disable_backfill__ = None;
10191 let mut snapshot_barrier_interval__ = None;
10192 let mut snapshot_batch_size__ = None;
10193 while let Some(k) = map_.next_key()? {
10194 match k {
10195 GeneratedField::DisableBackfill => {
10196 if disable_backfill__.is_some() {
10197 return Err(serde::de::Error::duplicate_field("disableBackfill"));
10198 }
10199 disable_backfill__ = Some(map_.next_value()?);
10200 }
10201 GeneratedField::SnapshotBarrierInterval => {
10202 if snapshot_barrier_interval__.is_some() {
10203 return Err(serde::de::Error::duplicate_field("snapshotBarrierInterval"));
10204 }
10205 snapshot_barrier_interval__ =
10206 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10207 ;
10208 }
10209 GeneratedField::SnapshotBatchSize => {
10210 if snapshot_batch_size__.is_some() {
10211 return Err(serde::de::Error::duplicate_field("snapshotBatchSize"));
10212 }
10213 snapshot_batch_size__ =
10214 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10215 ;
10216 }
10217 }
10218 }
10219 Ok(StreamCdcScanOptions {
10220 disable_backfill: disable_backfill__.unwrap_or_default(),
10221 snapshot_barrier_interval: snapshot_barrier_interval__.unwrap_or_default(),
10222 snapshot_batch_size: snapshot_batch_size__.unwrap_or_default(),
10223 })
10224 }
10225 }
10226 deserializer.deserialize_struct("stream_plan.StreamCdcScanOptions", FIELDS, GeneratedVisitor)
10227 }
10228}
10229impl serde::Serialize for StreamContext {
10230 #[allow(deprecated)]
10231 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10232 where
10233 S: serde::Serializer,
10234 {
10235 use serde::ser::SerializeStruct;
10236 let mut len = 0;
10237 if !self.timezone.is_empty() {
10238 len += 1;
10239 }
10240 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamContext", len)?;
10241 if !self.timezone.is_empty() {
10242 struct_ser.serialize_field("timezone", &self.timezone)?;
10243 }
10244 struct_ser.end()
10245 }
10246}
10247impl<'de> serde::Deserialize<'de> for StreamContext {
10248 #[allow(deprecated)]
10249 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10250 where
10251 D: serde::Deserializer<'de>,
10252 {
10253 const FIELDS: &[&str] = &[
10254 "timezone",
10255 ];
10256
10257 #[allow(clippy::enum_variant_names)]
10258 enum GeneratedField {
10259 Timezone,
10260 }
10261 impl<'de> serde::Deserialize<'de> for GeneratedField {
10262 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10263 where
10264 D: serde::Deserializer<'de>,
10265 {
10266 struct GeneratedVisitor;
10267
10268 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10269 type Value = GeneratedField;
10270
10271 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10272 write!(formatter, "expected one of: {:?}", &FIELDS)
10273 }
10274
10275 #[allow(unused_variables)]
10276 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10277 where
10278 E: serde::de::Error,
10279 {
10280 match value {
10281 "timezone" => Ok(GeneratedField::Timezone),
10282 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10283 }
10284 }
10285 }
10286 deserializer.deserialize_identifier(GeneratedVisitor)
10287 }
10288 }
10289 struct GeneratedVisitor;
10290 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10291 type Value = StreamContext;
10292
10293 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10294 formatter.write_str("struct stream_plan.StreamContext")
10295 }
10296
10297 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamContext, V::Error>
10298 where
10299 V: serde::de::MapAccess<'de>,
10300 {
10301 let mut timezone__ = None;
10302 while let Some(k) = map_.next_key()? {
10303 match k {
10304 GeneratedField::Timezone => {
10305 if timezone__.is_some() {
10306 return Err(serde::de::Error::duplicate_field("timezone"));
10307 }
10308 timezone__ = Some(map_.next_value()?);
10309 }
10310 }
10311 }
10312 Ok(StreamContext {
10313 timezone: timezone__.unwrap_or_default(),
10314 })
10315 }
10316 }
10317 deserializer.deserialize_struct("stream_plan.StreamContext", FIELDS, GeneratedVisitor)
10318 }
10319}
10320impl serde::Serialize for StreamFragmentGraph {
10321 #[allow(deprecated)]
10322 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10323 where
10324 S: serde::Serializer,
10325 {
10326 use serde::ser::SerializeStruct;
10327 let mut len = 0;
10328 if !self.fragments.is_empty() {
10329 len += 1;
10330 }
10331 if !self.edges.is_empty() {
10332 len += 1;
10333 }
10334 if !self.dependent_table_ids.is_empty() {
10335 len += 1;
10336 }
10337 if self.table_ids_cnt != 0 {
10338 len += 1;
10339 }
10340 if self.ctx.is_some() {
10341 len += 1;
10342 }
10343 if self.parallelism.is_some() {
10344 len += 1;
10345 }
10346 if self.max_parallelism != 0 {
10347 len += 1;
10348 }
10349 if self.backfill_order.is_some() {
10350 len += 1;
10351 }
10352 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph", len)?;
10353 if !self.fragments.is_empty() {
10354 struct_ser.serialize_field("fragments", &self.fragments)?;
10355 }
10356 if !self.edges.is_empty() {
10357 struct_ser.serialize_field("edges", &self.edges)?;
10358 }
10359 if !self.dependent_table_ids.is_empty() {
10360 struct_ser.serialize_field("dependentTableIds", &self.dependent_table_ids)?;
10361 }
10362 if self.table_ids_cnt != 0 {
10363 struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
10364 }
10365 if let Some(v) = self.ctx.as_ref() {
10366 struct_ser.serialize_field("ctx", v)?;
10367 }
10368 if let Some(v) = self.parallelism.as_ref() {
10369 struct_ser.serialize_field("parallelism", v)?;
10370 }
10371 if self.max_parallelism != 0 {
10372 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
10373 }
10374 if let Some(v) = self.backfill_order.as_ref() {
10375 struct_ser.serialize_field("backfillOrder", v)?;
10376 }
10377 struct_ser.end()
10378 }
10379}
10380impl<'de> serde::Deserialize<'de> for StreamFragmentGraph {
10381 #[allow(deprecated)]
10382 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10383 where
10384 D: serde::Deserializer<'de>,
10385 {
10386 const FIELDS: &[&str] = &[
10387 "fragments",
10388 "edges",
10389 "dependent_table_ids",
10390 "dependentTableIds",
10391 "table_ids_cnt",
10392 "tableIdsCnt",
10393 "ctx",
10394 "parallelism",
10395 "max_parallelism",
10396 "maxParallelism",
10397 "backfill_order",
10398 "backfillOrder",
10399 ];
10400
10401 #[allow(clippy::enum_variant_names)]
10402 enum GeneratedField {
10403 Fragments,
10404 Edges,
10405 DependentTableIds,
10406 TableIdsCnt,
10407 Ctx,
10408 Parallelism,
10409 MaxParallelism,
10410 BackfillOrder,
10411 }
10412 impl<'de> serde::Deserialize<'de> for GeneratedField {
10413 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10414 where
10415 D: serde::Deserializer<'de>,
10416 {
10417 struct GeneratedVisitor;
10418
10419 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10420 type Value = GeneratedField;
10421
10422 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10423 write!(formatter, "expected one of: {:?}", &FIELDS)
10424 }
10425
10426 #[allow(unused_variables)]
10427 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10428 where
10429 E: serde::de::Error,
10430 {
10431 match value {
10432 "fragments" => Ok(GeneratedField::Fragments),
10433 "edges" => Ok(GeneratedField::Edges),
10434 "dependentTableIds" | "dependent_table_ids" => Ok(GeneratedField::DependentTableIds),
10435 "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
10436 "ctx" => Ok(GeneratedField::Ctx),
10437 "parallelism" => Ok(GeneratedField::Parallelism),
10438 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
10439 "backfillOrder" | "backfill_order" => Ok(GeneratedField::BackfillOrder),
10440 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10441 }
10442 }
10443 }
10444 deserializer.deserialize_identifier(GeneratedVisitor)
10445 }
10446 }
10447 struct GeneratedVisitor;
10448 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10449 type Value = StreamFragmentGraph;
10450
10451 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10452 formatter.write_str("struct stream_plan.StreamFragmentGraph")
10453 }
10454
10455 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFragmentGraph, V::Error>
10456 where
10457 V: serde::de::MapAccess<'de>,
10458 {
10459 let mut fragments__ = None;
10460 let mut edges__ = None;
10461 let mut dependent_table_ids__ = None;
10462 let mut table_ids_cnt__ = None;
10463 let mut ctx__ = None;
10464 let mut parallelism__ = None;
10465 let mut max_parallelism__ = None;
10466 let mut backfill_order__ = None;
10467 while let Some(k) = map_.next_key()? {
10468 match k {
10469 GeneratedField::Fragments => {
10470 if fragments__.is_some() {
10471 return Err(serde::de::Error::duplicate_field("fragments"));
10472 }
10473 fragments__ = Some(
10474 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10475 .into_iter().map(|(k,v)| (k.0, v)).collect()
10476 );
10477 }
10478 GeneratedField::Edges => {
10479 if edges__.is_some() {
10480 return Err(serde::de::Error::duplicate_field("edges"));
10481 }
10482 edges__ = Some(map_.next_value()?);
10483 }
10484 GeneratedField::DependentTableIds => {
10485 if dependent_table_ids__.is_some() {
10486 return Err(serde::de::Error::duplicate_field("dependentTableIds"));
10487 }
10488 dependent_table_ids__ =
10489 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10490 .into_iter().map(|x| x.0).collect())
10491 ;
10492 }
10493 GeneratedField::TableIdsCnt => {
10494 if table_ids_cnt__.is_some() {
10495 return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
10496 }
10497 table_ids_cnt__ =
10498 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10499 ;
10500 }
10501 GeneratedField::Ctx => {
10502 if ctx__.is_some() {
10503 return Err(serde::de::Error::duplicate_field("ctx"));
10504 }
10505 ctx__ = map_.next_value()?;
10506 }
10507 GeneratedField::Parallelism => {
10508 if parallelism__.is_some() {
10509 return Err(serde::de::Error::duplicate_field("parallelism"));
10510 }
10511 parallelism__ = map_.next_value()?;
10512 }
10513 GeneratedField::MaxParallelism => {
10514 if max_parallelism__.is_some() {
10515 return Err(serde::de::Error::duplicate_field("maxParallelism"));
10516 }
10517 max_parallelism__ =
10518 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10519 ;
10520 }
10521 GeneratedField::BackfillOrder => {
10522 if backfill_order__.is_some() {
10523 return Err(serde::de::Error::duplicate_field("backfillOrder"));
10524 }
10525 backfill_order__ = map_.next_value()?;
10526 }
10527 }
10528 }
10529 Ok(StreamFragmentGraph {
10530 fragments: fragments__.unwrap_or_default(),
10531 edges: edges__.unwrap_or_default(),
10532 dependent_table_ids: dependent_table_ids__.unwrap_or_default(),
10533 table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
10534 ctx: ctx__,
10535 parallelism: parallelism__,
10536 max_parallelism: max_parallelism__.unwrap_or_default(),
10537 backfill_order: backfill_order__,
10538 })
10539 }
10540 }
10541 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph", FIELDS, GeneratedVisitor)
10542 }
10543}
10544impl serde::Serialize for stream_fragment_graph::Parallelism {
10545 #[allow(deprecated)]
10546 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10547 where
10548 S: serde::Serializer,
10549 {
10550 use serde::ser::SerializeStruct;
10551 let mut len = 0;
10552 if self.parallelism != 0 {
10553 len += 1;
10554 }
10555 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.Parallelism", len)?;
10556 if self.parallelism != 0 {
10557 #[allow(clippy::needless_borrow)]
10558 #[allow(clippy::needless_borrows_for_generic_args)]
10559 struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
10560 }
10561 struct_ser.end()
10562 }
10563}
10564impl<'de> serde::Deserialize<'de> for stream_fragment_graph::Parallelism {
10565 #[allow(deprecated)]
10566 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10567 where
10568 D: serde::Deserializer<'de>,
10569 {
10570 const FIELDS: &[&str] = &[
10571 "parallelism",
10572 ];
10573
10574 #[allow(clippy::enum_variant_names)]
10575 enum GeneratedField {
10576 Parallelism,
10577 }
10578 impl<'de> serde::Deserialize<'de> for GeneratedField {
10579 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10580 where
10581 D: serde::Deserializer<'de>,
10582 {
10583 struct GeneratedVisitor;
10584
10585 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10586 type Value = GeneratedField;
10587
10588 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10589 write!(formatter, "expected one of: {:?}", &FIELDS)
10590 }
10591
10592 #[allow(unused_variables)]
10593 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10594 where
10595 E: serde::de::Error,
10596 {
10597 match value {
10598 "parallelism" => Ok(GeneratedField::Parallelism),
10599 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10600 }
10601 }
10602 }
10603 deserializer.deserialize_identifier(GeneratedVisitor)
10604 }
10605 }
10606 struct GeneratedVisitor;
10607 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10608 type Value = stream_fragment_graph::Parallelism;
10609
10610 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10611 formatter.write_str("struct stream_plan.StreamFragmentGraph.Parallelism")
10612 }
10613
10614 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::Parallelism, V::Error>
10615 where
10616 V: serde::de::MapAccess<'de>,
10617 {
10618 let mut parallelism__ = None;
10619 while let Some(k) = map_.next_key()? {
10620 match k {
10621 GeneratedField::Parallelism => {
10622 if parallelism__.is_some() {
10623 return Err(serde::de::Error::duplicate_field("parallelism"));
10624 }
10625 parallelism__ =
10626 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10627 ;
10628 }
10629 }
10630 }
10631 Ok(stream_fragment_graph::Parallelism {
10632 parallelism: parallelism__.unwrap_or_default(),
10633 })
10634 }
10635 }
10636 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.Parallelism", FIELDS, GeneratedVisitor)
10637 }
10638}
10639impl serde::Serialize for stream_fragment_graph::StreamFragment {
10640 #[allow(deprecated)]
10641 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10642 where
10643 S: serde::Serializer,
10644 {
10645 use serde::ser::SerializeStruct;
10646 let mut len = 0;
10647 if self.fragment_id != 0 {
10648 len += 1;
10649 }
10650 if self.node.is_some() {
10651 len += 1;
10652 }
10653 if self.fragment_type_mask != 0 {
10654 len += 1;
10655 }
10656 if self.requires_singleton {
10657 len += 1;
10658 }
10659 if self.table_ids_cnt != 0 {
10660 len += 1;
10661 }
10662 if !self.upstream_table_ids.is_empty() {
10663 len += 1;
10664 }
10665 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", len)?;
10666 if self.fragment_id != 0 {
10667 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
10668 }
10669 if let Some(v) = self.node.as_ref() {
10670 struct_ser.serialize_field("node", v)?;
10671 }
10672 if self.fragment_type_mask != 0 {
10673 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
10674 }
10675 if self.requires_singleton {
10676 struct_ser.serialize_field("requiresSingleton", &self.requires_singleton)?;
10677 }
10678 if self.table_ids_cnt != 0 {
10679 struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
10680 }
10681 if !self.upstream_table_ids.is_empty() {
10682 struct_ser.serialize_field("upstreamTableIds", &self.upstream_table_ids)?;
10683 }
10684 struct_ser.end()
10685 }
10686}
10687impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragment {
10688 #[allow(deprecated)]
10689 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10690 where
10691 D: serde::Deserializer<'de>,
10692 {
10693 const FIELDS: &[&str] = &[
10694 "fragment_id",
10695 "fragmentId",
10696 "node",
10697 "fragment_type_mask",
10698 "fragmentTypeMask",
10699 "requires_singleton",
10700 "requiresSingleton",
10701 "table_ids_cnt",
10702 "tableIdsCnt",
10703 "upstream_table_ids",
10704 "upstreamTableIds",
10705 ];
10706
10707 #[allow(clippy::enum_variant_names)]
10708 enum GeneratedField {
10709 FragmentId,
10710 Node,
10711 FragmentTypeMask,
10712 RequiresSingleton,
10713 TableIdsCnt,
10714 UpstreamTableIds,
10715 }
10716 impl<'de> serde::Deserialize<'de> for GeneratedField {
10717 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10718 where
10719 D: serde::Deserializer<'de>,
10720 {
10721 struct GeneratedVisitor;
10722
10723 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10724 type Value = GeneratedField;
10725
10726 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10727 write!(formatter, "expected one of: {:?}", &FIELDS)
10728 }
10729
10730 #[allow(unused_variables)]
10731 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10732 where
10733 E: serde::de::Error,
10734 {
10735 match value {
10736 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
10737 "node" => Ok(GeneratedField::Node),
10738 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
10739 "requiresSingleton" | "requires_singleton" => Ok(GeneratedField::RequiresSingleton),
10740 "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
10741 "upstreamTableIds" | "upstream_table_ids" => Ok(GeneratedField::UpstreamTableIds),
10742 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10743 }
10744 }
10745 }
10746 deserializer.deserialize_identifier(GeneratedVisitor)
10747 }
10748 }
10749 struct GeneratedVisitor;
10750 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10751 type Value = stream_fragment_graph::StreamFragment;
10752
10753 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10754 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragment")
10755 }
10756
10757 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragment, V::Error>
10758 where
10759 V: serde::de::MapAccess<'de>,
10760 {
10761 let mut fragment_id__ = None;
10762 let mut node__ = None;
10763 let mut fragment_type_mask__ = None;
10764 let mut requires_singleton__ = None;
10765 let mut table_ids_cnt__ = None;
10766 let mut upstream_table_ids__ = None;
10767 while let Some(k) = map_.next_key()? {
10768 match k {
10769 GeneratedField::FragmentId => {
10770 if fragment_id__.is_some() {
10771 return Err(serde::de::Error::duplicate_field("fragmentId"));
10772 }
10773 fragment_id__ =
10774 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10775 ;
10776 }
10777 GeneratedField::Node => {
10778 if node__.is_some() {
10779 return Err(serde::de::Error::duplicate_field("node"));
10780 }
10781 node__ = map_.next_value()?;
10782 }
10783 GeneratedField::FragmentTypeMask => {
10784 if fragment_type_mask__.is_some() {
10785 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
10786 }
10787 fragment_type_mask__ =
10788 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10789 ;
10790 }
10791 GeneratedField::RequiresSingleton => {
10792 if requires_singleton__.is_some() {
10793 return Err(serde::de::Error::duplicate_field("requiresSingleton"));
10794 }
10795 requires_singleton__ = Some(map_.next_value()?);
10796 }
10797 GeneratedField::TableIdsCnt => {
10798 if table_ids_cnt__.is_some() {
10799 return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
10800 }
10801 table_ids_cnt__ =
10802 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10803 ;
10804 }
10805 GeneratedField::UpstreamTableIds => {
10806 if upstream_table_ids__.is_some() {
10807 return Err(serde::de::Error::duplicate_field("upstreamTableIds"));
10808 }
10809 upstream_table_ids__ =
10810 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10811 .into_iter().map(|x| x.0).collect())
10812 ;
10813 }
10814 }
10815 }
10816 Ok(stream_fragment_graph::StreamFragment {
10817 fragment_id: fragment_id__.unwrap_or_default(),
10818 node: node__,
10819 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
10820 requires_singleton: requires_singleton__.unwrap_or_default(),
10821 table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
10822 upstream_table_ids: upstream_table_ids__.unwrap_or_default(),
10823 })
10824 }
10825 }
10826 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", FIELDS, GeneratedVisitor)
10827 }
10828}
10829impl serde::Serialize for stream_fragment_graph::StreamFragmentEdge {
10830 #[allow(deprecated)]
10831 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10832 where
10833 S: serde::Serializer,
10834 {
10835 use serde::ser::SerializeStruct;
10836 let mut len = 0;
10837 if self.dispatch_strategy.is_some() {
10838 len += 1;
10839 }
10840 if self.link_id != 0 {
10841 len += 1;
10842 }
10843 if self.upstream_id != 0 {
10844 len += 1;
10845 }
10846 if self.downstream_id != 0 {
10847 len += 1;
10848 }
10849 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", len)?;
10850 if let Some(v) = self.dispatch_strategy.as_ref() {
10851 struct_ser.serialize_field("dispatchStrategy", v)?;
10852 }
10853 if self.link_id != 0 {
10854 #[allow(clippy::needless_borrow)]
10855 #[allow(clippy::needless_borrows_for_generic_args)]
10856 struct_ser.serialize_field("linkId", ToString::to_string(&self.link_id).as_str())?;
10857 }
10858 if self.upstream_id != 0 {
10859 struct_ser.serialize_field("upstreamId", &self.upstream_id)?;
10860 }
10861 if self.downstream_id != 0 {
10862 struct_ser.serialize_field("downstreamId", &self.downstream_id)?;
10863 }
10864 struct_ser.end()
10865 }
10866}
10867impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragmentEdge {
10868 #[allow(deprecated)]
10869 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10870 where
10871 D: serde::Deserializer<'de>,
10872 {
10873 const FIELDS: &[&str] = &[
10874 "dispatch_strategy",
10875 "dispatchStrategy",
10876 "link_id",
10877 "linkId",
10878 "upstream_id",
10879 "upstreamId",
10880 "downstream_id",
10881 "downstreamId",
10882 ];
10883
10884 #[allow(clippy::enum_variant_names)]
10885 enum GeneratedField {
10886 DispatchStrategy,
10887 LinkId,
10888 UpstreamId,
10889 DownstreamId,
10890 }
10891 impl<'de> serde::Deserialize<'de> for GeneratedField {
10892 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10893 where
10894 D: serde::Deserializer<'de>,
10895 {
10896 struct GeneratedVisitor;
10897
10898 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10899 type Value = GeneratedField;
10900
10901 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10902 write!(formatter, "expected one of: {:?}", &FIELDS)
10903 }
10904
10905 #[allow(unused_variables)]
10906 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10907 where
10908 E: serde::de::Error,
10909 {
10910 match value {
10911 "dispatchStrategy" | "dispatch_strategy" => Ok(GeneratedField::DispatchStrategy),
10912 "linkId" | "link_id" => Ok(GeneratedField::LinkId),
10913 "upstreamId" | "upstream_id" => Ok(GeneratedField::UpstreamId),
10914 "downstreamId" | "downstream_id" => Ok(GeneratedField::DownstreamId),
10915 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10916 }
10917 }
10918 }
10919 deserializer.deserialize_identifier(GeneratedVisitor)
10920 }
10921 }
10922 struct GeneratedVisitor;
10923 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10924 type Value = stream_fragment_graph::StreamFragmentEdge;
10925
10926 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10927 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragmentEdge")
10928 }
10929
10930 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragmentEdge, V::Error>
10931 where
10932 V: serde::de::MapAccess<'de>,
10933 {
10934 let mut dispatch_strategy__ = None;
10935 let mut link_id__ = None;
10936 let mut upstream_id__ = None;
10937 let mut downstream_id__ = None;
10938 while let Some(k) = map_.next_key()? {
10939 match k {
10940 GeneratedField::DispatchStrategy => {
10941 if dispatch_strategy__.is_some() {
10942 return Err(serde::de::Error::duplicate_field("dispatchStrategy"));
10943 }
10944 dispatch_strategy__ = map_.next_value()?;
10945 }
10946 GeneratedField::LinkId => {
10947 if link_id__.is_some() {
10948 return Err(serde::de::Error::duplicate_field("linkId"));
10949 }
10950 link_id__ =
10951 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10952 ;
10953 }
10954 GeneratedField::UpstreamId => {
10955 if upstream_id__.is_some() {
10956 return Err(serde::de::Error::duplicate_field("upstreamId"));
10957 }
10958 upstream_id__ =
10959 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10960 ;
10961 }
10962 GeneratedField::DownstreamId => {
10963 if downstream_id__.is_some() {
10964 return Err(serde::de::Error::duplicate_field("downstreamId"));
10965 }
10966 downstream_id__ =
10967 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10968 ;
10969 }
10970 }
10971 }
10972 Ok(stream_fragment_graph::StreamFragmentEdge {
10973 dispatch_strategy: dispatch_strategy__,
10974 link_id: link_id__.unwrap_or_default(),
10975 upstream_id: upstream_id__.unwrap_or_default(),
10976 downstream_id: downstream_id__.unwrap_or_default(),
10977 })
10978 }
10979 }
10980 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", FIELDS, GeneratedVisitor)
10981 }
10982}
10983impl serde::Serialize for StreamFsFetch {
10984 #[allow(deprecated)]
10985 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10986 where
10987 S: serde::Serializer,
10988 {
10989 use serde::ser::SerializeStruct;
10990 let mut len = 0;
10991 if self.source_id != 0 {
10992 len += 1;
10993 }
10994 if self.state_table.is_some() {
10995 len += 1;
10996 }
10997 if self.row_id_index.is_some() {
10998 len += 1;
10999 }
11000 if !self.columns.is_empty() {
11001 len += 1;
11002 }
11003 if !self.with_properties.is_empty() {
11004 len += 1;
11005 }
11006 if self.info.is_some() {
11007 len += 1;
11008 }
11009 if !self.source_name.is_empty() {
11010 len += 1;
11011 }
11012 if self.rate_limit.is_some() {
11013 len += 1;
11014 }
11015 if !self.secret_refs.is_empty() {
11016 len += 1;
11017 }
11018 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetch", len)?;
11019 if self.source_id != 0 {
11020 struct_ser.serialize_field("sourceId", &self.source_id)?;
11021 }
11022 if let Some(v) = self.state_table.as_ref() {
11023 struct_ser.serialize_field("stateTable", v)?;
11024 }
11025 if let Some(v) = self.row_id_index.as_ref() {
11026 struct_ser.serialize_field("rowIdIndex", v)?;
11027 }
11028 if !self.columns.is_empty() {
11029 struct_ser.serialize_field("columns", &self.columns)?;
11030 }
11031 if !self.with_properties.is_empty() {
11032 struct_ser.serialize_field("withProperties", &self.with_properties)?;
11033 }
11034 if let Some(v) = self.info.as_ref() {
11035 struct_ser.serialize_field("info", v)?;
11036 }
11037 if !self.source_name.is_empty() {
11038 struct_ser.serialize_field("sourceName", &self.source_name)?;
11039 }
11040 if let Some(v) = self.rate_limit.as_ref() {
11041 struct_ser.serialize_field("rateLimit", v)?;
11042 }
11043 if !self.secret_refs.is_empty() {
11044 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
11045 }
11046 struct_ser.end()
11047 }
11048}
11049impl<'de> serde::Deserialize<'de> for StreamFsFetch {
11050 #[allow(deprecated)]
11051 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11052 where
11053 D: serde::Deserializer<'de>,
11054 {
11055 const FIELDS: &[&str] = &[
11056 "source_id",
11057 "sourceId",
11058 "state_table",
11059 "stateTable",
11060 "row_id_index",
11061 "rowIdIndex",
11062 "columns",
11063 "with_properties",
11064 "withProperties",
11065 "info",
11066 "source_name",
11067 "sourceName",
11068 "rate_limit",
11069 "rateLimit",
11070 "secret_refs",
11071 "secretRefs",
11072 ];
11073
11074 #[allow(clippy::enum_variant_names)]
11075 enum GeneratedField {
11076 SourceId,
11077 StateTable,
11078 RowIdIndex,
11079 Columns,
11080 WithProperties,
11081 Info,
11082 SourceName,
11083 RateLimit,
11084 SecretRefs,
11085 }
11086 impl<'de> serde::Deserialize<'de> for GeneratedField {
11087 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11088 where
11089 D: serde::Deserializer<'de>,
11090 {
11091 struct GeneratedVisitor;
11092
11093 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11094 type Value = GeneratedField;
11095
11096 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11097 write!(formatter, "expected one of: {:?}", &FIELDS)
11098 }
11099
11100 #[allow(unused_variables)]
11101 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11102 where
11103 E: serde::de::Error,
11104 {
11105 match value {
11106 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
11107 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11108 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
11109 "columns" => Ok(GeneratedField::Columns),
11110 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
11111 "info" => Ok(GeneratedField::Info),
11112 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
11113 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11114 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
11115 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11116 }
11117 }
11118 }
11119 deserializer.deserialize_identifier(GeneratedVisitor)
11120 }
11121 }
11122 struct GeneratedVisitor;
11123 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11124 type Value = StreamFsFetch;
11125
11126 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11127 formatter.write_str("struct stream_plan.StreamFsFetch")
11128 }
11129
11130 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetch, V::Error>
11131 where
11132 V: serde::de::MapAccess<'de>,
11133 {
11134 let mut source_id__ = None;
11135 let mut state_table__ = None;
11136 let mut row_id_index__ = None;
11137 let mut columns__ = None;
11138 let mut with_properties__ = None;
11139 let mut info__ = None;
11140 let mut source_name__ = None;
11141 let mut rate_limit__ = None;
11142 let mut secret_refs__ = None;
11143 while let Some(k) = map_.next_key()? {
11144 match k {
11145 GeneratedField::SourceId => {
11146 if source_id__.is_some() {
11147 return Err(serde::de::Error::duplicate_field("sourceId"));
11148 }
11149 source_id__ =
11150 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11151 ;
11152 }
11153 GeneratedField::StateTable => {
11154 if state_table__.is_some() {
11155 return Err(serde::de::Error::duplicate_field("stateTable"));
11156 }
11157 state_table__ = map_.next_value()?;
11158 }
11159 GeneratedField::RowIdIndex => {
11160 if row_id_index__.is_some() {
11161 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
11162 }
11163 row_id_index__ =
11164 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11165 ;
11166 }
11167 GeneratedField::Columns => {
11168 if columns__.is_some() {
11169 return Err(serde::de::Error::duplicate_field("columns"));
11170 }
11171 columns__ = Some(map_.next_value()?);
11172 }
11173 GeneratedField::WithProperties => {
11174 if with_properties__.is_some() {
11175 return Err(serde::de::Error::duplicate_field("withProperties"));
11176 }
11177 with_properties__ = Some(
11178 map_.next_value::<std::collections::BTreeMap<_, _>>()?
11179 );
11180 }
11181 GeneratedField::Info => {
11182 if info__.is_some() {
11183 return Err(serde::de::Error::duplicate_field("info"));
11184 }
11185 info__ = map_.next_value()?;
11186 }
11187 GeneratedField::SourceName => {
11188 if source_name__.is_some() {
11189 return Err(serde::de::Error::duplicate_field("sourceName"));
11190 }
11191 source_name__ = Some(map_.next_value()?);
11192 }
11193 GeneratedField::RateLimit => {
11194 if rate_limit__.is_some() {
11195 return Err(serde::de::Error::duplicate_field("rateLimit"));
11196 }
11197 rate_limit__ =
11198 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11199 ;
11200 }
11201 GeneratedField::SecretRefs => {
11202 if secret_refs__.is_some() {
11203 return Err(serde::de::Error::duplicate_field("secretRefs"));
11204 }
11205 secret_refs__ = Some(
11206 map_.next_value::<std::collections::BTreeMap<_, _>>()?
11207 );
11208 }
11209 }
11210 }
11211 Ok(StreamFsFetch {
11212 source_id: source_id__.unwrap_or_default(),
11213 state_table: state_table__,
11214 row_id_index: row_id_index__,
11215 columns: columns__.unwrap_or_default(),
11216 with_properties: with_properties__.unwrap_or_default(),
11217 info: info__,
11218 source_name: source_name__.unwrap_or_default(),
11219 rate_limit: rate_limit__,
11220 secret_refs: secret_refs__.unwrap_or_default(),
11221 })
11222 }
11223 }
11224 deserializer.deserialize_struct("stream_plan.StreamFsFetch", FIELDS, GeneratedVisitor)
11225 }
11226}
11227impl serde::Serialize for StreamFsFetchNode {
11228 #[allow(deprecated)]
11229 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11230 where
11231 S: serde::Serializer,
11232 {
11233 use serde::ser::SerializeStruct;
11234 let mut len = 0;
11235 if self.node_inner.is_some() {
11236 len += 1;
11237 }
11238 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetchNode", len)?;
11239 if let Some(v) = self.node_inner.as_ref() {
11240 struct_ser.serialize_field("nodeInner", v)?;
11241 }
11242 struct_ser.end()
11243 }
11244}
11245impl<'de> serde::Deserialize<'de> for StreamFsFetchNode {
11246 #[allow(deprecated)]
11247 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11248 where
11249 D: serde::Deserializer<'de>,
11250 {
11251 const FIELDS: &[&str] = &[
11252 "node_inner",
11253 "nodeInner",
11254 ];
11255
11256 #[allow(clippy::enum_variant_names)]
11257 enum GeneratedField {
11258 NodeInner,
11259 }
11260 impl<'de> serde::Deserialize<'de> for GeneratedField {
11261 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11262 where
11263 D: serde::Deserializer<'de>,
11264 {
11265 struct GeneratedVisitor;
11266
11267 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11268 type Value = GeneratedField;
11269
11270 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11271 write!(formatter, "expected one of: {:?}", &FIELDS)
11272 }
11273
11274 #[allow(unused_variables)]
11275 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11276 where
11277 E: serde::de::Error,
11278 {
11279 match value {
11280 "nodeInner" | "node_inner" => Ok(GeneratedField::NodeInner),
11281 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11282 }
11283 }
11284 }
11285 deserializer.deserialize_identifier(GeneratedVisitor)
11286 }
11287 }
11288 struct GeneratedVisitor;
11289 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11290 type Value = StreamFsFetchNode;
11291
11292 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11293 formatter.write_str("struct stream_plan.StreamFsFetchNode")
11294 }
11295
11296 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetchNode, V::Error>
11297 where
11298 V: serde::de::MapAccess<'de>,
11299 {
11300 let mut node_inner__ = None;
11301 while let Some(k) = map_.next_key()? {
11302 match k {
11303 GeneratedField::NodeInner => {
11304 if node_inner__.is_some() {
11305 return Err(serde::de::Error::duplicate_field("nodeInner"));
11306 }
11307 node_inner__ = map_.next_value()?;
11308 }
11309 }
11310 }
11311 Ok(StreamFsFetchNode {
11312 node_inner: node_inner__,
11313 })
11314 }
11315 }
11316 deserializer.deserialize_struct("stream_plan.StreamFsFetchNode", FIELDS, GeneratedVisitor)
11317 }
11318}
11319impl serde::Serialize for StreamMessage {
11320 #[allow(deprecated)]
11321 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11322 where
11323 S: serde::Serializer,
11324 {
11325 use serde::ser::SerializeStruct;
11326 let mut len = 0;
11327 if self.stream_message.is_some() {
11328 len += 1;
11329 }
11330 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessage", len)?;
11331 if let Some(v) = self.stream_message.as_ref() {
11332 match v {
11333 stream_message::StreamMessage::StreamChunk(v) => {
11334 struct_ser.serialize_field("streamChunk", v)?;
11335 }
11336 stream_message::StreamMessage::Barrier(v) => {
11337 struct_ser.serialize_field("barrier", v)?;
11338 }
11339 stream_message::StreamMessage::Watermark(v) => {
11340 struct_ser.serialize_field("watermark", v)?;
11341 }
11342 }
11343 }
11344 struct_ser.end()
11345 }
11346}
11347impl<'de> serde::Deserialize<'de> for StreamMessage {
11348 #[allow(deprecated)]
11349 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11350 where
11351 D: serde::Deserializer<'de>,
11352 {
11353 const FIELDS: &[&str] = &[
11354 "stream_chunk",
11355 "streamChunk",
11356 "barrier",
11357 "watermark",
11358 ];
11359
11360 #[allow(clippy::enum_variant_names)]
11361 enum GeneratedField {
11362 StreamChunk,
11363 Barrier,
11364 Watermark,
11365 }
11366 impl<'de> serde::Deserialize<'de> for GeneratedField {
11367 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11368 where
11369 D: serde::Deserializer<'de>,
11370 {
11371 struct GeneratedVisitor;
11372
11373 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11374 type Value = GeneratedField;
11375
11376 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11377 write!(formatter, "expected one of: {:?}", &FIELDS)
11378 }
11379
11380 #[allow(unused_variables)]
11381 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11382 where
11383 E: serde::de::Error,
11384 {
11385 match value {
11386 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
11387 "barrier" => Ok(GeneratedField::Barrier),
11388 "watermark" => Ok(GeneratedField::Watermark),
11389 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11390 }
11391 }
11392 }
11393 deserializer.deserialize_identifier(GeneratedVisitor)
11394 }
11395 }
11396 struct GeneratedVisitor;
11397 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11398 type Value = StreamMessage;
11399
11400 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11401 formatter.write_str("struct stream_plan.StreamMessage")
11402 }
11403
11404 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessage, V::Error>
11405 where
11406 V: serde::de::MapAccess<'de>,
11407 {
11408 let mut stream_message__ = None;
11409 while let Some(k) = map_.next_key()? {
11410 match k {
11411 GeneratedField::StreamChunk => {
11412 if stream_message__.is_some() {
11413 return Err(serde::de::Error::duplicate_field("streamChunk"));
11414 }
11415 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::StreamChunk)
11416;
11417 }
11418 GeneratedField::Barrier => {
11419 if stream_message__.is_some() {
11420 return Err(serde::de::Error::duplicate_field("barrier"));
11421 }
11422 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Barrier)
11423;
11424 }
11425 GeneratedField::Watermark => {
11426 if stream_message__.is_some() {
11427 return Err(serde::de::Error::duplicate_field("watermark"));
11428 }
11429 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Watermark)
11430;
11431 }
11432 }
11433 }
11434 Ok(StreamMessage {
11435 stream_message: stream_message__,
11436 })
11437 }
11438 }
11439 deserializer.deserialize_struct("stream_plan.StreamMessage", FIELDS, GeneratedVisitor)
11440 }
11441}
11442impl serde::Serialize for StreamMessageBatch {
11443 #[allow(deprecated)]
11444 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11445 where
11446 S: serde::Serializer,
11447 {
11448 use serde::ser::SerializeStruct;
11449 let mut len = 0;
11450 if self.stream_message_batch.is_some() {
11451 len += 1;
11452 }
11453 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch", len)?;
11454 if let Some(v) = self.stream_message_batch.as_ref() {
11455 match v {
11456 stream_message_batch::StreamMessageBatch::StreamChunk(v) => {
11457 struct_ser.serialize_field("streamChunk", v)?;
11458 }
11459 stream_message_batch::StreamMessageBatch::BarrierBatch(v) => {
11460 struct_ser.serialize_field("barrierBatch", v)?;
11461 }
11462 stream_message_batch::StreamMessageBatch::Watermark(v) => {
11463 struct_ser.serialize_field("watermark", v)?;
11464 }
11465 }
11466 }
11467 struct_ser.end()
11468 }
11469}
11470impl<'de> serde::Deserialize<'de> for StreamMessageBatch {
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 "stream_chunk",
11478 "streamChunk",
11479 "barrier_batch",
11480 "barrierBatch",
11481 "watermark",
11482 ];
11483
11484 #[allow(clippy::enum_variant_names)]
11485 enum GeneratedField {
11486 StreamChunk,
11487 BarrierBatch,
11488 Watermark,
11489 }
11490 impl<'de> serde::Deserialize<'de> for GeneratedField {
11491 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11492 where
11493 D: serde::Deserializer<'de>,
11494 {
11495 struct GeneratedVisitor;
11496
11497 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11498 type Value = GeneratedField;
11499
11500 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11501 write!(formatter, "expected one of: {:?}", &FIELDS)
11502 }
11503
11504 #[allow(unused_variables)]
11505 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11506 where
11507 E: serde::de::Error,
11508 {
11509 match value {
11510 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
11511 "barrierBatch" | "barrier_batch" => Ok(GeneratedField::BarrierBatch),
11512 "watermark" => Ok(GeneratedField::Watermark),
11513 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11514 }
11515 }
11516 }
11517 deserializer.deserialize_identifier(GeneratedVisitor)
11518 }
11519 }
11520 struct GeneratedVisitor;
11521 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11522 type Value = StreamMessageBatch;
11523
11524 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11525 formatter.write_str("struct stream_plan.StreamMessageBatch")
11526 }
11527
11528 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessageBatch, V::Error>
11529 where
11530 V: serde::de::MapAccess<'de>,
11531 {
11532 let mut stream_message_batch__ = None;
11533 while let Some(k) = map_.next_key()? {
11534 match k {
11535 GeneratedField::StreamChunk => {
11536 if stream_message_batch__.is_some() {
11537 return Err(serde::de::Error::duplicate_field("streamChunk"));
11538 }
11539 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::StreamChunk)
11540;
11541 }
11542 GeneratedField::BarrierBatch => {
11543 if stream_message_batch__.is_some() {
11544 return Err(serde::de::Error::duplicate_field("barrierBatch"));
11545 }
11546 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::BarrierBatch)
11547;
11548 }
11549 GeneratedField::Watermark => {
11550 if stream_message_batch__.is_some() {
11551 return Err(serde::de::Error::duplicate_field("watermark"));
11552 }
11553 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::Watermark)
11554;
11555 }
11556 }
11557 }
11558 Ok(StreamMessageBatch {
11559 stream_message_batch: stream_message_batch__,
11560 })
11561 }
11562 }
11563 deserializer.deserialize_struct("stream_plan.StreamMessageBatch", FIELDS, GeneratedVisitor)
11564 }
11565}
11566impl serde::Serialize for stream_message_batch::BarrierBatch {
11567 #[allow(deprecated)]
11568 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11569 where
11570 S: serde::Serializer,
11571 {
11572 use serde::ser::SerializeStruct;
11573 let mut len = 0;
11574 if !self.barriers.is_empty() {
11575 len += 1;
11576 }
11577 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", len)?;
11578 if !self.barriers.is_empty() {
11579 struct_ser.serialize_field("barriers", &self.barriers)?;
11580 }
11581 struct_ser.end()
11582 }
11583}
11584impl<'de> serde::Deserialize<'de> for stream_message_batch::BarrierBatch {
11585 #[allow(deprecated)]
11586 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11587 where
11588 D: serde::Deserializer<'de>,
11589 {
11590 const FIELDS: &[&str] = &[
11591 "barriers",
11592 ];
11593
11594 #[allow(clippy::enum_variant_names)]
11595 enum GeneratedField {
11596 Barriers,
11597 }
11598 impl<'de> serde::Deserialize<'de> for GeneratedField {
11599 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11600 where
11601 D: serde::Deserializer<'de>,
11602 {
11603 struct GeneratedVisitor;
11604
11605 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11606 type Value = GeneratedField;
11607
11608 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11609 write!(formatter, "expected one of: {:?}", &FIELDS)
11610 }
11611
11612 #[allow(unused_variables)]
11613 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11614 where
11615 E: serde::de::Error,
11616 {
11617 match value {
11618 "barriers" => Ok(GeneratedField::Barriers),
11619 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11620 }
11621 }
11622 }
11623 deserializer.deserialize_identifier(GeneratedVisitor)
11624 }
11625 }
11626 struct GeneratedVisitor;
11627 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11628 type Value = stream_message_batch::BarrierBatch;
11629
11630 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11631 formatter.write_str("struct stream_plan.StreamMessageBatch.BarrierBatch")
11632 }
11633
11634 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_message_batch::BarrierBatch, V::Error>
11635 where
11636 V: serde::de::MapAccess<'de>,
11637 {
11638 let mut barriers__ = None;
11639 while let Some(k) = map_.next_key()? {
11640 match k {
11641 GeneratedField::Barriers => {
11642 if barriers__.is_some() {
11643 return Err(serde::de::Error::duplicate_field("barriers"));
11644 }
11645 barriers__ = Some(map_.next_value()?);
11646 }
11647 }
11648 }
11649 Ok(stream_message_batch::BarrierBatch {
11650 barriers: barriers__.unwrap_or_default(),
11651 })
11652 }
11653 }
11654 deserializer.deserialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", FIELDS, GeneratedVisitor)
11655 }
11656}
11657impl serde::Serialize for StreamNode {
11658 #[allow(deprecated)]
11659 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11660 where
11661 S: serde::Serializer,
11662 {
11663 use serde::ser::SerializeStruct;
11664 let mut len = 0;
11665 if self.operator_id != 0 {
11666 len += 1;
11667 }
11668 if !self.input.is_empty() {
11669 len += 1;
11670 }
11671 if !self.stream_key.is_empty() {
11672 len += 1;
11673 }
11674 if self.append_only {
11675 len += 1;
11676 }
11677 if !self.identity.is_empty() {
11678 len += 1;
11679 }
11680 if !self.fields.is_empty() {
11681 len += 1;
11682 }
11683 if self.node_body.is_some() {
11684 len += 1;
11685 }
11686 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamNode", len)?;
11687 if self.operator_id != 0 {
11688 #[allow(clippy::needless_borrow)]
11689 #[allow(clippy::needless_borrows_for_generic_args)]
11690 struct_ser.serialize_field("operatorId", ToString::to_string(&self.operator_id).as_str())?;
11691 }
11692 if !self.input.is_empty() {
11693 struct_ser.serialize_field("input", &self.input)?;
11694 }
11695 if !self.stream_key.is_empty() {
11696 struct_ser.serialize_field("streamKey", &self.stream_key)?;
11697 }
11698 if self.append_only {
11699 struct_ser.serialize_field("appendOnly", &self.append_only)?;
11700 }
11701 if !self.identity.is_empty() {
11702 struct_ser.serialize_field("identity", &self.identity)?;
11703 }
11704 if !self.fields.is_empty() {
11705 struct_ser.serialize_field("fields", &self.fields)?;
11706 }
11707 if let Some(v) = self.node_body.as_ref() {
11708 match v {
11709 stream_node::NodeBody::Source(v) => {
11710 struct_ser.serialize_field("source", v)?;
11711 }
11712 stream_node::NodeBody::Project(v) => {
11713 struct_ser.serialize_field("project", v)?;
11714 }
11715 stream_node::NodeBody::Filter(v) => {
11716 struct_ser.serialize_field("filter", v)?;
11717 }
11718 stream_node::NodeBody::Materialize(v) => {
11719 struct_ser.serialize_field("materialize", v)?;
11720 }
11721 stream_node::NodeBody::StatelessSimpleAgg(v) => {
11722 struct_ser.serialize_field("statelessSimpleAgg", v)?;
11723 }
11724 stream_node::NodeBody::SimpleAgg(v) => {
11725 struct_ser.serialize_field("simpleAgg", v)?;
11726 }
11727 stream_node::NodeBody::HashAgg(v) => {
11728 struct_ser.serialize_field("hashAgg", v)?;
11729 }
11730 stream_node::NodeBody::AppendOnlyTopN(v) => {
11731 struct_ser.serialize_field("appendOnlyTopN", v)?;
11732 }
11733 stream_node::NodeBody::HashJoin(v) => {
11734 struct_ser.serialize_field("hashJoin", v)?;
11735 }
11736 stream_node::NodeBody::TopN(v) => {
11737 struct_ser.serialize_field("topN", v)?;
11738 }
11739 stream_node::NodeBody::HopWindow(v) => {
11740 struct_ser.serialize_field("hopWindow", v)?;
11741 }
11742 stream_node::NodeBody::Merge(v) => {
11743 struct_ser.serialize_field("merge", v)?;
11744 }
11745 stream_node::NodeBody::Exchange(v) => {
11746 struct_ser.serialize_field("exchange", v)?;
11747 }
11748 stream_node::NodeBody::StreamScan(v) => {
11749 struct_ser.serialize_field("streamScan", v)?;
11750 }
11751 stream_node::NodeBody::BatchPlan(v) => {
11752 struct_ser.serialize_field("batchPlan", v)?;
11753 }
11754 stream_node::NodeBody::Lookup(v) => {
11755 struct_ser.serialize_field("lookup", v)?;
11756 }
11757 stream_node::NodeBody::Arrange(v) => {
11758 struct_ser.serialize_field("arrange", v)?;
11759 }
11760 stream_node::NodeBody::LookupUnion(v) => {
11761 struct_ser.serialize_field("lookupUnion", v)?;
11762 }
11763 stream_node::NodeBody::Union(v) => {
11764 struct_ser.serialize_field("union", v)?;
11765 }
11766 stream_node::NodeBody::DeltaIndexJoin(v) => {
11767 struct_ser.serialize_field("deltaIndexJoin", v)?;
11768 }
11769 stream_node::NodeBody::Sink(v) => {
11770 struct_ser.serialize_field("sink", v)?;
11771 }
11772 stream_node::NodeBody::Expand(v) => {
11773 struct_ser.serialize_field("expand", v)?;
11774 }
11775 stream_node::NodeBody::DynamicFilter(v) => {
11776 struct_ser.serialize_field("dynamicFilter", v)?;
11777 }
11778 stream_node::NodeBody::ProjectSet(v) => {
11779 struct_ser.serialize_field("projectSet", v)?;
11780 }
11781 stream_node::NodeBody::GroupTopN(v) => {
11782 struct_ser.serialize_field("groupTopN", v)?;
11783 }
11784 stream_node::NodeBody::Sort(v) => {
11785 struct_ser.serialize_field("sort", v)?;
11786 }
11787 stream_node::NodeBody::WatermarkFilter(v) => {
11788 struct_ser.serialize_field("watermarkFilter", v)?;
11789 }
11790 stream_node::NodeBody::Dml(v) => {
11791 struct_ser.serialize_field("dml", v)?;
11792 }
11793 stream_node::NodeBody::RowIdGen(v) => {
11794 struct_ser.serialize_field("rowIdGen", v)?;
11795 }
11796 stream_node::NodeBody::Now(v) => {
11797 struct_ser.serialize_field("now", v)?;
11798 }
11799 stream_node::NodeBody::AppendOnlyGroupTopN(v) => {
11800 struct_ser.serialize_field("appendOnlyGroupTopN", v)?;
11801 }
11802 stream_node::NodeBody::TemporalJoin(v) => {
11803 struct_ser.serialize_field("temporalJoin", v)?;
11804 }
11805 stream_node::NodeBody::BarrierRecv(v) => {
11806 struct_ser.serialize_field("barrierRecv", v)?;
11807 }
11808 stream_node::NodeBody::Values(v) => {
11809 struct_ser.serialize_field("values", v)?;
11810 }
11811 stream_node::NodeBody::AppendOnlyDedup(v) => {
11812 struct_ser.serialize_field("appendOnlyDedup", v)?;
11813 }
11814 stream_node::NodeBody::NoOp(v) => {
11815 struct_ser.serialize_field("noOp", v)?;
11816 }
11817 stream_node::NodeBody::EowcOverWindow(v) => {
11818 struct_ser.serialize_field("eowcOverWindow", v)?;
11819 }
11820 stream_node::NodeBody::OverWindow(v) => {
11821 struct_ser.serialize_field("overWindow", v)?;
11822 }
11823 stream_node::NodeBody::StreamFsFetch(v) => {
11824 struct_ser.serialize_field("streamFsFetch", v)?;
11825 }
11826 stream_node::NodeBody::StreamCdcScan(v) => {
11827 struct_ser.serialize_field("streamCdcScan", v)?;
11828 }
11829 stream_node::NodeBody::CdcFilter(v) => {
11830 struct_ser.serialize_field("cdcFilter", v)?;
11831 }
11832 stream_node::NodeBody::SourceBackfill(v) => {
11833 struct_ser.serialize_field("sourceBackfill", v)?;
11834 }
11835 stream_node::NodeBody::Changelog(v) => {
11836 struct_ser.serialize_field("changelog", v)?;
11837 }
11838 stream_node::NodeBody::LocalApproxPercentile(v) => {
11839 struct_ser.serialize_field("localApproxPercentile", v)?;
11840 }
11841 stream_node::NodeBody::GlobalApproxPercentile(v) => {
11842 struct_ser.serialize_field("globalApproxPercentile", v)?;
11843 }
11844 stream_node::NodeBody::RowMerge(v) => {
11845 struct_ser.serialize_field("rowMerge", v)?;
11846 }
11847 stream_node::NodeBody::AsOfJoin(v) => {
11848 struct_ser.serialize_field("asOfJoin", v)?;
11849 }
11850 stream_node::NodeBody::SyncLogStore(v) => {
11851 struct_ser.serialize_field("syncLogStore", v)?;
11852 }
11853 stream_node::NodeBody::MaterializedExprs(v) => {
11854 struct_ser.serialize_field("materializedExprs", v)?;
11855 }
11856 }
11857 }
11858 struct_ser.end()
11859 }
11860}
11861impl<'de> serde::Deserialize<'de> for StreamNode {
11862 #[allow(deprecated)]
11863 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11864 where
11865 D: serde::Deserializer<'de>,
11866 {
11867 const FIELDS: &[&str] = &[
11868 "operator_id",
11869 "operatorId",
11870 "input",
11871 "stream_key",
11872 "streamKey",
11873 "append_only",
11874 "appendOnly",
11875 "identity",
11876 "fields",
11877 "source",
11878 "project",
11879 "filter",
11880 "materialize",
11881 "stateless_simple_agg",
11882 "statelessSimpleAgg",
11883 "simple_agg",
11884 "simpleAgg",
11885 "hash_agg",
11886 "hashAgg",
11887 "append_only_top_n",
11888 "appendOnlyTopN",
11889 "hash_join",
11890 "hashJoin",
11891 "top_n",
11892 "topN",
11893 "hop_window",
11894 "hopWindow",
11895 "merge",
11896 "exchange",
11897 "stream_scan",
11898 "streamScan",
11899 "batch_plan",
11900 "batchPlan",
11901 "lookup",
11902 "arrange",
11903 "lookup_union",
11904 "lookupUnion",
11905 "union",
11906 "delta_index_join",
11907 "deltaIndexJoin",
11908 "sink",
11909 "expand",
11910 "dynamic_filter",
11911 "dynamicFilter",
11912 "project_set",
11913 "projectSet",
11914 "group_top_n",
11915 "groupTopN",
11916 "sort",
11917 "watermark_filter",
11918 "watermarkFilter",
11919 "dml",
11920 "row_id_gen",
11921 "rowIdGen",
11922 "now",
11923 "append_only_group_top_n",
11924 "appendOnlyGroupTopN",
11925 "temporal_join",
11926 "temporalJoin",
11927 "barrier_recv",
11928 "barrierRecv",
11929 "values",
11930 "append_only_dedup",
11931 "appendOnlyDedup",
11932 "no_op",
11933 "noOp",
11934 "eowc_over_window",
11935 "eowcOverWindow",
11936 "over_window",
11937 "overWindow",
11938 "stream_fs_fetch",
11939 "streamFsFetch",
11940 "stream_cdc_scan",
11941 "streamCdcScan",
11942 "cdc_filter",
11943 "cdcFilter",
11944 "source_backfill",
11945 "sourceBackfill",
11946 "changelog",
11947 "local_approx_percentile",
11948 "localApproxPercentile",
11949 "global_approx_percentile",
11950 "globalApproxPercentile",
11951 "row_merge",
11952 "rowMerge",
11953 "as_of_join",
11954 "asOfJoin",
11955 "sync_log_store",
11956 "syncLogStore",
11957 "materialized_exprs",
11958 "materializedExprs",
11959 ];
11960
11961 #[allow(clippy::enum_variant_names)]
11962 enum GeneratedField {
11963 OperatorId,
11964 Input,
11965 StreamKey,
11966 AppendOnly,
11967 Identity,
11968 Fields,
11969 Source,
11970 Project,
11971 Filter,
11972 Materialize,
11973 StatelessSimpleAgg,
11974 SimpleAgg,
11975 HashAgg,
11976 AppendOnlyTopN,
11977 HashJoin,
11978 TopN,
11979 HopWindow,
11980 Merge,
11981 Exchange,
11982 StreamScan,
11983 BatchPlan,
11984 Lookup,
11985 Arrange,
11986 LookupUnion,
11987 Union,
11988 DeltaIndexJoin,
11989 Sink,
11990 Expand,
11991 DynamicFilter,
11992 ProjectSet,
11993 GroupTopN,
11994 Sort,
11995 WatermarkFilter,
11996 Dml,
11997 RowIdGen,
11998 Now,
11999 AppendOnlyGroupTopN,
12000 TemporalJoin,
12001 BarrierRecv,
12002 Values,
12003 AppendOnlyDedup,
12004 NoOp,
12005 EowcOverWindow,
12006 OverWindow,
12007 StreamFsFetch,
12008 StreamCdcScan,
12009 CdcFilter,
12010 SourceBackfill,
12011 Changelog,
12012 LocalApproxPercentile,
12013 GlobalApproxPercentile,
12014 RowMerge,
12015 AsOfJoin,
12016 SyncLogStore,
12017 MaterializedExprs,
12018 }
12019 impl<'de> serde::Deserialize<'de> for GeneratedField {
12020 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12021 where
12022 D: serde::Deserializer<'de>,
12023 {
12024 struct GeneratedVisitor;
12025
12026 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12027 type Value = GeneratedField;
12028
12029 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12030 write!(formatter, "expected one of: {:?}", &FIELDS)
12031 }
12032
12033 #[allow(unused_variables)]
12034 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12035 where
12036 E: serde::de::Error,
12037 {
12038 match value {
12039 "operatorId" | "operator_id" => Ok(GeneratedField::OperatorId),
12040 "input" => Ok(GeneratedField::Input),
12041 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
12042 "appendOnly" | "append_only" => Ok(GeneratedField::AppendOnly),
12043 "identity" => Ok(GeneratedField::Identity),
12044 "fields" => Ok(GeneratedField::Fields),
12045 "source" => Ok(GeneratedField::Source),
12046 "project" => Ok(GeneratedField::Project),
12047 "filter" => Ok(GeneratedField::Filter),
12048 "materialize" => Ok(GeneratedField::Materialize),
12049 "statelessSimpleAgg" | "stateless_simple_agg" => Ok(GeneratedField::StatelessSimpleAgg),
12050 "simpleAgg" | "simple_agg" => Ok(GeneratedField::SimpleAgg),
12051 "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
12052 "appendOnlyTopN" | "append_only_top_n" => Ok(GeneratedField::AppendOnlyTopN),
12053 "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
12054 "topN" | "top_n" => Ok(GeneratedField::TopN),
12055 "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
12056 "merge" => Ok(GeneratedField::Merge),
12057 "exchange" => Ok(GeneratedField::Exchange),
12058 "streamScan" | "stream_scan" => Ok(GeneratedField::StreamScan),
12059 "batchPlan" | "batch_plan" => Ok(GeneratedField::BatchPlan),
12060 "lookup" => Ok(GeneratedField::Lookup),
12061 "arrange" => Ok(GeneratedField::Arrange),
12062 "lookupUnion" | "lookup_union" => Ok(GeneratedField::LookupUnion),
12063 "union" => Ok(GeneratedField::Union),
12064 "deltaIndexJoin" | "delta_index_join" => Ok(GeneratedField::DeltaIndexJoin),
12065 "sink" => Ok(GeneratedField::Sink),
12066 "expand" => Ok(GeneratedField::Expand),
12067 "dynamicFilter" | "dynamic_filter" => Ok(GeneratedField::DynamicFilter),
12068 "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
12069 "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
12070 "sort" => Ok(GeneratedField::Sort),
12071 "watermarkFilter" | "watermark_filter" => Ok(GeneratedField::WatermarkFilter),
12072 "dml" => Ok(GeneratedField::Dml),
12073 "rowIdGen" | "row_id_gen" => Ok(GeneratedField::RowIdGen),
12074 "now" => Ok(GeneratedField::Now),
12075 "appendOnlyGroupTopN" | "append_only_group_top_n" => Ok(GeneratedField::AppendOnlyGroupTopN),
12076 "temporalJoin" | "temporal_join" => Ok(GeneratedField::TemporalJoin),
12077 "barrierRecv" | "barrier_recv" => Ok(GeneratedField::BarrierRecv),
12078 "values" => Ok(GeneratedField::Values),
12079 "appendOnlyDedup" | "append_only_dedup" => Ok(GeneratedField::AppendOnlyDedup),
12080 "noOp" | "no_op" => Ok(GeneratedField::NoOp),
12081 "eowcOverWindow" | "eowc_over_window" => Ok(GeneratedField::EowcOverWindow),
12082 "overWindow" | "over_window" => Ok(GeneratedField::OverWindow),
12083 "streamFsFetch" | "stream_fs_fetch" => Ok(GeneratedField::StreamFsFetch),
12084 "streamCdcScan" | "stream_cdc_scan" => Ok(GeneratedField::StreamCdcScan),
12085 "cdcFilter" | "cdc_filter" => Ok(GeneratedField::CdcFilter),
12086 "sourceBackfill" | "source_backfill" => Ok(GeneratedField::SourceBackfill),
12087 "changelog" => Ok(GeneratedField::Changelog),
12088 "localApproxPercentile" | "local_approx_percentile" => Ok(GeneratedField::LocalApproxPercentile),
12089 "globalApproxPercentile" | "global_approx_percentile" => Ok(GeneratedField::GlobalApproxPercentile),
12090 "rowMerge" | "row_merge" => Ok(GeneratedField::RowMerge),
12091 "asOfJoin" | "as_of_join" => Ok(GeneratedField::AsOfJoin),
12092 "syncLogStore" | "sync_log_store" => Ok(GeneratedField::SyncLogStore),
12093 "materializedExprs" | "materialized_exprs" => Ok(GeneratedField::MaterializedExprs),
12094 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12095 }
12096 }
12097 }
12098 deserializer.deserialize_identifier(GeneratedVisitor)
12099 }
12100 }
12101 struct GeneratedVisitor;
12102 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12103 type Value = StreamNode;
12104
12105 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12106 formatter.write_str("struct stream_plan.StreamNode")
12107 }
12108
12109 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamNode, V::Error>
12110 where
12111 V: serde::de::MapAccess<'de>,
12112 {
12113 let mut operator_id__ = None;
12114 let mut input__ = None;
12115 let mut stream_key__ = None;
12116 let mut append_only__ = None;
12117 let mut identity__ = None;
12118 let mut fields__ = None;
12119 let mut node_body__ = None;
12120 while let Some(k) = map_.next_key()? {
12121 match k {
12122 GeneratedField::OperatorId => {
12123 if operator_id__.is_some() {
12124 return Err(serde::de::Error::duplicate_field("operatorId"));
12125 }
12126 operator_id__ =
12127 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12128 ;
12129 }
12130 GeneratedField::Input => {
12131 if input__.is_some() {
12132 return Err(serde::de::Error::duplicate_field("input"));
12133 }
12134 input__ = Some(map_.next_value()?);
12135 }
12136 GeneratedField::StreamKey => {
12137 if stream_key__.is_some() {
12138 return Err(serde::de::Error::duplicate_field("streamKey"));
12139 }
12140 stream_key__ =
12141 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12142 .into_iter().map(|x| x.0).collect())
12143 ;
12144 }
12145 GeneratedField::AppendOnly => {
12146 if append_only__.is_some() {
12147 return Err(serde::de::Error::duplicate_field("appendOnly"));
12148 }
12149 append_only__ = Some(map_.next_value()?);
12150 }
12151 GeneratedField::Identity => {
12152 if identity__.is_some() {
12153 return Err(serde::de::Error::duplicate_field("identity"));
12154 }
12155 identity__ = Some(map_.next_value()?);
12156 }
12157 GeneratedField::Fields => {
12158 if fields__.is_some() {
12159 return Err(serde::de::Error::duplicate_field("fields"));
12160 }
12161 fields__ = Some(map_.next_value()?);
12162 }
12163 GeneratedField::Source => {
12164 if node_body__.is_some() {
12165 return Err(serde::de::Error::duplicate_field("source"));
12166 }
12167 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Source)
12168;
12169 }
12170 GeneratedField::Project => {
12171 if node_body__.is_some() {
12172 return Err(serde::de::Error::duplicate_field("project"));
12173 }
12174 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Project)
12175;
12176 }
12177 GeneratedField::Filter => {
12178 if node_body__.is_some() {
12179 return Err(serde::de::Error::duplicate_field("filter"));
12180 }
12181 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Filter)
12182;
12183 }
12184 GeneratedField::Materialize => {
12185 if node_body__.is_some() {
12186 return Err(serde::de::Error::duplicate_field("materialize"));
12187 }
12188 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Materialize)
12189;
12190 }
12191 GeneratedField::StatelessSimpleAgg => {
12192 if node_body__.is_some() {
12193 return Err(serde::de::Error::duplicate_field("statelessSimpleAgg"));
12194 }
12195 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StatelessSimpleAgg)
12196;
12197 }
12198 GeneratedField::SimpleAgg => {
12199 if node_body__.is_some() {
12200 return Err(serde::de::Error::duplicate_field("simpleAgg"));
12201 }
12202 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SimpleAgg)
12203;
12204 }
12205 GeneratedField::HashAgg => {
12206 if node_body__.is_some() {
12207 return Err(serde::de::Error::duplicate_field("hashAgg"));
12208 }
12209 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashAgg)
12210;
12211 }
12212 GeneratedField::AppendOnlyTopN => {
12213 if node_body__.is_some() {
12214 return Err(serde::de::Error::duplicate_field("appendOnlyTopN"));
12215 }
12216 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyTopN)
12217;
12218 }
12219 GeneratedField::HashJoin => {
12220 if node_body__.is_some() {
12221 return Err(serde::de::Error::duplicate_field("hashJoin"));
12222 }
12223 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashJoin)
12224;
12225 }
12226 GeneratedField::TopN => {
12227 if node_body__.is_some() {
12228 return Err(serde::de::Error::duplicate_field("topN"));
12229 }
12230 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TopN)
12231;
12232 }
12233 GeneratedField::HopWindow => {
12234 if node_body__.is_some() {
12235 return Err(serde::de::Error::duplicate_field("hopWindow"));
12236 }
12237 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HopWindow)
12238;
12239 }
12240 GeneratedField::Merge => {
12241 if node_body__.is_some() {
12242 return Err(serde::de::Error::duplicate_field("merge"));
12243 }
12244 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Merge)
12245;
12246 }
12247 GeneratedField::Exchange => {
12248 if node_body__.is_some() {
12249 return Err(serde::de::Error::duplicate_field("exchange"));
12250 }
12251 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Exchange)
12252;
12253 }
12254 GeneratedField::StreamScan => {
12255 if node_body__.is_some() {
12256 return Err(serde::de::Error::duplicate_field("streamScan"));
12257 }
12258 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamScan)
12259;
12260 }
12261 GeneratedField::BatchPlan => {
12262 if node_body__.is_some() {
12263 return Err(serde::de::Error::duplicate_field("batchPlan"));
12264 }
12265 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BatchPlan)
12266;
12267 }
12268 GeneratedField::Lookup => {
12269 if node_body__.is_some() {
12270 return Err(serde::de::Error::duplicate_field("lookup"));
12271 }
12272 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Lookup)
12273;
12274 }
12275 GeneratedField::Arrange => {
12276 if node_body__.is_some() {
12277 return Err(serde::de::Error::duplicate_field("arrange"));
12278 }
12279 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Arrange)
12280;
12281 }
12282 GeneratedField::LookupUnion => {
12283 if node_body__.is_some() {
12284 return Err(serde::de::Error::duplicate_field("lookupUnion"));
12285 }
12286 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LookupUnion)
12287;
12288 }
12289 GeneratedField::Union => {
12290 if node_body__.is_some() {
12291 return Err(serde::de::Error::duplicate_field("union"));
12292 }
12293 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Union)
12294;
12295 }
12296 GeneratedField::DeltaIndexJoin => {
12297 if node_body__.is_some() {
12298 return Err(serde::de::Error::duplicate_field("deltaIndexJoin"));
12299 }
12300 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DeltaIndexJoin)
12301;
12302 }
12303 GeneratedField::Sink => {
12304 if node_body__.is_some() {
12305 return Err(serde::de::Error::duplicate_field("sink"));
12306 }
12307 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sink)
12308;
12309 }
12310 GeneratedField::Expand => {
12311 if node_body__.is_some() {
12312 return Err(serde::de::Error::duplicate_field("expand"));
12313 }
12314 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Expand)
12315;
12316 }
12317 GeneratedField::DynamicFilter => {
12318 if node_body__.is_some() {
12319 return Err(serde::de::Error::duplicate_field("dynamicFilter"));
12320 }
12321 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DynamicFilter)
12322;
12323 }
12324 GeneratedField::ProjectSet => {
12325 if node_body__.is_some() {
12326 return Err(serde::de::Error::duplicate_field("projectSet"));
12327 }
12328 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::ProjectSet)
12329;
12330 }
12331 GeneratedField::GroupTopN => {
12332 if node_body__.is_some() {
12333 return Err(serde::de::Error::duplicate_field("groupTopN"));
12334 }
12335 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GroupTopN)
12336;
12337 }
12338 GeneratedField::Sort => {
12339 if node_body__.is_some() {
12340 return Err(serde::de::Error::duplicate_field("sort"));
12341 }
12342 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sort)
12343;
12344 }
12345 GeneratedField::WatermarkFilter => {
12346 if node_body__.is_some() {
12347 return Err(serde::de::Error::duplicate_field("watermarkFilter"));
12348 }
12349 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::WatermarkFilter)
12350;
12351 }
12352 GeneratedField::Dml => {
12353 if node_body__.is_some() {
12354 return Err(serde::de::Error::duplicate_field("dml"));
12355 }
12356 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Dml)
12357;
12358 }
12359 GeneratedField::RowIdGen => {
12360 if node_body__.is_some() {
12361 return Err(serde::de::Error::duplicate_field("rowIdGen"));
12362 }
12363 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowIdGen)
12364;
12365 }
12366 GeneratedField::Now => {
12367 if node_body__.is_some() {
12368 return Err(serde::de::Error::duplicate_field("now"));
12369 }
12370 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Now)
12371;
12372 }
12373 GeneratedField::AppendOnlyGroupTopN => {
12374 if node_body__.is_some() {
12375 return Err(serde::de::Error::duplicate_field("appendOnlyGroupTopN"));
12376 }
12377 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyGroupTopN)
12378;
12379 }
12380 GeneratedField::TemporalJoin => {
12381 if node_body__.is_some() {
12382 return Err(serde::de::Error::duplicate_field("temporalJoin"));
12383 }
12384 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TemporalJoin)
12385;
12386 }
12387 GeneratedField::BarrierRecv => {
12388 if node_body__.is_some() {
12389 return Err(serde::de::Error::duplicate_field("barrierRecv"));
12390 }
12391 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BarrierRecv)
12392;
12393 }
12394 GeneratedField::Values => {
12395 if node_body__.is_some() {
12396 return Err(serde::de::Error::duplicate_field("values"));
12397 }
12398 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Values)
12399;
12400 }
12401 GeneratedField::AppendOnlyDedup => {
12402 if node_body__.is_some() {
12403 return Err(serde::de::Error::duplicate_field("appendOnlyDedup"));
12404 }
12405 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyDedup)
12406;
12407 }
12408 GeneratedField::NoOp => {
12409 if node_body__.is_some() {
12410 return Err(serde::de::Error::duplicate_field("noOp"));
12411 }
12412 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::NoOp)
12413;
12414 }
12415 GeneratedField::EowcOverWindow => {
12416 if node_body__.is_some() {
12417 return Err(serde::de::Error::duplicate_field("eowcOverWindow"));
12418 }
12419 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcOverWindow)
12420;
12421 }
12422 GeneratedField::OverWindow => {
12423 if node_body__.is_some() {
12424 return Err(serde::de::Error::duplicate_field("overWindow"));
12425 }
12426 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::OverWindow)
12427;
12428 }
12429 GeneratedField::StreamFsFetch => {
12430 if node_body__.is_some() {
12431 return Err(serde::de::Error::duplicate_field("streamFsFetch"));
12432 }
12433 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamFsFetch)
12434;
12435 }
12436 GeneratedField::StreamCdcScan => {
12437 if node_body__.is_some() {
12438 return Err(serde::de::Error::duplicate_field("streamCdcScan"));
12439 }
12440 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamCdcScan)
12441;
12442 }
12443 GeneratedField::CdcFilter => {
12444 if node_body__.is_some() {
12445 return Err(serde::de::Error::duplicate_field("cdcFilter"));
12446 }
12447 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CdcFilter)
12448;
12449 }
12450 GeneratedField::SourceBackfill => {
12451 if node_body__.is_some() {
12452 return Err(serde::de::Error::duplicate_field("sourceBackfill"));
12453 }
12454 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SourceBackfill)
12455;
12456 }
12457 GeneratedField::Changelog => {
12458 if node_body__.is_some() {
12459 return Err(serde::de::Error::duplicate_field("changelog"));
12460 }
12461 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Changelog)
12462;
12463 }
12464 GeneratedField::LocalApproxPercentile => {
12465 if node_body__.is_some() {
12466 return Err(serde::de::Error::duplicate_field("localApproxPercentile"));
12467 }
12468 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalApproxPercentile)
12469;
12470 }
12471 GeneratedField::GlobalApproxPercentile => {
12472 if node_body__.is_some() {
12473 return Err(serde::de::Error::duplicate_field("globalApproxPercentile"));
12474 }
12475 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GlobalApproxPercentile)
12476;
12477 }
12478 GeneratedField::RowMerge => {
12479 if node_body__.is_some() {
12480 return Err(serde::de::Error::duplicate_field("rowMerge"));
12481 }
12482 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowMerge)
12483;
12484 }
12485 GeneratedField::AsOfJoin => {
12486 if node_body__.is_some() {
12487 return Err(serde::de::Error::duplicate_field("asOfJoin"));
12488 }
12489 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AsOfJoin)
12490;
12491 }
12492 GeneratedField::SyncLogStore => {
12493 if node_body__.is_some() {
12494 return Err(serde::de::Error::duplicate_field("syncLogStore"));
12495 }
12496 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SyncLogStore)
12497;
12498 }
12499 GeneratedField::MaterializedExprs => {
12500 if node_body__.is_some() {
12501 return Err(serde::de::Error::duplicate_field("materializedExprs"));
12502 }
12503 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MaterializedExprs)
12504;
12505 }
12506 }
12507 }
12508 Ok(StreamNode {
12509 operator_id: operator_id__.unwrap_or_default(),
12510 input: input__.unwrap_or_default(),
12511 stream_key: stream_key__.unwrap_or_default(),
12512 append_only: append_only__.unwrap_or_default(),
12513 identity: identity__.unwrap_or_default(),
12514 fields: fields__.unwrap_or_default(),
12515 node_body: node_body__,
12516 })
12517 }
12518 }
12519 deserializer.deserialize_struct("stream_plan.StreamNode", FIELDS, GeneratedVisitor)
12520 }
12521}
12522impl serde::Serialize for StreamScanNode {
12523 #[allow(deprecated)]
12524 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12525 where
12526 S: serde::Serializer,
12527 {
12528 use serde::ser::SerializeStruct;
12529 let mut len = 0;
12530 if self.table_id != 0 {
12531 len += 1;
12532 }
12533 if !self.upstream_column_ids.is_empty() {
12534 len += 1;
12535 }
12536 if !self.output_indices.is_empty() {
12537 len += 1;
12538 }
12539 if self.stream_scan_type != 0 {
12540 len += 1;
12541 }
12542 if self.state_table.is_some() {
12543 len += 1;
12544 }
12545 if self.table_desc.is_some() {
12546 len += 1;
12547 }
12548 if self.rate_limit.is_some() {
12549 len += 1;
12550 }
12551 if self.snapshot_read_barrier_interval != 0 {
12552 len += 1;
12553 }
12554 if self.arrangement_table.is_some() {
12555 len += 1;
12556 }
12557 if self.snapshot_backfill_epoch.is_some() {
12558 len += 1;
12559 }
12560 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamScanNode", len)?;
12561 if self.table_id != 0 {
12562 struct_ser.serialize_field("tableId", &self.table_id)?;
12563 }
12564 if !self.upstream_column_ids.is_empty() {
12565 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
12566 }
12567 if !self.output_indices.is_empty() {
12568 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
12569 }
12570 if self.stream_scan_type != 0 {
12571 let v = StreamScanType::try_from(self.stream_scan_type)
12572 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_scan_type)))?;
12573 struct_ser.serialize_field("streamScanType", &v)?;
12574 }
12575 if let Some(v) = self.state_table.as_ref() {
12576 struct_ser.serialize_field("stateTable", v)?;
12577 }
12578 if let Some(v) = self.table_desc.as_ref() {
12579 struct_ser.serialize_field("tableDesc", v)?;
12580 }
12581 if let Some(v) = self.rate_limit.as_ref() {
12582 struct_ser.serialize_field("rateLimit", v)?;
12583 }
12584 if self.snapshot_read_barrier_interval != 0 {
12585 struct_ser.serialize_field("snapshotReadBarrierInterval", &self.snapshot_read_barrier_interval)?;
12586 }
12587 if let Some(v) = self.arrangement_table.as_ref() {
12588 struct_ser.serialize_field("arrangementTable", v)?;
12589 }
12590 if let Some(v) = self.snapshot_backfill_epoch.as_ref() {
12591 #[allow(clippy::needless_borrow)]
12592 #[allow(clippy::needless_borrows_for_generic_args)]
12593 struct_ser.serialize_field("snapshotBackfillEpoch", ToString::to_string(&v).as_str())?;
12594 }
12595 struct_ser.end()
12596 }
12597}
12598impl<'de> serde::Deserialize<'de> for StreamScanNode {
12599 #[allow(deprecated)]
12600 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12601 where
12602 D: serde::Deserializer<'de>,
12603 {
12604 const FIELDS: &[&str] = &[
12605 "table_id",
12606 "tableId",
12607 "upstream_column_ids",
12608 "upstreamColumnIds",
12609 "output_indices",
12610 "outputIndices",
12611 "stream_scan_type",
12612 "streamScanType",
12613 "state_table",
12614 "stateTable",
12615 "table_desc",
12616 "tableDesc",
12617 "rate_limit",
12618 "rateLimit",
12619 "snapshot_read_barrier_interval",
12620 "snapshotReadBarrierInterval",
12621 "arrangement_table",
12622 "arrangementTable",
12623 "snapshot_backfill_epoch",
12624 "snapshotBackfillEpoch",
12625 ];
12626
12627 #[allow(clippy::enum_variant_names)]
12628 enum GeneratedField {
12629 TableId,
12630 UpstreamColumnIds,
12631 OutputIndices,
12632 StreamScanType,
12633 StateTable,
12634 TableDesc,
12635 RateLimit,
12636 SnapshotReadBarrierInterval,
12637 ArrangementTable,
12638 SnapshotBackfillEpoch,
12639 }
12640 impl<'de> serde::Deserialize<'de> for GeneratedField {
12641 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12642 where
12643 D: serde::Deserializer<'de>,
12644 {
12645 struct GeneratedVisitor;
12646
12647 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12648 type Value = GeneratedField;
12649
12650 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12651 write!(formatter, "expected one of: {:?}", &FIELDS)
12652 }
12653
12654 #[allow(unused_variables)]
12655 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12656 where
12657 E: serde::de::Error,
12658 {
12659 match value {
12660 "tableId" | "table_id" => Ok(GeneratedField::TableId),
12661 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
12662 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
12663 "streamScanType" | "stream_scan_type" => Ok(GeneratedField::StreamScanType),
12664 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
12665 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
12666 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
12667 "snapshotReadBarrierInterval" | "snapshot_read_barrier_interval" => Ok(GeneratedField::SnapshotReadBarrierInterval),
12668 "arrangementTable" | "arrangement_table" => Ok(GeneratedField::ArrangementTable),
12669 "snapshotBackfillEpoch" | "snapshot_backfill_epoch" => Ok(GeneratedField::SnapshotBackfillEpoch),
12670 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12671 }
12672 }
12673 }
12674 deserializer.deserialize_identifier(GeneratedVisitor)
12675 }
12676 }
12677 struct GeneratedVisitor;
12678 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12679 type Value = StreamScanNode;
12680
12681 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12682 formatter.write_str("struct stream_plan.StreamScanNode")
12683 }
12684
12685 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamScanNode, V::Error>
12686 where
12687 V: serde::de::MapAccess<'de>,
12688 {
12689 let mut table_id__ = None;
12690 let mut upstream_column_ids__ = None;
12691 let mut output_indices__ = None;
12692 let mut stream_scan_type__ = None;
12693 let mut state_table__ = None;
12694 let mut table_desc__ = None;
12695 let mut rate_limit__ = None;
12696 let mut snapshot_read_barrier_interval__ = None;
12697 let mut arrangement_table__ = None;
12698 let mut snapshot_backfill_epoch__ = None;
12699 while let Some(k) = map_.next_key()? {
12700 match k {
12701 GeneratedField::TableId => {
12702 if table_id__.is_some() {
12703 return Err(serde::de::Error::duplicate_field("tableId"));
12704 }
12705 table_id__ =
12706 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12707 ;
12708 }
12709 GeneratedField::UpstreamColumnIds => {
12710 if upstream_column_ids__.is_some() {
12711 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
12712 }
12713 upstream_column_ids__ =
12714 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12715 .into_iter().map(|x| x.0).collect())
12716 ;
12717 }
12718 GeneratedField::OutputIndices => {
12719 if output_indices__.is_some() {
12720 return Err(serde::de::Error::duplicate_field("outputIndices"));
12721 }
12722 output_indices__ =
12723 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12724 .into_iter().map(|x| x.0).collect())
12725 ;
12726 }
12727 GeneratedField::StreamScanType => {
12728 if stream_scan_type__.is_some() {
12729 return Err(serde::de::Error::duplicate_field("streamScanType"));
12730 }
12731 stream_scan_type__ = Some(map_.next_value::<StreamScanType>()? as i32);
12732 }
12733 GeneratedField::StateTable => {
12734 if state_table__.is_some() {
12735 return Err(serde::de::Error::duplicate_field("stateTable"));
12736 }
12737 state_table__ = map_.next_value()?;
12738 }
12739 GeneratedField::TableDesc => {
12740 if table_desc__.is_some() {
12741 return Err(serde::de::Error::duplicate_field("tableDesc"));
12742 }
12743 table_desc__ = map_.next_value()?;
12744 }
12745 GeneratedField::RateLimit => {
12746 if rate_limit__.is_some() {
12747 return Err(serde::de::Error::duplicate_field("rateLimit"));
12748 }
12749 rate_limit__ =
12750 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12751 ;
12752 }
12753 GeneratedField::SnapshotReadBarrierInterval => {
12754 if snapshot_read_barrier_interval__.is_some() {
12755 return Err(serde::de::Error::duplicate_field("snapshotReadBarrierInterval"));
12756 }
12757 snapshot_read_barrier_interval__ =
12758 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12759 ;
12760 }
12761 GeneratedField::ArrangementTable => {
12762 if arrangement_table__.is_some() {
12763 return Err(serde::de::Error::duplicate_field("arrangementTable"));
12764 }
12765 arrangement_table__ = map_.next_value()?;
12766 }
12767 GeneratedField::SnapshotBackfillEpoch => {
12768 if snapshot_backfill_epoch__.is_some() {
12769 return Err(serde::de::Error::duplicate_field("snapshotBackfillEpoch"));
12770 }
12771 snapshot_backfill_epoch__ =
12772 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12773 ;
12774 }
12775 }
12776 }
12777 Ok(StreamScanNode {
12778 table_id: table_id__.unwrap_or_default(),
12779 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
12780 output_indices: output_indices__.unwrap_or_default(),
12781 stream_scan_type: stream_scan_type__.unwrap_or_default(),
12782 state_table: state_table__,
12783 table_desc: table_desc__,
12784 rate_limit: rate_limit__,
12785 snapshot_read_barrier_interval: snapshot_read_barrier_interval__.unwrap_or_default(),
12786 arrangement_table: arrangement_table__,
12787 snapshot_backfill_epoch: snapshot_backfill_epoch__,
12788 })
12789 }
12790 }
12791 deserializer.deserialize_struct("stream_plan.StreamScanNode", FIELDS, GeneratedVisitor)
12792 }
12793}
12794impl serde::Serialize for StreamScanType {
12795 #[allow(deprecated)]
12796 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12797 where
12798 S: serde::Serializer,
12799 {
12800 let variant = match self {
12801 Self::Unspecified => "STREAM_SCAN_TYPE_UNSPECIFIED",
12802 Self::Chain => "STREAM_SCAN_TYPE_CHAIN",
12803 Self::Rearrange => "STREAM_SCAN_TYPE_REARRANGE",
12804 Self::Backfill => "STREAM_SCAN_TYPE_BACKFILL",
12805 Self::UpstreamOnly => "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
12806 Self::ArrangementBackfill => "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
12807 Self::SnapshotBackfill => "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
12808 Self::CrossDbSnapshotBackfill => "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
12809 };
12810 serializer.serialize_str(variant)
12811 }
12812}
12813impl<'de> serde::Deserialize<'de> for StreamScanType {
12814 #[allow(deprecated)]
12815 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12816 where
12817 D: serde::Deserializer<'de>,
12818 {
12819 const FIELDS: &[&str] = &[
12820 "STREAM_SCAN_TYPE_UNSPECIFIED",
12821 "STREAM_SCAN_TYPE_CHAIN",
12822 "STREAM_SCAN_TYPE_REARRANGE",
12823 "STREAM_SCAN_TYPE_BACKFILL",
12824 "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
12825 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
12826 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
12827 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
12828 ];
12829
12830 struct GeneratedVisitor;
12831
12832 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12833 type Value = StreamScanType;
12834
12835 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12836 write!(formatter, "expected one of: {:?}", &FIELDS)
12837 }
12838
12839 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
12840 where
12841 E: serde::de::Error,
12842 {
12843 i32::try_from(v)
12844 .ok()
12845 .and_then(|x| x.try_into().ok())
12846 .ok_or_else(|| {
12847 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
12848 })
12849 }
12850
12851 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
12852 where
12853 E: serde::de::Error,
12854 {
12855 i32::try_from(v)
12856 .ok()
12857 .and_then(|x| x.try_into().ok())
12858 .ok_or_else(|| {
12859 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
12860 })
12861 }
12862
12863 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
12864 where
12865 E: serde::de::Error,
12866 {
12867 match value {
12868 "STREAM_SCAN_TYPE_UNSPECIFIED" => Ok(StreamScanType::Unspecified),
12869 "STREAM_SCAN_TYPE_CHAIN" => Ok(StreamScanType::Chain),
12870 "STREAM_SCAN_TYPE_REARRANGE" => Ok(StreamScanType::Rearrange),
12871 "STREAM_SCAN_TYPE_BACKFILL" => Ok(StreamScanType::Backfill),
12872 "STREAM_SCAN_TYPE_UPSTREAM_ONLY" => Ok(StreamScanType::UpstreamOnly),
12873 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL" => Ok(StreamScanType::ArrangementBackfill),
12874 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL" => Ok(StreamScanType::SnapshotBackfill),
12875 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL" => Ok(StreamScanType::CrossDbSnapshotBackfill),
12876 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
12877 }
12878 }
12879 }
12880 deserializer.deserialize_any(GeneratedVisitor)
12881 }
12882}
12883impl serde::Serialize for StreamSource {
12884 #[allow(deprecated)]
12885 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12886 where
12887 S: serde::Serializer,
12888 {
12889 use serde::ser::SerializeStruct;
12890 let mut len = 0;
12891 if self.source_id != 0 {
12892 len += 1;
12893 }
12894 if self.state_table.is_some() {
12895 len += 1;
12896 }
12897 if self.row_id_index.is_some() {
12898 len += 1;
12899 }
12900 if !self.columns.is_empty() {
12901 len += 1;
12902 }
12903 if !self.with_properties.is_empty() {
12904 len += 1;
12905 }
12906 if self.info.is_some() {
12907 len += 1;
12908 }
12909 if !self.source_name.is_empty() {
12910 len += 1;
12911 }
12912 if self.rate_limit.is_some() {
12913 len += 1;
12914 }
12915 if !self.secret_refs.is_empty() {
12916 len += 1;
12917 }
12918 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamSource", len)?;
12919 if self.source_id != 0 {
12920 struct_ser.serialize_field("sourceId", &self.source_id)?;
12921 }
12922 if let Some(v) = self.state_table.as_ref() {
12923 struct_ser.serialize_field("stateTable", v)?;
12924 }
12925 if let Some(v) = self.row_id_index.as_ref() {
12926 struct_ser.serialize_field("rowIdIndex", v)?;
12927 }
12928 if !self.columns.is_empty() {
12929 struct_ser.serialize_field("columns", &self.columns)?;
12930 }
12931 if !self.with_properties.is_empty() {
12932 struct_ser.serialize_field("withProperties", &self.with_properties)?;
12933 }
12934 if let Some(v) = self.info.as_ref() {
12935 struct_ser.serialize_field("info", v)?;
12936 }
12937 if !self.source_name.is_empty() {
12938 struct_ser.serialize_field("sourceName", &self.source_name)?;
12939 }
12940 if let Some(v) = self.rate_limit.as_ref() {
12941 struct_ser.serialize_field("rateLimit", v)?;
12942 }
12943 if !self.secret_refs.is_empty() {
12944 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
12945 }
12946 struct_ser.end()
12947 }
12948}
12949impl<'de> serde::Deserialize<'de> for StreamSource {
12950 #[allow(deprecated)]
12951 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12952 where
12953 D: serde::Deserializer<'de>,
12954 {
12955 const FIELDS: &[&str] = &[
12956 "source_id",
12957 "sourceId",
12958 "state_table",
12959 "stateTable",
12960 "row_id_index",
12961 "rowIdIndex",
12962 "columns",
12963 "with_properties",
12964 "withProperties",
12965 "info",
12966 "source_name",
12967 "sourceName",
12968 "rate_limit",
12969 "rateLimit",
12970 "secret_refs",
12971 "secretRefs",
12972 ];
12973
12974 #[allow(clippy::enum_variant_names)]
12975 enum GeneratedField {
12976 SourceId,
12977 StateTable,
12978 RowIdIndex,
12979 Columns,
12980 WithProperties,
12981 Info,
12982 SourceName,
12983 RateLimit,
12984 SecretRefs,
12985 }
12986 impl<'de> serde::Deserialize<'de> for GeneratedField {
12987 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12988 where
12989 D: serde::Deserializer<'de>,
12990 {
12991 struct GeneratedVisitor;
12992
12993 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12994 type Value = GeneratedField;
12995
12996 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12997 write!(formatter, "expected one of: {:?}", &FIELDS)
12998 }
12999
13000 #[allow(unused_variables)]
13001 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13002 where
13003 E: serde::de::Error,
13004 {
13005 match value {
13006 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
13007 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
13008 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
13009 "columns" => Ok(GeneratedField::Columns),
13010 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
13011 "info" => Ok(GeneratedField::Info),
13012 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
13013 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
13014 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
13015 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13016 }
13017 }
13018 }
13019 deserializer.deserialize_identifier(GeneratedVisitor)
13020 }
13021 }
13022 struct GeneratedVisitor;
13023 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13024 type Value = StreamSource;
13025
13026 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13027 formatter.write_str("struct stream_plan.StreamSource")
13028 }
13029
13030 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSource, V::Error>
13031 where
13032 V: serde::de::MapAccess<'de>,
13033 {
13034 let mut source_id__ = None;
13035 let mut state_table__ = None;
13036 let mut row_id_index__ = None;
13037 let mut columns__ = None;
13038 let mut with_properties__ = None;
13039 let mut info__ = None;
13040 let mut source_name__ = None;
13041 let mut rate_limit__ = None;
13042 let mut secret_refs__ = None;
13043 while let Some(k) = map_.next_key()? {
13044 match k {
13045 GeneratedField::SourceId => {
13046 if source_id__.is_some() {
13047 return Err(serde::de::Error::duplicate_field("sourceId"));
13048 }
13049 source_id__ =
13050 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13051 ;
13052 }
13053 GeneratedField::StateTable => {
13054 if state_table__.is_some() {
13055 return Err(serde::de::Error::duplicate_field("stateTable"));
13056 }
13057 state_table__ = map_.next_value()?;
13058 }
13059 GeneratedField::RowIdIndex => {
13060 if row_id_index__.is_some() {
13061 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
13062 }
13063 row_id_index__ =
13064 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13065 ;
13066 }
13067 GeneratedField::Columns => {
13068 if columns__.is_some() {
13069 return Err(serde::de::Error::duplicate_field("columns"));
13070 }
13071 columns__ = Some(map_.next_value()?);
13072 }
13073 GeneratedField::WithProperties => {
13074 if with_properties__.is_some() {
13075 return Err(serde::de::Error::duplicate_field("withProperties"));
13076 }
13077 with_properties__ = Some(
13078 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13079 );
13080 }
13081 GeneratedField::Info => {
13082 if info__.is_some() {
13083 return Err(serde::de::Error::duplicate_field("info"));
13084 }
13085 info__ = map_.next_value()?;
13086 }
13087 GeneratedField::SourceName => {
13088 if source_name__.is_some() {
13089 return Err(serde::de::Error::duplicate_field("sourceName"));
13090 }
13091 source_name__ = Some(map_.next_value()?);
13092 }
13093 GeneratedField::RateLimit => {
13094 if rate_limit__.is_some() {
13095 return Err(serde::de::Error::duplicate_field("rateLimit"));
13096 }
13097 rate_limit__ =
13098 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13099 ;
13100 }
13101 GeneratedField::SecretRefs => {
13102 if secret_refs__.is_some() {
13103 return Err(serde::de::Error::duplicate_field("secretRefs"));
13104 }
13105 secret_refs__ = Some(
13106 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13107 );
13108 }
13109 }
13110 }
13111 Ok(StreamSource {
13112 source_id: source_id__.unwrap_or_default(),
13113 state_table: state_table__,
13114 row_id_index: row_id_index__,
13115 columns: columns__.unwrap_or_default(),
13116 with_properties: with_properties__.unwrap_or_default(),
13117 info: info__,
13118 source_name: source_name__.unwrap_or_default(),
13119 rate_limit: rate_limit__,
13120 secret_refs: secret_refs__.unwrap_or_default(),
13121 })
13122 }
13123 }
13124 deserializer.deserialize_struct("stream_plan.StreamSource", FIELDS, GeneratedVisitor)
13125 }
13126}
13127impl serde::Serialize for SubscriptionUpstreamInfo {
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.subscriber_id != 0 {
13136 len += 1;
13137 }
13138 if self.upstream_mv_table_id != 0 {
13139 len += 1;
13140 }
13141 let mut struct_ser = serializer.serialize_struct("stream_plan.SubscriptionUpstreamInfo", len)?;
13142 if self.subscriber_id != 0 {
13143 struct_ser.serialize_field("subscriberId", &self.subscriber_id)?;
13144 }
13145 if self.upstream_mv_table_id != 0 {
13146 struct_ser.serialize_field("upstreamMvTableId", &self.upstream_mv_table_id)?;
13147 }
13148 struct_ser.end()
13149 }
13150}
13151impl<'de> serde::Deserialize<'de> for SubscriptionUpstreamInfo {
13152 #[allow(deprecated)]
13153 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13154 where
13155 D: serde::Deserializer<'de>,
13156 {
13157 const FIELDS: &[&str] = &[
13158 "subscriber_id",
13159 "subscriberId",
13160 "upstream_mv_table_id",
13161 "upstreamMvTableId",
13162 ];
13163
13164 #[allow(clippy::enum_variant_names)]
13165 enum GeneratedField {
13166 SubscriberId,
13167 UpstreamMvTableId,
13168 }
13169 impl<'de> serde::Deserialize<'de> for GeneratedField {
13170 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13171 where
13172 D: serde::Deserializer<'de>,
13173 {
13174 struct GeneratedVisitor;
13175
13176 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13177 type Value = GeneratedField;
13178
13179 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13180 write!(formatter, "expected one of: {:?}", &FIELDS)
13181 }
13182
13183 #[allow(unused_variables)]
13184 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13185 where
13186 E: serde::de::Error,
13187 {
13188 match value {
13189 "subscriberId" | "subscriber_id" => Ok(GeneratedField::SubscriberId),
13190 "upstreamMvTableId" | "upstream_mv_table_id" => Ok(GeneratedField::UpstreamMvTableId),
13191 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13192 }
13193 }
13194 }
13195 deserializer.deserialize_identifier(GeneratedVisitor)
13196 }
13197 }
13198 struct GeneratedVisitor;
13199 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13200 type Value = SubscriptionUpstreamInfo;
13201
13202 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13203 formatter.write_str("struct stream_plan.SubscriptionUpstreamInfo")
13204 }
13205
13206 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscriptionUpstreamInfo, V::Error>
13207 where
13208 V: serde::de::MapAccess<'de>,
13209 {
13210 let mut subscriber_id__ = None;
13211 let mut upstream_mv_table_id__ = None;
13212 while let Some(k) = map_.next_key()? {
13213 match k {
13214 GeneratedField::SubscriberId => {
13215 if subscriber_id__.is_some() {
13216 return Err(serde::de::Error::duplicate_field("subscriberId"));
13217 }
13218 subscriber_id__ =
13219 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13220 ;
13221 }
13222 GeneratedField::UpstreamMvTableId => {
13223 if upstream_mv_table_id__.is_some() {
13224 return Err(serde::de::Error::duplicate_field("upstreamMvTableId"));
13225 }
13226 upstream_mv_table_id__ =
13227 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13228 ;
13229 }
13230 }
13231 }
13232 Ok(SubscriptionUpstreamInfo {
13233 subscriber_id: subscriber_id__.unwrap_or_default(),
13234 upstream_mv_table_id: upstream_mv_table_id__.unwrap_or_default(),
13235 })
13236 }
13237 }
13238 deserializer.deserialize_struct("stream_plan.SubscriptionUpstreamInfo", FIELDS, GeneratedVisitor)
13239 }
13240}
13241impl serde::Serialize for SyncLogStoreNode {
13242 #[allow(deprecated)]
13243 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13244 where
13245 S: serde::Serializer,
13246 {
13247 use serde::ser::SerializeStruct;
13248 let mut len = 0;
13249 if self.log_store_table.is_some() {
13250 len += 1;
13251 }
13252 if self.pause_duration_ms != 0 {
13253 len += 1;
13254 }
13255 if self.buffer_size != 0 {
13256 len += 1;
13257 }
13258 if self.aligned {
13259 len += 1;
13260 }
13261 let mut struct_ser = serializer.serialize_struct("stream_plan.SyncLogStoreNode", len)?;
13262 if let Some(v) = self.log_store_table.as_ref() {
13263 struct_ser.serialize_field("logStoreTable", v)?;
13264 }
13265 if self.pause_duration_ms != 0 {
13266 struct_ser.serialize_field("pauseDurationMs", &self.pause_duration_ms)?;
13267 }
13268 if self.buffer_size != 0 {
13269 struct_ser.serialize_field("bufferSize", &self.buffer_size)?;
13270 }
13271 if self.aligned {
13272 struct_ser.serialize_field("aligned", &self.aligned)?;
13273 }
13274 struct_ser.end()
13275 }
13276}
13277impl<'de> serde::Deserialize<'de> for SyncLogStoreNode {
13278 #[allow(deprecated)]
13279 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13280 where
13281 D: serde::Deserializer<'de>,
13282 {
13283 const FIELDS: &[&str] = &[
13284 "log_store_table",
13285 "logStoreTable",
13286 "pause_duration_ms",
13287 "pauseDurationMs",
13288 "buffer_size",
13289 "bufferSize",
13290 "aligned",
13291 ];
13292
13293 #[allow(clippy::enum_variant_names)]
13294 enum GeneratedField {
13295 LogStoreTable,
13296 PauseDurationMs,
13297 BufferSize,
13298 Aligned,
13299 }
13300 impl<'de> serde::Deserialize<'de> for GeneratedField {
13301 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13302 where
13303 D: serde::Deserializer<'de>,
13304 {
13305 struct GeneratedVisitor;
13306
13307 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13308 type Value = GeneratedField;
13309
13310 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13311 write!(formatter, "expected one of: {:?}", &FIELDS)
13312 }
13313
13314 #[allow(unused_variables)]
13315 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13316 where
13317 E: serde::de::Error,
13318 {
13319 match value {
13320 "logStoreTable" | "log_store_table" => Ok(GeneratedField::LogStoreTable),
13321 "pauseDurationMs" | "pause_duration_ms" => Ok(GeneratedField::PauseDurationMs),
13322 "bufferSize" | "buffer_size" => Ok(GeneratedField::BufferSize),
13323 "aligned" => Ok(GeneratedField::Aligned),
13324 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13325 }
13326 }
13327 }
13328 deserializer.deserialize_identifier(GeneratedVisitor)
13329 }
13330 }
13331 struct GeneratedVisitor;
13332 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13333 type Value = SyncLogStoreNode;
13334
13335 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13336 formatter.write_str("struct stream_plan.SyncLogStoreNode")
13337 }
13338
13339 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SyncLogStoreNode, V::Error>
13340 where
13341 V: serde::de::MapAccess<'de>,
13342 {
13343 let mut log_store_table__ = None;
13344 let mut pause_duration_ms__ = None;
13345 let mut buffer_size__ = None;
13346 let mut aligned__ = None;
13347 while let Some(k) = map_.next_key()? {
13348 match k {
13349 GeneratedField::LogStoreTable => {
13350 if log_store_table__.is_some() {
13351 return Err(serde::de::Error::duplicate_field("logStoreTable"));
13352 }
13353 log_store_table__ = map_.next_value()?;
13354 }
13355 GeneratedField::PauseDurationMs => {
13356 if pause_duration_ms__.is_some() {
13357 return Err(serde::de::Error::duplicate_field("pauseDurationMs"));
13358 }
13359 pause_duration_ms__ =
13360 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13361 ;
13362 }
13363 GeneratedField::BufferSize => {
13364 if buffer_size__.is_some() {
13365 return Err(serde::de::Error::duplicate_field("bufferSize"));
13366 }
13367 buffer_size__ =
13368 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13369 ;
13370 }
13371 GeneratedField::Aligned => {
13372 if aligned__.is_some() {
13373 return Err(serde::de::Error::duplicate_field("aligned"));
13374 }
13375 aligned__ = Some(map_.next_value()?);
13376 }
13377 }
13378 }
13379 Ok(SyncLogStoreNode {
13380 log_store_table: log_store_table__,
13381 pause_duration_ms: pause_duration_ms__.unwrap_or_default(),
13382 buffer_size: buffer_size__.unwrap_or_default(),
13383 aligned: aligned__.unwrap_or_default(),
13384 })
13385 }
13386 }
13387 deserializer.deserialize_struct("stream_plan.SyncLogStoreNode", FIELDS, GeneratedVisitor)
13388 }
13389}
13390impl serde::Serialize for TemporalJoinNode {
13391 #[allow(deprecated)]
13392 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13393 where
13394 S: serde::Serializer,
13395 {
13396 use serde::ser::SerializeStruct;
13397 let mut len = 0;
13398 if self.join_type != 0 {
13399 len += 1;
13400 }
13401 if !self.left_key.is_empty() {
13402 len += 1;
13403 }
13404 if !self.right_key.is_empty() {
13405 len += 1;
13406 }
13407 if !self.null_safe.is_empty() {
13408 len += 1;
13409 }
13410 if self.condition.is_some() {
13411 len += 1;
13412 }
13413 if !self.output_indices.is_empty() {
13414 len += 1;
13415 }
13416 if self.table_desc.is_some() {
13417 len += 1;
13418 }
13419 if !self.table_output_indices.is_empty() {
13420 len += 1;
13421 }
13422 if self.memo_table.is_some() {
13423 len += 1;
13424 }
13425 if self.is_nested_loop {
13426 len += 1;
13427 }
13428 let mut struct_ser = serializer.serialize_struct("stream_plan.TemporalJoinNode", len)?;
13429 if self.join_type != 0 {
13430 let v = super::plan_common::JoinType::try_from(self.join_type)
13431 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
13432 struct_ser.serialize_field("joinType", &v)?;
13433 }
13434 if !self.left_key.is_empty() {
13435 struct_ser.serialize_field("leftKey", &self.left_key)?;
13436 }
13437 if !self.right_key.is_empty() {
13438 struct_ser.serialize_field("rightKey", &self.right_key)?;
13439 }
13440 if !self.null_safe.is_empty() {
13441 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
13442 }
13443 if let Some(v) = self.condition.as_ref() {
13444 struct_ser.serialize_field("condition", v)?;
13445 }
13446 if !self.output_indices.is_empty() {
13447 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
13448 }
13449 if let Some(v) = self.table_desc.as_ref() {
13450 struct_ser.serialize_field("tableDesc", v)?;
13451 }
13452 if !self.table_output_indices.is_empty() {
13453 struct_ser.serialize_field("tableOutputIndices", &self.table_output_indices)?;
13454 }
13455 if let Some(v) = self.memo_table.as_ref() {
13456 struct_ser.serialize_field("memoTable", v)?;
13457 }
13458 if self.is_nested_loop {
13459 struct_ser.serialize_field("isNestedLoop", &self.is_nested_loop)?;
13460 }
13461 struct_ser.end()
13462 }
13463}
13464impl<'de> serde::Deserialize<'de> for TemporalJoinNode {
13465 #[allow(deprecated)]
13466 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13467 where
13468 D: serde::Deserializer<'de>,
13469 {
13470 const FIELDS: &[&str] = &[
13471 "join_type",
13472 "joinType",
13473 "left_key",
13474 "leftKey",
13475 "right_key",
13476 "rightKey",
13477 "null_safe",
13478 "nullSafe",
13479 "condition",
13480 "output_indices",
13481 "outputIndices",
13482 "table_desc",
13483 "tableDesc",
13484 "table_output_indices",
13485 "tableOutputIndices",
13486 "memo_table",
13487 "memoTable",
13488 "is_nested_loop",
13489 "isNestedLoop",
13490 ];
13491
13492 #[allow(clippy::enum_variant_names)]
13493 enum GeneratedField {
13494 JoinType,
13495 LeftKey,
13496 RightKey,
13497 NullSafe,
13498 Condition,
13499 OutputIndices,
13500 TableDesc,
13501 TableOutputIndices,
13502 MemoTable,
13503 IsNestedLoop,
13504 }
13505 impl<'de> serde::Deserialize<'de> for GeneratedField {
13506 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13507 where
13508 D: serde::Deserializer<'de>,
13509 {
13510 struct GeneratedVisitor;
13511
13512 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13513 type Value = GeneratedField;
13514
13515 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13516 write!(formatter, "expected one of: {:?}", &FIELDS)
13517 }
13518
13519 #[allow(unused_variables)]
13520 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13521 where
13522 E: serde::de::Error,
13523 {
13524 match value {
13525 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
13526 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
13527 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
13528 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
13529 "condition" => Ok(GeneratedField::Condition),
13530 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
13531 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
13532 "tableOutputIndices" | "table_output_indices" => Ok(GeneratedField::TableOutputIndices),
13533 "memoTable" | "memo_table" => Ok(GeneratedField::MemoTable),
13534 "isNestedLoop" | "is_nested_loop" => Ok(GeneratedField::IsNestedLoop),
13535 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13536 }
13537 }
13538 }
13539 deserializer.deserialize_identifier(GeneratedVisitor)
13540 }
13541 }
13542 struct GeneratedVisitor;
13543 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13544 type Value = TemporalJoinNode;
13545
13546 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13547 formatter.write_str("struct stream_plan.TemporalJoinNode")
13548 }
13549
13550 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TemporalJoinNode, V::Error>
13551 where
13552 V: serde::de::MapAccess<'de>,
13553 {
13554 let mut join_type__ = None;
13555 let mut left_key__ = None;
13556 let mut right_key__ = None;
13557 let mut null_safe__ = None;
13558 let mut condition__ = None;
13559 let mut output_indices__ = None;
13560 let mut table_desc__ = None;
13561 let mut table_output_indices__ = None;
13562 let mut memo_table__ = None;
13563 let mut is_nested_loop__ = None;
13564 while let Some(k) = map_.next_key()? {
13565 match k {
13566 GeneratedField::JoinType => {
13567 if join_type__.is_some() {
13568 return Err(serde::de::Error::duplicate_field("joinType"));
13569 }
13570 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
13571 }
13572 GeneratedField::LeftKey => {
13573 if left_key__.is_some() {
13574 return Err(serde::de::Error::duplicate_field("leftKey"));
13575 }
13576 left_key__ =
13577 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13578 .into_iter().map(|x| x.0).collect())
13579 ;
13580 }
13581 GeneratedField::RightKey => {
13582 if right_key__.is_some() {
13583 return Err(serde::de::Error::duplicate_field("rightKey"));
13584 }
13585 right_key__ =
13586 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13587 .into_iter().map(|x| x.0).collect())
13588 ;
13589 }
13590 GeneratedField::NullSafe => {
13591 if null_safe__.is_some() {
13592 return Err(serde::de::Error::duplicate_field("nullSafe"));
13593 }
13594 null_safe__ = Some(map_.next_value()?);
13595 }
13596 GeneratedField::Condition => {
13597 if condition__.is_some() {
13598 return Err(serde::de::Error::duplicate_field("condition"));
13599 }
13600 condition__ = map_.next_value()?;
13601 }
13602 GeneratedField::OutputIndices => {
13603 if output_indices__.is_some() {
13604 return Err(serde::de::Error::duplicate_field("outputIndices"));
13605 }
13606 output_indices__ =
13607 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13608 .into_iter().map(|x| x.0).collect())
13609 ;
13610 }
13611 GeneratedField::TableDesc => {
13612 if table_desc__.is_some() {
13613 return Err(serde::de::Error::duplicate_field("tableDesc"));
13614 }
13615 table_desc__ = map_.next_value()?;
13616 }
13617 GeneratedField::TableOutputIndices => {
13618 if table_output_indices__.is_some() {
13619 return Err(serde::de::Error::duplicate_field("tableOutputIndices"));
13620 }
13621 table_output_indices__ =
13622 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13623 .into_iter().map(|x| x.0).collect())
13624 ;
13625 }
13626 GeneratedField::MemoTable => {
13627 if memo_table__.is_some() {
13628 return Err(serde::de::Error::duplicate_field("memoTable"));
13629 }
13630 memo_table__ = map_.next_value()?;
13631 }
13632 GeneratedField::IsNestedLoop => {
13633 if is_nested_loop__.is_some() {
13634 return Err(serde::de::Error::duplicate_field("isNestedLoop"));
13635 }
13636 is_nested_loop__ = Some(map_.next_value()?);
13637 }
13638 }
13639 }
13640 Ok(TemporalJoinNode {
13641 join_type: join_type__.unwrap_or_default(),
13642 left_key: left_key__.unwrap_or_default(),
13643 right_key: right_key__.unwrap_or_default(),
13644 null_safe: null_safe__.unwrap_or_default(),
13645 condition: condition__,
13646 output_indices: output_indices__.unwrap_or_default(),
13647 table_desc: table_desc__,
13648 table_output_indices: table_output_indices__.unwrap_or_default(),
13649 memo_table: memo_table__,
13650 is_nested_loop: is_nested_loop__.unwrap_or_default(),
13651 })
13652 }
13653 }
13654 deserializer.deserialize_struct("stream_plan.TemporalJoinNode", FIELDS, GeneratedVisitor)
13655 }
13656}
13657impl serde::Serialize for ThrottleMutation {
13658 #[allow(deprecated)]
13659 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13660 where
13661 S: serde::Serializer,
13662 {
13663 use serde::ser::SerializeStruct;
13664 let mut len = 0;
13665 if !self.actor_throttle.is_empty() {
13666 len += 1;
13667 }
13668 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation", len)?;
13669 if !self.actor_throttle.is_empty() {
13670 struct_ser.serialize_field("actorThrottle", &self.actor_throttle)?;
13671 }
13672 struct_ser.end()
13673 }
13674}
13675impl<'de> serde::Deserialize<'de> for ThrottleMutation {
13676 #[allow(deprecated)]
13677 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13678 where
13679 D: serde::Deserializer<'de>,
13680 {
13681 const FIELDS: &[&str] = &[
13682 "actor_throttle",
13683 "actorThrottle",
13684 ];
13685
13686 #[allow(clippy::enum_variant_names)]
13687 enum GeneratedField {
13688 ActorThrottle,
13689 }
13690 impl<'de> serde::Deserialize<'de> for GeneratedField {
13691 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13692 where
13693 D: serde::Deserializer<'de>,
13694 {
13695 struct GeneratedVisitor;
13696
13697 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13698 type Value = GeneratedField;
13699
13700 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13701 write!(formatter, "expected one of: {:?}", &FIELDS)
13702 }
13703
13704 #[allow(unused_variables)]
13705 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13706 where
13707 E: serde::de::Error,
13708 {
13709 match value {
13710 "actorThrottle" | "actor_throttle" => Ok(GeneratedField::ActorThrottle),
13711 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13712 }
13713 }
13714 }
13715 deserializer.deserialize_identifier(GeneratedVisitor)
13716 }
13717 }
13718 struct GeneratedVisitor;
13719 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13720 type Value = ThrottleMutation;
13721
13722 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13723 formatter.write_str("struct stream_plan.ThrottleMutation")
13724 }
13725
13726 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ThrottleMutation, V::Error>
13727 where
13728 V: serde::de::MapAccess<'de>,
13729 {
13730 let mut actor_throttle__ = None;
13731 while let Some(k) = map_.next_key()? {
13732 match k {
13733 GeneratedField::ActorThrottle => {
13734 if actor_throttle__.is_some() {
13735 return Err(serde::de::Error::duplicate_field("actorThrottle"));
13736 }
13737 actor_throttle__ = Some(
13738 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
13739 .into_iter().map(|(k,v)| (k.0, v)).collect()
13740 );
13741 }
13742 }
13743 }
13744 Ok(ThrottleMutation {
13745 actor_throttle: actor_throttle__.unwrap_or_default(),
13746 })
13747 }
13748 }
13749 deserializer.deserialize_struct("stream_plan.ThrottleMutation", FIELDS, GeneratedVisitor)
13750 }
13751}
13752impl serde::Serialize for throttle_mutation::RateLimit {
13753 #[allow(deprecated)]
13754 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13755 where
13756 S: serde::Serializer,
13757 {
13758 use serde::ser::SerializeStruct;
13759 let mut len = 0;
13760 if self.rate_limit.is_some() {
13761 len += 1;
13762 }
13763 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation.RateLimit", len)?;
13764 if let Some(v) = self.rate_limit.as_ref() {
13765 struct_ser.serialize_field("rateLimit", v)?;
13766 }
13767 struct_ser.end()
13768 }
13769}
13770impl<'de> serde::Deserialize<'de> for throttle_mutation::RateLimit {
13771 #[allow(deprecated)]
13772 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13773 where
13774 D: serde::Deserializer<'de>,
13775 {
13776 const FIELDS: &[&str] = &[
13777 "rate_limit",
13778 "rateLimit",
13779 ];
13780
13781 #[allow(clippy::enum_variant_names)]
13782 enum GeneratedField {
13783 RateLimit,
13784 }
13785 impl<'de> serde::Deserialize<'de> for GeneratedField {
13786 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13787 where
13788 D: serde::Deserializer<'de>,
13789 {
13790 struct GeneratedVisitor;
13791
13792 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13793 type Value = GeneratedField;
13794
13795 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13796 write!(formatter, "expected one of: {:?}", &FIELDS)
13797 }
13798
13799 #[allow(unused_variables)]
13800 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13801 where
13802 E: serde::de::Error,
13803 {
13804 match value {
13805 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
13806 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13807 }
13808 }
13809 }
13810 deserializer.deserialize_identifier(GeneratedVisitor)
13811 }
13812 }
13813 struct GeneratedVisitor;
13814 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13815 type Value = throttle_mutation::RateLimit;
13816
13817 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13818 formatter.write_str("struct stream_plan.ThrottleMutation.RateLimit")
13819 }
13820
13821 fn visit_map<V>(self, mut map_: V) -> std::result::Result<throttle_mutation::RateLimit, V::Error>
13822 where
13823 V: serde::de::MapAccess<'de>,
13824 {
13825 let mut rate_limit__ = None;
13826 while let Some(k) = map_.next_key()? {
13827 match k {
13828 GeneratedField::RateLimit => {
13829 if rate_limit__.is_some() {
13830 return Err(serde::de::Error::duplicate_field("rateLimit"));
13831 }
13832 rate_limit__ =
13833 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13834 ;
13835 }
13836 }
13837 }
13838 Ok(throttle_mutation::RateLimit {
13839 rate_limit: rate_limit__,
13840 })
13841 }
13842 }
13843 deserializer.deserialize_struct("stream_plan.ThrottleMutation.RateLimit", FIELDS, GeneratedVisitor)
13844 }
13845}
13846impl serde::Serialize for TopNNode {
13847 #[allow(deprecated)]
13848 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13849 where
13850 S: serde::Serializer,
13851 {
13852 use serde::ser::SerializeStruct;
13853 let mut len = 0;
13854 if self.limit != 0 {
13855 len += 1;
13856 }
13857 if self.offset != 0 {
13858 len += 1;
13859 }
13860 if self.table.is_some() {
13861 len += 1;
13862 }
13863 if !self.order_by.is_empty() {
13864 len += 1;
13865 }
13866 if self.with_ties {
13867 len += 1;
13868 }
13869 let mut struct_ser = serializer.serialize_struct("stream_plan.TopNNode", len)?;
13870 if self.limit != 0 {
13871 #[allow(clippy::needless_borrow)]
13872 #[allow(clippy::needless_borrows_for_generic_args)]
13873 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
13874 }
13875 if self.offset != 0 {
13876 #[allow(clippy::needless_borrow)]
13877 #[allow(clippy::needless_borrows_for_generic_args)]
13878 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
13879 }
13880 if let Some(v) = self.table.as_ref() {
13881 struct_ser.serialize_field("table", v)?;
13882 }
13883 if !self.order_by.is_empty() {
13884 struct_ser.serialize_field("orderBy", &self.order_by)?;
13885 }
13886 if self.with_ties {
13887 struct_ser.serialize_field("withTies", &self.with_ties)?;
13888 }
13889 struct_ser.end()
13890 }
13891}
13892impl<'de> serde::Deserialize<'de> for TopNNode {
13893 #[allow(deprecated)]
13894 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13895 where
13896 D: serde::Deserializer<'de>,
13897 {
13898 const FIELDS: &[&str] = &[
13899 "limit",
13900 "offset",
13901 "table",
13902 "order_by",
13903 "orderBy",
13904 "with_ties",
13905 "withTies",
13906 ];
13907
13908 #[allow(clippy::enum_variant_names)]
13909 enum GeneratedField {
13910 Limit,
13911 Offset,
13912 Table,
13913 OrderBy,
13914 WithTies,
13915 }
13916 impl<'de> serde::Deserialize<'de> for GeneratedField {
13917 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13918 where
13919 D: serde::Deserializer<'de>,
13920 {
13921 struct GeneratedVisitor;
13922
13923 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13924 type Value = GeneratedField;
13925
13926 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13927 write!(formatter, "expected one of: {:?}", &FIELDS)
13928 }
13929
13930 #[allow(unused_variables)]
13931 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13932 where
13933 E: serde::de::Error,
13934 {
13935 match value {
13936 "limit" => Ok(GeneratedField::Limit),
13937 "offset" => Ok(GeneratedField::Offset),
13938 "table" => Ok(GeneratedField::Table),
13939 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
13940 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
13941 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13942 }
13943 }
13944 }
13945 deserializer.deserialize_identifier(GeneratedVisitor)
13946 }
13947 }
13948 struct GeneratedVisitor;
13949 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13950 type Value = TopNNode;
13951
13952 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13953 formatter.write_str("struct stream_plan.TopNNode")
13954 }
13955
13956 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
13957 where
13958 V: serde::de::MapAccess<'de>,
13959 {
13960 let mut limit__ = None;
13961 let mut offset__ = None;
13962 let mut table__ = None;
13963 let mut order_by__ = None;
13964 let mut with_ties__ = None;
13965 while let Some(k) = map_.next_key()? {
13966 match k {
13967 GeneratedField::Limit => {
13968 if limit__.is_some() {
13969 return Err(serde::de::Error::duplicate_field("limit"));
13970 }
13971 limit__ =
13972 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13973 ;
13974 }
13975 GeneratedField::Offset => {
13976 if offset__.is_some() {
13977 return Err(serde::de::Error::duplicate_field("offset"));
13978 }
13979 offset__ =
13980 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13981 ;
13982 }
13983 GeneratedField::Table => {
13984 if table__.is_some() {
13985 return Err(serde::de::Error::duplicate_field("table"));
13986 }
13987 table__ = map_.next_value()?;
13988 }
13989 GeneratedField::OrderBy => {
13990 if order_by__.is_some() {
13991 return Err(serde::de::Error::duplicate_field("orderBy"));
13992 }
13993 order_by__ = Some(map_.next_value()?);
13994 }
13995 GeneratedField::WithTies => {
13996 if with_ties__.is_some() {
13997 return Err(serde::de::Error::duplicate_field("withTies"));
13998 }
13999 with_ties__ = Some(map_.next_value()?);
14000 }
14001 }
14002 }
14003 Ok(TopNNode {
14004 limit: limit__.unwrap_or_default(),
14005 offset: offset__.unwrap_or_default(),
14006 table: table__,
14007 order_by: order_by__.unwrap_or_default(),
14008 with_ties: with_ties__.unwrap_or_default(),
14009 })
14010 }
14011 }
14012 deserializer.deserialize_struct("stream_plan.TopNNode", FIELDS, GeneratedVisitor)
14013 }
14014}
14015impl serde::Serialize for UnionNode {
14016 #[allow(deprecated)]
14017 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14018 where
14019 S: serde::Serializer,
14020 {
14021 use serde::ser::SerializeStruct;
14022 let len = 0;
14023 let struct_ser = serializer.serialize_struct("stream_plan.UnionNode", len)?;
14024 struct_ser.end()
14025 }
14026}
14027impl<'de> serde::Deserialize<'de> for UnionNode {
14028 #[allow(deprecated)]
14029 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14030 where
14031 D: serde::Deserializer<'de>,
14032 {
14033 const FIELDS: &[&str] = &[
14034 ];
14035
14036 #[allow(clippy::enum_variant_names)]
14037 enum GeneratedField {
14038 }
14039 impl<'de> serde::Deserialize<'de> for GeneratedField {
14040 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14041 where
14042 D: serde::Deserializer<'de>,
14043 {
14044 struct GeneratedVisitor;
14045
14046 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14047 type Value = GeneratedField;
14048
14049 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14050 write!(formatter, "expected one of: {:?}", &FIELDS)
14051 }
14052
14053 #[allow(unused_variables)]
14054 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14055 where
14056 E: serde::de::Error,
14057 {
14058 Err(serde::de::Error::unknown_field(value, FIELDS))
14059 }
14060 }
14061 deserializer.deserialize_identifier(GeneratedVisitor)
14062 }
14063 }
14064 struct GeneratedVisitor;
14065 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14066 type Value = UnionNode;
14067
14068 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14069 formatter.write_str("struct stream_plan.UnionNode")
14070 }
14071
14072 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
14073 where
14074 V: serde::de::MapAccess<'de>,
14075 {
14076 while map_.next_key::<GeneratedField>()?.is_some() {
14077 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14078 }
14079 Ok(UnionNode {
14080 })
14081 }
14082 }
14083 deserializer.deserialize_struct("stream_plan.UnionNode", FIELDS, GeneratedVisitor)
14084 }
14085}
14086impl serde::Serialize for UpdateMutation {
14087 #[allow(deprecated)]
14088 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14089 where
14090 S: serde::Serializer,
14091 {
14092 use serde::ser::SerializeStruct;
14093 let mut len = 0;
14094 if !self.dispatcher_update.is_empty() {
14095 len += 1;
14096 }
14097 if !self.merge_update.is_empty() {
14098 len += 1;
14099 }
14100 if !self.actor_vnode_bitmap_update.is_empty() {
14101 len += 1;
14102 }
14103 if !self.dropped_actors.is_empty() {
14104 len += 1;
14105 }
14106 if !self.actor_splits.is_empty() {
14107 len += 1;
14108 }
14109 if !self.actor_new_dispatchers.is_empty() {
14110 len += 1;
14111 }
14112 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation", len)?;
14113 if !self.dispatcher_update.is_empty() {
14114 struct_ser.serialize_field("dispatcherUpdate", &self.dispatcher_update)?;
14115 }
14116 if !self.merge_update.is_empty() {
14117 struct_ser.serialize_field("mergeUpdate", &self.merge_update)?;
14118 }
14119 if !self.actor_vnode_bitmap_update.is_empty() {
14120 struct_ser.serialize_field("actorVnodeBitmapUpdate", &self.actor_vnode_bitmap_update)?;
14121 }
14122 if !self.dropped_actors.is_empty() {
14123 struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
14124 }
14125 if !self.actor_splits.is_empty() {
14126 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
14127 }
14128 if !self.actor_new_dispatchers.is_empty() {
14129 struct_ser.serialize_field("actorNewDispatchers", &self.actor_new_dispatchers)?;
14130 }
14131 struct_ser.end()
14132 }
14133}
14134impl<'de> serde::Deserialize<'de> for UpdateMutation {
14135 #[allow(deprecated)]
14136 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14137 where
14138 D: serde::Deserializer<'de>,
14139 {
14140 const FIELDS: &[&str] = &[
14141 "dispatcher_update",
14142 "dispatcherUpdate",
14143 "merge_update",
14144 "mergeUpdate",
14145 "actor_vnode_bitmap_update",
14146 "actorVnodeBitmapUpdate",
14147 "dropped_actors",
14148 "droppedActors",
14149 "actor_splits",
14150 "actorSplits",
14151 "actor_new_dispatchers",
14152 "actorNewDispatchers",
14153 ];
14154
14155 #[allow(clippy::enum_variant_names)]
14156 enum GeneratedField {
14157 DispatcherUpdate,
14158 MergeUpdate,
14159 ActorVnodeBitmapUpdate,
14160 DroppedActors,
14161 ActorSplits,
14162 ActorNewDispatchers,
14163 }
14164 impl<'de> serde::Deserialize<'de> for GeneratedField {
14165 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14166 where
14167 D: serde::Deserializer<'de>,
14168 {
14169 struct GeneratedVisitor;
14170
14171 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14172 type Value = GeneratedField;
14173
14174 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14175 write!(formatter, "expected one of: {:?}", &FIELDS)
14176 }
14177
14178 #[allow(unused_variables)]
14179 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14180 where
14181 E: serde::de::Error,
14182 {
14183 match value {
14184 "dispatcherUpdate" | "dispatcher_update" => Ok(GeneratedField::DispatcherUpdate),
14185 "mergeUpdate" | "merge_update" => Ok(GeneratedField::MergeUpdate),
14186 "actorVnodeBitmapUpdate" | "actor_vnode_bitmap_update" => Ok(GeneratedField::ActorVnodeBitmapUpdate),
14187 "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
14188 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
14189 "actorNewDispatchers" | "actor_new_dispatchers" => Ok(GeneratedField::ActorNewDispatchers),
14190 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14191 }
14192 }
14193 }
14194 deserializer.deserialize_identifier(GeneratedVisitor)
14195 }
14196 }
14197 struct GeneratedVisitor;
14198 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14199 type Value = UpdateMutation;
14200
14201 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14202 formatter.write_str("struct stream_plan.UpdateMutation")
14203 }
14204
14205 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateMutation, V::Error>
14206 where
14207 V: serde::de::MapAccess<'de>,
14208 {
14209 let mut dispatcher_update__ = None;
14210 let mut merge_update__ = None;
14211 let mut actor_vnode_bitmap_update__ = None;
14212 let mut dropped_actors__ = None;
14213 let mut actor_splits__ = None;
14214 let mut actor_new_dispatchers__ = None;
14215 while let Some(k) = map_.next_key()? {
14216 match k {
14217 GeneratedField::DispatcherUpdate => {
14218 if dispatcher_update__.is_some() {
14219 return Err(serde::de::Error::duplicate_field("dispatcherUpdate"));
14220 }
14221 dispatcher_update__ = Some(map_.next_value()?);
14222 }
14223 GeneratedField::MergeUpdate => {
14224 if merge_update__.is_some() {
14225 return Err(serde::de::Error::duplicate_field("mergeUpdate"));
14226 }
14227 merge_update__ = Some(map_.next_value()?);
14228 }
14229 GeneratedField::ActorVnodeBitmapUpdate => {
14230 if actor_vnode_bitmap_update__.is_some() {
14231 return Err(serde::de::Error::duplicate_field("actorVnodeBitmapUpdate"));
14232 }
14233 actor_vnode_bitmap_update__ = Some(
14234 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14235 .into_iter().map(|(k,v)| (k.0, v)).collect()
14236 );
14237 }
14238 GeneratedField::DroppedActors => {
14239 if dropped_actors__.is_some() {
14240 return Err(serde::de::Error::duplicate_field("droppedActors"));
14241 }
14242 dropped_actors__ =
14243 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14244 .into_iter().map(|x| x.0).collect())
14245 ;
14246 }
14247 GeneratedField::ActorSplits => {
14248 if actor_splits__.is_some() {
14249 return Err(serde::de::Error::duplicate_field("actorSplits"));
14250 }
14251 actor_splits__ = Some(
14252 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14253 .into_iter().map(|(k,v)| (k.0, v)).collect()
14254 );
14255 }
14256 GeneratedField::ActorNewDispatchers => {
14257 if actor_new_dispatchers__.is_some() {
14258 return Err(serde::de::Error::duplicate_field("actorNewDispatchers"));
14259 }
14260 actor_new_dispatchers__ = Some(
14261 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14262 .into_iter().map(|(k,v)| (k.0, v)).collect()
14263 );
14264 }
14265 }
14266 }
14267 Ok(UpdateMutation {
14268 dispatcher_update: dispatcher_update__.unwrap_or_default(),
14269 merge_update: merge_update__.unwrap_or_default(),
14270 actor_vnode_bitmap_update: actor_vnode_bitmap_update__.unwrap_or_default(),
14271 dropped_actors: dropped_actors__.unwrap_or_default(),
14272 actor_splits: actor_splits__.unwrap_or_default(),
14273 actor_new_dispatchers: actor_new_dispatchers__.unwrap_or_default(),
14274 })
14275 }
14276 }
14277 deserializer.deserialize_struct("stream_plan.UpdateMutation", FIELDS, GeneratedVisitor)
14278 }
14279}
14280impl serde::Serialize for update_mutation::DispatcherUpdate {
14281 #[allow(deprecated)]
14282 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14283 where
14284 S: serde::Serializer,
14285 {
14286 use serde::ser::SerializeStruct;
14287 let mut len = 0;
14288 if self.actor_id != 0 {
14289 len += 1;
14290 }
14291 if self.dispatcher_id != 0 {
14292 len += 1;
14293 }
14294 if self.hash_mapping.is_some() {
14295 len += 1;
14296 }
14297 if !self.added_downstream_actor_id.is_empty() {
14298 len += 1;
14299 }
14300 if !self.removed_downstream_actor_id.is_empty() {
14301 len += 1;
14302 }
14303 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", len)?;
14304 if self.actor_id != 0 {
14305 struct_ser.serialize_field("actorId", &self.actor_id)?;
14306 }
14307 if self.dispatcher_id != 0 {
14308 #[allow(clippy::needless_borrow)]
14309 #[allow(clippy::needless_borrows_for_generic_args)]
14310 struct_ser.serialize_field("dispatcherId", ToString::to_string(&self.dispatcher_id).as_str())?;
14311 }
14312 if let Some(v) = self.hash_mapping.as_ref() {
14313 struct_ser.serialize_field("hashMapping", v)?;
14314 }
14315 if !self.added_downstream_actor_id.is_empty() {
14316 struct_ser.serialize_field("addedDownstreamActorId", &self.added_downstream_actor_id)?;
14317 }
14318 if !self.removed_downstream_actor_id.is_empty() {
14319 struct_ser.serialize_field("removedDownstreamActorId", &self.removed_downstream_actor_id)?;
14320 }
14321 struct_ser.end()
14322 }
14323}
14324impl<'de> serde::Deserialize<'de> for update_mutation::DispatcherUpdate {
14325 #[allow(deprecated)]
14326 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14327 where
14328 D: serde::Deserializer<'de>,
14329 {
14330 const FIELDS: &[&str] = &[
14331 "actor_id",
14332 "actorId",
14333 "dispatcher_id",
14334 "dispatcherId",
14335 "hash_mapping",
14336 "hashMapping",
14337 "added_downstream_actor_id",
14338 "addedDownstreamActorId",
14339 "removed_downstream_actor_id",
14340 "removedDownstreamActorId",
14341 ];
14342
14343 #[allow(clippy::enum_variant_names)]
14344 enum GeneratedField {
14345 ActorId,
14346 DispatcherId,
14347 HashMapping,
14348 AddedDownstreamActorId,
14349 RemovedDownstreamActorId,
14350 }
14351 impl<'de> serde::Deserialize<'de> for GeneratedField {
14352 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14353 where
14354 D: serde::Deserializer<'de>,
14355 {
14356 struct GeneratedVisitor;
14357
14358 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14359 type Value = GeneratedField;
14360
14361 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14362 write!(formatter, "expected one of: {:?}", &FIELDS)
14363 }
14364
14365 #[allow(unused_variables)]
14366 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14367 where
14368 E: serde::de::Error,
14369 {
14370 match value {
14371 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
14372 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
14373 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
14374 "addedDownstreamActorId" | "added_downstream_actor_id" => Ok(GeneratedField::AddedDownstreamActorId),
14375 "removedDownstreamActorId" | "removed_downstream_actor_id" => Ok(GeneratedField::RemovedDownstreamActorId),
14376 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14377 }
14378 }
14379 }
14380 deserializer.deserialize_identifier(GeneratedVisitor)
14381 }
14382 }
14383 struct GeneratedVisitor;
14384 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14385 type Value = update_mutation::DispatcherUpdate;
14386
14387 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14388 formatter.write_str("struct stream_plan.UpdateMutation.DispatcherUpdate")
14389 }
14390
14391 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::DispatcherUpdate, V::Error>
14392 where
14393 V: serde::de::MapAccess<'de>,
14394 {
14395 let mut actor_id__ = None;
14396 let mut dispatcher_id__ = None;
14397 let mut hash_mapping__ = None;
14398 let mut added_downstream_actor_id__ = None;
14399 let mut removed_downstream_actor_id__ = None;
14400 while let Some(k) = map_.next_key()? {
14401 match k {
14402 GeneratedField::ActorId => {
14403 if actor_id__.is_some() {
14404 return Err(serde::de::Error::duplicate_field("actorId"));
14405 }
14406 actor_id__ =
14407 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14408 ;
14409 }
14410 GeneratedField::DispatcherId => {
14411 if dispatcher_id__.is_some() {
14412 return Err(serde::de::Error::duplicate_field("dispatcherId"));
14413 }
14414 dispatcher_id__ =
14415 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14416 ;
14417 }
14418 GeneratedField::HashMapping => {
14419 if hash_mapping__.is_some() {
14420 return Err(serde::de::Error::duplicate_field("hashMapping"));
14421 }
14422 hash_mapping__ = map_.next_value()?;
14423 }
14424 GeneratedField::AddedDownstreamActorId => {
14425 if added_downstream_actor_id__.is_some() {
14426 return Err(serde::de::Error::duplicate_field("addedDownstreamActorId"));
14427 }
14428 added_downstream_actor_id__ =
14429 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14430 .into_iter().map(|x| x.0).collect())
14431 ;
14432 }
14433 GeneratedField::RemovedDownstreamActorId => {
14434 if removed_downstream_actor_id__.is_some() {
14435 return Err(serde::de::Error::duplicate_field("removedDownstreamActorId"));
14436 }
14437 removed_downstream_actor_id__ =
14438 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14439 .into_iter().map(|x| x.0).collect())
14440 ;
14441 }
14442 }
14443 }
14444 Ok(update_mutation::DispatcherUpdate {
14445 actor_id: actor_id__.unwrap_or_default(),
14446 dispatcher_id: dispatcher_id__.unwrap_or_default(),
14447 hash_mapping: hash_mapping__,
14448 added_downstream_actor_id: added_downstream_actor_id__.unwrap_or_default(),
14449 removed_downstream_actor_id: removed_downstream_actor_id__.unwrap_or_default(),
14450 })
14451 }
14452 }
14453 deserializer.deserialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", FIELDS, GeneratedVisitor)
14454 }
14455}
14456impl serde::Serialize for update_mutation::MergeUpdate {
14457 #[allow(deprecated)]
14458 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14459 where
14460 S: serde::Serializer,
14461 {
14462 use serde::ser::SerializeStruct;
14463 let mut len = 0;
14464 if self.actor_id != 0 {
14465 len += 1;
14466 }
14467 if self.upstream_fragment_id != 0 {
14468 len += 1;
14469 }
14470 if self.new_upstream_fragment_id.is_some() {
14471 len += 1;
14472 }
14473 if !self.added_upstream_actors.is_empty() {
14474 len += 1;
14475 }
14476 if !self.removed_upstream_actor_id.is_empty() {
14477 len += 1;
14478 }
14479 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.MergeUpdate", len)?;
14480 if self.actor_id != 0 {
14481 struct_ser.serialize_field("actorId", &self.actor_id)?;
14482 }
14483 if self.upstream_fragment_id != 0 {
14484 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
14485 }
14486 if let Some(v) = self.new_upstream_fragment_id.as_ref() {
14487 struct_ser.serialize_field("newUpstreamFragmentId", v)?;
14488 }
14489 if !self.added_upstream_actors.is_empty() {
14490 struct_ser.serialize_field("addedUpstreamActors", &self.added_upstream_actors)?;
14491 }
14492 if !self.removed_upstream_actor_id.is_empty() {
14493 struct_ser.serialize_field("removedUpstreamActorId", &self.removed_upstream_actor_id)?;
14494 }
14495 struct_ser.end()
14496 }
14497}
14498impl<'de> serde::Deserialize<'de> for update_mutation::MergeUpdate {
14499 #[allow(deprecated)]
14500 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14501 where
14502 D: serde::Deserializer<'de>,
14503 {
14504 const FIELDS: &[&str] = &[
14505 "actor_id",
14506 "actorId",
14507 "upstream_fragment_id",
14508 "upstreamFragmentId",
14509 "new_upstream_fragment_id",
14510 "newUpstreamFragmentId",
14511 "added_upstream_actors",
14512 "addedUpstreamActors",
14513 "removed_upstream_actor_id",
14514 "removedUpstreamActorId",
14515 ];
14516
14517 #[allow(clippy::enum_variant_names)]
14518 enum GeneratedField {
14519 ActorId,
14520 UpstreamFragmentId,
14521 NewUpstreamFragmentId,
14522 AddedUpstreamActors,
14523 RemovedUpstreamActorId,
14524 }
14525 impl<'de> serde::Deserialize<'de> for GeneratedField {
14526 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14527 where
14528 D: serde::Deserializer<'de>,
14529 {
14530 struct GeneratedVisitor;
14531
14532 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14533 type Value = GeneratedField;
14534
14535 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14536 write!(formatter, "expected one of: {:?}", &FIELDS)
14537 }
14538
14539 #[allow(unused_variables)]
14540 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14541 where
14542 E: serde::de::Error,
14543 {
14544 match value {
14545 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
14546 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
14547 "newUpstreamFragmentId" | "new_upstream_fragment_id" => Ok(GeneratedField::NewUpstreamFragmentId),
14548 "addedUpstreamActors" | "added_upstream_actors" => Ok(GeneratedField::AddedUpstreamActors),
14549 "removedUpstreamActorId" | "removed_upstream_actor_id" => Ok(GeneratedField::RemovedUpstreamActorId),
14550 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14551 }
14552 }
14553 }
14554 deserializer.deserialize_identifier(GeneratedVisitor)
14555 }
14556 }
14557 struct GeneratedVisitor;
14558 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14559 type Value = update_mutation::MergeUpdate;
14560
14561 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14562 formatter.write_str("struct stream_plan.UpdateMutation.MergeUpdate")
14563 }
14564
14565 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::MergeUpdate, V::Error>
14566 where
14567 V: serde::de::MapAccess<'de>,
14568 {
14569 let mut actor_id__ = None;
14570 let mut upstream_fragment_id__ = None;
14571 let mut new_upstream_fragment_id__ = None;
14572 let mut added_upstream_actors__ = None;
14573 let mut removed_upstream_actor_id__ = None;
14574 while let Some(k) = map_.next_key()? {
14575 match k {
14576 GeneratedField::ActorId => {
14577 if actor_id__.is_some() {
14578 return Err(serde::de::Error::duplicate_field("actorId"));
14579 }
14580 actor_id__ =
14581 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14582 ;
14583 }
14584 GeneratedField::UpstreamFragmentId => {
14585 if upstream_fragment_id__.is_some() {
14586 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
14587 }
14588 upstream_fragment_id__ =
14589 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14590 ;
14591 }
14592 GeneratedField::NewUpstreamFragmentId => {
14593 if new_upstream_fragment_id__.is_some() {
14594 return Err(serde::de::Error::duplicate_field("newUpstreamFragmentId"));
14595 }
14596 new_upstream_fragment_id__ =
14597 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14598 ;
14599 }
14600 GeneratedField::AddedUpstreamActors => {
14601 if added_upstream_actors__.is_some() {
14602 return Err(serde::de::Error::duplicate_field("addedUpstreamActors"));
14603 }
14604 added_upstream_actors__ = Some(map_.next_value()?);
14605 }
14606 GeneratedField::RemovedUpstreamActorId => {
14607 if removed_upstream_actor_id__.is_some() {
14608 return Err(serde::de::Error::duplicate_field("removedUpstreamActorId"));
14609 }
14610 removed_upstream_actor_id__ =
14611 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14612 .into_iter().map(|x| x.0).collect())
14613 ;
14614 }
14615 }
14616 }
14617 Ok(update_mutation::MergeUpdate {
14618 actor_id: actor_id__.unwrap_or_default(),
14619 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
14620 new_upstream_fragment_id: new_upstream_fragment_id__,
14621 added_upstream_actors: added_upstream_actors__.unwrap_or_default(),
14622 removed_upstream_actor_id: removed_upstream_actor_id__.unwrap_or_default(),
14623 })
14624 }
14625 }
14626 deserializer.deserialize_struct("stream_plan.UpdateMutation.MergeUpdate", FIELDS, GeneratedVisitor)
14627 }
14628}
14629impl serde::Serialize for ValuesNode {
14630 #[allow(deprecated)]
14631 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14632 where
14633 S: serde::Serializer,
14634 {
14635 use serde::ser::SerializeStruct;
14636 let mut len = 0;
14637 if !self.tuples.is_empty() {
14638 len += 1;
14639 }
14640 if !self.fields.is_empty() {
14641 len += 1;
14642 }
14643 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode", len)?;
14644 if !self.tuples.is_empty() {
14645 struct_ser.serialize_field("tuples", &self.tuples)?;
14646 }
14647 if !self.fields.is_empty() {
14648 struct_ser.serialize_field("fields", &self.fields)?;
14649 }
14650 struct_ser.end()
14651 }
14652}
14653impl<'de> serde::Deserialize<'de> for ValuesNode {
14654 #[allow(deprecated)]
14655 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14656 where
14657 D: serde::Deserializer<'de>,
14658 {
14659 const FIELDS: &[&str] = &[
14660 "tuples",
14661 "fields",
14662 ];
14663
14664 #[allow(clippy::enum_variant_names)]
14665 enum GeneratedField {
14666 Tuples,
14667 Fields,
14668 }
14669 impl<'de> serde::Deserialize<'de> for GeneratedField {
14670 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14671 where
14672 D: serde::Deserializer<'de>,
14673 {
14674 struct GeneratedVisitor;
14675
14676 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14677 type Value = GeneratedField;
14678
14679 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14680 write!(formatter, "expected one of: {:?}", &FIELDS)
14681 }
14682
14683 #[allow(unused_variables)]
14684 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14685 where
14686 E: serde::de::Error,
14687 {
14688 match value {
14689 "tuples" => Ok(GeneratedField::Tuples),
14690 "fields" => Ok(GeneratedField::Fields),
14691 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14692 }
14693 }
14694 }
14695 deserializer.deserialize_identifier(GeneratedVisitor)
14696 }
14697 }
14698 struct GeneratedVisitor;
14699 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14700 type Value = ValuesNode;
14701
14702 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14703 formatter.write_str("struct stream_plan.ValuesNode")
14704 }
14705
14706 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
14707 where
14708 V: serde::de::MapAccess<'de>,
14709 {
14710 let mut tuples__ = None;
14711 let mut fields__ = None;
14712 while let Some(k) = map_.next_key()? {
14713 match k {
14714 GeneratedField::Tuples => {
14715 if tuples__.is_some() {
14716 return Err(serde::de::Error::duplicate_field("tuples"));
14717 }
14718 tuples__ = Some(map_.next_value()?);
14719 }
14720 GeneratedField::Fields => {
14721 if fields__.is_some() {
14722 return Err(serde::de::Error::duplicate_field("fields"));
14723 }
14724 fields__ = Some(map_.next_value()?);
14725 }
14726 }
14727 }
14728 Ok(ValuesNode {
14729 tuples: tuples__.unwrap_or_default(),
14730 fields: fields__.unwrap_or_default(),
14731 })
14732 }
14733 }
14734 deserializer.deserialize_struct("stream_plan.ValuesNode", FIELDS, GeneratedVisitor)
14735 }
14736}
14737impl serde::Serialize for values_node::ExprTuple {
14738 #[allow(deprecated)]
14739 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14740 where
14741 S: serde::Serializer,
14742 {
14743 use serde::ser::SerializeStruct;
14744 let mut len = 0;
14745 if !self.cells.is_empty() {
14746 len += 1;
14747 }
14748 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode.ExprTuple", len)?;
14749 if !self.cells.is_empty() {
14750 struct_ser.serialize_field("cells", &self.cells)?;
14751 }
14752 struct_ser.end()
14753 }
14754}
14755impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
14756 #[allow(deprecated)]
14757 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14758 where
14759 D: serde::Deserializer<'de>,
14760 {
14761 const FIELDS: &[&str] = &[
14762 "cells",
14763 ];
14764
14765 #[allow(clippy::enum_variant_names)]
14766 enum GeneratedField {
14767 Cells,
14768 }
14769 impl<'de> serde::Deserialize<'de> for GeneratedField {
14770 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14771 where
14772 D: serde::Deserializer<'de>,
14773 {
14774 struct GeneratedVisitor;
14775
14776 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14777 type Value = GeneratedField;
14778
14779 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14780 write!(formatter, "expected one of: {:?}", &FIELDS)
14781 }
14782
14783 #[allow(unused_variables)]
14784 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14785 where
14786 E: serde::de::Error,
14787 {
14788 match value {
14789 "cells" => Ok(GeneratedField::Cells),
14790 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14791 }
14792 }
14793 }
14794 deserializer.deserialize_identifier(GeneratedVisitor)
14795 }
14796 }
14797 struct GeneratedVisitor;
14798 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14799 type Value = values_node::ExprTuple;
14800
14801 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14802 formatter.write_str("struct stream_plan.ValuesNode.ExprTuple")
14803 }
14804
14805 fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
14806 where
14807 V: serde::de::MapAccess<'de>,
14808 {
14809 let mut cells__ = None;
14810 while let Some(k) = map_.next_key()? {
14811 match k {
14812 GeneratedField::Cells => {
14813 if cells__.is_some() {
14814 return Err(serde::de::Error::duplicate_field("cells"));
14815 }
14816 cells__ = Some(map_.next_value()?);
14817 }
14818 }
14819 }
14820 Ok(values_node::ExprTuple {
14821 cells: cells__.unwrap_or_default(),
14822 })
14823 }
14824 }
14825 deserializer.deserialize_struct("stream_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
14826 }
14827}
14828impl serde::Serialize for Watermark {
14829 #[allow(deprecated)]
14830 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14831 where
14832 S: serde::Serializer,
14833 {
14834 use serde::ser::SerializeStruct;
14835 let mut len = 0;
14836 if self.column.is_some() {
14837 len += 1;
14838 }
14839 if self.val.is_some() {
14840 len += 1;
14841 }
14842 let mut struct_ser = serializer.serialize_struct("stream_plan.Watermark", len)?;
14843 if let Some(v) = self.column.as_ref() {
14844 struct_ser.serialize_field("column", v)?;
14845 }
14846 if let Some(v) = self.val.as_ref() {
14847 struct_ser.serialize_field("val", v)?;
14848 }
14849 struct_ser.end()
14850 }
14851}
14852impl<'de> serde::Deserialize<'de> for Watermark {
14853 #[allow(deprecated)]
14854 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14855 where
14856 D: serde::Deserializer<'de>,
14857 {
14858 const FIELDS: &[&str] = &[
14859 "column",
14860 "val",
14861 ];
14862
14863 #[allow(clippy::enum_variant_names)]
14864 enum GeneratedField {
14865 Column,
14866 Val,
14867 }
14868 impl<'de> serde::Deserialize<'de> for GeneratedField {
14869 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14870 where
14871 D: serde::Deserializer<'de>,
14872 {
14873 struct GeneratedVisitor;
14874
14875 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14876 type Value = GeneratedField;
14877
14878 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14879 write!(formatter, "expected one of: {:?}", &FIELDS)
14880 }
14881
14882 #[allow(unused_variables)]
14883 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14884 where
14885 E: serde::de::Error,
14886 {
14887 match value {
14888 "column" => Ok(GeneratedField::Column),
14889 "val" => Ok(GeneratedField::Val),
14890 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14891 }
14892 }
14893 }
14894 deserializer.deserialize_identifier(GeneratedVisitor)
14895 }
14896 }
14897 struct GeneratedVisitor;
14898 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14899 type Value = Watermark;
14900
14901 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14902 formatter.write_str("struct stream_plan.Watermark")
14903 }
14904
14905 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Watermark, V::Error>
14906 where
14907 V: serde::de::MapAccess<'de>,
14908 {
14909 let mut column__ = None;
14910 let mut val__ = None;
14911 while let Some(k) = map_.next_key()? {
14912 match k {
14913 GeneratedField::Column => {
14914 if column__.is_some() {
14915 return Err(serde::de::Error::duplicate_field("column"));
14916 }
14917 column__ = map_.next_value()?;
14918 }
14919 GeneratedField::Val => {
14920 if val__.is_some() {
14921 return Err(serde::de::Error::duplicate_field("val"));
14922 }
14923 val__ = map_.next_value()?;
14924 }
14925 }
14926 }
14927 Ok(Watermark {
14928 column: column__,
14929 val: val__,
14930 })
14931 }
14932 }
14933 deserializer.deserialize_struct("stream_plan.Watermark", FIELDS, GeneratedVisitor)
14934 }
14935}
14936impl serde::Serialize for WatermarkFilterNode {
14937 #[allow(deprecated)]
14938 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14939 where
14940 S: serde::Serializer,
14941 {
14942 use serde::ser::SerializeStruct;
14943 let mut len = 0;
14944 if !self.watermark_descs.is_empty() {
14945 len += 1;
14946 }
14947 if !self.tables.is_empty() {
14948 len += 1;
14949 }
14950 let mut struct_ser = serializer.serialize_struct("stream_plan.WatermarkFilterNode", len)?;
14951 if !self.watermark_descs.is_empty() {
14952 struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
14953 }
14954 if !self.tables.is_empty() {
14955 struct_ser.serialize_field("tables", &self.tables)?;
14956 }
14957 struct_ser.end()
14958 }
14959}
14960impl<'de> serde::Deserialize<'de> for WatermarkFilterNode {
14961 #[allow(deprecated)]
14962 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14963 where
14964 D: serde::Deserializer<'de>,
14965 {
14966 const FIELDS: &[&str] = &[
14967 "watermark_descs",
14968 "watermarkDescs",
14969 "tables",
14970 ];
14971
14972 #[allow(clippy::enum_variant_names)]
14973 enum GeneratedField {
14974 WatermarkDescs,
14975 Tables,
14976 }
14977 impl<'de> serde::Deserialize<'de> for GeneratedField {
14978 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14979 where
14980 D: serde::Deserializer<'de>,
14981 {
14982 struct GeneratedVisitor;
14983
14984 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14985 type Value = GeneratedField;
14986
14987 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14988 write!(formatter, "expected one of: {:?}", &FIELDS)
14989 }
14990
14991 #[allow(unused_variables)]
14992 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14993 where
14994 E: serde::de::Error,
14995 {
14996 match value {
14997 "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
14998 "tables" => Ok(GeneratedField::Tables),
14999 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15000 }
15001 }
15002 }
15003 deserializer.deserialize_identifier(GeneratedVisitor)
15004 }
15005 }
15006 struct GeneratedVisitor;
15007 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15008 type Value = WatermarkFilterNode;
15009
15010 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15011 formatter.write_str("struct stream_plan.WatermarkFilterNode")
15012 }
15013
15014 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkFilterNode, V::Error>
15015 where
15016 V: serde::de::MapAccess<'de>,
15017 {
15018 let mut watermark_descs__ = None;
15019 let mut tables__ = None;
15020 while let Some(k) = map_.next_key()? {
15021 match k {
15022 GeneratedField::WatermarkDescs => {
15023 if watermark_descs__.is_some() {
15024 return Err(serde::de::Error::duplicate_field("watermarkDescs"));
15025 }
15026 watermark_descs__ = Some(map_.next_value()?);
15027 }
15028 GeneratedField::Tables => {
15029 if tables__.is_some() {
15030 return Err(serde::de::Error::duplicate_field("tables"));
15031 }
15032 tables__ = Some(map_.next_value()?);
15033 }
15034 }
15035 }
15036 Ok(WatermarkFilterNode {
15037 watermark_descs: watermark_descs__.unwrap_or_default(),
15038 tables: tables__.unwrap_or_default(),
15039 })
15040 }
15041 }
15042 deserializer.deserialize_struct("stream_plan.WatermarkFilterNode", FIELDS, GeneratedVisitor)
15043 }
15044}