1#![allow(clippy::useless_conversion)]
2use crate::stream_plan::*;
3impl serde::Serialize for ActorMapping {
4 #[allow(deprecated)]
5 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6 where
7 S: serde::Serializer,
8 {
9 use serde::ser::SerializeStruct;
10 let mut len = 0;
11 if !self.original_indices.is_empty() {
12 len += 1;
13 }
14 if !self.data.is_empty() {
15 len += 1;
16 }
17 let mut struct_ser = serializer.serialize_struct("stream_plan.ActorMapping", len)?;
18 if !self.original_indices.is_empty() {
19 struct_ser.serialize_field("originalIndices", &self.original_indices)?;
20 }
21 if !self.data.is_empty() {
22 struct_ser.serialize_field("data", &self.data)?;
23 }
24 struct_ser.end()
25 }
26}
27impl<'de> serde::Deserialize<'de> for ActorMapping {
28 #[allow(deprecated)]
29 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
30 where
31 D: serde::Deserializer<'de>,
32 {
33 const FIELDS: &[&str] = &[
34 "original_indices",
35 "originalIndices",
36 "data",
37 ];
38
39 #[allow(clippy::enum_variant_names)]
40 enum GeneratedField {
41 OriginalIndices,
42 Data,
43 }
44 impl<'de> serde::Deserialize<'de> for GeneratedField {
45 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
46 where
47 D: serde::Deserializer<'de>,
48 {
49 struct GeneratedVisitor;
50
51 impl serde::de::Visitor<'_> for GeneratedVisitor {
52 type Value = GeneratedField;
53
54 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
55 write!(formatter, "expected one of: {:?}", &FIELDS)
56 }
57
58 #[allow(unused_variables)]
59 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
60 where
61 E: serde::de::Error,
62 {
63 match value {
64 "originalIndices" | "original_indices" => Ok(GeneratedField::OriginalIndices),
65 "data" => Ok(GeneratedField::Data),
66 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
67 }
68 }
69 }
70 deserializer.deserialize_identifier(GeneratedVisitor)
71 }
72 }
73 struct GeneratedVisitor;
74 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
75 type Value = ActorMapping;
76
77 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
78 formatter.write_str("struct stream_plan.ActorMapping")
79 }
80
81 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorMapping, V::Error>
82 where
83 V: serde::de::MapAccess<'de>,
84 {
85 let mut original_indices__ = None;
86 let mut data__ = None;
87 while let Some(k) = map_.next_key()? {
88 match k {
89 GeneratedField::OriginalIndices => {
90 if original_indices__.is_some() {
91 return Err(serde::de::Error::duplicate_field("originalIndices"));
92 }
93 original_indices__ =
94 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
95 .into_iter().map(|x| x.0).collect())
96 ;
97 }
98 GeneratedField::Data => {
99 if data__.is_some() {
100 return Err(serde::de::Error::duplicate_field("data"));
101 }
102 data__ =
103 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
104 .into_iter().map(|x| x.0).collect())
105 ;
106 }
107 }
108 }
109 Ok(ActorMapping {
110 original_indices: original_indices__.unwrap_or_default(),
111 data: data__.unwrap_or_default(),
112 })
113 }
114 }
115 deserializer.deserialize_struct("stream_plan.ActorMapping", FIELDS, GeneratedVisitor)
116 }
117}
118impl serde::Serialize for AddMutation {
119 #[allow(deprecated)]
120 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
121 where
122 S: serde::Serializer,
123 {
124 use serde::ser::SerializeStruct;
125 let mut len = 0;
126 if !self.actor_dispatchers.is_empty() {
127 len += 1;
128 }
129 if !self.added_actors.is_empty() {
130 len += 1;
131 }
132 if !self.actor_splits.is_empty() {
133 len += 1;
134 }
135 if self.pause {
136 len += 1;
137 }
138 if !self.subscriptions_to_add.is_empty() {
139 len += 1;
140 }
141 if !self.backfill_nodes_to_pause.is_empty() {
142 len += 1;
143 }
144 if self.actor_cdc_table_snapshot_splits.is_some() {
145 len += 1;
146 }
147 if !self.new_upstream_sinks.is_empty() {
148 len += 1;
149 }
150 let mut struct_ser = serializer.serialize_struct("stream_plan.AddMutation", len)?;
151 if !self.actor_dispatchers.is_empty() {
152 struct_ser.serialize_field("actorDispatchers", &self.actor_dispatchers)?;
153 }
154 if !self.added_actors.is_empty() {
155 struct_ser.serialize_field("addedActors", &self.added_actors)?;
156 }
157 if !self.actor_splits.is_empty() {
158 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
159 }
160 if self.pause {
161 struct_ser.serialize_field("pause", &self.pause)?;
162 }
163 if !self.subscriptions_to_add.is_empty() {
164 struct_ser.serialize_field("subscriptionsToAdd", &self.subscriptions_to_add)?;
165 }
166 if !self.backfill_nodes_to_pause.is_empty() {
167 struct_ser.serialize_field("backfillNodesToPause", &self.backfill_nodes_to_pause)?;
168 }
169 if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
170 struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
171 }
172 if !self.new_upstream_sinks.is_empty() {
173 struct_ser.serialize_field("newUpstreamSinks", &self.new_upstream_sinks)?;
174 }
175 struct_ser.end()
176 }
177}
178impl<'de> serde::Deserialize<'de> for AddMutation {
179 #[allow(deprecated)]
180 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
181 where
182 D: serde::Deserializer<'de>,
183 {
184 const FIELDS: &[&str] = &[
185 "actor_dispatchers",
186 "actorDispatchers",
187 "added_actors",
188 "addedActors",
189 "actor_splits",
190 "actorSplits",
191 "pause",
192 "subscriptions_to_add",
193 "subscriptionsToAdd",
194 "backfill_nodes_to_pause",
195 "backfillNodesToPause",
196 "actor_cdc_table_snapshot_splits",
197 "actorCdcTableSnapshotSplits",
198 "new_upstream_sinks",
199 "newUpstreamSinks",
200 ];
201
202 #[allow(clippy::enum_variant_names)]
203 enum GeneratedField {
204 ActorDispatchers,
205 AddedActors,
206 ActorSplits,
207 Pause,
208 SubscriptionsToAdd,
209 BackfillNodesToPause,
210 ActorCdcTableSnapshotSplits,
211 NewUpstreamSinks,
212 }
213 impl<'de> serde::Deserialize<'de> for GeneratedField {
214 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
215 where
216 D: serde::Deserializer<'de>,
217 {
218 struct GeneratedVisitor;
219
220 impl serde::de::Visitor<'_> for GeneratedVisitor {
221 type Value = GeneratedField;
222
223 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
224 write!(formatter, "expected one of: {:?}", &FIELDS)
225 }
226
227 #[allow(unused_variables)]
228 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
229 where
230 E: serde::de::Error,
231 {
232 match value {
233 "actorDispatchers" | "actor_dispatchers" => Ok(GeneratedField::ActorDispatchers),
234 "addedActors" | "added_actors" => Ok(GeneratedField::AddedActors),
235 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
236 "pause" => Ok(GeneratedField::Pause),
237 "subscriptionsToAdd" | "subscriptions_to_add" => Ok(GeneratedField::SubscriptionsToAdd),
238 "backfillNodesToPause" | "backfill_nodes_to_pause" => Ok(GeneratedField::BackfillNodesToPause),
239 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
240 "newUpstreamSinks" | "new_upstream_sinks" => Ok(GeneratedField::NewUpstreamSinks),
241 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
242 }
243 }
244 }
245 deserializer.deserialize_identifier(GeneratedVisitor)
246 }
247 }
248 struct GeneratedVisitor;
249 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
250 type Value = AddMutation;
251
252 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
253 formatter.write_str("struct stream_plan.AddMutation")
254 }
255
256 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddMutation, V::Error>
257 where
258 V: serde::de::MapAccess<'de>,
259 {
260 let mut actor_dispatchers__ = None;
261 let mut added_actors__ = None;
262 let mut actor_splits__ = None;
263 let mut pause__ = None;
264 let mut subscriptions_to_add__ = None;
265 let mut backfill_nodes_to_pause__ = None;
266 let mut actor_cdc_table_snapshot_splits__ = None;
267 let mut new_upstream_sinks__ = None;
268 while let Some(k) = map_.next_key()? {
269 match k {
270 GeneratedField::ActorDispatchers => {
271 if actor_dispatchers__.is_some() {
272 return Err(serde::de::Error::duplicate_field("actorDispatchers"));
273 }
274 actor_dispatchers__ = Some(
275 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
276 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
277 );
278 }
279 GeneratedField::AddedActors => {
280 if added_actors__.is_some() {
281 return Err(serde::de::Error::duplicate_field("addedActors"));
282 }
283 added_actors__ =
284 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
285 .into_iter().map(|x| x.0).collect())
286 ;
287 }
288 GeneratedField::ActorSplits => {
289 if actor_splits__.is_some() {
290 return Err(serde::de::Error::duplicate_field("actorSplits"));
291 }
292 actor_splits__ = Some(
293 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
294 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
295 );
296 }
297 GeneratedField::Pause => {
298 if pause__.is_some() {
299 return Err(serde::de::Error::duplicate_field("pause"));
300 }
301 pause__ = Some(map_.next_value()?);
302 }
303 GeneratedField::SubscriptionsToAdd => {
304 if subscriptions_to_add__.is_some() {
305 return Err(serde::de::Error::duplicate_field("subscriptionsToAdd"));
306 }
307 subscriptions_to_add__ = Some(map_.next_value()?);
308 }
309 GeneratedField::BackfillNodesToPause => {
310 if backfill_nodes_to_pause__.is_some() {
311 return Err(serde::de::Error::duplicate_field("backfillNodesToPause"));
312 }
313 backfill_nodes_to_pause__ =
314 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
315 .into_iter().map(|x| x.0).collect())
316 ;
317 }
318 GeneratedField::ActorCdcTableSnapshotSplits => {
319 if actor_cdc_table_snapshot_splits__.is_some() {
320 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
321 }
322 actor_cdc_table_snapshot_splits__ = map_.next_value()?;
323 }
324 GeneratedField::NewUpstreamSinks => {
325 if new_upstream_sinks__.is_some() {
326 return Err(serde::de::Error::duplicate_field("newUpstreamSinks"));
327 }
328 new_upstream_sinks__ = Some(
329 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
330 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
331 );
332 }
333 }
334 }
335 Ok(AddMutation {
336 actor_dispatchers: actor_dispatchers__.unwrap_or_default(),
337 added_actors: added_actors__.unwrap_or_default(),
338 actor_splits: actor_splits__.unwrap_or_default(),
339 pause: pause__.unwrap_or_default(),
340 subscriptions_to_add: subscriptions_to_add__.unwrap_or_default(),
341 backfill_nodes_to_pause: backfill_nodes_to_pause__.unwrap_or_default(),
342 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
343 new_upstream_sinks: new_upstream_sinks__.unwrap_or_default(),
344 })
345 }
346 }
347 deserializer.deserialize_struct("stream_plan.AddMutation", FIELDS, GeneratedVisitor)
348 }
349}
350impl serde::Serialize for add_mutation::NewUpstreamSink {
351 #[allow(deprecated)]
352 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
353 where
354 S: serde::Serializer,
355 {
356 use serde::ser::SerializeStruct;
357 let mut len = 0;
358 if self.info.is_some() {
359 len += 1;
360 }
361 if !self.upstream_actors.is_empty() {
362 len += 1;
363 }
364 let mut struct_ser = serializer.serialize_struct("stream_plan.AddMutation.NewUpstreamSink", len)?;
365 if let Some(v) = self.info.as_ref() {
366 struct_ser.serialize_field("info", v)?;
367 }
368 if !self.upstream_actors.is_empty() {
369 struct_ser.serialize_field("upstreamActors", &self.upstream_actors)?;
370 }
371 struct_ser.end()
372 }
373}
374impl<'de> serde::Deserialize<'de> for add_mutation::NewUpstreamSink {
375 #[allow(deprecated)]
376 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
377 where
378 D: serde::Deserializer<'de>,
379 {
380 const FIELDS: &[&str] = &[
381 "info",
382 "upstream_actors",
383 "upstreamActors",
384 ];
385
386 #[allow(clippy::enum_variant_names)]
387 enum GeneratedField {
388 Info,
389 UpstreamActors,
390 }
391 impl<'de> serde::Deserialize<'de> for GeneratedField {
392 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
393 where
394 D: serde::Deserializer<'de>,
395 {
396 struct GeneratedVisitor;
397
398 impl serde::de::Visitor<'_> for GeneratedVisitor {
399 type Value = GeneratedField;
400
401 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
402 write!(formatter, "expected one of: {:?}", &FIELDS)
403 }
404
405 #[allow(unused_variables)]
406 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
407 where
408 E: serde::de::Error,
409 {
410 match value {
411 "info" => Ok(GeneratedField::Info),
412 "upstreamActors" | "upstream_actors" => Ok(GeneratedField::UpstreamActors),
413 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
414 }
415 }
416 }
417 deserializer.deserialize_identifier(GeneratedVisitor)
418 }
419 }
420 struct GeneratedVisitor;
421 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
422 type Value = add_mutation::NewUpstreamSink;
423
424 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
425 formatter.write_str("struct stream_plan.AddMutation.NewUpstreamSink")
426 }
427
428 fn visit_map<V>(self, mut map_: V) -> std::result::Result<add_mutation::NewUpstreamSink, V::Error>
429 where
430 V: serde::de::MapAccess<'de>,
431 {
432 let mut info__ = None;
433 let mut upstream_actors__ = None;
434 while let Some(k) = map_.next_key()? {
435 match k {
436 GeneratedField::Info => {
437 if info__.is_some() {
438 return Err(serde::de::Error::duplicate_field("info"));
439 }
440 info__ = map_.next_value()?;
441 }
442 GeneratedField::UpstreamActors => {
443 if upstream_actors__.is_some() {
444 return Err(serde::de::Error::duplicate_field("upstreamActors"));
445 }
446 upstream_actors__ = Some(map_.next_value()?);
447 }
448 }
449 }
450 Ok(add_mutation::NewUpstreamSink {
451 info: info__,
452 upstream_actors: upstream_actors__.unwrap_or_default(),
453 })
454 }
455 }
456 deserializer.deserialize_struct("stream_plan.AddMutation.NewUpstreamSink", FIELDS, GeneratedVisitor)
457 }
458}
459impl serde::Serialize for AggCallState {
460 #[allow(deprecated)]
461 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
462 where
463 S: serde::Serializer,
464 {
465 use serde::ser::SerializeStruct;
466 let mut len = 0;
467 if self.inner.is_some() {
468 len += 1;
469 }
470 let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState", len)?;
471 if let Some(v) = self.inner.as_ref() {
472 match v {
473 agg_call_state::Inner::ValueState(v) => {
474 struct_ser.serialize_field("valueState", v)?;
475 }
476 agg_call_state::Inner::MaterializedInputState(v) => {
477 struct_ser.serialize_field("materializedInputState", v)?;
478 }
479 }
480 }
481 struct_ser.end()
482 }
483}
484impl<'de> serde::Deserialize<'de> for AggCallState {
485 #[allow(deprecated)]
486 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
487 where
488 D: serde::Deserializer<'de>,
489 {
490 const FIELDS: &[&str] = &[
491 "value_state",
492 "valueState",
493 "materialized_input_state",
494 "materializedInputState",
495 ];
496
497 #[allow(clippy::enum_variant_names)]
498 enum GeneratedField {
499 ValueState,
500 MaterializedInputState,
501 }
502 impl<'de> serde::Deserialize<'de> for GeneratedField {
503 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
504 where
505 D: serde::Deserializer<'de>,
506 {
507 struct GeneratedVisitor;
508
509 impl serde::de::Visitor<'_> for GeneratedVisitor {
510 type Value = GeneratedField;
511
512 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
513 write!(formatter, "expected one of: {:?}", &FIELDS)
514 }
515
516 #[allow(unused_variables)]
517 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
518 where
519 E: serde::de::Error,
520 {
521 match value {
522 "valueState" | "value_state" => Ok(GeneratedField::ValueState),
523 "materializedInputState" | "materialized_input_state" => Ok(GeneratedField::MaterializedInputState),
524 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
525 }
526 }
527 }
528 deserializer.deserialize_identifier(GeneratedVisitor)
529 }
530 }
531 struct GeneratedVisitor;
532 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
533 type Value = AggCallState;
534
535 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
536 formatter.write_str("struct stream_plan.AggCallState")
537 }
538
539 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AggCallState, V::Error>
540 where
541 V: serde::de::MapAccess<'de>,
542 {
543 let mut inner__ = None;
544 while let Some(k) = map_.next_key()? {
545 match k {
546 GeneratedField::ValueState => {
547 if inner__.is_some() {
548 return Err(serde::de::Error::duplicate_field("valueState"));
549 }
550 inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::ValueState)
551;
552 }
553 GeneratedField::MaterializedInputState => {
554 if inner__.is_some() {
555 return Err(serde::de::Error::duplicate_field("materializedInputState"));
556 }
557 inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::MaterializedInputState)
558;
559 }
560 }
561 }
562 Ok(AggCallState {
563 inner: inner__,
564 })
565 }
566 }
567 deserializer.deserialize_struct("stream_plan.AggCallState", FIELDS, GeneratedVisitor)
568 }
569}
570impl serde::Serialize for agg_call_state::MaterializedInputState {
571 #[allow(deprecated)]
572 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
573 where
574 S: serde::Serializer,
575 {
576 use serde::ser::SerializeStruct;
577 let mut len = 0;
578 if self.table.is_some() {
579 len += 1;
580 }
581 if !self.included_upstream_indices.is_empty() {
582 len += 1;
583 }
584 if !self.table_value_indices.is_empty() {
585 len += 1;
586 }
587 if !self.order_columns.is_empty() {
588 len += 1;
589 }
590 let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState.MaterializedInputState", len)?;
591 if let Some(v) = self.table.as_ref() {
592 struct_ser.serialize_field("table", v)?;
593 }
594 if !self.included_upstream_indices.is_empty() {
595 struct_ser.serialize_field("includedUpstreamIndices", &self.included_upstream_indices)?;
596 }
597 if !self.table_value_indices.is_empty() {
598 struct_ser.serialize_field("tableValueIndices", &self.table_value_indices)?;
599 }
600 if !self.order_columns.is_empty() {
601 struct_ser.serialize_field("orderColumns", &self.order_columns)?;
602 }
603 struct_ser.end()
604 }
605}
606impl<'de> serde::Deserialize<'de> for agg_call_state::MaterializedInputState {
607 #[allow(deprecated)]
608 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
609 where
610 D: serde::Deserializer<'de>,
611 {
612 const FIELDS: &[&str] = &[
613 "table",
614 "included_upstream_indices",
615 "includedUpstreamIndices",
616 "table_value_indices",
617 "tableValueIndices",
618 "order_columns",
619 "orderColumns",
620 ];
621
622 #[allow(clippy::enum_variant_names)]
623 enum GeneratedField {
624 Table,
625 IncludedUpstreamIndices,
626 TableValueIndices,
627 OrderColumns,
628 }
629 impl<'de> serde::Deserialize<'de> for GeneratedField {
630 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
631 where
632 D: serde::Deserializer<'de>,
633 {
634 struct GeneratedVisitor;
635
636 impl serde::de::Visitor<'_> for GeneratedVisitor {
637 type Value = GeneratedField;
638
639 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
640 write!(formatter, "expected one of: {:?}", &FIELDS)
641 }
642
643 #[allow(unused_variables)]
644 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
645 where
646 E: serde::de::Error,
647 {
648 match value {
649 "table" => Ok(GeneratedField::Table),
650 "includedUpstreamIndices" | "included_upstream_indices" => Ok(GeneratedField::IncludedUpstreamIndices),
651 "tableValueIndices" | "table_value_indices" => Ok(GeneratedField::TableValueIndices),
652 "orderColumns" | "order_columns" => Ok(GeneratedField::OrderColumns),
653 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
654 }
655 }
656 }
657 deserializer.deserialize_identifier(GeneratedVisitor)
658 }
659 }
660 struct GeneratedVisitor;
661 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
662 type Value = agg_call_state::MaterializedInputState;
663
664 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
665 formatter.write_str("struct stream_plan.AggCallState.MaterializedInputState")
666 }
667
668 fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::MaterializedInputState, V::Error>
669 where
670 V: serde::de::MapAccess<'de>,
671 {
672 let mut table__ = None;
673 let mut included_upstream_indices__ = None;
674 let mut table_value_indices__ = None;
675 let mut order_columns__ = None;
676 while let Some(k) = map_.next_key()? {
677 match k {
678 GeneratedField::Table => {
679 if table__.is_some() {
680 return Err(serde::de::Error::duplicate_field("table"));
681 }
682 table__ = map_.next_value()?;
683 }
684 GeneratedField::IncludedUpstreamIndices => {
685 if included_upstream_indices__.is_some() {
686 return Err(serde::de::Error::duplicate_field("includedUpstreamIndices"));
687 }
688 included_upstream_indices__ =
689 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
690 .into_iter().map(|x| x.0).collect())
691 ;
692 }
693 GeneratedField::TableValueIndices => {
694 if table_value_indices__.is_some() {
695 return Err(serde::de::Error::duplicate_field("tableValueIndices"));
696 }
697 table_value_indices__ =
698 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
699 .into_iter().map(|x| x.0).collect())
700 ;
701 }
702 GeneratedField::OrderColumns => {
703 if order_columns__.is_some() {
704 return Err(serde::de::Error::duplicate_field("orderColumns"));
705 }
706 order_columns__ = Some(map_.next_value()?);
707 }
708 }
709 }
710 Ok(agg_call_state::MaterializedInputState {
711 table: table__,
712 included_upstream_indices: included_upstream_indices__.unwrap_or_default(),
713 table_value_indices: table_value_indices__.unwrap_or_default(),
714 order_columns: order_columns__.unwrap_or_default(),
715 })
716 }
717 }
718 deserializer.deserialize_struct("stream_plan.AggCallState.MaterializedInputState", FIELDS, GeneratedVisitor)
719 }
720}
721impl serde::Serialize for agg_call_state::ValueState {
722 #[allow(deprecated)]
723 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
724 where
725 S: serde::Serializer,
726 {
727 use serde::ser::SerializeStruct;
728 let len = 0;
729 let struct_ser = serializer.serialize_struct("stream_plan.AggCallState.ValueState", len)?;
730 struct_ser.end()
731 }
732}
733impl<'de> serde::Deserialize<'de> for agg_call_state::ValueState {
734 #[allow(deprecated)]
735 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
736 where
737 D: serde::Deserializer<'de>,
738 {
739 const FIELDS: &[&str] = &[
740 ];
741
742 #[allow(clippy::enum_variant_names)]
743 enum GeneratedField {
744 }
745 impl<'de> serde::Deserialize<'de> for GeneratedField {
746 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
747 where
748 D: serde::Deserializer<'de>,
749 {
750 struct GeneratedVisitor;
751
752 impl serde::de::Visitor<'_> for GeneratedVisitor {
753 type Value = GeneratedField;
754
755 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
756 write!(formatter, "expected one of: {:?}", &FIELDS)
757 }
758
759 #[allow(unused_variables)]
760 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
761 where
762 E: serde::de::Error,
763 {
764 Err(serde::de::Error::unknown_field(value, FIELDS))
765 }
766 }
767 deserializer.deserialize_identifier(GeneratedVisitor)
768 }
769 }
770 struct GeneratedVisitor;
771 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
772 type Value = agg_call_state::ValueState;
773
774 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
775 formatter.write_str("struct stream_plan.AggCallState.ValueState")
776 }
777
778 fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::ValueState, V::Error>
779 where
780 V: serde::de::MapAccess<'de>,
781 {
782 while map_.next_key::<GeneratedField>()?.is_some() {
783 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
784 }
785 Ok(agg_call_state::ValueState {
786 })
787 }
788 }
789 deserializer.deserialize_struct("stream_plan.AggCallState.ValueState", FIELDS, GeneratedVisitor)
790 }
791}
792impl serde::Serialize for AggNodeVersion {
793 #[allow(deprecated)]
794 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
795 where
796 S: serde::Serializer,
797 {
798 let variant = match self {
799 Self::Unspecified => "AGG_NODE_VERSION_UNSPECIFIED",
800 Self::Issue12140 => "AGG_NODE_VERSION_ISSUE_12140",
801 Self::Issue13465 => "AGG_NODE_VERSION_ISSUE_13465",
802 };
803 serializer.serialize_str(variant)
804 }
805}
806impl<'de> serde::Deserialize<'de> for AggNodeVersion {
807 #[allow(deprecated)]
808 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
809 where
810 D: serde::Deserializer<'de>,
811 {
812 const FIELDS: &[&str] = &[
813 "AGG_NODE_VERSION_UNSPECIFIED",
814 "AGG_NODE_VERSION_ISSUE_12140",
815 "AGG_NODE_VERSION_ISSUE_13465",
816 ];
817
818 struct GeneratedVisitor;
819
820 impl serde::de::Visitor<'_> for GeneratedVisitor {
821 type Value = AggNodeVersion;
822
823 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
824 write!(formatter, "expected one of: {:?}", &FIELDS)
825 }
826
827 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
828 where
829 E: serde::de::Error,
830 {
831 i32::try_from(v)
832 .ok()
833 .and_then(|x| x.try_into().ok())
834 .ok_or_else(|| {
835 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
836 })
837 }
838
839 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
840 where
841 E: serde::de::Error,
842 {
843 i32::try_from(v)
844 .ok()
845 .and_then(|x| x.try_into().ok())
846 .ok_or_else(|| {
847 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
848 })
849 }
850
851 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
852 where
853 E: serde::de::Error,
854 {
855 match value {
856 "AGG_NODE_VERSION_UNSPECIFIED" => Ok(AggNodeVersion::Unspecified),
857 "AGG_NODE_VERSION_ISSUE_12140" => Ok(AggNodeVersion::Issue12140),
858 "AGG_NODE_VERSION_ISSUE_13465" => Ok(AggNodeVersion::Issue13465),
859 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
860 }
861 }
862 }
863 deserializer.deserialize_any(GeneratedVisitor)
864 }
865}
866impl serde::Serialize for ArrangeNode {
867 #[allow(deprecated)]
868 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
869 where
870 S: serde::Serializer,
871 {
872 use serde::ser::SerializeStruct;
873 let mut len = 0;
874 if self.table_info.is_some() {
875 len += 1;
876 }
877 if !self.distribution_key.is_empty() {
878 len += 1;
879 }
880 if self.table.is_some() {
881 len += 1;
882 }
883 let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangeNode", len)?;
884 if let Some(v) = self.table_info.as_ref() {
885 struct_ser.serialize_field("tableInfo", v)?;
886 }
887 if !self.distribution_key.is_empty() {
888 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
889 }
890 if let Some(v) = self.table.as_ref() {
891 struct_ser.serialize_field("table", v)?;
892 }
893 struct_ser.end()
894 }
895}
896impl<'de> serde::Deserialize<'de> for ArrangeNode {
897 #[allow(deprecated)]
898 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
899 where
900 D: serde::Deserializer<'de>,
901 {
902 const FIELDS: &[&str] = &[
903 "table_info",
904 "tableInfo",
905 "distribution_key",
906 "distributionKey",
907 "table",
908 ];
909
910 #[allow(clippy::enum_variant_names)]
911 enum GeneratedField {
912 TableInfo,
913 DistributionKey,
914 Table,
915 }
916 impl<'de> serde::Deserialize<'de> for GeneratedField {
917 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
918 where
919 D: serde::Deserializer<'de>,
920 {
921 struct GeneratedVisitor;
922
923 impl serde::de::Visitor<'_> for GeneratedVisitor {
924 type Value = GeneratedField;
925
926 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
927 write!(formatter, "expected one of: {:?}", &FIELDS)
928 }
929
930 #[allow(unused_variables)]
931 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
932 where
933 E: serde::de::Error,
934 {
935 match value {
936 "tableInfo" | "table_info" => Ok(GeneratedField::TableInfo),
937 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
938 "table" => Ok(GeneratedField::Table),
939 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
940 }
941 }
942 }
943 deserializer.deserialize_identifier(GeneratedVisitor)
944 }
945 }
946 struct GeneratedVisitor;
947 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
948 type Value = ArrangeNode;
949
950 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
951 formatter.write_str("struct stream_plan.ArrangeNode")
952 }
953
954 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangeNode, V::Error>
955 where
956 V: serde::de::MapAccess<'de>,
957 {
958 let mut table_info__ = None;
959 let mut distribution_key__ = None;
960 let mut table__ = None;
961 while let Some(k) = map_.next_key()? {
962 match k {
963 GeneratedField::TableInfo => {
964 if table_info__.is_some() {
965 return Err(serde::de::Error::duplicate_field("tableInfo"));
966 }
967 table_info__ = map_.next_value()?;
968 }
969 GeneratedField::DistributionKey => {
970 if distribution_key__.is_some() {
971 return Err(serde::de::Error::duplicate_field("distributionKey"));
972 }
973 distribution_key__ =
974 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
975 .into_iter().map(|x| x.0).collect())
976 ;
977 }
978 GeneratedField::Table => {
979 if table__.is_some() {
980 return Err(serde::de::Error::duplicate_field("table"));
981 }
982 table__ = map_.next_value()?;
983 }
984 }
985 }
986 Ok(ArrangeNode {
987 table_info: table_info__,
988 distribution_key: distribution_key__.unwrap_or_default(),
989 table: table__,
990 })
991 }
992 }
993 deserializer.deserialize_struct("stream_plan.ArrangeNode", FIELDS, GeneratedVisitor)
994 }
995}
996impl serde::Serialize for ArrangementInfo {
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.arrange_key_orders.is_empty() {
1005 len += 1;
1006 }
1007 if !self.column_descs.is_empty() {
1008 len += 1;
1009 }
1010 if self.table_desc.is_some() {
1011 len += 1;
1012 }
1013 if !self.output_col_idx.is_empty() {
1014 len += 1;
1015 }
1016 let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangementInfo", len)?;
1017 if !self.arrange_key_orders.is_empty() {
1018 struct_ser.serialize_field("arrangeKeyOrders", &self.arrange_key_orders)?;
1019 }
1020 if !self.column_descs.is_empty() {
1021 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
1022 }
1023 if let Some(v) = self.table_desc.as_ref() {
1024 struct_ser.serialize_field("tableDesc", v)?;
1025 }
1026 if !self.output_col_idx.is_empty() {
1027 struct_ser.serialize_field("outputColIdx", &self.output_col_idx)?;
1028 }
1029 struct_ser.end()
1030 }
1031}
1032impl<'de> serde::Deserialize<'de> for ArrangementInfo {
1033 #[allow(deprecated)]
1034 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1035 where
1036 D: serde::Deserializer<'de>,
1037 {
1038 const FIELDS: &[&str] = &[
1039 "arrange_key_orders",
1040 "arrangeKeyOrders",
1041 "column_descs",
1042 "columnDescs",
1043 "table_desc",
1044 "tableDesc",
1045 "output_col_idx",
1046 "outputColIdx",
1047 ];
1048
1049 #[allow(clippy::enum_variant_names)]
1050 enum GeneratedField {
1051 ArrangeKeyOrders,
1052 ColumnDescs,
1053 TableDesc,
1054 OutputColIdx,
1055 }
1056 impl<'de> serde::Deserialize<'de> for GeneratedField {
1057 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1058 where
1059 D: serde::Deserializer<'de>,
1060 {
1061 struct GeneratedVisitor;
1062
1063 impl serde::de::Visitor<'_> for GeneratedVisitor {
1064 type Value = GeneratedField;
1065
1066 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1067 write!(formatter, "expected one of: {:?}", &FIELDS)
1068 }
1069
1070 #[allow(unused_variables)]
1071 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1072 where
1073 E: serde::de::Error,
1074 {
1075 match value {
1076 "arrangeKeyOrders" | "arrange_key_orders" => Ok(GeneratedField::ArrangeKeyOrders),
1077 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
1078 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
1079 "outputColIdx" | "output_col_idx" => Ok(GeneratedField::OutputColIdx),
1080 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1081 }
1082 }
1083 }
1084 deserializer.deserialize_identifier(GeneratedVisitor)
1085 }
1086 }
1087 struct GeneratedVisitor;
1088 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1089 type Value = ArrangementInfo;
1090
1091 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1092 formatter.write_str("struct stream_plan.ArrangementInfo")
1093 }
1094
1095 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangementInfo, V::Error>
1096 where
1097 V: serde::de::MapAccess<'de>,
1098 {
1099 let mut arrange_key_orders__ = None;
1100 let mut column_descs__ = None;
1101 let mut table_desc__ = None;
1102 let mut output_col_idx__ = None;
1103 while let Some(k) = map_.next_key()? {
1104 match k {
1105 GeneratedField::ArrangeKeyOrders => {
1106 if arrange_key_orders__.is_some() {
1107 return Err(serde::de::Error::duplicate_field("arrangeKeyOrders"));
1108 }
1109 arrange_key_orders__ = Some(map_.next_value()?);
1110 }
1111 GeneratedField::ColumnDescs => {
1112 if column_descs__.is_some() {
1113 return Err(serde::de::Error::duplicate_field("columnDescs"));
1114 }
1115 column_descs__ = Some(map_.next_value()?);
1116 }
1117 GeneratedField::TableDesc => {
1118 if table_desc__.is_some() {
1119 return Err(serde::de::Error::duplicate_field("tableDesc"));
1120 }
1121 table_desc__ = map_.next_value()?;
1122 }
1123 GeneratedField::OutputColIdx => {
1124 if output_col_idx__.is_some() {
1125 return Err(serde::de::Error::duplicate_field("outputColIdx"));
1126 }
1127 output_col_idx__ =
1128 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1129 .into_iter().map(|x| x.0).collect())
1130 ;
1131 }
1132 }
1133 }
1134 Ok(ArrangementInfo {
1135 arrange_key_orders: arrange_key_orders__.unwrap_or_default(),
1136 column_descs: column_descs__.unwrap_or_default(),
1137 table_desc: table_desc__,
1138 output_col_idx: output_col_idx__.unwrap_or_default(),
1139 })
1140 }
1141 }
1142 deserializer.deserialize_struct("stream_plan.ArrangementInfo", FIELDS, GeneratedVisitor)
1143 }
1144}
1145impl serde::Serialize for AsOfJoinNode {
1146 #[allow(deprecated)]
1147 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1148 where
1149 S: serde::Serializer,
1150 {
1151 use serde::ser::SerializeStruct;
1152 let mut len = 0;
1153 if self.join_type != 0 {
1154 len += 1;
1155 }
1156 if !self.left_key.is_empty() {
1157 len += 1;
1158 }
1159 if !self.right_key.is_empty() {
1160 len += 1;
1161 }
1162 if self.left_table.is_some() {
1163 len += 1;
1164 }
1165 if self.right_table.is_some() {
1166 len += 1;
1167 }
1168 if !self.output_indices.is_empty() {
1169 len += 1;
1170 }
1171 if !self.left_deduped_input_pk_indices.is_empty() {
1172 len += 1;
1173 }
1174 if !self.right_deduped_input_pk_indices.is_empty() {
1175 len += 1;
1176 }
1177 if !self.null_safe.is_empty() {
1178 len += 1;
1179 }
1180 if self.asof_desc.is_some() {
1181 len += 1;
1182 }
1183 if self.join_encoding_type != 0 {
1184 len += 1;
1185 }
1186 let mut struct_ser = serializer.serialize_struct("stream_plan.AsOfJoinNode", len)?;
1187 if self.join_type != 0 {
1188 let v = super::plan_common::AsOfJoinType::try_from(self.join_type)
1189 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
1190 struct_ser.serialize_field("joinType", &v)?;
1191 }
1192 if !self.left_key.is_empty() {
1193 struct_ser.serialize_field("leftKey", &self.left_key)?;
1194 }
1195 if !self.right_key.is_empty() {
1196 struct_ser.serialize_field("rightKey", &self.right_key)?;
1197 }
1198 if let Some(v) = self.left_table.as_ref() {
1199 struct_ser.serialize_field("leftTable", v)?;
1200 }
1201 if let Some(v) = self.right_table.as_ref() {
1202 struct_ser.serialize_field("rightTable", v)?;
1203 }
1204 if !self.output_indices.is_empty() {
1205 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
1206 }
1207 if !self.left_deduped_input_pk_indices.is_empty() {
1208 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
1209 }
1210 if !self.right_deduped_input_pk_indices.is_empty() {
1211 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
1212 }
1213 if !self.null_safe.is_empty() {
1214 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
1215 }
1216 if let Some(v) = self.asof_desc.as_ref() {
1217 struct_ser.serialize_field("asofDesc", v)?;
1218 }
1219 if self.join_encoding_type != 0 {
1220 let v = JoinEncodingType::try_from(self.join_encoding_type)
1221 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
1222 struct_ser.serialize_field("joinEncodingType", &v)?;
1223 }
1224 struct_ser.end()
1225 }
1226}
1227impl<'de> serde::Deserialize<'de> for AsOfJoinNode {
1228 #[allow(deprecated)]
1229 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1230 where
1231 D: serde::Deserializer<'de>,
1232 {
1233 const FIELDS: &[&str] = &[
1234 "join_type",
1235 "joinType",
1236 "left_key",
1237 "leftKey",
1238 "right_key",
1239 "rightKey",
1240 "left_table",
1241 "leftTable",
1242 "right_table",
1243 "rightTable",
1244 "output_indices",
1245 "outputIndices",
1246 "left_deduped_input_pk_indices",
1247 "leftDedupedInputPkIndices",
1248 "right_deduped_input_pk_indices",
1249 "rightDedupedInputPkIndices",
1250 "null_safe",
1251 "nullSafe",
1252 "asof_desc",
1253 "asofDesc",
1254 "join_encoding_type",
1255 "joinEncodingType",
1256 ];
1257
1258 #[allow(clippy::enum_variant_names)]
1259 enum GeneratedField {
1260 JoinType,
1261 LeftKey,
1262 RightKey,
1263 LeftTable,
1264 RightTable,
1265 OutputIndices,
1266 LeftDedupedInputPkIndices,
1267 RightDedupedInputPkIndices,
1268 NullSafe,
1269 AsofDesc,
1270 JoinEncodingType,
1271 }
1272 impl<'de> serde::Deserialize<'de> for GeneratedField {
1273 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1274 where
1275 D: serde::Deserializer<'de>,
1276 {
1277 struct GeneratedVisitor;
1278
1279 impl serde::de::Visitor<'_> for GeneratedVisitor {
1280 type Value = GeneratedField;
1281
1282 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1283 write!(formatter, "expected one of: {:?}", &FIELDS)
1284 }
1285
1286 #[allow(unused_variables)]
1287 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1288 where
1289 E: serde::de::Error,
1290 {
1291 match value {
1292 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
1293 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
1294 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
1295 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
1296 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
1297 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
1298 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
1299 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
1300 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
1301 "asofDesc" | "asof_desc" => Ok(GeneratedField::AsofDesc),
1302 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
1303 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1304 }
1305 }
1306 }
1307 deserializer.deserialize_identifier(GeneratedVisitor)
1308 }
1309 }
1310 struct GeneratedVisitor;
1311 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1312 type Value = AsOfJoinNode;
1313
1314 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1315 formatter.write_str("struct stream_plan.AsOfJoinNode")
1316 }
1317
1318 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AsOfJoinNode, V::Error>
1319 where
1320 V: serde::de::MapAccess<'de>,
1321 {
1322 let mut join_type__ = None;
1323 let mut left_key__ = None;
1324 let mut right_key__ = None;
1325 let mut left_table__ = None;
1326 let mut right_table__ = None;
1327 let mut output_indices__ = None;
1328 let mut left_deduped_input_pk_indices__ = None;
1329 let mut right_deduped_input_pk_indices__ = None;
1330 let mut null_safe__ = None;
1331 let mut asof_desc__ = None;
1332 let mut join_encoding_type__ = None;
1333 while let Some(k) = map_.next_key()? {
1334 match k {
1335 GeneratedField::JoinType => {
1336 if join_type__.is_some() {
1337 return Err(serde::de::Error::duplicate_field("joinType"));
1338 }
1339 join_type__ = Some(map_.next_value::<super::plan_common::AsOfJoinType>()? as i32);
1340 }
1341 GeneratedField::LeftKey => {
1342 if left_key__.is_some() {
1343 return Err(serde::de::Error::duplicate_field("leftKey"));
1344 }
1345 left_key__ =
1346 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1347 .into_iter().map(|x| x.0).collect())
1348 ;
1349 }
1350 GeneratedField::RightKey => {
1351 if right_key__.is_some() {
1352 return Err(serde::de::Error::duplicate_field("rightKey"));
1353 }
1354 right_key__ =
1355 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1356 .into_iter().map(|x| x.0).collect())
1357 ;
1358 }
1359 GeneratedField::LeftTable => {
1360 if left_table__.is_some() {
1361 return Err(serde::de::Error::duplicate_field("leftTable"));
1362 }
1363 left_table__ = map_.next_value()?;
1364 }
1365 GeneratedField::RightTable => {
1366 if right_table__.is_some() {
1367 return Err(serde::de::Error::duplicate_field("rightTable"));
1368 }
1369 right_table__ = map_.next_value()?;
1370 }
1371 GeneratedField::OutputIndices => {
1372 if output_indices__.is_some() {
1373 return Err(serde::de::Error::duplicate_field("outputIndices"));
1374 }
1375 output_indices__ =
1376 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1377 .into_iter().map(|x| x.0).collect())
1378 ;
1379 }
1380 GeneratedField::LeftDedupedInputPkIndices => {
1381 if left_deduped_input_pk_indices__.is_some() {
1382 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
1383 }
1384 left_deduped_input_pk_indices__ =
1385 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1386 .into_iter().map(|x| x.0).collect())
1387 ;
1388 }
1389 GeneratedField::RightDedupedInputPkIndices => {
1390 if right_deduped_input_pk_indices__.is_some() {
1391 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
1392 }
1393 right_deduped_input_pk_indices__ =
1394 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1395 .into_iter().map(|x| x.0).collect())
1396 ;
1397 }
1398 GeneratedField::NullSafe => {
1399 if null_safe__.is_some() {
1400 return Err(serde::de::Error::duplicate_field("nullSafe"));
1401 }
1402 null_safe__ = Some(map_.next_value()?);
1403 }
1404 GeneratedField::AsofDesc => {
1405 if asof_desc__.is_some() {
1406 return Err(serde::de::Error::duplicate_field("asofDesc"));
1407 }
1408 asof_desc__ = map_.next_value()?;
1409 }
1410 GeneratedField::JoinEncodingType => {
1411 if join_encoding_type__.is_some() {
1412 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
1413 }
1414 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
1415 }
1416 }
1417 }
1418 Ok(AsOfJoinNode {
1419 join_type: join_type__.unwrap_or_default(),
1420 left_key: left_key__.unwrap_or_default(),
1421 right_key: right_key__.unwrap_or_default(),
1422 left_table: left_table__,
1423 right_table: right_table__,
1424 output_indices: output_indices__.unwrap_or_default(),
1425 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
1426 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
1427 null_safe: null_safe__.unwrap_or_default(),
1428 asof_desc: asof_desc__,
1429 join_encoding_type: join_encoding_type__.unwrap_or_default(),
1430 })
1431 }
1432 }
1433 deserializer.deserialize_struct("stream_plan.AsOfJoinNode", FIELDS, GeneratedVisitor)
1434 }
1435}
1436impl serde::Serialize for BackfillOrder {
1437 #[allow(deprecated)]
1438 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1439 where
1440 S: serde::Serializer,
1441 {
1442 use serde::ser::SerializeStruct;
1443 let mut len = 0;
1444 if !self.order.is_empty() {
1445 len += 1;
1446 }
1447 let mut struct_ser = serializer.serialize_struct("stream_plan.BackfillOrder", len)?;
1448 if !self.order.is_empty() {
1449 struct_ser.serialize_field("order", &self.order)?;
1450 }
1451 struct_ser.end()
1452 }
1453}
1454impl<'de> serde::Deserialize<'de> for BackfillOrder {
1455 #[allow(deprecated)]
1456 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1457 where
1458 D: serde::Deserializer<'de>,
1459 {
1460 const FIELDS: &[&str] = &[
1461 "order",
1462 ];
1463
1464 #[allow(clippy::enum_variant_names)]
1465 enum GeneratedField {
1466 Order,
1467 }
1468 impl<'de> serde::Deserialize<'de> for GeneratedField {
1469 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1470 where
1471 D: serde::Deserializer<'de>,
1472 {
1473 struct GeneratedVisitor;
1474
1475 impl serde::de::Visitor<'_> for GeneratedVisitor {
1476 type Value = GeneratedField;
1477
1478 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1479 write!(formatter, "expected one of: {:?}", &FIELDS)
1480 }
1481
1482 #[allow(unused_variables)]
1483 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1484 where
1485 E: serde::de::Error,
1486 {
1487 match value {
1488 "order" => Ok(GeneratedField::Order),
1489 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1490 }
1491 }
1492 }
1493 deserializer.deserialize_identifier(GeneratedVisitor)
1494 }
1495 }
1496 struct GeneratedVisitor;
1497 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1498 type Value = BackfillOrder;
1499
1500 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1501 formatter.write_str("struct stream_plan.BackfillOrder")
1502 }
1503
1504 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BackfillOrder, V::Error>
1505 where
1506 V: serde::de::MapAccess<'de>,
1507 {
1508 let mut order__ = None;
1509 while let Some(k) = map_.next_key()? {
1510 match k {
1511 GeneratedField::Order => {
1512 if order__.is_some() {
1513 return Err(serde::de::Error::duplicate_field("order"));
1514 }
1515 order__ = Some(
1516 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1517 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1518 );
1519 }
1520 }
1521 }
1522 Ok(BackfillOrder {
1523 order: order__.unwrap_or_default(),
1524 })
1525 }
1526 }
1527 deserializer.deserialize_struct("stream_plan.BackfillOrder", FIELDS, GeneratedVisitor)
1528 }
1529}
1530impl serde::Serialize for Barrier {
1531 #[allow(deprecated)]
1532 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1533 where
1534 S: serde::Serializer,
1535 {
1536 use serde::ser::SerializeStruct;
1537 let mut len = 0;
1538 if self.epoch.is_some() {
1539 len += 1;
1540 }
1541 if self.mutation.is_some() {
1542 len += 1;
1543 }
1544 if !self.tracing_context.is_empty() {
1545 len += 1;
1546 }
1547 if self.kind != 0 {
1548 len += 1;
1549 }
1550 let mut struct_ser = serializer.serialize_struct("stream_plan.Barrier", len)?;
1551 if let Some(v) = self.epoch.as_ref() {
1552 struct_ser.serialize_field("epoch", v)?;
1553 }
1554 if let Some(v) = self.mutation.as_ref() {
1555 struct_ser.serialize_field("mutation", v)?;
1556 }
1557 if !self.tracing_context.is_empty() {
1558 struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
1559 }
1560 if self.kind != 0 {
1561 let v = barrier::BarrierKind::try_from(self.kind)
1562 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
1563 struct_ser.serialize_field("kind", &v)?;
1564 }
1565 struct_ser.end()
1566 }
1567}
1568impl<'de> serde::Deserialize<'de> for Barrier {
1569 #[allow(deprecated)]
1570 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1571 where
1572 D: serde::Deserializer<'de>,
1573 {
1574 const FIELDS: &[&str] = &[
1575 "epoch",
1576 "mutation",
1577 "tracing_context",
1578 "tracingContext",
1579 "kind",
1580 ];
1581
1582 #[allow(clippy::enum_variant_names)]
1583 enum GeneratedField {
1584 Epoch,
1585 Mutation,
1586 TracingContext,
1587 Kind,
1588 }
1589 impl<'de> serde::Deserialize<'de> for GeneratedField {
1590 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1591 where
1592 D: serde::Deserializer<'de>,
1593 {
1594 struct GeneratedVisitor;
1595
1596 impl serde::de::Visitor<'_> for GeneratedVisitor {
1597 type Value = GeneratedField;
1598
1599 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1600 write!(formatter, "expected one of: {:?}", &FIELDS)
1601 }
1602
1603 #[allow(unused_variables)]
1604 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1605 where
1606 E: serde::de::Error,
1607 {
1608 match value {
1609 "epoch" => Ok(GeneratedField::Epoch),
1610 "mutation" => Ok(GeneratedField::Mutation),
1611 "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
1612 "kind" => Ok(GeneratedField::Kind),
1613 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1614 }
1615 }
1616 }
1617 deserializer.deserialize_identifier(GeneratedVisitor)
1618 }
1619 }
1620 struct GeneratedVisitor;
1621 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1622 type Value = Barrier;
1623
1624 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1625 formatter.write_str("struct stream_plan.Barrier")
1626 }
1627
1628 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Barrier, V::Error>
1629 where
1630 V: serde::de::MapAccess<'de>,
1631 {
1632 let mut epoch__ = None;
1633 let mut mutation__ = None;
1634 let mut tracing_context__ = None;
1635 let mut kind__ = None;
1636 while let Some(k) = map_.next_key()? {
1637 match k {
1638 GeneratedField::Epoch => {
1639 if epoch__.is_some() {
1640 return Err(serde::de::Error::duplicate_field("epoch"));
1641 }
1642 epoch__ = map_.next_value()?;
1643 }
1644 GeneratedField::Mutation => {
1645 if mutation__.is_some() {
1646 return Err(serde::de::Error::duplicate_field("mutation"));
1647 }
1648 mutation__ = map_.next_value()?;
1649 }
1650 GeneratedField::TracingContext => {
1651 if tracing_context__.is_some() {
1652 return Err(serde::de::Error::duplicate_field("tracingContext"));
1653 }
1654 tracing_context__ = Some(
1655 map_.next_value::<std::collections::HashMap<_, _>>()?
1656 );
1657 }
1658 GeneratedField::Kind => {
1659 if kind__.is_some() {
1660 return Err(serde::de::Error::duplicate_field("kind"));
1661 }
1662 kind__ = Some(map_.next_value::<barrier::BarrierKind>()? as i32);
1663 }
1664 }
1665 }
1666 Ok(Barrier {
1667 epoch: epoch__,
1668 mutation: mutation__,
1669 tracing_context: tracing_context__.unwrap_or_default(),
1670 kind: kind__.unwrap_or_default(),
1671 })
1672 }
1673 }
1674 deserializer.deserialize_struct("stream_plan.Barrier", FIELDS, GeneratedVisitor)
1675 }
1676}
1677impl serde::Serialize for barrier::BarrierKind {
1678 #[allow(deprecated)]
1679 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1680 where
1681 S: serde::Serializer,
1682 {
1683 let variant = match self {
1684 Self::Unspecified => "BARRIER_KIND_UNSPECIFIED",
1685 Self::Initial => "BARRIER_KIND_INITIAL",
1686 Self::Barrier => "BARRIER_KIND_BARRIER",
1687 Self::Checkpoint => "BARRIER_KIND_CHECKPOINT",
1688 };
1689 serializer.serialize_str(variant)
1690 }
1691}
1692impl<'de> serde::Deserialize<'de> for barrier::BarrierKind {
1693 #[allow(deprecated)]
1694 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1695 where
1696 D: serde::Deserializer<'de>,
1697 {
1698 const FIELDS: &[&str] = &[
1699 "BARRIER_KIND_UNSPECIFIED",
1700 "BARRIER_KIND_INITIAL",
1701 "BARRIER_KIND_BARRIER",
1702 "BARRIER_KIND_CHECKPOINT",
1703 ];
1704
1705 struct GeneratedVisitor;
1706
1707 impl serde::de::Visitor<'_> for GeneratedVisitor {
1708 type Value = barrier::BarrierKind;
1709
1710 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1711 write!(formatter, "expected one of: {:?}", &FIELDS)
1712 }
1713
1714 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1715 where
1716 E: serde::de::Error,
1717 {
1718 i32::try_from(v)
1719 .ok()
1720 .and_then(|x| x.try_into().ok())
1721 .ok_or_else(|| {
1722 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1723 })
1724 }
1725
1726 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1727 where
1728 E: serde::de::Error,
1729 {
1730 i32::try_from(v)
1731 .ok()
1732 .and_then(|x| x.try_into().ok())
1733 .ok_or_else(|| {
1734 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1735 })
1736 }
1737
1738 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1739 where
1740 E: serde::de::Error,
1741 {
1742 match value {
1743 "BARRIER_KIND_UNSPECIFIED" => Ok(barrier::BarrierKind::Unspecified),
1744 "BARRIER_KIND_INITIAL" => Ok(barrier::BarrierKind::Initial),
1745 "BARRIER_KIND_BARRIER" => Ok(barrier::BarrierKind::Barrier),
1746 "BARRIER_KIND_CHECKPOINT" => Ok(barrier::BarrierKind::Checkpoint),
1747 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1748 }
1749 }
1750 }
1751 deserializer.deserialize_any(GeneratedVisitor)
1752 }
1753}
1754impl serde::Serialize for BarrierMutation {
1755 #[allow(deprecated)]
1756 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1757 where
1758 S: serde::Serializer,
1759 {
1760 use serde::ser::SerializeStruct;
1761 let mut len = 0;
1762 if self.mutation.is_some() {
1763 len += 1;
1764 }
1765 let mut struct_ser = serializer.serialize_struct("stream_plan.BarrierMutation", len)?;
1766 if let Some(v) = self.mutation.as_ref() {
1767 match v {
1768 barrier_mutation::Mutation::Add(v) => {
1769 struct_ser.serialize_field("add", v)?;
1770 }
1771 barrier_mutation::Mutation::Stop(v) => {
1772 struct_ser.serialize_field("stop", v)?;
1773 }
1774 barrier_mutation::Mutation::Update(v) => {
1775 struct_ser.serialize_field("update", v)?;
1776 }
1777 barrier_mutation::Mutation::Splits(v) => {
1778 struct_ser.serialize_field("splits", v)?;
1779 }
1780 barrier_mutation::Mutation::Pause(v) => {
1781 struct_ser.serialize_field("pause", v)?;
1782 }
1783 barrier_mutation::Mutation::Resume(v) => {
1784 struct_ser.serialize_field("resume", v)?;
1785 }
1786 barrier_mutation::Mutation::Throttle(v) => {
1787 struct_ser.serialize_field("throttle", v)?;
1788 }
1789 barrier_mutation::Mutation::DropSubscriptions(v) => {
1790 struct_ser.serialize_field("dropSubscriptions", v)?;
1791 }
1792 barrier_mutation::Mutation::ConnectorPropsChange(v) => {
1793 struct_ser.serialize_field("connectorPropsChange", v)?;
1794 }
1795 barrier_mutation::Mutation::StartFragmentBackfill(v) => {
1796 struct_ser.serialize_field("startFragmentBackfill", v)?;
1797 }
1798 barrier_mutation::Mutation::RefreshStart(v) => {
1799 struct_ser.serialize_field("refreshStart", v)?;
1800 }
1801 barrier_mutation::Mutation::LoadFinish(v) => {
1802 struct_ser.serialize_field("loadFinish", v)?;
1803 }
1804 barrier_mutation::Mutation::ListFinish(v) => {
1805 struct_ser.serialize_field("listFinish", v)?;
1806 }
1807 barrier_mutation::Mutation::ResetSource(v) => {
1808 struct_ser.serialize_field("resetSource", v)?;
1809 }
1810 barrier_mutation::Mutation::InjectSourceOffsets(v) => {
1811 struct_ser.serialize_field("injectSourceOffsets", v)?;
1812 }
1813 }
1814 }
1815 struct_ser.end()
1816 }
1817}
1818impl<'de> serde::Deserialize<'de> for BarrierMutation {
1819 #[allow(deprecated)]
1820 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1821 where
1822 D: serde::Deserializer<'de>,
1823 {
1824 const FIELDS: &[&str] = &[
1825 "add",
1826 "stop",
1827 "update",
1828 "splits",
1829 "pause",
1830 "resume",
1831 "throttle",
1832 "drop_subscriptions",
1833 "dropSubscriptions",
1834 "connector_props_change",
1835 "connectorPropsChange",
1836 "start_fragment_backfill",
1837 "startFragmentBackfill",
1838 "refresh_start",
1839 "refreshStart",
1840 "load_finish",
1841 "loadFinish",
1842 "list_finish",
1843 "listFinish",
1844 "reset_source",
1845 "resetSource",
1846 "inject_source_offsets",
1847 "injectSourceOffsets",
1848 ];
1849
1850 #[allow(clippy::enum_variant_names)]
1851 enum GeneratedField {
1852 Add,
1853 Stop,
1854 Update,
1855 Splits,
1856 Pause,
1857 Resume,
1858 Throttle,
1859 DropSubscriptions,
1860 ConnectorPropsChange,
1861 StartFragmentBackfill,
1862 RefreshStart,
1863 LoadFinish,
1864 ListFinish,
1865 ResetSource,
1866 InjectSourceOffsets,
1867 }
1868 impl<'de> serde::Deserialize<'de> for GeneratedField {
1869 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1870 where
1871 D: serde::Deserializer<'de>,
1872 {
1873 struct GeneratedVisitor;
1874
1875 impl serde::de::Visitor<'_> for GeneratedVisitor {
1876 type Value = GeneratedField;
1877
1878 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1879 write!(formatter, "expected one of: {:?}", &FIELDS)
1880 }
1881
1882 #[allow(unused_variables)]
1883 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1884 where
1885 E: serde::de::Error,
1886 {
1887 match value {
1888 "add" => Ok(GeneratedField::Add),
1889 "stop" => Ok(GeneratedField::Stop),
1890 "update" => Ok(GeneratedField::Update),
1891 "splits" => Ok(GeneratedField::Splits),
1892 "pause" => Ok(GeneratedField::Pause),
1893 "resume" => Ok(GeneratedField::Resume),
1894 "throttle" => Ok(GeneratedField::Throttle),
1895 "dropSubscriptions" | "drop_subscriptions" => Ok(GeneratedField::DropSubscriptions),
1896 "connectorPropsChange" | "connector_props_change" => Ok(GeneratedField::ConnectorPropsChange),
1897 "startFragmentBackfill" | "start_fragment_backfill" => Ok(GeneratedField::StartFragmentBackfill),
1898 "refreshStart" | "refresh_start" => Ok(GeneratedField::RefreshStart),
1899 "loadFinish" | "load_finish" => Ok(GeneratedField::LoadFinish),
1900 "listFinish" | "list_finish" => Ok(GeneratedField::ListFinish),
1901 "resetSource" | "reset_source" => Ok(GeneratedField::ResetSource),
1902 "injectSourceOffsets" | "inject_source_offsets" => Ok(GeneratedField::InjectSourceOffsets),
1903 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1904 }
1905 }
1906 }
1907 deserializer.deserialize_identifier(GeneratedVisitor)
1908 }
1909 }
1910 struct GeneratedVisitor;
1911 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1912 type Value = BarrierMutation;
1913
1914 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1915 formatter.write_str("struct stream_plan.BarrierMutation")
1916 }
1917
1918 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierMutation, V::Error>
1919 where
1920 V: serde::de::MapAccess<'de>,
1921 {
1922 let mut mutation__ = None;
1923 while let Some(k) = map_.next_key()? {
1924 match k {
1925 GeneratedField::Add => {
1926 if mutation__.is_some() {
1927 return Err(serde::de::Error::duplicate_field("add"));
1928 }
1929 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Add)
1930;
1931 }
1932 GeneratedField::Stop => {
1933 if mutation__.is_some() {
1934 return Err(serde::de::Error::duplicate_field("stop"));
1935 }
1936 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Stop)
1937;
1938 }
1939 GeneratedField::Update => {
1940 if mutation__.is_some() {
1941 return Err(serde::de::Error::duplicate_field("update"));
1942 }
1943 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Update)
1944;
1945 }
1946 GeneratedField::Splits => {
1947 if mutation__.is_some() {
1948 return Err(serde::de::Error::duplicate_field("splits"));
1949 }
1950 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Splits)
1951;
1952 }
1953 GeneratedField::Pause => {
1954 if mutation__.is_some() {
1955 return Err(serde::de::Error::duplicate_field("pause"));
1956 }
1957 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Pause)
1958;
1959 }
1960 GeneratedField::Resume => {
1961 if mutation__.is_some() {
1962 return Err(serde::de::Error::duplicate_field("resume"));
1963 }
1964 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Resume)
1965;
1966 }
1967 GeneratedField::Throttle => {
1968 if mutation__.is_some() {
1969 return Err(serde::de::Error::duplicate_field("throttle"));
1970 }
1971 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Throttle)
1972;
1973 }
1974 GeneratedField::DropSubscriptions => {
1975 if mutation__.is_some() {
1976 return Err(serde::de::Error::duplicate_field("dropSubscriptions"));
1977 }
1978 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::DropSubscriptions)
1979;
1980 }
1981 GeneratedField::ConnectorPropsChange => {
1982 if mutation__.is_some() {
1983 return Err(serde::de::Error::duplicate_field("connectorPropsChange"));
1984 }
1985 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ConnectorPropsChange)
1986;
1987 }
1988 GeneratedField::StartFragmentBackfill => {
1989 if mutation__.is_some() {
1990 return Err(serde::de::Error::duplicate_field("startFragmentBackfill"));
1991 }
1992 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::StartFragmentBackfill)
1993;
1994 }
1995 GeneratedField::RefreshStart => {
1996 if mutation__.is_some() {
1997 return Err(serde::de::Error::duplicate_field("refreshStart"));
1998 }
1999 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::RefreshStart)
2000;
2001 }
2002 GeneratedField::LoadFinish => {
2003 if mutation__.is_some() {
2004 return Err(serde::de::Error::duplicate_field("loadFinish"));
2005 }
2006 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::LoadFinish)
2007;
2008 }
2009 GeneratedField::ListFinish => {
2010 if mutation__.is_some() {
2011 return Err(serde::de::Error::duplicate_field("listFinish"));
2012 }
2013 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ListFinish)
2014;
2015 }
2016 GeneratedField::ResetSource => {
2017 if mutation__.is_some() {
2018 return Err(serde::de::Error::duplicate_field("resetSource"));
2019 }
2020 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ResetSource)
2021;
2022 }
2023 GeneratedField::InjectSourceOffsets => {
2024 if mutation__.is_some() {
2025 return Err(serde::de::Error::duplicate_field("injectSourceOffsets"));
2026 }
2027 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::InjectSourceOffsets)
2028;
2029 }
2030 }
2031 }
2032 Ok(BarrierMutation {
2033 mutation: mutation__,
2034 })
2035 }
2036 }
2037 deserializer.deserialize_struct("stream_plan.BarrierMutation", FIELDS, GeneratedVisitor)
2038 }
2039}
2040impl serde::Serialize for BarrierRecvNode {
2041 #[allow(deprecated)]
2042 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2043 where
2044 S: serde::Serializer,
2045 {
2046 use serde::ser::SerializeStruct;
2047 let len = 0;
2048 let struct_ser = serializer.serialize_struct("stream_plan.BarrierRecvNode", len)?;
2049 struct_ser.end()
2050 }
2051}
2052impl<'de> serde::Deserialize<'de> for BarrierRecvNode {
2053 #[allow(deprecated)]
2054 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2055 where
2056 D: serde::Deserializer<'de>,
2057 {
2058 const FIELDS: &[&str] = &[
2059 ];
2060
2061 #[allow(clippy::enum_variant_names)]
2062 enum GeneratedField {
2063 }
2064 impl<'de> serde::Deserialize<'de> for GeneratedField {
2065 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2066 where
2067 D: serde::Deserializer<'de>,
2068 {
2069 struct GeneratedVisitor;
2070
2071 impl serde::de::Visitor<'_> for GeneratedVisitor {
2072 type Value = GeneratedField;
2073
2074 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2075 write!(formatter, "expected one of: {:?}", &FIELDS)
2076 }
2077
2078 #[allow(unused_variables)]
2079 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2080 where
2081 E: serde::de::Error,
2082 {
2083 Err(serde::de::Error::unknown_field(value, FIELDS))
2084 }
2085 }
2086 deserializer.deserialize_identifier(GeneratedVisitor)
2087 }
2088 }
2089 struct GeneratedVisitor;
2090 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2091 type Value = BarrierRecvNode;
2092
2093 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2094 formatter.write_str("struct stream_plan.BarrierRecvNode")
2095 }
2096
2097 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierRecvNode, V::Error>
2098 where
2099 V: serde::de::MapAccess<'de>,
2100 {
2101 while map_.next_key::<GeneratedField>()?.is_some() {
2102 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2103 }
2104 Ok(BarrierRecvNode {
2105 })
2106 }
2107 }
2108 deserializer.deserialize_struct("stream_plan.BarrierRecvNode", FIELDS, GeneratedVisitor)
2109 }
2110}
2111impl serde::Serialize for BatchPlanNode {
2112 #[allow(deprecated)]
2113 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2114 where
2115 S: serde::Serializer,
2116 {
2117 use serde::ser::SerializeStruct;
2118 let mut len = 0;
2119 if self.table_desc.is_some() {
2120 len += 1;
2121 }
2122 if !self.column_ids.is_empty() {
2123 len += 1;
2124 }
2125 let mut struct_ser = serializer.serialize_struct("stream_plan.BatchPlanNode", len)?;
2126 if let Some(v) = self.table_desc.as_ref() {
2127 struct_ser.serialize_field("tableDesc", v)?;
2128 }
2129 if !self.column_ids.is_empty() {
2130 struct_ser.serialize_field("columnIds", &self.column_ids)?;
2131 }
2132 struct_ser.end()
2133 }
2134}
2135impl<'de> serde::Deserialize<'de> for BatchPlanNode {
2136 #[allow(deprecated)]
2137 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2138 where
2139 D: serde::Deserializer<'de>,
2140 {
2141 const FIELDS: &[&str] = &[
2142 "table_desc",
2143 "tableDesc",
2144 "column_ids",
2145 "columnIds",
2146 ];
2147
2148 #[allow(clippy::enum_variant_names)]
2149 enum GeneratedField {
2150 TableDesc,
2151 ColumnIds,
2152 }
2153 impl<'de> serde::Deserialize<'de> for GeneratedField {
2154 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2155 where
2156 D: serde::Deserializer<'de>,
2157 {
2158 struct GeneratedVisitor;
2159
2160 impl serde::de::Visitor<'_> for GeneratedVisitor {
2161 type Value = GeneratedField;
2162
2163 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2164 write!(formatter, "expected one of: {:?}", &FIELDS)
2165 }
2166
2167 #[allow(unused_variables)]
2168 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2169 where
2170 E: serde::de::Error,
2171 {
2172 match value {
2173 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
2174 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
2175 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2176 }
2177 }
2178 }
2179 deserializer.deserialize_identifier(GeneratedVisitor)
2180 }
2181 }
2182 struct GeneratedVisitor;
2183 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2184 type Value = BatchPlanNode;
2185
2186 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2187 formatter.write_str("struct stream_plan.BatchPlanNode")
2188 }
2189
2190 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BatchPlanNode, V::Error>
2191 where
2192 V: serde::de::MapAccess<'de>,
2193 {
2194 let mut table_desc__ = None;
2195 let mut column_ids__ = None;
2196 while let Some(k) = map_.next_key()? {
2197 match k {
2198 GeneratedField::TableDesc => {
2199 if table_desc__.is_some() {
2200 return Err(serde::de::Error::duplicate_field("tableDesc"));
2201 }
2202 table_desc__ = map_.next_value()?;
2203 }
2204 GeneratedField::ColumnIds => {
2205 if column_ids__.is_some() {
2206 return Err(serde::de::Error::duplicate_field("columnIds"));
2207 }
2208 column_ids__ =
2209 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2210 .into_iter().map(|x| x.0).collect())
2211 ;
2212 }
2213 }
2214 }
2215 Ok(BatchPlanNode {
2216 table_desc: table_desc__,
2217 column_ids: column_ids__.unwrap_or_default(),
2218 })
2219 }
2220 }
2221 deserializer.deserialize_struct("stream_plan.BatchPlanNode", FIELDS, GeneratedVisitor)
2222 }
2223}
2224impl serde::Serialize for CdcFilterNode {
2225 #[allow(deprecated)]
2226 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2227 where
2228 S: serde::Serializer,
2229 {
2230 use serde::ser::SerializeStruct;
2231 let mut len = 0;
2232 if self.search_condition.is_some() {
2233 len += 1;
2234 }
2235 if self.upstream_source_id != 0 {
2236 len += 1;
2237 }
2238 let mut struct_ser = serializer.serialize_struct("stream_plan.CdcFilterNode", len)?;
2239 if let Some(v) = self.search_condition.as_ref() {
2240 struct_ser.serialize_field("searchCondition", v)?;
2241 }
2242 if self.upstream_source_id != 0 {
2243 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
2244 }
2245 struct_ser.end()
2246 }
2247}
2248impl<'de> serde::Deserialize<'de> for CdcFilterNode {
2249 #[allow(deprecated)]
2250 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2251 where
2252 D: serde::Deserializer<'de>,
2253 {
2254 const FIELDS: &[&str] = &[
2255 "search_condition",
2256 "searchCondition",
2257 "upstream_source_id",
2258 "upstreamSourceId",
2259 ];
2260
2261 #[allow(clippy::enum_variant_names)]
2262 enum GeneratedField {
2263 SearchCondition,
2264 UpstreamSourceId,
2265 }
2266 impl<'de> serde::Deserialize<'de> for GeneratedField {
2267 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2268 where
2269 D: serde::Deserializer<'de>,
2270 {
2271 struct GeneratedVisitor;
2272
2273 impl serde::de::Visitor<'_> for GeneratedVisitor {
2274 type Value = GeneratedField;
2275
2276 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2277 write!(formatter, "expected one of: {:?}", &FIELDS)
2278 }
2279
2280 #[allow(unused_variables)]
2281 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2282 where
2283 E: serde::de::Error,
2284 {
2285 match value {
2286 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
2287 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
2288 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2289 }
2290 }
2291 }
2292 deserializer.deserialize_identifier(GeneratedVisitor)
2293 }
2294 }
2295 struct GeneratedVisitor;
2296 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2297 type Value = CdcFilterNode;
2298
2299 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2300 formatter.write_str("struct stream_plan.CdcFilterNode")
2301 }
2302
2303 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcFilterNode, V::Error>
2304 where
2305 V: serde::de::MapAccess<'de>,
2306 {
2307 let mut search_condition__ = None;
2308 let mut upstream_source_id__ = None;
2309 while let Some(k) = map_.next_key()? {
2310 match k {
2311 GeneratedField::SearchCondition => {
2312 if search_condition__.is_some() {
2313 return Err(serde::de::Error::duplicate_field("searchCondition"));
2314 }
2315 search_condition__ = map_.next_value()?;
2316 }
2317 GeneratedField::UpstreamSourceId => {
2318 if upstream_source_id__.is_some() {
2319 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
2320 }
2321 upstream_source_id__ =
2322 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2323 ;
2324 }
2325 }
2326 }
2327 Ok(CdcFilterNode {
2328 search_condition: search_condition__,
2329 upstream_source_id: upstream_source_id__.unwrap_or_default(),
2330 })
2331 }
2332 }
2333 deserializer.deserialize_struct("stream_plan.CdcFilterNode", FIELDS, GeneratedVisitor)
2334 }
2335}
2336impl serde::Serialize for ChangeLogNode {
2337 #[allow(deprecated)]
2338 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2339 where
2340 S: serde::Serializer,
2341 {
2342 use serde::ser::SerializeStruct;
2343 let mut len = 0;
2344 if self.need_op {
2345 len += 1;
2346 }
2347 if !self.distribution_keys.is_empty() {
2348 len += 1;
2349 }
2350 let mut struct_ser = serializer.serialize_struct("stream_plan.ChangeLogNode", len)?;
2351 if self.need_op {
2352 struct_ser.serialize_field("needOp", &self.need_op)?;
2353 }
2354 if !self.distribution_keys.is_empty() {
2355 struct_ser.serialize_field("distributionKeys", &self.distribution_keys)?;
2356 }
2357 struct_ser.end()
2358 }
2359}
2360impl<'de> serde::Deserialize<'de> for ChangeLogNode {
2361 #[allow(deprecated)]
2362 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2363 where
2364 D: serde::Deserializer<'de>,
2365 {
2366 const FIELDS: &[&str] = &[
2367 "need_op",
2368 "needOp",
2369 "distribution_keys",
2370 "distributionKeys",
2371 ];
2372
2373 #[allow(clippy::enum_variant_names)]
2374 enum GeneratedField {
2375 NeedOp,
2376 DistributionKeys,
2377 }
2378 impl<'de> serde::Deserialize<'de> for GeneratedField {
2379 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2380 where
2381 D: serde::Deserializer<'de>,
2382 {
2383 struct GeneratedVisitor;
2384
2385 impl serde::de::Visitor<'_> for GeneratedVisitor {
2386 type Value = GeneratedField;
2387
2388 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2389 write!(formatter, "expected one of: {:?}", &FIELDS)
2390 }
2391
2392 #[allow(unused_variables)]
2393 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2394 where
2395 E: serde::de::Error,
2396 {
2397 match value {
2398 "needOp" | "need_op" => Ok(GeneratedField::NeedOp),
2399 "distributionKeys" | "distribution_keys" => Ok(GeneratedField::DistributionKeys),
2400 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2401 }
2402 }
2403 }
2404 deserializer.deserialize_identifier(GeneratedVisitor)
2405 }
2406 }
2407 struct GeneratedVisitor;
2408 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2409 type Value = ChangeLogNode;
2410
2411 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2412 formatter.write_str("struct stream_plan.ChangeLogNode")
2413 }
2414
2415 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ChangeLogNode, V::Error>
2416 where
2417 V: serde::de::MapAccess<'de>,
2418 {
2419 let mut need_op__ = None;
2420 let mut distribution_keys__ = None;
2421 while let Some(k) = map_.next_key()? {
2422 match k {
2423 GeneratedField::NeedOp => {
2424 if need_op__.is_some() {
2425 return Err(serde::de::Error::duplicate_field("needOp"));
2426 }
2427 need_op__ = Some(map_.next_value()?);
2428 }
2429 GeneratedField::DistributionKeys => {
2430 if distribution_keys__.is_some() {
2431 return Err(serde::de::Error::duplicate_field("distributionKeys"));
2432 }
2433 distribution_keys__ =
2434 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2435 .into_iter().map(|x| x.0).collect())
2436 ;
2437 }
2438 }
2439 }
2440 Ok(ChangeLogNode {
2441 need_op: need_op__.unwrap_or_default(),
2442 distribution_keys: distribution_keys__.unwrap_or_default(),
2443 })
2444 }
2445 }
2446 deserializer.deserialize_struct("stream_plan.ChangeLogNode", FIELDS, GeneratedVisitor)
2447 }
2448}
2449impl serde::Serialize for Columns {
2450 #[allow(deprecated)]
2451 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2452 where
2453 S: serde::Serializer,
2454 {
2455 use serde::ser::SerializeStruct;
2456 let mut len = 0;
2457 if !self.columns.is_empty() {
2458 len += 1;
2459 }
2460 let mut struct_ser = serializer.serialize_struct("stream_plan.Columns", len)?;
2461 if !self.columns.is_empty() {
2462 struct_ser.serialize_field("columns", &self.columns)?;
2463 }
2464 struct_ser.end()
2465 }
2466}
2467impl<'de> serde::Deserialize<'de> for Columns {
2468 #[allow(deprecated)]
2469 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2470 where
2471 D: serde::Deserializer<'de>,
2472 {
2473 const FIELDS: &[&str] = &[
2474 "columns",
2475 ];
2476
2477 #[allow(clippy::enum_variant_names)]
2478 enum GeneratedField {
2479 Columns,
2480 }
2481 impl<'de> serde::Deserialize<'de> for GeneratedField {
2482 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2483 where
2484 D: serde::Deserializer<'de>,
2485 {
2486 struct GeneratedVisitor;
2487
2488 impl serde::de::Visitor<'_> for GeneratedVisitor {
2489 type Value = GeneratedField;
2490
2491 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2492 write!(formatter, "expected one of: {:?}", &FIELDS)
2493 }
2494
2495 #[allow(unused_variables)]
2496 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2497 where
2498 E: serde::de::Error,
2499 {
2500 match value {
2501 "columns" => Ok(GeneratedField::Columns),
2502 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2503 }
2504 }
2505 }
2506 deserializer.deserialize_identifier(GeneratedVisitor)
2507 }
2508 }
2509 struct GeneratedVisitor;
2510 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2511 type Value = Columns;
2512
2513 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2514 formatter.write_str("struct stream_plan.Columns")
2515 }
2516
2517 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Columns, V::Error>
2518 where
2519 V: serde::de::MapAccess<'de>,
2520 {
2521 let mut columns__ = None;
2522 while let Some(k) = map_.next_key()? {
2523 match k {
2524 GeneratedField::Columns => {
2525 if columns__.is_some() {
2526 return Err(serde::de::Error::duplicate_field("columns"));
2527 }
2528 columns__ = Some(map_.next_value()?);
2529 }
2530 }
2531 }
2532 Ok(Columns {
2533 columns: columns__.unwrap_or_default(),
2534 })
2535 }
2536 }
2537 deserializer.deserialize_struct("stream_plan.Columns", FIELDS, GeneratedVisitor)
2538 }
2539}
2540impl serde::Serialize for ConnectorPropsChangeMutation {
2541 #[allow(deprecated)]
2542 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2543 where
2544 S: serde::Serializer,
2545 {
2546 use serde::ser::SerializeStruct;
2547 let mut len = 0;
2548 if !self.connector_props_infos.is_empty() {
2549 len += 1;
2550 }
2551 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation", len)?;
2552 if !self.connector_props_infos.is_empty() {
2553 struct_ser.serialize_field("connectorPropsInfos", &self.connector_props_infos)?;
2554 }
2555 struct_ser.end()
2556 }
2557}
2558impl<'de> serde::Deserialize<'de> for ConnectorPropsChangeMutation {
2559 #[allow(deprecated)]
2560 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2561 where
2562 D: serde::Deserializer<'de>,
2563 {
2564 const FIELDS: &[&str] = &[
2565 "connector_props_infos",
2566 "connectorPropsInfos",
2567 ];
2568
2569 #[allow(clippy::enum_variant_names)]
2570 enum GeneratedField {
2571 ConnectorPropsInfos,
2572 }
2573 impl<'de> serde::Deserialize<'de> for GeneratedField {
2574 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2575 where
2576 D: serde::Deserializer<'de>,
2577 {
2578 struct GeneratedVisitor;
2579
2580 impl serde::de::Visitor<'_> for GeneratedVisitor {
2581 type Value = GeneratedField;
2582
2583 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2584 write!(formatter, "expected one of: {:?}", &FIELDS)
2585 }
2586
2587 #[allow(unused_variables)]
2588 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2589 where
2590 E: serde::de::Error,
2591 {
2592 match value {
2593 "connectorPropsInfos" | "connector_props_infos" => Ok(GeneratedField::ConnectorPropsInfos),
2594 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2595 }
2596 }
2597 }
2598 deserializer.deserialize_identifier(GeneratedVisitor)
2599 }
2600 }
2601 struct GeneratedVisitor;
2602 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2603 type Value = ConnectorPropsChangeMutation;
2604
2605 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2606 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation")
2607 }
2608
2609 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectorPropsChangeMutation, V::Error>
2610 where
2611 V: serde::de::MapAccess<'de>,
2612 {
2613 let mut connector_props_infos__ = None;
2614 while let Some(k) = map_.next_key()? {
2615 match k {
2616 GeneratedField::ConnectorPropsInfos => {
2617 if connector_props_infos__.is_some() {
2618 return Err(serde::de::Error::duplicate_field("connectorPropsInfos"));
2619 }
2620 connector_props_infos__ = Some(
2621 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
2622 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
2623 );
2624 }
2625 }
2626 }
2627 Ok(ConnectorPropsChangeMutation {
2628 connector_props_infos: connector_props_infos__.unwrap_or_default(),
2629 })
2630 }
2631 }
2632 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation", FIELDS, GeneratedVisitor)
2633 }
2634}
2635impl serde::Serialize for connector_props_change_mutation::ConnectorPropsInfo {
2636 #[allow(deprecated)]
2637 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2638 where
2639 S: serde::Serializer,
2640 {
2641 use serde::ser::SerializeStruct;
2642 let mut len = 0;
2643 if !self.connector_props_info.is_empty() {
2644 len += 1;
2645 }
2646 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", len)?;
2647 if !self.connector_props_info.is_empty() {
2648 struct_ser.serialize_field("connectorPropsInfo", &self.connector_props_info)?;
2649 }
2650 struct_ser.end()
2651 }
2652}
2653impl<'de> serde::Deserialize<'de> for connector_props_change_mutation::ConnectorPropsInfo {
2654 #[allow(deprecated)]
2655 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2656 where
2657 D: serde::Deserializer<'de>,
2658 {
2659 const FIELDS: &[&str] = &[
2660 "connector_props_info",
2661 "connectorPropsInfo",
2662 ];
2663
2664 #[allow(clippy::enum_variant_names)]
2665 enum GeneratedField {
2666 ConnectorPropsInfo,
2667 }
2668 impl<'de> serde::Deserialize<'de> for GeneratedField {
2669 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2670 where
2671 D: serde::Deserializer<'de>,
2672 {
2673 struct GeneratedVisitor;
2674
2675 impl serde::de::Visitor<'_> for GeneratedVisitor {
2676 type Value = GeneratedField;
2677
2678 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2679 write!(formatter, "expected one of: {:?}", &FIELDS)
2680 }
2681
2682 #[allow(unused_variables)]
2683 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2684 where
2685 E: serde::de::Error,
2686 {
2687 match value {
2688 "connectorPropsInfo" | "connector_props_info" => Ok(GeneratedField::ConnectorPropsInfo),
2689 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2690 }
2691 }
2692 }
2693 deserializer.deserialize_identifier(GeneratedVisitor)
2694 }
2695 }
2696 struct GeneratedVisitor;
2697 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2698 type Value = connector_props_change_mutation::ConnectorPropsInfo;
2699
2700 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2701 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo")
2702 }
2703
2704 fn visit_map<V>(self, mut map_: V) -> std::result::Result<connector_props_change_mutation::ConnectorPropsInfo, V::Error>
2705 where
2706 V: serde::de::MapAccess<'de>,
2707 {
2708 let mut connector_props_info__ = None;
2709 while let Some(k) = map_.next_key()? {
2710 match k {
2711 GeneratedField::ConnectorPropsInfo => {
2712 if connector_props_info__.is_some() {
2713 return Err(serde::de::Error::duplicate_field("connectorPropsInfo"));
2714 }
2715 connector_props_info__ = Some(
2716 map_.next_value::<std::collections::HashMap<_, _>>()?
2717 );
2718 }
2719 }
2720 }
2721 Ok(connector_props_change_mutation::ConnectorPropsInfo {
2722 connector_props_info: connector_props_info__.unwrap_or_default(),
2723 })
2724 }
2725 }
2726 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", FIELDS, GeneratedVisitor)
2727 }
2728}
2729impl serde::Serialize for DedupNode {
2730 #[allow(deprecated)]
2731 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2732 where
2733 S: serde::Serializer,
2734 {
2735 use serde::ser::SerializeStruct;
2736 let mut len = 0;
2737 if self.state_table.is_some() {
2738 len += 1;
2739 }
2740 if !self.dedup_column_indices.is_empty() {
2741 len += 1;
2742 }
2743 let mut struct_ser = serializer.serialize_struct("stream_plan.DedupNode", len)?;
2744 if let Some(v) = self.state_table.as_ref() {
2745 struct_ser.serialize_field("stateTable", v)?;
2746 }
2747 if !self.dedup_column_indices.is_empty() {
2748 struct_ser.serialize_field("dedupColumnIndices", &self.dedup_column_indices)?;
2749 }
2750 struct_ser.end()
2751 }
2752}
2753impl<'de> serde::Deserialize<'de> for DedupNode {
2754 #[allow(deprecated)]
2755 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2756 where
2757 D: serde::Deserializer<'de>,
2758 {
2759 const FIELDS: &[&str] = &[
2760 "state_table",
2761 "stateTable",
2762 "dedup_column_indices",
2763 "dedupColumnIndices",
2764 ];
2765
2766 #[allow(clippy::enum_variant_names)]
2767 enum GeneratedField {
2768 StateTable,
2769 DedupColumnIndices,
2770 }
2771 impl<'de> serde::Deserialize<'de> for GeneratedField {
2772 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2773 where
2774 D: serde::Deserializer<'de>,
2775 {
2776 struct GeneratedVisitor;
2777
2778 impl serde::de::Visitor<'_> for GeneratedVisitor {
2779 type Value = GeneratedField;
2780
2781 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2782 write!(formatter, "expected one of: {:?}", &FIELDS)
2783 }
2784
2785 #[allow(unused_variables)]
2786 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2787 where
2788 E: serde::de::Error,
2789 {
2790 match value {
2791 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
2792 "dedupColumnIndices" | "dedup_column_indices" => Ok(GeneratedField::DedupColumnIndices),
2793 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2794 }
2795 }
2796 }
2797 deserializer.deserialize_identifier(GeneratedVisitor)
2798 }
2799 }
2800 struct GeneratedVisitor;
2801 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2802 type Value = DedupNode;
2803
2804 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2805 formatter.write_str("struct stream_plan.DedupNode")
2806 }
2807
2808 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DedupNode, V::Error>
2809 where
2810 V: serde::de::MapAccess<'de>,
2811 {
2812 let mut state_table__ = None;
2813 let mut dedup_column_indices__ = None;
2814 while let Some(k) = map_.next_key()? {
2815 match k {
2816 GeneratedField::StateTable => {
2817 if state_table__.is_some() {
2818 return Err(serde::de::Error::duplicate_field("stateTable"));
2819 }
2820 state_table__ = map_.next_value()?;
2821 }
2822 GeneratedField::DedupColumnIndices => {
2823 if dedup_column_indices__.is_some() {
2824 return Err(serde::de::Error::duplicate_field("dedupColumnIndices"));
2825 }
2826 dedup_column_indices__ =
2827 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2828 .into_iter().map(|x| x.0).collect())
2829 ;
2830 }
2831 }
2832 }
2833 Ok(DedupNode {
2834 state_table: state_table__,
2835 dedup_column_indices: dedup_column_indices__.unwrap_or_default(),
2836 })
2837 }
2838 }
2839 deserializer.deserialize_struct("stream_plan.DedupNode", FIELDS, GeneratedVisitor)
2840 }
2841}
2842impl serde::Serialize for DeltaExpression {
2843 #[allow(deprecated)]
2844 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2845 where
2846 S: serde::Serializer,
2847 {
2848 use serde::ser::SerializeStruct;
2849 let mut len = 0;
2850 if self.delta_type != 0 {
2851 len += 1;
2852 }
2853 if self.delta.is_some() {
2854 len += 1;
2855 }
2856 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaExpression", len)?;
2857 if self.delta_type != 0 {
2858 let v = super::expr::expr_node::Type::try_from(self.delta_type)
2859 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.delta_type)))?;
2860 struct_ser.serialize_field("deltaType", &v)?;
2861 }
2862 if let Some(v) = self.delta.as_ref() {
2863 struct_ser.serialize_field("delta", v)?;
2864 }
2865 struct_ser.end()
2866 }
2867}
2868impl<'de> serde::Deserialize<'de> for DeltaExpression {
2869 #[allow(deprecated)]
2870 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2871 where
2872 D: serde::Deserializer<'de>,
2873 {
2874 const FIELDS: &[&str] = &[
2875 "delta_type",
2876 "deltaType",
2877 "delta",
2878 ];
2879
2880 #[allow(clippy::enum_variant_names)]
2881 enum GeneratedField {
2882 DeltaType,
2883 Delta,
2884 }
2885 impl<'de> serde::Deserialize<'de> for GeneratedField {
2886 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2887 where
2888 D: serde::Deserializer<'de>,
2889 {
2890 struct GeneratedVisitor;
2891
2892 impl serde::de::Visitor<'_> for GeneratedVisitor {
2893 type Value = GeneratedField;
2894
2895 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2896 write!(formatter, "expected one of: {:?}", &FIELDS)
2897 }
2898
2899 #[allow(unused_variables)]
2900 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2901 where
2902 E: serde::de::Error,
2903 {
2904 match value {
2905 "deltaType" | "delta_type" => Ok(GeneratedField::DeltaType),
2906 "delta" => Ok(GeneratedField::Delta),
2907 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2908 }
2909 }
2910 }
2911 deserializer.deserialize_identifier(GeneratedVisitor)
2912 }
2913 }
2914 struct GeneratedVisitor;
2915 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2916 type Value = DeltaExpression;
2917
2918 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2919 formatter.write_str("struct stream_plan.DeltaExpression")
2920 }
2921
2922 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaExpression, V::Error>
2923 where
2924 V: serde::de::MapAccess<'de>,
2925 {
2926 let mut delta_type__ = None;
2927 let mut delta__ = None;
2928 while let Some(k) = map_.next_key()? {
2929 match k {
2930 GeneratedField::DeltaType => {
2931 if delta_type__.is_some() {
2932 return Err(serde::de::Error::duplicate_field("deltaType"));
2933 }
2934 delta_type__ = Some(map_.next_value::<super::expr::expr_node::Type>()? as i32);
2935 }
2936 GeneratedField::Delta => {
2937 if delta__.is_some() {
2938 return Err(serde::de::Error::duplicate_field("delta"));
2939 }
2940 delta__ = map_.next_value()?;
2941 }
2942 }
2943 }
2944 Ok(DeltaExpression {
2945 delta_type: delta_type__.unwrap_or_default(),
2946 delta: delta__,
2947 })
2948 }
2949 }
2950 deserializer.deserialize_struct("stream_plan.DeltaExpression", FIELDS, GeneratedVisitor)
2951 }
2952}
2953impl serde::Serialize for DeltaIndexJoinNode {
2954 #[allow(deprecated)]
2955 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2956 where
2957 S: serde::Serializer,
2958 {
2959 use serde::ser::SerializeStruct;
2960 let mut len = 0;
2961 if self.join_type != 0 {
2962 len += 1;
2963 }
2964 if !self.left_key.is_empty() {
2965 len += 1;
2966 }
2967 if !self.right_key.is_empty() {
2968 len += 1;
2969 }
2970 if self.condition.is_some() {
2971 len += 1;
2972 }
2973 if self.left_table_id != 0 {
2974 len += 1;
2975 }
2976 if self.right_table_id != 0 {
2977 len += 1;
2978 }
2979 if self.left_info.is_some() {
2980 len += 1;
2981 }
2982 if self.right_info.is_some() {
2983 len += 1;
2984 }
2985 if !self.output_indices.is_empty() {
2986 len += 1;
2987 }
2988 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaIndexJoinNode", len)?;
2989 if self.join_type != 0 {
2990 let v = super::plan_common::JoinType::try_from(self.join_type)
2991 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
2992 struct_ser.serialize_field("joinType", &v)?;
2993 }
2994 if !self.left_key.is_empty() {
2995 struct_ser.serialize_field("leftKey", &self.left_key)?;
2996 }
2997 if !self.right_key.is_empty() {
2998 struct_ser.serialize_field("rightKey", &self.right_key)?;
2999 }
3000 if let Some(v) = self.condition.as_ref() {
3001 struct_ser.serialize_field("condition", v)?;
3002 }
3003 if self.left_table_id != 0 {
3004 struct_ser.serialize_field("leftTableId", &self.left_table_id)?;
3005 }
3006 if self.right_table_id != 0 {
3007 struct_ser.serialize_field("rightTableId", &self.right_table_id)?;
3008 }
3009 if let Some(v) = self.left_info.as_ref() {
3010 struct_ser.serialize_field("leftInfo", v)?;
3011 }
3012 if let Some(v) = self.right_info.as_ref() {
3013 struct_ser.serialize_field("rightInfo", v)?;
3014 }
3015 if !self.output_indices.is_empty() {
3016 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
3017 }
3018 struct_ser.end()
3019 }
3020}
3021impl<'de> serde::Deserialize<'de> for DeltaIndexJoinNode {
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 "join_type",
3029 "joinType",
3030 "left_key",
3031 "leftKey",
3032 "right_key",
3033 "rightKey",
3034 "condition",
3035 "left_table_id",
3036 "leftTableId",
3037 "right_table_id",
3038 "rightTableId",
3039 "left_info",
3040 "leftInfo",
3041 "right_info",
3042 "rightInfo",
3043 "output_indices",
3044 "outputIndices",
3045 ];
3046
3047 #[allow(clippy::enum_variant_names)]
3048 enum GeneratedField {
3049 JoinType,
3050 LeftKey,
3051 RightKey,
3052 Condition,
3053 LeftTableId,
3054 RightTableId,
3055 LeftInfo,
3056 RightInfo,
3057 OutputIndices,
3058 }
3059 impl<'de> serde::Deserialize<'de> for GeneratedField {
3060 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3061 where
3062 D: serde::Deserializer<'de>,
3063 {
3064 struct GeneratedVisitor;
3065
3066 impl serde::de::Visitor<'_> for GeneratedVisitor {
3067 type Value = GeneratedField;
3068
3069 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3070 write!(formatter, "expected one of: {:?}", &FIELDS)
3071 }
3072
3073 #[allow(unused_variables)]
3074 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3075 where
3076 E: serde::de::Error,
3077 {
3078 match value {
3079 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
3080 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
3081 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
3082 "condition" => Ok(GeneratedField::Condition),
3083 "leftTableId" | "left_table_id" => Ok(GeneratedField::LeftTableId),
3084 "rightTableId" | "right_table_id" => Ok(GeneratedField::RightTableId),
3085 "leftInfo" | "left_info" => Ok(GeneratedField::LeftInfo),
3086 "rightInfo" | "right_info" => Ok(GeneratedField::RightInfo),
3087 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
3088 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3089 }
3090 }
3091 }
3092 deserializer.deserialize_identifier(GeneratedVisitor)
3093 }
3094 }
3095 struct GeneratedVisitor;
3096 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3097 type Value = DeltaIndexJoinNode;
3098
3099 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3100 formatter.write_str("struct stream_plan.DeltaIndexJoinNode")
3101 }
3102
3103 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaIndexJoinNode, V::Error>
3104 where
3105 V: serde::de::MapAccess<'de>,
3106 {
3107 let mut join_type__ = None;
3108 let mut left_key__ = None;
3109 let mut right_key__ = None;
3110 let mut condition__ = None;
3111 let mut left_table_id__ = None;
3112 let mut right_table_id__ = None;
3113 let mut left_info__ = None;
3114 let mut right_info__ = None;
3115 let mut output_indices__ = None;
3116 while let Some(k) = map_.next_key()? {
3117 match k {
3118 GeneratedField::JoinType => {
3119 if join_type__.is_some() {
3120 return Err(serde::de::Error::duplicate_field("joinType"));
3121 }
3122 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
3123 }
3124 GeneratedField::LeftKey => {
3125 if left_key__.is_some() {
3126 return Err(serde::de::Error::duplicate_field("leftKey"));
3127 }
3128 left_key__ =
3129 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3130 .into_iter().map(|x| x.0).collect())
3131 ;
3132 }
3133 GeneratedField::RightKey => {
3134 if right_key__.is_some() {
3135 return Err(serde::de::Error::duplicate_field("rightKey"));
3136 }
3137 right_key__ =
3138 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3139 .into_iter().map(|x| x.0).collect())
3140 ;
3141 }
3142 GeneratedField::Condition => {
3143 if condition__.is_some() {
3144 return Err(serde::de::Error::duplicate_field("condition"));
3145 }
3146 condition__ = map_.next_value()?;
3147 }
3148 GeneratedField::LeftTableId => {
3149 if left_table_id__.is_some() {
3150 return Err(serde::de::Error::duplicate_field("leftTableId"));
3151 }
3152 left_table_id__ =
3153 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3154 ;
3155 }
3156 GeneratedField::RightTableId => {
3157 if right_table_id__.is_some() {
3158 return Err(serde::de::Error::duplicate_field("rightTableId"));
3159 }
3160 right_table_id__ =
3161 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3162 ;
3163 }
3164 GeneratedField::LeftInfo => {
3165 if left_info__.is_some() {
3166 return Err(serde::de::Error::duplicate_field("leftInfo"));
3167 }
3168 left_info__ = map_.next_value()?;
3169 }
3170 GeneratedField::RightInfo => {
3171 if right_info__.is_some() {
3172 return Err(serde::de::Error::duplicate_field("rightInfo"));
3173 }
3174 right_info__ = map_.next_value()?;
3175 }
3176 GeneratedField::OutputIndices => {
3177 if output_indices__.is_some() {
3178 return Err(serde::de::Error::duplicate_field("outputIndices"));
3179 }
3180 output_indices__ =
3181 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3182 .into_iter().map(|x| x.0).collect())
3183 ;
3184 }
3185 }
3186 }
3187 Ok(DeltaIndexJoinNode {
3188 join_type: join_type__.unwrap_or_default(),
3189 left_key: left_key__.unwrap_or_default(),
3190 right_key: right_key__.unwrap_or_default(),
3191 condition: condition__,
3192 left_table_id: left_table_id__.unwrap_or_default(),
3193 right_table_id: right_table_id__.unwrap_or_default(),
3194 left_info: left_info__,
3195 right_info: right_info__,
3196 output_indices: output_indices__.unwrap_or_default(),
3197 })
3198 }
3199 }
3200 deserializer.deserialize_struct("stream_plan.DeltaIndexJoinNode", FIELDS, GeneratedVisitor)
3201 }
3202}
3203impl serde::Serialize for DispatchOutputMapping {
3204 #[allow(deprecated)]
3205 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3206 where
3207 S: serde::Serializer,
3208 {
3209 use serde::ser::SerializeStruct;
3210 let mut len = 0;
3211 if !self.indices.is_empty() {
3212 len += 1;
3213 }
3214 if !self.types.is_empty() {
3215 len += 1;
3216 }
3217 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping", len)?;
3218 if !self.indices.is_empty() {
3219 struct_ser.serialize_field("indices", &self.indices)?;
3220 }
3221 if !self.types.is_empty() {
3222 struct_ser.serialize_field("types", &self.types)?;
3223 }
3224 struct_ser.end()
3225 }
3226}
3227impl<'de> serde::Deserialize<'de> for DispatchOutputMapping {
3228 #[allow(deprecated)]
3229 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3230 where
3231 D: serde::Deserializer<'de>,
3232 {
3233 const FIELDS: &[&str] = &[
3234 "indices",
3235 "types",
3236 ];
3237
3238 #[allow(clippy::enum_variant_names)]
3239 enum GeneratedField {
3240 Indices,
3241 Types,
3242 }
3243 impl<'de> serde::Deserialize<'de> for GeneratedField {
3244 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3245 where
3246 D: serde::Deserializer<'de>,
3247 {
3248 struct GeneratedVisitor;
3249
3250 impl serde::de::Visitor<'_> for GeneratedVisitor {
3251 type Value = GeneratedField;
3252
3253 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3254 write!(formatter, "expected one of: {:?}", &FIELDS)
3255 }
3256
3257 #[allow(unused_variables)]
3258 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3259 where
3260 E: serde::de::Error,
3261 {
3262 match value {
3263 "indices" => Ok(GeneratedField::Indices),
3264 "types" => Ok(GeneratedField::Types),
3265 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3266 }
3267 }
3268 }
3269 deserializer.deserialize_identifier(GeneratedVisitor)
3270 }
3271 }
3272 struct GeneratedVisitor;
3273 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3274 type Value = DispatchOutputMapping;
3275
3276 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3277 formatter.write_str("struct stream_plan.DispatchOutputMapping")
3278 }
3279
3280 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchOutputMapping, V::Error>
3281 where
3282 V: serde::de::MapAccess<'de>,
3283 {
3284 let mut indices__ = None;
3285 let mut types__ = None;
3286 while let Some(k) = map_.next_key()? {
3287 match k {
3288 GeneratedField::Indices => {
3289 if indices__.is_some() {
3290 return Err(serde::de::Error::duplicate_field("indices"));
3291 }
3292 indices__ =
3293 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3294 .into_iter().map(|x| x.0).collect())
3295 ;
3296 }
3297 GeneratedField::Types => {
3298 if types__.is_some() {
3299 return Err(serde::de::Error::duplicate_field("types"));
3300 }
3301 types__ = Some(map_.next_value()?);
3302 }
3303 }
3304 }
3305 Ok(DispatchOutputMapping {
3306 indices: indices__.unwrap_or_default(),
3307 types: types__.unwrap_or_default(),
3308 })
3309 }
3310 }
3311 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping", FIELDS, GeneratedVisitor)
3312 }
3313}
3314impl serde::Serialize for dispatch_output_mapping::TypePair {
3315 #[allow(deprecated)]
3316 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3317 where
3318 S: serde::Serializer,
3319 {
3320 use serde::ser::SerializeStruct;
3321 let mut len = 0;
3322 if self.upstream.is_some() {
3323 len += 1;
3324 }
3325 if self.downstream.is_some() {
3326 len += 1;
3327 }
3328 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping.TypePair", len)?;
3329 if let Some(v) = self.upstream.as_ref() {
3330 struct_ser.serialize_field("upstream", v)?;
3331 }
3332 if let Some(v) = self.downstream.as_ref() {
3333 struct_ser.serialize_field("downstream", v)?;
3334 }
3335 struct_ser.end()
3336 }
3337}
3338impl<'de> serde::Deserialize<'de> for dispatch_output_mapping::TypePair {
3339 #[allow(deprecated)]
3340 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3341 where
3342 D: serde::Deserializer<'de>,
3343 {
3344 const FIELDS: &[&str] = &[
3345 "upstream",
3346 "downstream",
3347 ];
3348
3349 #[allow(clippy::enum_variant_names)]
3350 enum GeneratedField {
3351 Upstream,
3352 Downstream,
3353 }
3354 impl<'de> serde::Deserialize<'de> for GeneratedField {
3355 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3356 where
3357 D: serde::Deserializer<'de>,
3358 {
3359 struct GeneratedVisitor;
3360
3361 impl serde::de::Visitor<'_> for GeneratedVisitor {
3362 type Value = GeneratedField;
3363
3364 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3365 write!(formatter, "expected one of: {:?}", &FIELDS)
3366 }
3367
3368 #[allow(unused_variables)]
3369 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3370 where
3371 E: serde::de::Error,
3372 {
3373 match value {
3374 "upstream" => Ok(GeneratedField::Upstream),
3375 "downstream" => Ok(GeneratedField::Downstream),
3376 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3377 }
3378 }
3379 }
3380 deserializer.deserialize_identifier(GeneratedVisitor)
3381 }
3382 }
3383 struct GeneratedVisitor;
3384 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3385 type Value = dispatch_output_mapping::TypePair;
3386
3387 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3388 formatter.write_str("struct stream_plan.DispatchOutputMapping.TypePair")
3389 }
3390
3391 fn visit_map<V>(self, mut map_: V) -> std::result::Result<dispatch_output_mapping::TypePair, V::Error>
3392 where
3393 V: serde::de::MapAccess<'de>,
3394 {
3395 let mut upstream__ = None;
3396 let mut downstream__ = None;
3397 while let Some(k) = map_.next_key()? {
3398 match k {
3399 GeneratedField::Upstream => {
3400 if upstream__.is_some() {
3401 return Err(serde::de::Error::duplicate_field("upstream"));
3402 }
3403 upstream__ = map_.next_value()?;
3404 }
3405 GeneratedField::Downstream => {
3406 if downstream__.is_some() {
3407 return Err(serde::de::Error::duplicate_field("downstream"));
3408 }
3409 downstream__ = map_.next_value()?;
3410 }
3411 }
3412 }
3413 Ok(dispatch_output_mapping::TypePair {
3414 upstream: upstream__,
3415 downstream: downstream__,
3416 })
3417 }
3418 }
3419 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping.TypePair", FIELDS, GeneratedVisitor)
3420 }
3421}
3422impl serde::Serialize for DispatchStrategy {
3423 #[allow(deprecated)]
3424 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3425 where
3426 S: serde::Serializer,
3427 {
3428 use serde::ser::SerializeStruct;
3429 let mut len = 0;
3430 if self.r#type != 0 {
3431 len += 1;
3432 }
3433 if !self.dist_key_indices.is_empty() {
3434 len += 1;
3435 }
3436 if self.output_mapping.is_some() {
3437 len += 1;
3438 }
3439 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchStrategy", len)?;
3440 if self.r#type != 0 {
3441 let v = DispatcherType::try_from(self.r#type)
3442 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3443 struct_ser.serialize_field("type", &v)?;
3444 }
3445 if !self.dist_key_indices.is_empty() {
3446 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3447 }
3448 if let Some(v) = self.output_mapping.as_ref() {
3449 struct_ser.serialize_field("outputMapping", v)?;
3450 }
3451 struct_ser.end()
3452 }
3453}
3454impl<'de> serde::Deserialize<'de> for DispatchStrategy {
3455 #[allow(deprecated)]
3456 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3457 where
3458 D: serde::Deserializer<'de>,
3459 {
3460 const FIELDS: &[&str] = &[
3461 "type",
3462 "dist_key_indices",
3463 "distKeyIndices",
3464 "output_mapping",
3465 "outputMapping",
3466 ];
3467
3468 #[allow(clippy::enum_variant_names)]
3469 enum GeneratedField {
3470 Type,
3471 DistKeyIndices,
3472 OutputMapping,
3473 }
3474 impl<'de> serde::Deserialize<'de> for GeneratedField {
3475 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3476 where
3477 D: serde::Deserializer<'de>,
3478 {
3479 struct GeneratedVisitor;
3480
3481 impl serde::de::Visitor<'_> for GeneratedVisitor {
3482 type Value = GeneratedField;
3483
3484 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3485 write!(formatter, "expected one of: {:?}", &FIELDS)
3486 }
3487
3488 #[allow(unused_variables)]
3489 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3490 where
3491 E: serde::de::Error,
3492 {
3493 match value {
3494 "type" => Ok(GeneratedField::Type),
3495 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3496 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3497 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3498 }
3499 }
3500 }
3501 deserializer.deserialize_identifier(GeneratedVisitor)
3502 }
3503 }
3504 struct GeneratedVisitor;
3505 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3506 type Value = DispatchStrategy;
3507
3508 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3509 formatter.write_str("struct stream_plan.DispatchStrategy")
3510 }
3511
3512 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchStrategy, V::Error>
3513 where
3514 V: serde::de::MapAccess<'de>,
3515 {
3516 let mut r#type__ = None;
3517 let mut dist_key_indices__ = None;
3518 let mut output_mapping__ = None;
3519 while let Some(k) = map_.next_key()? {
3520 match k {
3521 GeneratedField::Type => {
3522 if r#type__.is_some() {
3523 return Err(serde::de::Error::duplicate_field("type"));
3524 }
3525 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3526 }
3527 GeneratedField::DistKeyIndices => {
3528 if dist_key_indices__.is_some() {
3529 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3530 }
3531 dist_key_indices__ =
3532 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3533 .into_iter().map(|x| x.0).collect())
3534 ;
3535 }
3536 GeneratedField::OutputMapping => {
3537 if output_mapping__.is_some() {
3538 return Err(serde::de::Error::duplicate_field("outputMapping"));
3539 }
3540 output_mapping__ = map_.next_value()?;
3541 }
3542 }
3543 }
3544 Ok(DispatchStrategy {
3545 r#type: r#type__.unwrap_or_default(),
3546 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3547 output_mapping: output_mapping__,
3548 })
3549 }
3550 }
3551 deserializer.deserialize_struct("stream_plan.DispatchStrategy", FIELDS, GeneratedVisitor)
3552 }
3553}
3554impl serde::Serialize for Dispatcher {
3555 #[allow(deprecated)]
3556 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3557 where
3558 S: serde::Serializer,
3559 {
3560 use serde::ser::SerializeStruct;
3561 let mut len = 0;
3562 if self.r#type != 0 {
3563 len += 1;
3564 }
3565 if !self.dist_key_indices.is_empty() {
3566 len += 1;
3567 }
3568 if self.output_mapping.is_some() {
3569 len += 1;
3570 }
3571 if self.hash_mapping.is_some() {
3572 len += 1;
3573 }
3574 if self.dispatcher_id != 0 {
3575 len += 1;
3576 }
3577 if !self.downstream_actor_id.is_empty() {
3578 len += 1;
3579 }
3580 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatcher", len)?;
3581 if self.r#type != 0 {
3582 let v = DispatcherType::try_from(self.r#type)
3583 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3584 struct_ser.serialize_field("type", &v)?;
3585 }
3586 if !self.dist_key_indices.is_empty() {
3587 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3588 }
3589 if let Some(v) = self.output_mapping.as_ref() {
3590 struct_ser.serialize_field("outputMapping", v)?;
3591 }
3592 if let Some(v) = self.hash_mapping.as_ref() {
3593 struct_ser.serialize_field("hashMapping", v)?;
3594 }
3595 if self.dispatcher_id != 0 {
3596 struct_ser.serialize_field("dispatcherId", &self.dispatcher_id)?;
3597 }
3598 if !self.downstream_actor_id.is_empty() {
3599 struct_ser.serialize_field("downstreamActorId", &self.downstream_actor_id)?;
3600 }
3601 struct_ser.end()
3602 }
3603}
3604impl<'de> serde::Deserialize<'de> for Dispatcher {
3605 #[allow(deprecated)]
3606 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3607 where
3608 D: serde::Deserializer<'de>,
3609 {
3610 const FIELDS: &[&str] = &[
3611 "type",
3612 "dist_key_indices",
3613 "distKeyIndices",
3614 "output_mapping",
3615 "outputMapping",
3616 "hash_mapping",
3617 "hashMapping",
3618 "dispatcher_id",
3619 "dispatcherId",
3620 "downstream_actor_id",
3621 "downstreamActorId",
3622 ];
3623
3624 #[allow(clippy::enum_variant_names)]
3625 enum GeneratedField {
3626 Type,
3627 DistKeyIndices,
3628 OutputMapping,
3629 HashMapping,
3630 DispatcherId,
3631 DownstreamActorId,
3632 }
3633 impl<'de> serde::Deserialize<'de> for GeneratedField {
3634 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3635 where
3636 D: serde::Deserializer<'de>,
3637 {
3638 struct GeneratedVisitor;
3639
3640 impl serde::de::Visitor<'_> for GeneratedVisitor {
3641 type Value = GeneratedField;
3642
3643 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3644 write!(formatter, "expected one of: {:?}", &FIELDS)
3645 }
3646
3647 #[allow(unused_variables)]
3648 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3649 where
3650 E: serde::de::Error,
3651 {
3652 match value {
3653 "type" => Ok(GeneratedField::Type),
3654 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3655 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3656 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
3657 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
3658 "downstreamActorId" | "downstream_actor_id" => Ok(GeneratedField::DownstreamActorId),
3659 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3660 }
3661 }
3662 }
3663 deserializer.deserialize_identifier(GeneratedVisitor)
3664 }
3665 }
3666 struct GeneratedVisitor;
3667 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3668 type Value = Dispatcher;
3669
3670 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3671 formatter.write_str("struct stream_plan.Dispatcher")
3672 }
3673
3674 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatcher, V::Error>
3675 where
3676 V: serde::de::MapAccess<'de>,
3677 {
3678 let mut r#type__ = None;
3679 let mut dist_key_indices__ = None;
3680 let mut output_mapping__ = None;
3681 let mut hash_mapping__ = None;
3682 let mut dispatcher_id__ = None;
3683 let mut downstream_actor_id__ = None;
3684 while let Some(k) = map_.next_key()? {
3685 match k {
3686 GeneratedField::Type => {
3687 if r#type__.is_some() {
3688 return Err(serde::de::Error::duplicate_field("type"));
3689 }
3690 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3691 }
3692 GeneratedField::DistKeyIndices => {
3693 if dist_key_indices__.is_some() {
3694 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3695 }
3696 dist_key_indices__ =
3697 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3698 .into_iter().map(|x| x.0).collect())
3699 ;
3700 }
3701 GeneratedField::OutputMapping => {
3702 if output_mapping__.is_some() {
3703 return Err(serde::de::Error::duplicate_field("outputMapping"));
3704 }
3705 output_mapping__ = map_.next_value()?;
3706 }
3707 GeneratedField::HashMapping => {
3708 if hash_mapping__.is_some() {
3709 return Err(serde::de::Error::duplicate_field("hashMapping"));
3710 }
3711 hash_mapping__ = map_.next_value()?;
3712 }
3713 GeneratedField::DispatcherId => {
3714 if dispatcher_id__.is_some() {
3715 return Err(serde::de::Error::duplicate_field("dispatcherId"));
3716 }
3717 dispatcher_id__ =
3718 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3719 ;
3720 }
3721 GeneratedField::DownstreamActorId => {
3722 if downstream_actor_id__.is_some() {
3723 return Err(serde::de::Error::duplicate_field("downstreamActorId"));
3724 }
3725 downstream_actor_id__ =
3726 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3727 .into_iter().map(|x| x.0).collect())
3728 ;
3729 }
3730 }
3731 }
3732 Ok(Dispatcher {
3733 r#type: r#type__.unwrap_or_default(),
3734 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3735 output_mapping: output_mapping__,
3736 hash_mapping: hash_mapping__,
3737 dispatcher_id: dispatcher_id__.unwrap_or_default(),
3738 downstream_actor_id: downstream_actor_id__.unwrap_or_default(),
3739 })
3740 }
3741 }
3742 deserializer.deserialize_struct("stream_plan.Dispatcher", FIELDS, GeneratedVisitor)
3743 }
3744}
3745impl serde::Serialize for DispatcherType {
3746 #[allow(deprecated)]
3747 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3748 where
3749 S: serde::Serializer,
3750 {
3751 let variant = match self {
3752 Self::Unspecified => "DISPATCHER_TYPE_UNSPECIFIED",
3753 Self::Hash => "DISPATCHER_TYPE_HASH",
3754 Self::Broadcast => "DISPATCHER_TYPE_BROADCAST",
3755 Self::Simple => "DISPATCHER_TYPE_SIMPLE",
3756 Self::NoShuffle => "DISPATCHER_TYPE_NO_SHUFFLE",
3757 };
3758 serializer.serialize_str(variant)
3759 }
3760}
3761impl<'de> serde::Deserialize<'de> for DispatcherType {
3762 #[allow(deprecated)]
3763 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3764 where
3765 D: serde::Deserializer<'de>,
3766 {
3767 const FIELDS: &[&str] = &[
3768 "DISPATCHER_TYPE_UNSPECIFIED",
3769 "DISPATCHER_TYPE_HASH",
3770 "DISPATCHER_TYPE_BROADCAST",
3771 "DISPATCHER_TYPE_SIMPLE",
3772 "DISPATCHER_TYPE_NO_SHUFFLE",
3773 ];
3774
3775 struct GeneratedVisitor;
3776
3777 impl serde::de::Visitor<'_> for GeneratedVisitor {
3778 type Value = DispatcherType;
3779
3780 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3781 write!(formatter, "expected one of: {:?}", &FIELDS)
3782 }
3783
3784 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3785 where
3786 E: serde::de::Error,
3787 {
3788 i32::try_from(v)
3789 .ok()
3790 .and_then(|x| x.try_into().ok())
3791 .ok_or_else(|| {
3792 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3793 })
3794 }
3795
3796 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3797 where
3798 E: serde::de::Error,
3799 {
3800 i32::try_from(v)
3801 .ok()
3802 .and_then(|x| x.try_into().ok())
3803 .ok_or_else(|| {
3804 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3805 })
3806 }
3807
3808 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3809 where
3810 E: serde::de::Error,
3811 {
3812 match value {
3813 "DISPATCHER_TYPE_UNSPECIFIED" => Ok(DispatcherType::Unspecified),
3814 "DISPATCHER_TYPE_HASH" => Ok(DispatcherType::Hash),
3815 "DISPATCHER_TYPE_BROADCAST" => Ok(DispatcherType::Broadcast),
3816 "DISPATCHER_TYPE_SIMPLE" => Ok(DispatcherType::Simple),
3817 "DISPATCHER_TYPE_NO_SHUFFLE" => Ok(DispatcherType::NoShuffle),
3818 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3819 }
3820 }
3821 }
3822 deserializer.deserialize_any(GeneratedVisitor)
3823 }
3824}
3825impl serde::Serialize for Dispatchers {
3826 #[allow(deprecated)]
3827 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3828 where
3829 S: serde::Serializer,
3830 {
3831 use serde::ser::SerializeStruct;
3832 let mut len = 0;
3833 if !self.dispatchers.is_empty() {
3834 len += 1;
3835 }
3836 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatchers", len)?;
3837 if !self.dispatchers.is_empty() {
3838 struct_ser.serialize_field("dispatchers", &self.dispatchers)?;
3839 }
3840 struct_ser.end()
3841 }
3842}
3843impl<'de> serde::Deserialize<'de> for Dispatchers {
3844 #[allow(deprecated)]
3845 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3846 where
3847 D: serde::Deserializer<'de>,
3848 {
3849 const FIELDS: &[&str] = &[
3850 "dispatchers",
3851 ];
3852
3853 #[allow(clippy::enum_variant_names)]
3854 enum GeneratedField {
3855 Dispatchers,
3856 }
3857 impl<'de> serde::Deserialize<'de> for GeneratedField {
3858 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3859 where
3860 D: serde::Deserializer<'de>,
3861 {
3862 struct GeneratedVisitor;
3863
3864 impl serde::de::Visitor<'_> for GeneratedVisitor {
3865 type Value = GeneratedField;
3866
3867 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3868 write!(formatter, "expected one of: {:?}", &FIELDS)
3869 }
3870
3871 #[allow(unused_variables)]
3872 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3873 where
3874 E: serde::de::Error,
3875 {
3876 match value {
3877 "dispatchers" => Ok(GeneratedField::Dispatchers),
3878 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3879 }
3880 }
3881 }
3882 deserializer.deserialize_identifier(GeneratedVisitor)
3883 }
3884 }
3885 struct GeneratedVisitor;
3886 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3887 type Value = Dispatchers;
3888
3889 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3890 formatter.write_str("struct stream_plan.Dispatchers")
3891 }
3892
3893 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatchers, V::Error>
3894 where
3895 V: serde::de::MapAccess<'de>,
3896 {
3897 let mut dispatchers__ = None;
3898 while let Some(k) = map_.next_key()? {
3899 match k {
3900 GeneratedField::Dispatchers => {
3901 if dispatchers__.is_some() {
3902 return Err(serde::de::Error::duplicate_field("dispatchers"));
3903 }
3904 dispatchers__ = Some(map_.next_value()?);
3905 }
3906 }
3907 }
3908 Ok(Dispatchers {
3909 dispatchers: dispatchers__.unwrap_or_default(),
3910 })
3911 }
3912 }
3913 deserializer.deserialize_struct("stream_plan.Dispatchers", FIELDS, GeneratedVisitor)
3914 }
3915}
3916impl serde::Serialize for DmlNode {
3917 #[allow(deprecated)]
3918 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3919 where
3920 S: serde::Serializer,
3921 {
3922 use serde::ser::SerializeStruct;
3923 let mut len = 0;
3924 if self.table_id != 0 {
3925 len += 1;
3926 }
3927 if self.table_version_id != 0 {
3928 len += 1;
3929 }
3930 if !self.column_descs.is_empty() {
3931 len += 1;
3932 }
3933 if self.rate_limit.is_some() {
3934 len += 1;
3935 }
3936 let mut struct_ser = serializer.serialize_struct("stream_plan.DmlNode", len)?;
3937 if self.table_id != 0 {
3938 struct_ser.serialize_field("tableId", &self.table_id)?;
3939 }
3940 if self.table_version_id != 0 {
3941 #[allow(clippy::needless_borrow)]
3942 #[allow(clippy::needless_borrows_for_generic_args)]
3943 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
3944 }
3945 if !self.column_descs.is_empty() {
3946 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
3947 }
3948 if let Some(v) = self.rate_limit.as_ref() {
3949 struct_ser.serialize_field("rateLimit", v)?;
3950 }
3951 struct_ser.end()
3952 }
3953}
3954impl<'de> serde::Deserialize<'de> for DmlNode {
3955 #[allow(deprecated)]
3956 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3957 where
3958 D: serde::Deserializer<'de>,
3959 {
3960 const FIELDS: &[&str] = &[
3961 "table_id",
3962 "tableId",
3963 "table_version_id",
3964 "tableVersionId",
3965 "column_descs",
3966 "columnDescs",
3967 "rate_limit",
3968 "rateLimit",
3969 ];
3970
3971 #[allow(clippy::enum_variant_names)]
3972 enum GeneratedField {
3973 TableId,
3974 TableVersionId,
3975 ColumnDescs,
3976 RateLimit,
3977 }
3978 impl<'de> serde::Deserialize<'de> for GeneratedField {
3979 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3980 where
3981 D: serde::Deserializer<'de>,
3982 {
3983 struct GeneratedVisitor;
3984
3985 impl serde::de::Visitor<'_> for GeneratedVisitor {
3986 type Value = GeneratedField;
3987
3988 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3989 write!(formatter, "expected one of: {:?}", &FIELDS)
3990 }
3991
3992 #[allow(unused_variables)]
3993 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3994 where
3995 E: serde::de::Error,
3996 {
3997 match value {
3998 "tableId" | "table_id" => Ok(GeneratedField::TableId),
3999 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
4000 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
4001 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
4002 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4003 }
4004 }
4005 }
4006 deserializer.deserialize_identifier(GeneratedVisitor)
4007 }
4008 }
4009 struct GeneratedVisitor;
4010 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4011 type Value = DmlNode;
4012
4013 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4014 formatter.write_str("struct stream_plan.DmlNode")
4015 }
4016
4017 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DmlNode, V::Error>
4018 where
4019 V: serde::de::MapAccess<'de>,
4020 {
4021 let mut table_id__ = None;
4022 let mut table_version_id__ = None;
4023 let mut column_descs__ = None;
4024 let mut rate_limit__ = None;
4025 while let Some(k) = map_.next_key()? {
4026 match k {
4027 GeneratedField::TableId => {
4028 if table_id__.is_some() {
4029 return Err(serde::de::Error::duplicate_field("tableId"));
4030 }
4031 table_id__ =
4032 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4033 ;
4034 }
4035 GeneratedField::TableVersionId => {
4036 if table_version_id__.is_some() {
4037 return Err(serde::de::Error::duplicate_field("tableVersionId"));
4038 }
4039 table_version_id__ =
4040 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4041 ;
4042 }
4043 GeneratedField::ColumnDescs => {
4044 if column_descs__.is_some() {
4045 return Err(serde::de::Error::duplicate_field("columnDescs"));
4046 }
4047 column_descs__ = Some(map_.next_value()?);
4048 }
4049 GeneratedField::RateLimit => {
4050 if rate_limit__.is_some() {
4051 return Err(serde::de::Error::duplicate_field("rateLimit"));
4052 }
4053 rate_limit__ =
4054 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4055 ;
4056 }
4057 }
4058 }
4059 Ok(DmlNode {
4060 table_id: table_id__.unwrap_or_default(),
4061 table_version_id: table_version_id__.unwrap_or_default(),
4062 column_descs: column_descs__.unwrap_or_default(),
4063 rate_limit: rate_limit__,
4064 })
4065 }
4066 }
4067 deserializer.deserialize_struct("stream_plan.DmlNode", FIELDS, GeneratedVisitor)
4068 }
4069}
4070impl serde::Serialize for DropSubscriptionsMutation {
4071 #[allow(deprecated)]
4072 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4073 where
4074 S: serde::Serializer,
4075 {
4076 use serde::ser::SerializeStruct;
4077 let mut len = 0;
4078 if !self.info.is_empty() {
4079 len += 1;
4080 }
4081 let mut struct_ser = serializer.serialize_struct("stream_plan.DropSubscriptionsMutation", len)?;
4082 if !self.info.is_empty() {
4083 struct_ser.serialize_field("info", &self.info)?;
4084 }
4085 struct_ser.end()
4086 }
4087}
4088impl<'de> serde::Deserialize<'de> for DropSubscriptionsMutation {
4089 #[allow(deprecated)]
4090 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4091 where
4092 D: serde::Deserializer<'de>,
4093 {
4094 const FIELDS: &[&str] = &[
4095 "info",
4096 ];
4097
4098 #[allow(clippy::enum_variant_names)]
4099 enum GeneratedField {
4100 Info,
4101 }
4102 impl<'de> serde::Deserialize<'de> for GeneratedField {
4103 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4104 where
4105 D: serde::Deserializer<'de>,
4106 {
4107 struct GeneratedVisitor;
4108
4109 impl serde::de::Visitor<'_> for GeneratedVisitor {
4110 type Value = GeneratedField;
4111
4112 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4113 write!(formatter, "expected one of: {:?}", &FIELDS)
4114 }
4115
4116 #[allow(unused_variables)]
4117 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4118 where
4119 E: serde::de::Error,
4120 {
4121 match value {
4122 "info" => Ok(GeneratedField::Info),
4123 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4124 }
4125 }
4126 }
4127 deserializer.deserialize_identifier(GeneratedVisitor)
4128 }
4129 }
4130 struct GeneratedVisitor;
4131 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4132 type Value = DropSubscriptionsMutation;
4133
4134 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4135 formatter.write_str("struct stream_plan.DropSubscriptionsMutation")
4136 }
4137
4138 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionsMutation, V::Error>
4139 where
4140 V: serde::de::MapAccess<'de>,
4141 {
4142 let mut info__ = None;
4143 while let Some(k) = map_.next_key()? {
4144 match k {
4145 GeneratedField::Info => {
4146 if info__.is_some() {
4147 return Err(serde::de::Error::duplicate_field("info"));
4148 }
4149 info__ = Some(map_.next_value()?);
4150 }
4151 }
4152 }
4153 Ok(DropSubscriptionsMutation {
4154 info: info__.unwrap_or_default(),
4155 })
4156 }
4157 }
4158 deserializer.deserialize_struct("stream_plan.DropSubscriptionsMutation", FIELDS, GeneratedVisitor)
4159 }
4160}
4161impl serde::Serialize for DynamicFilterNode {
4162 #[allow(deprecated)]
4163 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4164 where
4165 S: serde::Serializer,
4166 {
4167 use serde::ser::SerializeStruct;
4168 let mut len = 0;
4169 if self.left_key != 0 {
4170 len += 1;
4171 }
4172 if self.condition.is_some() {
4173 len += 1;
4174 }
4175 if self.left_table.is_some() {
4176 len += 1;
4177 }
4178 if self.right_table.is_some() {
4179 len += 1;
4180 }
4181 if self.condition_always_relax {
4182 len += 1;
4183 }
4184 if self.cleaned_by_watermark {
4185 len += 1;
4186 }
4187 let mut struct_ser = serializer.serialize_struct("stream_plan.DynamicFilterNode", len)?;
4188 if self.left_key != 0 {
4189 struct_ser.serialize_field("leftKey", &self.left_key)?;
4190 }
4191 if let Some(v) = self.condition.as_ref() {
4192 struct_ser.serialize_field("condition", v)?;
4193 }
4194 if let Some(v) = self.left_table.as_ref() {
4195 struct_ser.serialize_field("leftTable", v)?;
4196 }
4197 if let Some(v) = self.right_table.as_ref() {
4198 struct_ser.serialize_field("rightTable", v)?;
4199 }
4200 if self.condition_always_relax {
4201 struct_ser.serialize_field("conditionAlwaysRelax", &self.condition_always_relax)?;
4202 }
4203 if self.cleaned_by_watermark {
4204 struct_ser.serialize_field("cleanedByWatermark", &self.cleaned_by_watermark)?;
4205 }
4206 struct_ser.end()
4207 }
4208}
4209impl<'de> serde::Deserialize<'de> for DynamicFilterNode {
4210 #[allow(deprecated)]
4211 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4212 where
4213 D: serde::Deserializer<'de>,
4214 {
4215 const FIELDS: &[&str] = &[
4216 "left_key",
4217 "leftKey",
4218 "condition",
4219 "left_table",
4220 "leftTable",
4221 "right_table",
4222 "rightTable",
4223 "condition_always_relax",
4224 "conditionAlwaysRelax",
4225 "cleaned_by_watermark",
4226 "cleanedByWatermark",
4227 ];
4228
4229 #[allow(clippy::enum_variant_names)]
4230 enum GeneratedField {
4231 LeftKey,
4232 Condition,
4233 LeftTable,
4234 RightTable,
4235 ConditionAlwaysRelax,
4236 CleanedByWatermark,
4237 }
4238 impl<'de> serde::Deserialize<'de> for GeneratedField {
4239 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4240 where
4241 D: serde::Deserializer<'de>,
4242 {
4243 struct GeneratedVisitor;
4244
4245 impl serde::de::Visitor<'_> for GeneratedVisitor {
4246 type Value = GeneratedField;
4247
4248 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4249 write!(formatter, "expected one of: {:?}", &FIELDS)
4250 }
4251
4252 #[allow(unused_variables)]
4253 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4254 where
4255 E: serde::de::Error,
4256 {
4257 match value {
4258 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
4259 "condition" => Ok(GeneratedField::Condition),
4260 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
4261 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
4262 "conditionAlwaysRelax" | "condition_always_relax" => Ok(GeneratedField::ConditionAlwaysRelax),
4263 "cleanedByWatermark" | "cleaned_by_watermark" => Ok(GeneratedField::CleanedByWatermark),
4264 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4265 }
4266 }
4267 }
4268 deserializer.deserialize_identifier(GeneratedVisitor)
4269 }
4270 }
4271 struct GeneratedVisitor;
4272 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4273 type Value = DynamicFilterNode;
4274
4275 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4276 formatter.write_str("struct stream_plan.DynamicFilterNode")
4277 }
4278
4279 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DynamicFilterNode, V::Error>
4280 where
4281 V: serde::de::MapAccess<'de>,
4282 {
4283 let mut left_key__ = None;
4284 let mut condition__ = None;
4285 let mut left_table__ = None;
4286 let mut right_table__ = None;
4287 let mut condition_always_relax__ = None;
4288 let mut cleaned_by_watermark__ = None;
4289 while let Some(k) = map_.next_key()? {
4290 match k {
4291 GeneratedField::LeftKey => {
4292 if left_key__.is_some() {
4293 return Err(serde::de::Error::duplicate_field("leftKey"));
4294 }
4295 left_key__ =
4296 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4297 ;
4298 }
4299 GeneratedField::Condition => {
4300 if condition__.is_some() {
4301 return Err(serde::de::Error::duplicate_field("condition"));
4302 }
4303 condition__ = map_.next_value()?;
4304 }
4305 GeneratedField::LeftTable => {
4306 if left_table__.is_some() {
4307 return Err(serde::de::Error::duplicate_field("leftTable"));
4308 }
4309 left_table__ = map_.next_value()?;
4310 }
4311 GeneratedField::RightTable => {
4312 if right_table__.is_some() {
4313 return Err(serde::de::Error::duplicate_field("rightTable"));
4314 }
4315 right_table__ = map_.next_value()?;
4316 }
4317 GeneratedField::ConditionAlwaysRelax => {
4318 if condition_always_relax__.is_some() {
4319 return Err(serde::de::Error::duplicate_field("conditionAlwaysRelax"));
4320 }
4321 condition_always_relax__ = Some(map_.next_value()?);
4322 }
4323 GeneratedField::CleanedByWatermark => {
4324 if cleaned_by_watermark__.is_some() {
4325 return Err(serde::de::Error::duplicate_field("cleanedByWatermark"));
4326 }
4327 cleaned_by_watermark__ = Some(map_.next_value()?);
4328 }
4329 }
4330 }
4331 Ok(DynamicFilterNode {
4332 left_key: left_key__.unwrap_or_default(),
4333 condition: condition__,
4334 left_table: left_table__,
4335 right_table: right_table__,
4336 condition_always_relax: condition_always_relax__.unwrap_or_default(),
4337 cleaned_by_watermark: cleaned_by_watermark__.unwrap_or_default(),
4338 })
4339 }
4340 }
4341 deserializer.deserialize_struct("stream_plan.DynamicFilterNode", FIELDS, GeneratedVisitor)
4342 }
4343}
4344impl serde::Serialize for EowcGapFillNode {
4345 #[allow(deprecated)]
4346 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4347 where
4348 S: serde::Serializer,
4349 {
4350 use serde::ser::SerializeStruct;
4351 let mut len = 0;
4352 if self.time_column_index != 0 {
4353 len += 1;
4354 }
4355 if self.interval.is_some() {
4356 len += 1;
4357 }
4358 if !self.fill_columns.is_empty() {
4359 len += 1;
4360 }
4361 if !self.fill_strategies.is_empty() {
4362 len += 1;
4363 }
4364 if self.buffer_table.is_some() {
4365 len += 1;
4366 }
4367 if self.prev_row_table.is_some() {
4368 len += 1;
4369 }
4370 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcGapFillNode", len)?;
4371 if self.time_column_index != 0 {
4372 struct_ser.serialize_field("timeColumnIndex", &self.time_column_index)?;
4373 }
4374 if let Some(v) = self.interval.as_ref() {
4375 struct_ser.serialize_field("interval", v)?;
4376 }
4377 if !self.fill_columns.is_empty() {
4378 struct_ser.serialize_field("fillColumns", &self.fill_columns)?;
4379 }
4380 if !self.fill_strategies.is_empty() {
4381 struct_ser.serialize_field("fillStrategies", &self.fill_strategies)?;
4382 }
4383 if let Some(v) = self.buffer_table.as_ref() {
4384 struct_ser.serialize_field("bufferTable", v)?;
4385 }
4386 if let Some(v) = self.prev_row_table.as_ref() {
4387 struct_ser.serialize_field("prevRowTable", v)?;
4388 }
4389 struct_ser.end()
4390 }
4391}
4392impl<'de> serde::Deserialize<'de> for EowcGapFillNode {
4393 #[allow(deprecated)]
4394 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4395 where
4396 D: serde::Deserializer<'de>,
4397 {
4398 const FIELDS: &[&str] = &[
4399 "time_column_index",
4400 "timeColumnIndex",
4401 "interval",
4402 "fill_columns",
4403 "fillColumns",
4404 "fill_strategies",
4405 "fillStrategies",
4406 "buffer_table",
4407 "bufferTable",
4408 "prev_row_table",
4409 "prevRowTable",
4410 ];
4411
4412 #[allow(clippy::enum_variant_names)]
4413 enum GeneratedField {
4414 TimeColumnIndex,
4415 Interval,
4416 FillColumns,
4417 FillStrategies,
4418 BufferTable,
4419 PrevRowTable,
4420 }
4421 impl<'de> serde::Deserialize<'de> for GeneratedField {
4422 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4423 where
4424 D: serde::Deserializer<'de>,
4425 {
4426 struct GeneratedVisitor;
4427
4428 impl serde::de::Visitor<'_> for GeneratedVisitor {
4429 type Value = GeneratedField;
4430
4431 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4432 write!(formatter, "expected one of: {:?}", &FIELDS)
4433 }
4434
4435 #[allow(unused_variables)]
4436 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4437 where
4438 E: serde::de::Error,
4439 {
4440 match value {
4441 "timeColumnIndex" | "time_column_index" => Ok(GeneratedField::TimeColumnIndex),
4442 "interval" => Ok(GeneratedField::Interval),
4443 "fillColumns" | "fill_columns" => Ok(GeneratedField::FillColumns),
4444 "fillStrategies" | "fill_strategies" => Ok(GeneratedField::FillStrategies),
4445 "bufferTable" | "buffer_table" => Ok(GeneratedField::BufferTable),
4446 "prevRowTable" | "prev_row_table" => Ok(GeneratedField::PrevRowTable),
4447 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4448 }
4449 }
4450 }
4451 deserializer.deserialize_identifier(GeneratedVisitor)
4452 }
4453 }
4454 struct GeneratedVisitor;
4455 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4456 type Value = EowcGapFillNode;
4457
4458 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4459 formatter.write_str("struct stream_plan.EowcGapFillNode")
4460 }
4461
4462 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcGapFillNode, V::Error>
4463 where
4464 V: serde::de::MapAccess<'de>,
4465 {
4466 let mut time_column_index__ = None;
4467 let mut interval__ = None;
4468 let mut fill_columns__ = None;
4469 let mut fill_strategies__ = None;
4470 let mut buffer_table__ = None;
4471 let mut prev_row_table__ = None;
4472 while let Some(k) = map_.next_key()? {
4473 match k {
4474 GeneratedField::TimeColumnIndex => {
4475 if time_column_index__.is_some() {
4476 return Err(serde::de::Error::duplicate_field("timeColumnIndex"));
4477 }
4478 time_column_index__ =
4479 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4480 ;
4481 }
4482 GeneratedField::Interval => {
4483 if interval__.is_some() {
4484 return Err(serde::de::Error::duplicate_field("interval"));
4485 }
4486 interval__ = map_.next_value()?;
4487 }
4488 GeneratedField::FillColumns => {
4489 if fill_columns__.is_some() {
4490 return Err(serde::de::Error::duplicate_field("fillColumns"));
4491 }
4492 fill_columns__ =
4493 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4494 .into_iter().map(|x| x.0).collect())
4495 ;
4496 }
4497 GeneratedField::FillStrategies => {
4498 if fill_strategies__.is_some() {
4499 return Err(serde::de::Error::duplicate_field("fillStrategies"));
4500 }
4501 fill_strategies__ = Some(map_.next_value()?);
4502 }
4503 GeneratedField::BufferTable => {
4504 if buffer_table__.is_some() {
4505 return Err(serde::de::Error::duplicate_field("bufferTable"));
4506 }
4507 buffer_table__ = map_.next_value()?;
4508 }
4509 GeneratedField::PrevRowTable => {
4510 if prev_row_table__.is_some() {
4511 return Err(serde::de::Error::duplicate_field("prevRowTable"));
4512 }
4513 prev_row_table__ = map_.next_value()?;
4514 }
4515 }
4516 }
4517 Ok(EowcGapFillNode {
4518 time_column_index: time_column_index__.unwrap_or_default(),
4519 interval: interval__,
4520 fill_columns: fill_columns__.unwrap_or_default(),
4521 fill_strategies: fill_strategies__.unwrap_or_default(),
4522 buffer_table: buffer_table__,
4523 prev_row_table: prev_row_table__,
4524 })
4525 }
4526 }
4527 deserializer.deserialize_struct("stream_plan.EowcGapFillNode", FIELDS, GeneratedVisitor)
4528 }
4529}
4530impl serde::Serialize for EowcOverWindowNode {
4531 #[allow(deprecated)]
4532 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4533 where
4534 S: serde::Serializer,
4535 {
4536 use serde::ser::SerializeStruct;
4537 let mut len = 0;
4538 if !self.calls.is_empty() {
4539 len += 1;
4540 }
4541 if !self.partition_by.is_empty() {
4542 len += 1;
4543 }
4544 if !self.order_by.is_empty() {
4545 len += 1;
4546 }
4547 if self.state_table.is_some() {
4548 len += 1;
4549 }
4550 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcOverWindowNode", len)?;
4551 if !self.calls.is_empty() {
4552 struct_ser.serialize_field("calls", &self.calls)?;
4553 }
4554 if !self.partition_by.is_empty() {
4555 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
4556 }
4557 if !self.order_by.is_empty() {
4558 struct_ser.serialize_field("orderBy", &self.order_by)?;
4559 }
4560 if let Some(v) = self.state_table.as_ref() {
4561 struct_ser.serialize_field("stateTable", v)?;
4562 }
4563 struct_ser.end()
4564 }
4565}
4566impl<'de> serde::Deserialize<'de> for EowcOverWindowNode {
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 "calls",
4574 "partition_by",
4575 "partitionBy",
4576 "order_by",
4577 "orderBy",
4578 "state_table",
4579 "stateTable",
4580 ];
4581
4582 #[allow(clippy::enum_variant_names)]
4583 enum GeneratedField {
4584 Calls,
4585 PartitionBy,
4586 OrderBy,
4587 StateTable,
4588 }
4589 impl<'de> serde::Deserialize<'de> for GeneratedField {
4590 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4591 where
4592 D: serde::Deserializer<'de>,
4593 {
4594 struct GeneratedVisitor;
4595
4596 impl serde::de::Visitor<'_> for GeneratedVisitor {
4597 type Value = GeneratedField;
4598
4599 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4600 write!(formatter, "expected one of: {:?}", &FIELDS)
4601 }
4602
4603 #[allow(unused_variables)]
4604 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4605 where
4606 E: serde::de::Error,
4607 {
4608 match value {
4609 "calls" => Ok(GeneratedField::Calls),
4610 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
4611 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
4612 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
4613 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4614 }
4615 }
4616 }
4617 deserializer.deserialize_identifier(GeneratedVisitor)
4618 }
4619 }
4620 struct GeneratedVisitor;
4621 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4622 type Value = EowcOverWindowNode;
4623
4624 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4625 formatter.write_str("struct stream_plan.EowcOverWindowNode")
4626 }
4627
4628 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcOverWindowNode, V::Error>
4629 where
4630 V: serde::de::MapAccess<'de>,
4631 {
4632 let mut calls__ = None;
4633 let mut partition_by__ = None;
4634 let mut order_by__ = None;
4635 let mut state_table__ = None;
4636 while let Some(k) = map_.next_key()? {
4637 match k {
4638 GeneratedField::Calls => {
4639 if calls__.is_some() {
4640 return Err(serde::de::Error::duplicate_field("calls"));
4641 }
4642 calls__ = Some(map_.next_value()?);
4643 }
4644 GeneratedField::PartitionBy => {
4645 if partition_by__.is_some() {
4646 return Err(serde::de::Error::duplicate_field("partitionBy"));
4647 }
4648 partition_by__ =
4649 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4650 .into_iter().map(|x| x.0).collect())
4651 ;
4652 }
4653 GeneratedField::OrderBy => {
4654 if order_by__.is_some() {
4655 return Err(serde::de::Error::duplicate_field("orderBy"));
4656 }
4657 order_by__ = Some(map_.next_value()?);
4658 }
4659 GeneratedField::StateTable => {
4660 if state_table__.is_some() {
4661 return Err(serde::de::Error::duplicate_field("stateTable"));
4662 }
4663 state_table__ = map_.next_value()?;
4664 }
4665 }
4666 }
4667 Ok(EowcOverWindowNode {
4668 calls: calls__.unwrap_or_default(),
4669 partition_by: partition_by__.unwrap_or_default(),
4670 order_by: order_by__.unwrap_or_default(),
4671 state_table: state_table__,
4672 })
4673 }
4674 }
4675 deserializer.deserialize_struct("stream_plan.EowcOverWindowNode", FIELDS, GeneratedVisitor)
4676 }
4677}
4678impl serde::Serialize for ExchangeNode {
4679 #[allow(deprecated)]
4680 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4681 where
4682 S: serde::Serializer,
4683 {
4684 use serde::ser::SerializeStruct;
4685 let mut len = 0;
4686 if self.strategy.is_some() {
4687 len += 1;
4688 }
4689 let mut struct_ser = serializer.serialize_struct("stream_plan.ExchangeNode", len)?;
4690 if let Some(v) = self.strategy.as_ref() {
4691 struct_ser.serialize_field("strategy", v)?;
4692 }
4693 struct_ser.end()
4694 }
4695}
4696impl<'de> serde::Deserialize<'de> for ExchangeNode {
4697 #[allow(deprecated)]
4698 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4699 where
4700 D: serde::Deserializer<'de>,
4701 {
4702 const FIELDS: &[&str] = &[
4703 "strategy",
4704 ];
4705
4706 #[allow(clippy::enum_variant_names)]
4707 enum GeneratedField {
4708 Strategy,
4709 }
4710 impl<'de> serde::Deserialize<'de> for GeneratedField {
4711 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4712 where
4713 D: serde::Deserializer<'de>,
4714 {
4715 struct GeneratedVisitor;
4716
4717 impl serde::de::Visitor<'_> for GeneratedVisitor {
4718 type Value = GeneratedField;
4719
4720 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4721 write!(formatter, "expected one of: {:?}", &FIELDS)
4722 }
4723
4724 #[allow(unused_variables)]
4725 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4726 where
4727 E: serde::de::Error,
4728 {
4729 match value {
4730 "strategy" => Ok(GeneratedField::Strategy),
4731 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4732 }
4733 }
4734 }
4735 deserializer.deserialize_identifier(GeneratedVisitor)
4736 }
4737 }
4738 struct GeneratedVisitor;
4739 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4740 type Value = ExchangeNode;
4741
4742 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4743 formatter.write_str("struct stream_plan.ExchangeNode")
4744 }
4745
4746 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExchangeNode, V::Error>
4747 where
4748 V: serde::de::MapAccess<'de>,
4749 {
4750 let mut strategy__ = None;
4751 while let Some(k) = map_.next_key()? {
4752 match k {
4753 GeneratedField::Strategy => {
4754 if strategy__.is_some() {
4755 return Err(serde::de::Error::duplicate_field("strategy"));
4756 }
4757 strategy__ = map_.next_value()?;
4758 }
4759 }
4760 }
4761 Ok(ExchangeNode {
4762 strategy: strategy__,
4763 })
4764 }
4765 }
4766 deserializer.deserialize_struct("stream_plan.ExchangeNode", FIELDS, GeneratedVisitor)
4767 }
4768}
4769impl serde::Serialize for ExpandNode {
4770 #[allow(deprecated)]
4771 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4772 where
4773 S: serde::Serializer,
4774 {
4775 use serde::ser::SerializeStruct;
4776 let mut len = 0;
4777 if !self.column_subsets.is_empty() {
4778 len += 1;
4779 }
4780 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode", len)?;
4781 if !self.column_subsets.is_empty() {
4782 struct_ser.serialize_field("columnSubsets", &self.column_subsets)?;
4783 }
4784 struct_ser.end()
4785 }
4786}
4787impl<'de> serde::Deserialize<'de> for ExpandNode {
4788 #[allow(deprecated)]
4789 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4790 where
4791 D: serde::Deserializer<'de>,
4792 {
4793 const FIELDS: &[&str] = &[
4794 "column_subsets",
4795 "columnSubsets",
4796 ];
4797
4798 #[allow(clippy::enum_variant_names)]
4799 enum GeneratedField {
4800 ColumnSubsets,
4801 }
4802 impl<'de> serde::Deserialize<'de> for GeneratedField {
4803 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4804 where
4805 D: serde::Deserializer<'de>,
4806 {
4807 struct GeneratedVisitor;
4808
4809 impl serde::de::Visitor<'_> for GeneratedVisitor {
4810 type Value = GeneratedField;
4811
4812 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4813 write!(formatter, "expected one of: {:?}", &FIELDS)
4814 }
4815
4816 #[allow(unused_variables)]
4817 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4818 where
4819 E: serde::de::Error,
4820 {
4821 match value {
4822 "columnSubsets" | "column_subsets" => Ok(GeneratedField::ColumnSubsets),
4823 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4824 }
4825 }
4826 }
4827 deserializer.deserialize_identifier(GeneratedVisitor)
4828 }
4829 }
4830 struct GeneratedVisitor;
4831 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4832 type Value = ExpandNode;
4833
4834 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4835 formatter.write_str("struct stream_plan.ExpandNode")
4836 }
4837
4838 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpandNode, V::Error>
4839 where
4840 V: serde::de::MapAccess<'de>,
4841 {
4842 let mut column_subsets__ = None;
4843 while let Some(k) = map_.next_key()? {
4844 match k {
4845 GeneratedField::ColumnSubsets => {
4846 if column_subsets__.is_some() {
4847 return Err(serde::de::Error::duplicate_field("columnSubsets"));
4848 }
4849 column_subsets__ = Some(map_.next_value()?);
4850 }
4851 }
4852 }
4853 Ok(ExpandNode {
4854 column_subsets: column_subsets__.unwrap_or_default(),
4855 })
4856 }
4857 }
4858 deserializer.deserialize_struct("stream_plan.ExpandNode", FIELDS, GeneratedVisitor)
4859 }
4860}
4861impl serde::Serialize for expand_node::Subset {
4862 #[allow(deprecated)]
4863 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4864 where
4865 S: serde::Serializer,
4866 {
4867 use serde::ser::SerializeStruct;
4868 let mut len = 0;
4869 if !self.column_indices.is_empty() {
4870 len += 1;
4871 }
4872 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode.Subset", len)?;
4873 if !self.column_indices.is_empty() {
4874 struct_ser.serialize_field("columnIndices", &self.column_indices)?;
4875 }
4876 struct_ser.end()
4877 }
4878}
4879impl<'de> serde::Deserialize<'de> for expand_node::Subset {
4880 #[allow(deprecated)]
4881 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4882 where
4883 D: serde::Deserializer<'de>,
4884 {
4885 const FIELDS: &[&str] = &[
4886 "column_indices",
4887 "columnIndices",
4888 ];
4889
4890 #[allow(clippy::enum_variant_names)]
4891 enum GeneratedField {
4892 ColumnIndices,
4893 }
4894 impl<'de> serde::Deserialize<'de> for GeneratedField {
4895 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4896 where
4897 D: serde::Deserializer<'de>,
4898 {
4899 struct GeneratedVisitor;
4900
4901 impl serde::de::Visitor<'_> for GeneratedVisitor {
4902 type Value = GeneratedField;
4903
4904 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4905 write!(formatter, "expected one of: {:?}", &FIELDS)
4906 }
4907
4908 #[allow(unused_variables)]
4909 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4910 where
4911 E: serde::de::Error,
4912 {
4913 match value {
4914 "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
4915 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4916 }
4917 }
4918 }
4919 deserializer.deserialize_identifier(GeneratedVisitor)
4920 }
4921 }
4922 struct GeneratedVisitor;
4923 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4924 type Value = expand_node::Subset;
4925
4926 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4927 formatter.write_str("struct stream_plan.ExpandNode.Subset")
4928 }
4929
4930 fn visit_map<V>(self, mut map_: V) -> std::result::Result<expand_node::Subset, V::Error>
4931 where
4932 V: serde::de::MapAccess<'de>,
4933 {
4934 let mut column_indices__ = None;
4935 while let Some(k) = map_.next_key()? {
4936 match k {
4937 GeneratedField::ColumnIndices => {
4938 if column_indices__.is_some() {
4939 return Err(serde::de::Error::duplicate_field("columnIndices"));
4940 }
4941 column_indices__ =
4942 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4943 .into_iter().map(|x| x.0).collect())
4944 ;
4945 }
4946 }
4947 }
4948 Ok(expand_node::Subset {
4949 column_indices: column_indices__.unwrap_or_default(),
4950 })
4951 }
4952 }
4953 deserializer.deserialize_struct("stream_plan.ExpandNode.Subset", FIELDS, GeneratedVisitor)
4954 }
4955}
4956impl serde::Serialize for FilterNode {
4957 #[allow(deprecated)]
4958 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4959 where
4960 S: serde::Serializer,
4961 {
4962 use serde::ser::SerializeStruct;
4963 let mut len = 0;
4964 if self.search_condition.is_some() {
4965 len += 1;
4966 }
4967 let mut struct_ser = serializer.serialize_struct("stream_plan.FilterNode", len)?;
4968 if let Some(v) = self.search_condition.as_ref() {
4969 struct_ser.serialize_field("searchCondition", v)?;
4970 }
4971 struct_ser.end()
4972 }
4973}
4974impl<'de> serde::Deserialize<'de> for FilterNode {
4975 #[allow(deprecated)]
4976 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4977 where
4978 D: serde::Deserializer<'de>,
4979 {
4980 const FIELDS: &[&str] = &[
4981 "search_condition",
4982 "searchCondition",
4983 ];
4984
4985 #[allow(clippy::enum_variant_names)]
4986 enum GeneratedField {
4987 SearchCondition,
4988 }
4989 impl<'de> serde::Deserialize<'de> for GeneratedField {
4990 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4991 where
4992 D: serde::Deserializer<'de>,
4993 {
4994 struct GeneratedVisitor;
4995
4996 impl serde::de::Visitor<'_> for GeneratedVisitor {
4997 type Value = GeneratedField;
4998
4999 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5000 write!(formatter, "expected one of: {:?}", &FIELDS)
5001 }
5002
5003 #[allow(unused_variables)]
5004 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5005 where
5006 E: serde::de::Error,
5007 {
5008 match value {
5009 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
5010 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5011 }
5012 }
5013 }
5014 deserializer.deserialize_identifier(GeneratedVisitor)
5015 }
5016 }
5017 struct GeneratedVisitor;
5018 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5019 type Value = FilterNode;
5020
5021 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5022 formatter.write_str("struct stream_plan.FilterNode")
5023 }
5024
5025 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FilterNode, V::Error>
5026 where
5027 V: serde::de::MapAccess<'de>,
5028 {
5029 let mut search_condition__ = None;
5030 while let Some(k) = map_.next_key()? {
5031 match k {
5032 GeneratedField::SearchCondition => {
5033 if search_condition__.is_some() {
5034 return Err(serde::de::Error::duplicate_field("searchCondition"));
5035 }
5036 search_condition__ = map_.next_value()?;
5037 }
5038 }
5039 }
5040 Ok(FilterNode {
5041 search_condition: search_condition__,
5042 })
5043 }
5044 }
5045 deserializer.deserialize_struct("stream_plan.FilterNode", FIELDS, GeneratedVisitor)
5046 }
5047}
5048impl serde::Serialize for GapFillNode {
5049 #[allow(deprecated)]
5050 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5051 where
5052 S: serde::Serializer,
5053 {
5054 use serde::ser::SerializeStruct;
5055 let mut len = 0;
5056 if self.time_column_index != 0 {
5057 len += 1;
5058 }
5059 if self.interval.is_some() {
5060 len += 1;
5061 }
5062 if !self.fill_columns.is_empty() {
5063 len += 1;
5064 }
5065 if !self.fill_strategies.is_empty() {
5066 len += 1;
5067 }
5068 if self.state_table.is_some() {
5069 len += 1;
5070 }
5071 let mut struct_ser = serializer.serialize_struct("stream_plan.GapFillNode", len)?;
5072 if self.time_column_index != 0 {
5073 struct_ser.serialize_field("timeColumnIndex", &self.time_column_index)?;
5074 }
5075 if let Some(v) = self.interval.as_ref() {
5076 struct_ser.serialize_field("interval", v)?;
5077 }
5078 if !self.fill_columns.is_empty() {
5079 struct_ser.serialize_field("fillColumns", &self.fill_columns)?;
5080 }
5081 if !self.fill_strategies.is_empty() {
5082 struct_ser.serialize_field("fillStrategies", &self.fill_strategies)?;
5083 }
5084 if let Some(v) = self.state_table.as_ref() {
5085 struct_ser.serialize_field("stateTable", v)?;
5086 }
5087 struct_ser.end()
5088 }
5089}
5090impl<'de> serde::Deserialize<'de> for GapFillNode {
5091 #[allow(deprecated)]
5092 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5093 where
5094 D: serde::Deserializer<'de>,
5095 {
5096 const FIELDS: &[&str] = &[
5097 "time_column_index",
5098 "timeColumnIndex",
5099 "interval",
5100 "fill_columns",
5101 "fillColumns",
5102 "fill_strategies",
5103 "fillStrategies",
5104 "state_table",
5105 "stateTable",
5106 ];
5107
5108 #[allow(clippy::enum_variant_names)]
5109 enum GeneratedField {
5110 TimeColumnIndex,
5111 Interval,
5112 FillColumns,
5113 FillStrategies,
5114 StateTable,
5115 }
5116 impl<'de> serde::Deserialize<'de> for GeneratedField {
5117 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5118 where
5119 D: serde::Deserializer<'de>,
5120 {
5121 struct GeneratedVisitor;
5122
5123 impl serde::de::Visitor<'_> for GeneratedVisitor {
5124 type Value = GeneratedField;
5125
5126 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5127 write!(formatter, "expected one of: {:?}", &FIELDS)
5128 }
5129
5130 #[allow(unused_variables)]
5131 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5132 where
5133 E: serde::de::Error,
5134 {
5135 match value {
5136 "timeColumnIndex" | "time_column_index" => Ok(GeneratedField::TimeColumnIndex),
5137 "interval" => Ok(GeneratedField::Interval),
5138 "fillColumns" | "fill_columns" => Ok(GeneratedField::FillColumns),
5139 "fillStrategies" | "fill_strategies" => Ok(GeneratedField::FillStrategies),
5140 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
5141 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5142 }
5143 }
5144 }
5145 deserializer.deserialize_identifier(GeneratedVisitor)
5146 }
5147 }
5148 struct GeneratedVisitor;
5149 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5150 type Value = GapFillNode;
5151
5152 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5153 formatter.write_str("struct stream_plan.GapFillNode")
5154 }
5155
5156 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GapFillNode, V::Error>
5157 where
5158 V: serde::de::MapAccess<'de>,
5159 {
5160 let mut time_column_index__ = None;
5161 let mut interval__ = None;
5162 let mut fill_columns__ = None;
5163 let mut fill_strategies__ = None;
5164 let mut state_table__ = None;
5165 while let Some(k) = map_.next_key()? {
5166 match k {
5167 GeneratedField::TimeColumnIndex => {
5168 if time_column_index__.is_some() {
5169 return Err(serde::de::Error::duplicate_field("timeColumnIndex"));
5170 }
5171 time_column_index__ =
5172 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5173 ;
5174 }
5175 GeneratedField::Interval => {
5176 if interval__.is_some() {
5177 return Err(serde::de::Error::duplicate_field("interval"));
5178 }
5179 interval__ = map_.next_value()?;
5180 }
5181 GeneratedField::FillColumns => {
5182 if fill_columns__.is_some() {
5183 return Err(serde::de::Error::duplicate_field("fillColumns"));
5184 }
5185 fill_columns__ =
5186 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5187 .into_iter().map(|x| x.0).collect())
5188 ;
5189 }
5190 GeneratedField::FillStrategies => {
5191 if fill_strategies__.is_some() {
5192 return Err(serde::de::Error::duplicate_field("fillStrategies"));
5193 }
5194 fill_strategies__ = Some(map_.next_value()?);
5195 }
5196 GeneratedField::StateTable => {
5197 if state_table__.is_some() {
5198 return Err(serde::de::Error::duplicate_field("stateTable"));
5199 }
5200 state_table__ = map_.next_value()?;
5201 }
5202 }
5203 }
5204 Ok(GapFillNode {
5205 time_column_index: time_column_index__.unwrap_or_default(),
5206 interval: interval__,
5207 fill_columns: fill_columns__.unwrap_or_default(),
5208 fill_strategies: fill_strategies__.unwrap_or_default(),
5209 state_table: state_table__,
5210 })
5211 }
5212 }
5213 deserializer.deserialize_struct("stream_plan.GapFillNode", FIELDS, GeneratedVisitor)
5214 }
5215}
5216impl serde::Serialize for GlobalApproxPercentileNode {
5217 #[allow(deprecated)]
5218 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5219 where
5220 S: serde::Serializer,
5221 {
5222 use serde::ser::SerializeStruct;
5223 let mut len = 0;
5224 if self.base != 0. {
5225 len += 1;
5226 }
5227 if self.quantile != 0. {
5228 len += 1;
5229 }
5230 if self.bucket_state_table.is_some() {
5231 len += 1;
5232 }
5233 if self.count_state_table.is_some() {
5234 len += 1;
5235 }
5236 let mut struct_ser = serializer.serialize_struct("stream_plan.GlobalApproxPercentileNode", len)?;
5237 if self.base != 0. {
5238 struct_ser.serialize_field("base", &self.base)?;
5239 }
5240 if self.quantile != 0. {
5241 struct_ser.serialize_field("quantile", &self.quantile)?;
5242 }
5243 if let Some(v) = self.bucket_state_table.as_ref() {
5244 struct_ser.serialize_field("bucketStateTable", v)?;
5245 }
5246 if let Some(v) = self.count_state_table.as_ref() {
5247 struct_ser.serialize_field("countStateTable", v)?;
5248 }
5249 struct_ser.end()
5250 }
5251}
5252impl<'de> serde::Deserialize<'de> for GlobalApproxPercentileNode {
5253 #[allow(deprecated)]
5254 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5255 where
5256 D: serde::Deserializer<'de>,
5257 {
5258 const FIELDS: &[&str] = &[
5259 "base",
5260 "quantile",
5261 "bucket_state_table",
5262 "bucketStateTable",
5263 "count_state_table",
5264 "countStateTable",
5265 ];
5266
5267 #[allow(clippy::enum_variant_names)]
5268 enum GeneratedField {
5269 Base,
5270 Quantile,
5271 BucketStateTable,
5272 CountStateTable,
5273 }
5274 impl<'de> serde::Deserialize<'de> for GeneratedField {
5275 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5276 where
5277 D: serde::Deserializer<'de>,
5278 {
5279 struct GeneratedVisitor;
5280
5281 impl serde::de::Visitor<'_> for GeneratedVisitor {
5282 type Value = GeneratedField;
5283
5284 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5285 write!(formatter, "expected one of: {:?}", &FIELDS)
5286 }
5287
5288 #[allow(unused_variables)]
5289 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5290 where
5291 E: serde::de::Error,
5292 {
5293 match value {
5294 "base" => Ok(GeneratedField::Base),
5295 "quantile" => Ok(GeneratedField::Quantile),
5296 "bucketStateTable" | "bucket_state_table" => Ok(GeneratedField::BucketStateTable),
5297 "countStateTable" | "count_state_table" => Ok(GeneratedField::CountStateTable),
5298 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5299 }
5300 }
5301 }
5302 deserializer.deserialize_identifier(GeneratedVisitor)
5303 }
5304 }
5305 struct GeneratedVisitor;
5306 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5307 type Value = GlobalApproxPercentileNode;
5308
5309 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5310 formatter.write_str("struct stream_plan.GlobalApproxPercentileNode")
5311 }
5312
5313 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GlobalApproxPercentileNode, V::Error>
5314 where
5315 V: serde::de::MapAccess<'de>,
5316 {
5317 let mut base__ = None;
5318 let mut quantile__ = None;
5319 let mut bucket_state_table__ = None;
5320 let mut count_state_table__ = None;
5321 while let Some(k) = map_.next_key()? {
5322 match k {
5323 GeneratedField::Base => {
5324 if base__.is_some() {
5325 return Err(serde::de::Error::duplicate_field("base"));
5326 }
5327 base__ =
5328 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5329 ;
5330 }
5331 GeneratedField::Quantile => {
5332 if quantile__.is_some() {
5333 return Err(serde::de::Error::duplicate_field("quantile"));
5334 }
5335 quantile__ =
5336 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5337 ;
5338 }
5339 GeneratedField::BucketStateTable => {
5340 if bucket_state_table__.is_some() {
5341 return Err(serde::de::Error::duplicate_field("bucketStateTable"));
5342 }
5343 bucket_state_table__ = map_.next_value()?;
5344 }
5345 GeneratedField::CountStateTable => {
5346 if count_state_table__.is_some() {
5347 return Err(serde::de::Error::duplicate_field("countStateTable"));
5348 }
5349 count_state_table__ = map_.next_value()?;
5350 }
5351 }
5352 }
5353 Ok(GlobalApproxPercentileNode {
5354 base: base__.unwrap_or_default(),
5355 quantile: quantile__.unwrap_or_default(),
5356 bucket_state_table: bucket_state_table__,
5357 count_state_table: count_state_table__,
5358 })
5359 }
5360 }
5361 deserializer.deserialize_struct("stream_plan.GlobalApproxPercentileNode", FIELDS, GeneratedVisitor)
5362 }
5363}
5364impl serde::Serialize for GroupTopNNode {
5365 #[allow(deprecated)]
5366 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5367 where
5368 S: serde::Serializer,
5369 {
5370 use serde::ser::SerializeStruct;
5371 let mut len = 0;
5372 if self.limit != 0 {
5373 len += 1;
5374 }
5375 if self.offset != 0 {
5376 len += 1;
5377 }
5378 if !self.group_key.is_empty() {
5379 len += 1;
5380 }
5381 if self.table.is_some() {
5382 len += 1;
5383 }
5384 if !self.order_by.is_empty() {
5385 len += 1;
5386 }
5387 if self.with_ties {
5388 len += 1;
5389 }
5390 let mut struct_ser = serializer.serialize_struct("stream_plan.GroupTopNNode", len)?;
5391 if self.limit != 0 {
5392 #[allow(clippy::needless_borrow)]
5393 #[allow(clippy::needless_borrows_for_generic_args)]
5394 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
5395 }
5396 if self.offset != 0 {
5397 #[allow(clippy::needless_borrow)]
5398 #[allow(clippy::needless_borrows_for_generic_args)]
5399 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
5400 }
5401 if !self.group_key.is_empty() {
5402 struct_ser.serialize_field("groupKey", &self.group_key)?;
5403 }
5404 if let Some(v) = self.table.as_ref() {
5405 struct_ser.serialize_field("table", v)?;
5406 }
5407 if !self.order_by.is_empty() {
5408 struct_ser.serialize_field("orderBy", &self.order_by)?;
5409 }
5410 if self.with_ties {
5411 struct_ser.serialize_field("withTies", &self.with_ties)?;
5412 }
5413 struct_ser.end()
5414 }
5415}
5416impl<'de> serde::Deserialize<'de> for GroupTopNNode {
5417 #[allow(deprecated)]
5418 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5419 where
5420 D: serde::Deserializer<'de>,
5421 {
5422 const FIELDS: &[&str] = &[
5423 "limit",
5424 "offset",
5425 "group_key",
5426 "groupKey",
5427 "table",
5428 "order_by",
5429 "orderBy",
5430 "with_ties",
5431 "withTies",
5432 ];
5433
5434 #[allow(clippy::enum_variant_names)]
5435 enum GeneratedField {
5436 Limit,
5437 Offset,
5438 GroupKey,
5439 Table,
5440 OrderBy,
5441 WithTies,
5442 }
5443 impl<'de> serde::Deserialize<'de> for GeneratedField {
5444 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5445 where
5446 D: serde::Deserializer<'de>,
5447 {
5448 struct GeneratedVisitor;
5449
5450 impl serde::de::Visitor<'_> for GeneratedVisitor {
5451 type Value = GeneratedField;
5452
5453 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5454 write!(formatter, "expected one of: {:?}", &FIELDS)
5455 }
5456
5457 #[allow(unused_variables)]
5458 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5459 where
5460 E: serde::de::Error,
5461 {
5462 match value {
5463 "limit" => Ok(GeneratedField::Limit),
5464 "offset" => Ok(GeneratedField::Offset),
5465 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5466 "table" => Ok(GeneratedField::Table),
5467 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
5468 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
5469 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5470 }
5471 }
5472 }
5473 deserializer.deserialize_identifier(GeneratedVisitor)
5474 }
5475 }
5476 struct GeneratedVisitor;
5477 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5478 type Value = GroupTopNNode;
5479
5480 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5481 formatter.write_str("struct stream_plan.GroupTopNNode")
5482 }
5483
5484 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupTopNNode, V::Error>
5485 where
5486 V: serde::de::MapAccess<'de>,
5487 {
5488 let mut limit__ = None;
5489 let mut offset__ = None;
5490 let mut group_key__ = None;
5491 let mut table__ = None;
5492 let mut order_by__ = None;
5493 let mut with_ties__ = None;
5494 while let Some(k) = map_.next_key()? {
5495 match k {
5496 GeneratedField::Limit => {
5497 if limit__.is_some() {
5498 return Err(serde::de::Error::duplicate_field("limit"));
5499 }
5500 limit__ =
5501 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5502 ;
5503 }
5504 GeneratedField::Offset => {
5505 if offset__.is_some() {
5506 return Err(serde::de::Error::duplicate_field("offset"));
5507 }
5508 offset__ =
5509 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5510 ;
5511 }
5512 GeneratedField::GroupKey => {
5513 if group_key__.is_some() {
5514 return Err(serde::de::Error::duplicate_field("groupKey"));
5515 }
5516 group_key__ =
5517 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5518 .into_iter().map(|x| x.0).collect())
5519 ;
5520 }
5521 GeneratedField::Table => {
5522 if table__.is_some() {
5523 return Err(serde::de::Error::duplicate_field("table"));
5524 }
5525 table__ = map_.next_value()?;
5526 }
5527 GeneratedField::OrderBy => {
5528 if order_by__.is_some() {
5529 return Err(serde::de::Error::duplicate_field("orderBy"));
5530 }
5531 order_by__ = Some(map_.next_value()?);
5532 }
5533 GeneratedField::WithTies => {
5534 if with_ties__.is_some() {
5535 return Err(serde::de::Error::duplicate_field("withTies"));
5536 }
5537 with_ties__ = Some(map_.next_value()?);
5538 }
5539 }
5540 }
5541 Ok(GroupTopNNode {
5542 limit: limit__.unwrap_or_default(),
5543 offset: offset__.unwrap_or_default(),
5544 group_key: group_key__.unwrap_or_default(),
5545 table: table__,
5546 order_by: order_by__.unwrap_or_default(),
5547 with_ties: with_ties__.unwrap_or_default(),
5548 })
5549 }
5550 }
5551 deserializer.deserialize_struct("stream_plan.GroupTopNNode", FIELDS, GeneratedVisitor)
5552 }
5553}
5554impl serde::Serialize for HashAggNode {
5555 #[allow(deprecated)]
5556 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5557 where
5558 S: serde::Serializer,
5559 {
5560 use serde::ser::SerializeStruct;
5561 let mut len = 0;
5562 if !self.group_key.is_empty() {
5563 len += 1;
5564 }
5565 if !self.agg_calls.is_empty() {
5566 len += 1;
5567 }
5568 if !self.agg_call_states.is_empty() {
5569 len += 1;
5570 }
5571 if self.intermediate_state_table.is_some() {
5572 len += 1;
5573 }
5574 if self.is_append_only {
5575 len += 1;
5576 }
5577 if !self.distinct_dedup_tables.is_empty() {
5578 len += 1;
5579 }
5580 if self.row_count_index != 0 {
5581 len += 1;
5582 }
5583 if self.emit_on_window_close {
5584 len += 1;
5585 }
5586 if self.version != 0 {
5587 len += 1;
5588 }
5589 let mut struct_ser = serializer.serialize_struct("stream_plan.HashAggNode", len)?;
5590 if !self.group_key.is_empty() {
5591 struct_ser.serialize_field("groupKey", &self.group_key)?;
5592 }
5593 if !self.agg_calls.is_empty() {
5594 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
5595 }
5596 if !self.agg_call_states.is_empty() {
5597 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
5598 }
5599 if let Some(v) = self.intermediate_state_table.as_ref() {
5600 struct_ser.serialize_field("intermediateStateTable", v)?;
5601 }
5602 if self.is_append_only {
5603 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5604 }
5605 if !self.distinct_dedup_tables.is_empty() {
5606 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
5607 }
5608 if self.row_count_index != 0 {
5609 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
5610 }
5611 if self.emit_on_window_close {
5612 struct_ser.serialize_field("emitOnWindowClose", &self.emit_on_window_close)?;
5613 }
5614 if self.version != 0 {
5615 let v = AggNodeVersion::try_from(self.version)
5616 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
5617 struct_ser.serialize_field("version", &v)?;
5618 }
5619 struct_ser.end()
5620 }
5621}
5622impl<'de> serde::Deserialize<'de> for HashAggNode {
5623 #[allow(deprecated)]
5624 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5625 where
5626 D: serde::Deserializer<'de>,
5627 {
5628 const FIELDS: &[&str] = &[
5629 "group_key",
5630 "groupKey",
5631 "agg_calls",
5632 "aggCalls",
5633 "agg_call_states",
5634 "aggCallStates",
5635 "intermediate_state_table",
5636 "intermediateStateTable",
5637 "is_append_only",
5638 "isAppendOnly",
5639 "distinct_dedup_tables",
5640 "distinctDedupTables",
5641 "row_count_index",
5642 "rowCountIndex",
5643 "emit_on_window_close",
5644 "emitOnWindowClose",
5645 "version",
5646 ];
5647
5648 #[allow(clippy::enum_variant_names)]
5649 enum GeneratedField {
5650 GroupKey,
5651 AggCalls,
5652 AggCallStates,
5653 IntermediateStateTable,
5654 IsAppendOnly,
5655 DistinctDedupTables,
5656 RowCountIndex,
5657 EmitOnWindowClose,
5658 Version,
5659 }
5660 impl<'de> serde::Deserialize<'de> for GeneratedField {
5661 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5662 where
5663 D: serde::Deserializer<'de>,
5664 {
5665 struct GeneratedVisitor;
5666
5667 impl serde::de::Visitor<'_> for GeneratedVisitor {
5668 type Value = GeneratedField;
5669
5670 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5671 write!(formatter, "expected one of: {:?}", &FIELDS)
5672 }
5673
5674 #[allow(unused_variables)]
5675 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5676 where
5677 E: serde::de::Error,
5678 {
5679 match value {
5680 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5681 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
5682 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
5683 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
5684 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5685 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
5686 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
5687 "emitOnWindowClose" | "emit_on_window_close" => Ok(GeneratedField::EmitOnWindowClose),
5688 "version" => Ok(GeneratedField::Version),
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 = HashAggNode;
5699
5700 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5701 formatter.write_str("struct stream_plan.HashAggNode")
5702 }
5703
5704 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashAggNode, V::Error>
5705 where
5706 V: serde::de::MapAccess<'de>,
5707 {
5708 let mut group_key__ = None;
5709 let mut agg_calls__ = None;
5710 let mut agg_call_states__ = None;
5711 let mut intermediate_state_table__ = None;
5712 let mut is_append_only__ = None;
5713 let mut distinct_dedup_tables__ = None;
5714 let mut row_count_index__ = None;
5715 let mut emit_on_window_close__ = None;
5716 let mut version__ = None;
5717 while let Some(k) = map_.next_key()? {
5718 match k {
5719 GeneratedField::GroupKey => {
5720 if group_key__.is_some() {
5721 return Err(serde::de::Error::duplicate_field("groupKey"));
5722 }
5723 group_key__ =
5724 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5725 .into_iter().map(|x| x.0).collect())
5726 ;
5727 }
5728 GeneratedField::AggCalls => {
5729 if agg_calls__.is_some() {
5730 return Err(serde::de::Error::duplicate_field("aggCalls"));
5731 }
5732 agg_calls__ = Some(map_.next_value()?);
5733 }
5734 GeneratedField::AggCallStates => {
5735 if agg_call_states__.is_some() {
5736 return Err(serde::de::Error::duplicate_field("aggCallStates"));
5737 }
5738 agg_call_states__ = Some(map_.next_value()?);
5739 }
5740 GeneratedField::IntermediateStateTable => {
5741 if intermediate_state_table__.is_some() {
5742 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
5743 }
5744 intermediate_state_table__ = map_.next_value()?;
5745 }
5746 GeneratedField::IsAppendOnly => {
5747 if is_append_only__.is_some() {
5748 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
5749 }
5750 is_append_only__ = Some(map_.next_value()?);
5751 }
5752 GeneratedField::DistinctDedupTables => {
5753 if distinct_dedup_tables__.is_some() {
5754 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
5755 }
5756 distinct_dedup_tables__ = Some(
5757 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5758 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
5759 );
5760 }
5761 GeneratedField::RowCountIndex => {
5762 if row_count_index__.is_some() {
5763 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
5764 }
5765 row_count_index__ =
5766 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5767 ;
5768 }
5769 GeneratedField::EmitOnWindowClose => {
5770 if emit_on_window_close__.is_some() {
5771 return Err(serde::de::Error::duplicate_field("emitOnWindowClose"));
5772 }
5773 emit_on_window_close__ = Some(map_.next_value()?);
5774 }
5775 GeneratedField::Version => {
5776 if version__.is_some() {
5777 return Err(serde::de::Error::duplicate_field("version"));
5778 }
5779 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
5780 }
5781 }
5782 }
5783 Ok(HashAggNode {
5784 group_key: group_key__.unwrap_or_default(),
5785 agg_calls: agg_calls__.unwrap_or_default(),
5786 agg_call_states: agg_call_states__.unwrap_or_default(),
5787 intermediate_state_table: intermediate_state_table__,
5788 is_append_only: is_append_only__.unwrap_or_default(),
5789 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
5790 row_count_index: row_count_index__.unwrap_or_default(),
5791 emit_on_window_close: emit_on_window_close__.unwrap_or_default(),
5792 version: version__.unwrap_or_default(),
5793 })
5794 }
5795 }
5796 deserializer.deserialize_struct("stream_plan.HashAggNode", FIELDS, GeneratedVisitor)
5797 }
5798}
5799impl serde::Serialize for HashJoinNode {
5800 #[allow(deprecated)]
5801 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5802 where
5803 S: serde::Serializer,
5804 {
5805 use serde::ser::SerializeStruct;
5806 let mut len = 0;
5807 if self.join_type != 0 {
5808 len += 1;
5809 }
5810 if !self.left_key.is_empty() {
5811 len += 1;
5812 }
5813 if !self.right_key.is_empty() {
5814 len += 1;
5815 }
5816 if self.condition.is_some() {
5817 len += 1;
5818 }
5819 if self.left_table.is_some() {
5820 len += 1;
5821 }
5822 if self.right_table.is_some() {
5823 len += 1;
5824 }
5825 if self.left_degree_table.is_some() {
5826 len += 1;
5827 }
5828 if self.right_degree_table.is_some() {
5829 len += 1;
5830 }
5831 if !self.output_indices.is_empty() {
5832 len += 1;
5833 }
5834 if !self.left_deduped_input_pk_indices.is_empty() {
5835 len += 1;
5836 }
5837 if !self.right_deduped_input_pk_indices.is_empty() {
5838 len += 1;
5839 }
5840 if !self.null_safe.is_empty() {
5841 len += 1;
5842 }
5843 if self.is_append_only {
5844 len += 1;
5845 }
5846 if self.join_encoding_type != 0 {
5847 len += 1;
5848 }
5849 if self.watermark_handle_desc.is_some() {
5850 len += 1;
5851 }
5852 let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinNode", len)?;
5853 if self.join_type != 0 {
5854 let v = super::plan_common::JoinType::try_from(self.join_type)
5855 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
5856 struct_ser.serialize_field("joinType", &v)?;
5857 }
5858 if !self.left_key.is_empty() {
5859 struct_ser.serialize_field("leftKey", &self.left_key)?;
5860 }
5861 if !self.right_key.is_empty() {
5862 struct_ser.serialize_field("rightKey", &self.right_key)?;
5863 }
5864 if let Some(v) = self.condition.as_ref() {
5865 struct_ser.serialize_field("condition", v)?;
5866 }
5867 if let Some(v) = self.left_table.as_ref() {
5868 struct_ser.serialize_field("leftTable", v)?;
5869 }
5870 if let Some(v) = self.right_table.as_ref() {
5871 struct_ser.serialize_field("rightTable", v)?;
5872 }
5873 if let Some(v) = self.left_degree_table.as_ref() {
5874 struct_ser.serialize_field("leftDegreeTable", v)?;
5875 }
5876 if let Some(v) = self.right_degree_table.as_ref() {
5877 struct_ser.serialize_field("rightDegreeTable", v)?;
5878 }
5879 if !self.output_indices.is_empty() {
5880 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
5881 }
5882 if !self.left_deduped_input_pk_indices.is_empty() {
5883 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
5884 }
5885 if !self.right_deduped_input_pk_indices.is_empty() {
5886 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
5887 }
5888 if !self.null_safe.is_empty() {
5889 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
5890 }
5891 if self.is_append_only {
5892 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5893 }
5894 if self.join_encoding_type != 0 {
5895 let v = JoinEncodingType::try_from(self.join_encoding_type)
5896 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
5897 struct_ser.serialize_field("joinEncodingType", &v)?;
5898 }
5899 if let Some(v) = self.watermark_handle_desc.as_ref() {
5900 struct_ser.serialize_field("watermarkHandleDesc", v)?;
5901 }
5902 struct_ser.end()
5903 }
5904}
5905impl<'de> serde::Deserialize<'de> for HashJoinNode {
5906 #[allow(deprecated)]
5907 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5908 where
5909 D: serde::Deserializer<'de>,
5910 {
5911 const FIELDS: &[&str] = &[
5912 "join_type",
5913 "joinType",
5914 "left_key",
5915 "leftKey",
5916 "right_key",
5917 "rightKey",
5918 "condition",
5919 "left_table",
5920 "leftTable",
5921 "right_table",
5922 "rightTable",
5923 "left_degree_table",
5924 "leftDegreeTable",
5925 "right_degree_table",
5926 "rightDegreeTable",
5927 "output_indices",
5928 "outputIndices",
5929 "left_deduped_input_pk_indices",
5930 "leftDedupedInputPkIndices",
5931 "right_deduped_input_pk_indices",
5932 "rightDedupedInputPkIndices",
5933 "null_safe",
5934 "nullSafe",
5935 "is_append_only",
5936 "isAppendOnly",
5937 "join_encoding_type",
5938 "joinEncodingType",
5939 "watermark_handle_desc",
5940 "watermarkHandleDesc",
5941 ];
5942
5943 #[allow(clippy::enum_variant_names)]
5944 enum GeneratedField {
5945 JoinType,
5946 LeftKey,
5947 RightKey,
5948 Condition,
5949 LeftTable,
5950 RightTable,
5951 LeftDegreeTable,
5952 RightDegreeTable,
5953 OutputIndices,
5954 LeftDedupedInputPkIndices,
5955 RightDedupedInputPkIndices,
5956 NullSafe,
5957 IsAppendOnly,
5958 JoinEncodingType,
5959 WatermarkHandleDesc,
5960 }
5961 impl<'de> serde::Deserialize<'de> for GeneratedField {
5962 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5963 where
5964 D: serde::Deserializer<'de>,
5965 {
5966 struct GeneratedVisitor;
5967
5968 impl serde::de::Visitor<'_> for GeneratedVisitor {
5969 type Value = GeneratedField;
5970
5971 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5972 write!(formatter, "expected one of: {:?}", &FIELDS)
5973 }
5974
5975 #[allow(unused_variables)]
5976 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5977 where
5978 E: serde::de::Error,
5979 {
5980 match value {
5981 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
5982 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
5983 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
5984 "condition" => Ok(GeneratedField::Condition),
5985 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
5986 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
5987 "leftDegreeTable" | "left_degree_table" => Ok(GeneratedField::LeftDegreeTable),
5988 "rightDegreeTable" | "right_degree_table" => Ok(GeneratedField::RightDegreeTable),
5989 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
5990 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
5991 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
5992 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
5993 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5994 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
5995 "watermarkHandleDesc" | "watermark_handle_desc" => Ok(GeneratedField::WatermarkHandleDesc),
5996 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5997 }
5998 }
5999 }
6000 deserializer.deserialize_identifier(GeneratedVisitor)
6001 }
6002 }
6003 struct GeneratedVisitor;
6004 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6005 type Value = HashJoinNode;
6006
6007 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6008 formatter.write_str("struct stream_plan.HashJoinNode")
6009 }
6010
6011 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinNode, V::Error>
6012 where
6013 V: serde::de::MapAccess<'de>,
6014 {
6015 let mut join_type__ = None;
6016 let mut left_key__ = None;
6017 let mut right_key__ = None;
6018 let mut condition__ = None;
6019 let mut left_table__ = None;
6020 let mut right_table__ = None;
6021 let mut left_degree_table__ = None;
6022 let mut right_degree_table__ = None;
6023 let mut output_indices__ = None;
6024 let mut left_deduped_input_pk_indices__ = None;
6025 let mut right_deduped_input_pk_indices__ = None;
6026 let mut null_safe__ = None;
6027 let mut is_append_only__ = None;
6028 let mut join_encoding_type__ = None;
6029 let mut watermark_handle_desc__ = None;
6030 while let Some(k) = map_.next_key()? {
6031 match k {
6032 GeneratedField::JoinType => {
6033 if join_type__.is_some() {
6034 return Err(serde::de::Error::duplicate_field("joinType"));
6035 }
6036 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
6037 }
6038 GeneratedField::LeftKey => {
6039 if left_key__.is_some() {
6040 return Err(serde::de::Error::duplicate_field("leftKey"));
6041 }
6042 left_key__ =
6043 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6044 .into_iter().map(|x| x.0).collect())
6045 ;
6046 }
6047 GeneratedField::RightKey => {
6048 if right_key__.is_some() {
6049 return Err(serde::de::Error::duplicate_field("rightKey"));
6050 }
6051 right_key__ =
6052 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6053 .into_iter().map(|x| x.0).collect())
6054 ;
6055 }
6056 GeneratedField::Condition => {
6057 if condition__.is_some() {
6058 return Err(serde::de::Error::duplicate_field("condition"));
6059 }
6060 condition__ = map_.next_value()?;
6061 }
6062 GeneratedField::LeftTable => {
6063 if left_table__.is_some() {
6064 return Err(serde::de::Error::duplicate_field("leftTable"));
6065 }
6066 left_table__ = map_.next_value()?;
6067 }
6068 GeneratedField::RightTable => {
6069 if right_table__.is_some() {
6070 return Err(serde::de::Error::duplicate_field("rightTable"));
6071 }
6072 right_table__ = map_.next_value()?;
6073 }
6074 GeneratedField::LeftDegreeTable => {
6075 if left_degree_table__.is_some() {
6076 return Err(serde::de::Error::duplicate_field("leftDegreeTable"));
6077 }
6078 left_degree_table__ = map_.next_value()?;
6079 }
6080 GeneratedField::RightDegreeTable => {
6081 if right_degree_table__.is_some() {
6082 return Err(serde::de::Error::duplicate_field("rightDegreeTable"));
6083 }
6084 right_degree_table__ = map_.next_value()?;
6085 }
6086 GeneratedField::OutputIndices => {
6087 if output_indices__.is_some() {
6088 return Err(serde::de::Error::duplicate_field("outputIndices"));
6089 }
6090 output_indices__ =
6091 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6092 .into_iter().map(|x| x.0).collect())
6093 ;
6094 }
6095 GeneratedField::LeftDedupedInputPkIndices => {
6096 if left_deduped_input_pk_indices__.is_some() {
6097 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
6098 }
6099 left_deduped_input_pk_indices__ =
6100 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6101 .into_iter().map(|x| x.0).collect())
6102 ;
6103 }
6104 GeneratedField::RightDedupedInputPkIndices => {
6105 if right_deduped_input_pk_indices__.is_some() {
6106 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
6107 }
6108 right_deduped_input_pk_indices__ =
6109 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6110 .into_iter().map(|x| x.0).collect())
6111 ;
6112 }
6113 GeneratedField::NullSafe => {
6114 if null_safe__.is_some() {
6115 return Err(serde::de::Error::duplicate_field("nullSafe"));
6116 }
6117 null_safe__ = Some(map_.next_value()?);
6118 }
6119 GeneratedField::IsAppendOnly => {
6120 if is_append_only__.is_some() {
6121 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
6122 }
6123 is_append_only__ = Some(map_.next_value()?);
6124 }
6125 GeneratedField::JoinEncodingType => {
6126 if join_encoding_type__.is_some() {
6127 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
6128 }
6129 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
6130 }
6131 GeneratedField::WatermarkHandleDesc => {
6132 if watermark_handle_desc__.is_some() {
6133 return Err(serde::de::Error::duplicate_field("watermarkHandleDesc"));
6134 }
6135 watermark_handle_desc__ = map_.next_value()?;
6136 }
6137 }
6138 }
6139 Ok(HashJoinNode {
6140 join_type: join_type__.unwrap_or_default(),
6141 left_key: left_key__.unwrap_or_default(),
6142 right_key: right_key__.unwrap_or_default(),
6143 condition: condition__,
6144 left_table: left_table__,
6145 right_table: right_table__,
6146 left_degree_table: left_degree_table__,
6147 right_degree_table: right_degree_table__,
6148 output_indices: output_indices__.unwrap_or_default(),
6149 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
6150 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
6151 null_safe: null_safe__.unwrap_or_default(),
6152 is_append_only: is_append_only__.unwrap_or_default(),
6153 join_encoding_type: join_encoding_type__.unwrap_or_default(),
6154 watermark_handle_desc: watermark_handle_desc__,
6155 })
6156 }
6157 }
6158 deserializer.deserialize_struct("stream_plan.HashJoinNode", FIELDS, GeneratedVisitor)
6159 }
6160}
6161impl serde::Serialize for HashJoinWatermarkHandleDesc {
6162 #[allow(deprecated)]
6163 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6164 where
6165 S: serde::Serializer,
6166 {
6167 use serde::ser::SerializeStruct;
6168 let mut len = 0;
6169 if !self.watermark_indices_in_jk.is_empty() {
6170 len += 1;
6171 }
6172 if !self.inequality_pairs.is_empty() {
6173 len += 1;
6174 }
6175 let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinWatermarkHandleDesc", len)?;
6176 if !self.watermark_indices_in_jk.is_empty() {
6177 struct_ser.serialize_field("watermarkIndicesInJk", &self.watermark_indices_in_jk)?;
6178 }
6179 if !self.inequality_pairs.is_empty() {
6180 struct_ser.serialize_field("inequalityPairs", &self.inequality_pairs)?;
6181 }
6182 struct_ser.end()
6183 }
6184}
6185impl<'de> serde::Deserialize<'de> for HashJoinWatermarkHandleDesc {
6186 #[allow(deprecated)]
6187 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6188 where
6189 D: serde::Deserializer<'de>,
6190 {
6191 const FIELDS: &[&str] = &[
6192 "watermark_indices_in_jk",
6193 "watermarkIndicesInJk",
6194 "inequality_pairs",
6195 "inequalityPairs",
6196 ];
6197
6198 #[allow(clippy::enum_variant_names)]
6199 enum GeneratedField {
6200 WatermarkIndicesInJk,
6201 InequalityPairs,
6202 }
6203 impl<'de> serde::Deserialize<'de> for GeneratedField {
6204 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6205 where
6206 D: serde::Deserializer<'de>,
6207 {
6208 struct GeneratedVisitor;
6209
6210 impl serde::de::Visitor<'_> for GeneratedVisitor {
6211 type Value = GeneratedField;
6212
6213 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6214 write!(formatter, "expected one of: {:?}", &FIELDS)
6215 }
6216
6217 #[allow(unused_variables)]
6218 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6219 where
6220 E: serde::de::Error,
6221 {
6222 match value {
6223 "watermarkIndicesInJk" | "watermark_indices_in_jk" => Ok(GeneratedField::WatermarkIndicesInJk),
6224 "inequalityPairs" | "inequality_pairs" => Ok(GeneratedField::InequalityPairs),
6225 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6226 }
6227 }
6228 }
6229 deserializer.deserialize_identifier(GeneratedVisitor)
6230 }
6231 }
6232 struct GeneratedVisitor;
6233 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6234 type Value = HashJoinWatermarkHandleDesc;
6235
6236 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6237 formatter.write_str("struct stream_plan.HashJoinWatermarkHandleDesc")
6238 }
6239
6240 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinWatermarkHandleDesc, V::Error>
6241 where
6242 V: serde::de::MapAccess<'de>,
6243 {
6244 let mut watermark_indices_in_jk__ = None;
6245 let mut inequality_pairs__ = None;
6246 while let Some(k) = map_.next_key()? {
6247 match k {
6248 GeneratedField::WatermarkIndicesInJk => {
6249 if watermark_indices_in_jk__.is_some() {
6250 return Err(serde::de::Error::duplicate_field("watermarkIndicesInJk"));
6251 }
6252 watermark_indices_in_jk__ = Some(map_.next_value()?);
6253 }
6254 GeneratedField::InequalityPairs => {
6255 if inequality_pairs__.is_some() {
6256 return Err(serde::de::Error::duplicate_field("inequalityPairs"));
6257 }
6258 inequality_pairs__ = Some(map_.next_value()?);
6259 }
6260 }
6261 }
6262 Ok(HashJoinWatermarkHandleDesc {
6263 watermark_indices_in_jk: watermark_indices_in_jk__.unwrap_or_default(),
6264 inequality_pairs: inequality_pairs__.unwrap_or_default(),
6265 })
6266 }
6267 }
6268 deserializer.deserialize_struct("stream_plan.HashJoinWatermarkHandleDesc", FIELDS, GeneratedVisitor)
6269 }
6270}
6271impl serde::Serialize for HopWindowNode {
6272 #[allow(deprecated)]
6273 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6274 where
6275 S: serde::Serializer,
6276 {
6277 use serde::ser::SerializeStruct;
6278 let mut len = 0;
6279 if self.time_col != 0 {
6280 len += 1;
6281 }
6282 if self.window_slide.is_some() {
6283 len += 1;
6284 }
6285 if self.window_size.is_some() {
6286 len += 1;
6287 }
6288 if !self.output_indices.is_empty() {
6289 len += 1;
6290 }
6291 if !self.window_start_exprs.is_empty() {
6292 len += 1;
6293 }
6294 if !self.window_end_exprs.is_empty() {
6295 len += 1;
6296 }
6297 let mut struct_ser = serializer.serialize_struct("stream_plan.HopWindowNode", len)?;
6298 if self.time_col != 0 {
6299 struct_ser.serialize_field("timeCol", &self.time_col)?;
6300 }
6301 if let Some(v) = self.window_slide.as_ref() {
6302 struct_ser.serialize_field("windowSlide", v)?;
6303 }
6304 if let Some(v) = self.window_size.as_ref() {
6305 struct_ser.serialize_field("windowSize", v)?;
6306 }
6307 if !self.output_indices.is_empty() {
6308 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
6309 }
6310 if !self.window_start_exprs.is_empty() {
6311 struct_ser.serialize_field("windowStartExprs", &self.window_start_exprs)?;
6312 }
6313 if !self.window_end_exprs.is_empty() {
6314 struct_ser.serialize_field("windowEndExprs", &self.window_end_exprs)?;
6315 }
6316 struct_ser.end()
6317 }
6318}
6319impl<'de> serde::Deserialize<'de> for HopWindowNode {
6320 #[allow(deprecated)]
6321 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6322 where
6323 D: serde::Deserializer<'de>,
6324 {
6325 const FIELDS: &[&str] = &[
6326 "time_col",
6327 "timeCol",
6328 "window_slide",
6329 "windowSlide",
6330 "window_size",
6331 "windowSize",
6332 "output_indices",
6333 "outputIndices",
6334 "window_start_exprs",
6335 "windowStartExprs",
6336 "window_end_exprs",
6337 "windowEndExprs",
6338 ];
6339
6340 #[allow(clippy::enum_variant_names)]
6341 enum GeneratedField {
6342 TimeCol,
6343 WindowSlide,
6344 WindowSize,
6345 OutputIndices,
6346 WindowStartExprs,
6347 WindowEndExprs,
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 serde::de::Visitor<'_> 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 "timeCol" | "time_col" => Ok(GeneratedField::TimeCol),
6370 "windowSlide" | "window_slide" => Ok(GeneratedField::WindowSlide),
6371 "windowSize" | "window_size" => Ok(GeneratedField::WindowSize),
6372 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
6373 "windowStartExprs" | "window_start_exprs" => Ok(GeneratedField::WindowStartExprs),
6374 "windowEndExprs" | "window_end_exprs" => Ok(GeneratedField::WindowEndExprs),
6375 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6376 }
6377 }
6378 }
6379 deserializer.deserialize_identifier(GeneratedVisitor)
6380 }
6381 }
6382 struct GeneratedVisitor;
6383 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6384 type Value = HopWindowNode;
6385
6386 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6387 formatter.write_str("struct stream_plan.HopWindowNode")
6388 }
6389
6390 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HopWindowNode, V::Error>
6391 where
6392 V: serde::de::MapAccess<'de>,
6393 {
6394 let mut time_col__ = None;
6395 let mut window_slide__ = None;
6396 let mut window_size__ = None;
6397 let mut output_indices__ = None;
6398 let mut window_start_exprs__ = None;
6399 let mut window_end_exprs__ = None;
6400 while let Some(k) = map_.next_key()? {
6401 match k {
6402 GeneratedField::TimeCol => {
6403 if time_col__.is_some() {
6404 return Err(serde::de::Error::duplicate_field("timeCol"));
6405 }
6406 time_col__ =
6407 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6408 ;
6409 }
6410 GeneratedField::WindowSlide => {
6411 if window_slide__.is_some() {
6412 return Err(serde::de::Error::duplicate_field("windowSlide"));
6413 }
6414 window_slide__ = map_.next_value()?;
6415 }
6416 GeneratedField::WindowSize => {
6417 if window_size__.is_some() {
6418 return Err(serde::de::Error::duplicate_field("windowSize"));
6419 }
6420 window_size__ = map_.next_value()?;
6421 }
6422 GeneratedField::OutputIndices => {
6423 if output_indices__.is_some() {
6424 return Err(serde::de::Error::duplicate_field("outputIndices"));
6425 }
6426 output_indices__ =
6427 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6428 .into_iter().map(|x| x.0).collect())
6429 ;
6430 }
6431 GeneratedField::WindowStartExprs => {
6432 if window_start_exprs__.is_some() {
6433 return Err(serde::de::Error::duplicate_field("windowStartExprs"));
6434 }
6435 window_start_exprs__ = Some(map_.next_value()?);
6436 }
6437 GeneratedField::WindowEndExprs => {
6438 if window_end_exprs__.is_some() {
6439 return Err(serde::de::Error::duplicate_field("windowEndExprs"));
6440 }
6441 window_end_exprs__ = Some(map_.next_value()?);
6442 }
6443 }
6444 }
6445 Ok(HopWindowNode {
6446 time_col: time_col__.unwrap_or_default(),
6447 window_slide: window_slide__,
6448 window_size: window_size__,
6449 output_indices: output_indices__.unwrap_or_default(),
6450 window_start_exprs: window_start_exprs__.unwrap_or_default(),
6451 window_end_exprs: window_end_exprs__.unwrap_or_default(),
6452 })
6453 }
6454 }
6455 deserializer.deserialize_struct("stream_plan.HopWindowNode", FIELDS, GeneratedVisitor)
6456 }
6457}
6458impl serde::Serialize for InequalityPair {
6459 #[allow(deprecated)]
6460 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6461 where
6462 S: serde::Serializer,
6463 {
6464 use serde::ser::SerializeStruct;
6465 let mut len = 0;
6466 if self.key_required_larger != 0 {
6467 len += 1;
6468 }
6469 if self.key_required_smaller != 0 {
6470 len += 1;
6471 }
6472 if self.clean_state {
6473 len += 1;
6474 }
6475 if self.delta_expression.is_some() {
6476 len += 1;
6477 }
6478 let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPair", len)?;
6479 if self.key_required_larger != 0 {
6480 struct_ser.serialize_field("keyRequiredLarger", &self.key_required_larger)?;
6481 }
6482 if self.key_required_smaller != 0 {
6483 struct_ser.serialize_field("keyRequiredSmaller", &self.key_required_smaller)?;
6484 }
6485 if self.clean_state {
6486 struct_ser.serialize_field("cleanState", &self.clean_state)?;
6487 }
6488 if let Some(v) = self.delta_expression.as_ref() {
6489 struct_ser.serialize_field("deltaExpression", v)?;
6490 }
6491 struct_ser.end()
6492 }
6493}
6494impl<'de> serde::Deserialize<'de> for InequalityPair {
6495 #[allow(deprecated)]
6496 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6497 where
6498 D: serde::Deserializer<'de>,
6499 {
6500 const FIELDS: &[&str] = &[
6501 "key_required_larger",
6502 "keyRequiredLarger",
6503 "key_required_smaller",
6504 "keyRequiredSmaller",
6505 "clean_state",
6506 "cleanState",
6507 "delta_expression",
6508 "deltaExpression",
6509 ];
6510
6511 #[allow(clippy::enum_variant_names)]
6512 enum GeneratedField {
6513 KeyRequiredLarger,
6514 KeyRequiredSmaller,
6515 CleanState,
6516 DeltaExpression,
6517 }
6518 impl<'de> serde::Deserialize<'de> for GeneratedField {
6519 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6520 where
6521 D: serde::Deserializer<'de>,
6522 {
6523 struct GeneratedVisitor;
6524
6525 impl serde::de::Visitor<'_> for GeneratedVisitor {
6526 type Value = GeneratedField;
6527
6528 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6529 write!(formatter, "expected one of: {:?}", &FIELDS)
6530 }
6531
6532 #[allow(unused_variables)]
6533 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6534 where
6535 E: serde::de::Error,
6536 {
6537 match value {
6538 "keyRequiredLarger" | "key_required_larger" => Ok(GeneratedField::KeyRequiredLarger),
6539 "keyRequiredSmaller" | "key_required_smaller" => Ok(GeneratedField::KeyRequiredSmaller),
6540 "cleanState" | "clean_state" => Ok(GeneratedField::CleanState),
6541 "deltaExpression" | "delta_expression" => Ok(GeneratedField::DeltaExpression),
6542 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6543 }
6544 }
6545 }
6546 deserializer.deserialize_identifier(GeneratedVisitor)
6547 }
6548 }
6549 struct GeneratedVisitor;
6550 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6551 type Value = InequalityPair;
6552
6553 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6554 formatter.write_str("struct stream_plan.InequalityPair")
6555 }
6556
6557 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPair, V::Error>
6558 where
6559 V: serde::de::MapAccess<'de>,
6560 {
6561 let mut key_required_larger__ = None;
6562 let mut key_required_smaller__ = None;
6563 let mut clean_state__ = None;
6564 let mut delta_expression__ = None;
6565 while let Some(k) = map_.next_key()? {
6566 match k {
6567 GeneratedField::KeyRequiredLarger => {
6568 if key_required_larger__.is_some() {
6569 return Err(serde::de::Error::duplicate_field("keyRequiredLarger"));
6570 }
6571 key_required_larger__ =
6572 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6573 ;
6574 }
6575 GeneratedField::KeyRequiredSmaller => {
6576 if key_required_smaller__.is_some() {
6577 return Err(serde::de::Error::duplicate_field("keyRequiredSmaller"));
6578 }
6579 key_required_smaller__ =
6580 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6581 ;
6582 }
6583 GeneratedField::CleanState => {
6584 if clean_state__.is_some() {
6585 return Err(serde::de::Error::duplicate_field("cleanState"));
6586 }
6587 clean_state__ = Some(map_.next_value()?);
6588 }
6589 GeneratedField::DeltaExpression => {
6590 if delta_expression__.is_some() {
6591 return Err(serde::de::Error::duplicate_field("deltaExpression"));
6592 }
6593 delta_expression__ = map_.next_value()?;
6594 }
6595 }
6596 }
6597 Ok(InequalityPair {
6598 key_required_larger: key_required_larger__.unwrap_or_default(),
6599 key_required_smaller: key_required_smaller__.unwrap_or_default(),
6600 clean_state: clean_state__.unwrap_or_default(),
6601 delta_expression: delta_expression__,
6602 })
6603 }
6604 }
6605 deserializer.deserialize_struct("stream_plan.InequalityPair", FIELDS, GeneratedVisitor)
6606 }
6607}
6608impl serde::Serialize for InequalityPairV2 {
6609 #[allow(deprecated)]
6610 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6611 where
6612 S: serde::Serializer,
6613 {
6614 use serde::ser::SerializeStruct;
6615 let mut len = 0;
6616 if self.left_idx != 0 {
6617 len += 1;
6618 }
6619 if self.right_idx != 0 {
6620 len += 1;
6621 }
6622 if self.clean_left_state {
6623 len += 1;
6624 }
6625 if self.clean_right_state {
6626 len += 1;
6627 }
6628 if self.op != 0 {
6629 len += 1;
6630 }
6631 let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPairV2", len)?;
6632 if self.left_idx != 0 {
6633 struct_ser.serialize_field("leftIdx", &self.left_idx)?;
6634 }
6635 if self.right_idx != 0 {
6636 struct_ser.serialize_field("rightIdx", &self.right_idx)?;
6637 }
6638 if self.clean_left_state {
6639 struct_ser.serialize_field("cleanLeftState", &self.clean_left_state)?;
6640 }
6641 if self.clean_right_state {
6642 struct_ser.serialize_field("cleanRightState", &self.clean_right_state)?;
6643 }
6644 if self.op != 0 {
6645 let v = InequalityType::try_from(self.op)
6646 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.op)))?;
6647 struct_ser.serialize_field("op", &v)?;
6648 }
6649 struct_ser.end()
6650 }
6651}
6652impl<'de> serde::Deserialize<'de> for InequalityPairV2 {
6653 #[allow(deprecated)]
6654 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6655 where
6656 D: serde::Deserializer<'de>,
6657 {
6658 const FIELDS: &[&str] = &[
6659 "left_idx",
6660 "leftIdx",
6661 "right_idx",
6662 "rightIdx",
6663 "clean_left_state",
6664 "cleanLeftState",
6665 "clean_right_state",
6666 "cleanRightState",
6667 "op",
6668 ];
6669
6670 #[allow(clippy::enum_variant_names)]
6671 enum GeneratedField {
6672 LeftIdx,
6673 RightIdx,
6674 CleanLeftState,
6675 CleanRightState,
6676 Op,
6677 }
6678 impl<'de> serde::Deserialize<'de> for GeneratedField {
6679 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6680 where
6681 D: serde::Deserializer<'de>,
6682 {
6683 struct GeneratedVisitor;
6684
6685 impl serde::de::Visitor<'_> for GeneratedVisitor {
6686 type Value = GeneratedField;
6687
6688 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6689 write!(formatter, "expected one of: {:?}", &FIELDS)
6690 }
6691
6692 #[allow(unused_variables)]
6693 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6694 where
6695 E: serde::de::Error,
6696 {
6697 match value {
6698 "leftIdx" | "left_idx" => Ok(GeneratedField::LeftIdx),
6699 "rightIdx" | "right_idx" => Ok(GeneratedField::RightIdx),
6700 "cleanLeftState" | "clean_left_state" => Ok(GeneratedField::CleanLeftState),
6701 "cleanRightState" | "clean_right_state" => Ok(GeneratedField::CleanRightState),
6702 "op" => Ok(GeneratedField::Op),
6703 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6704 }
6705 }
6706 }
6707 deserializer.deserialize_identifier(GeneratedVisitor)
6708 }
6709 }
6710 struct GeneratedVisitor;
6711 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6712 type Value = InequalityPairV2;
6713
6714 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6715 formatter.write_str("struct stream_plan.InequalityPairV2")
6716 }
6717
6718 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPairV2, V::Error>
6719 where
6720 V: serde::de::MapAccess<'de>,
6721 {
6722 let mut left_idx__ = None;
6723 let mut right_idx__ = None;
6724 let mut clean_left_state__ = None;
6725 let mut clean_right_state__ = None;
6726 let mut op__ = None;
6727 while let Some(k) = map_.next_key()? {
6728 match k {
6729 GeneratedField::LeftIdx => {
6730 if left_idx__.is_some() {
6731 return Err(serde::de::Error::duplicate_field("leftIdx"));
6732 }
6733 left_idx__ =
6734 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6735 ;
6736 }
6737 GeneratedField::RightIdx => {
6738 if right_idx__.is_some() {
6739 return Err(serde::de::Error::duplicate_field("rightIdx"));
6740 }
6741 right_idx__ =
6742 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6743 ;
6744 }
6745 GeneratedField::CleanLeftState => {
6746 if clean_left_state__.is_some() {
6747 return Err(serde::de::Error::duplicate_field("cleanLeftState"));
6748 }
6749 clean_left_state__ = Some(map_.next_value()?);
6750 }
6751 GeneratedField::CleanRightState => {
6752 if clean_right_state__.is_some() {
6753 return Err(serde::de::Error::duplicate_field("cleanRightState"));
6754 }
6755 clean_right_state__ = Some(map_.next_value()?);
6756 }
6757 GeneratedField::Op => {
6758 if op__.is_some() {
6759 return Err(serde::de::Error::duplicate_field("op"));
6760 }
6761 op__ = Some(map_.next_value::<InequalityType>()? as i32);
6762 }
6763 }
6764 }
6765 Ok(InequalityPairV2 {
6766 left_idx: left_idx__.unwrap_or_default(),
6767 right_idx: right_idx__.unwrap_or_default(),
6768 clean_left_state: clean_left_state__.unwrap_or_default(),
6769 clean_right_state: clean_right_state__.unwrap_or_default(),
6770 op: op__.unwrap_or_default(),
6771 })
6772 }
6773 }
6774 deserializer.deserialize_struct("stream_plan.InequalityPairV2", FIELDS, GeneratedVisitor)
6775 }
6776}
6777impl serde::Serialize for InequalityType {
6778 #[allow(deprecated)]
6779 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6780 where
6781 S: serde::Serializer,
6782 {
6783 let variant = match self {
6784 Self::Unspecified => "INEQUALITY_TYPE_UNSPECIFIED",
6785 Self::LessThan => "INEQUALITY_TYPE_LESS_THAN",
6786 Self::LessThanOrEqual => "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL",
6787 Self::GreaterThan => "INEQUALITY_TYPE_GREATER_THAN",
6788 Self::GreaterThanOrEqual => "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL",
6789 };
6790 serializer.serialize_str(variant)
6791 }
6792}
6793impl<'de> serde::Deserialize<'de> for InequalityType {
6794 #[allow(deprecated)]
6795 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6796 where
6797 D: serde::Deserializer<'de>,
6798 {
6799 const FIELDS: &[&str] = &[
6800 "INEQUALITY_TYPE_UNSPECIFIED",
6801 "INEQUALITY_TYPE_LESS_THAN",
6802 "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL",
6803 "INEQUALITY_TYPE_GREATER_THAN",
6804 "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL",
6805 ];
6806
6807 struct GeneratedVisitor;
6808
6809 impl serde::de::Visitor<'_> for GeneratedVisitor {
6810 type Value = InequalityType;
6811
6812 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6813 write!(formatter, "expected one of: {:?}", &FIELDS)
6814 }
6815
6816 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6817 where
6818 E: serde::de::Error,
6819 {
6820 i32::try_from(v)
6821 .ok()
6822 .and_then(|x| x.try_into().ok())
6823 .ok_or_else(|| {
6824 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6825 })
6826 }
6827
6828 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6829 where
6830 E: serde::de::Error,
6831 {
6832 i32::try_from(v)
6833 .ok()
6834 .and_then(|x| x.try_into().ok())
6835 .ok_or_else(|| {
6836 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6837 })
6838 }
6839
6840 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6841 where
6842 E: serde::de::Error,
6843 {
6844 match value {
6845 "INEQUALITY_TYPE_UNSPECIFIED" => Ok(InequalityType::Unspecified),
6846 "INEQUALITY_TYPE_LESS_THAN" => Ok(InequalityType::LessThan),
6847 "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL" => Ok(InequalityType::LessThanOrEqual),
6848 "INEQUALITY_TYPE_GREATER_THAN" => Ok(InequalityType::GreaterThan),
6849 "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL" => Ok(InequalityType::GreaterThanOrEqual),
6850 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6851 }
6852 }
6853 }
6854 deserializer.deserialize_any(GeneratedVisitor)
6855 }
6856}
6857impl serde::Serialize for InjectSourceOffsetsMutation {
6858 #[allow(deprecated)]
6859 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6860 where
6861 S: serde::Serializer,
6862 {
6863 use serde::ser::SerializeStruct;
6864 let mut len = 0;
6865 if self.source_id != 0 {
6866 len += 1;
6867 }
6868 if !self.split_offsets.is_empty() {
6869 len += 1;
6870 }
6871 let mut struct_ser = serializer.serialize_struct("stream_plan.InjectSourceOffsetsMutation", len)?;
6872 if self.source_id != 0 {
6873 struct_ser.serialize_field("sourceId", &self.source_id)?;
6874 }
6875 if !self.split_offsets.is_empty() {
6876 struct_ser.serialize_field("splitOffsets", &self.split_offsets)?;
6877 }
6878 struct_ser.end()
6879 }
6880}
6881impl<'de> serde::Deserialize<'de> for InjectSourceOffsetsMutation {
6882 #[allow(deprecated)]
6883 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6884 where
6885 D: serde::Deserializer<'de>,
6886 {
6887 const FIELDS: &[&str] = &[
6888 "source_id",
6889 "sourceId",
6890 "split_offsets",
6891 "splitOffsets",
6892 ];
6893
6894 #[allow(clippy::enum_variant_names)]
6895 enum GeneratedField {
6896 SourceId,
6897 SplitOffsets,
6898 }
6899 impl<'de> serde::Deserialize<'de> for GeneratedField {
6900 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6901 where
6902 D: serde::Deserializer<'de>,
6903 {
6904 struct GeneratedVisitor;
6905
6906 impl serde::de::Visitor<'_> for GeneratedVisitor {
6907 type Value = GeneratedField;
6908
6909 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6910 write!(formatter, "expected one of: {:?}", &FIELDS)
6911 }
6912
6913 #[allow(unused_variables)]
6914 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6915 where
6916 E: serde::de::Error,
6917 {
6918 match value {
6919 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
6920 "splitOffsets" | "split_offsets" => Ok(GeneratedField::SplitOffsets),
6921 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6922 }
6923 }
6924 }
6925 deserializer.deserialize_identifier(GeneratedVisitor)
6926 }
6927 }
6928 struct GeneratedVisitor;
6929 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6930 type Value = InjectSourceOffsetsMutation;
6931
6932 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6933 formatter.write_str("struct stream_plan.InjectSourceOffsetsMutation")
6934 }
6935
6936 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InjectSourceOffsetsMutation, V::Error>
6937 where
6938 V: serde::de::MapAccess<'de>,
6939 {
6940 let mut source_id__ = None;
6941 let mut split_offsets__ = None;
6942 while let Some(k) = map_.next_key()? {
6943 match k {
6944 GeneratedField::SourceId => {
6945 if source_id__.is_some() {
6946 return Err(serde::de::Error::duplicate_field("sourceId"));
6947 }
6948 source_id__ =
6949 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6950 ;
6951 }
6952 GeneratedField::SplitOffsets => {
6953 if split_offsets__.is_some() {
6954 return Err(serde::de::Error::duplicate_field("splitOffsets"));
6955 }
6956 split_offsets__ = Some(
6957 map_.next_value::<std::collections::HashMap<_, _>>()?
6958 );
6959 }
6960 }
6961 }
6962 Ok(InjectSourceOffsetsMutation {
6963 source_id: source_id__.unwrap_or_default(),
6964 split_offsets: split_offsets__.unwrap_or_default(),
6965 })
6966 }
6967 }
6968 deserializer.deserialize_struct("stream_plan.InjectSourceOffsetsMutation", FIELDS, GeneratedVisitor)
6969 }
6970}
6971impl serde::Serialize for JoinEncodingType {
6972 #[allow(deprecated)]
6973 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6974 where
6975 S: serde::Serializer,
6976 {
6977 let variant = match self {
6978 Self::Unspecified => "UNSPECIFIED",
6979 Self::MemoryOptimized => "MEMORY_OPTIMIZED",
6980 Self::CpuOptimized => "CPU_OPTIMIZED",
6981 };
6982 serializer.serialize_str(variant)
6983 }
6984}
6985impl<'de> serde::Deserialize<'de> for JoinEncodingType {
6986 #[allow(deprecated)]
6987 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6988 where
6989 D: serde::Deserializer<'de>,
6990 {
6991 const FIELDS: &[&str] = &[
6992 "UNSPECIFIED",
6993 "MEMORY_OPTIMIZED",
6994 "CPU_OPTIMIZED",
6995 ];
6996
6997 struct GeneratedVisitor;
6998
6999 impl serde::de::Visitor<'_> for GeneratedVisitor {
7000 type Value = JoinEncodingType;
7001
7002 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7003 write!(formatter, "expected one of: {:?}", &FIELDS)
7004 }
7005
7006 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
7007 where
7008 E: serde::de::Error,
7009 {
7010 i32::try_from(v)
7011 .ok()
7012 .and_then(|x| x.try_into().ok())
7013 .ok_or_else(|| {
7014 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
7015 })
7016 }
7017
7018 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
7019 where
7020 E: serde::de::Error,
7021 {
7022 i32::try_from(v)
7023 .ok()
7024 .and_then(|x| x.try_into().ok())
7025 .ok_or_else(|| {
7026 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
7027 })
7028 }
7029
7030 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
7031 where
7032 E: serde::de::Error,
7033 {
7034 match value {
7035 "UNSPECIFIED" => Ok(JoinEncodingType::Unspecified),
7036 "MEMORY_OPTIMIZED" => Ok(JoinEncodingType::MemoryOptimized),
7037 "CPU_OPTIMIZED" => Ok(JoinEncodingType::CpuOptimized),
7038 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
7039 }
7040 }
7041 }
7042 deserializer.deserialize_any(GeneratedVisitor)
7043 }
7044}
7045impl serde::Serialize for JoinKeyWatermarkIndex {
7046 #[allow(deprecated)]
7047 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7048 where
7049 S: serde::Serializer,
7050 {
7051 use serde::ser::SerializeStruct;
7052 let mut len = 0;
7053 if self.index != 0 {
7054 len += 1;
7055 }
7056 if self.do_state_cleaning {
7057 len += 1;
7058 }
7059 let mut struct_ser = serializer.serialize_struct("stream_plan.JoinKeyWatermarkIndex", len)?;
7060 if self.index != 0 {
7061 struct_ser.serialize_field("index", &self.index)?;
7062 }
7063 if self.do_state_cleaning {
7064 struct_ser.serialize_field("doStateCleaning", &self.do_state_cleaning)?;
7065 }
7066 struct_ser.end()
7067 }
7068}
7069impl<'de> serde::Deserialize<'de> for JoinKeyWatermarkIndex {
7070 #[allow(deprecated)]
7071 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7072 where
7073 D: serde::Deserializer<'de>,
7074 {
7075 const FIELDS: &[&str] = &[
7076 "index",
7077 "do_state_cleaning",
7078 "doStateCleaning",
7079 ];
7080
7081 #[allow(clippy::enum_variant_names)]
7082 enum GeneratedField {
7083 Index,
7084 DoStateCleaning,
7085 }
7086 impl<'de> serde::Deserialize<'de> for GeneratedField {
7087 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7088 where
7089 D: serde::Deserializer<'de>,
7090 {
7091 struct GeneratedVisitor;
7092
7093 impl serde::de::Visitor<'_> for GeneratedVisitor {
7094 type Value = GeneratedField;
7095
7096 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7097 write!(formatter, "expected one of: {:?}", &FIELDS)
7098 }
7099
7100 #[allow(unused_variables)]
7101 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7102 where
7103 E: serde::de::Error,
7104 {
7105 match value {
7106 "index" => Ok(GeneratedField::Index),
7107 "doStateCleaning" | "do_state_cleaning" => Ok(GeneratedField::DoStateCleaning),
7108 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7109 }
7110 }
7111 }
7112 deserializer.deserialize_identifier(GeneratedVisitor)
7113 }
7114 }
7115 struct GeneratedVisitor;
7116 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7117 type Value = JoinKeyWatermarkIndex;
7118
7119 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7120 formatter.write_str("struct stream_plan.JoinKeyWatermarkIndex")
7121 }
7122
7123 fn visit_map<V>(self, mut map_: V) -> std::result::Result<JoinKeyWatermarkIndex, V::Error>
7124 where
7125 V: serde::de::MapAccess<'de>,
7126 {
7127 let mut index__ = None;
7128 let mut do_state_cleaning__ = None;
7129 while let Some(k) = map_.next_key()? {
7130 match k {
7131 GeneratedField::Index => {
7132 if index__.is_some() {
7133 return Err(serde::de::Error::duplicate_field("index"));
7134 }
7135 index__ =
7136 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7137 ;
7138 }
7139 GeneratedField::DoStateCleaning => {
7140 if do_state_cleaning__.is_some() {
7141 return Err(serde::de::Error::duplicate_field("doStateCleaning"));
7142 }
7143 do_state_cleaning__ = Some(map_.next_value()?);
7144 }
7145 }
7146 }
7147 Ok(JoinKeyWatermarkIndex {
7148 index: index__.unwrap_or_default(),
7149 do_state_cleaning: do_state_cleaning__.unwrap_or_default(),
7150 })
7151 }
7152 }
7153 deserializer.deserialize_struct("stream_plan.JoinKeyWatermarkIndex", FIELDS, GeneratedVisitor)
7154 }
7155}
7156impl serde::Serialize for ListFinishMutation {
7157 #[allow(deprecated)]
7158 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7159 where
7160 S: serde::Serializer,
7161 {
7162 use serde::ser::SerializeStruct;
7163 let mut len = 0;
7164 if self.associated_source_id != 0 {
7165 len += 1;
7166 }
7167 let mut struct_ser = serializer.serialize_struct("stream_plan.ListFinishMutation", len)?;
7168 if self.associated_source_id != 0 {
7169 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
7170 }
7171 struct_ser.end()
7172 }
7173}
7174impl<'de> serde::Deserialize<'de> for ListFinishMutation {
7175 #[allow(deprecated)]
7176 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7177 where
7178 D: serde::Deserializer<'de>,
7179 {
7180 const FIELDS: &[&str] = &[
7181 "associated_source_id",
7182 "associatedSourceId",
7183 ];
7184
7185 #[allow(clippy::enum_variant_names)]
7186 enum GeneratedField {
7187 AssociatedSourceId,
7188 }
7189 impl<'de> serde::Deserialize<'de> for GeneratedField {
7190 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7191 where
7192 D: serde::Deserializer<'de>,
7193 {
7194 struct GeneratedVisitor;
7195
7196 impl serde::de::Visitor<'_> for GeneratedVisitor {
7197 type Value = GeneratedField;
7198
7199 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7200 write!(formatter, "expected one of: {:?}", &FIELDS)
7201 }
7202
7203 #[allow(unused_variables)]
7204 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7205 where
7206 E: serde::de::Error,
7207 {
7208 match value {
7209 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
7210 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7211 }
7212 }
7213 }
7214 deserializer.deserialize_identifier(GeneratedVisitor)
7215 }
7216 }
7217 struct GeneratedVisitor;
7218 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7219 type Value = ListFinishMutation;
7220
7221 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7222 formatter.write_str("struct stream_plan.ListFinishMutation")
7223 }
7224
7225 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFinishMutation, V::Error>
7226 where
7227 V: serde::de::MapAccess<'de>,
7228 {
7229 let mut associated_source_id__ = None;
7230 while let Some(k) = map_.next_key()? {
7231 match k {
7232 GeneratedField::AssociatedSourceId => {
7233 if associated_source_id__.is_some() {
7234 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
7235 }
7236 associated_source_id__ =
7237 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7238 ;
7239 }
7240 }
7241 }
7242 Ok(ListFinishMutation {
7243 associated_source_id: associated_source_id__.unwrap_or_default(),
7244 })
7245 }
7246 }
7247 deserializer.deserialize_struct("stream_plan.ListFinishMutation", FIELDS, GeneratedVisitor)
7248 }
7249}
7250impl serde::Serialize for LoadFinishMutation {
7251 #[allow(deprecated)]
7252 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7253 where
7254 S: serde::Serializer,
7255 {
7256 use serde::ser::SerializeStruct;
7257 let mut len = 0;
7258 if self.associated_source_id != 0 {
7259 len += 1;
7260 }
7261 let mut struct_ser = serializer.serialize_struct("stream_plan.LoadFinishMutation", len)?;
7262 if self.associated_source_id != 0 {
7263 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
7264 }
7265 struct_ser.end()
7266 }
7267}
7268impl<'de> serde::Deserialize<'de> for LoadFinishMutation {
7269 #[allow(deprecated)]
7270 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7271 where
7272 D: serde::Deserializer<'de>,
7273 {
7274 const FIELDS: &[&str] = &[
7275 "associated_source_id",
7276 "associatedSourceId",
7277 ];
7278
7279 #[allow(clippy::enum_variant_names)]
7280 enum GeneratedField {
7281 AssociatedSourceId,
7282 }
7283 impl<'de> serde::Deserialize<'de> for GeneratedField {
7284 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7285 where
7286 D: serde::Deserializer<'de>,
7287 {
7288 struct GeneratedVisitor;
7289
7290 impl serde::de::Visitor<'_> for GeneratedVisitor {
7291 type Value = GeneratedField;
7292
7293 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7294 write!(formatter, "expected one of: {:?}", &FIELDS)
7295 }
7296
7297 #[allow(unused_variables)]
7298 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7299 where
7300 E: serde::de::Error,
7301 {
7302 match value {
7303 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
7304 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7305 }
7306 }
7307 }
7308 deserializer.deserialize_identifier(GeneratedVisitor)
7309 }
7310 }
7311 struct GeneratedVisitor;
7312 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7313 type Value = LoadFinishMutation;
7314
7315 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7316 formatter.write_str("struct stream_plan.LoadFinishMutation")
7317 }
7318
7319 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LoadFinishMutation, V::Error>
7320 where
7321 V: serde::de::MapAccess<'de>,
7322 {
7323 let mut associated_source_id__ = None;
7324 while let Some(k) = map_.next_key()? {
7325 match k {
7326 GeneratedField::AssociatedSourceId => {
7327 if associated_source_id__.is_some() {
7328 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
7329 }
7330 associated_source_id__ =
7331 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7332 ;
7333 }
7334 }
7335 }
7336 Ok(LoadFinishMutation {
7337 associated_source_id: associated_source_id__.unwrap_or_default(),
7338 })
7339 }
7340 }
7341 deserializer.deserialize_struct("stream_plan.LoadFinishMutation", FIELDS, GeneratedVisitor)
7342 }
7343}
7344impl serde::Serialize for LocalApproxPercentileNode {
7345 #[allow(deprecated)]
7346 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7347 where
7348 S: serde::Serializer,
7349 {
7350 use serde::ser::SerializeStruct;
7351 let mut len = 0;
7352 if self.base != 0. {
7353 len += 1;
7354 }
7355 if self.percentile_index != 0 {
7356 len += 1;
7357 }
7358 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalApproxPercentileNode", len)?;
7359 if self.base != 0. {
7360 struct_ser.serialize_field("base", &self.base)?;
7361 }
7362 if self.percentile_index != 0 {
7363 struct_ser.serialize_field("percentileIndex", &self.percentile_index)?;
7364 }
7365 struct_ser.end()
7366 }
7367}
7368impl<'de> serde::Deserialize<'de> for LocalApproxPercentileNode {
7369 #[allow(deprecated)]
7370 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7371 where
7372 D: serde::Deserializer<'de>,
7373 {
7374 const FIELDS: &[&str] = &[
7375 "base",
7376 "percentile_index",
7377 "percentileIndex",
7378 ];
7379
7380 #[allow(clippy::enum_variant_names)]
7381 enum GeneratedField {
7382 Base,
7383 PercentileIndex,
7384 }
7385 impl<'de> serde::Deserialize<'de> for GeneratedField {
7386 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7387 where
7388 D: serde::Deserializer<'de>,
7389 {
7390 struct GeneratedVisitor;
7391
7392 impl serde::de::Visitor<'_> for GeneratedVisitor {
7393 type Value = GeneratedField;
7394
7395 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7396 write!(formatter, "expected one of: {:?}", &FIELDS)
7397 }
7398
7399 #[allow(unused_variables)]
7400 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7401 where
7402 E: serde::de::Error,
7403 {
7404 match value {
7405 "base" => Ok(GeneratedField::Base),
7406 "percentileIndex" | "percentile_index" => Ok(GeneratedField::PercentileIndex),
7407 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7408 }
7409 }
7410 }
7411 deserializer.deserialize_identifier(GeneratedVisitor)
7412 }
7413 }
7414 struct GeneratedVisitor;
7415 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7416 type Value = LocalApproxPercentileNode;
7417
7418 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7419 formatter.write_str("struct stream_plan.LocalApproxPercentileNode")
7420 }
7421
7422 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalApproxPercentileNode, V::Error>
7423 where
7424 V: serde::de::MapAccess<'de>,
7425 {
7426 let mut base__ = None;
7427 let mut percentile_index__ = None;
7428 while let Some(k) = map_.next_key()? {
7429 match k {
7430 GeneratedField::Base => {
7431 if base__.is_some() {
7432 return Err(serde::de::Error::duplicate_field("base"));
7433 }
7434 base__ =
7435 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7436 ;
7437 }
7438 GeneratedField::PercentileIndex => {
7439 if percentile_index__.is_some() {
7440 return Err(serde::de::Error::duplicate_field("percentileIndex"));
7441 }
7442 percentile_index__ =
7443 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7444 ;
7445 }
7446 }
7447 }
7448 Ok(LocalApproxPercentileNode {
7449 base: base__.unwrap_or_default(),
7450 percentile_index: percentile_index__.unwrap_or_default(),
7451 })
7452 }
7453 }
7454 deserializer.deserialize_struct("stream_plan.LocalApproxPercentileNode", FIELDS, GeneratedVisitor)
7455 }
7456}
7457impl serde::Serialize for LocalityProviderNode {
7458 #[allow(deprecated)]
7459 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7460 where
7461 S: serde::Serializer,
7462 {
7463 use serde::ser::SerializeStruct;
7464 let mut len = 0;
7465 if !self.locality_columns.is_empty() {
7466 len += 1;
7467 }
7468 if self.state_table.is_some() {
7469 len += 1;
7470 }
7471 if self.progress_table.is_some() {
7472 len += 1;
7473 }
7474 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalityProviderNode", len)?;
7475 if !self.locality_columns.is_empty() {
7476 struct_ser.serialize_field("localityColumns", &self.locality_columns)?;
7477 }
7478 if let Some(v) = self.state_table.as_ref() {
7479 struct_ser.serialize_field("stateTable", v)?;
7480 }
7481 if let Some(v) = self.progress_table.as_ref() {
7482 struct_ser.serialize_field("progressTable", v)?;
7483 }
7484 struct_ser.end()
7485 }
7486}
7487impl<'de> serde::Deserialize<'de> for LocalityProviderNode {
7488 #[allow(deprecated)]
7489 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7490 where
7491 D: serde::Deserializer<'de>,
7492 {
7493 const FIELDS: &[&str] = &[
7494 "locality_columns",
7495 "localityColumns",
7496 "state_table",
7497 "stateTable",
7498 "progress_table",
7499 "progressTable",
7500 ];
7501
7502 #[allow(clippy::enum_variant_names)]
7503 enum GeneratedField {
7504 LocalityColumns,
7505 StateTable,
7506 ProgressTable,
7507 }
7508 impl<'de> serde::Deserialize<'de> for GeneratedField {
7509 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7510 where
7511 D: serde::Deserializer<'de>,
7512 {
7513 struct GeneratedVisitor;
7514
7515 impl serde::de::Visitor<'_> for GeneratedVisitor {
7516 type Value = GeneratedField;
7517
7518 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7519 write!(formatter, "expected one of: {:?}", &FIELDS)
7520 }
7521
7522 #[allow(unused_variables)]
7523 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7524 where
7525 E: serde::de::Error,
7526 {
7527 match value {
7528 "localityColumns" | "locality_columns" => Ok(GeneratedField::LocalityColumns),
7529 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7530 "progressTable" | "progress_table" => Ok(GeneratedField::ProgressTable),
7531 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7532 }
7533 }
7534 }
7535 deserializer.deserialize_identifier(GeneratedVisitor)
7536 }
7537 }
7538 struct GeneratedVisitor;
7539 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7540 type Value = LocalityProviderNode;
7541
7542 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7543 formatter.write_str("struct stream_plan.LocalityProviderNode")
7544 }
7545
7546 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalityProviderNode, V::Error>
7547 where
7548 V: serde::de::MapAccess<'de>,
7549 {
7550 let mut locality_columns__ = None;
7551 let mut state_table__ = None;
7552 let mut progress_table__ = None;
7553 while let Some(k) = map_.next_key()? {
7554 match k {
7555 GeneratedField::LocalityColumns => {
7556 if locality_columns__.is_some() {
7557 return Err(serde::de::Error::duplicate_field("localityColumns"));
7558 }
7559 locality_columns__ =
7560 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7561 .into_iter().map(|x| x.0).collect())
7562 ;
7563 }
7564 GeneratedField::StateTable => {
7565 if state_table__.is_some() {
7566 return Err(serde::de::Error::duplicate_field("stateTable"));
7567 }
7568 state_table__ = map_.next_value()?;
7569 }
7570 GeneratedField::ProgressTable => {
7571 if progress_table__.is_some() {
7572 return Err(serde::de::Error::duplicate_field("progressTable"));
7573 }
7574 progress_table__ = map_.next_value()?;
7575 }
7576 }
7577 }
7578 Ok(LocalityProviderNode {
7579 locality_columns: locality_columns__.unwrap_or_default(),
7580 state_table: state_table__,
7581 progress_table: progress_table__,
7582 })
7583 }
7584 }
7585 deserializer.deserialize_struct("stream_plan.LocalityProviderNode", FIELDS, GeneratedVisitor)
7586 }
7587}
7588impl serde::Serialize for LookupNode {
7589 #[allow(deprecated)]
7590 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7591 where
7592 S: serde::Serializer,
7593 {
7594 use serde::ser::SerializeStruct;
7595 let mut len = 0;
7596 if !self.arrange_key.is_empty() {
7597 len += 1;
7598 }
7599 if !self.stream_key.is_empty() {
7600 len += 1;
7601 }
7602 if self.use_current_epoch {
7603 len += 1;
7604 }
7605 if !self.column_mapping.is_empty() {
7606 len += 1;
7607 }
7608 if self.arrangement_table_info.is_some() {
7609 len += 1;
7610 }
7611 if self.arrangement_table_id.is_some() {
7612 len += 1;
7613 }
7614 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupNode", len)?;
7615 if !self.arrange_key.is_empty() {
7616 struct_ser.serialize_field("arrangeKey", &self.arrange_key)?;
7617 }
7618 if !self.stream_key.is_empty() {
7619 struct_ser.serialize_field("streamKey", &self.stream_key)?;
7620 }
7621 if self.use_current_epoch {
7622 struct_ser.serialize_field("useCurrentEpoch", &self.use_current_epoch)?;
7623 }
7624 if !self.column_mapping.is_empty() {
7625 struct_ser.serialize_field("columnMapping", &self.column_mapping)?;
7626 }
7627 if let Some(v) = self.arrangement_table_info.as_ref() {
7628 struct_ser.serialize_field("arrangementTableInfo", v)?;
7629 }
7630 if let Some(v) = self.arrangement_table_id.as_ref() {
7631 match v {
7632 lookup_node::ArrangementTableId::TableId(v) => {
7633 struct_ser.serialize_field("tableId", v)?;
7634 }
7635 lookup_node::ArrangementTableId::IndexId(v) => {
7636 struct_ser.serialize_field("indexId", v)?;
7637 }
7638 }
7639 }
7640 struct_ser.end()
7641 }
7642}
7643impl<'de> serde::Deserialize<'de> for LookupNode {
7644 #[allow(deprecated)]
7645 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7646 where
7647 D: serde::Deserializer<'de>,
7648 {
7649 const FIELDS: &[&str] = &[
7650 "arrange_key",
7651 "arrangeKey",
7652 "stream_key",
7653 "streamKey",
7654 "use_current_epoch",
7655 "useCurrentEpoch",
7656 "column_mapping",
7657 "columnMapping",
7658 "arrangement_table_info",
7659 "arrangementTableInfo",
7660 "table_id",
7661 "tableId",
7662 "index_id",
7663 "indexId",
7664 ];
7665
7666 #[allow(clippy::enum_variant_names)]
7667 enum GeneratedField {
7668 ArrangeKey,
7669 StreamKey,
7670 UseCurrentEpoch,
7671 ColumnMapping,
7672 ArrangementTableInfo,
7673 TableId,
7674 IndexId,
7675 }
7676 impl<'de> serde::Deserialize<'de> for GeneratedField {
7677 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7678 where
7679 D: serde::Deserializer<'de>,
7680 {
7681 struct GeneratedVisitor;
7682
7683 impl serde::de::Visitor<'_> for GeneratedVisitor {
7684 type Value = GeneratedField;
7685
7686 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7687 write!(formatter, "expected one of: {:?}", &FIELDS)
7688 }
7689
7690 #[allow(unused_variables)]
7691 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7692 where
7693 E: serde::de::Error,
7694 {
7695 match value {
7696 "arrangeKey" | "arrange_key" => Ok(GeneratedField::ArrangeKey),
7697 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
7698 "useCurrentEpoch" | "use_current_epoch" => Ok(GeneratedField::UseCurrentEpoch),
7699 "columnMapping" | "column_mapping" => Ok(GeneratedField::ColumnMapping),
7700 "arrangementTableInfo" | "arrangement_table_info" => Ok(GeneratedField::ArrangementTableInfo),
7701 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7702 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
7703 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7704 }
7705 }
7706 }
7707 deserializer.deserialize_identifier(GeneratedVisitor)
7708 }
7709 }
7710 struct GeneratedVisitor;
7711 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7712 type Value = LookupNode;
7713
7714 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7715 formatter.write_str("struct stream_plan.LookupNode")
7716 }
7717
7718 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupNode, V::Error>
7719 where
7720 V: serde::de::MapAccess<'de>,
7721 {
7722 let mut arrange_key__ = None;
7723 let mut stream_key__ = None;
7724 let mut use_current_epoch__ = None;
7725 let mut column_mapping__ = None;
7726 let mut arrangement_table_info__ = None;
7727 let mut arrangement_table_id__ = None;
7728 while let Some(k) = map_.next_key()? {
7729 match k {
7730 GeneratedField::ArrangeKey => {
7731 if arrange_key__.is_some() {
7732 return Err(serde::de::Error::duplicate_field("arrangeKey"));
7733 }
7734 arrange_key__ =
7735 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7736 .into_iter().map(|x| x.0).collect())
7737 ;
7738 }
7739 GeneratedField::StreamKey => {
7740 if stream_key__.is_some() {
7741 return Err(serde::de::Error::duplicate_field("streamKey"));
7742 }
7743 stream_key__ =
7744 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7745 .into_iter().map(|x| x.0).collect())
7746 ;
7747 }
7748 GeneratedField::UseCurrentEpoch => {
7749 if use_current_epoch__.is_some() {
7750 return Err(serde::de::Error::duplicate_field("useCurrentEpoch"));
7751 }
7752 use_current_epoch__ = Some(map_.next_value()?);
7753 }
7754 GeneratedField::ColumnMapping => {
7755 if column_mapping__.is_some() {
7756 return Err(serde::de::Error::duplicate_field("columnMapping"));
7757 }
7758 column_mapping__ =
7759 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7760 .into_iter().map(|x| x.0).collect())
7761 ;
7762 }
7763 GeneratedField::ArrangementTableInfo => {
7764 if arrangement_table_info__.is_some() {
7765 return Err(serde::de::Error::duplicate_field("arrangementTableInfo"));
7766 }
7767 arrangement_table_info__ = map_.next_value()?;
7768 }
7769 GeneratedField::TableId => {
7770 if arrangement_table_id__.is_some() {
7771 return Err(serde::de::Error::duplicate_field("tableId"));
7772 }
7773 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::TableId(x.0));
7774 }
7775 GeneratedField::IndexId => {
7776 if arrangement_table_id__.is_some() {
7777 return Err(serde::de::Error::duplicate_field("indexId"));
7778 }
7779 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::IndexId(x.0));
7780 }
7781 }
7782 }
7783 Ok(LookupNode {
7784 arrange_key: arrange_key__.unwrap_or_default(),
7785 stream_key: stream_key__.unwrap_or_default(),
7786 use_current_epoch: use_current_epoch__.unwrap_or_default(),
7787 column_mapping: column_mapping__.unwrap_or_default(),
7788 arrangement_table_info: arrangement_table_info__,
7789 arrangement_table_id: arrangement_table_id__,
7790 })
7791 }
7792 }
7793 deserializer.deserialize_struct("stream_plan.LookupNode", FIELDS, GeneratedVisitor)
7794 }
7795}
7796impl serde::Serialize for LookupUnionNode {
7797 #[allow(deprecated)]
7798 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7799 where
7800 S: serde::Serializer,
7801 {
7802 use serde::ser::SerializeStruct;
7803 let mut len = 0;
7804 if !self.order.is_empty() {
7805 len += 1;
7806 }
7807 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupUnionNode", len)?;
7808 if !self.order.is_empty() {
7809 struct_ser.serialize_field("order", &self.order)?;
7810 }
7811 struct_ser.end()
7812 }
7813}
7814impl<'de> serde::Deserialize<'de> for LookupUnionNode {
7815 #[allow(deprecated)]
7816 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7817 where
7818 D: serde::Deserializer<'de>,
7819 {
7820 const FIELDS: &[&str] = &[
7821 "order",
7822 ];
7823
7824 #[allow(clippy::enum_variant_names)]
7825 enum GeneratedField {
7826 Order,
7827 }
7828 impl<'de> serde::Deserialize<'de> for GeneratedField {
7829 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7830 where
7831 D: serde::Deserializer<'de>,
7832 {
7833 struct GeneratedVisitor;
7834
7835 impl serde::de::Visitor<'_> for GeneratedVisitor {
7836 type Value = GeneratedField;
7837
7838 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7839 write!(formatter, "expected one of: {:?}", &FIELDS)
7840 }
7841
7842 #[allow(unused_variables)]
7843 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7844 where
7845 E: serde::de::Error,
7846 {
7847 match value {
7848 "order" => Ok(GeneratedField::Order),
7849 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7850 }
7851 }
7852 }
7853 deserializer.deserialize_identifier(GeneratedVisitor)
7854 }
7855 }
7856 struct GeneratedVisitor;
7857 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7858 type Value = LookupUnionNode;
7859
7860 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7861 formatter.write_str("struct stream_plan.LookupUnionNode")
7862 }
7863
7864 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupUnionNode, V::Error>
7865 where
7866 V: serde::de::MapAccess<'de>,
7867 {
7868 let mut order__ = None;
7869 while let Some(k) = map_.next_key()? {
7870 match k {
7871 GeneratedField::Order => {
7872 if order__.is_some() {
7873 return Err(serde::de::Error::duplicate_field("order"));
7874 }
7875 order__ =
7876 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7877 .into_iter().map(|x| x.0).collect())
7878 ;
7879 }
7880 }
7881 }
7882 Ok(LookupUnionNode {
7883 order: order__.unwrap_or_default(),
7884 })
7885 }
7886 }
7887 deserializer.deserialize_struct("stream_plan.LookupUnionNode", FIELDS, GeneratedVisitor)
7888 }
7889}
7890impl serde::Serialize for MaterializeNode {
7891 #[allow(deprecated)]
7892 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7893 where
7894 S: serde::Serializer,
7895 {
7896 use serde::ser::SerializeStruct;
7897 let mut len = 0;
7898 if self.table_id != 0 {
7899 len += 1;
7900 }
7901 if !self.column_orders.is_empty() {
7902 len += 1;
7903 }
7904 if self.table.is_some() {
7905 len += 1;
7906 }
7907 if self.staging_table.is_some() {
7908 len += 1;
7909 }
7910 if self.refresh_progress_table.is_some() {
7911 len += 1;
7912 }
7913 if self.cleaned_by_ttl_watermark {
7914 len += 1;
7915 }
7916 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializeNode", len)?;
7917 if self.table_id != 0 {
7918 struct_ser.serialize_field("tableId", &self.table_id)?;
7919 }
7920 if !self.column_orders.is_empty() {
7921 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
7922 }
7923 if let Some(v) = self.table.as_ref() {
7924 struct_ser.serialize_field("table", v)?;
7925 }
7926 if let Some(v) = self.staging_table.as_ref() {
7927 struct_ser.serialize_field("stagingTable", v)?;
7928 }
7929 if let Some(v) = self.refresh_progress_table.as_ref() {
7930 struct_ser.serialize_field("refreshProgressTable", v)?;
7931 }
7932 if self.cleaned_by_ttl_watermark {
7933 struct_ser.serialize_field("cleanedByTtlWatermark", &self.cleaned_by_ttl_watermark)?;
7934 }
7935 struct_ser.end()
7936 }
7937}
7938impl<'de> serde::Deserialize<'de> for MaterializeNode {
7939 #[allow(deprecated)]
7940 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7941 where
7942 D: serde::Deserializer<'de>,
7943 {
7944 const FIELDS: &[&str] = &[
7945 "table_id",
7946 "tableId",
7947 "column_orders",
7948 "columnOrders",
7949 "table",
7950 "staging_table",
7951 "stagingTable",
7952 "refresh_progress_table",
7953 "refreshProgressTable",
7954 "cleaned_by_ttl_watermark",
7955 "cleanedByTtlWatermark",
7956 ];
7957
7958 #[allow(clippy::enum_variant_names)]
7959 enum GeneratedField {
7960 TableId,
7961 ColumnOrders,
7962 Table,
7963 StagingTable,
7964 RefreshProgressTable,
7965 CleanedByTtlWatermark,
7966 }
7967 impl<'de> serde::Deserialize<'de> for GeneratedField {
7968 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7969 where
7970 D: serde::Deserializer<'de>,
7971 {
7972 struct GeneratedVisitor;
7973
7974 impl serde::de::Visitor<'_> for GeneratedVisitor {
7975 type Value = GeneratedField;
7976
7977 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7978 write!(formatter, "expected one of: {:?}", &FIELDS)
7979 }
7980
7981 #[allow(unused_variables)]
7982 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7983 where
7984 E: serde::de::Error,
7985 {
7986 match value {
7987 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7988 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
7989 "table" => Ok(GeneratedField::Table),
7990 "stagingTable" | "staging_table" => Ok(GeneratedField::StagingTable),
7991 "refreshProgressTable" | "refresh_progress_table" => Ok(GeneratedField::RefreshProgressTable),
7992 "cleanedByTtlWatermark" | "cleaned_by_ttl_watermark" => Ok(GeneratedField::CleanedByTtlWatermark),
7993 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7994 }
7995 }
7996 }
7997 deserializer.deserialize_identifier(GeneratedVisitor)
7998 }
7999 }
8000 struct GeneratedVisitor;
8001 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8002 type Value = MaterializeNode;
8003
8004 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8005 formatter.write_str("struct stream_plan.MaterializeNode")
8006 }
8007
8008 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializeNode, V::Error>
8009 where
8010 V: serde::de::MapAccess<'de>,
8011 {
8012 let mut table_id__ = None;
8013 let mut column_orders__ = None;
8014 let mut table__ = None;
8015 let mut staging_table__ = None;
8016 let mut refresh_progress_table__ = None;
8017 let mut cleaned_by_ttl_watermark__ = None;
8018 while let Some(k) = map_.next_key()? {
8019 match k {
8020 GeneratedField::TableId => {
8021 if table_id__.is_some() {
8022 return Err(serde::de::Error::duplicate_field("tableId"));
8023 }
8024 table_id__ =
8025 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8026 ;
8027 }
8028 GeneratedField::ColumnOrders => {
8029 if column_orders__.is_some() {
8030 return Err(serde::de::Error::duplicate_field("columnOrders"));
8031 }
8032 column_orders__ = Some(map_.next_value()?);
8033 }
8034 GeneratedField::Table => {
8035 if table__.is_some() {
8036 return Err(serde::de::Error::duplicate_field("table"));
8037 }
8038 table__ = map_.next_value()?;
8039 }
8040 GeneratedField::StagingTable => {
8041 if staging_table__.is_some() {
8042 return Err(serde::de::Error::duplicate_field("stagingTable"));
8043 }
8044 staging_table__ = map_.next_value()?;
8045 }
8046 GeneratedField::RefreshProgressTable => {
8047 if refresh_progress_table__.is_some() {
8048 return Err(serde::de::Error::duplicate_field("refreshProgressTable"));
8049 }
8050 refresh_progress_table__ = map_.next_value()?;
8051 }
8052 GeneratedField::CleanedByTtlWatermark => {
8053 if cleaned_by_ttl_watermark__.is_some() {
8054 return Err(serde::de::Error::duplicate_field("cleanedByTtlWatermark"));
8055 }
8056 cleaned_by_ttl_watermark__ = Some(map_.next_value()?);
8057 }
8058 }
8059 }
8060 Ok(MaterializeNode {
8061 table_id: table_id__.unwrap_or_default(),
8062 column_orders: column_orders__.unwrap_or_default(),
8063 table: table__,
8064 staging_table: staging_table__,
8065 refresh_progress_table: refresh_progress_table__,
8066 cleaned_by_ttl_watermark: cleaned_by_ttl_watermark__.unwrap_or_default(),
8067 })
8068 }
8069 }
8070 deserializer.deserialize_struct("stream_plan.MaterializeNode", FIELDS, GeneratedVisitor)
8071 }
8072}
8073impl serde::Serialize for MaterializedExprsNode {
8074 #[allow(deprecated)]
8075 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8076 where
8077 S: serde::Serializer,
8078 {
8079 use serde::ser::SerializeStruct;
8080 let mut len = 0;
8081 if !self.exprs.is_empty() {
8082 len += 1;
8083 }
8084 if self.state_table.is_some() {
8085 len += 1;
8086 }
8087 if self.state_clean_col_idx.is_some() {
8088 len += 1;
8089 }
8090 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializedExprsNode", len)?;
8091 if !self.exprs.is_empty() {
8092 struct_ser.serialize_field("exprs", &self.exprs)?;
8093 }
8094 if let Some(v) = self.state_table.as_ref() {
8095 struct_ser.serialize_field("stateTable", v)?;
8096 }
8097 if let Some(v) = self.state_clean_col_idx.as_ref() {
8098 struct_ser.serialize_field("stateCleanColIdx", v)?;
8099 }
8100 struct_ser.end()
8101 }
8102}
8103impl<'de> serde::Deserialize<'de> for MaterializedExprsNode {
8104 #[allow(deprecated)]
8105 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8106 where
8107 D: serde::Deserializer<'de>,
8108 {
8109 const FIELDS: &[&str] = &[
8110 "exprs",
8111 "state_table",
8112 "stateTable",
8113 "state_clean_col_idx",
8114 "stateCleanColIdx",
8115 ];
8116
8117 #[allow(clippy::enum_variant_names)]
8118 enum GeneratedField {
8119 Exprs,
8120 StateTable,
8121 StateCleanColIdx,
8122 }
8123 impl<'de> serde::Deserialize<'de> for GeneratedField {
8124 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8125 where
8126 D: serde::Deserializer<'de>,
8127 {
8128 struct GeneratedVisitor;
8129
8130 impl serde::de::Visitor<'_> for GeneratedVisitor {
8131 type Value = GeneratedField;
8132
8133 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8134 write!(formatter, "expected one of: {:?}", &FIELDS)
8135 }
8136
8137 #[allow(unused_variables)]
8138 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8139 where
8140 E: serde::de::Error,
8141 {
8142 match value {
8143 "exprs" => Ok(GeneratedField::Exprs),
8144 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
8145 "stateCleanColIdx" | "state_clean_col_idx" => Ok(GeneratedField::StateCleanColIdx),
8146 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8147 }
8148 }
8149 }
8150 deserializer.deserialize_identifier(GeneratedVisitor)
8151 }
8152 }
8153 struct GeneratedVisitor;
8154 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8155 type Value = MaterializedExprsNode;
8156
8157 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8158 formatter.write_str("struct stream_plan.MaterializedExprsNode")
8159 }
8160
8161 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializedExprsNode, V::Error>
8162 where
8163 V: serde::de::MapAccess<'de>,
8164 {
8165 let mut exprs__ = None;
8166 let mut state_table__ = None;
8167 let mut state_clean_col_idx__ = None;
8168 while let Some(k) = map_.next_key()? {
8169 match k {
8170 GeneratedField::Exprs => {
8171 if exprs__.is_some() {
8172 return Err(serde::de::Error::duplicate_field("exprs"));
8173 }
8174 exprs__ = Some(map_.next_value()?);
8175 }
8176 GeneratedField::StateTable => {
8177 if state_table__.is_some() {
8178 return Err(serde::de::Error::duplicate_field("stateTable"));
8179 }
8180 state_table__ = map_.next_value()?;
8181 }
8182 GeneratedField::StateCleanColIdx => {
8183 if state_clean_col_idx__.is_some() {
8184 return Err(serde::de::Error::duplicate_field("stateCleanColIdx"));
8185 }
8186 state_clean_col_idx__ =
8187 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
8188 ;
8189 }
8190 }
8191 }
8192 Ok(MaterializedExprsNode {
8193 exprs: exprs__.unwrap_or_default(),
8194 state_table: state_table__,
8195 state_clean_col_idx: state_clean_col_idx__,
8196 })
8197 }
8198 }
8199 deserializer.deserialize_struct("stream_plan.MaterializedExprsNode", FIELDS, GeneratedVisitor)
8200 }
8201}
8202impl serde::Serialize for MergeNode {
8203 #[allow(deprecated)]
8204 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8205 where
8206 S: serde::Serializer,
8207 {
8208 use serde::ser::SerializeStruct;
8209 let mut len = 0;
8210 if !self.upstream_actor_id.is_empty() {
8211 len += 1;
8212 }
8213 if self.upstream_fragment_id != 0 {
8214 len += 1;
8215 }
8216 if self.upstream_dispatcher_type != 0 {
8217 len += 1;
8218 }
8219 if !self.fields.is_empty() {
8220 len += 1;
8221 }
8222 let mut struct_ser = serializer.serialize_struct("stream_plan.MergeNode", len)?;
8223 if !self.upstream_actor_id.is_empty() {
8224 struct_ser.serialize_field("upstreamActorId", &self.upstream_actor_id)?;
8225 }
8226 if self.upstream_fragment_id != 0 {
8227 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
8228 }
8229 if self.upstream_dispatcher_type != 0 {
8230 let v = DispatcherType::try_from(self.upstream_dispatcher_type)
8231 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.upstream_dispatcher_type)))?;
8232 struct_ser.serialize_field("upstreamDispatcherType", &v)?;
8233 }
8234 if !self.fields.is_empty() {
8235 struct_ser.serialize_field("fields", &self.fields)?;
8236 }
8237 struct_ser.end()
8238 }
8239}
8240impl<'de> serde::Deserialize<'de> for MergeNode {
8241 #[allow(deprecated)]
8242 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8243 where
8244 D: serde::Deserializer<'de>,
8245 {
8246 const FIELDS: &[&str] = &[
8247 "upstream_actor_id",
8248 "upstreamActorId",
8249 "upstream_fragment_id",
8250 "upstreamFragmentId",
8251 "upstream_dispatcher_type",
8252 "upstreamDispatcherType",
8253 "fields",
8254 ];
8255
8256 #[allow(clippy::enum_variant_names)]
8257 enum GeneratedField {
8258 UpstreamActorId,
8259 UpstreamFragmentId,
8260 UpstreamDispatcherType,
8261 Fields,
8262 }
8263 impl<'de> serde::Deserialize<'de> for GeneratedField {
8264 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8265 where
8266 D: serde::Deserializer<'de>,
8267 {
8268 struct GeneratedVisitor;
8269
8270 impl serde::de::Visitor<'_> for GeneratedVisitor {
8271 type Value = GeneratedField;
8272
8273 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8274 write!(formatter, "expected one of: {:?}", &FIELDS)
8275 }
8276
8277 #[allow(unused_variables)]
8278 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8279 where
8280 E: serde::de::Error,
8281 {
8282 match value {
8283 "upstreamActorId" | "upstream_actor_id" => Ok(GeneratedField::UpstreamActorId),
8284 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
8285 "upstreamDispatcherType" | "upstream_dispatcher_type" => Ok(GeneratedField::UpstreamDispatcherType),
8286 "fields" => Ok(GeneratedField::Fields),
8287 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8288 }
8289 }
8290 }
8291 deserializer.deserialize_identifier(GeneratedVisitor)
8292 }
8293 }
8294 struct GeneratedVisitor;
8295 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8296 type Value = MergeNode;
8297
8298 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8299 formatter.write_str("struct stream_plan.MergeNode")
8300 }
8301
8302 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeNode, V::Error>
8303 where
8304 V: serde::de::MapAccess<'de>,
8305 {
8306 let mut upstream_actor_id__ = None;
8307 let mut upstream_fragment_id__ = None;
8308 let mut upstream_dispatcher_type__ = None;
8309 let mut fields__ = None;
8310 while let Some(k) = map_.next_key()? {
8311 match k {
8312 GeneratedField::UpstreamActorId => {
8313 if upstream_actor_id__.is_some() {
8314 return Err(serde::de::Error::duplicate_field("upstreamActorId"));
8315 }
8316 upstream_actor_id__ =
8317 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8318 .into_iter().map(|x| x.0).collect())
8319 ;
8320 }
8321 GeneratedField::UpstreamFragmentId => {
8322 if upstream_fragment_id__.is_some() {
8323 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
8324 }
8325 upstream_fragment_id__ =
8326 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8327 ;
8328 }
8329 GeneratedField::UpstreamDispatcherType => {
8330 if upstream_dispatcher_type__.is_some() {
8331 return Err(serde::de::Error::duplicate_field("upstreamDispatcherType"));
8332 }
8333 upstream_dispatcher_type__ = Some(map_.next_value::<DispatcherType>()? as i32);
8334 }
8335 GeneratedField::Fields => {
8336 if fields__.is_some() {
8337 return Err(serde::de::Error::duplicate_field("fields"));
8338 }
8339 fields__ = Some(map_.next_value()?);
8340 }
8341 }
8342 }
8343 Ok(MergeNode {
8344 upstream_actor_id: upstream_actor_id__.unwrap_or_default(),
8345 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
8346 upstream_dispatcher_type: upstream_dispatcher_type__.unwrap_or_default(),
8347 fields: fields__.unwrap_or_default(),
8348 })
8349 }
8350 }
8351 deserializer.deserialize_struct("stream_plan.MergeNode", FIELDS, GeneratedVisitor)
8352 }
8353}
8354impl serde::Serialize for NoOpNode {
8355 #[allow(deprecated)]
8356 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8357 where
8358 S: serde::Serializer,
8359 {
8360 use serde::ser::SerializeStruct;
8361 let len = 0;
8362 let struct_ser = serializer.serialize_struct("stream_plan.NoOpNode", len)?;
8363 struct_ser.end()
8364 }
8365}
8366impl<'de> serde::Deserialize<'de> for NoOpNode {
8367 #[allow(deprecated)]
8368 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8369 where
8370 D: serde::Deserializer<'de>,
8371 {
8372 const FIELDS: &[&str] = &[
8373 ];
8374
8375 #[allow(clippy::enum_variant_names)]
8376 enum GeneratedField {
8377 }
8378 impl<'de> serde::Deserialize<'de> for GeneratedField {
8379 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8380 where
8381 D: serde::Deserializer<'de>,
8382 {
8383 struct GeneratedVisitor;
8384
8385 impl serde::de::Visitor<'_> for GeneratedVisitor {
8386 type Value = GeneratedField;
8387
8388 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8389 write!(formatter, "expected one of: {:?}", &FIELDS)
8390 }
8391
8392 #[allow(unused_variables)]
8393 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8394 where
8395 E: serde::de::Error,
8396 {
8397 Err(serde::de::Error::unknown_field(value, FIELDS))
8398 }
8399 }
8400 deserializer.deserialize_identifier(GeneratedVisitor)
8401 }
8402 }
8403 struct GeneratedVisitor;
8404 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8405 type Value = NoOpNode;
8406
8407 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8408 formatter.write_str("struct stream_plan.NoOpNode")
8409 }
8410
8411 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NoOpNode, V::Error>
8412 where
8413 V: serde::de::MapAccess<'de>,
8414 {
8415 while map_.next_key::<GeneratedField>()?.is_some() {
8416 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8417 }
8418 Ok(NoOpNode {
8419 })
8420 }
8421 }
8422 deserializer.deserialize_struct("stream_plan.NoOpNode", FIELDS, GeneratedVisitor)
8423 }
8424}
8425impl serde::Serialize for NowModeGenerateSeries {
8426 #[allow(deprecated)]
8427 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8428 where
8429 S: serde::Serializer,
8430 {
8431 use serde::ser::SerializeStruct;
8432 let mut len = 0;
8433 if self.start_timestamp.is_some() {
8434 len += 1;
8435 }
8436 if self.interval.is_some() {
8437 len += 1;
8438 }
8439 let mut struct_ser = serializer.serialize_struct("stream_plan.NowModeGenerateSeries", len)?;
8440 if let Some(v) = self.start_timestamp.as_ref() {
8441 struct_ser.serialize_field("startTimestamp", v)?;
8442 }
8443 if let Some(v) = self.interval.as_ref() {
8444 struct_ser.serialize_field("interval", v)?;
8445 }
8446 struct_ser.end()
8447 }
8448}
8449impl<'de> serde::Deserialize<'de> for NowModeGenerateSeries {
8450 #[allow(deprecated)]
8451 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8452 where
8453 D: serde::Deserializer<'de>,
8454 {
8455 const FIELDS: &[&str] = &[
8456 "start_timestamp",
8457 "startTimestamp",
8458 "interval",
8459 ];
8460
8461 #[allow(clippy::enum_variant_names)]
8462 enum GeneratedField {
8463 StartTimestamp,
8464 Interval,
8465 }
8466 impl<'de> serde::Deserialize<'de> for GeneratedField {
8467 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8468 where
8469 D: serde::Deserializer<'de>,
8470 {
8471 struct GeneratedVisitor;
8472
8473 impl serde::de::Visitor<'_> for GeneratedVisitor {
8474 type Value = GeneratedField;
8475
8476 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8477 write!(formatter, "expected one of: {:?}", &FIELDS)
8478 }
8479
8480 #[allow(unused_variables)]
8481 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8482 where
8483 E: serde::de::Error,
8484 {
8485 match value {
8486 "startTimestamp" | "start_timestamp" => Ok(GeneratedField::StartTimestamp),
8487 "interval" => Ok(GeneratedField::Interval),
8488 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8489 }
8490 }
8491 }
8492 deserializer.deserialize_identifier(GeneratedVisitor)
8493 }
8494 }
8495 struct GeneratedVisitor;
8496 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8497 type Value = NowModeGenerateSeries;
8498
8499 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8500 formatter.write_str("struct stream_plan.NowModeGenerateSeries")
8501 }
8502
8503 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeGenerateSeries, V::Error>
8504 where
8505 V: serde::de::MapAccess<'de>,
8506 {
8507 let mut start_timestamp__ = None;
8508 let mut interval__ = None;
8509 while let Some(k) = map_.next_key()? {
8510 match k {
8511 GeneratedField::StartTimestamp => {
8512 if start_timestamp__.is_some() {
8513 return Err(serde::de::Error::duplicate_field("startTimestamp"));
8514 }
8515 start_timestamp__ = map_.next_value()?;
8516 }
8517 GeneratedField::Interval => {
8518 if interval__.is_some() {
8519 return Err(serde::de::Error::duplicate_field("interval"));
8520 }
8521 interval__ = map_.next_value()?;
8522 }
8523 }
8524 }
8525 Ok(NowModeGenerateSeries {
8526 start_timestamp: start_timestamp__,
8527 interval: interval__,
8528 })
8529 }
8530 }
8531 deserializer.deserialize_struct("stream_plan.NowModeGenerateSeries", FIELDS, GeneratedVisitor)
8532 }
8533}
8534impl serde::Serialize for NowModeUpdateCurrent {
8535 #[allow(deprecated)]
8536 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8537 where
8538 S: serde::Serializer,
8539 {
8540 use serde::ser::SerializeStruct;
8541 let len = 0;
8542 let struct_ser = serializer.serialize_struct("stream_plan.NowModeUpdateCurrent", len)?;
8543 struct_ser.end()
8544 }
8545}
8546impl<'de> serde::Deserialize<'de> for NowModeUpdateCurrent {
8547 #[allow(deprecated)]
8548 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8549 where
8550 D: serde::Deserializer<'de>,
8551 {
8552 const FIELDS: &[&str] = &[
8553 ];
8554
8555 #[allow(clippy::enum_variant_names)]
8556 enum GeneratedField {
8557 }
8558 impl<'de> serde::Deserialize<'de> for GeneratedField {
8559 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8560 where
8561 D: serde::Deserializer<'de>,
8562 {
8563 struct GeneratedVisitor;
8564
8565 impl serde::de::Visitor<'_> for GeneratedVisitor {
8566 type Value = GeneratedField;
8567
8568 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8569 write!(formatter, "expected one of: {:?}", &FIELDS)
8570 }
8571
8572 #[allow(unused_variables)]
8573 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8574 where
8575 E: serde::de::Error,
8576 {
8577 Err(serde::de::Error::unknown_field(value, FIELDS))
8578 }
8579 }
8580 deserializer.deserialize_identifier(GeneratedVisitor)
8581 }
8582 }
8583 struct GeneratedVisitor;
8584 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8585 type Value = NowModeUpdateCurrent;
8586
8587 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8588 formatter.write_str("struct stream_plan.NowModeUpdateCurrent")
8589 }
8590
8591 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeUpdateCurrent, V::Error>
8592 where
8593 V: serde::de::MapAccess<'de>,
8594 {
8595 while map_.next_key::<GeneratedField>()?.is_some() {
8596 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8597 }
8598 Ok(NowModeUpdateCurrent {
8599 })
8600 }
8601 }
8602 deserializer.deserialize_struct("stream_plan.NowModeUpdateCurrent", FIELDS, GeneratedVisitor)
8603 }
8604}
8605impl serde::Serialize for NowNode {
8606 #[allow(deprecated)]
8607 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8608 where
8609 S: serde::Serializer,
8610 {
8611 use serde::ser::SerializeStruct;
8612 let mut len = 0;
8613 if self.state_table.is_some() {
8614 len += 1;
8615 }
8616 if self.mode.is_some() {
8617 len += 1;
8618 }
8619 let mut struct_ser = serializer.serialize_struct("stream_plan.NowNode", len)?;
8620 if let Some(v) = self.state_table.as_ref() {
8621 struct_ser.serialize_field("stateTable", v)?;
8622 }
8623 if let Some(v) = self.mode.as_ref() {
8624 match v {
8625 now_node::Mode::UpdateCurrent(v) => {
8626 struct_ser.serialize_field("updateCurrent", v)?;
8627 }
8628 now_node::Mode::GenerateSeries(v) => {
8629 struct_ser.serialize_field("generateSeries", v)?;
8630 }
8631 }
8632 }
8633 struct_ser.end()
8634 }
8635}
8636impl<'de> serde::Deserialize<'de> for NowNode {
8637 #[allow(deprecated)]
8638 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8639 where
8640 D: serde::Deserializer<'de>,
8641 {
8642 const FIELDS: &[&str] = &[
8643 "state_table",
8644 "stateTable",
8645 "update_current",
8646 "updateCurrent",
8647 "generate_series",
8648 "generateSeries",
8649 ];
8650
8651 #[allow(clippy::enum_variant_names)]
8652 enum GeneratedField {
8653 StateTable,
8654 UpdateCurrent,
8655 GenerateSeries,
8656 }
8657 impl<'de> serde::Deserialize<'de> for GeneratedField {
8658 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8659 where
8660 D: serde::Deserializer<'de>,
8661 {
8662 struct GeneratedVisitor;
8663
8664 impl serde::de::Visitor<'_> for GeneratedVisitor {
8665 type Value = GeneratedField;
8666
8667 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8668 write!(formatter, "expected one of: {:?}", &FIELDS)
8669 }
8670
8671 #[allow(unused_variables)]
8672 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8673 where
8674 E: serde::de::Error,
8675 {
8676 match value {
8677 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
8678 "updateCurrent" | "update_current" => Ok(GeneratedField::UpdateCurrent),
8679 "generateSeries" | "generate_series" => Ok(GeneratedField::GenerateSeries),
8680 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8681 }
8682 }
8683 }
8684 deserializer.deserialize_identifier(GeneratedVisitor)
8685 }
8686 }
8687 struct GeneratedVisitor;
8688 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8689 type Value = NowNode;
8690
8691 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8692 formatter.write_str("struct stream_plan.NowNode")
8693 }
8694
8695 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowNode, V::Error>
8696 where
8697 V: serde::de::MapAccess<'de>,
8698 {
8699 let mut state_table__ = None;
8700 let mut mode__ = None;
8701 while let Some(k) = map_.next_key()? {
8702 match k {
8703 GeneratedField::StateTable => {
8704 if state_table__.is_some() {
8705 return Err(serde::de::Error::duplicate_field("stateTable"));
8706 }
8707 state_table__ = map_.next_value()?;
8708 }
8709 GeneratedField::UpdateCurrent => {
8710 if mode__.is_some() {
8711 return Err(serde::de::Error::duplicate_field("updateCurrent"));
8712 }
8713 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::UpdateCurrent)
8714;
8715 }
8716 GeneratedField::GenerateSeries => {
8717 if mode__.is_some() {
8718 return Err(serde::de::Error::duplicate_field("generateSeries"));
8719 }
8720 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::GenerateSeries)
8721;
8722 }
8723 }
8724 }
8725 Ok(NowNode {
8726 state_table: state_table__,
8727 mode: mode__,
8728 })
8729 }
8730 }
8731 deserializer.deserialize_struct("stream_plan.NowNode", FIELDS, GeneratedVisitor)
8732 }
8733}
8734impl serde::Serialize for OverWindowCachePolicy {
8735 #[allow(deprecated)]
8736 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8737 where
8738 S: serde::Serializer,
8739 {
8740 let variant = match self {
8741 Self::Unspecified => "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
8742 Self::Full => "OVER_WINDOW_CACHE_POLICY_FULL",
8743 Self::Recent => "OVER_WINDOW_CACHE_POLICY_RECENT",
8744 Self::RecentFirstN => "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
8745 Self::RecentLastN => "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
8746 };
8747 serializer.serialize_str(variant)
8748 }
8749}
8750impl<'de> serde::Deserialize<'de> for OverWindowCachePolicy {
8751 #[allow(deprecated)]
8752 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8753 where
8754 D: serde::Deserializer<'de>,
8755 {
8756 const FIELDS: &[&str] = &[
8757 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
8758 "OVER_WINDOW_CACHE_POLICY_FULL",
8759 "OVER_WINDOW_CACHE_POLICY_RECENT",
8760 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
8761 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
8762 ];
8763
8764 struct GeneratedVisitor;
8765
8766 impl serde::de::Visitor<'_> for GeneratedVisitor {
8767 type Value = OverWindowCachePolicy;
8768
8769 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8770 write!(formatter, "expected one of: {:?}", &FIELDS)
8771 }
8772
8773 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8774 where
8775 E: serde::de::Error,
8776 {
8777 i32::try_from(v)
8778 .ok()
8779 .and_then(|x| x.try_into().ok())
8780 .ok_or_else(|| {
8781 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8782 })
8783 }
8784
8785 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8786 where
8787 E: serde::de::Error,
8788 {
8789 i32::try_from(v)
8790 .ok()
8791 .and_then(|x| x.try_into().ok())
8792 .ok_or_else(|| {
8793 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8794 })
8795 }
8796
8797 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8798 where
8799 E: serde::de::Error,
8800 {
8801 match value {
8802 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED" => Ok(OverWindowCachePolicy::Unspecified),
8803 "OVER_WINDOW_CACHE_POLICY_FULL" => Ok(OverWindowCachePolicy::Full),
8804 "OVER_WINDOW_CACHE_POLICY_RECENT" => Ok(OverWindowCachePolicy::Recent),
8805 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N" => Ok(OverWindowCachePolicy::RecentFirstN),
8806 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N" => Ok(OverWindowCachePolicy::RecentLastN),
8807 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8808 }
8809 }
8810 }
8811 deserializer.deserialize_any(GeneratedVisitor)
8812 }
8813}
8814impl serde::Serialize for OverWindowNode {
8815 #[allow(deprecated)]
8816 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8817 where
8818 S: serde::Serializer,
8819 {
8820 use serde::ser::SerializeStruct;
8821 let mut len = 0;
8822 if !self.calls.is_empty() {
8823 len += 1;
8824 }
8825 if !self.partition_by.is_empty() {
8826 len += 1;
8827 }
8828 if !self.order_by.is_empty() {
8829 len += 1;
8830 }
8831 if self.state_table.is_some() {
8832 len += 1;
8833 }
8834 if self.cache_policy != 0 {
8835 len += 1;
8836 }
8837 let mut struct_ser = serializer.serialize_struct("stream_plan.OverWindowNode", len)?;
8838 if !self.calls.is_empty() {
8839 struct_ser.serialize_field("calls", &self.calls)?;
8840 }
8841 if !self.partition_by.is_empty() {
8842 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
8843 }
8844 if !self.order_by.is_empty() {
8845 struct_ser.serialize_field("orderBy", &self.order_by)?;
8846 }
8847 if let Some(v) = self.state_table.as_ref() {
8848 struct_ser.serialize_field("stateTable", v)?;
8849 }
8850 if self.cache_policy != 0 {
8851 let v = OverWindowCachePolicy::try_from(self.cache_policy)
8852 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cache_policy)))?;
8853 struct_ser.serialize_field("cachePolicy", &v)?;
8854 }
8855 struct_ser.end()
8856 }
8857}
8858impl<'de> serde::Deserialize<'de> for OverWindowNode {
8859 #[allow(deprecated)]
8860 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8861 where
8862 D: serde::Deserializer<'de>,
8863 {
8864 const FIELDS: &[&str] = &[
8865 "calls",
8866 "partition_by",
8867 "partitionBy",
8868 "order_by",
8869 "orderBy",
8870 "state_table",
8871 "stateTable",
8872 "cache_policy",
8873 "cachePolicy",
8874 ];
8875
8876 #[allow(clippy::enum_variant_names)]
8877 enum GeneratedField {
8878 Calls,
8879 PartitionBy,
8880 OrderBy,
8881 StateTable,
8882 CachePolicy,
8883 }
8884 impl<'de> serde::Deserialize<'de> for GeneratedField {
8885 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8886 where
8887 D: serde::Deserializer<'de>,
8888 {
8889 struct GeneratedVisitor;
8890
8891 impl serde::de::Visitor<'_> for GeneratedVisitor {
8892 type Value = GeneratedField;
8893
8894 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8895 write!(formatter, "expected one of: {:?}", &FIELDS)
8896 }
8897
8898 #[allow(unused_variables)]
8899 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8900 where
8901 E: serde::de::Error,
8902 {
8903 match value {
8904 "calls" => Ok(GeneratedField::Calls),
8905 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
8906 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
8907 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
8908 "cachePolicy" | "cache_policy" => Ok(GeneratedField::CachePolicy),
8909 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8910 }
8911 }
8912 }
8913 deserializer.deserialize_identifier(GeneratedVisitor)
8914 }
8915 }
8916 struct GeneratedVisitor;
8917 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8918 type Value = OverWindowNode;
8919
8920 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8921 formatter.write_str("struct stream_plan.OverWindowNode")
8922 }
8923
8924 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverWindowNode, V::Error>
8925 where
8926 V: serde::de::MapAccess<'de>,
8927 {
8928 let mut calls__ = None;
8929 let mut partition_by__ = None;
8930 let mut order_by__ = None;
8931 let mut state_table__ = None;
8932 let mut cache_policy__ = None;
8933 while let Some(k) = map_.next_key()? {
8934 match k {
8935 GeneratedField::Calls => {
8936 if calls__.is_some() {
8937 return Err(serde::de::Error::duplicate_field("calls"));
8938 }
8939 calls__ = Some(map_.next_value()?);
8940 }
8941 GeneratedField::PartitionBy => {
8942 if partition_by__.is_some() {
8943 return Err(serde::de::Error::duplicate_field("partitionBy"));
8944 }
8945 partition_by__ =
8946 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8947 .into_iter().map(|x| x.0).collect())
8948 ;
8949 }
8950 GeneratedField::OrderBy => {
8951 if order_by__.is_some() {
8952 return Err(serde::de::Error::duplicate_field("orderBy"));
8953 }
8954 order_by__ = Some(map_.next_value()?);
8955 }
8956 GeneratedField::StateTable => {
8957 if state_table__.is_some() {
8958 return Err(serde::de::Error::duplicate_field("stateTable"));
8959 }
8960 state_table__ = map_.next_value()?;
8961 }
8962 GeneratedField::CachePolicy => {
8963 if cache_policy__.is_some() {
8964 return Err(serde::de::Error::duplicate_field("cachePolicy"));
8965 }
8966 cache_policy__ = Some(map_.next_value::<OverWindowCachePolicy>()? as i32);
8967 }
8968 }
8969 }
8970 Ok(OverWindowNode {
8971 calls: calls__.unwrap_or_default(),
8972 partition_by: partition_by__.unwrap_or_default(),
8973 order_by: order_by__.unwrap_or_default(),
8974 state_table: state_table__,
8975 cache_policy: cache_policy__.unwrap_or_default(),
8976 })
8977 }
8978 }
8979 deserializer.deserialize_struct("stream_plan.OverWindowNode", FIELDS, GeneratedVisitor)
8980 }
8981}
8982impl serde::Serialize for PauseMutation {
8983 #[allow(deprecated)]
8984 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8985 where
8986 S: serde::Serializer,
8987 {
8988 use serde::ser::SerializeStruct;
8989 let len = 0;
8990 let struct_ser = serializer.serialize_struct("stream_plan.PauseMutation", len)?;
8991 struct_ser.end()
8992 }
8993}
8994impl<'de> serde::Deserialize<'de> for PauseMutation {
8995 #[allow(deprecated)]
8996 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8997 where
8998 D: serde::Deserializer<'de>,
8999 {
9000 const FIELDS: &[&str] = &[
9001 ];
9002
9003 #[allow(clippy::enum_variant_names)]
9004 enum GeneratedField {
9005 }
9006 impl<'de> serde::Deserialize<'de> for GeneratedField {
9007 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9008 where
9009 D: serde::Deserializer<'de>,
9010 {
9011 struct GeneratedVisitor;
9012
9013 impl serde::de::Visitor<'_> for GeneratedVisitor {
9014 type Value = GeneratedField;
9015
9016 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9017 write!(formatter, "expected one of: {:?}", &FIELDS)
9018 }
9019
9020 #[allow(unused_variables)]
9021 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9022 where
9023 E: serde::de::Error,
9024 {
9025 Err(serde::de::Error::unknown_field(value, FIELDS))
9026 }
9027 }
9028 deserializer.deserialize_identifier(GeneratedVisitor)
9029 }
9030 }
9031 struct GeneratedVisitor;
9032 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9033 type Value = PauseMutation;
9034
9035 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9036 formatter.write_str("struct stream_plan.PauseMutation")
9037 }
9038
9039 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseMutation, V::Error>
9040 where
9041 V: serde::de::MapAccess<'de>,
9042 {
9043 while map_.next_key::<GeneratedField>()?.is_some() {
9044 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9045 }
9046 Ok(PauseMutation {
9047 })
9048 }
9049 }
9050 deserializer.deserialize_struct("stream_plan.PauseMutation", FIELDS, GeneratedVisitor)
9051 }
9052}
9053impl serde::Serialize for ProjectNode {
9054 #[allow(deprecated)]
9055 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9056 where
9057 S: serde::Serializer,
9058 {
9059 use serde::ser::SerializeStruct;
9060 let mut len = 0;
9061 if !self.select_list.is_empty() {
9062 len += 1;
9063 }
9064 if !self.watermark_input_cols.is_empty() {
9065 len += 1;
9066 }
9067 if !self.watermark_output_cols.is_empty() {
9068 len += 1;
9069 }
9070 if !self.nondecreasing_exprs.is_empty() {
9071 len += 1;
9072 }
9073 if self.noop_update_hint {
9074 len += 1;
9075 }
9076 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectNode", len)?;
9077 if !self.select_list.is_empty() {
9078 struct_ser.serialize_field("selectList", &self.select_list)?;
9079 }
9080 if !self.watermark_input_cols.is_empty() {
9081 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
9082 }
9083 if !self.watermark_output_cols.is_empty() {
9084 struct_ser.serialize_field("watermarkOutputCols", &self.watermark_output_cols)?;
9085 }
9086 if !self.nondecreasing_exprs.is_empty() {
9087 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
9088 }
9089 if self.noop_update_hint {
9090 struct_ser.serialize_field("noopUpdateHint", &self.noop_update_hint)?;
9091 }
9092 struct_ser.end()
9093 }
9094}
9095impl<'de> serde::Deserialize<'de> for ProjectNode {
9096 #[allow(deprecated)]
9097 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9098 where
9099 D: serde::Deserializer<'de>,
9100 {
9101 const FIELDS: &[&str] = &[
9102 "select_list",
9103 "selectList",
9104 "watermark_input_cols",
9105 "watermarkInputCols",
9106 "watermark_output_cols",
9107 "watermarkOutputCols",
9108 "nondecreasing_exprs",
9109 "nondecreasingExprs",
9110 "noop_update_hint",
9111 "noopUpdateHint",
9112 ];
9113
9114 #[allow(clippy::enum_variant_names)]
9115 enum GeneratedField {
9116 SelectList,
9117 WatermarkInputCols,
9118 WatermarkOutputCols,
9119 NondecreasingExprs,
9120 NoopUpdateHint,
9121 }
9122 impl<'de> serde::Deserialize<'de> for GeneratedField {
9123 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9124 where
9125 D: serde::Deserializer<'de>,
9126 {
9127 struct GeneratedVisitor;
9128
9129 impl serde::de::Visitor<'_> for GeneratedVisitor {
9130 type Value = GeneratedField;
9131
9132 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9133 write!(formatter, "expected one of: {:?}", &FIELDS)
9134 }
9135
9136 #[allow(unused_variables)]
9137 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9138 where
9139 E: serde::de::Error,
9140 {
9141 match value {
9142 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
9143 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
9144 "watermarkOutputCols" | "watermark_output_cols" => Ok(GeneratedField::WatermarkOutputCols),
9145 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
9146 "noopUpdateHint" | "noop_update_hint" => Ok(GeneratedField::NoopUpdateHint),
9147 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9148 }
9149 }
9150 }
9151 deserializer.deserialize_identifier(GeneratedVisitor)
9152 }
9153 }
9154 struct GeneratedVisitor;
9155 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9156 type Value = ProjectNode;
9157
9158 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9159 formatter.write_str("struct stream_plan.ProjectNode")
9160 }
9161
9162 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
9163 where
9164 V: serde::de::MapAccess<'de>,
9165 {
9166 let mut select_list__ = None;
9167 let mut watermark_input_cols__ = None;
9168 let mut watermark_output_cols__ = None;
9169 let mut nondecreasing_exprs__ = None;
9170 let mut noop_update_hint__ = None;
9171 while let Some(k) = map_.next_key()? {
9172 match k {
9173 GeneratedField::SelectList => {
9174 if select_list__.is_some() {
9175 return Err(serde::de::Error::duplicate_field("selectList"));
9176 }
9177 select_list__ = Some(map_.next_value()?);
9178 }
9179 GeneratedField::WatermarkInputCols => {
9180 if watermark_input_cols__.is_some() {
9181 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
9182 }
9183 watermark_input_cols__ =
9184 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9185 .into_iter().map(|x| x.0).collect())
9186 ;
9187 }
9188 GeneratedField::WatermarkOutputCols => {
9189 if watermark_output_cols__.is_some() {
9190 return Err(serde::de::Error::duplicate_field("watermarkOutputCols"));
9191 }
9192 watermark_output_cols__ =
9193 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9194 .into_iter().map(|x| x.0).collect())
9195 ;
9196 }
9197 GeneratedField::NondecreasingExprs => {
9198 if nondecreasing_exprs__.is_some() {
9199 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
9200 }
9201 nondecreasing_exprs__ =
9202 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9203 .into_iter().map(|x| x.0).collect())
9204 ;
9205 }
9206 GeneratedField::NoopUpdateHint => {
9207 if noop_update_hint__.is_some() {
9208 return Err(serde::de::Error::duplicate_field("noopUpdateHint"));
9209 }
9210 noop_update_hint__ = Some(map_.next_value()?);
9211 }
9212 }
9213 }
9214 Ok(ProjectNode {
9215 select_list: select_list__.unwrap_or_default(),
9216 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
9217 watermark_output_cols: watermark_output_cols__.unwrap_or_default(),
9218 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
9219 noop_update_hint: noop_update_hint__.unwrap_or_default(),
9220 })
9221 }
9222 }
9223 deserializer.deserialize_struct("stream_plan.ProjectNode", FIELDS, GeneratedVisitor)
9224 }
9225}
9226impl serde::Serialize for ProjectSetNode {
9227 #[allow(deprecated)]
9228 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9229 where
9230 S: serde::Serializer,
9231 {
9232 use serde::ser::SerializeStruct;
9233 let mut len = 0;
9234 if !self.select_list.is_empty() {
9235 len += 1;
9236 }
9237 if !self.watermark_input_cols.is_empty() {
9238 len += 1;
9239 }
9240 if !self.watermark_expr_indices.is_empty() {
9241 len += 1;
9242 }
9243 if !self.nondecreasing_exprs.is_empty() {
9244 len += 1;
9245 }
9246 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectSetNode", len)?;
9247 if !self.select_list.is_empty() {
9248 struct_ser.serialize_field("selectList", &self.select_list)?;
9249 }
9250 if !self.watermark_input_cols.is_empty() {
9251 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
9252 }
9253 if !self.watermark_expr_indices.is_empty() {
9254 struct_ser.serialize_field("watermarkExprIndices", &self.watermark_expr_indices)?;
9255 }
9256 if !self.nondecreasing_exprs.is_empty() {
9257 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
9258 }
9259 struct_ser.end()
9260 }
9261}
9262impl<'de> serde::Deserialize<'de> for ProjectSetNode {
9263 #[allow(deprecated)]
9264 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9265 where
9266 D: serde::Deserializer<'de>,
9267 {
9268 const FIELDS: &[&str] = &[
9269 "select_list",
9270 "selectList",
9271 "watermark_input_cols",
9272 "watermarkInputCols",
9273 "watermark_expr_indices",
9274 "watermarkExprIndices",
9275 "nondecreasing_exprs",
9276 "nondecreasingExprs",
9277 ];
9278
9279 #[allow(clippy::enum_variant_names)]
9280 enum GeneratedField {
9281 SelectList,
9282 WatermarkInputCols,
9283 WatermarkExprIndices,
9284 NondecreasingExprs,
9285 }
9286 impl<'de> serde::Deserialize<'de> for GeneratedField {
9287 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9288 where
9289 D: serde::Deserializer<'de>,
9290 {
9291 struct GeneratedVisitor;
9292
9293 impl serde::de::Visitor<'_> for GeneratedVisitor {
9294 type Value = GeneratedField;
9295
9296 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9297 write!(formatter, "expected one of: {:?}", &FIELDS)
9298 }
9299
9300 #[allow(unused_variables)]
9301 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9302 where
9303 E: serde::de::Error,
9304 {
9305 match value {
9306 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
9307 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
9308 "watermarkExprIndices" | "watermark_expr_indices" => Ok(GeneratedField::WatermarkExprIndices),
9309 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
9310 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9311 }
9312 }
9313 }
9314 deserializer.deserialize_identifier(GeneratedVisitor)
9315 }
9316 }
9317 struct GeneratedVisitor;
9318 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9319 type Value = ProjectSetNode;
9320
9321 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9322 formatter.write_str("struct stream_plan.ProjectSetNode")
9323 }
9324
9325 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
9326 where
9327 V: serde::de::MapAccess<'de>,
9328 {
9329 let mut select_list__ = None;
9330 let mut watermark_input_cols__ = None;
9331 let mut watermark_expr_indices__ = None;
9332 let mut nondecreasing_exprs__ = None;
9333 while let Some(k) = map_.next_key()? {
9334 match k {
9335 GeneratedField::SelectList => {
9336 if select_list__.is_some() {
9337 return Err(serde::de::Error::duplicate_field("selectList"));
9338 }
9339 select_list__ = Some(map_.next_value()?);
9340 }
9341 GeneratedField::WatermarkInputCols => {
9342 if watermark_input_cols__.is_some() {
9343 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
9344 }
9345 watermark_input_cols__ =
9346 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9347 .into_iter().map(|x| x.0).collect())
9348 ;
9349 }
9350 GeneratedField::WatermarkExprIndices => {
9351 if watermark_expr_indices__.is_some() {
9352 return Err(serde::de::Error::duplicate_field("watermarkExprIndices"));
9353 }
9354 watermark_expr_indices__ =
9355 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9356 .into_iter().map(|x| x.0).collect())
9357 ;
9358 }
9359 GeneratedField::NondecreasingExprs => {
9360 if nondecreasing_exprs__.is_some() {
9361 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
9362 }
9363 nondecreasing_exprs__ =
9364 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9365 .into_iter().map(|x| x.0).collect())
9366 ;
9367 }
9368 }
9369 }
9370 Ok(ProjectSetNode {
9371 select_list: select_list__.unwrap_or_default(),
9372 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
9373 watermark_expr_indices: watermark_expr_indices__.unwrap_or_default(),
9374 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
9375 })
9376 }
9377 }
9378 deserializer.deserialize_struct("stream_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
9379 }
9380}
9381impl serde::Serialize for RefreshStartMutation {
9382 #[allow(deprecated)]
9383 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9384 where
9385 S: serde::Serializer,
9386 {
9387 use serde::ser::SerializeStruct;
9388 let mut len = 0;
9389 if self.table_id != 0 {
9390 len += 1;
9391 }
9392 if self.associated_source_id != 0 {
9393 len += 1;
9394 }
9395 let mut struct_ser = serializer.serialize_struct("stream_plan.RefreshStartMutation", len)?;
9396 if self.table_id != 0 {
9397 struct_ser.serialize_field("tableId", &self.table_id)?;
9398 }
9399 if self.associated_source_id != 0 {
9400 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
9401 }
9402 struct_ser.end()
9403 }
9404}
9405impl<'de> serde::Deserialize<'de> for RefreshStartMutation {
9406 #[allow(deprecated)]
9407 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9408 where
9409 D: serde::Deserializer<'de>,
9410 {
9411 const FIELDS: &[&str] = &[
9412 "table_id",
9413 "tableId",
9414 "associated_source_id",
9415 "associatedSourceId",
9416 ];
9417
9418 #[allow(clippy::enum_variant_names)]
9419 enum GeneratedField {
9420 TableId,
9421 AssociatedSourceId,
9422 }
9423 impl<'de> serde::Deserialize<'de> for GeneratedField {
9424 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9425 where
9426 D: serde::Deserializer<'de>,
9427 {
9428 struct GeneratedVisitor;
9429
9430 impl serde::de::Visitor<'_> for GeneratedVisitor {
9431 type Value = GeneratedField;
9432
9433 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9434 write!(formatter, "expected one of: {:?}", &FIELDS)
9435 }
9436
9437 #[allow(unused_variables)]
9438 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9439 where
9440 E: serde::de::Error,
9441 {
9442 match value {
9443 "tableId" | "table_id" => Ok(GeneratedField::TableId),
9444 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
9445 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9446 }
9447 }
9448 }
9449 deserializer.deserialize_identifier(GeneratedVisitor)
9450 }
9451 }
9452 struct GeneratedVisitor;
9453 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9454 type Value = RefreshStartMutation;
9455
9456 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9457 formatter.write_str("struct stream_plan.RefreshStartMutation")
9458 }
9459
9460 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshStartMutation, V::Error>
9461 where
9462 V: serde::de::MapAccess<'de>,
9463 {
9464 let mut table_id__ = None;
9465 let mut associated_source_id__ = None;
9466 while let Some(k) = map_.next_key()? {
9467 match k {
9468 GeneratedField::TableId => {
9469 if table_id__.is_some() {
9470 return Err(serde::de::Error::duplicate_field("tableId"));
9471 }
9472 table_id__ =
9473 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9474 ;
9475 }
9476 GeneratedField::AssociatedSourceId => {
9477 if associated_source_id__.is_some() {
9478 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
9479 }
9480 associated_source_id__ =
9481 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9482 ;
9483 }
9484 }
9485 }
9486 Ok(RefreshStartMutation {
9487 table_id: table_id__.unwrap_or_default(),
9488 associated_source_id: associated_source_id__.unwrap_or_default(),
9489 })
9490 }
9491 }
9492 deserializer.deserialize_struct("stream_plan.RefreshStartMutation", FIELDS, GeneratedVisitor)
9493 }
9494}
9495impl serde::Serialize for ResetSourceMutation {
9496 #[allow(deprecated)]
9497 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9498 where
9499 S: serde::Serializer,
9500 {
9501 use serde::ser::SerializeStruct;
9502 let mut len = 0;
9503 if self.source_id != 0 {
9504 len += 1;
9505 }
9506 let mut struct_ser = serializer.serialize_struct("stream_plan.ResetSourceMutation", len)?;
9507 if self.source_id != 0 {
9508 struct_ser.serialize_field("sourceId", &self.source_id)?;
9509 }
9510 struct_ser.end()
9511 }
9512}
9513impl<'de> serde::Deserialize<'de> for ResetSourceMutation {
9514 #[allow(deprecated)]
9515 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9516 where
9517 D: serde::Deserializer<'de>,
9518 {
9519 const FIELDS: &[&str] = &[
9520 "source_id",
9521 "sourceId",
9522 ];
9523
9524 #[allow(clippy::enum_variant_names)]
9525 enum GeneratedField {
9526 SourceId,
9527 }
9528 impl<'de> serde::Deserialize<'de> for GeneratedField {
9529 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9530 where
9531 D: serde::Deserializer<'de>,
9532 {
9533 struct GeneratedVisitor;
9534
9535 impl serde::de::Visitor<'_> for GeneratedVisitor {
9536 type Value = GeneratedField;
9537
9538 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9539 write!(formatter, "expected one of: {:?}", &FIELDS)
9540 }
9541
9542 #[allow(unused_variables)]
9543 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9544 where
9545 E: serde::de::Error,
9546 {
9547 match value {
9548 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
9549 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9550 }
9551 }
9552 }
9553 deserializer.deserialize_identifier(GeneratedVisitor)
9554 }
9555 }
9556 struct GeneratedVisitor;
9557 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9558 type Value = ResetSourceMutation;
9559
9560 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9561 formatter.write_str("struct stream_plan.ResetSourceMutation")
9562 }
9563
9564 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceMutation, V::Error>
9565 where
9566 V: serde::de::MapAccess<'de>,
9567 {
9568 let mut source_id__ = None;
9569 while let Some(k) = map_.next_key()? {
9570 match k {
9571 GeneratedField::SourceId => {
9572 if source_id__.is_some() {
9573 return Err(serde::de::Error::duplicate_field("sourceId"));
9574 }
9575 source_id__ =
9576 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9577 ;
9578 }
9579 }
9580 }
9581 Ok(ResetSourceMutation {
9582 source_id: source_id__.unwrap_or_default(),
9583 })
9584 }
9585 }
9586 deserializer.deserialize_struct("stream_plan.ResetSourceMutation", FIELDS, GeneratedVisitor)
9587 }
9588}
9589impl serde::Serialize for ResumeMutation {
9590 #[allow(deprecated)]
9591 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9592 where
9593 S: serde::Serializer,
9594 {
9595 use serde::ser::SerializeStruct;
9596 let len = 0;
9597 let struct_ser = serializer.serialize_struct("stream_plan.ResumeMutation", len)?;
9598 struct_ser.end()
9599 }
9600}
9601impl<'de> serde::Deserialize<'de> for ResumeMutation {
9602 #[allow(deprecated)]
9603 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9604 where
9605 D: serde::Deserializer<'de>,
9606 {
9607 const FIELDS: &[&str] = &[
9608 ];
9609
9610 #[allow(clippy::enum_variant_names)]
9611 enum GeneratedField {
9612 }
9613 impl<'de> serde::Deserialize<'de> for GeneratedField {
9614 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9615 where
9616 D: serde::Deserializer<'de>,
9617 {
9618 struct GeneratedVisitor;
9619
9620 impl serde::de::Visitor<'_> for GeneratedVisitor {
9621 type Value = GeneratedField;
9622
9623 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9624 write!(formatter, "expected one of: {:?}", &FIELDS)
9625 }
9626
9627 #[allow(unused_variables)]
9628 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9629 where
9630 E: serde::de::Error,
9631 {
9632 Err(serde::de::Error::unknown_field(value, FIELDS))
9633 }
9634 }
9635 deserializer.deserialize_identifier(GeneratedVisitor)
9636 }
9637 }
9638 struct GeneratedVisitor;
9639 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9640 type Value = ResumeMutation;
9641
9642 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9643 formatter.write_str("struct stream_plan.ResumeMutation")
9644 }
9645
9646 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeMutation, V::Error>
9647 where
9648 V: serde::de::MapAccess<'de>,
9649 {
9650 while map_.next_key::<GeneratedField>()?.is_some() {
9651 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9652 }
9653 Ok(ResumeMutation {
9654 })
9655 }
9656 }
9657 deserializer.deserialize_struct("stream_plan.ResumeMutation", FIELDS, GeneratedVisitor)
9658 }
9659}
9660impl serde::Serialize for RowIdGenNode {
9661 #[allow(deprecated)]
9662 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9663 where
9664 S: serde::Serializer,
9665 {
9666 use serde::ser::SerializeStruct;
9667 let mut len = 0;
9668 if self.row_id_index != 0 {
9669 len += 1;
9670 }
9671 let mut struct_ser = serializer.serialize_struct("stream_plan.RowIdGenNode", len)?;
9672 if self.row_id_index != 0 {
9673 #[allow(clippy::needless_borrow)]
9674 #[allow(clippy::needless_borrows_for_generic_args)]
9675 struct_ser.serialize_field("rowIdIndex", ToString::to_string(&self.row_id_index).as_str())?;
9676 }
9677 struct_ser.end()
9678 }
9679}
9680impl<'de> serde::Deserialize<'de> for RowIdGenNode {
9681 #[allow(deprecated)]
9682 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9683 where
9684 D: serde::Deserializer<'de>,
9685 {
9686 const FIELDS: &[&str] = &[
9687 "row_id_index",
9688 "rowIdIndex",
9689 ];
9690
9691 #[allow(clippy::enum_variant_names)]
9692 enum GeneratedField {
9693 RowIdIndex,
9694 }
9695 impl<'de> serde::Deserialize<'de> for GeneratedField {
9696 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9697 where
9698 D: serde::Deserializer<'de>,
9699 {
9700 struct GeneratedVisitor;
9701
9702 impl serde::de::Visitor<'_> for GeneratedVisitor {
9703 type Value = GeneratedField;
9704
9705 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9706 write!(formatter, "expected one of: {:?}", &FIELDS)
9707 }
9708
9709 #[allow(unused_variables)]
9710 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9711 where
9712 E: serde::de::Error,
9713 {
9714 match value {
9715 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
9716 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9717 }
9718 }
9719 }
9720 deserializer.deserialize_identifier(GeneratedVisitor)
9721 }
9722 }
9723 struct GeneratedVisitor;
9724 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9725 type Value = RowIdGenNode;
9726
9727 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9728 formatter.write_str("struct stream_plan.RowIdGenNode")
9729 }
9730
9731 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowIdGenNode, V::Error>
9732 where
9733 V: serde::de::MapAccess<'de>,
9734 {
9735 let mut row_id_index__ = None;
9736 while let Some(k) = map_.next_key()? {
9737 match k {
9738 GeneratedField::RowIdIndex => {
9739 if row_id_index__.is_some() {
9740 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
9741 }
9742 row_id_index__ =
9743 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9744 ;
9745 }
9746 }
9747 }
9748 Ok(RowIdGenNode {
9749 row_id_index: row_id_index__.unwrap_or_default(),
9750 })
9751 }
9752 }
9753 deserializer.deserialize_struct("stream_plan.RowIdGenNode", FIELDS, GeneratedVisitor)
9754 }
9755}
9756impl serde::Serialize for RowMergeNode {
9757 #[allow(deprecated)]
9758 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9759 where
9760 S: serde::Serializer,
9761 {
9762 use serde::ser::SerializeStruct;
9763 let mut len = 0;
9764 if self.lhs_mapping.is_some() {
9765 len += 1;
9766 }
9767 if self.rhs_mapping.is_some() {
9768 len += 1;
9769 }
9770 let mut struct_ser = serializer.serialize_struct("stream_plan.RowMergeNode", len)?;
9771 if let Some(v) = self.lhs_mapping.as_ref() {
9772 struct_ser.serialize_field("lhsMapping", v)?;
9773 }
9774 if let Some(v) = self.rhs_mapping.as_ref() {
9775 struct_ser.serialize_field("rhsMapping", v)?;
9776 }
9777 struct_ser.end()
9778 }
9779}
9780impl<'de> serde::Deserialize<'de> for RowMergeNode {
9781 #[allow(deprecated)]
9782 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9783 where
9784 D: serde::Deserializer<'de>,
9785 {
9786 const FIELDS: &[&str] = &[
9787 "lhs_mapping",
9788 "lhsMapping",
9789 "rhs_mapping",
9790 "rhsMapping",
9791 ];
9792
9793 #[allow(clippy::enum_variant_names)]
9794 enum GeneratedField {
9795 LhsMapping,
9796 RhsMapping,
9797 }
9798 impl<'de> serde::Deserialize<'de> for GeneratedField {
9799 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9800 where
9801 D: serde::Deserializer<'de>,
9802 {
9803 struct GeneratedVisitor;
9804
9805 impl serde::de::Visitor<'_> for GeneratedVisitor {
9806 type Value = GeneratedField;
9807
9808 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9809 write!(formatter, "expected one of: {:?}", &FIELDS)
9810 }
9811
9812 #[allow(unused_variables)]
9813 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9814 where
9815 E: serde::de::Error,
9816 {
9817 match value {
9818 "lhsMapping" | "lhs_mapping" => Ok(GeneratedField::LhsMapping),
9819 "rhsMapping" | "rhs_mapping" => Ok(GeneratedField::RhsMapping),
9820 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9821 }
9822 }
9823 }
9824 deserializer.deserialize_identifier(GeneratedVisitor)
9825 }
9826 }
9827 struct GeneratedVisitor;
9828 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9829 type Value = RowMergeNode;
9830
9831 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9832 formatter.write_str("struct stream_plan.RowMergeNode")
9833 }
9834
9835 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowMergeNode, V::Error>
9836 where
9837 V: serde::de::MapAccess<'de>,
9838 {
9839 let mut lhs_mapping__ = None;
9840 let mut rhs_mapping__ = None;
9841 while let Some(k) = map_.next_key()? {
9842 match k {
9843 GeneratedField::LhsMapping => {
9844 if lhs_mapping__.is_some() {
9845 return Err(serde::de::Error::duplicate_field("lhsMapping"));
9846 }
9847 lhs_mapping__ = map_.next_value()?;
9848 }
9849 GeneratedField::RhsMapping => {
9850 if rhs_mapping__.is_some() {
9851 return Err(serde::de::Error::duplicate_field("rhsMapping"));
9852 }
9853 rhs_mapping__ = map_.next_value()?;
9854 }
9855 }
9856 }
9857 Ok(RowMergeNode {
9858 lhs_mapping: lhs_mapping__,
9859 rhs_mapping: rhs_mapping__,
9860 })
9861 }
9862 }
9863 deserializer.deserialize_struct("stream_plan.RowMergeNode", FIELDS, GeneratedVisitor)
9864 }
9865}
9866impl serde::Serialize for SimpleAggNode {
9867 #[allow(deprecated)]
9868 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9869 where
9870 S: serde::Serializer,
9871 {
9872 use serde::ser::SerializeStruct;
9873 let mut len = 0;
9874 if !self.agg_calls.is_empty() {
9875 len += 1;
9876 }
9877 if !self.agg_call_states.is_empty() {
9878 len += 1;
9879 }
9880 if self.intermediate_state_table.is_some() {
9881 len += 1;
9882 }
9883 if self.is_append_only {
9884 len += 1;
9885 }
9886 if !self.distinct_dedup_tables.is_empty() {
9887 len += 1;
9888 }
9889 if self.row_count_index != 0 {
9890 len += 1;
9891 }
9892 if self.version != 0 {
9893 len += 1;
9894 }
9895 if self.must_output_per_barrier {
9896 len += 1;
9897 }
9898 let mut struct_ser = serializer.serialize_struct("stream_plan.SimpleAggNode", len)?;
9899 if !self.agg_calls.is_empty() {
9900 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
9901 }
9902 if !self.agg_call_states.is_empty() {
9903 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
9904 }
9905 if let Some(v) = self.intermediate_state_table.as_ref() {
9906 struct_ser.serialize_field("intermediateStateTable", v)?;
9907 }
9908 if self.is_append_only {
9909 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
9910 }
9911 if !self.distinct_dedup_tables.is_empty() {
9912 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
9913 }
9914 if self.row_count_index != 0 {
9915 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
9916 }
9917 if self.version != 0 {
9918 let v = AggNodeVersion::try_from(self.version)
9919 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
9920 struct_ser.serialize_field("version", &v)?;
9921 }
9922 if self.must_output_per_barrier {
9923 struct_ser.serialize_field("mustOutputPerBarrier", &self.must_output_per_barrier)?;
9924 }
9925 struct_ser.end()
9926 }
9927}
9928impl<'de> serde::Deserialize<'de> for SimpleAggNode {
9929 #[allow(deprecated)]
9930 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9931 where
9932 D: serde::Deserializer<'de>,
9933 {
9934 const FIELDS: &[&str] = &[
9935 "agg_calls",
9936 "aggCalls",
9937 "agg_call_states",
9938 "aggCallStates",
9939 "intermediate_state_table",
9940 "intermediateStateTable",
9941 "is_append_only",
9942 "isAppendOnly",
9943 "distinct_dedup_tables",
9944 "distinctDedupTables",
9945 "row_count_index",
9946 "rowCountIndex",
9947 "version",
9948 "must_output_per_barrier",
9949 "mustOutputPerBarrier",
9950 ];
9951
9952 #[allow(clippy::enum_variant_names)]
9953 enum GeneratedField {
9954 AggCalls,
9955 AggCallStates,
9956 IntermediateStateTable,
9957 IsAppendOnly,
9958 DistinctDedupTables,
9959 RowCountIndex,
9960 Version,
9961 MustOutputPerBarrier,
9962 }
9963 impl<'de> serde::Deserialize<'de> for GeneratedField {
9964 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9965 where
9966 D: serde::Deserializer<'de>,
9967 {
9968 struct GeneratedVisitor;
9969
9970 impl serde::de::Visitor<'_> for GeneratedVisitor {
9971 type Value = GeneratedField;
9972
9973 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9974 write!(formatter, "expected one of: {:?}", &FIELDS)
9975 }
9976
9977 #[allow(unused_variables)]
9978 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9979 where
9980 E: serde::de::Error,
9981 {
9982 match value {
9983 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
9984 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
9985 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
9986 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
9987 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
9988 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
9989 "version" => Ok(GeneratedField::Version),
9990 "mustOutputPerBarrier" | "must_output_per_barrier" => Ok(GeneratedField::MustOutputPerBarrier),
9991 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9992 }
9993 }
9994 }
9995 deserializer.deserialize_identifier(GeneratedVisitor)
9996 }
9997 }
9998 struct GeneratedVisitor;
9999 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10000 type Value = SimpleAggNode;
10001
10002 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10003 formatter.write_str("struct stream_plan.SimpleAggNode")
10004 }
10005
10006 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SimpleAggNode, V::Error>
10007 where
10008 V: serde::de::MapAccess<'de>,
10009 {
10010 let mut agg_calls__ = None;
10011 let mut agg_call_states__ = None;
10012 let mut intermediate_state_table__ = None;
10013 let mut is_append_only__ = None;
10014 let mut distinct_dedup_tables__ = None;
10015 let mut row_count_index__ = None;
10016 let mut version__ = None;
10017 let mut must_output_per_barrier__ = None;
10018 while let Some(k) = map_.next_key()? {
10019 match k {
10020 GeneratedField::AggCalls => {
10021 if agg_calls__.is_some() {
10022 return Err(serde::de::Error::duplicate_field("aggCalls"));
10023 }
10024 agg_calls__ = Some(map_.next_value()?);
10025 }
10026 GeneratedField::AggCallStates => {
10027 if agg_call_states__.is_some() {
10028 return Err(serde::de::Error::duplicate_field("aggCallStates"));
10029 }
10030 agg_call_states__ = Some(map_.next_value()?);
10031 }
10032 GeneratedField::IntermediateStateTable => {
10033 if intermediate_state_table__.is_some() {
10034 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
10035 }
10036 intermediate_state_table__ = map_.next_value()?;
10037 }
10038 GeneratedField::IsAppendOnly => {
10039 if is_append_only__.is_some() {
10040 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
10041 }
10042 is_append_only__ = Some(map_.next_value()?);
10043 }
10044 GeneratedField::DistinctDedupTables => {
10045 if distinct_dedup_tables__.is_some() {
10046 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
10047 }
10048 distinct_dedup_tables__ = Some(
10049 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10050 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
10051 );
10052 }
10053 GeneratedField::RowCountIndex => {
10054 if row_count_index__.is_some() {
10055 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
10056 }
10057 row_count_index__ =
10058 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10059 ;
10060 }
10061 GeneratedField::Version => {
10062 if version__.is_some() {
10063 return Err(serde::de::Error::duplicate_field("version"));
10064 }
10065 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
10066 }
10067 GeneratedField::MustOutputPerBarrier => {
10068 if must_output_per_barrier__.is_some() {
10069 return Err(serde::de::Error::duplicate_field("mustOutputPerBarrier"));
10070 }
10071 must_output_per_barrier__ = Some(map_.next_value()?);
10072 }
10073 }
10074 }
10075 Ok(SimpleAggNode {
10076 agg_calls: agg_calls__.unwrap_or_default(),
10077 agg_call_states: agg_call_states__.unwrap_or_default(),
10078 intermediate_state_table: intermediate_state_table__,
10079 is_append_only: is_append_only__.unwrap_or_default(),
10080 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
10081 row_count_index: row_count_index__.unwrap_or_default(),
10082 version: version__.unwrap_or_default(),
10083 must_output_per_barrier: must_output_per_barrier__.unwrap_or_default(),
10084 })
10085 }
10086 }
10087 deserializer.deserialize_struct("stream_plan.SimpleAggNode", FIELDS, GeneratedVisitor)
10088 }
10089}
10090impl serde::Serialize for SinkAddColumnsOp {
10091 #[allow(deprecated)]
10092 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10093 where
10094 S: serde::Serializer,
10095 {
10096 use serde::ser::SerializeStruct;
10097 let mut len = 0;
10098 if !self.fields.is_empty() {
10099 len += 1;
10100 }
10101 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkAddColumnsOp", len)?;
10102 if !self.fields.is_empty() {
10103 struct_ser.serialize_field("fields", &self.fields)?;
10104 }
10105 struct_ser.end()
10106 }
10107}
10108impl<'de> serde::Deserialize<'de> for SinkAddColumnsOp {
10109 #[allow(deprecated)]
10110 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10111 where
10112 D: serde::Deserializer<'de>,
10113 {
10114 const FIELDS: &[&str] = &[
10115 "fields",
10116 ];
10117
10118 #[allow(clippy::enum_variant_names)]
10119 enum GeneratedField {
10120 Fields,
10121 }
10122 impl<'de> serde::Deserialize<'de> for GeneratedField {
10123 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10124 where
10125 D: serde::Deserializer<'de>,
10126 {
10127 struct GeneratedVisitor;
10128
10129 impl serde::de::Visitor<'_> for GeneratedVisitor {
10130 type Value = GeneratedField;
10131
10132 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10133 write!(formatter, "expected one of: {:?}", &FIELDS)
10134 }
10135
10136 #[allow(unused_variables)]
10137 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10138 where
10139 E: serde::de::Error,
10140 {
10141 match value {
10142 "fields" => Ok(GeneratedField::Fields),
10143 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10144 }
10145 }
10146 }
10147 deserializer.deserialize_identifier(GeneratedVisitor)
10148 }
10149 }
10150 struct GeneratedVisitor;
10151 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10152 type Value = SinkAddColumnsOp;
10153
10154 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10155 formatter.write_str("struct stream_plan.SinkAddColumnsOp")
10156 }
10157
10158 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkAddColumnsOp, V::Error>
10159 where
10160 V: serde::de::MapAccess<'de>,
10161 {
10162 let mut fields__ = None;
10163 while let Some(k) = map_.next_key()? {
10164 match k {
10165 GeneratedField::Fields => {
10166 if fields__.is_some() {
10167 return Err(serde::de::Error::duplicate_field("fields"));
10168 }
10169 fields__ = Some(map_.next_value()?);
10170 }
10171 }
10172 }
10173 Ok(SinkAddColumnsOp {
10174 fields: fields__.unwrap_or_default(),
10175 })
10176 }
10177 }
10178 deserializer.deserialize_struct("stream_plan.SinkAddColumnsOp", FIELDS, GeneratedVisitor)
10179 }
10180}
10181impl serde::Serialize for SinkDesc {
10182 #[allow(deprecated)]
10183 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10184 where
10185 S: serde::Serializer,
10186 {
10187 use serde::ser::SerializeStruct;
10188 let mut len = 0;
10189 if self.id != 0 {
10190 len += 1;
10191 }
10192 if !self.name.is_empty() {
10193 len += 1;
10194 }
10195 if !self.definition.is_empty() {
10196 len += 1;
10197 }
10198 if !self.plan_pk.is_empty() {
10199 len += 1;
10200 }
10201 if !self.downstream_pk.is_empty() {
10202 len += 1;
10203 }
10204 if !self.distribution_key.is_empty() {
10205 len += 1;
10206 }
10207 if !self.properties.is_empty() {
10208 len += 1;
10209 }
10210 if self.sink_type != 0 {
10211 len += 1;
10212 }
10213 if !self.column_catalogs.is_empty() {
10214 len += 1;
10215 }
10216 if !self.db_name.is_empty() {
10217 len += 1;
10218 }
10219 if !self.sink_from_name.is_empty() {
10220 len += 1;
10221 }
10222 if self.format_desc.is_some() {
10223 len += 1;
10224 }
10225 if self.target_table.is_some() {
10226 len += 1;
10227 }
10228 if self.extra_partition_col_idx.is_some() {
10229 len += 1;
10230 }
10231 if !self.secret_refs.is_empty() {
10232 len += 1;
10233 }
10234 if self.raw_ignore_delete {
10235 len += 1;
10236 }
10237 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDesc", len)?;
10238 if self.id != 0 {
10239 struct_ser.serialize_field("id", &self.id)?;
10240 }
10241 if !self.name.is_empty() {
10242 struct_ser.serialize_field("name", &self.name)?;
10243 }
10244 if !self.definition.is_empty() {
10245 struct_ser.serialize_field("definition", &self.definition)?;
10246 }
10247 if !self.plan_pk.is_empty() {
10248 struct_ser.serialize_field("planPk", &self.plan_pk)?;
10249 }
10250 if !self.downstream_pk.is_empty() {
10251 struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
10252 }
10253 if !self.distribution_key.is_empty() {
10254 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
10255 }
10256 if !self.properties.is_empty() {
10257 struct_ser.serialize_field("properties", &self.properties)?;
10258 }
10259 if self.sink_type != 0 {
10260 let v = super::catalog::SinkType::try_from(self.sink_type)
10261 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
10262 struct_ser.serialize_field("sinkType", &v)?;
10263 }
10264 if !self.column_catalogs.is_empty() {
10265 struct_ser.serialize_field("columnCatalogs", &self.column_catalogs)?;
10266 }
10267 if !self.db_name.is_empty() {
10268 struct_ser.serialize_field("dbName", &self.db_name)?;
10269 }
10270 if !self.sink_from_name.is_empty() {
10271 struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
10272 }
10273 if let Some(v) = self.format_desc.as_ref() {
10274 struct_ser.serialize_field("formatDesc", v)?;
10275 }
10276 if let Some(v) = self.target_table.as_ref() {
10277 struct_ser.serialize_field("targetTable", v)?;
10278 }
10279 if let Some(v) = self.extra_partition_col_idx.as_ref() {
10280 #[allow(clippy::needless_borrow)]
10281 #[allow(clippy::needless_borrows_for_generic_args)]
10282 struct_ser.serialize_field("extraPartitionColIdx", ToString::to_string(&v).as_str())?;
10283 }
10284 if !self.secret_refs.is_empty() {
10285 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
10286 }
10287 if self.raw_ignore_delete {
10288 struct_ser.serialize_field("rawIgnoreDelete", &self.raw_ignore_delete)?;
10289 }
10290 struct_ser.end()
10291 }
10292}
10293impl<'de> serde::Deserialize<'de> for SinkDesc {
10294 #[allow(deprecated)]
10295 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10296 where
10297 D: serde::Deserializer<'de>,
10298 {
10299 const FIELDS: &[&str] = &[
10300 "id",
10301 "name",
10302 "definition",
10303 "plan_pk",
10304 "planPk",
10305 "downstream_pk",
10306 "downstreamPk",
10307 "distribution_key",
10308 "distributionKey",
10309 "properties",
10310 "sink_type",
10311 "sinkType",
10312 "column_catalogs",
10313 "columnCatalogs",
10314 "db_name",
10315 "dbName",
10316 "sink_from_name",
10317 "sinkFromName",
10318 "format_desc",
10319 "formatDesc",
10320 "target_table",
10321 "targetTable",
10322 "extra_partition_col_idx",
10323 "extraPartitionColIdx",
10324 "secret_refs",
10325 "secretRefs",
10326 "raw_ignore_delete",
10327 "rawIgnoreDelete",
10328 ];
10329
10330 #[allow(clippy::enum_variant_names)]
10331 enum GeneratedField {
10332 Id,
10333 Name,
10334 Definition,
10335 PlanPk,
10336 DownstreamPk,
10337 DistributionKey,
10338 Properties,
10339 SinkType,
10340 ColumnCatalogs,
10341 DbName,
10342 SinkFromName,
10343 FormatDesc,
10344 TargetTable,
10345 ExtraPartitionColIdx,
10346 SecretRefs,
10347 RawIgnoreDelete,
10348 }
10349 impl<'de> serde::Deserialize<'de> for GeneratedField {
10350 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10351 where
10352 D: serde::Deserializer<'de>,
10353 {
10354 struct GeneratedVisitor;
10355
10356 impl serde::de::Visitor<'_> for GeneratedVisitor {
10357 type Value = GeneratedField;
10358
10359 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10360 write!(formatter, "expected one of: {:?}", &FIELDS)
10361 }
10362
10363 #[allow(unused_variables)]
10364 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10365 where
10366 E: serde::de::Error,
10367 {
10368 match value {
10369 "id" => Ok(GeneratedField::Id),
10370 "name" => Ok(GeneratedField::Name),
10371 "definition" => Ok(GeneratedField::Definition),
10372 "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
10373 "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
10374 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
10375 "properties" => Ok(GeneratedField::Properties),
10376 "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
10377 "columnCatalogs" | "column_catalogs" => Ok(GeneratedField::ColumnCatalogs),
10378 "dbName" | "db_name" => Ok(GeneratedField::DbName),
10379 "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
10380 "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
10381 "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
10382 "extraPartitionColIdx" | "extra_partition_col_idx" => Ok(GeneratedField::ExtraPartitionColIdx),
10383 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
10384 "rawIgnoreDelete" | "raw_ignore_delete" => Ok(GeneratedField::RawIgnoreDelete),
10385 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10386 }
10387 }
10388 }
10389 deserializer.deserialize_identifier(GeneratedVisitor)
10390 }
10391 }
10392 struct GeneratedVisitor;
10393 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10394 type Value = SinkDesc;
10395
10396 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10397 formatter.write_str("struct stream_plan.SinkDesc")
10398 }
10399
10400 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDesc, V::Error>
10401 where
10402 V: serde::de::MapAccess<'de>,
10403 {
10404 let mut id__ = None;
10405 let mut name__ = None;
10406 let mut definition__ = None;
10407 let mut plan_pk__ = None;
10408 let mut downstream_pk__ = None;
10409 let mut distribution_key__ = None;
10410 let mut properties__ = None;
10411 let mut sink_type__ = None;
10412 let mut column_catalogs__ = None;
10413 let mut db_name__ = None;
10414 let mut sink_from_name__ = None;
10415 let mut format_desc__ = None;
10416 let mut target_table__ = None;
10417 let mut extra_partition_col_idx__ = None;
10418 let mut secret_refs__ = None;
10419 let mut raw_ignore_delete__ = None;
10420 while let Some(k) = map_.next_key()? {
10421 match k {
10422 GeneratedField::Id => {
10423 if id__.is_some() {
10424 return Err(serde::de::Error::duplicate_field("id"));
10425 }
10426 id__ =
10427 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10428 ;
10429 }
10430 GeneratedField::Name => {
10431 if name__.is_some() {
10432 return Err(serde::de::Error::duplicate_field("name"));
10433 }
10434 name__ = Some(map_.next_value()?);
10435 }
10436 GeneratedField::Definition => {
10437 if definition__.is_some() {
10438 return Err(serde::de::Error::duplicate_field("definition"));
10439 }
10440 definition__ = Some(map_.next_value()?);
10441 }
10442 GeneratedField::PlanPk => {
10443 if plan_pk__.is_some() {
10444 return Err(serde::de::Error::duplicate_field("planPk"));
10445 }
10446 plan_pk__ = Some(map_.next_value()?);
10447 }
10448 GeneratedField::DownstreamPk => {
10449 if downstream_pk__.is_some() {
10450 return Err(serde::de::Error::duplicate_field("downstreamPk"));
10451 }
10452 downstream_pk__ =
10453 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10454 .into_iter().map(|x| x.0).collect())
10455 ;
10456 }
10457 GeneratedField::DistributionKey => {
10458 if distribution_key__.is_some() {
10459 return Err(serde::de::Error::duplicate_field("distributionKey"));
10460 }
10461 distribution_key__ =
10462 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10463 .into_iter().map(|x| x.0).collect())
10464 ;
10465 }
10466 GeneratedField::Properties => {
10467 if properties__.is_some() {
10468 return Err(serde::de::Error::duplicate_field("properties"));
10469 }
10470 properties__ = Some(
10471 map_.next_value::<std::collections::BTreeMap<_, _>>()?
10472 );
10473 }
10474 GeneratedField::SinkType => {
10475 if sink_type__.is_some() {
10476 return Err(serde::de::Error::duplicate_field("sinkType"));
10477 }
10478 sink_type__ = Some(map_.next_value::<super::catalog::SinkType>()? as i32);
10479 }
10480 GeneratedField::ColumnCatalogs => {
10481 if column_catalogs__.is_some() {
10482 return Err(serde::de::Error::duplicate_field("columnCatalogs"));
10483 }
10484 column_catalogs__ = Some(map_.next_value()?);
10485 }
10486 GeneratedField::DbName => {
10487 if db_name__.is_some() {
10488 return Err(serde::de::Error::duplicate_field("dbName"));
10489 }
10490 db_name__ = Some(map_.next_value()?);
10491 }
10492 GeneratedField::SinkFromName => {
10493 if sink_from_name__.is_some() {
10494 return Err(serde::de::Error::duplicate_field("sinkFromName"));
10495 }
10496 sink_from_name__ = Some(map_.next_value()?);
10497 }
10498 GeneratedField::FormatDesc => {
10499 if format_desc__.is_some() {
10500 return Err(serde::de::Error::duplicate_field("formatDesc"));
10501 }
10502 format_desc__ = map_.next_value()?;
10503 }
10504 GeneratedField::TargetTable => {
10505 if target_table__.is_some() {
10506 return Err(serde::de::Error::duplicate_field("targetTable"));
10507 }
10508 target_table__ =
10509 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10510 ;
10511 }
10512 GeneratedField::ExtraPartitionColIdx => {
10513 if extra_partition_col_idx__.is_some() {
10514 return Err(serde::de::Error::duplicate_field("extraPartitionColIdx"));
10515 }
10516 extra_partition_col_idx__ =
10517 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10518 ;
10519 }
10520 GeneratedField::SecretRefs => {
10521 if secret_refs__.is_some() {
10522 return Err(serde::de::Error::duplicate_field("secretRefs"));
10523 }
10524 secret_refs__ = Some(
10525 map_.next_value::<std::collections::BTreeMap<_, _>>()?
10526 );
10527 }
10528 GeneratedField::RawIgnoreDelete => {
10529 if raw_ignore_delete__.is_some() {
10530 return Err(serde::de::Error::duplicate_field("rawIgnoreDelete"));
10531 }
10532 raw_ignore_delete__ = Some(map_.next_value()?);
10533 }
10534 }
10535 }
10536 Ok(SinkDesc {
10537 id: id__.unwrap_or_default(),
10538 name: name__.unwrap_or_default(),
10539 definition: definition__.unwrap_or_default(),
10540 plan_pk: plan_pk__.unwrap_or_default(),
10541 downstream_pk: downstream_pk__.unwrap_or_default(),
10542 distribution_key: distribution_key__.unwrap_or_default(),
10543 properties: properties__.unwrap_or_default(),
10544 sink_type: sink_type__.unwrap_or_default(),
10545 column_catalogs: column_catalogs__.unwrap_or_default(),
10546 db_name: db_name__.unwrap_or_default(),
10547 sink_from_name: sink_from_name__.unwrap_or_default(),
10548 format_desc: format_desc__,
10549 target_table: target_table__,
10550 extra_partition_col_idx: extra_partition_col_idx__,
10551 secret_refs: secret_refs__.unwrap_or_default(),
10552 raw_ignore_delete: raw_ignore_delete__.unwrap_or_default(),
10553 })
10554 }
10555 }
10556 deserializer.deserialize_struct("stream_plan.SinkDesc", FIELDS, GeneratedVisitor)
10557 }
10558}
10559impl serde::Serialize for SinkDropColumnsOp {
10560 #[allow(deprecated)]
10561 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10562 where
10563 S: serde::Serializer,
10564 {
10565 use serde::ser::SerializeStruct;
10566 let mut len = 0;
10567 if !self.column_names.is_empty() {
10568 len += 1;
10569 }
10570 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDropColumnsOp", len)?;
10571 if !self.column_names.is_empty() {
10572 struct_ser.serialize_field("columnNames", &self.column_names)?;
10573 }
10574 struct_ser.end()
10575 }
10576}
10577impl<'de> serde::Deserialize<'de> for SinkDropColumnsOp {
10578 #[allow(deprecated)]
10579 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10580 where
10581 D: serde::Deserializer<'de>,
10582 {
10583 const FIELDS: &[&str] = &[
10584 "column_names",
10585 "columnNames",
10586 ];
10587
10588 #[allow(clippy::enum_variant_names)]
10589 enum GeneratedField {
10590 ColumnNames,
10591 }
10592 impl<'de> serde::Deserialize<'de> for GeneratedField {
10593 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10594 where
10595 D: serde::Deserializer<'de>,
10596 {
10597 struct GeneratedVisitor;
10598
10599 impl serde::de::Visitor<'_> for GeneratedVisitor {
10600 type Value = GeneratedField;
10601
10602 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10603 write!(formatter, "expected one of: {:?}", &FIELDS)
10604 }
10605
10606 #[allow(unused_variables)]
10607 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10608 where
10609 E: serde::de::Error,
10610 {
10611 match value {
10612 "columnNames" | "column_names" => Ok(GeneratedField::ColumnNames),
10613 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10614 }
10615 }
10616 }
10617 deserializer.deserialize_identifier(GeneratedVisitor)
10618 }
10619 }
10620 struct GeneratedVisitor;
10621 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10622 type Value = SinkDropColumnsOp;
10623
10624 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10625 formatter.write_str("struct stream_plan.SinkDropColumnsOp")
10626 }
10627
10628 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDropColumnsOp, V::Error>
10629 where
10630 V: serde::de::MapAccess<'de>,
10631 {
10632 let mut column_names__ = None;
10633 while let Some(k) = map_.next_key()? {
10634 match k {
10635 GeneratedField::ColumnNames => {
10636 if column_names__.is_some() {
10637 return Err(serde::de::Error::duplicate_field("columnNames"));
10638 }
10639 column_names__ = Some(map_.next_value()?);
10640 }
10641 }
10642 }
10643 Ok(SinkDropColumnsOp {
10644 column_names: column_names__.unwrap_or_default(),
10645 })
10646 }
10647 }
10648 deserializer.deserialize_struct("stream_plan.SinkDropColumnsOp", FIELDS, GeneratedVisitor)
10649 }
10650}
10651impl serde::Serialize for SinkLogStoreType {
10652 #[allow(deprecated)]
10653 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10654 where
10655 S: serde::Serializer,
10656 {
10657 let variant = match self {
10658 Self::Unspecified => "SINK_LOG_STORE_TYPE_UNSPECIFIED",
10659 Self::KvLogStore => "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
10660 Self::InMemoryLogStore => "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
10661 };
10662 serializer.serialize_str(variant)
10663 }
10664}
10665impl<'de> serde::Deserialize<'de> for SinkLogStoreType {
10666 #[allow(deprecated)]
10667 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10668 where
10669 D: serde::Deserializer<'de>,
10670 {
10671 const FIELDS: &[&str] = &[
10672 "SINK_LOG_STORE_TYPE_UNSPECIFIED",
10673 "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
10674 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
10675 ];
10676
10677 struct GeneratedVisitor;
10678
10679 impl serde::de::Visitor<'_> for GeneratedVisitor {
10680 type Value = SinkLogStoreType;
10681
10682 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10683 write!(formatter, "expected one of: {:?}", &FIELDS)
10684 }
10685
10686 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
10687 where
10688 E: serde::de::Error,
10689 {
10690 i32::try_from(v)
10691 .ok()
10692 .and_then(|x| x.try_into().ok())
10693 .ok_or_else(|| {
10694 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
10695 })
10696 }
10697
10698 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
10699 where
10700 E: serde::de::Error,
10701 {
10702 i32::try_from(v)
10703 .ok()
10704 .and_then(|x| x.try_into().ok())
10705 .ok_or_else(|| {
10706 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
10707 })
10708 }
10709
10710 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
10711 where
10712 E: serde::de::Error,
10713 {
10714 match value {
10715 "SINK_LOG_STORE_TYPE_UNSPECIFIED" => Ok(SinkLogStoreType::Unspecified),
10716 "SINK_LOG_STORE_TYPE_KV_LOG_STORE" => Ok(SinkLogStoreType::KvLogStore),
10717 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE" => Ok(SinkLogStoreType::InMemoryLogStore),
10718 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
10719 }
10720 }
10721 }
10722 deserializer.deserialize_any(GeneratedVisitor)
10723 }
10724}
10725impl serde::Serialize for SinkNode {
10726 #[allow(deprecated)]
10727 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10728 where
10729 S: serde::Serializer,
10730 {
10731 use serde::ser::SerializeStruct;
10732 let mut len = 0;
10733 if self.sink_desc.is_some() {
10734 len += 1;
10735 }
10736 if self.table.is_some() {
10737 len += 1;
10738 }
10739 if self.log_store_type != 0 {
10740 len += 1;
10741 }
10742 if self.rate_limit.is_some() {
10743 len += 1;
10744 }
10745 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkNode", len)?;
10746 if let Some(v) = self.sink_desc.as_ref() {
10747 struct_ser.serialize_field("sinkDesc", v)?;
10748 }
10749 if let Some(v) = self.table.as_ref() {
10750 struct_ser.serialize_field("table", v)?;
10751 }
10752 if self.log_store_type != 0 {
10753 let v = SinkLogStoreType::try_from(self.log_store_type)
10754 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.log_store_type)))?;
10755 struct_ser.serialize_field("logStoreType", &v)?;
10756 }
10757 if let Some(v) = self.rate_limit.as_ref() {
10758 struct_ser.serialize_field("rateLimit", v)?;
10759 }
10760 struct_ser.end()
10761 }
10762}
10763impl<'de> serde::Deserialize<'de> for SinkNode {
10764 #[allow(deprecated)]
10765 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10766 where
10767 D: serde::Deserializer<'de>,
10768 {
10769 const FIELDS: &[&str] = &[
10770 "sink_desc",
10771 "sinkDesc",
10772 "table",
10773 "log_store_type",
10774 "logStoreType",
10775 "rate_limit",
10776 "rateLimit",
10777 ];
10778
10779 #[allow(clippy::enum_variant_names)]
10780 enum GeneratedField {
10781 SinkDesc,
10782 Table,
10783 LogStoreType,
10784 RateLimit,
10785 }
10786 impl<'de> serde::Deserialize<'de> for GeneratedField {
10787 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10788 where
10789 D: serde::Deserializer<'de>,
10790 {
10791 struct GeneratedVisitor;
10792
10793 impl serde::de::Visitor<'_> for GeneratedVisitor {
10794 type Value = GeneratedField;
10795
10796 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10797 write!(formatter, "expected one of: {:?}", &FIELDS)
10798 }
10799
10800 #[allow(unused_variables)]
10801 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10802 where
10803 E: serde::de::Error,
10804 {
10805 match value {
10806 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
10807 "table" => Ok(GeneratedField::Table),
10808 "logStoreType" | "log_store_type" => Ok(GeneratedField::LogStoreType),
10809 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
10810 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10811 }
10812 }
10813 }
10814 deserializer.deserialize_identifier(GeneratedVisitor)
10815 }
10816 }
10817 struct GeneratedVisitor;
10818 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10819 type Value = SinkNode;
10820
10821 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10822 formatter.write_str("struct stream_plan.SinkNode")
10823 }
10824
10825 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkNode, V::Error>
10826 where
10827 V: serde::de::MapAccess<'de>,
10828 {
10829 let mut sink_desc__ = None;
10830 let mut table__ = None;
10831 let mut log_store_type__ = None;
10832 let mut rate_limit__ = None;
10833 while let Some(k) = map_.next_key()? {
10834 match k {
10835 GeneratedField::SinkDesc => {
10836 if sink_desc__.is_some() {
10837 return Err(serde::de::Error::duplicate_field("sinkDesc"));
10838 }
10839 sink_desc__ = map_.next_value()?;
10840 }
10841 GeneratedField::Table => {
10842 if table__.is_some() {
10843 return Err(serde::de::Error::duplicate_field("table"));
10844 }
10845 table__ = map_.next_value()?;
10846 }
10847 GeneratedField::LogStoreType => {
10848 if log_store_type__.is_some() {
10849 return Err(serde::de::Error::duplicate_field("logStoreType"));
10850 }
10851 log_store_type__ = Some(map_.next_value::<SinkLogStoreType>()? as i32);
10852 }
10853 GeneratedField::RateLimit => {
10854 if rate_limit__.is_some() {
10855 return Err(serde::de::Error::duplicate_field("rateLimit"));
10856 }
10857 rate_limit__ =
10858 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10859 ;
10860 }
10861 }
10862 }
10863 Ok(SinkNode {
10864 sink_desc: sink_desc__,
10865 table: table__,
10866 log_store_type: log_store_type__.unwrap_or_default(),
10867 rate_limit: rate_limit__,
10868 })
10869 }
10870 }
10871 deserializer.deserialize_struct("stream_plan.SinkNode", FIELDS, GeneratedVisitor)
10872 }
10873}
10874impl serde::Serialize for SinkSchemaChange {
10875 #[allow(deprecated)]
10876 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10877 where
10878 S: serde::Serializer,
10879 {
10880 use serde::ser::SerializeStruct;
10881 let mut len = 0;
10882 if !self.original_schema.is_empty() {
10883 len += 1;
10884 }
10885 if self.op.is_some() {
10886 len += 1;
10887 }
10888 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkSchemaChange", len)?;
10889 if !self.original_schema.is_empty() {
10890 struct_ser.serialize_field("originalSchema", &self.original_schema)?;
10891 }
10892 if let Some(v) = self.op.as_ref() {
10893 match v {
10894 sink_schema_change::Op::AddColumns(v) => {
10895 struct_ser.serialize_field("addColumns", v)?;
10896 }
10897 sink_schema_change::Op::DropColumns(v) => {
10898 struct_ser.serialize_field("dropColumns", v)?;
10899 }
10900 }
10901 }
10902 struct_ser.end()
10903 }
10904}
10905impl<'de> serde::Deserialize<'de> for SinkSchemaChange {
10906 #[allow(deprecated)]
10907 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10908 where
10909 D: serde::Deserializer<'de>,
10910 {
10911 const FIELDS: &[&str] = &[
10912 "original_schema",
10913 "originalSchema",
10914 "add_columns",
10915 "addColumns",
10916 "drop_columns",
10917 "dropColumns",
10918 ];
10919
10920 #[allow(clippy::enum_variant_names)]
10921 enum GeneratedField {
10922 OriginalSchema,
10923 AddColumns,
10924 DropColumns,
10925 }
10926 impl<'de> serde::Deserialize<'de> for GeneratedField {
10927 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10928 where
10929 D: serde::Deserializer<'de>,
10930 {
10931 struct GeneratedVisitor;
10932
10933 impl serde::de::Visitor<'_> for GeneratedVisitor {
10934 type Value = GeneratedField;
10935
10936 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10937 write!(formatter, "expected one of: {:?}", &FIELDS)
10938 }
10939
10940 #[allow(unused_variables)]
10941 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10942 where
10943 E: serde::de::Error,
10944 {
10945 match value {
10946 "originalSchema" | "original_schema" => Ok(GeneratedField::OriginalSchema),
10947 "addColumns" | "add_columns" => Ok(GeneratedField::AddColumns),
10948 "dropColumns" | "drop_columns" => Ok(GeneratedField::DropColumns),
10949 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10950 }
10951 }
10952 }
10953 deserializer.deserialize_identifier(GeneratedVisitor)
10954 }
10955 }
10956 struct GeneratedVisitor;
10957 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10958 type Value = SinkSchemaChange;
10959
10960 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10961 formatter.write_str("struct stream_plan.SinkSchemaChange")
10962 }
10963
10964 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkSchemaChange, V::Error>
10965 where
10966 V: serde::de::MapAccess<'de>,
10967 {
10968 let mut original_schema__ = None;
10969 let mut op__ = None;
10970 while let Some(k) = map_.next_key()? {
10971 match k {
10972 GeneratedField::OriginalSchema => {
10973 if original_schema__.is_some() {
10974 return Err(serde::de::Error::duplicate_field("originalSchema"));
10975 }
10976 original_schema__ = Some(map_.next_value()?);
10977 }
10978 GeneratedField::AddColumns => {
10979 if op__.is_some() {
10980 return Err(serde::de::Error::duplicate_field("addColumns"));
10981 }
10982 op__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_schema_change::Op::AddColumns)
10983;
10984 }
10985 GeneratedField::DropColumns => {
10986 if op__.is_some() {
10987 return Err(serde::de::Error::duplicate_field("dropColumns"));
10988 }
10989 op__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_schema_change::Op::DropColumns)
10990;
10991 }
10992 }
10993 }
10994 Ok(SinkSchemaChange {
10995 original_schema: original_schema__.unwrap_or_default(),
10996 op: op__,
10997 })
10998 }
10999 }
11000 deserializer.deserialize_struct("stream_plan.SinkSchemaChange", FIELDS, GeneratedVisitor)
11001 }
11002}
11003impl serde::Serialize for SortNode {
11004 #[allow(deprecated)]
11005 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11006 where
11007 S: serde::Serializer,
11008 {
11009 use serde::ser::SerializeStruct;
11010 let mut len = 0;
11011 if self.state_table.is_some() {
11012 len += 1;
11013 }
11014 if self.sort_column_index != 0 {
11015 len += 1;
11016 }
11017 let mut struct_ser = serializer.serialize_struct("stream_plan.SortNode", len)?;
11018 if let Some(v) = self.state_table.as_ref() {
11019 struct_ser.serialize_field("stateTable", v)?;
11020 }
11021 if self.sort_column_index != 0 {
11022 struct_ser.serialize_field("sortColumnIndex", &self.sort_column_index)?;
11023 }
11024 struct_ser.end()
11025 }
11026}
11027impl<'de> serde::Deserialize<'de> for SortNode {
11028 #[allow(deprecated)]
11029 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11030 where
11031 D: serde::Deserializer<'de>,
11032 {
11033 const FIELDS: &[&str] = &[
11034 "state_table",
11035 "stateTable",
11036 "sort_column_index",
11037 "sortColumnIndex",
11038 ];
11039
11040 #[allow(clippy::enum_variant_names)]
11041 enum GeneratedField {
11042 StateTable,
11043 SortColumnIndex,
11044 }
11045 impl<'de> serde::Deserialize<'de> for GeneratedField {
11046 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11047 where
11048 D: serde::Deserializer<'de>,
11049 {
11050 struct GeneratedVisitor;
11051
11052 impl serde::de::Visitor<'_> for GeneratedVisitor {
11053 type Value = GeneratedField;
11054
11055 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11056 write!(formatter, "expected one of: {:?}", &FIELDS)
11057 }
11058
11059 #[allow(unused_variables)]
11060 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11061 where
11062 E: serde::de::Error,
11063 {
11064 match value {
11065 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11066 "sortColumnIndex" | "sort_column_index" => Ok(GeneratedField::SortColumnIndex),
11067 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11068 }
11069 }
11070 }
11071 deserializer.deserialize_identifier(GeneratedVisitor)
11072 }
11073 }
11074 struct GeneratedVisitor;
11075 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11076 type Value = SortNode;
11077
11078 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11079 formatter.write_str("struct stream_plan.SortNode")
11080 }
11081
11082 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
11083 where
11084 V: serde::de::MapAccess<'de>,
11085 {
11086 let mut state_table__ = None;
11087 let mut sort_column_index__ = None;
11088 while let Some(k) = map_.next_key()? {
11089 match k {
11090 GeneratedField::StateTable => {
11091 if state_table__.is_some() {
11092 return Err(serde::de::Error::duplicate_field("stateTable"));
11093 }
11094 state_table__ = map_.next_value()?;
11095 }
11096 GeneratedField::SortColumnIndex => {
11097 if sort_column_index__.is_some() {
11098 return Err(serde::de::Error::duplicate_field("sortColumnIndex"));
11099 }
11100 sort_column_index__ =
11101 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11102 ;
11103 }
11104 }
11105 }
11106 Ok(SortNode {
11107 state_table: state_table__,
11108 sort_column_index: sort_column_index__.unwrap_or_default(),
11109 })
11110 }
11111 }
11112 deserializer.deserialize_struct("stream_plan.SortNode", FIELDS, GeneratedVisitor)
11113 }
11114}
11115impl serde::Serialize for SourceBackfillNode {
11116 #[allow(deprecated)]
11117 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11118 where
11119 S: serde::Serializer,
11120 {
11121 use serde::ser::SerializeStruct;
11122 let mut len = 0;
11123 if self.upstream_source_id != 0 {
11124 len += 1;
11125 }
11126 if self.row_id_index.is_some() {
11127 len += 1;
11128 }
11129 if !self.columns.is_empty() {
11130 len += 1;
11131 }
11132 if self.info.is_some() {
11133 len += 1;
11134 }
11135 if !self.source_name.is_empty() {
11136 len += 1;
11137 }
11138 if !self.with_properties.is_empty() {
11139 len += 1;
11140 }
11141 if self.rate_limit.is_some() {
11142 len += 1;
11143 }
11144 if self.state_table.is_some() {
11145 len += 1;
11146 }
11147 if !self.secret_refs.is_empty() {
11148 len += 1;
11149 }
11150 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceBackfillNode", len)?;
11151 if self.upstream_source_id != 0 {
11152 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
11153 }
11154 if let Some(v) = self.row_id_index.as_ref() {
11155 struct_ser.serialize_field("rowIdIndex", v)?;
11156 }
11157 if !self.columns.is_empty() {
11158 struct_ser.serialize_field("columns", &self.columns)?;
11159 }
11160 if let Some(v) = self.info.as_ref() {
11161 struct_ser.serialize_field("info", v)?;
11162 }
11163 if !self.source_name.is_empty() {
11164 struct_ser.serialize_field("sourceName", &self.source_name)?;
11165 }
11166 if !self.with_properties.is_empty() {
11167 struct_ser.serialize_field("withProperties", &self.with_properties)?;
11168 }
11169 if let Some(v) = self.rate_limit.as_ref() {
11170 struct_ser.serialize_field("rateLimit", v)?;
11171 }
11172 if let Some(v) = self.state_table.as_ref() {
11173 struct_ser.serialize_field("stateTable", v)?;
11174 }
11175 if !self.secret_refs.is_empty() {
11176 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
11177 }
11178 struct_ser.end()
11179 }
11180}
11181impl<'de> serde::Deserialize<'de> for SourceBackfillNode {
11182 #[allow(deprecated)]
11183 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11184 where
11185 D: serde::Deserializer<'de>,
11186 {
11187 const FIELDS: &[&str] = &[
11188 "upstream_source_id",
11189 "upstreamSourceId",
11190 "row_id_index",
11191 "rowIdIndex",
11192 "columns",
11193 "info",
11194 "source_name",
11195 "sourceName",
11196 "with_properties",
11197 "withProperties",
11198 "rate_limit",
11199 "rateLimit",
11200 "state_table",
11201 "stateTable",
11202 "secret_refs",
11203 "secretRefs",
11204 ];
11205
11206 #[allow(clippy::enum_variant_names)]
11207 enum GeneratedField {
11208 UpstreamSourceId,
11209 RowIdIndex,
11210 Columns,
11211 Info,
11212 SourceName,
11213 WithProperties,
11214 RateLimit,
11215 StateTable,
11216 SecretRefs,
11217 }
11218 impl<'de> serde::Deserialize<'de> for GeneratedField {
11219 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11220 where
11221 D: serde::Deserializer<'de>,
11222 {
11223 struct GeneratedVisitor;
11224
11225 impl serde::de::Visitor<'_> for GeneratedVisitor {
11226 type Value = GeneratedField;
11227
11228 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11229 write!(formatter, "expected one of: {:?}", &FIELDS)
11230 }
11231
11232 #[allow(unused_variables)]
11233 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11234 where
11235 E: serde::de::Error,
11236 {
11237 match value {
11238 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
11239 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
11240 "columns" => Ok(GeneratedField::Columns),
11241 "info" => Ok(GeneratedField::Info),
11242 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
11243 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
11244 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11245 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11246 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
11247 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11248 }
11249 }
11250 }
11251 deserializer.deserialize_identifier(GeneratedVisitor)
11252 }
11253 }
11254 struct GeneratedVisitor;
11255 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11256 type Value = SourceBackfillNode;
11257
11258 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11259 formatter.write_str("struct stream_plan.SourceBackfillNode")
11260 }
11261
11262 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceBackfillNode, V::Error>
11263 where
11264 V: serde::de::MapAccess<'de>,
11265 {
11266 let mut upstream_source_id__ = None;
11267 let mut row_id_index__ = None;
11268 let mut columns__ = None;
11269 let mut info__ = None;
11270 let mut source_name__ = None;
11271 let mut with_properties__ = None;
11272 let mut rate_limit__ = None;
11273 let mut state_table__ = None;
11274 let mut secret_refs__ = None;
11275 while let Some(k) = map_.next_key()? {
11276 match k {
11277 GeneratedField::UpstreamSourceId => {
11278 if upstream_source_id__.is_some() {
11279 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
11280 }
11281 upstream_source_id__ =
11282 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11283 ;
11284 }
11285 GeneratedField::RowIdIndex => {
11286 if row_id_index__.is_some() {
11287 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
11288 }
11289 row_id_index__ =
11290 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11291 ;
11292 }
11293 GeneratedField::Columns => {
11294 if columns__.is_some() {
11295 return Err(serde::de::Error::duplicate_field("columns"));
11296 }
11297 columns__ = Some(map_.next_value()?);
11298 }
11299 GeneratedField::Info => {
11300 if info__.is_some() {
11301 return Err(serde::de::Error::duplicate_field("info"));
11302 }
11303 info__ = map_.next_value()?;
11304 }
11305 GeneratedField::SourceName => {
11306 if source_name__.is_some() {
11307 return Err(serde::de::Error::duplicate_field("sourceName"));
11308 }
11309 source_name__ = Some(map_.next_value()?);
11310 }
11311 GeneratedField::WithProperties => {
11312 if with_properties__.is_some() {
11313 return Err(serde::de::Error::duplicate_field("withProperties"));
11314 }
11315 with_properties__ = Some(
11316 map_.next_value::<std::collections::BTreeMap<_, _>>()?
11317 );
11318 }
11319 GeneratedField::RateLimit => {
11320 if rate_limit__.is_some() {
11321 return Err(serde::de::Error::duplicate_field("rateLimit"));
11322 }
11323 rate_limit__ =
11324 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11325 ;
11326 }
11327 GeneratedField::StateTable => {
11328 if state_table__.is_some() {
11329 return Err(serde::de::Error::duplicate_field("stateTable"));
11330 }
11331 state_table__ = map_.next_value()?;
11332 }
11333 GeneratedField::SecretRefs => {
11334 if secret_refs__.is_some() {
11335 return Err(serde::de::Error::duplicate_field("secretRefs"));
11336 }
11337 secret_refs__ = Some(
11338 map_.next_value::<std::collections::BTreeMap<_, _>>()?
11339 );
11340 }
11341 }
11342 }
11343 Ok(SourceBackfillNode {
11344 upstream_source_id: upstream_source_id__.unwrap_or_default(),
11345 row_id_index: row_id_index__,
11346 columns: columns__.unwrap_or_default(),
11347 info: info__,
11348 source_name: source_name__.unwrap_or_default(),
11349 with_properties: with_properties__.unwrap_or_default(),
11350 rate_limit: rate_limit__,
11351 state_table: state_table__,
11352 secret_refs: secret_refs__.unwrap_or_default(),
11353 })
11354 }
11355 }
11356 deserializer.deserialize_struct("stream_plan.SourceBackfillNode", FIELDS, GeneratedVisitor)
11357 }
11358}
11359impl serde::Serialize for SourceChangeSplitMutation {
11360 #[allow(deprecated)]
11361 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11362 where
11363 S: serde::Serializer,
11364 {
11365 use serde::ser::SerializeStruct;
11366 let mut len = 0;
11367 if !self.actor_splits.is_empty() {
11368 len += 1;
11369 }
11370 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceChangeSplitMutation", len)?;
11371 if !self.actor_splits.is_empty() {
11372 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
11373 }
11374 struct_ser.end()
11375 }
11376}
11377impl<'de> serde::Deserialize<'de> for SourceChangeSplitMutation {
11378 #[allow(deprecated)]
11379 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11380 where
11381 D: serde::Deserializer<'de>,
11382 {
11383 const FIELDS: &[&str] = &[
11384 "actor_splits",
11385 "actorSplits",
11386 ];
11387
11388 #[allow(clippy::enum_variant_names)]
11389 enum GeneratedField {
11390 ActorSplits,
11391 }
11392 impl<'de> serde::Deserialize<'de> for GeneratedField {
11393 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11394 where
11395 D: serde::Deserializer<'de>,
11396 {
11397 struct GeneratedVisitor;
11398
11399 impl serde::de::Visitor<'_> for GeneratedVisitor {
11400 type Value = GeneratedField;
11401
11402 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11403 write!(formatter, "expected one of: {:?}", &FIELDS)
11404 }
11405
11406 #[allow(unused_variables)]
11407 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11408 where
11409 E: serde::de::Error,
11410 {
11411 match value {
11412 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
11413 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11414 }
11415 }
11416 }
11417 deserializer.deserialize_identifier(GeneratedVisitor)
11418 }
11419 }
11420 struct GeneratedVisitor;
11421 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11422 type Value = SourceChangeSplitMutation;
11423
11424 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11425 formatter.write_str("struct stream_plan.SourceChangeSplitMutation")
11426 }
11427
11428 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceChangeSplitMutation, V::Error>
11429 where
11430 V: serde::de::MapAccess<'de>,
11431 {
11432 let mut actor_splits__ = None;
11433 while let Some(k) = map_.next_key()? {
11434 match k {
11435 GeneratedField::ActorSplits => {
11436 if actor_splits__.is_some() {
11437 return Err(serde::de::Error::duplicate_field("actorSplits"));
11438 }
11439 actor_splits__ = Some(
11440 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11441 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
11442 );
11443 }
11444 }
11445 }
11446 Ok(SourceChangeSplitMutation {
11447 actor_splits: actor_splits__.unwrap_or_default(),
11448 })
11449 }
11450 }
11451 deserializer.deserialize_struct("stream_plan.SourceChangeSplitMutation", FIELDS, GeneratedVisitor)
11452 }
11453}
11454impl serde::Serialize for SourceNode {
11455 #[allow(deprecated)]
11456 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11457 where
11458 S: serde::Serializer,
11459 {
11460 use serde::ser::SerializeStruct;
11461 let mut len = 0;
11462 if self.source_inner.is_some() {
11463 len += 1;
11464 }
11465 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceNode", len)?;
11466 if let Some(v) = self.source_inner.as_ref() {
11467 struct_ser.serialize_field("sourceInner", v)?;
11468 }
11469 struct_ser.end()
11470 }
11471}
11472impl<'de> serde::Deserialize<'de> for SourceNode {
11473 #[allow(deprecated)]
11474 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11475 where
11476 D: serde::Deserializer<'de>,
11477 {
11478 const FIELDS: &[&str] = &[
11479 "source_inner",
11480 "sourceInner",
11481 ];
11482
11483 #[allow(clippy::enum_variant_names)]
11484 enum GeneratedField {
11485 SourceInner,
11486 }
11487 impl<'de> serde::Deserialize<'de> for GeneratedField {
11488 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11489 where
11490 D: serde::Deserializer<'de>,
11491 {
11492 struct GeneratedVisitor;
11493
11494 impl serde::de::Visitor<'_> for GeneratedVisitor {
11495 type Value = GeneratedField;
11496
11497 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11498 write!(formatter, "expected one of: {:?}", &FIELDS)
11499 }
11500
11501 #[allow(unused_variables)]
11502 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11503 where
11504 E: serde::de::Error,
11505 {
11506 match value {
11507 "sourceInner" | "source_inner" => Ok(GeneratedField::SourceInner),
11508 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11509 }
11510 }
11511 }
11512 deserializer.deserialize_identifier(GeneratedVisitor)
11513 }
11514 }
11515 struct GeneratedVisitor;
11516 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11517 type Value = SourceNode;
11518
11519 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11520 formatter.write_str("struct stream_plan.SourceNode")
11521 }
11522
11523 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
11524 where
11525 V: serde::de::MapAccess<'de>,
11526 {
11527 let mut source_inner__ = None;
11528 while let Some(k) = map_.next_key()? {
11529 match k {
11530 GeneratedField::SourceInner => {
11531 if source_inner__.is_some() {
11532 return Err(serde::de::Error::duplicate_field("sourceInner"));
11533 }
11534 source_inner__ = map_.next_value()?;
11535 }
11536 }
11537 }
11538 Ok(SourceNode {
11539 source_inner: source_inner__,
11540 })
11541 }
11542 }
11543 deserializer.deserialize_struct("stream_plan.SourceNode", FIELDS, GeneratedVisitor)
11544 }
11545}
11546impl serde::Serialize for StartFragmentBackfillMutation {
11547 #[allow(deprecated)]
11548 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11549 where
11550 S: serde::Serializer,
11551 {
11552 use serde::ser::SerializeStruct;
11553 let mut len = 0;
11554 if !self.fragment_ids.is_empty() {
11555 len += 1;
11556 }
11557 let mut struct_ser = serializer.serialize_struct("stream_plan.StartFragmentBackfillMutation", len)?;
11558 if !self.fragment_ids.is_empty() {
11559 struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
11560 }
11561 struct_ser.end()
11562 }
11563}
11564impl<'de> serde::Deserialize<'de> for StartFragmentBackfillMutation {
11565 #[allow(deprecated)]
11566 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11567 where
11568 D: serde::Deserializer<'de>,
11569 {
11570 const FIELDS: &[&str] = &[
11571 "fragment_ids",
11572 "fragmentIds",
11573 ];
11574
11575 #[allow(clippy::enum_variant_names)]
11576 enum GeneratedField {
11577 FragmentIds,
11578 }
11579 impl<'de> serde::Deserialize<'de> for GeneratedField {
11580 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11581 where
11582 D: serde::Deserializer<'de>,
11583 {
11584 struct GeneratedVisitor;
11585
11586 impl serde::de::Visitor<'_> for GeneratedVisitor {
11587 type Value = GeneratedField;
11588
11589 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11590 write!(formatter, "expected one of: {:?}", &FIELDS)
11591 }
11592
11593 #[allow(unused_variables)]
11594 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11595 where
11596 E: serde::de::Error,
11597 {
11598 match value {
11599 "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
11600 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11601 }
11602 }
11603 }
11604 deserializer.deserialize_identifier(GeneratedVisitor)
11605 }
11606 }
11607 struct GeneratedVisitor;
11608 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11609 type Value = StartFragmentBackfillMutation;
11610
11611 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11612 formatter.write_str("struct stream_plan.StartFragmentBackfillMutation")
11613 }
11614
11615 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StartFragmentBackfillMutation, V::Error>
11616 where
11617 V: serde::de::MapAccess<'de>,
11618 {
11619 let mut fragment_ids__ = None;
11620 while let Some(k) = map_.next_key()? {
11621 match k {
11622 GeneratedField::FragmentIds => {
11623 if fragment_ids__.is_some() {
11624 return Err(serde::de::Error::duplicate_field("fragmentIds"));
11625 }
11626 fragment_ids__ =
11627 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11628 .into_iter().map(|x| x.0).collect())
11629 ;
11630 }
11631 }
11632 }
11633 Ok(StartFragmentBackfillMutation {
11634 fragment_ids: fragment_ids__.unwrap_or_default(),
11635 })
11636 }
11637 }
11638 deserializer.deserialize_struct("stream_plan.StartFragmentBackfillMutation", FIELDS, GeneratedVisitor)
11639 }
11640}
11641impl serde::Serialize for StopMutation {
11642 #[allow(deprecated)]
11643 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11644 where
11645 S: serde::Serializer,
11646 {
11647 use serde::ser::SerializeStruct;
11648 let mut len = 0;
11649 if !self.actors.is_empty() {
11650 len += 1;
11651 }
11652 if !self.dropped_sink_fragments.is_empty() {
11653 len += 1;
11654 }
11655 let mut struct_ser = serializer.serialize_struct("stream_plan.StopMutation", len)?;
11656 if !self.actors.is_empty() {
11657 struct_ser.serialize_field("actors", &self.actors)?;
11658 }
11659 if !self.dropped_sink_fragments.is_empty() {
11660 struct_ser.serialize_field("droppedSinkFragments", &self.dropped_sink_fragments)?;
11661 }
11662 struct_ser.end()
11663 }
11664}
11665impl<'de> serde::Deserialize<'de> for StopMutation {
11666 #[allow(deprecated)]
11667 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11668 where
11669 D: serde::Deserializer<'de>,
11670 {
11671 const FIELDS: &[&str] = &[
11672 "actors",
11673 "dropped_sink_fragments",
11674 "droppedSinkFragments",
11675 ];
11676
11677 #[allow(clippy::enum_variant_names)]
11678 enum GeneratedField {
11679 Actors,
11680 DroppedSinkFragments,
11681 }
11682 impl<'de> serde::Deserialize<'de> for GeneratedField {
11683 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11684 where
11685 D: serde::Deserializer<'de>,
11686 {
11687 struct GeneratedVisitor;
11688
11689 impl serde::de::Visitor<'_> for GeneratedVisitor {
11690 type Value = GeneratedField;
11691
11692 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11693 write!(formatter, "expected one of: {:?}", &FIELDS)
11694 }
11695
11696 #[allow(unused_variables)]
11697 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11698 where
11699 E: serde::de::Error,
11700 {
11701 match value {
11702 "actors" => Ok(GeneratedField::Actors),
11703 "droppedSinkFragments" | "dropped_sink_fragments" => Ok(GeneratedField::DroppedSinkFragments),
11704 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11705 }
11706 }
11707 }
11708 deserializer.deserialize_identifier(GeneratedVisitor)
11709 }
11710 }
11711 struct GeneratedVisitor;
11712 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11713 type Value = StopMutation;
11714
11715 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11716 formatter.write_str("struct stream_plan.StopMutation")
11717 }
11718
11719 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopMutation, V::Error>
11720 where
11721 V: serde::de::MapAccess<'de>,
11722 {
11723 let mut actors__ = None;
11724 let mut dropped_sink_fragments__ = None;
11725 while let Some(k) = map_.next_key()? {
11726 match k {
11727 GeneratedField::Actors => {
11728 if actors__.is_some() {
11729 return Err(serde::de::Error::duplicate_field("actors"));
11730 }
11731 actors__ =
11732 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11733 .into_iter().map(|x| x.0).collect())
11734 ;
11735 }
11736 GeneratedField::DroppedSinkFragments => {
11737 if dropped_sink_fragments__.is_some() {
11738 return Err(serde::de::Error::duplicate_field("droppedSinkFragments"));
11739 }
11740 dropped_sink_fragments__ =
11741 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11742 .into_iter().map(|x| x.0).collect())
11743 ;
11744 }
11745 }
11746 }
11747 Ok(StopMutation {
11748 actors: actors__.unwrap_or_default(),
11749 dropped_sink_fragments: dropped_sink_fragments__.unwrap_or_default(),
11750 })
11751 }
11752 }
11753 deserializer.deserialize_struct("stream_plan.StopMutation", FIELDS, GeneratedVisitor)
11754 }
11755}
11756impl serde::Serialize for StreamActor {
11757 #[allow(deprecated)]
11758 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11759 where
11760 S: serde::Serializer,
11761 {
11762 use serde::ser::SerializeStruct;
11763 let mut len = 0;
11764 if self.actor_id != 0 {
11765 len += 1;
11766 }
11767 if self.fragment_id != 0 {
11768 len += 1;
11769 }
11770 if !self.dispatcher.is_empty() {
11771 len += 1;
11772 }
11773 if self.vnode_bitmap.is_some() {
11774 len += 1;
11775 }
11776 if !self.mview_definition.is_empty() {
11777 len += 1;
11778 }
11779 if self.expr_context.is_some() {
11780 len += 1;
11781 }
11782 if !self.config_override.is_empty() {
11783 len += 1;
11784 }
11785 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamActor", len)?;
11786 if self.actor_id != 0 {
11787 struct_ser.serialize_field("actorId", &self.actor_id)?;
11788 }
11789 if self.fragment_id != 0 {
11790 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
11791 }
11792 if !self.dispatcher.is_empty() {
11793 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
11794 }
11795 if let Some(v) = self.vnode_bitmap.as_ref() {
11796 struct_ser.serialize_field("vnodeBitmap", v)?;
11797 }
11798 if !self.mview_definition.is_empty() {
11799 struct_ser.serialize_field("mviewDefinition", &self.mview_definition)?;
11800 }
11801 if let Some(v) = self.expr_context.as_ref() {
11802 struct_ser.serialize_field("exprContext", v)?;
11803 }
11804 if !self.config_override.is_empty() {
11805 struct_ser.serialize_field("configOverride", &self.config_override)?;
11806 }
11807 struct_ser.end()
11808 }
11809}
11810impl<'de> serde::Deserialize<'de> for StreamActor {
11811 #[allow(deprecated)]
11812 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11813 where
11814 D: serde::Deserializer<'de>,
11815 {
11816 const FIELDS: &[&str] = &[
11817 "actor_id",
11818 "actorId",
11819 "fragment_id",
11820 "fragmentId",
11821 "dispatcher",
11822 "vnode_bitmap",
11823 "vnodeBitmap",
11824 "mview_definition",
11825 "mviewDefinition",
11826 "expr_context",
11827 "exprContext",
11828 "config_override",
11829 "configOverride",
11830 ];
11831
11832 #[allow(clippy::enum_variant_names)]
11833 enum GeneratedField {
11834 ActorId,
11835 FragmentId,
11836 Dispatcher,
11837 VnodeBitmap,
11838 MviewDefinition,
11839 ExprContext,
11840 ConfigOverride,
11841 }
11842 impl<'de> serde::Deserialize<'de> for GeneratedField {
11843 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11844 where
11845 D: serde::Deserializer<'de>,
11846 {
11847 struct GeneratedVisitor;
11848
11849 impl serde::de::Visitor<'_> for GeneratedVisitor {
11850 type Value = GeneratedField;
11851
11852 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11853 write!(formatter, "expected one of: {:?}", &FIELDS)
11854 }
11855
11856 #[allow(unused_variables)]
11857 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11858 where
11859 E: serde::de::Error,
11860 {
11861 match value {
11862 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
11863 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
11864 "dispatcher" => Ok(GeneratedField::Dispatcher),
11865 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
11866 "mviewDefinition" | "mview_definition" => Ok(GeneratedField::MviewDefinition),
11867 "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
11868 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
11869 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11870 }
11871 }
11872 }
11873 deserializer.deserialize_identifier(GeneratedVisitor)
11874 }
11875 }
11876 struct GeneratedVisitor;
11877 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11878 type Value = StreamActor;
11879
11880 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11881 formatter.write_str("struct stream_plan.StreamActor")
11882 }
11883
11884 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamActor, V::Error>
11885 where
11886 V: serde::de::MapAccess<'de>,
11887 {
11888 let mut actor_id__ = None;
11889 let mut fragment_id__ = None;
11890 let mut dispatcher__ = None;
11891 let mut vnode_bitmap__ = None;
11892 let mut mview_definition__ = None;
11893 let mut expr_context__ = None;
11894 let mut config_override__ = None;
11895 while let Some(k) = map_.next_key()? {
11896 match k {
11897 GeneratedField::ActorId => {
11898 if actor_id__.is_some() {
11899 return Err(serde::de::Error::duplicate_field("actorId"));
11900 }
11901 actor_id__ =
11902 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11903 ;
11904 }
11905 GeneratedField::FragmentId => {
11906 if fragment_id__.is_some() {
11907 return Err(serde::de::Error::duplicate_field("fragmentId"));
11908 }
11909 fragment_id__ =
11910 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11911 ;
11912 }
11913 GeneratedField::Dispatcher => {
11914 if dispatcher__.is_some() {
11915 return Err(serde::de::Error::duplicate_field("dispatcher"));
11916 }
11917 dispatcher__ = Some(map_.next_value()?);
11918 }
11919 GeneratedField::VnodeBitmap => {
11920 if vnode_bitmap__.is_some() {
11921 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
11922 }
11923 vnode_bitmap__ = map_.next_value()?;
11924 }
11925 GeneratedField::MviewDefinition => {
11926 if mview_definition__.is_some() {
11927 return Err(serde::de::Error::duplicate_field("mviewDefinition"));
11928 }
11929 mview_definition__ = Some(map_.next_value()?);
11930 }
11931 GeneratedField::ExprContext => {
11932 if expr_context__.is_some() {
11933 return Err(serde::de::Error::duplicate_field("exprContext"));
11934 }
11935 expr_context__ = map_.next_value()?;
11936 }
11937 GeneratedField::ConfigOverride => {
11938 if config_override__.is_some() {
11939 return Err(serde::de::Error::duplicate_field("configOverride"));
11940 }
11941 config_override__ = Some(map_.next_value()?);
11942 }
11943 }
11944 }
11945 Ok(StreamActor {
11946 actor_id: actor_id__.unwrap_or_default(),
11947 fragment_id: fragment_id__.unwrap_or_default(),
11948 dispatcher: dispatcher__.unwrap_or_default(),
11949 vnode_bitmap: vnode_bitmap__,
11950 mview_definition: mview_definition__.unwrap_or_default(),
11951 expr_context: expr_context__,
11952 config_override: config_override__.unwrap_or_default(),
11953 })
11954 }
11955 }
11956 deserializer.deserialize_struct("stream_plan.StreamActor", FIELDS, GeneratedVisitor)
11957 }
11958}
11959impl serde::Serialize for StreamCdcScanNode {
11960 #[allow(deprecated)]
11961 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11962 where
11963 S: serde::Serializer,
11964 {
11965 use serde::ser::SerializeStruct;
11966 let mut len = 0;
11967 if self.table_id != 0 {
11968 len += 1;
11969 }
11970 if !self.upstream_column_ids.is_empty() {
11971 len += 1;
11972 }
11973 if !self.output_indices.is_empty() {
11974 len += 1;
11975 }
11976 if self.state_table.is_some() {
11977 len += 1;
11978 }
11979 if self.cdc_table_desc.is_some() {
11980 len += 1;
11981 }
11982 if self.rate_limit.is_some() {
11983 len += 1;
11984 }
11985 if self.disable_backfill {
11986 len += 1;
11987 }
11988 if self.options.is_some() {
11989 len += 1;
11990 }
11991 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanNode", len)?;
11992 if self.table_id != 0 {
11993 struct_ser.serialize_field("tableId", &self.table_id)?;
11994 }
11995 if !self.upstream_column_ids.is_empty() {
11996 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
11997 }
11998 if !self.output_indices.is_empty() {
11999 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
12000 }
12001 if let Some(v) = self.state_table.as_ref() {
12002 struct_ser.serialize_field("stateTable", v)?;
12003 }
12004 if let Some(v) = self.cdc_table_desc.as_ref() {
12005 struct_ser.serialize_field("cdcTableDesc", v)?;
12006 }
12007 if let Some(v) = self.rate_limit.as_ref() {
12008 struct_ser.serialize_field("rateLimit", v)?;
12009 }
12010 if self.disable_backfill {
12011 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
12012 }
12013 if let Some(v) = self.options.as_ref() {
12014 struct_ser.serialize_field("options", v)?;
12015 }
12016 struct_ser.end()
12017 }
12018}
12019impl<'de> serde::Deserialize<'de> for StreamCdcScanNode {
12020 #[allow(deprecated)]
12021 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12022 where
12023 D: serde::Deserializer<'de>,
12024 {
12025 const FIELDS: &[&str] = &[
12026 "table_id",
12027 "tableId",
12028 "upstream_column_ids",
12029 "upstreamColumnIds",
12030 "output_indices",
12031 "outputIndices",
12032 "state_table",
12033 "stateTable",
12034 "cdc_table_desc",
12035 "cdcTableDesc",
12036 "rate_limit",
12037 "rateLimit",
12038 "disable_backfill",
12039 "disableBackfill",
12040 "options",
12041 ];
12042
12043 #[allow(clippy::enum_variant_names)]
12044 enum GeneratedField {
12045 TableId,
12046 UpstreamColumnIds,
12047 OutputIndices,
12048 StateTable,
12049 CdcTableDesc,
12050 RateLimit,
12051 DisableBackfill,
12052 Options,
12053 }
12054 impl<'de> serde::Deserialize<'de> for GeneratedField {
12055 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12056 where
12057 D: serde::Deserializer<'de>,
12058 {
12059 struct GeneratedVisitor;
12060
12061 impl serde::de::Visitor<'_> for GeneratedVisitor {
12062 type Value = GeneratedField;
12063
12064 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12065 write!(formatter, "expected one of: {:?}", &FIELDS)
12066 }
12067
12068 #[allow(unused_variables)]
12069 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12070 where
12071 E: serde::de::Error,
12072 {
12073 match value {
12074 "tableId" | "table_id" => Ok(GeneratedField::TableId),
12075 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
12076 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
12077 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
12078 "cdcTableDesc" | "cdc_table_desc" => Ok(GeneratedField::CdcTableDesc),
12079 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
12080 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
12081 "options" => Ok(GeneratedField::Options),
12082 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12083 }
12084 }
12085 }
12086 deserializer.deserialize_identifier(GeneratedVisitor)
12087 }
12088 }
12089 struct GeneratedVisitor;
12090 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12091 type Value = StreamCdcScanNode;
12092
12093 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12094 formatter.write_str("struct stream_plan.StreamCdcScanNode")
12095 }
12096
12097 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanNode, V::Error>
12098 where
12099 V: serde::de::MapAccess<'de>,
12100 {
12101 let mut table_id__ = None;
12102 let mut upstream_column_ids__ = None;
12103 let mut output_indices__ = None;
12104 let mut state_table__ = None;
12105 let mut cdc_table_desc__ = None;
12106 let mut rate_limit__ = None;
12107 let mut disable_backfill__ = None;
12108 let mut options__ = None;
12109 while let Some(k) = map_.next_key()? {
12110 match k {
12111 GeneratedField::TableId => {
12112 if table_id__.is_some() {
12113 return Err(serde::de::Error::duplicate_field("tableId"));
12114 }
12115 table_id__ =
12116 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12117 ;
12118 }
12119 GeneratedField::UpstreamColumnIds => {
12120 if upstream_column_ids__.is_some() {
12121 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
12122 }
12123 upstream_column_ids__ =
12124 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12125 .into_iter().map(|x| x.0).collect())
12126 ;
12127 }
12128 GeneratedField::OutputIndices => {
12129 if output_indices__.is_some() {
12130 return Err(serde::de::Error::duplicate_field("outputIndices"));
12131 }
12132 output_indices__ =
12133 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12134 .into_iter().map(|x| x.0).collect())
12135 ;
12136 }
12137 GeneratedField::StateTable => {
12138 if state_table__.is_some() {
12139 return Err(serde::de::Error::duplicate_field("stateTable"));
12140 }
12141 state_table__ = map_.next_value()?;
12142 }
12143 GeneratedField::CdcTableDesc => {
12144 if cdc_table_desc__.is_some() {
12145 return Err(serde::de::Error::duplicate_field("cdcTableDesc"));
12146 }
12147 cdc_table_desc__ = map_.next_value()?;
12148 }
12149 GeneratedField::RateLimit => {
12150 if rate_limit__.is_some() {
12151 return Err(serde::de::Error::duplicate_field("rateLimit"));
12152 }
12153 rate_limit__ =
12154 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12155 ;
12156 }
12157 GeneratedField::DisableBackfill => {
12158 if disable_backfill__.is_some() {
12159 return Err(serde::de::Error::duplicate_field("disableBackfill"));
12160 }
12161 disable_backfill__ = Some(map_.next_value()?);
12162 }
12163 GeneratedField::Options => {
12164 if options__.is_some() {
12165 return Err(serde::de::Error::duplicate_field("options"));
12166 }
12167 options__ = map_.next_value()?;
12168 }
12169 }
12170 }
12171 Ok(StreamCdcScanNode {
12172 table_id: table_id__.unwrap_or_default(),
12173 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
12174 output_indices: output_indices__.unwrap_or_default(),
12175 state_table: state_table__,
12176 cdc_table_desc: cdc_table_desc__,
12177 rate_limit: rate_limit__,
12178 disable_backfill: disable_backfill__.unwrap_or_default(),
12179 options: options__,
12180 })
12181 }
12182 }
12183 deserializer.deserialize_struct("stream_plan.StreamCdcScanNode", FIELDS, GeneratedVisitor)
12184 }
12185}
12186impl serde::Serialize for StreamCdcScanOptions {
12187 #[allow(deprecated)]
12188 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12189 where
12190 S: serde::Serializer,
12191 {
12192 use serde::ser::SerializeStruct;
12193 let mut len = 0;
12194 if self.disable_backfill {
12195 len += 1;
12196 }
12197 if self.snapshot_barrier_interval != 0 {
12198 len += 1;
12199 }
12200 if self.snapshot_batch_size != 0 {
12201 len += 1;
12202 }
12203 if self.backfill_parallelism != 0 {
12204 len += 1;
12205 }
12206 if self.backfill_num_rows_per_split != 0 {
12207 len += 1;
12208 }
12209 if self.backfill_as_even_splits {
12210 len += 1;
12211 }
12212 if self.backfill_split_pk_column_index != 0 {
12213 len += 1;
12214 }
12215 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanOptions", len)?;
12216 if self.disable_backfill {
12217 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
12218 }
12219 if self.snapshot_barrier_interval != 0 {
12220 struct_ser.serialize_field("snapshotBarrierInterval", &self.snapshot_barrier_interval)?;
12221 }
12222 if self.snapshot_batch_size != 0 {
12223 struct_ser.serialize_field("snapshotBatchSize", &self.snapshot_batch_size)?;
12224 }
12225 if self.backfill_parallelism != 0 {
12226 struct_ser.serialize_field("backfillParallelism", &self.backfill_parallelism)?;
12227 }
12228 if self.backfill_num_rows_per_split != 0 {
12229 #[allow(clippy::needless_borrow)]
12230 #[allow(clippy::needless_borrows_for_generic_args)]
12231 struct_ser.serialize_field("backfillNumRowsPerSplit", ToString::to_string(&self.backfill_num_rows_per_split).as_str())?;
12232 }
12233 if self.backfill_as_even_splits {
12234 struct_ser.serialize_field("backfillAsEvenSplits", &self.backfill_as_even_splits)?;
12235 }
12236 if self.backfill_split_pk_column_index != 0 {
12237 struct_ser.serialize_field("backfillSplitPkColumnIndex", &self.backfill_split_pk_column_index)?;
12238 }
12239 struct_ser.end()
12240 }
12241}
12242impl<'de> serde::Deserialize<'de> for StreamCdcScanOptions {
12243 #[allow(deprecated)]
12244 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12245 where
12246 D: serde::Deserializer<'de>,
12247 {
12248 const FIELDS: &[&str] = &[
12249 "disable_backfill",
12250 "disableBackfill",
12251 "snapshot_barrier_interval",
12252 "snapshotBarrierInterval",
12253 "snapshot_batch_size",
12254 "snapshotBatchSize",
12255 "backfill_parallelism",
12256 "backfillParallelism",
12257 "backfill_num_rows_per_split",
12258 "backfillNumRowsPerSplit",
12259 "backfill_as_even_splits",
12260 "backfillAsEvenSplits",
12261 "backfill_split_pk_column_index",
12262 "backfillSplitPkColumnIndex",
12263 ];
12264
12265 #[allow(clippy::enum_variant_names)]
12266 enum GeneratedField {
12267 DisableBackfill,
12268 SnapshotBarrierInterval,
12269 SnapshotBatchSize,
12270 BackfillParallelism,
12271 BackfillNumRowsPerSplit,
12272 BackfillAsEvenSplits,
12273 BackfillSplitPkColumnIndex,
12274 }
12275 impl<'de> serde::Deserialize<'de> for GeneratedField {
12276 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12277 where
12278 D: serde::Deserializer<'de>,
12279 {
12280 struct GeneratedVisitor;
12281
12282 impl serde::de::Visitor<'_> for GeneratedVisitor {
12283 type Value = GeneratedField;
12284
12285 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12286 write!(formatter, "expected one of: {:?}", &FIELDS)
12287 }
12288
12289 #[allow(unused_variables)]
12290 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12291 where
12292 E: serde::de::Error,
12293 {
12294 match value {
12295 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
12296 "snapshotBarrierInterval" | "snapshot_barrier_interval" => Ok(GeneratedField::SnapshotBarrierInterval),
12297 "snapshotBatchSize" | "snapshot_batch_size" => Ok(GeneratedField::SnapshotBatchSize),
12298 "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
12299 "backfillNumRowsPerSplit" | "backfill_num_rows_per_split" => Ok(GeneratedField::BackfillNumRowsPerSplit),
12300 "backfillAsEvenSplits" | "backfill_as_even_splits" => Ok(GeneratedField::BackfillAsEvenSplits),
12301 "backfillSplitPkColumnIndex" | "backfill_split_pk_column_index" => Ok(GeneratedField::BackfillSplitPkColumnIndex),
12302 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12303 }
12304 }
12305 }
12306 deserializer.deserialize_identifier(GeneratedVisitor)
12307 }
12308 }
12309 struct GeneratedVisitor;
12310 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12311 type Value = StreamCdcScanOptions;
12312
12313 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12314 formatter.write_str("struct stream_plan.StreamCdcScanOptions")
12315 }
12316
12317 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanOptions, V::Error>
12318 where
12319 V: serde::de::MapAccess<'de>,
12320 {
12321 let mut disable_backfill__ = None;
12322 let mut snapshot_barrier_interval__ = None;
12323 let mut snapshot_batch_size__ = None;
12324 let mut backfill_parallelism__ = None;
12325 let mut backfill_num_rows_per_split__ = None;
12326 let mut backfill_as_even_splits__ = None;
12327 let mut backfill_split_pk_column_index__ = None;
12328 while let Some(k) = map_.next_key()? {
12329 match k {
12330 GeneratedField::DisableBackfill => {
12331 if disable_backfill__.is_some() {
12332 return Err(serde::de::Error::duplicate_field("disableBackfill"));
12333 }
12334 disable_backfill__ = Some(map_.next_value()?);
12335 }
12336 GeneratedField::SnapshotBarrierInterval => {
12337 if snapshot_barrier_interval__.is_some() {
12338 return Err(serde::de::Error::duplicate_field("snapshotBarrierInterval"));
12339 }
12340 snapshot_barrier_interval__ =
12341 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12342 ;
12343 }
12344 GeneratedField::SnapshotBatchSize => {
12345 if snapshot_batch_size__.is_some() {
12346 return Err(serde::de::Error::duplicate_field("snapshotBatchSize"));
12347 }
12348 snapshot_batch_size__ =
12349 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12350 ;
12351 }
12352 GeneratedField::BackfillParallelism => {
12353 if backfill_parallelism__.is_some() {
12354 return Err(serde::de::Error::duplicate_field("backfillParallelism"));
12355 }
12356 backfill_parallelism__ =
12357 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12358 ;
12359 }
12360 GeneratedField::BackfillNumRowsPerSplit => {
12361 if backfill_num_rows_per_split__.is_some() {
12362 return Err(serde::de::Error::duplicate_field("backfillNumRowsPerSplit"));
12363 }
12364 backfill_num_rows_per_split__ =
12365 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12366 ;
12367 }
12368 GeneratedField::BackfillAsEvenSplits => {
12369 if backfill_as_even_splits__.is_some() {
12370 return Err(serde::de::Error::duplicate_field("backfillAsEvenSplits"));
12371 }
12372 backfill_as_even_splits__ = Some(map_.next_value()?);
12373 }
12374 GeneratedField::BackfillSplitPkColumnIndex => {
12375 if backfill_split_pk_column_index__.is_some() {
12376 return Err(serde::de::Error::duplicate_field("backfillSplitPkColumnIndex"));
12377 }
12378 backfill_split_pk_column_index__ =
12379 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12380 ;
12381 }
12382 }
12383 }
12384 Ok(StreamCdcScanOptions {
12385 disable_backfill: disable_backfill__.unwrap_or_default(),
12386 snapshot_barrier_interval: snapshot_barrier_interval__.unwrap_or_default(),
12387 snapshot_batch_size: snapshot_batch_size__.unwrap_or_default(),
12388 backfill_parallelism: backfill_parallelism__.unwrap_or_default(),
12389 backfill_num_rows_per_split: backfill_num_rows_per_split__.unwrap_or_default(),
12390 backfill_as_even_splits: backfill_as_even_splits__.unwrap_or_default(),
12391 backfill_split_pk_column_index: backfill_split_pk_column_index__.unwrap_or_default(),
12392 })
12393 }
12394 }
12395 deserializer.deserialize_struct("stream_plan.StreamCdcScanOptions", FIELDS, GeneratedVisitor)
12396 }
12397}
12398impl serde::Serialize for StreamContext {
12399 #[allow(deprecated)]
12400 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12401 where
12402 S: serde::Serializer,
12403 {
12404 use serde::ser::SerializeStruct;
12405 let mut len = 0;
12406 if !self.timezone.is_empty() {
12407 len += 1;
12408 }
12409 if !self.config_override.is_empty() {
12410 len += 1;
12411 }
12412 if !self.adaptive_parallelism_strategy.is_empty() {
12413 len += 1;
12414 }
12415 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamContext", len)?;
12416 if !self.timezone.is_empty() {
12417 struct_ser.serialize_field("timezone", &self.timezone)?;
12418 }
12419 if !self.config_override.is_empty() {
12420 struct_ser.serialize_field("configOverride", &self.config_override)?;
12421 }
12422 if !self.adaptive_parallelism_strategy.is_empty() {
12423 struct_ser.serialize_field("adaptiveParallelismStrategy", &self.adaptive_parallelism_strategy)?;
12424 }
12425 struct_ser.end()
12426 }
12427}
12428impl<'de> serde::Deserialize<'de> for StreamContext {
12429 #[allow(deprecated)]
12430 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12431 where
12432 D: serde::Deserializer<'de>,
12433 {
12434 const FIELDS: &[&str] = &[
12435 "timezone",
12436 "config_override",
12437 "configOverride",
12438 "adaptive_parallelism_strategy",
12439 "adaptiveParallelismStrategy",
12440 ];
12441
12442 #[allow(clippy::enum_variant_names)]
12443 enum GeneratedField {
12444 Timezone,
12445 ConfigOverride,
12446 AdaptiveParallelismStrategy,
12447 }
12448 impl<'de> serde::Deserialize<'de> for GeneratedField {
12449 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12450 where
12451 D: serde::Deserializer<'de>,
12452 {
12453 struct GeneratedVisitor;
12454
12455 impl serde::de::Visitor<'_> for GeneratedVisitor {
12456 type Value = GeneratedField;
12457
12458 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12459 write!(formatter, "expected one of: {:?}", &FIELDS)
12460 }
12461
12462 #[allow(unused_variables)]
12463 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12464 where
12465 E: serde::de::Error,
12466 {
12467 match value {
12468 "timezone" => Ok(GeneratedField::Timezone),
12469 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
12470 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
12471 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12472 }
12473 }
12474 }
12475 deserializer.deserialize_identifier(GeneratedVisitor)
12476 }
12477 }
12478 struct GeneratedVisitor;
12479 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12480 type Value = StreamContext;
12481
12482 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12483 formatter.write_str("struct stream_plan.StreamContext")
12484 }
12485
12486 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamContext, V::Error>
12487 where
12488 V: serde::de::MapAccess<'de>,
12489 {
12490 let mut timezone__ = None;
12491 let mut config_override__ = None;
12492 let mut adaptive_parallelism_strategy__ = None;
12493 while let Some(k) = map_.next_key()? {
12494 match k {
12495 GeneratedField::Timezone => {
12496 if timezone__.is_some() {
12497 return Err(serde::de::Error::duplicate_field("timezone"));
12498 }
12499 timezone__ = Some(map_.next_value()?);
12500 }
12501 GeneratedField::ConfigOverride => {
12502 if config_override__.is_some() {
12503 return Err(serde::de::Error::duplicate_field("configOverride"));
12504 }
12505 config_override__ = Some(map_.next_value()?);
12506 }
12507 GeneratedField::AdaptiveParallelismStrategy => {
12508 if adaptive_parallelism_strategy__.is_some() {
12509 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
12510 }
12511 adaptive_parallelism_strategy__ = Some(map_.next_value()?);
12512 }
12513 }
12514 }
12515 Ok(StreamContext {
12516 timezone: timezone__.unwrap_or_default(),
12517 config_override: config_override__.unwrap_or_default(),
12518 adaptive_parallelism_strategy: adaptive_parallelism_strategy__.unwrap_or_default(),
12519 })
12520 }
12521 }
12522 deserializer.deserialize_struct("stream_plan.StreamContext", FIELDS, GeneratedVisitor)
12523 }
12524}
12525impl serde::Serialize for StreamFragmentGraph {
12526 #[allow(deprecated)]
12527 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12528 where
12529 S: serde::Serializer,
12530 {
12531 use serde::ser::SerializeStruct;
12532 let mut len = 0;
12533 if !self.fragments.is_empty() {
12534 len += 1;
12535 }
12536 if !self.edges.is_empty() {
12537 len += 1;
12538 }
12539 if !self.dependent_table_ids.is_empty() {
12540 len += 1;
12541 }
12542 if self.table_ids_cnt != 0 {
12543 len += 1;
12544 }
12545 if self.ctx.is_some() {
12546 len += 1;
12547 }
12548 if self.parallelism.is_some() {
12549 len += 1;
12550 }
12551 if self.backfill_parallelism.is_some() {
12552 len += 1;
12553 }
12554 if self.max_parallelism != 0 {
12555 len += 1;
12556 }
12557 if self.backfill_order.is_some() {
12558 len += 1;
12559 }
12560 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph", len)?;
12561 if !self.fragments.is_empty() {
12562 struct_ser.serialize_field("fragments", &self.fragments)?;
12563 }
12564 if !self.edges.is_empty() {
12565 struct_ser.serialize_field("edges", &self.edges)?;
12566 }
12567 if !self.dependent_table_ids.is_empty() {
12568 struct_ser.serialize_field("dependentTableIds", &self.dependent_table_ids)?;
12569 }
12570 if self.table_ids_cnt != 0 {
12571 struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
12572 }
12573 if let Some(v) = self.ctx.as_ref() {
12574 struct_ser.serialize_field("ctx", v)?;
12575 }
12576 if let Some(v) = self.parallelism.as_ref() {
12577 struct_ser.serialize_field("parallelism", v)?;
12578 }
12579 if let Some(v) = self.backfill_parallelism.as_ref() {
12580 struct_ser.serialize_field("backfillParallelism", v)?;
12581 }
12582 if self.max_parallelism != 0 {
12583 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
12584 }
12585 if let Some(v) = self.backfill_order.as_ref() {
12586 struct_ser.serialize_field("backfillOrder", v)?;
12587 }
12588 struct_ser.end()
12589 }
12590}
12591impl<'de> serde::Deserialize<'de> for StreamFragmentGraph {
12592 #[allow(deprecated)]
12593 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12594 where
12595 D: serde::Deserializer<'de>,
12596 {
12597 const FIELDS: &[&str] = &[
12598 "fragments",
12599 "edges",
12600 "dependent_table_ids",
12601 "dependentTableIds",
12602 "table_ids_cnt",
12603 "tableIdsCnt",
12604 "ctx",
12605 "parallelism",
12606 "backfill_parallelism",
12607 "backfillParallelism",
12608 "max_parallelism",
12609 "maxParallelism",
12610 "backfill_order",
12611 "backfillOrder",
12612 ];
12613
12614 #[allow(clippy::enum_variant_names)]
12615 enum GeneratedField {
12616 Fragments,
12617 Edges,
12618 DependentTableIds,
12619 TableIdsCnt,
12620 Ctx,
12621 Parallelism,
12622 BackfillParallelism,
12623 MaxParallelism,
12624 BackfillOrder,
12625 }
12626 impl<'de> serde::Deserialize<'de> for GeneratedField {
12627 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12628 where
12629 D: serde::Deserializer<'de>,
12630 {
12631 struct GeneratedVisitor;
12632
12633 impl serde::de::Visitor<'_> for GeneratedVisitor {
12634 type Value = GeneratedField;
12635
12636 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12637 write!(formatter, "expected one of: {:?}", &FIELDS)
12638 }
12639
12640 #[allow(unused_variables)]
12641 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12642 where
12643 E: serde::de::Error,
12644 {
12645 match value {
12646 "fragments" => Ok(GeneratedField::Fragments),
12647 "edges" => Ok(GeneratedField::Edges),
12648 "dependentTableIds" | "dependent_table_ids" => Ok(GeneratedField::DependentTableIds),
12649 "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
12650 "ctx" => Ok(GeneratedField::Ctx),
12651 "parallelism" => Ok(GeneratedField::Parallelism),
12652 "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
12653 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
12654 "backfillOrder" | "backfill_order" => Ok(GeneratedField::BackfillOrder),
12655 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12656 }
12657 }
12658 }
12659 deserializer.deserialize_identifier(GeneratedVisitor)
12660 }
12661 }
12662 struct GeneratedVisitor;
12663 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12664 type Value = StreamFragmentGraph;
12665
12666 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12667 formatter.write_str("struct stream_plan.StreamFragmentGraph")
12668 }
12669
12670 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFragmentGraph, V::Error>
12671 where
12672 V: serde::de::MapAccess<'de>,
12673 {
12674 let mut fragments__ = None;
12675 let mut edges__ = None;
12676 let mut dependent_table_ids__ = None;
12677 let mut table_ids_cnt__ = None;
12678 let mut ctx__ = None;
12679 let mut parallelism__ = None;
12680 let mut backfill_parallelism__ = None;
12681 let mut max_parallelism__ = None;
12682 let mut backfill_order__ = None;
12683 while let Some(k) = map_.next_key()? {
12684 match k {
12685 GeneratedField::Fragments => {
12686 if fragments__.is_some() {
12687 return Err(serde::de::Error::duplicate_field("fragments"));
12688 }
12689 fragments__ = Some(
12690 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
12691 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
12692 );
12693 }
12694 GeneratedField::Edges => {
12695 if edges__.is_some() {
12696 return Err(serde::de::Error::duplicate_field("edges"));
12697 }
12698 edges__ = Some(map_.next_value()?);
12699 }
12700 GeneratedField::DependentTableIds => {
12701 if dependent_table_ids__.is_some() {
12702 return Err(serde::de::Error::duplicate_field("dependentTableIds"));
12703 }
12704 dependent_table_ids__ =
12705 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12706 .into_iter().map(|x| x.0).collect())
12707 ;
12708 }
12709 GeneratedField::TableIdsCnt => {
12710 if table_ids_cnt__.is_some() {
12711 return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
12712 }
12713 table_ids_cnt__ =
12714 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12715 ;
12716 }
12717 GeneratedField::Ctx => {
12718 if ctx__.is_some() {
12719 return Err(serde::de::Error::duplicate_field("ctx"));
12720 }
12721 ctx__ = map_.next_value()?;
12722 }
12723 GeneratedField::Parallelism => {
12724 if parallelism__.is_some() {
12725 return Err(serde::de::Error::duplicate_field("parallelism"));
12726 }
12727 parallelism__ = map_.next_value()?;
12728 }
12729 GeneratedField::BackfillParallelism => {
12730 if backfill_parallelism__.is_some() {
12731 return Err(serde::de::Error::duplicate_field("backfillParallelism"));
12732 }
12733 backfill_parallelism__ = map_.next_value()?;
12734 }
12735 GeneratedField::MaxParallelism => {
12736 if max_parallelism__.is_some() {
12737 return Err(serde::de::Error::duplicate_field("maxParallelism"));
12738 }
12739 max_parallelism__ =
12740 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12741 ;
12742 }
12743 GeneratedField::BackfillOrder => {
12744 if backfill_order__.is_some() {
12745 return Err(serde::de::Error::duplicate_field("backfillOrder"));
12746 }
12747 backfill_order__ = map_.next_value()?;
12748 }
12749 }
12750 }
12751 Ok(StreamFragmentGraph {
12752 fragments: fragments__.unwrap_or_default(),
12753 edges: edges__.unwrap_or_default(),
12754 dependent_table_ids: dependent_table_ids__.unwrap_or_default(),
12755 table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
12756 ctx: ctx__,
12757 parallelism: parallelism__,
12758 backfill_parallelism: backfill_parallelism__,
12759 max_parallelism: max_parallelism__.unwrap_or_default(),
12760 backfill_order: backfill_order__,
12761 })
12762 }
12763 }
12764 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph", FIELDS, GeneratedVisitor)
12765 }
12766}
12767impl serde::Serialize for stream_fragment_graph::Parallelism {
12768 #[allow(deprecated)]
12769 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12770 where
12771 S: serde::Serializer,
12772 {
12773 use serde::ser::SerializeStruct;
12774 let mut len = 0;
12775 if self.parallelism != 0 {
12776 len += 1;
12777 }
12778 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.Parallelism", len)?;
12779 if self.parallelism != 0 {
12780 #[allow(clippy::needless_borrow)]
12781 #[allow(clippy::needless_borrows_for_generic_args)]
12782 struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
12783 }
12784 struct_ser.end()
12785 }
12786}
12787impl<'de> serde::Deserialize<'de> for stream_fragment_graph::Parallelism {
12788 #[allow(deprecated)]
12789 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12790 where
12791 D: serde::Deserializer<'de>,
12792 {
12793 const FIELDS: &[&str] = &[
12794 "parallelism",
12795 ];
12796
12797 #[allow(clippy::enum_variant_names)]
12798 enum GeneratedField {
12799 Parallelism,
12800 }
12801 impl<'de> serde::Deserialize<'de> for GeneratedField {
12802 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12803 where
12804 D: serde::Deserializer<'de>,
12805 {
12806 struct GeneratedVisitor;
12807
12808 impl serde::de::Visitor<'_> for GeneratedVisitor {
12809 type Value = GeneratedField;
12810
12811 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12812 write!(formatter, "expected one of: {:?}", &FIELDS)
12813 }
12814
12815 #[allow(unused_variables)]
12816 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12817 where
12818 E: serde::de::Error,
12819 {
12820 match value {
12821 "parallelism" => Ok(GeneratedField::Parallelism),
12822 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12823 }
12824 }
12825 }
12826 deserializer.deserialize_identifier(GeneratedVisitor)
12827 }
12828 }
12829 struct GeneratedVisitor;
12830 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12831 type Value = stream_fragment_graph::Parallelism;
12832
12833 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12834 formatter.write_str("struct stream_plan.StreamFragmentGraph.Parallelism")
12835 }
12836
12837 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::Parallelism, V::Error>
12838 where
12839 V: serde::de::MapAccess<'de>,
12840 {
12841 let mut parallelism__ = None;
12842 while let Some(k) = map_.next_key()? {
12843 match k {
12844 GeneratedField::Parallelism => {
12845 if parallelism__.is_some() {
12846 return Err(serde::de::Error::duplicate_field("parallelism"));
12847 }
12848 parallelism__ =
12849 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12850 ;
12851 }
12852 }
12853 }
12854 Ok(stream_fragment_graph::Parallelism {
12855 parallelism: parallelism__.unwrap_or_default(),
12856 })
12857 }
12858 }
12859 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.Parallelism", FIELDS, GeneratedVisitor)
12860 }
12861}
12862impl serde::Serialize for stream_fragment_graph::StreamFragment {
12863 #[allow(deprecated)]
12864 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12865 where
12866 S: serde::Serializer,
12867 {
12868 use serde::ser::SerializeStruct;
12869 let mut len = 0;
12870 if self.fragment_id != 0 {
12871 len += 1;
12872 }
12873 if self.node.is_some() {
12874 len += 1;
12875 }
12876 if self.fragment_type_mask != 0 {
12877 len += 1;
12878 }
12879 if self.requires_singleton {
12880 len += 1;
12881 }
12882 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", len)?;
12883 if self.fragment_id != 0 {
12884 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
12885 }
12886 if let Some(v) = self.node.as_ref() {
12887 struct_ser.serialize_field("node", v)?;
12888 }
12889 if self.fragment_type_mask != 0 {
12890 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
12891 }
12892 if self.requires_singleton {
12893 struct_ser.serialize_field("requiresSingleton", &self.requires_singleton)?;
12894 }
12895 struct_ser.end()
12896 }
12897}
12898impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragment {
12899 #[allow(deprecated)]
12900 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12901 where
12902 D: serde::Deserializer<'de>,
12903 {
12904 const FIELDS: &[&str] = &[
12905 "fragment_id",
12906 "fragmentId",
12907 "node",
12908 "fragment_type_mask",
12909 "fragmentTypeMask",
12910 "requires_singleton",
12911 "requiresSingleton",
12912 ];
12913
12914 #[allow(clippy::enum_variant_names)]
12915 enum GeneratedField {
12916 FragmentId,
12917 Node,
12918 FragmentTypeMask,
12919 RequiresSingleton,
12920 }
12921 impl<'de> serde::Deserialize<'de> for GeneratedField {
12922 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12923 where
12924 D: serde::Deserializer<'de>,
12925 {
12926 struct GeneratedVisitor;
12927
12928 impl serde::de::Visitor<'_> for GeneratedVisitor {
12929 type Value = GeneratedField;
12930
12931 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12932 write!(formatter, "expected one of: {:?}", &FIELDS)
12933 }
12934
12935 #[allow(unused_variables)]
12936 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12937 where
12938 E: serde::de::Error,
12939 {
12940 match value {
12941 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
12942 "node" => Ok(GeneratedField::Node),
12943 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
12944 "requiresSingleton" | "requires_singleton" => Ok(GeneratedField::RequiresSingleton),
12945 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12946 }
12947 }
12948 }
12949 deserializer.deserialize_identifier(GeneratedVisitor)
12950 }
12951 }
12952 struct GeneratedVisitor;
12953 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12954 type Value = stream_fragment_graph::StreamFragment;
12955
12956 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12957 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragment")
12958 }
12959
12960 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragment, V::Error>
12961 where
12962 V: serde::de::MapAccess<'de>,
12963 {
12964 let mut fragment_id__ = None;
12965 let mut node__ = None;
12966 let mut fragment_type_mask__ = None;
12967 let mut requires_singleton__ = None;
12968 while let Some(k) = map_.next_key()? {
12969 match k {
12970 GeneratedField::FragmentId => {
12971 if fragment_id__.is_some() {
12972 return Err(serde::de::Error::duplicate_field("fragmentId"));
12973 }
12974 fragment_id__ =
12975 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12976 ;
12977 }
12978 GeneratedField::Node => {
12979 if node__.is_some() {
12980 return Err(serde::de::Error::duplicate_field("node"));
12981 }
12982 node__ = map_.next_value()?;
12983 }
12984 GeneratedField::FragmentTypeMask => {
12985 if fragment_type_mask__.is_some() {
12986 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
12987 }
12988 fragment_type_mask__ =
12989 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12990 ;
12991 }
12992 GeneratedField::RequiresSingleton => {
12993 if requires_singleton__.is_some() {
12994 return Err(serde::de::Error::duplicate_field("requiresSingleton"));
12995 }
12996 requires_singleton__ = Some(map_.next_value()?);
12997 }
12998 }
12999 }
13000 Ok(stream_fragment_graph::StreamFragment {
13001 fragment_id: fragment_id__.unwrap_or_default(),
13002 node: node__,
13003 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
13004 requires_singleton: requires_singleton__.unwrap_or_default(),
13005 })
13006 }
13007 }
13008 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", FIELDS, GeneratedVisitor)
13009 }
13010}
13011impl serde::Serialize for stream_fragment_graph::StreamFragmentEdge {
13012 #[allow(deprecated)]
13013 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13014 where
13015 S: serde::Serializer,
13016 {
13017 use serde::ser::SerializeStruct;
13018 let mut len = 0;
13019 if self.dispatch_strategy.is_some() {
13020 len += 1;
13021 }
13022 if self.link_id != 0 {
13023 len += 1;
13024 }
13025 if self.upstream_id != 0 {
13026 len += 1;
13027 }
13028 if self.downstream_id != 0 {
13029 len += 1;
13030 }
13031 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", len)?;
13032 if let Some(v) = self.dispatch_strategy.as_ref() {
13033 struct_ser.serialize_field("dispatchStrategy", v)?;
13034 }
13035 if self.link_id != 0 {
13036 #[allow(clippy::needless_borrow)]
13037 #[allow(clippy::needless_borrows_for_generic_args)]
13038 struct_ser.serialize_field("linkId", ToString::to_string(&self.link_id).as_str())?;
13039 }
13040 if self.upstream_id != 0 {
13041 struct_ser.serialize_field("upstreamId", &self.upstream_id)?;
13042 }
13043 if self.downstream_id != 0 {
13044 struct_ser.serialize_field("downstreamId", &self.downstream_id)?;
13045 }
13046 struct_ser.end()
13047 }
13048}
13049impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragmentEdge {
13050 #[allow(deprecated)]
13051 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13052 where
13053 D: serde::Deserializer<'de>,
13054 {
13055 const FIELDS: &[&str] = &[
13056 "dispatch_strategy",
13057 "dispatchStrategy",
13058 "link_id",
13059 "linkId",
13060 "upstream_id",
13061 "upstreamId",
13062 "downstream_id",
13063 "downstreamId",
13064 ];
13065
13066 #[allow(clippy::enum_variant_names)]
13067 enum GeneratedField {
13068 DispatchStrategy,
13069 LinkId,
13070 UpstreamId,
13071 DownstreamId,
13072 }
13073 impl<'de> serde::Deserialize<'de> for GeneratedField {
13074 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13075 where
13076 D: serde::Deserializer<'de>,
13077 {
13078 struct GeneratedVisitor;
13079
13080 impl serde::de::Visitor<'_> for GeneratedVisitor {
13081 type Value = GeneratedField;
13082
13083 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13084 write!(formatter, "expected one of: {:?}", &FIELDS)
13085 }
13086
13087 #[allow(unused_variables)]
13088 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13089 where
13090 E: serde::de::Error,
13091 {
13092 match value {
13093 "dispatchStrategy" | "dispatch_strategy" => Ok(GeneratedField::DispatchStrategy),
13094 "linkId" | "link_id" => Ok(GeneratedField::LinkId),
13095 "upstreamId" | "upstream_id" => Ok(GeneratedField::UpstreamId),
13096 "downstreamId" | "downstream_id" => Ok(GeneratedField::DownstreamId),
13097 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13098 }
13099 }
13100 }
13101 deserializer.deserialize_identifier(GeneratedVisitor)
13102 }
13103 }
13104 struct GeneratedVisitor;
13105 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13106 type Value = stream_fragment_graph::StreamFragmentEdge;
13107
13108 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13109 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragmentEdge")
13110 }
13111
13112 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragmentEdge, V::Error>
13113 where
13114 V: serde::de::MapAccess<'de>,
13115 {
13116 let mut dispatch_strategy__ = None;
13117 let mut link_id__ = None;
13118 let mut upstream_id__ = None;
13119 let mut downstream_id__ = None;
13120 while let Some(k) = map_.next_key()? {
13121 match k {
13122 GeneratedField::DispatchStrategy => {
13123 if dispatch_strategy__.is_some() {
13124 return Err(serde::de::Error::duplicate_field("dispatchStrategy"));
13125 }
13126 dispatch_strategy__ = map_.next_value()?;
13127 }
13128 GeneratedField::LinkId => {
13129 if link_id__.is_some() {
13130 return Err(serde::de::Error::duplicate_field("linkId"));
13131 }
13132 link_id__ =
13133 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13134 ;
13135 }
13136 GeneratedField::UpstreamId => {
13137 if upstream_id__.is_some() {
13138 return Err(serde::de::Error::duplicate_field("upstreamId"));
13139 }
13140 upstream_id__ =
13141 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13142 ;
13143 }
13144 GeneratedField::DownstreamId => {
13145 if downstream_id__.is_some() {
13146 return Err(serde::de::Error::duplicate_field("downstreamId"));
13147 }
13148 downstream_id__ =
13149 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13150 ;
13151 }
13152 }
13153 }
13154 Ok(stream_fragment_graph::StreamFragmentEdge {
13155 dispatch_strategy: dispatch_strategy__,
13156 link_id: link_id__.unwrap_or_default(),
13157 upstream_id: upstream_id__.unwrap_or_default(),
13158 downstream_id: downstream_id__.unwrap_or_default(),
13159 })
13160 }
13161 }
13162 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", FIELDS, GeneratedVisitor)
13163 }
13164}
13165impl serde::Serialize for StreamFsFetch {
13166 #[allow(deprecated)]
13167 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13168 where
13169 S: serde::Serializer,
13170 {
13171 use serde::ser::SerializeStruct;
13172 let mut len = 0;
13173 if self.source_id != 0 {
13174 len += 1;
13175 }
13176 if self.state_table.is_some() {
13177 len += 1;
13178 }
13179 if self.row_id_index.is_some() {
13180 len += 1;
13181 }
13182 if !self.columns.is_empty() {
13183 len += 1;
13184 }
13185 if !self.with_properties.is_empty() {
13186 len += 1;
13187 }
13188 if self.info.is_some() {
13189 len += 1;
13190 }
13191 if !self.source_name.is_empty() {
13192 len += 1;
13193 }
13194 if self.rate_limit.is_some() {
13195 len += 1;
13196 }
13197 if !self.secret_refs.is_empty() {
13198 len += 1;
13199 }
13200 if self.refresh_mode.is_some() {
13201 len += 1;
13202 }
13203 if self.associated_table_id.is_some() {
13204 len += 1;
13205 }
13206 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetch", len)?;
13207 if self.source_id != 0 {
13208 struct_ser.serialize_field("sourceId", &self.source_id)?;
13209 }
13210 if let Some(v) = self.state_table.as_ref() {
13211 struct_ser.serialize_field("stateTable", v)?;
13212 }
13213 if let Some(v) = self.row_id_index.as_ref() {
13214 struct_ser.serialize_field("rowIdIndex", v)?;
13215 }
13216 if !self.columns.is_empty() {
13217 struct_ser.serialize_field("columns", &self.columns)?;
13218 }
13219 if !self.with_properties.is_empty() {
13220 struct_ser.serialize_field("withProperties", &self.with_properties)?;
13221 }
13222 if let Some(v) = self.info.as_ref() {
13223 struct_ser.serialize_field("info", v)?;
13224 }
13225 if !self.source_name.is_empty() {
13226 struct_ser.serialize_field("sourceName", &self.source_name)?;
13227 }
13228 if let Some(v) = self.rate_limit.as_ref() {
13229 struct_ser.serialize_field("rateLimit", v)?;
13230 }
13231 if !self.secret_refs.is_empty() {
13232 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
13233 }
13234 if let Some(v) = self.refresh_mode.as_ref() {
13235 struct_ser.serialize_field("refreshMode", v)?;
13236 }
13237 if let Some(v) = self.associated_table_id.as_ref() {
13238 struct_ser.serialize_field("associatedTableId", v)?;
13239 }
13240 struct_ser.end()
13241 }
13242}
13243impl<'de> serde::Deserialize<'de> for StreamFsFetch {
13244 #[allow(deprecated)]
13245 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13246 where
13247 D: serde::Deserializer<'de>,
13248 {
13249 const FIELDS: &[&str] = &[
13250 "source_id",
13251 "sourceId",
13252 "state_table",
13253 "stateTable",
13254 "row_id_index",
13255 "rowIdIndex",
13256 "columns",
13257 "with_properties",
13258 "withProperties",
13259 "info",
13260 "source_name",
13261 "sourceName",
13262 "rate_limit",
13263 "rateLimit",
13264 "secret_refs",
13265 "secretRefs",
13266 "refresh_mode",
13267 "refreshMode",
13268 "associated_table_id",
13269 "associatedTableId",
13270 ];
13271
13272 #[allow(clippy::enum_variant_names)]
13273 enum GeneratedField {
13274 SourceId,
13275 StateTable,
13276 RowIdIndex,
13277 Columns,
13278 WithProperties,
13279 Info,
13280 SourceName,
13281 RateLimit,
13282 SecretRefs,
13283 RefreshMode,
13284 AssociatedTableId,
13285 }
13286 impl<'de> serde::Deserialize<'de> for GeneratedField {
13287 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13288 where
13289 D: serde::Deserializer<'de>,
13290 {
13291 struct GeneratedVisitor;
13292
13293 impl serde::de::Visitor<'_> for GeneratedVisitor {
13294 type Value = GeneratedField;
13295
13296 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13297 write!(formatter, "expected one of: {:?}", &FIELDS)
13298 }
13299
13300 #[allow(unused_variables)]
13301 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13302 where
13303 E: serde::de::Error,
13304 {
13305 match value {
13306 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
13307 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
13308 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
13309 "columns" => Ok(GeneratedField::Columns),
13310 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
13311 "info" => Ok(GeneratedField::Info),
13312 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
13313 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
13314 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
13315 "refreshMode" | "refresh_mode" => Ok(GeneratedField::RefreshMode),
13316 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
13317 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13318 }
13319 }
13320 }
13321 deserializer.deserialize_identifier(GeneratedVisitor)
13322 }
13323 }
13324 struct GeneratedVisitor;
13325 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13326 type Value = StreamFsFetch;
13327
13328 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13329 formatter.write_str("struct stream_plan.StreamFsFetch")
13330 }
13331
13332 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetch, V::Error>
13333 where
13334 V: serde::de::MapAccess<'de>,
13335 {
13336 let mut source_id__ = None;
13337 let mut state_table__ = None;
13338 let mut row_id_index__ = None;
13339 let mut columns__ = None;
13340 let mut with_properties__ = None;
13341 let mut info__ = None;
13342 let mut source_name__ = None;
13343 let mut rate_limit__ = None;
13344 let mut secret_refs__ = None;
13345 let mut refresh_mode__ = None;
13346 let mut associated_table_id__ = None;
13347 while let Some(k) = map_.next_key()? {
13348 match k {
13349 GeneratedField::SourceId => {
13350 if source_id__.is_some() {
13351 return Err(serde::de::Error::duplicate_field("sourceId"));
13352 }
13353 source_id__ =
13354 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13355 ;
13356 }
13357 GeneratedField::StateTable => {
13358 if state_table__.is_some() {
13359 return Err(serde::de::Error::duplicate_field("stateTable"));
13360 }
13361 state_table__ = map_.next_value()?;
13362 }
13363 GeneratedField::RowIdIndex => {
13364 if row_id_index__.is_some() {
13365 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
13366 }
13367 row_id_index__ =
13368 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13369 ;
13370 }
13371 GeneratedField::Columns => {
13372 if columns__.is_some() {
13373 return Err(serde::de::Error::duplicate_field("columns"));
13374 }
13375 columns__ = Some(map_.next_value()?);
13376 }
13377 GeneratedField::WithProperties => {
13378 if with_properties__.is_some() {
13379 return Err(serde::de::Error::duplicate_field("withProperties"));
13380 }
13381 with_properties__ = Some(
13382 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13383 );
13384 }
13385 GeneratedField::Info => {
13386 if info__.is_some() {
13387 return Err(serde::de::Error::duplicate_field("info"));
13388 }
13389 info__ = map_.next_value()?;
13390 }
13391 GeneratedField::SourceName => {
13392 if source_name__.is_some() {
13393 return Err(serde::de::Error::duplicate_field("sourceName"));
13394 }
13395 source_name__ = Some(map_.next_value()?);
13396 }
13397 GeneratedField::RateLimit => {
13398 if rate_limit__.is_some() {
13399 return Err(serde::de::Error::duplicate_field("rateLimit"));
13400 }
13401 rate_limit__ =
13402 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13403 ;
13404 }
13405 GeneratedField::SecretRefs => {
13406 if secret_refs__.is_some() {
13407 return Err(serde::de::Error::duplicate_field("secretRefs"));
13408 }
13409 secret_refs__ = Some(
13410 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13411 );
13412 }
13413 GeneratedField::RefreshMode => {
13414 if refresh_mode__.is_some() {
13415 return Err(serde::de::Error::duplicate_field("refreshMode"));
13416 }
13417 refresh_mode__ = map_.next_value()?;
13418 }
13419 GeneratedField::AssociatedTableId => {
13420 if associated_table_id__.is_some() {
13421 return Err(serde::de::Error::duplicate_field("associatedTableId"));
13422 }
13423 associated_table_id__ =
13424 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13425 ;
13426 }
13427 }
13428 }
13429 Ok(StreamFsFetch {
13430 source_id: source_id__.unwrap_or_default(),
13431 state_table: state_table__,
13432 row_id_index: row_id_index__,
13433 columns: columns__.unwrap_or_default(),
13434 with_properties: with_properties__.unwrap_or_default(),
13435 info: info__,
13436 source_name: source_name__.unwrap_or_default(),
13437 rate_limit: rate_limit__,
13438 secret_refs: secret_refs__.unwrap_or_default(),
13439 refresh_mode: refresh_mode__,
13440 associated_table_id: associated_table_id__,
13441 })
13442 }
13443 }
13444 deserializer.deserialize_struct("stream_plan.StreamFsFetch", FIELDS, GeneratedVisitor)
13445 }
13446}
13447impl serde::Serialize for StreamFsFetchNode {
13448 #[allow(deprecated)]
13449 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13450 where
13451 S: serde::Serializer,
13452 {
13453 use serde::ser::SerializeStruct;
13454 let mut len = 0;
13455 if self.node_inner.is_some() {
13456 len += 1;
13457 }
13458 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetchNode", len)?;
13459 if let Some(v) = self.node_inner.as_ref() {
13460 struct_ser.serialize_field("nodeInner", v)?;
13461 }
13462 struct_ser.end()
13463 }
13464}
13465impl<'de> serde::Deserialize<'de> for StreamFsFetchNode {
13466 #[allow(deprecated)]
13467 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13468 where
13469 D: serde::Deserializer<'de>,
13470 {
13471 const FIELDS: &[&str] = &[
13472 "node_inner",
13473 "nodeInner",
13474 ];
13475
13476 #[allow(clippy::enum_variant_names)]
13477 enum GeneratedField {
13478 NodeInner,
13479 }
13480 impl<'de> serde::Deserialize<'de> for GeneratedField {
13481 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13482 where
13483 D: serde::Deserializer<'de>,
13484 {
13485 struct GeneratedVisitor;
13486
13487 impl serde::de::Visitor<'_> for GeneratedVisitor {
13488 type Value = GeneratedField;
13489
13490 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13491 write!(formatter, "expected one of: {:?}", &FIELDS)
13492 }
13493
13494 #[allow(unused_variables)]
13495 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13496 where
13497 E: serde::de::Error,
13498 {
13499 match value {
13500 "nodeInner" | "node_inner" => Ok(GeneratedField::NodeInner),
13501 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13502 }
13503 }
13504 }
13505 deserializer.deserialize_identifier(GeneratedVisitor)
13506 }
13507 }
13508 struct GeneratedVisitor;
13509 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13510 type Value = StreamFsFetchNode;
13511
13512 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13513 formatter.write_str("struct stream_plan.StreamFsFetchNode")
13514 }
13515
13516 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetchNode, V::Error>
13517 where
13518 V: serde::de::MapAccess<'de>,
13519 {
13520 let mut node_inner__ = None;
13521 while let Some(k) = map_.next_key()? {
13522 match k {
13523 GeneratedField::NodeInner => {
13524 if node_inner__.is_some() {
13525 return Err(serde::de::Error::duplicate_field("nodeInner"));
13526 }
13527 node_inner__ = map_.next_value()?;
13528 }
13529 }
13530 }
13531 Ok(StreamFsFetchNode {
13532 node_inner: node_inner__,
13533 })
13534 }
13535 }
13536 deserializer.deserialize_struct("stream_plan.StreamFsFetchNode", FIELDS, GeneratedVisitor)
13537 }
13538}
13539impl serde::Serialize for StreamMessage {
13540 #[allow(deprecated)]
13541 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13542 where
13543 S: serde::Serializer,
13544 {
13545 use serde::ser::SerializeStruct;
13546 let mut len = 0;
13547 if self.stream_message.is_some() {
13548 len += 1;
13549 }
13550 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessage", len)?;
13551 if let Some(v) = self.stream_message.as_ref() {
13552 match v {
13553 stream_message::StreamMessage::StreamChunk(v) => {
13554 struct_ser.serialize_field("streamChunk", v)?;
13555 }
13556 stream_message::StreamMessage::Barrier(v) => {
13557 struct_ser.serialize_field("barrier", v)?;
13558 }
13559 stream_message::StreamMessage::Watermark(v) => {
13560 struct_ser.serialize_field("watermark", v)?;
13561 }
13562 }
13563 }
13564 struct_ser.end()
13565 }
13566}
13567impl<'de> serde::Deserialize<'de> for StreamMessage {
13568 #[allow(deprecated)]
13569 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13570 where
13571 D: serde::Deserializer<'de>,
13572 {
13573 const FIELDS: &[&str] = &[
13574 "stream_chunk",
13575 "streamChunk",
13576 "barrier",
13577 "watermark",
13578 ];
13579
13580 #[allow(clippy::enum_variant_names)]
13581 enum GeneratedField {
13582 StreamChunk,
13583 Barrier,
13584 Watermark,
13585 }
13586 impl<'de> serde::Deserialize<'de> for GeneratedField {
13587 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13588 where
13589 D: serde::Deserializer<'de>,
13590 {
13591 struct GeneratedVisitor;
13592
13593 impl serde::de::Visitor<'_> for GeneratedVisitor {
13594 type Value = GeneratedField;
13595
13596 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13597 write!(formatter, "expected one of: {:?}", &FIELDS)
13598 }
13599
13600 #[allow(unused_variables)]
13601 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13602 where
13603 E: serde::de::Error,
13604 {
13605 match value {
13606 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
13607 "barrier" => Ok(GeneratedField::Barrier),
13608 "watermark" => Ok(GeneratedField::Watermark),
13609 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13610 }
13611 }
13612 }
13613 deserializer.deserialize_identifier(GeneratedVisitor)
13614 }
13615 }
13616 struct GeneratedVisitor;
13617 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13618 type Value = StreamMessage;
13619
13620 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13621 formatter.write_str("struct stream_plan.StreamMessage")
13622 }
13623
13624 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessage, V::Error>
13625 where
13626 V: serde::de::MapAccess<'de>,
13627 {
13628 let mut stream_message__ = None;
13629 while let Some(k) = map_.next_key()? {
13630 match k {
13631 GeneratedField::StreamChunk => {
13632 if stream_message__.is_some() {
13633 return Err(serde::de::Error::duplicate_field("streamChunk"));
13634 }
13635 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::StreamChunk)
13636;
13637 }
13638 GeneratedField::Barrier => {
13639 if stream_message__.is_some() {
13640 return Err(serde::de::Error::duplicate_field("barrier"));
13641 }
13642 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Barrier)
13643;
13644 }
13645 GeneratedField::Watermark => {
13646 if stream_message__.is_some() {
13647 return Err(serde::de::Error::duplicate_field("watermark"));
13648 }
13649 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Watermark)
13650;
13651 }
13652 }
13653 }
13654 Ok(StreamMessage {
13655 stream_message: stream_message__,
13656 })
13657 }
13658 }
13659 deserializer.deserialize_struct("stream_plan.StreamMessage", FIELDS, GeneratedVisitor)
13660 }
13661}
13662impl serde::Serialize for StreamMessageBatch {
13663 #[allow(deprecated)]
13664 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13665 where
13666 S: serde::Serializer,
13667 {
13668 use serde::ser::SerializeStruct;
13669 let mut len = 0;
13670 if self.stream_message_batch.is_some() {
13671 len += 1;
13672 }
13673 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch", len)?;
13674 if let Some(v) = self.stream_message_batch.as_ref() {
13675 match v {
13676 stream_message_batch::StreamMessageBatch::StreamChunk(v) => {
13677 struct_ser.serialize_field("streamChunk", v)?;
13678 }
13679 stream_message_batch::StreamMessageBatch::BarrierBatch(v) => {
13680 struct_ser.serialize_field("barrierBatch", v)?;
13681 }
13682 stream_message_batch::StreamMessageBatch::Watermark(v) => {
13683 struct_ser.serialize_field("watermark", v)?;
13684 }
13685 }
13686 }
13687 struct_ser.end()
13688 }
13689}
13690impl<'de> serde::Deserialize<'de> for StreamMessageBatch {
13691 #[allow(deprecated)]
13692 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13693 where
13694 D: serde::Deserializer<'de>,
13695 {
13696 const FIELDS: &[&str] = &[
13697 "stream_chunk",
13698 "streamChunk",
13699 "barrier_batch",
13700 "barrierBatch",
13701 "watermark",
13702 ];
13703
13704 #[allow(clippy::enum_variant_names)]
13705 enum GeneratedField {
13706 StreamChunk,
13707 BarrierBatch,
13708 Watermark,
13709 }
13710 impl<'de> serde::Deserialize<'de> for GeneratedField {
13711 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13712 where
13713 D: serde::Deserializer<'de>,
13714 {
13715 struct GeneratedVisitor;
13716
13717 impl serde::de::Visitor<'_> for GeneratedVisitor {
13718 type Value = GeneratedField;
13719
13720 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13721 write!(formatter, "expected one of: {:?}", &FIELDS)
13722 }
13723
13724 #[allow(unused_variables)]
13725 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13726 where
13727 E: serde::de::Error,
13728 {
13729 match value {
13730 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
13731 "barrierBatch" | "barrier_batch" => Ok(GeneratedField::BarrierBatch),
13732 "watermark" => Ok(GeneratedField::Watermark),
13733 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13734 }
13735 }
13736 }
13737 deserializer.deserialize_identifier(GeneratedVisitor)
13738 }
13739 }
13740 struct GeneratedVisitor;
13741 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13742 type Value = StreamMessageBatch;
13743
13744 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13745 formatter.write_str("struct stream_plan.StreamMessageBatch")
13746 }
13747
13748 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessageBatch, V::Error>
13749 where
13750 V: serde::de::MapAccess<'de>,
13751 {
13752 let mut stream_message_batch__ = None;
13753 while let Some(k) = map_.next_key()? {
13754 match k {
13755 GeneratedField::StreamChunk => {
13756 if stream_message_batch__.is_some() {
13757 return Err(serde::de::Error::duplicate_field("streamChunk"));
13758 }
13759 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::StreamChunk)
13760;
13761 }
13762 GeneratedField::BarrierBatch => {
13763 if stream_message_batch__.is_some() {
13764 return Err(serde::de::Error::duplicate_field("barrierBatch"));
13765 }
13766 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::BarrierBatch)
13767;
13768 }
13769 GeneratedField::Watermark => {
13770 if stream_message_batch__.is_some() {
13771 return Err(serde::de::Error::duplicate_field("watermark"));
13772 }
13773 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::Watermark)
13774;
13775 }
13776 }
13777 }
13778 Ok(StreamMessageBatch {
13779 stream_message_batch: stream_message_batch__,
13780 })
13781 }
13782 }
13783 deserializer.deserialize_struct("stream_plan.StreamMessageBatch", FIELDS, GeneratedVisitor)
13784 }
13785}
13786impl serde::Serialize for stream_message_batch::BarrierBatch {
13787 #[allow(deprecated)]
13788 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13789 where
13790 S: serde::Serializer,
13791 {
13792 use serde::ser::SerializeStruct;
13793 let mut len = 0;
13794 if !self.barriers.is_empty() {
13795 len += 1;
13796 }
13797 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", len)?;
13798 if !self.barriers.is_empty() {
13799 struct_ser.serialize_field("barriers", &self.barriers)?;
13800 }
13801 struct_ser.end()
13802 }
13803}
13804impl<'de> serde::Deserialize<'de> for stream_message_batch::BarrierBatch {
13805 #[allow(deprecated)]
13806 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13807 where
13808 D: serde::Deserializer<'de>,
13809 {
13810 const FIELDS: &[&str] = &[
13811 "barriers",
13812 ];
13813
13814 #[allow(clippy::enum_variant_names)]
13815 enum GeneratedField {
13816 Barriers,
13817 }
13818 impl<'de> serde::Deserialize<'de> for GeneratedField {
13819 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13820 where
13821 D: serde::Deserializer<'de>,
13822 {
13823 struct GeneratedVisitor;
13824
13825 impl serde::de::Visitor<'_> for GeneratedVisitor {
13826 type Value = GeneratedField;
13827
13828 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13829 write!(formatter, "expected one of: {:?}", &FIELDS)
13830 }
13831
13832 #[allow(unused_variables)]
13833 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13834 where
13835 E: serde::de::Error,
13836 {
13837 match value {
13838 "barriers" => Ok(GeneratedField::Barriers),
13839 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13840 }
13841 }
13842 }
13843 deserializer.deserialize_identifier(GeneratedVisitor)
13844 }
13845 }
13846 struct GeneratedVisitor;
13847 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13848 type Value = stream_message_batch::BarrierBatch;
13849
13850 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13851 formatter.write_str("struct stream_plan.StreamMessageBatch.BarrierBatch")
13852 }
13853
13854 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_message_batch::BarrierBatch, V::Error>
13855 where
13856 V: serde::de::MapAccess<'de>,
13857 {
13858 let mut barriers__ = None;
13859 while let Some(k) = map_.next_key()? {
13860 match k {
13861 GeneratedField::Barriers => {
13862 if barriers__.is_some() {
13863 return Err(serde::de::Error::duplicate_field("barriers"));
13864 }
13865 barriers__ = Some(map_.next_value()?);
13866 }
13867 }
13868 }
13869 Ok(stream_message_batch::BarrierBatch {
13870 barriers: barriers__.unwrap_or_default(),
13871 })
13872 }
13873 }
13874 deserializer.deserialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", FIELDS, GeneratedVisitor)
13875 }
13876}
13877impl serde::Serialize for StreamNode {
13878 #[allow(deprecated)]
13879 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13880 where
13881 S: serde::Serializer,
13882 {
13883 use serde::ser::SerializeStruct;
13884 let mut len = 0;
13885 if self.operator_id != 0 {
13886 len += 1;
13887 }
13888 if !self.input.is_empty() {
13889 len += 1;
13890 }
13891 if !self.stream_key.is_empty() {
13892 len += 1;
13893 }
13894 if self.stream_kind != 0 {
13895 len += 1;
13896 }
13897 if !self.identity.is_empty() {
13898 len += 1;
13899 }
13900 if !self.fields.is_empty() {
13901 len += 1;
13902 }
13903 if self.node_body.is_some() {
13904 len += 1;
13905 }
13906 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamNode", len)?;
13907 if self.operator_id != 0 {
13908 #[allow(clippy::needless_borrow)]
13909 #[allow(clippy::needless_borrows_for_generic_args)]
13910 struct_ser.serialize_field("operatorId", ToString::to_string(&self.operator_id).as_str())?;
13911 }
13912 if !self.input.is_empty() {
13913 struct_ser.serialize_field("input", &self.input)?;
13914 }
13915 if !self.stream_key.is_empty() {
13916 struct_ser.serialize_field("streamKey", &self.stream_key)?;
13917 }
13918 if self.stream_kind != 0 {
13919 let v = stream_node::StreamKind::try_from(self.stream_kind)
13920 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_kind)))?;
13921 struct_ser.serialize_field("streamKind", &v)?;
13922 }
13923 if !self.identity.is_empty() {
13924 struct_ser.serialize_field("identity", &self.identity)?;
13925 }
13926 if !self.fields.is_empty() {
13927 struct_ser.serialize_field("fields", &self.fields)?;
13928 }
13929 if let Some(v) = self.node_body.as_ref() {
13930 match v {
13931 stream_node::NodeBody::Source(v) => {
13932 struct_ser.serialize_field("source", v)?;
13933 }
13934 stream_node::NodeBody::Project(v) => {
13935 struct_ser.serialize_field("project", v)?;
13936 }
13937 stream_node::NodeBody::Filter(v) => {
13938 struct_ser.serialize_field("filter", v)?;
13939 }
13940 stream_node::NodeBody::Materialize(v) => {
13941 struct_ser.serialize_field("materialize", v)?;
13942 }
13943 stream_node::NodeBody::StatelessSimpleAgg(v) => {
13944 struct_ser.serialize_field("statelessSimpleAgg", v)?;
13945 }
13946 stream_node::NodeBody::SimpleAgg(v) => {
13947 struct_ser.serialize_field("simpleAgg", v)?;
13948 }
13949 stream_node::NodeBody::HashAgg(v) => {
13950 struct_ser.serialize_field("hashAgg", v)?;
13951 }
13952 stream_node::NodeBody::AppendOnlyTopN(v) => {
13953 struct_ser.serialize_field("appendOnlyTopN", v)?;
13954 }
13955 stream_node::NodeBody::HashJoin(v) => {
13956 struct_ser.serialize_field("hashJoin", v)?;
13957 }
13958 stream_node::NodeBody::TopN(v) => {
13959 struct_ser.serialize_field("topN", v)?;
13960 }
13961 stream_node::NodeBody::HopWindow(v) => {
13962 struct_ser.serialize_field("hopWindow", v)?;
13963 }
13964 stream_node::NodeBody::Merge(v) => {
13965 struct_ser.serialize_field("merge", v)?;
13966 }
13967 stream_node::NodeBody::Exchange(v) => {
13968 struct_ser.serialize_field("exchange", v)?;
13969 }
13970 stream_node::NodeBody::StreamScan(v) => {
13971 struct_ser.serialize_field("streamScan", v)?;
13972 }
13973 stream_node::NodeBody::BatchPlan(v) => {
13974 struct_ser.serialize_field("batchPlan", v)?;
13975 }
13976 stream_node::NodeBody::Lookup(v) => {
13977 struct_ser.serialize_field("lookup", v)?;
13978 }
13979 stream_node::NodeBody::Arrange(v) => {
13980 struct_ser.serialize_field("arrange", v)?;
13981 }
13982 stream_node::NodeBody::LookupUnion(v) => {
13983 struct_ser.serialize_field("lookupUnion", v)?;
13984 }
13985 stream_node::NodeBody::Union(v) => {
13986 struct_ser.serialize_field("union", v)?;
13987 }
13988 stream_node::NodeBody::DeltaIndexJoin(v) => {
13989 struct_ser.serialize_field("deltaIndexJoin", v)?;
13990 }
13991 stream_node::NodeBody::Sink(v) => {
13992 struct_ser.serialize_field("sink", v)?;
13993 }
13994 stream_node::NodeBody::Expand(v) => {
13995 struct_ser.serialize_field("expand", v)?;
13996 }
13997 stream_node::NodeBody::DynamicFilter(v) => {
13998 struct_ser.serialize_field("dynamicFilter", v)?;
13999 }
14000 stream_node::NodeBody::ProjectSet(v) => {
14001 struct_ser.serialize_field("projectSet", v)?;
14002 }
14003 stream_node::NodeBody::GroupTopN(v) => {
14004 struct_ser.serialize_field("groupTopN", v)?;
14005 }
14006 stream_node::NodeBody::Sort(v) => {
14007 struct_ser.serialize_field("sort", v)?;
14008 }
14009 stream_node::NodeBody::WatermarkFilter(v) => {
14010 struct_ser.serialize_field("watermarkFilter", v)?;
14011 }
14012 stream_node::NodeBody::Dml(v) => {
14013 struct_ser.serialize_field("dml", v)?;
14014 }
14015 stream_node::NodeBody::RowIdGen(v) => {
14016 struct_ser.serialize_field("rowIdGen", v)?;
14017 }
14018 stream_node::NodeBody::Now(v) => {
14019 struct_ser.serialize_field("now", v)?;
14020 }
14021 stream_node::NodeBody::AppendOnlyGroupTopN(v) => {
14022 struct_ser.serialize_field("appendOnlyGroupTopN", v)?;
14023 }
14024 stream_node::NodeBody::TemporalJoin(v) => {
14025 struct_ser.serialize_field("temporalJoin", v)?;
14026 }
14027 stream_node::NodeBody::BarrierRecv(v) => {
14028 struct_ser.serialize_field("barrierRecv", v)?;
14029 }
14030 stream_node::NodeBody::Values(v) => {
14031 struct_ser.serialize_field("values", v)?;
14032 }
14033 stream_node::NodeBody::AppendOnlyDedup(v) => {
14034 struct_ser.serialize_field("appendOnlyDedup", v)?;
14035 }
14036 stream_node::NodeBody::NoOp(v) => {
14037 struct_ser.serialize_field("noOp", v)?;
14038 }
14039 stream_node::NodeBody::EowcOverWindow(v) => {
14040 struct_ser.serialize_field("eowcOverWindow", v)?;
14041 }
14042 stream_node::NodeBody::OverWindow(v) => {
14043 struct_ser.serialize_field("overWindow", v)?;
14044 }
14045 stream_node::NodeBody::StreamFsFetch(v) => {
14046 struct_ser.serialize_field("streamFsFetch", v)?;
14047 }
14048 stream_node::NodeBody::StreamCdcScan(v) => {
14049 struct_ser.serialize_field("streamCdcScan", v)?;
14050 }
14051 stream_node::NodeBody::CdcFilter(v) => {
14052 struct_ser.serialize_field("cdcFilter", v)?;
14053 }
14054 stream_node::NodeBody::SourceBackfill(v) => {
14055 struct_ser.serialize_field("sourceBackfill", v)?;
14056 }
14057 stream_node::NodeBody::Changelog(v) => {
14058 struct_ser.serialize_field("changelog", v)?;
14059 }
14060 stream_node::NodeBody::LocalApproxPercentile(v) => {
14061 struct_ser.serialize_field("localApproxPercentile", v)?;
14062 }
14063 stream_node::NodeBody::GlobalApproxPercentile(v) => {
14064 struct_ser.serialize_field("globalApproxPercentile", v)?;
14065 }
14066 stream_node::NodeBody::RowMerge(v) => {
14067 struct_ser.serialize_field("rowMerge", v)?;
14068 }
14069 stream_node::NodeBody::AsOfJoin(v) => {
14070 struct_ser.serialize_field("asOfJoin", v)?;
14071 }
14072 stream_node::NodeBody::SyncLogStore(v) => {
14073 struct_ser.serialize_field("syncLogStore", v)?;
14074 }
14075 stream_node::NodeBody::MaterializedExprs(v) => {
14076 struct_ser.serialize_field("materializedExprs", v)?;
14077 }
14078 stream_node::NodeBody::VectorIndexWrite(v) => {
14079 struct_ser.serialize_field("vectorIndexWrite", v)?;
14080 }
14081 stream_node::NodeBody::UpstreamSinkUnion(v) => {
14082 struct_ser.serialize_field("upstreamSinkUnion", v)?;
14083 }
14084 stream_node::NodeBody::LocalityProvider(v) => {
14085 struct_ser.serialize_field("localityProvider", v)?;
14086 }
14087 stream_node::NodeBody::EowcGapFill(v) => {
14088 struct_ser.serialize_field("eowcGapFill", v)?;
14089 }
14090 stream_node::NodeBody::GapFill(v) => {
14091 struct_ser.serialize_field("gapFill", v)?;
14092 }
14093 stream_node::NodeBody::VectorIndexLookupJoin(v) => {
14094 struct_ser.serialize_field("vectorIndexLookupJoin", v)?;
14095 }
14096 }
14097 }
14098 struct_ser.end()
14099 }
14100}
14101impl<'de> serde::Deserialize<'de> for StreamNode {
14102 #[allow(deprecated)]
14103 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14104 where
14105 D: serde::Deserializer<'de>,
14106 {
14107 const FIELDS: &[&str] = &[
14108 "operator_id",
14109 "operatorId",
14110 "input",
14111 "stream_key",
14112 "streamKey",
14113 "stream_kind",
14114 "streamKind",
14115 "identity",
14116 "fields",
14117 "source",
14118 "project",
14119 "filter",
14120 "materialize",
14121 "stateless_simple_agg",
14122 "statelessSimpleAgg",
14123 "simple_agg",
14124 "simpleAgg",
14125 "hash_agg",
14126 "hashAgg",
14127 "append_only_top_n",
14128 "appendOnlyTopN",
14129 "hash_join",
14130 "hashJoin",
14131 "top_n",
14132 "topN",
14133 "hop_window",
14134 "hopWindow",
14135 "merge",
14136 "exchange",
14137 "stream_scan",
14138 "streamScan",
14139 "batch_plan",
14140 "batchPlan",
14141 "lookup",
14142 "arrange",
14143 "lookup_union",
14144 "lookupUnion",
14145 "union",
14146 "delta_index_join",
14147 "deltaIndexJoin",
14148 "sink",
14149 "expand",
14150 "dynamic_filter",
14151 "dynamicFilter",
14152 "project_set",
14153 "projectSet",
14154 "group_top_n",
14155 "groupTopN",
14156 "sort",
14157 "watermark_filter",
14158 "watermarkFilter",
14159 "dml",
14160 "row_id_gen",
14161 "rowIdGen",
14162 "now",
14163 "append_only_group_top_n",
14164 "appendOnlyGroupTopN",
14165 "temporal_join",
14166 "temporalJoin",
14167 "barrier_recv",
14168 "barrierRecv",
14169 "values",
14170 "append_only_dedup",
14171 "appendOnlyDedup",
14172 "no_op",
14173 "noOp",
14174 "eowc_over_window",
14175 "eowcOverWindow",
14176 "over_window",
14177 "overWindow",
14178 "stream_fs_fetch",
14179 "streamFsFetch",
14180 "stream_cdc_scan",
14181 "streamCdcScan",
14182 "cdc_filter",
14183 "cdcFilter",
14184 "source_backfill",
14185 "sourceBackfill",
14186 "changelog",
14187 "local_approx_percentile",
14188 "localApproxPercentile",
14189 "global_approx_percentile",
14190 "globalApproxPercentile",
14191 "row_merge",
14192 "rowMerge",
14193 "as_of_join",
14194 "asOfJoin",
14195 "sync_log_store",
14196 "syncLogStore",
14197 "materialized_exprs",
14198 "materializedExprs",
14199 "vector_index_write",
14200 "vectorIndexWrite",
14201 "upstream_sink_union",
14202 "upstreamSinkUnion",
14203 "locality_provider",
14204 "localityProvider",
14205 "eowc_gap_fill",
14206 "eowcGapFill",
14207 "gap_fill",
14208 "gapFill",
14209 "vector_index_lookup_join",
14210 "vectorIndexLookupJoin",
14211 ];
14212
14213 #[allow(clippy::enum_variant_names)]
14214 enum GeneratedField {
14215 OperatorId,
14216 Input,
14217 StreamKey,
14218 StreamKind,
14219 Identity,
14220 Fields,
14221 Source,
14222 Project,
14223 Filter,
14224 Materialize,
14225 StatelessSimpleAgg,
14226 SimpleAgg,
14227 HashAgg,
14228 AppendOnlyTopN,
14229 HashJoin,
14230 TopN,
14231 HopWindow,
14232 Merge,
14233 Exchange,
14234 StreamScan,
14235 BatchPlan,
14236 Lookup,
14237 Arrange,
14238 LookupUnion,
14239 Union,
14240 DeltaIndexJoin,
14241 Sink,
14242 Expand,
14243 DynamicFilter,
14244 ProjectSet,
14245 GroupTopN,
14246 Sort,
14247 WatermarkFilter,
14248 Dml,
14249 RowIdGen,
14250 Now,
14251 AppendOnlyGroupTopN,
14252 TemporalJoin,
14253 BarrierRecv,
14254 Values,
14255 AppendOnlyDedup,
14256 NoOp,
14257 EowcOverWindow,
14258 OverWindow,
14259 StreamFsFetch,
14260 StreamCdcScan,
14261 CdcFilter,
14262 SourceBackfill,
14263 Changelog,
14264 LocalApproxPercentile,
14265 GlobalApproxPercentile,
14266 RowMerge,
14267 AsOfJoin,
14268 SyncLogStore,
14269 MaterializedExprs,
14270 VectorIndexWrite,
14271 UpstreamSinkUnion,
14272 LocalityProvider,
14273 EowcGapFill,
14274 GapFill,
14275 VectorIndexLookupJoin,
14276 }
14277 impl<'de> serde::Deserialize<'de> for GeneratedField {
14278 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14279 where
14280 D: serde::Deserializer<'de>,
14281 {
14282 struct GeneratedVisitor;
14283
14284 impl serde::de::Visitor<'_> for GeneratedVisitor {
14285 type Value = GeneratedField;
14286
14287 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14288 write!(formatter, "expected one of: {:?}", &FIELDS)
14289 }
14290
14291 #[allow(unused_variables)]
14292 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14293 where
14294 E: serde::de::Error,
14295 {
14296 match value {
14297 "operatorId" | "operator_id" => Ok(GeneratedField::OperatorId),
14298 "input" => Ok(GeneratedField::Input),
14299 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
14300 "streamKind" | "stream_kind" => Ok(GeneratedField::StreamKind),
14301 "identity" => Ok(GeneratedField::Identity),
14302 "fields" => Ok(GeneratedField::Fields),
14303 "source" => Ok(GeneratedField::Source),
14304 "project" => Ok(GeneratedField::Project),
14305 "filter" => Ok(GeneratedField::Filter),
14306 "materialize" => Ok(GeneratedField::Materialize),
14307 "statelessSimpleAgg" | "stateless_simple_agg" => Ok(GeneratedField::StatelessSimpleAgg),
14308 "simpleAgg" | "simple_agg" => Ok(GeneratedField::SimpleAgg),
14309 "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
14310 "appendOnlyTopN" | "append_only_top_n" => Ok(GeneratedField::AppendOnlyTopN),
14311 "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
14312 "topN" | "top_n" => Ok(GeneratedField::TopN),
14313 "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
14314 "merge" => Ok(GeneratedField::Merge),
14315 "exchange" => Ok(GeneratedField::Exchange),
14316 "streamScan" | "stream_scan" => Ok(GeneratedField::StreamScan),
14317 "batchPlan" | "batch_plan" => Ok(GeneratedField::BatchPlan),
14318 "lookup" => Ok(GeneratedField::Lookup),
14319 "arrange" => Ok(GeneratedField::Arrange),
14320 "lookupUnion" | "lookup_union" => Ok(GeneratedField::LookupUnion),
14321 "union" => Ok(GeneratedField::Union),
14322 "deltaIndexJoin" | "delta_index_join" => Ok(GeneratedField::DeltaIndexJoin),
14323 "sink" => Ok(GeneratedField::Sink),
14324 "expand" => Ok(GeneratedField::Expand),
14325 "dynamicFilter" | "dynamic_filter" => Ok(GeneratedField::DynamicFilter),
14326 "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
14327 "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
14328 "sort" => Ok(GeneratedField::Sort),
14329 "watermarkFilter" | "watermark_filter" => Ok(GeneratedField::WatermarkFilter),
14330 "dml" => Ok(GeneratedField::Dml),
14331 "rowIdGen" | "row_id_gen" => Ok(GeneratedField::RowIdGen),
14332 "now" => Ok(GeneratedField::Now),
14333 "appendOnlyGroupTopN" | "append_only_group_top_n" => Ok(GeneratedField::AppendOnlyGroupTopN),
14334 "temporalJoin" | "temporal_join" => Ok(GeneratedField::TemporalJoin),
14335 "barrierRecv" | "barrier_recv" => Ok(GeneratedField::BarrierRecv),
14336 "values" => Ok(GeneratedField::Values),
14337 "appendOnlyDedup" | "append_only_dedup" => Ok(GeneratedField::AppendOnlyDedup),
14338 "noOp" | "no_op" => Ok(GeneratedField::NoOp),
14339 "eowcOverWindow" | "eowc_over_window" => Ok(GeneratedField::EowcOverWindow),
14340 "overWindow" | "over_window" => Ok(GeneratedField::OverWindow),
14341 "streamFsFetch" | "stream_fs_fetch" => Ok(GeneratedField::StreamFsFetch),
14342 "streamCdcScan" | "stream_cdc_scan" => Ok(GeneratedField::StreamCdcScan),
14343 "cdcFilter" | "cdc_filter" => Ok(GeneratedField::CdcFilter),
14344 "sourceBackfill" | "source_backfill" => Ok(GeneratedField::SourceBackfill),
14345 "changelog" => Ok(GeneratedField::Changelog),
14346 "localApproxPercentile" | "local_approx_percentile" => Ok(GeneratedField::LocalApproxPercentile),
14347 "globalApproxPercentile" | "global_approx_percentile" => Ok(GeneratedField::GlobalApproxPercentile),
14348 "rowMerge" | "row_merge" => Ok(GeneratedField::RowMerge),
14349 "asOfJoin" | "as_of_join" => Ok(GeneratedField::AsOfJoin),
14350 "syncLogStore" | "sync_log_store" => Ok(GeneratedField::SyncLogStore),
14351 "materializedExprs" | "materialized_exprs" => Ok(GeneratedField::MaterializedExprs),
14352 "vectorIndexWrite" | "vector_index_write" => Ok(GeneratedField::VectorIndexWrite),
14353 "upstreamSinkUnion" | "upstream_sink_union" => Ok(GeneratedField::UpstreamSinkUnion),
14354 "localityProvider" | "locality_provider" => Ok(GeneratedField::LocalityProvider),
14355 "eowcGapFill" | "eowc_gap_fill" => Ok(GeneratedField::EowcGapFill),
14356 "gapFill" | "gap_fill" => Ok(GeneratedField::GapFill),
14357 "vectorIndexLookupJoin" | "vector_index_lookup_join" => Ok(GeneratedField::VectorIndexLookupJoin),
14358 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14359 }
14360 }
14361 }
14362 deserializer.deserialize_identifier(GeneratedVisitor)
14363 }
14364 }
14365 struct GeneratedVisitor;
14366 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14367 type Value = StreamNode;
14368
14369 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14370 formatter.write_str("struct stream_plan.StreamNode")
14371 }
14372
14373 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamNode, V::Error>
14374 where
14375 V: serde::de::MapAccess<'de>,
14376 {
14377 let mut operator_id__ = None;
14378 let mut input__ = None;
14379 let mut stream_key__ = None;
14380 let mut stream_kind__ = None;
14381 let mut identity__ = None;
14382 let mut fields__ = None;
14383 let mut node_body__ = None;
14384 while let Some(k) = map_.next_key()? {
14385 match k {
14386 GeneratedField::OperatorId => {
14387 if operator_id__.is_some() {
14388 return Err(serde::de::Error::duplicate_field("operatorId"));
14389 }
14390 operator_id__ =
14391 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14392 ;
14393 }
14394 GeneratedField::Input => {
14395 if input__.is_some() {
14396 return Err(serde::de::Error::duplicate_field("input"));
14397 }
14398 input__ = Some(map_.next_value()?);
14399 }
14400 GeneratedField::StreamKey => {
14401 if stream_key__.is_some() {
14402 return Err(serde::de::Error::duplicate_field("streamKey"));
14403 }
14404 stream_key__ =
14405 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14406 .into_iter().map(|x| x.0).collect())
14407 ;
14408 }
14409 GeneratedField::StreamKind => {
14410 if stream_kind__.is_some() {
14411 return Err(serde::de::Error::duplicate_field("streamKind"));
14412 }
14413 stream_kind__ = Some(map_.next_value::<stream_node::StreamKind>()? as i32);
14414 }
14415 GeneratedField::Identity => {
14416 if identity__.is_some() {
14417 return Err(serde::de::Error::duplicate_field("identity"));
14418 }
14419 identity__ = Some(map_.next_value()?);
14420 }
14421 GeneratedField::Fields => {
14422 if fields__.is_some() {
14423 return Err(serde::de::Error::duplicate_field("fields"));
14424 }
14425 fields__ = Some(map_.next_value()?);
14426 }
14427 GeneratedField::Source => {
14428 if node_body__.is_some() {
14429 return Err(serde::de::Error::duplicate_field("source"));
14430 }
14431 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Source)
14432;
14433 }
14434 GeneratedField::Project => {
14435 if node_body__.is_some() {
14436 return Err(serde::de::Error::duplicate_field("project"));
14437 }
14438 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Project)
14439;
14440 }
14441 GeneratedField::Filter => {
14442 if node_body__.is_some() {
14443 return Err(serde::de::Error::duplicate_field("filter"));
14444 }
14445 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Filter)
14446;
14447 }
14448 GeneratedField::Materialize => {
14449 if node_body__.is_some() {
14450 return Err(serde::de::Error::duplicate_field("materialize"));
14451 }
14452 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Materialize)
14453;
14454 }
14455 GeneratedField::StatelessSimpleAgg => {
14456 if node_body__.is_some() {
14457 return Err(serde::de::Error::duplicate_field("statelessSimpleAgg"));
14458 }
14459 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StatelessSimpleAgg)
14460;
14461 }
14462 GeneratedField::SimpleAgg => {
14463 if node_body__.is_some() {
14464 return Err(serde::de::Error::duplicate_field("simpleAgg"));
14465 }
14466 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SimpleAgg)
14467;
14468 }
14469 GeneratedField::HashAgg => {
14470 if node_body__.is_some() {
14471 return Err(serde::de::Error::duplicate_field("hashAgg"));
14472 }
14473 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashAgg)
14474;
14475 }
14476 GeneratedField::AppendOnlyTopN => {
14477 if node_body__.is_some() {
14478 return Err(serde::de::Error::duplicate_field("appendOnlyTopN"));
14479 }
14480 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyTopN)
14481;
14482 }
14483 GeneratedField::HashJoin => {
14484 if node_body__.is_some() {
14485 return Err(serde::de::Error::duplicate_field("hashJoin"));
14486 }
14487 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashJoin)
14488;
14489 }
14490 GeneratedField::TopN => {
14491 if node_body__.is_some() {
14492 return Err(serde::de::Error::duplicate_field("topN"));
14493 }
14494 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TopN)
14495;
14496 }
14497 GeneratedField::HopWindow => {
14498 if node_body__.is_some() {
14499 return Err(serde::de::Error::duplicate_field("hopWindow"));
14500 }
14501 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HopWindow)
14502;
14503 }
14504 GeneratedField::Merge => {
14505 if node_body__.is_some() {
14506 return Err(serde::de::Error::duplicate_field("merge"));
14507 }
14508 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Merge)
14509;
14510 }
14511 GeneratedField::Exchange => {
14512 if node_body__.is_some() {
14513 return Err(serde::de::Error::duplicate_field("exchange"));
14514 }
14515 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Exchange)
14516;
14517 }
14518 GeneratedField::StreamScan => {
14519 if node_body__.is_some() {
14520 return Err(serde::de::Error::duplicate_field("streamScan"));
14521 }
14522 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamScan)
14523;
14524 }
14525 GeneratedField::BatchPlan => {
14526 if node_body__.is_some() {
14527 return Err(serde::de::Error::duplicate_field("batchPlan"));
14528 }
14529 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BatchPlan)
14530;
14531 }
14532 GeneratedField::Lookup => {
14533 if node_body__.is_some() {
14534 return Err(serde::de::Error::duplicate_field("lookup"));
14535 }
14536 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Lookup)
14537;
14538 }
14539 GeneratedField::Arrange => {
14540 if node_body__.is_some() {
14541 return Err(serde::de::Error::duplicate_field("arrange"));
14542 }
14543 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Arrange)
14544;
14545 }
14546 GeneratedField::LookupUnion => {
14547 if node_body__.is_some() {
14548 return Err(serde::de::Error::duplicate_field("lookupUnion"));
14549 }
14550 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LookupUnion)
14551;
14552 }
14553 GeneratedField::Union => {
14554 if node_body__.is_some() {
14555 return Err(serde::de::Error::duplicate_field("union"));
14556 }
14557 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Union)
14558;
14559 }
14560 GeneratedField::DeltaIndexJoin => {
14561 if node_body__.is_some() {
14562 return Err(serde::de::Error::duplicate_field("deltaIndexJoin"));
14563 }
14564 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DeltaIndexJoin)
14565;
14566 }
14567 GeneratedField::Sink => {
14568 if node_body__.is_some() {
14569 return Err(serde::de::Error::duplicate_field("sink"));
14570 }
14571 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sink)
14572;
14573 }
14574 GeneratedField::Expand => {
14575 if node_body__.is_some() {
14576 return Err(serde::de::Error::duplicate_field("expand"));
14577 }
14578 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Expand)
14579;
14580 }
14581 GeneratedField::DynamicFilter => {
14582 if node_body__.is_some() {
14583 return Err(serde::de::Error::duplicate_field("dynamicFilter"));
14584 }
14585 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DynamicFilter)
14586;
14587 }
14588 GeneratedField::ProjectSet => {
14589 if node_body__.is_some() {
14590 return Err(serde::de::Error::duplicate_field("projectSet"));
14591 }
14592 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::ProjectSet)
14593;
14594 }
14595 GeneratedField::GroupTopN => {
14596 if node_body__.is_some() {
14597 return Err(serde::de::Error::duplicate_field("groupTopN"));
14598 }
14599 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GroupTopN)
14600;
14601 }
14602 GeneratedField::Sort => {
14603 if node_body__.is_some() {
14604 return Err(serde::de::Error::duplicate_field("sort"));
14605 }
14606 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sort)
14607;
14608 }
14609 GeneratedField::WatermarkFilter => {
14610 if node_body__.is_some() {
14611 return Err(serde::de::Error::duplicate_field("watermarkFilter"));
14612 }
14613 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::WatermarkFilter)
14614;
14615 }
14616 GeneratedField::Dml => {
14617 if node_body__.is_some() {
14618 return Err(serde::de::Error::duplicate_field("dml"));
14619 }
14620 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Dml)
14621;
14622 }
14623 GeneratedField::RowIdGen => {
14624 if node_body__.is_some() {
14625 return Err(serde::de::Error::duplicate_field("rowIdGen"));
14626 }
14627 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowIdGen)
14628;
14629 }
14630 GeneratedField::Now => {
14631 if node_body__.is_some() {
14632 return Err(serde::de::Error::duplicate_field("now"));
14633 }
14634 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Now)
14635;
14636 }
14637 GeneratedField::AppendOnlyGroupTopN => {
14638 if node_body__.is_some() {
14639 return Err(serde::de::Error::duplicate_field("appendOnlyGroupTopN"));
14640 }
14641 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyGroupTopN)
14642;
14643 }
14644 GeneratedField::TemporalJoin => {
14645 if node_body__.is_some() {
14646 return Err(serde::de::Error::duplicate_field("temporalJoin"));
14647 }
14648 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TemporalJoin)
14649;
14650 }
14651 GeneratedField::BarrierRecv => {
14652 if node_body__.is_some() {
14653 return Err(serde::de::Error::duplicate_field("barrierRecv"));
14654 }
14655 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BarrierRecv)
14656;
14657 }
14658 GeneratedField::Values => {
14659 if node_body__.is_some() {
14660 return Err(serde::de::Error::duplicate_field("values"));
14661 }
14662 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Values)
14663;
14664 }
14665 GeneratedField::AppendOnlyDedup => {
14666 if node_body__.is_some() {
14667 return Err(serde::de::Error::duplicate_field("appendOnlyDedup"));
14668 }
14669 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyDedup)
14670;
14671 }
14672 GeneratedField::NoOp => {
14673 if node_body__.is_some() {
14674 return Err(serde::de::Error::duplicate_field("noOp"));
14675 }
14676 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::NoOp)
14677;
14678 }
14679 GeneratedField::EowcOverWindow => {
14680 if node_body__.is_some() {
14681 return Err(serde::de::Error::duplicate_field("eowcOverWindow"));
14682 }
14683 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcOverWindow)
14684;
14685 }
14686 GeneratedField::OverWindow => {
14687 if node_body__.is_some() {
14688 return Err(serde::de::Error::duplicate_field("overWindow"));
14689 }
14690 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::OverWindow)
14691;
14692 }
14693 GeneratedField::StreamFsFetch => {
14694 if node_body__.is_some() {
14695 return Err(serde::de::Error::duplicate_field("streamFsFetch"));
14696 }
14697 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamFsFetch)
14698;
14699 }
14700 GeneratedField::StreamCdcScan => {
14701 if node_body__.is_some() {
14702 return Err(serde::de::Error::duplicate_field("streamCdcScan"));
14703 }
14704 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamCdcScan)
14705;
14706 }
14707 GeneratedField::CdcFilter => {
14708 if node_body__.is_some() {
14709 return Err(serde::de::Error::duplicate_field("cdcFilter"));
14710 }
14711 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CdcFilter)
14712;
14713 }
14714 GeneratedField::SourceBackfill => {
14715 if node_body__.is_some() {
14716 return Err(serde::de::Error::duplicate_field("sourceBackfill"));
14717 }
14718 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SourceBackfill)
14719;
14720 }
14721 GeneratedField::Changelog => {
14722 if node_body__.is_some() {
14723 return Err(serde::de::Error::duplicate_field("changelog"));
14724 }
14725 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Changelog)
14726;
14727 }
14728 GeneratedField::LocalApproxPercentile => {
14729 if node_body__.is_some() {
14730 return Err(serde::de::Error::duplicate_field("localApproxPercentile"));
14731 }
14732 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalApproxPercentile)
14733;
14734 }
14735 GeneratedField::GlobalApproxPercentile => {
14736 if node_body__.is_some() {
14737 return Err(serde::de::Error::duplicate_field("globalApproxPercentile"));
14738 }
14739 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GlobalApproxPercentile)
14740;
14741 }
14742 GeneratedField::RowMerge => {
14743 if node_body__.is_some() {
14744 return Err(serde::de::Error::duplicate_field("rowMerge"));
14745 }
14746 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowMerge)
14747;
14748 }
14749 GeneratedField::AsOfJoin => {
14750 if node_body__.is_some() {
14751 return Err(serde::de::Error::duplicate_field("asOfJoin"));
14752 }
14753 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AsOfJoin)
14754;
14755 }
14756 GeneratedField::SyncLogStore => {
14757 if node_body__.is_some() {
14758 return Err(serde::de::Error::duplicate_field("syncLogStore"));
14759 }
14760 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SyncLogStore)
14761;
14762 }
14763 GeneratedField::MaterializedExprs => {
14764 if node_body__.is_some() {
14765 return Err(serde::de::Error::duplicate_field("materializedExprs"));
14766 }
14767 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MaterializedExprs)
14768;
14769 }
14770 GeneratedField::VectorIndexWrite => {
14771 if node_body__.is_some() {
14772 return Err(serde::de::Error::duplicate_field("vectorIndexWrite"));
14773 }
14774 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexWrite)
14775;
14776 }
14777 GeneratedField::UpstreamSinkUnion => {
14778 if node_body__.is_some() {
14779 return Err(serde::de::Error::duplicate_field("upstreamSinkUnion"));
14780 }
14781 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::UpstreamSinkUnion)
14782;
14783 }
14784 GeneratedField::LocalityProvider => {
14785 if node_body__.is_some() {
14786 return Err(serde::de::Error::duplicate_field("localityProvider"));
14787 }
14788 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalityProvider)
14789;
14790 }
14791 GeneratedField::EowcGapFill => {
14792 if node_body__.is_some() {
14793 return Err(serde::de::Error::duplicate_field("eowcGapFill"));
14794 }
14795 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcGapFill)
14796;
14797 }
14798 GeneratedField::GapFill => {
14799 if node_body__.is_some() {
14800 return Err(serde::de::Error::duplicate_field("gapFill"));
14801 }
14802 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GapFill)
14803;
14804 }
14805 GeneratedField::VectorIndexLookupJoin => {
14806 if node_body__.is_some() {
14807 return Err(serde::de::Error::duplicate_field("vectorIndexLookupJoin"));
14808 }
14809 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexLookupJoin)
14810;
14811 }
14812 }
14813 }
14814 Ok(StreamNode {
14815 operator_id: operator_id__.unwrap_or_default(),
14816 input: input__.unwrap_or_default(),
14817 stream_key: stream_key__.unwrap_or_default(),
14818 stream_kind: stream_kind__.unwrap_or_default(),
14819 identity: identity__.unwrap_or_default(),
14820 fields: fields__.unwrap_or_default(),
14821 node_body: node_body__,
14822 })
14823 }
14824 }
14825 deserializer.deserialize_struct("stream_plan.StreamNode", FIELDS, GeneratedVisitor)
14826 }
14827}
14828impl serde::Serialize for stream_node::StreamKind {
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 let variant = match self {
14835 Self::Retract => "STREAM_KIND_RETRACT",
14836 Self::AppendOnly => "STREAM_KIND_APPEND_ONLY",
14837 Self::Upsert => "STREAM_KIND_UPSERT",
14838 };
14839 serializer.serialize_str(variant)
14840 }
14841}
14842impl<'de> serde::Deserialize<'de> for stream_node::StreamKind {
14843 #[allow(deprecated)]
14844 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14845 where
14846 D: serde::Deserializer<'de>,
14847 {
14848 const FIELDS: &[&str] = &[
14849 "STREAM_KIND_RETRACT",
14850 "STREAM_KIND_APPEND_ONLY",
14851 "STREAM_KIND_UPSERT",
14852 ];
14853
14854 struct GeneratedVisitor;
14855
14856 impl serde::de::Visitor<'_> for GeneratedVisitor {
14857 type Value = stream_node::StreamKind;
14858
14859 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14860 write!(formatter, "expected one of: {:?}", &FIELDS)
14861 }
14862
14863 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14864 where
14865 E: serde::de::Error,
14866 {
14867 i32::try_from(v)
14868 .ok()
14869 .and_then(|x| x.try_into().ok())
14870 .ok_or_else(|| {
14871 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14872 })
14873 }
14874
14875 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14876 where
14877 E: serde::de::Error,
14878 {
14879 i32::try_from(v)
14880 .ok()
14881 .and_then(|x| x.try_into().ok())
14882 .ok_or_else(|| {
14883 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14884 })
14885 }
14886
14887 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14888 where
14889 E: serde::de::Error,
14890 {
14891 match value {
14892 "STREAM_KIND_RETRACT" => Ok(stream_node::StreamKind::Retract),
14893 "STREAM_KIND_APPEND_ONLY" => Ok(stream_node::StreamKind::AppendOnly),
14894 "STREAM_KIND_UPSERT" => Ok(stream_node::StreamKind::Upsert),
14895 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14896 }
14897 }
14898 }
14899 deserializer.deserialize_any(GeneratedVisitor)
14900 }
14901}
14902impl serde::Serialize for StreamScanNode {
14903 #[allow(deprecated)]
14904 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14905 where
14906 S: serde::Serializer,
14907 {
14908 use serde::ser::SerializeStruct;
14909 let mut len = 0;
14910 if self.table_id != 0 {
14911 len += 1;
14912 }
14913 if !self.upstream_column_ids.is_empty() {
14914 len += 1;
14915 }
14916 if !self.output_indices.is_empty() {
14917 len += 1;
14918 }
14919 if self.stream_scan_type != 0 {
14920 len += 1;
14921 }
14922 if self.state_table.is_some() {
14923 len += 1;
14924 }
14925 if self.table_desc.is_some() {
14926 len += 1;
14927 }
14928 if self.rate_limit.is_some() {
14929 len += 1;
14930 }
14931 if self.snapshot_read_barrier_interval != 0 {
14932 len += 1;
14933 }
14934 if self.arrangement_table.is_some() {
14935 len += 1;
14936 }
14937 if self.snapshot_backfill_epoch.is_some() {
14938 len += 1;
14939 }
14940 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamScanNode", len)?;
14941 if self.table_id != 0 {
14942 struct_ser.serialize_field("tableId", &self.table_id)?;
14943 }
14944 if !self.upstream_column_ids.is_empty() {
14945 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
14946 }
14947 if !self.output_indices.is_empty() {
14948 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
14949 }
14950 if self.stream_scan_type != 0 {
14951 let v = StreamScanType::try_from(self.stream_scan_type)
14952 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_scan_type)))?;
14953 struct_ser.serialize_field("streamScanType", &v)?;
14954 }
14955 if let Some(v) = self.state_table.as_ref() {
14956 struct_ser.serialize_field("stateTable", v)?;
14957 }
14958 if let Some(v) = self.table_desc.as_ref() {
14959 struct_ser.serialize_field("tableDesc", v)?;
14960 }
14961 if let Some(v) = self.rate_limit.as_ref() {
14962 struct_ser.serialize_field("rateLimit", v)?;
14963 }
14964 if self.snapshot_read_barrier_interval != 0 {
14965 struct_ser.serialize_field("snapshotReadBarrierInterval", &self.snapshot_read_barrier_interval)?;
14966 }
14967 if let Some(v) = self.arrangement_table.as_ref() {
14968 struct_ser.serialize_field("arrangementTable", v)?;
14969 }
14970 if let Some(v) = self.snapshot_backfill_epoch.as_ref() {
14971 #[allow(clippy::needless_borrow)]
14972 #[allow(clippy::needless_borrows_for_generic_args)]
14973 struct_ser.serialize_field("snapshotBackfillEpoch", ToString::to_string(&v).as_str())?;
14974 }
14975 struct_ser.end()
14976 }
14977}
14978impl<'de> serde::Deserialize<'de> for StreamScanNode {
14979 #[allow(deprecated)]
14980 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14981 where
14982 D: serde::Deserializer<'de>,
14983 {
14984 const FIELDS: &[&str] = &[
14985 "table_id",
14986 "tableId",
14987 "upstream_column_ids",
14988 "upstreamColumnIds",
14989 "output_indices",
14990 "outputIndices",
14991 "stream_scan_type",
14992 "streamScanType",
14993 "state_table",
14994 "stateTable",
14995 "table_desc",
14996 "tableDesc",
14997 "rate_limit",
14998 "rateLimit",
14999 "snapshot_read_barrier_interval",
15000 "snapshotReadBarrierInterval",
15001 "arrangement_table",
15002 "arrangementTable",
15003 "snapshot_backfill_epoch",
15004 "snapshotBackfillEpoch",
15005 ];
15006
15007 #[allow(clippy::enum_variant_names)]
15008 enum GeneratedField {
15009 TableId,
15010 UpstreamColumnIds,
15011 OutputIndices,
15012 StreamScanType,
15013 StateTable,
15014 TableDesc,
15015 RateLimit,
15016 SnapshotReadBarrierInterval,
15017 ArrangementTable,
15018 SnapshotBackfillEpoch,
15019 }
15020 impl<'de> serde::Deserialize<'de> for GeneratedField {
15021 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15022 where
15023 D: serde::Deserializer<'de>,
15024 {
15025 struct GeneratedVisitor;
15026
15027 impl serde::de::Visitor<'_> for GeneratedVisitor {
15028 type Value = GeneratedField;
15029
15030 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15031 write!(formatter, "expected one of: {:?}", &FIELDS)
15032 }
15033
15034 #[allow(unused_variables)]
15035 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15036 where
15037 E: serde::de::Error,
15038 {
15039 match value {
15040 "tableId" | "table_id" => Ok(GeneratedField::TableId),
15041 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
15042 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
15043 "streamScanType" | "stream_scan_type" => Ok(GeneratedField::StreamScanType),
15044 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
15045 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
15046 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
15047 "snapshotReadBarrierInterval" | "snapshot_read_barrier_interval" => Ok(GeneratedField::SnapshotReadBarrierInterval),
15048 "arrangementTable" | "arrangement_table" => Ok(GeneratedField::ArrangementTable),
15049 "snapshotBackfillEpoch" | "snapshot_backfill_epoch" => Ok(GeneratedField::SnapshotBackfillEpoch),
15050 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15051 }
15052 }
15053 }
15054 deserializer.deserialize_identifier(GeneratedVisitor)
15055 }
15056 }
15057 struct GeneratedVisitor;
15058 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15059 type Value = StreamScanNode;
15060
15061 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15062 formatter.write_str("struct stream_plan.StreamScanNode")
15063 }
15064
15065 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamScanNode, V::Error>
15066 where
15067 V: serde::de::MapAccess<'de>,
15068 {
15069 let mut table_id__ = None;
15070 let mut upstream_column_ids__ = None;
15071 let mut output_indices__ = None;
15072 let mut stream_scan_type__ = None;
15073 let mut state_table__ = None;
15074 let mut table_desc__ = None;
15075 let mut rate_limit__ = None;
15076 let mut snapshot_read_barrier_interval__ = None;
15077 let mut arrangement_table__ = None;
15078 let mut snapshot_backfill_epoch__ = None;
15079 while let Some(k) = map_.next_key()? {
15080 match k {
15081 GeneratedField::TableId => {
15082 if table_id__.is_some() {
15083 return Err(serde::de::Error::duplicate_field("tableId"));
15084 }
15085 table_id__ =
15086 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15087 ;
15088 }
15089 GeneratedField::UpstreamColumnIds => {
15090 if upstream_column_ids__.is_some() {
15091 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
15092 }
15093 upstream_column_ids__ =
15094 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15095 .into_iter().map(|x| x.0).collect())
15096 ;
15097 }
15098 GeneratedField::OutputIndices => {
15099 if output_indices__.is_some() {
15100 return Err(serde::de::Error::duplicate_field("outputIndices"));
15101 }
15102 output_indices__ =
15103 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15104 .into_iter().map(|x| x.0).collect())
15105 ;
15106 }
15107 GeneratedField::StreamScanType => {
15108 if stream_scan_type__.is_some() {
15109 return Err(serde::de::Error::duplicate_field("streamScanType"));
15110 }
15111 stream_scan_type__ = Some(map_.next_value::<StreamScanType>()? as i32);
15112 }
15113 GeneratedField::StateTable => {
15114 if state_table__.is_some() {
15115 return Err(serde::de::Error::duplicate_field("stateTable"));
15116 }
15117 state_table__ = map_.next_value()?;
15118 }
15119 GeneratedField::TableDesc => {
15120 if table_desc__.is_some() {
15121 return Err(serde::de::Error::duplicate_field("tableDesc"));
15122 }
15123 table_desc__ = map_.next_value()?;
15124 }
15125 GeneratedField::RateLimit => {
15126 if rate_limit__.is_some() {
15127 return Err(serde::de::Error::duplicate_field("rateLimit"));
15128 }
15129 rate_limit__ =
15130 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15131 ;
15132 }
15133 GeneratedField::SnapshotReadBarrierInterval => {
15134 if snapshot_read_barrier_interval__.is_some() {
15135 return Err(serde::de::Error::duplicate_field("snapshotReadBarrierInterval"));
15136 }
15137 snapshot_read_barrier_interval__ =
15138 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15139 ;
15140 }
15141 GeneratedField::ArrangementTable => {
15142 if arrangement_table__.is_some() {
15143 return Err(serde::de::Error::duplicate_field("arrangementTable"));
15144 }
15145 arrangement_table__ = map_.next_value()?;
15146 }
15147 GeneratedField::SnapshotBackfillEpoch => {
15148 if snapshot_backfill_epoch__.is_some() {
15149 return Err(serde::de::Error::duplicate_field("snapshotBackfillEpoch"));
15150 }
15151 snapshot_backfill_epoch__ =
15152 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15153 ;
15154 }
15155 }
15156 }
15157 Ok(StreamScanNode {
15158 table_id: table_id__.unwrap_or_default(),
15159 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
15160 output_indices: output_indices__.unwrap_or_default(),
15161 stream_scan_type: stream_scan_type__.unwrap_or_default(),
15162 state_table: state_table__,
15163 table_desc: table_desc__,
15164 rate_limit: rate_limit__,
15165 snapshot_read_barrier_interval: snapshot_read_barrier_interval__.unwrap_or_default(),
15166 arrangement_table: arrangement_table__,
15167 snapshot_backfill_epoch: snapshot_backfill_epoch__,
15168 })
15169 }
15170 }
15171 deserializer.deserialize_struct("stream_plan.StreamScanNode", FIELDS, GeneratedVisitor)
15172 }
15173}
15174impl serde::Serialize for StreamScanType {
15175 #[allow(deprecated)]
15176 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15177 where
15178 S: serde::Serializer,
15179 {
15180 let variant = match self {
15181 Self::Unspecified => "STREAM_SCAN_TYPE_UNSPECIFIED",
15182 Self::Chain => "STREAM_SCAN_TYPE_CHAIN",
15183 Self::Rearrange => "STREAM_SCAN_TYPE_REARRANGE",
15184 Self::Backfill => "STREAM_SCAN_TYPE_BACKFILL",
15185 Self::UpstreamOnly => "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
15186 Self::ArrangementBackfill => "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
15187 Self::SnapshotBackfill => "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
15188 Self::CrossDbSnapshotBackfill => "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
15189 };
15190 serializer.serialize_str(variant)
15191 }
15192}
15193impl<'de> serde::Deserialize<'de> for StreamScanType {
15194 #[allow(deprecated)]
15195 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15196 where
15197 D: serde::Deserializer<'de>,
15198 {
15199 const FIELDS: &[&str] = &[
15200 "STREAM_SCAN_TYPE_UNSPECIFIED",
15201 "STREAM_SCAN_TYPE_CHAIN",
15202 "STREAM_SCAN_TYPE_REARRANGE",
15203 "STREAM_SCAN_TYPE_BACKFILL",
15204 "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
15205 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
15206 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
15207 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
15208 ];
15209
15210 struct GeneratedVisitor;
15211
15212 impl serde::de::Visitor<'_> for GeneratedVisitor {
15213 type Value = StreamScanType;
15214
15215 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15216 write!(formatter, "expected one of: {:?}", &FIELDS)
15217 }
15218
15219 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15220 where
15221 E: serde::de::Error,
15222 {
15223 i32::try_from(v)
15224 .ok()
15225 .and_then(|x| x.try_into().ok())
15226 .ok_or_else(|| {
15227 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15228 })
15229 }
15230
15231 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15232 where
15233 E: serde::de::Error,
15234 {
15235 i32::try_from(v)
15236 .ok()
15237 .and_then(|x| x.try_into().ok())
15238 .ok_or_else(|| {
15239 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15240 })
15241 }
15242
15243 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15244 where
15245 E: serde::de::Error,
15246 {
15247 match value {
15248 "STREAM_SCAN_TYPE_UNSPECIFIED" => Ok(StreamScanType::Unspecified),
15249 "STREAM_SCAN_TYPE_CHAIN" => Ok(StreamScanType::Chain),
15250 "STREAM_SCAN_TYPE_REARRANGE" => Ok(StreamScanType::Rearrange),
15251 "STREAM_SCAN_TYPE_BACKFILL" => Ok(StreamScanType::Backfill),
15252 "STREAM_SCAN_TYPE_UPSTREAM_ONLY" => Ok(StreamScanType::UpstreamOnly),
15253 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL" => Ok(StreamScanType::ArrangementBackfill),
15254 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL" => Ok(StreamScanType::SnapshotBackfill),
15255 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL" => Ok(StreamScanType::CrossDbSnapshotBackfill),
15256 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15257 }
15258 }
15259 }
15260 deserializer.deserialize_any(GeneratedVisitor)
15261 }
15262}
15263impl serde::Serialize for StreamSource {
15264 #[allow(deprecated)]
15265 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15266 where
15267 S: serde::Serializer,
15268 {
15269 use serde::ser::SerializeStruct;
15270 let mut len = 0;
15271 if self.source_id != 0 {
15272 len += 1;
15273 }
15274 if self.state_table.is_some() {
15275 len += 1;
15276 }
15277 if self.row_id_index.is_some() {
15278 len += 1;
15279 }
15280 if !self.columns.is_empty() {
15281 len += 1;
15282 }
15283 if !self.with_properties.is_empty() {
15284 len += 1;
15285 }
15286 if self.info.is_some() {
15287 len += 1;
15288 }
15289 if !self.source_name.is_empty() {
15290 len += 1;
15291 }
15292 if self.rate_limit.is_some() {
15293 len += 1;
15294 }
15295 if !self.secret_refs.is_empty() {
15296 len += 1;
15297 }
15298 if self.downstream_columns.is_some() {
15299 len += 1;
15300 }
15301 if self.refresh_mode.is_some() {
15302 len += 1;
15303 }
15304 if self.associated_table_id.is_some() {
15305 len += 1;
15306 }
15307 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamSource", len)?;
15308 if self.source_id != 0 {
15309 struct_ser.serialize_field("sourceId", &self.source_id)?;
15310 }
15311 if let Some(v) = self.state_table.as_ref() {
15312 struct_ser.serialize_field("stateTable", v)?;
15313 }
15314 if let Some(v) = self.row_id_index.as_ref() {
15315 struct_ser.serialize_field("rowIdIndex", v)?;
15316 }
15317 if !self.columns.is_empty() {
15318 struct_ser.serialize_field("columns", &self.columns)?;
15319 }
15320 if !self.with_properties.is_empty() {
15321 struct_ser.serialize_field("withProperties", &self.with_properties)?;
15322 }
15323 if let Some(v) = self.info.as_ref() {
15324 struct_ser.serialize_field("info", v)?;
15325 }
15326 if !self.source_name.is_empty() {
15327 struct_ser.serialize_field("sourceName", &self.source_name)?;
15328 }
15329 if let Some(v) = self.rate_limit.as_ref() {
15330 struct_ser.serialize_field("rateLimit", v)?;
15331 }
15332 if !self.secret_refs.is_empty() {
15333 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
15334 }
15335 if let Some(v) = self.downstream_columns.as_ref() {
15336 struct_ser.serialize_field("downstreamColumns", v)?;
15337 }
15338 if let Some(v) = self.refresh_mode.as_ref() {
15339 struct_ser.serialize_field("refreshMode", v)?;
15340 }
15341 if let Some(v) = self.associated_table_id.as_ref() {
15342 struct_ser.serialize_field("associatedTableId", v)?;
15343 }
15344 struct_ser.end()
15345 }
15346}
15347impl<'de> serde::Deserialize<'de> for StreamSource {
15348 #[allow(deprecated)]
15349 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15350 where
15351 D: serde::Deserializer<'de>,
15352 {
15353 const FIELDS: &[&str] = &[
15354 "source_id",
15355 "sourceId",
15356 "state_table",
15357 "stateTable",
15358 "row_id_index",
15359 "rowIdIndex",
15360 "columns",
15361 "with_properties",
15362 "withProperties",
15363 "info",
15364 "source_name",
15365 "sourceName",
15366 "rate_limit",
15367 "rateLimit",
15368 "secret_refs",
15369 "secretRefs",
15370 "downstream_columns",
15371 "downstreamColumns",
15372 "refresh_mode",
15373 "refreshMode",
15374 "associated_table_id",
15375 "associatedTableId",
15376 ];
15377
15378 #[allow(clippy::enum_variant_names)]
15379 enum GeneratedField {
15380 SourceId,
15381 StateTable,
15382 RowIdIndex,
15383 Columns,
15384 WithProperties,
15385 Info,
15386 SourceName,
15387 RateLimit,
15388 SecretRefs,
15389 DownstreamColumns,
15390 RefreshMode,
15391 AssociatedTableId,
15392 }
15393 impl<'de> serde::Deserialize<'de> for GeneratedField {
15394 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15395 where
15396 D: serde::Deserializer<'de>,
15397 {
15398 struct GeneratedVisitor;
15399
15400 impl serde::de::Visitor<'_> for GeneratedVisitor {
15401 type Value = GeneratedField;
15402
15403 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15404 write!(formatter, "expected one of: {:?}", &FIELDS)
15405 }
15406
15407 #[allow(unused_variables)]
15408 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15409 where
15410 E: serde::de::Error,
15411 {
15412 match value {
15413 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
15414 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
15415 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
15416 "columns" => Ok(GeneratedField::Columns),
15417 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
15418 "info" => Ok(GeneratedField::Info),
15419 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
15420 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
15421 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
15422 "downstreamColumns" | "downstream_columns" => Ok(GeneratedField::DownstreamColumns),
15423 "refreshMode" | "refresh_mode" => Ok(GeneratedField::RefreshMode),
15424 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
15425 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15426 }
15427 }
15428 }
15429 deserializer.deserialize_identifier(GeneratedVisitor)
15430 }
15431 }
15432 struct GeneratedVisitor;
15433 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15434 type Value = StreamSource;
15435
15436 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15437 formatter.write_str("struct stream_plan.StreamSource")
15438 }
15439
15440 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSource, V::Error>
15441 where
15442 V: serde::de::MapAccess<'de>,
15443 {
15444 let mut source_id__ = None;
15445 let mut state_table__ = None;
15446 let mut row_id_index__ = None;
15447 let mut columns__ = None;
15448 let mut with_properties__ = None;
15449 let mut info__ = None;
15450 let mut source_name__ = None;
15451 let mut rate_limit__ = None;
15452 let mut secret_refs__ = None;
15453 let mut downstream_columns__ = None;
15454 let mut refresh_mode__ = None;
15455 let mut associated_table_id__ = None;
15456 while let Some(k) = map_.next_key()? {
15457 match k {
15458 GeneratedField::SourceId => {
15459 if source_id__.is_some() {
15460 return Err(serde::de::Error::duplicate_field("sourceId"));
15461 }
15462 source_id__ =
15463 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15464 ;
15465 }
15466 GeneratedField::StateTable => {
15467 if state_table__.is_some() {
15468 return Err(serde::de::Error::duplicate_field("stateTable"));
15469 }
15470 state_table__ = map_.next_value()?;
15471 }
15472 GeneratedField::RowIdIndex => {
15473 if row_id_index__.is_some() {
15474 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
15475 }
15476 row_id_index__ =
15477 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15478 ;
15479 }
15480 GeneratedField::Columns => {
15481 if columns__.is_some() {
15482 return Err(serde::de::Error::duplicate_field("columns"));
15483 }
15484 columns__ = Some(map_.next_value()?);
15485 }
15486 GeneratedField::WithProperties => {
15487 if with_properties__.is_some() {
15488 return Err(serde::de::Error::duplicate_field("withProperties"));
15489 }
15490 with_properties__ = Some(
15491 map_.next_value::<std::collections::BTreeMap<_, _>>()?
15492 );
15493 }
15494 GeneratedField::Info => {
15495 if info__.is_some() {
15496 return Err(serde::de::Error::duplicate_field("info"));
15497 }
15498 info__ = map_.next_value()?;
15499 }
15500 GeneratedField::SourceName => {
15501 if source_name__.is_some() {
15502 return Err(serde::de::Error::duplicate_field("sourceName"));
15503 }
15504 source_name__ = Some(map_.next_value()?);
15505 }
15506 GeneratedField::RateLimit => {
15507 if rate_limit__.is_some() {
15508 return Err(serde::de::Error::duplicate_field("rateLimit"));
15509 }
15510 rate_limit__ =
15511 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15512 ;
15513 }
15514 GeneratedField::SecretRefs => {
15515 if secret_refs__.is_some() {
15516 return Err(serde::de::Error::duplicate_field("secretRefs"));
15517 }
15518 secret_refs__ = Some(
15519 map_.next_value::<std::collections::BTreeMap<_, _>>()?
15520 );
15521 }
15522 GeneratedField::DownstreamColumns => {
15523 if downstream_columns__.is_some() {
15524 return Err(serde::de::Error::duplicate_field("downstreamColumns"));
15525 }
15526 downstream_columns__ = map_.next_value()?;
15527 }
15528 GeneratedField::RefreshMode => {
15529 if refresh_mode__.is_some() {
15530 return Err(serde::de::Error::duplicate_field("refreshMode"));
15531 }
15532 refresh_mode__ = map_.next_value()?;
15533 }
15534 GeneratedField::AssociatedTableId => {
15535 if associated_table_id__.is_some() {
15536 return Err(serde::de::Error::duplicate_field("associatedTableId"));
15537 }
15538 associated_table_id__ =
15539 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15540 ;
15541 }
15542 }
15543 }
15544 Ok(StreamSource {
15545 source_id: source_id__.unwrap_or_default(),
15546 state_table: state_table__,
15547 row_id_index: row_id_index__,
15548 columns: columns__.unwrap_or_default(),
15549 with_properties: with_properties__.unwrap_or_default(),
15550 info: info__,
15551 source_name: source_name__.unwrap_or_default(),
15552 rate_limit: rate_limit__,
15553 secret_refs: secret_refs__.unwrap_or_default(),
15554 downstream_columns: downstream_columns__,
15555 refresh_mode: refresh_mode__,
15556 associated_table_id: associated_table_id__,
15557 })
15558 }
15559 }
15560 deserializer.deserialize_struct("stream_plan.StreamSource", FIELDS, GeneratedVisitor)
15561 }
15562}
15563impl serde::Serialize for SubscriptionUpstreamInfo {
15564 #[allow(deprecated)]
15565 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15566 where
15567 S: serde::Serializer,
15568 {
15569 use serde::ser::SerializeStruct;
15570 let mut len = 0;
15571 if self.subscriber_id != 0 {
15572 len += 1;
15573 }
15574 if self.upstream_mv_table_id != 0 {
15575 len += 1;
15576 }
15577 let mut struct_ser = serializer.serialize_struct("stream_plan.SubscriptionUpstreamInfo", len)?;
15578 if self.subscriber_id != 0 {
15579 struct_ser.serialize_field("subscriberId", &self.subscriber_id)?;
15580 }
15581 if self.upstream_mv_table_id != 0 {
15582 struct_ser.serialize_field("upstreamMvTableId", &self.upstream_mv_table_id)?;
15583 }
15584 struct_ser.end()
15585 }
15586}
15587impl<'de> serde::Deserialize<'de> for SubscriptionUpstreamInfo {
15588 #[allow(deprecated)]
15589 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15590 where
15591 D: serde::Deserializer<'de>,
15592 {
15593 const FIELDS: &[&str] = &[
15594 "subscriber_id",
15595 "subscriberId",
15596 "upstream_mv_table_id",
15597 "upstreamMvTableId",
15598 ];
15599
15600 #[allow(clippy::enum_variant_names)]
15601 enum GeneratedField {
15602 SubscriberId,
15603 UpstreamMvTableId,
15604 }
15605 impl<'de> serde::Deserialize<'de> for GeneratedField {
15606 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15607 where
15608 D: serde::Deserializer<'de>,
15609 {
15610 struct GeneratedVisitor;
15611
15612 impl serde::de::Visitor<'_> for GeneratedVisitor {
15613 type Value = GeneratedField;
15614
15615 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15616 write!(formatter, "expected one of: {:?}", &FIELDS)
15617 }
15618
15619 #[allow(unused_variables)]
15620 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15621 where
15622 E: serde::de::Error,
15623 {
15624 match value {
15625 "subscriberId" | "subscriber_id" => Ok(GeneratedField::SubscriberId),
15626 "upstreamMvTableId" | "upstream_mv_table_id" => Ok(GeneratedField::UpstreamMvTableId),
15627 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15628 }
15629 }
15630 }
15631 deserializer.deserialize_identifier(GeneratedVisitor)
15632 }
15633 }
15634 struct GeneratedVisitor;
15635 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15636 type Value = SubscriptionUpstreamInfo;
15637
15638 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15639 formatter.write_str("struct stream_plan.SubscriptionUpstreamInfo")
15640 }
15641
15642 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscriptionUpstreamInfo, V::Error>
15643 where
15644 V: serde::de::MapAccess<'de>,
15645 {
15646 let mut subscriber_id__ = None;
15647 let mut upstream_mv_table_id__ = None;
15648 while let Some(k) = map_.next_key()? {
15649 match k {
15650 GeneratedField::SubscriberId => {
15651 if subscriber_id__.is_some() {
15652 return Err(serde::de::Error::duplicate_field("subscriberId"));
15653 }
15654 subscriber_id__ =
15655 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15656 ;
15657 }
15658 GeneratedField::UpstreamMvTableId => {
15659 if upstream_mv_table_id__.is_some() {
15660 return Err(serde::de::Error::duplicate_field("upstreamMvTableId"));
15661 }
15662 upstream_mv_table_id__ =
15663 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15664 ;
15665 }
15666 }
15667 }
15668 Ok(SubscriptionUpstreamInfo {
15669 subscriber_id: subscriber_id__.unwrap_or_default(),
15670 upstream_mv_table_id: upstream_mv_table_id__.unwrap_or_default(),
15671 })
15672 }
15673 }
15674 deserializer.deserialize_struct("stream_plan.SubscriptionUpstreamInfo", FIELDS, GeneratedVisitor)
15675 }
15676}
15677impl serde::Serialize for SyncLogStoreNode {
15678 #[allow(deprecated)]
15679 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15680 where
15681 S: serde::Serializer,
15682 {
15683 use serde::ser::SerializeStruct;
15684 let mut len = 0;
15685 if self.log_store_table.is_some() {
15686 len += 1;
15687 }
15688 if self.pause_duration_ms.is_some() {
15689 len += 1;
15690 }
15691 if self.buffer_size.is_some() {
15692 len += 1;
15693 }
15694 if self.aligned {
15695 len += 1;
15696 }
15697 let mut struct_ser = serializer.serialize_struct("stream_plan.SyncLogStoreNode", len)?;
15698 if let Some(v) = self.log_store_table.as_ref() {
15699 struct_ser.serialize_field("logStoreTable", v)?;
15700 }
15701 if let Some(v) = self.pause_duration_ms.as_ref() {
15702 struct_ser.serialize_field("pauseDurationMs", v)?;
15703 }
15704 if let Some(v) = self.buffer_size.as_ref() {
15705 struct_ser.serialize_field("bufferSize", v)?;
15706 }
15707 if self.aligned {
15708 struct_ser.serialize_field("aligned", &self.aligned)?;
15709 }
15710 struct_ser.end()
15711 }
15712}
15713impl<'de> serde::Deserialize<'de> for SyncLogStoreNode {
15714 #[allow(deprecated)]
15715 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15716 where
15717 D: serde::Deserializer<'de>,
15718 {
15719 const FIELDS: &[&str] = &[
15720 "log_store_table",
15721 "logStoreTable",
15722 "pause_duration_ms",
15723 "pauseDurationMs",
15724 "buffer_size",
15725 "bufferSize",
15726 "aligned",
15727 ];
15728
15729 #[allow(clippy::enum_variant_names)]
15730 enum GeneratedField {
15731 LogStoreTable,
15732 PauseDurationMs,
15733 BufferSize,
15734 Aligned,
15735 }
15736 impl<'de> serde::Deserialize<'de> for GeneratedField {
15737 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15738 where
15739 D: serde::Deserializer<'de>,
15740 {
15741 struct GeneratedVisitor;
15742
15743 impl serde::de::Visitor<'_> for GeneratedVisitor {
15744 type Value = GeneratedField;
15745
15746 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15747 write!(formatter, "expected one of: {:?}", &FIELDS)
15748 }
15749
15750 #[allow(unused_variables)]
15751 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15752 where
15753 E: serde::de::Error,
15754 {
15755 match value {
15756 "logStoreTable" | "log_store_table" => Ok(GeneratedField::LogStoreTable),
15757 "pauseDurationMs" | "pause_duration_ms" => Ok(GeneratedField::PauseDurationMs),
15758 "bufferSize" | "buffer_size" => Ok(GeneratedField::BufferSize),
15759 "aligned" => Ok(GeneratedField::Aligned),
15760 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15761 }
15762 }
15763 }
15764 deserializer.deserialize_identifier(GeneratedVisitor)
15765 }
15766 }
15767 struct GeneratedVisitor;
15768 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15769 type Value = SyncLogStoreNode;
15770
15771 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15772 formatter.write_str("struct stream_plan.SyncLogStoreNode")
15773 }
15774
15775 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SyncLogStoreNode, V::Error>
15776 where
15777 V: serde::de::MapAccess<'de>,
15778 {
15779 let mut log_store_table__ = None;
15780 let mut pause_duration_ms__ = None;
15781 let mut buffer_size__ = None;
15782 let mut aligned__ = None;
15783 while let Some(k) = map_.next_key()? {
15784 match k {
15785 GeneratedField::LogStoreTable => {
15786 if log_store_table__.is_some() {
15787 return Err(serde::de::Error::duplicate_field("logStoreTable"));
15788 }
15789 log_store_table__ = map_.next_value()?;
15790 }
15791 GeneratedField::PauseDurationMs => {
15792 if pause_duration_ms__.is_some() {
15793 return Err(serde::de::Error::duplicate_field("pauseDurationMs"));
15794 }
15795 pause_duration_ms__ =
15796 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15797 ;
15798 }
15799 GeneratedField::BufferSize => {
15800 if buffer_size__.is_some() {
15801 return Err(serde::de::Error::duplicate_field("bufferSize"));
15802 }
15803 buffer_size__ =
15804 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15805 ;
15806 }
15807 GeneratedField::Aligned => {
15808 if aligned__.is_some() {
15809 return Err(serde::de::Error::duplicate_field("aligned"));
15810 }
15811 aligned__ = Some(map_.next_value()?);
15812 }
15813 }
15814 }
15815 Ok(SyncLogStoreNode {
15816 log_store_table: log_store_table__,
15817 pause_duration_ms: pause_duration_ms__,
15818 buffer_size: buffer_size__,
15819 aligned: aligned__.unwrap_or_default(),
15820 })
15821 }
15822 }
15823 deserializer.deserialize_struct("stream_plan.SyncLogStoreNode", FIELDS, GeneratedVisitor)
15824 }
15825}
15826impl serde::Serialize for TemporalJoinNode {
15827 #[allow(deprecated)]
15828 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15829 where
15830 S: serde::Serializer,
15831 {
15832 use serde::ser::SerializeStruct;
15833 let mut len = 0;
15834 if self.join_type != 0 {
15835 len += 1;
15836 }
15837 if !self.left_key.is_empty() {
15838 len += 1;
15839 }
15840 if !self.right_key.is_empty() {
15841 len += 1;
15842 }
15843 if !self.null_safe.is_empty() {
15844 len += 1;
15845 }
15846 if self.condition.is_some() {
15847 len += 1;
15848 }
15849 if !self.output_indices.is_empty() {
15850 len += 1;
15851 }
15852 if self.table_desc.is_some() {
15853 len += 1;
15854 }
15855 if !self.table_output_indices.is_empty() {
15856 len += 1;
15857 }
15858 if self.memo_table.is_some() {
15859 len += 1;
15860 }
15861 if self.is_nested_loop {
15862 len += 1;
15863 }
15864 let mut struct_ser = serializer.serialize_struct("stream_plan.TemporalJoinNode", len)?;
15865 if self.join_type != 0 {
15866 let v = super::plan_common::JoinType::try_from(self.join_type)
15867 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
15868 struct_ser.serialize_field("joinType", &v)?;
15869 }
15870 if !self.left_key.is_empty() {
15871 struct_ser.serialize_field("leftKey", &self.left_key)?;
15872 }
15873 if !self.right_key.is_empty() {
15874 struct_ser.serialize_field("rightKey", &self.right_key)?;
15875 }
15876 if !self.null_safe.is_empty() {
15877 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
15878 }
15879 if let Some(v) = self.condition.as_ref() {
15880 struct_ser.serialize_field("condition", v)?;
15881 }
15882 if !self.output_indices.is_empty() {
15883 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
15884 }
15885 if let Some(v) = self.table_desc.as_ref() {
15886 struct_ser.serialize_field("tableDesc", v)?;
15887 }
15888 if !self.table_output_indices.is_empty() {
15889 struct_ser.serialize_field("tableOutputIndices", &self.table_output_indices)?;
15890 }
15891 if let Some(v) = self.memo_table.as_ref() {
15892 struct_ser.serialize_field("memoTable", v)?;
15893 }
15894 if self.is_nested_loop {
15895 struct_ser.serialize_field("isNestedLoop", &self.is_nested_loop)?;
15896 }
15897 struct_ser.end()
15898 }
15899}
15900impl<'de> serde::Deserialize<'de> for TemporalJoinNode {
15901 #[allow(deprecated)]
15902 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15903 where
15904 D: serde::Deserializer<'de>,
15905 {
15906 const FIELDS: &[&str] = &[
15907 "join_type",
15908 "joinType",
15909 "left_key",
15910 "leftKey",
15911 "right_key",
15912 "rightKey",
15913 "null_safe",
15914 "nullSafe",
15915 "condition",
15916 "output_indices",
15917 "outputIndices",
15918 "table_desc",
15919 "tableDesc",
15920 "table_output_indices",
15921 "tableOutputIndices",
15922 "memo_table",
15923 "memoTable",
15924 "is_nested_loop",
15925 "isNestedLoop",
15926 ];
15927
15928 #[allow(clippy::enum_variant_names)]
15929 enum GeneratedField {
15930 JoinType,
15931 LeftKey,
15932 RightKey,
15933 NullSafe,
15934 Condition,
15935 OutputIndices,
15936 TableDesc,
15937 TableOutputIndices,
15938 MemoTable,
15939 IsNestedLoop,
15940 }
15941 impl<'de> serde::Deserialize<'de> for GeneratedField {
15942 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15943 where
15944 D: serde::Deserializer<'de>,
15945 {
15946 struct GeneratedVisitor;
15947
15948 impl serde::de::Visitor<'_> for GeneratedVisitor {
15949 type Value = GeneratedField;
15950
15951 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15952 write!(formatter, "expected one of: {:?}", &FIELDS)
15953 }
15954
15955 #[allow(unused_variables)]
15956 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15957 where
15958 E: serde::de::Error,
15959 {
15960 match value {
15961 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
15962 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
15963 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
15964 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
15965 "condition" => Ok(GeneratedField::Condition),
15966 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
15967 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
15968 "tableOutputIndices" | "table_output_indices" => Ok(GeneratedField::TableOutputIndices),
15969 "memoTable" | "memo_table" => Ok(GeneratedField::MemoTable),
15970 "isNestedLoop" | "is_nested_loop" => Ok(GeneratedField::IsNestedLoop),
15971 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15972 }
15973 }
15974 }
15975 deserializer.deserialize_identifier(GeneratedVisitor)
15976 }
15977 }
15978 struct GeneratedVisitor;
15979 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15980 type Value = TemporalJoinNode;
15981
15982 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15983 formatter.write_str("struct stream_plan.TemporalJoinNode")
15984 }
15985
15986 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TemporalJoinNode, V::Error>
15987 where
15988 V: serde::de::MapAccess<'de>,
15989 {
15990 let mut join_type__ = None;
15991 let mut left_key__ = None;
15992 let mut right_key__ = None;
15993 let mut null_safe__ = None;
15994 let mut condition__ = None;
15995 let mut output_indices__ = None;
15996 let mut table_desc__ = None;
15997 let mut table_output_indices__ = None;
15998 let mut memo_table__ = None;
15999 let mut is_nested_loop__ = None;
16000 while let Some(k) = map_.next_key()? {
16001 match k {
16002 GeneratedField::JoinType => {
16003 if join_type__.is_some() {
16004 return Err(serde::de::Error::duplicate_field("joinType"));
16005 }
16006 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
16007 }
16008 GeneratedField::LeftKey => {
16009 if left_key__.is_some() {
16010 return Err(serde::de::Error::duplicate_field("leftKey"));
16011 }
16012 left_key__ =
16013 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16014 .into_iter().map(|x| x.0).collect())
16015 ;
16016 }
16017 GeneratedField::RightKey => {
16018 if right_key__.is_some() {
16019 return Err(serde::de::Error::duplicate_field("rightKey"));
16020 }
16021 right_key__ =
16022 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16023 .into_iter().map(|x| x.0).collect())
16024 ;
16025 }
16026 GeneratedField::NullSafe => {
16027 if null_safe__.is_some() {
16028 return Err(serde::de::Error::duplicate_field("nullSafe"));
16029 }
16030 null_safe__ = Some(map_.next_value()?);
16031 }
16032 GeneratedField::Condition => {
16033 if condition__.is_some() {
16034 return Err(serde::de::Error::duplicate_field("condition"));
16035 }
16036 condition__ = map_.next_value()?;
16037 }
16038 GeneratedField::OutputIndices => {
16039 if output_indices__.is_some() {
16040 return Err(serde::de::Error::duplicate_field("outputIndices"));
16041 }
16042 output_indices__ =
16043 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16044 .into_iter().map(|x| x.0).collect())
16045 ;
16046 }
16047 GeneratedField::TableDesc => {
16048 if table_desc__.is_some() {
16049 return Err(serde::de::Error::duplicate_field("tableDesc"));
16050 }
16051 table_desc__ = map_.next_value()?;
16052 }
16053 GeneratedField::TableOutputIndices => {
16054 if table_output_indices__.is_some() {
16055 return Err(serde::de::Error::duplicate_field("tableOutputIndices"));
16056 }
16057 table_output_indices__ =
16058 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16059 .into_iter().map(|x| x.0).collect())
16060 ;
16061 }
16062 GeneratedField::MemoTable => {
16063 if memo_table__.is_some() {
16064 return Err(serde::de::Error::duplicate_field("memoTable"));
16065 }
16066 memo_table__ = map_.next_value()?;
16067 }
16068 GeneratedField::IsNestedLoop => {
16069 if is_nested_loop__.is_some() {
16070 return Err(serde::de::Error::duplicate_field("isNestedLoop"));
16071 }
16072 is_nested_loop__ = Some(map_.next_value()?);
16073 }
16074 }
16075 }
16076 Ok(TemporalJoinNode {
16077 join_type: join_type__.unwrap_or_default(),
16078 left_key: left_key__.unwrap_or_default(),
16079 right_key: right_key__.unwrap_or_default(),
16080 null_safe: null_safe__.unwrap_or_default(),
16081 condition: condition__,
16082 output_indices: output_indices__.unwrap_or_default(),
16083 table_desc: table_desc__,
16084 table_output_indices: table_output_indices__.unwrap_or_default(),
16085 memo_table: memo_table__,
16086 is_nested_loop: is_nested_loop__.unwrap_or_default(),
16087 })
16088 }
16089 }
16090 deserializer.deserialize_struct("stream_plan.TemporalJoinNode", FIELDS, GeneratedVisitor)
16091 }
16092}
16093impl serde::Serialize for ThrottleMutation {
16094 #[allow(deprecated)]
16095 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16096 where
16097 S: serde::Serializer,
16098 {
16099 use serde::ser::SerializeStruct;
16100 let mut len = 0;
16101 if !self.fragment_throttle.is_empty() {
16102 len += 1;
16103 }
16104 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation", len)?;
16105 if !self.fragment_throttle.is_empty() {
16106 struct_ser.serialize_field("fragmentThrottle", &self.fragment_throttle)?;
16107 }
16108 struct_ser.end()
16109 }
16110}
16111impl<'de> serde::Deserialize<'de> for ThrottleMutation {
16112 #[allow(deprecated)]
16113 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16114 where
16115 D: serde::Deserializer<'de>,
16116 {
16117 const FIELDS: &[&str] = &[
16118 "fragment_throttle",
16119 "fragmentThrottle",
16120 ];
16121
16122 #[allow(clippy::enum_variant_names)]
16123 enum GeneratedField {
16124 FragmentThrottle,
16125 }
16126 impl<'de> serde::Deserialize<'de> for GeneratedField {
16127 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16128 where
16129 D: serde::Deserializer<'de>,
16130 {
16131 struct GeneratedVisitor;
16132
16133 impl serde::de::Visitor<'_> for GeneratedVisitor {
16134 type Value = GeneratedField;
16135
16136 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16137 write!(formatter, "expected one of: {:?}", &FIELDS)
16138 }
16139
16140 #[allow(unused_variables)]
16141 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16142 where
16143 E: serde::de::Error,
16144 {
16145 match value {
16146 "fragmentThrottle" | "fragment_throttle" => Ok(GeneratedField::FragmentThrottle),
16147 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16148 }
16149 }
16150 }
16151 deserializer.deserialize_identifier(GeneratedVisitor)
16152 }
16153 }
16154 struct GeneratedVisitor;
16155 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16156 type Value = ThrottleMutation;
16157
16158 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16159 formatter.write_str("struct stream_plan.ThrottleMutation")
16160 }
16161
16162 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ThrottleMutation, V::Error>
16163 where
16164 V: serde::de::MapAccess<'de>,
16165 {
16166 let mut fragment_throttle__ = None;
16167 while let Some(k) = map_.next_key()? {
16168 match k {
16169 GeneratedField::FragmentThrottle => {
16170 if fragment_throttle__.is_some() {
16171 return Err(serde::de::Error::duplicate_field("fragmentThrottle"));
16172 }
16173 fragment_throttle__ = Some(
16174 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
16175 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
16176 );
16177 }
16178 }
16179 }
16180 Ok(ThrottleMutation {
16181 fragment_throttle: fragment_throttle__.unwrap_or_default(),
16182 })
16183 }
16184 }
16185 deserializer.deserialize_struct("stream_plan.ThrottleMutation", FIELDS, GeneratedVisitor)
16186 }
16187}
16188impl serde::Serialize for throttle_mutation::ThrottleConfig {
16189 #[allow(deprecated)]
16190 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16191 where
16192 S: serde::Serializer,
16193 {
16194 use serde::ser::SerializeStruct;
16195 let mut len = 0;
16196 if self.rate_limit.is_some() {
16197 len += 1;
16198 }
16199 if self.throttle_type != 0 {
16200 len += 1;
16201 }
16202 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation.ThrottleConfig", len)?;
16203 if let Some(v) = self.rate_limit.as_ref() {
16204 struct_ser.serialize_field("rateLimit", v)?;
16205 }
16206 if self.throttle_type != 0 {
16207 let v = super::common::ThrottleType::try_from(self.throttle_type)
16208 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.throttle_type)))?;
16209 struct_ser.serialize_field("throttleType", &v)?;
16210 }
16211 struct_ser.end()
16212 }
16213}
16214impl<'de> serde::Deserialize<'de> for throttle_mutation::ThrottleConfig {
16215 #[allow(deprecated)]
16216 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16217 where
16218 D: serde::Deserializer<'de>,
16219 {
16220 const FIELDS: &[&str] = &[
16221 "rate_limit",
16222 "rateLimit",
16223 "throttle_type",
16224 "throttleType",
16225 ];
16226
16227 #[allow(clippy::enum_variant_names)]
16228 enum GeneratedField {
16229 RateLimit,
16230 ThrottleType,
16231 }
16232 impl<'de> serde::Deserialize<'de> for GeneratedField {
16233 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16234 where
16235 D: serde::Deserializer<'de>,
16236 {
16237 struct GeneratedVisitor;
16238
16239 impl serde::de::Visitor<'_> for GeneratedVisitor {
16240 type Value = GeneratedField;
16241
16242 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16243 write!(formatter, "expected one of: {:?}", &FIELDS)
16244 }
16245
16246 #[allow(unused_variables)]
16247 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16248 where
16249 E: serde::de::Error,
16250 {
16251 match value {
16252 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
16253 "throttleType" | "throttle_type" => Ok(GeneratedField::ThrottleType),
16254 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16255 }
16256 }
16257 }
16258 deserializer.deserialize_identifier(GeneratedVisitor)
16259 }
16260 }
16261 struct GeneratedVisitor;
16262 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16263 type Value = throttle_mutation::ThrottleConfig;
16264
16265 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16266 formatter.write_str("struct stream_plan.ThrottleMutation.ThrottleConfig")
16267 }
16268
16269 fn visit_map<V>(self, mut map_: V) -> std::result::Result<throttle_mutation::ThrottleConfig, V::Error>
16270 where
16271 V: serde::de::MapAccess<'de>,
16272 {
16273 let mut rate_limit__ = None;
16274 let mut throttle_type__ = None;
16275 while let Some(k) = map_.next_key()? {
16276 match k {
16277 GeneratedField::RateLimit => {
16278 if rate_limit__.is_some() {
16279 return Err(serde::de::Error::duplicate_field("rateLimit"));
16280 }
16281 rate_limit__ =
16282 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16283 ;
16284 }
16285 GeneratedField::ThrottleType => {
16286 if throttle_type__.is_some() {
16287 return Err(serde::de::Error::duplicate_field("throttleType"));
16288 }
16289 throttle_type__ = Some(map_.next_value::<super::common::ThrottleType>()? as i32);
16290 }
16291 }
16292 }
16293 Ok(throttle_mutation::ThrottleConfig {
16294 rate_limit: rate_limit__,
16295 throttle_type: throttle_type__.unwrap_or_default(),
16296 })
16297 }
16298 }
16299 deserializer.deserialize_struct("stream_plan.ThrottleMutation.ThrottleConfig", FIELDS, GeneratedVisitor)
16300 }
16301}
16302impl serde::Serialize for TopNNode {
16303 #[allow(deprecated)]
16304 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16305 where
16306 S: serde::Serializer,
16307 {
16308 use serde::ser::SerializeStruct;
16309 let mut len = 0;
16310 if self.limit != 0 {
16311 len += 1;
16312 }
16313 if self.offset != 0 {
16314 len += 1;
16315 }
16316 if self.table.is_some() {
16317 len += 1;
16318 }
16319 if !self.order_by.is_empty() {
16320 len += 1;
16321 }
16322 if self.with_ties {
16323 len += 1;
16324 }
16325 let mut struct_ser = serializer.serialize_struct("stream_plan.TopNNode", len)?;
16326 if self.limit != 0 {
16327 #[allow(clippy::needless_borrow)]
16328 #[allow(clippy::needless_borrows_for_generic_args)]
16329 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
16330 }
16331 if self.offset != 0 {
16332 #[allow(clippy::needless_borrow)]
16333 #[allow(clippy::needless_borrows_for_generic_args)]
16334 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
16335 }
16336 if let Some(v) = self.table.as_ref() {
16337 struct_ser.serialize_field("table", v)?;
16338 }
16339 if !self.order_by.is_empty() {
16340 struct_ser.serialize_field("orderBy", &self.order_by)?;
16341 }
16342 if self.with_ties {
16343 struct_ser.serialize_field("withTies", &self.with_ties)?;
16344 }
16345 struct_ser.end()
16346 }
16347}
16348impl<'de> serde::Deserialize<'de> for TopNNode {
16349 #[allow(deprecated)]
16350 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16351 where
16352 D: serde::Deserializer<'de>,
16353 {
16354 const FIELDS: &[&str] = &[
16355 "limit",
16356 "offset",
16357 "table",
16358 "order_by",
16359 "orderBy",
16360 "with_ties",
16361 "withTies",
16362 ];
16363
16364 #[allow(clippy::enum_variant_names)]
16365 enum GeneratedField {
16366 Limit,
16367 Offset,
16368 Table,
16369 OrderBy,
16370 WithTies,
16371 }
16372 impl<'de> serde::Deserialize<'de> for GeneratedField {
16373 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16374 where
16375 D: serde::Deserializer<'de>,
16376 {
16377 struct GeneratedVisitor;
16378
16379 impl serde::de::Visitor<'_> for GeneratedVisitor {
16380 type Value = GeneratedField;
16381
16382 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16383 write!(formatter, "expected one of: {:?}", &FIELDS)
16384 }
16385
16386 #[allow(unused_variables)]
16387 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16388 where
16389 E: serde::de::Error,
16390 {
16391 match value {
16392 "limit" => Ok(GeneratedField::Limit),
16393 "offset" => Ok(GeneratedField::Offset),
16394 "table" => Ok(GeneratedField::Table),
16395 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
16396 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
16397 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16398 }
16399 }
16400 }
16401 deserializer.deserialize_identifier(GeneratedVisitor)
16402 }
16403 }
16404 struct GeneratedVisitor;
16405 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16406 type Value = TopNNode;
16407
16408 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16409 formatter.write_str("struct stream_plan.TopNNode")
16410 }
16411
16412 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
16413 where
16414 V: serde::de::MapAccess<'de>,
16415 {
16416 let mut limit__ = None;
16417 let mut offset__ = None;
16418 let mut table__ = None;
16419 let mut order_by__ = None;
16420 let mut with_ties__ = None;
16421 while let Some(k) = map_.next_key()? {
16422 match k {
16423 GeneratedField::Limit => {
16424 if limit__.is_some() {
16425 return Err(serde::de::Error::duplicate_field("limit"));
16426 }
16427 limit__ =
16428 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16429 ;
16430 }
16431 GeneratedField::Offset => {
16432 if offset__.is_some() {
16433 return Err(serde::de::Error::duplicate_field("offset"));
16434 }
16435 offset__ =
16436 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16437 ;
16438 }
16439 GeneratedField::Table => {
16440 if table__.is_some() {
16441 return Err(serde::de::Error::duplicate_field("table"));
16442 }
16443 table__ = map_.next_value()?;
16444 }
16445 GeneratedField::OrderBy => {
16446 if order_by__.is_some() {
16447 return Err(serde::de::Error::duplicate_field("orderBy"));
16448 }
16449 order_by__ = Some(map_.next_value()?);
16450 }
16451 GeneratedField::WithTies => {
16452 if with_ties__.is_some() {
16453 return Err(serde::de::Error::duplicate_field("withTies"));
16454 }
16455 with_ties__ = Some(map_.next_value()?);
16456 }
16457 }
16458 }
16459 Ok(TopNNode {
16460 limit: limit__.unwrap_or_default(),
16461 offset: offset__.unwrap_or_default(),
16462 table: table__,
16463 order_by: order_by__.unwrap_or_default(),
16464 with_ties: with_ties__.unwrap_or_default(),
16465 })
16466 }
16467 }
16468 deserializer.deserialize_struct("stream_plan.TopNNode", FIELDS, GeneratedVisitor)
16469 }
16470}
16471impl serde::Serialize for UnionNode {
16472 #[allow(deprecated)]
16473 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16474 where
16475 S: serde::Serializer,
16476 {
16477 use serde::ser::SerializeStruct;
16478 let len = 0;
16479 let struct_ser = serializer.serialize_struct("stream_plan.UnionNode", len)?;
16480 struct_ser.end()
16481 }
16482}
16483impl<'de> serde::Deserialize<'de> for UnionNode {
16484 #[allow(deprecated)]
16485 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16486 where
16487 D: serde::Deserializer<'de>,
16488 {
16489 const FIELDS: &[&str] = &[
16490 ];
16491
16492 #[allow(clippy::enum_variant_names)]
16493 enum GeneratedField {
16494 }
16495 impl<'de> serde::Deserialize<'de> for GeneratedField {
16496 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16497 where
16498 D: serde::Deserializer<'de>,
16499 {
16500 struct GeneratedVisitor;
16501
16502 impl serde::de::Visitor<'_> for GeneratedVisitor {
16503 type Value = GeneratedField;
16504
16505 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16506 write!(formatter, "expected one of: {:?}", &FIELDS)
16507 }
16508
16509 #[allow(unused_variables)]
16510 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16511 where
16512 E: serde::de::Error,
16513 {
16514 Err(serde::de::Error::unknown_field(value, FIELDS))
16515 }
16516 }
16517 deserializer.deserialize_identifier(GeneratedVisitor)
16518 }
16519 }
16520 struct GeneratedVisitor;
16521 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16522 type Value = UnionNode;
16523
16524 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16525 formatter.write_str("struct stream_plan.UnionNode")
16526 }
16527
16528 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
16529 where
16530 V: serde::de::MapAccess<'de>,
16531 {
16532 while map_.next_key::<GeneratedField>()?.is_some() {
16533 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16534 }
16535 Ok(UnionNode {
16536 })
16537 }
16538 }
16539 deserializer.deserialize_struct("stream_plan.UnionNode", FIELDS, GeneratedVisitor)
16540 }
16541}
16542impl serde::Serialize for UpdateMutation {
16543 #[allow(deprecated)]
16544 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16545 where
16546 S: serde::Serializer,
16547 {
16548 use serde::ser::SerializeStruct;
16549 let mut len = 0;
16550 if !self.dispatcher_update.is_empty() {
16551 len += 1;
16552 }
16553 if !self.merge_update.is_empty() {
16554 len += 1;
16555 }
16556 if !self.actor_vnode_bitmap_update.is_empty() {
16557 len += 1;
16558 }
16559 if !self.dropped_actors.is_empty() {
16560 len += 1;
16561 }
16562 if !self.actor_splits.is_empty() {
16563 len += 1;
16564 }
16565 if !self.actor_new_dispatchers.is_empty() {
16566 len += 1;
16567 }
16568 if self.actor_cdc_table_snapshot_splits.is_some() {
16569 len += 1;
16570 }
16571 if !self.sink_schema_change.is_empty() {
16572 len += 1;
16573 }
16574 if !self.subscriptions_to_drop.is_empty() {
16575 len += 1;
16576 }
16577 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation", len)?;
16578 if !self.dispatcher_update.is_empty() {
16579 struct_ser.serialize_field("dispatcherUpdate", &self.dispatcher_update)?;
16580 }
16581 if !self.merge_update.is_empty() {
16582 struct_ser.serialize_field("mergeUpdate", &self.merge_update)?;
16583 }
16584 if !self.actor_vnode_bitmap_update.is_empty() {
16585 struct_ser.serialize_field("actorVnodeBitmapUpdate", &self.actor_vnode_bitmap_update)?;
16586 }
16587 if !self.dropped_actors.is_empty() {
16588 struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
16589 }
16590 if !self.actor_splits.is_empty() {
16591 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
16592 }
16593 if !self.actor_new_dispatchers.is_empty() {
16594 struct_ser.serialize_field("actorNewDispatchers", &self.actor_new_dispatchers)?;
16595 }
16596 if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
16597 struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
16598 }
16599 if !self.sink_schema_change.is_empty() {
16600 struct_ser.serialize_field("sinkSchemaChange", &self.sink_schema_change)?;
16601 }
16602 if !self.subscriptions_to_drop.is_empty() {
16603 struct_ser.serialize_field("subscriptionsToDrop", &self.subscriptions_to_drop)?;
16604 }
16605 struct_ser.end()
16606 }
16607}
16608impl<'de> serde::Deserialize<'de> for UpdateMutation {
16609 #[allow(deprecated)]
16610 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16611 where
16612 D: serde::Deserializer<'de>,
16613 {
16614 const FIELDS: &[&str] = &[
16615 "dispatcher_update",
16616 "dispatcherUpdate",
16617 "merge_update",
16618 "mergeUpdate",
16619 "actor_vnode_bitmap_update",
16620 "actorVnodeBitmapUpdate",
16621 "dropped_actors",
16622 "droppedActors",
16623 "actor_splits",
16624 "actorSplits",
16625 "actor_new_dispatchers",
16626 "actorNewDispatchers",
16627 "actor_cdc_table_snapshot_splits",
16628 "actorCdcTableSnapshotSplits",
16629 "sink_schema_change",
16630 "sinkSchemaChange",
16631 "subscriptions_to_drop",
16632 "subscriptionsToDrop",
16633 ];
16634
16635 #[allow(clippy::enum_variant_names)]
16636 enum GeneratedField {
16637 DispatcherUpdate,
16638 MergeUpdate,
16639 ActorVnodeBitmapUpdate,
16640 DroppedActors,
16641 ActorSplits,
16642 ActorNewDispatchers,
16643 ActorCdcTableSnapshotSplits,
16644 SinkSchemaChange,
16645 SubscriptionsToDrop,
16646 }
16647 impl<'de> serde::Deserialize<'de> for GeneratedField {
16648 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16649 where
16650 D: serde::Deserializer<'de>,
16651 {
16652 struct GeneratedVisitor;
16653
16654 impl serde::de::Visitor<'_> for GeneratedVisitor {
16655 type Value = GeneratedField;
16656
16657 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16658 write!(formatter, "expected one of: {:?}", &FIELDS)
16659 }
16660
16661 #[allow(unused_variables)]
16662 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16663 where
16664 E: serde::de::Error,
16665 {
16666 match value {
16667 "dispatcherUpdate" | "dispatcher_update" => Ok(GeneratedField::DispatcherUpdate),
16668 "mergeUpdate" | "merge_update" => Ok(GeneratedField::MergeUpdate),
16669 "actorVnodeBitmapUpdate" | "actor_vnode_bitmap_update" => Ok(GeneratedField::ActorVnodeBitmapUpdate),
16670 "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
16671 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
16672 "actorNewDispatchers" | "actor_new_dispatchers" => Ok(GeneratedField::ActorNewDispatchers),
16673 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
16674 "sinkSchemaChange" | "sink_schema_change" => Ok(GeneratedField::SinkSchemaChange),
16675 "subscriptionsToDrop" | "subscriptions_to_drop" => Ok(GeneratedField::SubscriptionsToDrop),
16676 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16677 }
16678 }
16679 }
16680 deserializer.deserialize_identifier(GeneratedVisitor)
16681 }
16682 }
16683 struct GeneratedVisitor;
16684 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16685 type Value = UpdateMutation;
16686
16687 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16688 formatter.write_str("struct stream_plan.UpdateMutation")
16689 }
16690
16691 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateMutation, V::Error>
16692 where
16693 V: serde::de::MapAccess<'de>,
16694 {
16695 let mut dispatcher_update__ = None;
16696 let mut merge_update__ = None;
16697 let mut actor_vnode_bitmap_update__ = None;
16698 let mut dropped_actors__ = None;
16699 let mut actor_splits__ = None;
16700 let mut actor_new_dispatchers__ = None;
16701 let mut actor_cdc_table_snapshot_splits__ = None;
16702 let mut sink_schema_change__ = None;
16703 let mut subscriptions_to_drop__ = None;
16704 while let Some(k) = map_.next_key()? {
16705 match k {
16706 GeneratedField::DispatcherUpdate => {
16707 if dispatcher_update__.is_some() {
16708 return Err(serde::de::Error::duplicate_field("dispatcherUpdate"));
16709 }
16710 dispatcher_update__ = Some(map_.next_value()?);
16711 }
16712 GeneratedField::MergeUpdate => {
16713 if merge_update__.is_some() {
16714 return Err(serde::de::Error::duplicate_field("mergeUpdate"));
16715 }
16716 merge_update__ = Some(map_.next_value()?);
16717 }
16718 GeneratedField::ActorVnodeBitmapUpdate => {
16719 if actor_vnode_bitmap_update__.is_some() {
16720 return Err(serde::de::Error::duplicate_field("actorVnodeBitmapUpdate"));
16721 }
16722 actor_vnode_bitmap_update__ = Some(
16723 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
16724 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
16725 );
16726 }
16727 GeneratedField::DroppedActors => {
16728 if dropped_actors__.is_some() {
16729 return Err(serde::de::Error::duplicate_field("droppedActors"));
16730 }
16731 dropped_actors__ =
16732 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16733 .into_iter().map(|x| x.0).collect())
16734 ;
16735 }
16736 GeneratedField::ActorSplits => {
16737 if actor_splits__.is_some() {
16738 return Err(serde::de::Error::duplicate_field("actorSplits"));
16739 }
16740 actor_splits__ = Some(
16741 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
16742 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
16743 );
16744 }
16745 GeneratedField::ActorNewDispatchers => {
16746 if actor_new_dispatchers__.is_some() {
16747 return Err(serde::de::Error::duplicate_field("actorNewDispatchers"));
16748 }
16749 actor_new_dispatchers__ = Some(
16750 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
16751 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
16752 );
16753 }
16754 GeneratedField::ActorCdcTableSnapshotSplits => {
16755 if actor_cdc_table_snapshot_splits__.is_some() {
16756 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
16757 }
16758 actor_cdc_table_snapshot_splits__ = map_.next_value()?;
16759 }
16760 GeneratedField::SinkSchemaChange => {
16761 if sink_schema_change__.is_some() {
16762 return Err(serde::de::Error::duplicate_field("sinkSchemaChange"));
16763 }
16764 sink_schema_change__ = Some(
16765 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
16766 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
16767 );
16768 }
16769 GeneratedField::SubscriptionsToDrop => {
16770 if subscriptions_to_drop__.is_some() {
16771 return Err(serde::de::Error::duplicate_field("subscriptionsToDrop"));
16772 }
16773 subscriptions_to_drop__ = Some(map_.next_value()?);
16774 }
16775 }
16776 }
16777 Ok(UpdateMutation {
16778 dispatcher_update: dispatcher_update__.unwrap_or_default(),
16779 merge_update: merge_update__.unwrap_or_default(),
16780 actor_vnode_bitmap_update: actor_vnode_bitmap_update__.unwrap_or_default(),
16781 dropped_actors: dropped_actors__.unwrap_or_default(),
16782 actor_splits: actor_splits__.unwrap_or_default(),
16783 actor_new_dispatchers: actor_new_dispatchers__.unwrap_or_default(),
16784 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
16785 sink_schema_change: sink_schema_change__.unwrap_or_default(),
16786 subscriptions_to_drop: subscriptions_to_drop__.unwrap_or_default(),
16787 })
16788 }
16789 }
16790 deserializer.deserialize_struct("stream_plan.UpdateMutation", FIELDS, GeneratedVisitor)
16791 }
16792}
16793impl serde::Serialize for update_mutation::DispatcherUpdate {
16794 #[allow(deprecated)]
16795 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16796 where
16797 S: serde::Serializer,
16798 {
16799 use serde::ser::SerializeStruct;
16800 let mut len = 0;
16801 if self.actor_id != 0 {
16802 len += 1;
16803 }
16804 if self.dispatcher_id != 0 {
16805 len += 1;
16806 }
16807 if self.hash_mapping.is_some() {
16808 len += 1;
16809 }
16810 if !self.added_downstream_actor_id.is_empty() {
16811 len += 1;
16812 }
16813 if !self.removed_downstream_actor_id.is_empty() {
16814 len += 1;
16815 }
16816 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", len)?;
16817 if self.actor_id != 0 {
16818 struct_ser.serialize_field("actorId", &self.actor_id)?;
16819 }
16820 if self.dispatcher_id != 0 {
16821 struct_ser.serialize_field("dispatcherId", &self.dispatcher_id)?;
16822 }
16823 if let Some(v) = self.hash_mapping.as_ref() {
16824 struct_ser.serialize_field("hashMapping", v)?;
16825 }
16826 if !self.added_downstream_actor_id.is_empty() {
16827 struct_ser.serialize_field("addedDownstreamActorId", &self.added_downstream_actor_id)?;
16828 }
16829 if !self.removed_downstream_actor_id.is_empty() {
16830 struct_ser.serialize_field("removedDownstreamActorId", &self.removed_downstream_actor_id)?;
16831 }
16832 struct_ser.end()
16833 }
16834}
16835impl<'de> serde::Deserialize<'de> for update_mutation::DispatcherUpdate {
16836 #[allow(deprecated)]
16837 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16838 where
16839 D: serde::Deserializer<'de>,
16840 {
16841 const FIELDS: &[&str] = &[
16842 "actor_id",
16843 "actorId",
16844 "dispatcher_id",
16845 "dispatcherId",
16846 "hash_mapping",
16847 "hashMapping",
16848 "added_downstream_actor_id",
16849 "addedDownstreamActorId",
16850 "removed_downstream_actor_id",
16851 "removedDownstreamActorId",
16852 ];
16853
16854 #[allow(clippy::enum_variant_names)]
16855 enum GeneratedField {
16856 ActorId,
16857 DispatcherId,
16858 HashMapping,
16859 AddedDownstreamActorId,
16860 RemovedDownstreamActorId,
16861 }
16862 impl<'de> serde::Deserialize<'de> for GeneratedField {
16863 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16864 where
16865 D: serde::Deserializer<'de>,
16866 {
16867 struct GeneratedVisitor;
16868
16869 impl serde::de::Visitor<'_> for GeneratedVisitor {
16870 type Value = GeneratedField;
16871
16872 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16873 write!(formatter, "expected one of: {:?}", &FIELDS)
16874 }
16875
16876 #[allow(unused_variables)]
16877 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16878 where
16879 E: serde::de::Error,
16880 {
16881 match value {
16882 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
16883 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
16884 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
16885 "addedDownstreamActorId" | "added_downstream_actor_id" => Ok(GeneratedField::AddedDownstreamActorId),
16886 "removedDownstreamActorId" | "removed_downstream_actor_id" => Ok(GeneratedField::RemovedDownstreamActorId),
16887 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16888 }
16889 }
16890 }
16891 deserializer.deserialize_identifier(GeneratedVisitor)
16892 }
16893 }
16894 struct GeneratedVisitor;
16895 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16896 type Value = update_mutation::DispatcherUpdate;
16897
16898 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16899 formatter.write_str("struct stream_plan.UpdateMutation.DispatcherUpdate")
16900 }
16901
16902 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::DispatcherUpdate, V::Error>
16903 where
16904 V: serde::de::MapAccess<'de>,
16905 {
16906 let mut actor_id__ = None;
16907 let mut dispatcher_id__ = None;
16908 let mut hash_mapping__ = None;
16909 let mut added_downstream_actor_id__ = None;
16910 let mut removed_downstream_actor_id__ = None;
16911 while let Some(k) = map_.next_key()? {
16912 match k {
16913 GeneratedField::ActorId => {
16914 if actor_id__.is_some() {
16915 return Err(serde::de::Error::duplicate_field("actorId"));
16916 }
16917 actor_id__ =
16918 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16919 ;
16920 }
16921 GeneratedField::DispatcherId => {
16922 if dispatcher_id__.is_some() {
16923 return Err(serde::de::Error::duplicate_field("dispatcherId"));
16924 }
16925 dispatcher_id__ =
16926 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16927 ;
16928 }
16929 GeneratedField::HashMapping => {
16930 if hash_mapping__.is_some() {
16931 return Err(serde::de::Error::duplicate_field("hashMapping"));
16932 }
16933 hash_mapping__ = map_.next_value()?;
16934 }
16935 GeneratedField::AddedDownstreamActorId => {
16936 if added_downstream_actor_id__.is_some() {
16937 return Err(serde::de::Error::duplicate_field("addedDownstreamActorId"));
16938 }
16939 added_downstream_actor_id__ =
16940 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16941 .into_iter().map(|x| x.0).collect())
16942 ;
16943 }
16944 GeneratedField::RemovedDownstreamActorId => {
16945 if removed_downstream_actor_id__.is_some() {
16946 return Err(serde::de::Error::duplicate_field("removedDownstreamActorId"));
16947 }
16948 removed_downstream_actor_id__ =
16949 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16950 .into_iter().map(|x| x.0).collect())
16951 ;
16952 }
16953 }
16954 }
16955 Ok(update_mutation::DispatcherUpdate {
16956 actor_id: actor_id__.unwrap_or_default(),
16957 dispatcher_id: dispatcher_id__.unwrap_or_default(),
16958 hash_mapping: hash_mapping__,
16959 added_downstream_actor_id: added_downstream_actor_id__.unwrap_or_default(),
16960 removed_downstream_actor_id: removed_downstream_actor_id__.unwrap_or_default(),
16961 })
16962 }
16963 }
16964 deserializer.deserialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", FIELDS, GeneratedVisitor)
16965 }
16966}
16967impl serde::Serialize for update_mutation::MergeUpdate {
16968 #[allow(deprecated)]
16969 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16970 where
16971 S: serde::Serializer,
16972 {
16973 use serde::ser::SerializeStruct;
16974 let mut len = 0;
16975 if self.actor_id != 0 {
16976 len += 1;
16977 }
16978 if self.upstream_fragment_id != 0 {
16979 len += 1;
16980 }
16981 if self.new_upstream_fragment_id.is_some() {
16982 len += 1;
16983 }
16984 if !self.added_upstream_actors.is_empty() {
16985 len += 1;
16986 }
16987 if !self.removed_upstream_actor_id.is_empty() {
16988 len += 1;
16989 }
16990 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.MergeUpdate", len)?;
16991 if self.actor_id != 0 {
16992 struct_ser.serialize_field("actorId", &self.actor_id)?;
16993 }
16994 if self.upstream_fragment_id != 0 {
16995 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
16996 }
16997 if let Some(v) = self.new_upstream_fragment_id.as_ref() {
16998 struct_ser.serialize_field("newUpstreamFragmentId", v)?;
16999 }
17000 if !self.added_upstream_actors.is_empty() {
17001 struct_ser.serialize_field("addedUpstreamActors", &self.added_upstream_actors)?;
17002 }
17003 if !self.removed_upstream_actor_id.is_empty() {
17004 struct_ser.serialize_field("removedUpstreamActorId", &self.removed_upstream_actor_id)?;
17005 }
17006 struct_ser.end()
17007 }
17008}
17009impl<'de> serde::Deserialize<'de> for update_mutation::MergeUpdate {
17010 #[allow(deprecated)]
17011 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17012 where
17013 D: serde::Deserializer<'de>,
17014 {
17015 const FIELDS: &[&str] = &[
17016 "actor_id",
17017 "actorId",
17018 "upstream_fragment_id",
17019 "upstreamFragmentId",
17020 "new_upstream_fragment_id",
17021 "newUpstreamFragmentId",
17022 "added_upstream_actors",
17023 "addedUpstreamActors",
17024 "removed_upstream_actor_id",
17025 "removedUpstreamActorId",
17026 ];
17027
17028 #[allow(clippy::enum_variant_names)]
17029 enum GeneratedField {
17030 ActorId,
17031 UpstreamFragmentId,
17032 NewUpstreamFragmentId,
17033 AddedUpstreamActors,
17034 RemovedUpstreamActorId,
17035 }
17036 impl<'de> serde::Deserialize<'de> for GeneratedField {
17037 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17038 where
17039 D: serde::Deserializer<'de>,
17040 {
17041 struct GeneratedVisitor;
17042
17043 impl serde::de::Visitor<'_> for GeneratedVisitor {
17044 type Value = GeneratedField;
17045
17046 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17047 write!(formatter, "expected one of: {:?}", &FIELDS)
17048 }
17049
17050 #[allow(unused_variables)]
17051 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17052 where
17053 E: serde::de::Error,
17054 {
17055 match value {
17056 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
17057 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
17058 "newUpstreamFragmentId" | "new_upstream_fragment_id" => Ok(GeneratedField::NewUpstreamFragmentId),
17059 "addedUpstreamActors" | "added_upstream_actors" => Ok(GeneratedField::AddedUpstreamActors),
17060 "removedUpstreamActorId" | "removed_upstream_actor_id" => Ok(GeneratedField::RemovedUpstreamActorId),
17061 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17062 }
17063 }
17064 }
17065 deserializer.deserialize_identifier(GeneratedVisitor)
17066 }
17067 }
17068 struct GeneratedVisitor;
17069 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17070 type Value = update_mutation::MergeUpdate;
17071
17072 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17073 formatter.write_str("struct stream_plan.UpdateMutation.MergeUpdate")
17074 }
17075
17076 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::MergeUpdate, V::Error>
17077 where
17078 V: serde::de::MapAccess<'de>,
17079 {
17080 let mut actor_id__ = None;
17081 let mut upstream_fragment_id__ = None;
17082 let mut new_upstream_fragment_id__ = None;
17083 let mut added_upstream_actors__ = None;
17084 let mut removed_upstream_actor_id__ = None;
17085 while let Some(k) = map_.next_key()? {
17086 match k {
17087 GeneratedField::ActorId => {
17088 if actor_id__.is_some() {
17089 return Err(serde::de::Error::duplicate_field("actorId"));
17090 }
17091 actor_id__ =
17092 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17093 ;
17094 }
17095 GeneratedField::UpstreamFragmentId => {
17096 if upstream_fragment_id__.is_some() {
17097 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
17098 }
17099 upstream_fragment_id__ =
17100 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17101 ;
17102 }
17103 GeneratedField::NewUpstreamFragmentId => {
17104 if new_upstream_fragment_id__.is_some() {
17105 return Err(serde::de::Error::duplicate_field("newUpstreamFragmentId"));
17106 }
17107 new_upstream_fragment_id__ =
17108 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17109 ;
17110 }
17111 GeneratedField::AddedUpstreamActors => {
17112 if added_upstream_actors__.is_some() {
17113 return Err(serde::de::Error::duplicate_field("addedUpstreamActors"));
17114 }
17115 added_upstream_actors__ = Some(map_.next_value()?);
17116 }
17117 GeneratedField::RemovedUpstreamActorId => {
17118 if removed_upstream_actor_id__.is_some() {
17119 return Err(serde::de::Error::duplicate_field("removedUpstreamActorId"));
17120 }
17121 removed_upstream_actor_id__ =
17122 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17123 .into_iter().map(|x| x.0).collect())
17124 ;
17125 }
17126 }
17127 }
17128 Ok(update_mutation::MergeUpdate {
17129 actor_id: actor_id__.unwrap_or_default(),
17130 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
17131 new_upstream_fragment_id: new_upstream_fragment_id__,
17132 added_upstream_actors: added_upstream_actors__.unwrap_or_default(),
17133 removed_upstream_actor_id: removed_upstream_actor_id__.unwrap_or_default(),
17134 })
17135 }
17136 }
17137 deserializer.deserialize_struct("stream_plan.UpdateMutation.MergeUpdate", FIELDS, GeneratedVisitor)
17138 }
17139}
17140impl serde::Serialize for UpstreamSinkInfo {
17141 #[allow(deprecated)]
17142 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17143 where
17144 S: serde::Serializer,
17145 {
17146 use serde::ser::SerializeStruct;
17147 let mut len = 0;
17148 if self.upstream_fragment_id != 0 {
17149 len += 1;
17150 }
17151 if !self.sink_output_schema.is_empty() {
17152 len += 1;
17153 }
17154 if !self.project_exprs.is_empty() {
17155 len += 1;
17156 }
17157 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkInfo", len)?;
17158 if self.upstream_fragment_id != 0 {
17159 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
17160 }
17161 if !self.sink_output_schema.is_empty() {
17162 struct_ser.serialize_field("sinkOutputSchema", &self.sink_output_schema)?;
17163 }
17164 if !self.project_exprs.is_empty() {
17165 struct_ser.serialize_field("projectExprs", &self.project_exprs)?;
17166 }
17167 struct_ser.end()
17168 }
17169}
17170impl<'de> serde::Deserialize<'de> for UpstreamSinkInfo {
17171 #[allow(deprecated)]
17172 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17173 where
17174 D: serde::Deserializer<'de>,
17175 {
17176 const FIELDS: &[&str] = &[
17177 "upstream_fragment_id",
17178 "upstreamFragmentId",
17179 "sink_output_schema",
17180 "sinkOutputSchema",
17181 "project_exprs",
17182 "projectExprs",
17183 ];
17184
17185 #[allow(clippy::enum_variant_names)]
17186 enum GeneratedField {
17187 UpstreamFragmentId,
17188 SinkOutputSchema,
17189 ProjectExprs,
17190 }
17191 impl<'de> serde::Deserialize<'de> for GeneratedField {
17192 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17193 where
17194 D: serde::Deserializer<'de>,
17195 {
17196 struct GeneratedVisitor;
17197
17198 impl serde::de::Visitor<'_> for GeneratedVisitor {
17199 type Value = GeneratedField;
17200
17201 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17202 write!(formatter, "expected one of: {:?}", &FIELDS)
17203 }
17204
17205 #[allow(unused_variables)]
17206 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17207 where
17208 E: serde::de::Error,
17209 {
17210 match value {
17211 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
17212 "sinkOutputSchema" | "sink_output_schema" => Ok(GeneratedField::SinkOutputSchema),
17213 "projectExprs" | "project_exprs" => Ok(GeneratedField::ProjectExprs),
17214 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17215 }
17216 }
17217 }
17218 deserializer.deserialize_identifier(GeneratedVisitor)
17219 }
17220 }
17221 struct GeneratedVisitor;
17222 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17223 type Value = UpstreamSinkInfo;
17224
17225 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17226 formatter.write_str("struct stream_plan.UpstreamSinkInfo")
17227 }
17228
17229 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkInfo, V::Error>
17230 where
17231 V: serde::de::MapAccess<'de>,
17232 {
17233 let mut upstream_fragment_id__ = None;
17234 let mut sink_output_schema__ = None;
17235 let mut project_exprs__ = None;
17236 while let Some(k) = map_.next_key()? {
17237 match k {
17238 GeneratedField::UpstreamFragmentId => {
17239 if upstream_fragment_id__.is_some() {
17240 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
17241 }
17242 upstream_fragment_id__ =
17243 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17244 ;
17245 }
17246 GeneratedField::SinkOutputSchema => {
17247 if sink_output_schema__.is_some() {
17248 return Err(serde::de::Error::duplicate_field("sinkOutputSchema"));
17249 }
17250 sink_output_schema__ = Some(map_.next_value()?);
17251 }
17252 GeneratedField::ProjectExprs => {
17253 if project_exprs__.is_some() {
17254 return Err(serde::de::Error::duplicate_field("projectExprs"));
17255 }
17256 project_exprs__ = Some(map_.next_value()?);
17257 }
17258 }
17259 }
17260 Ok(UpstreamSinkInfo {
17261 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
17262 sink_output_schema: sink_output_schema__.unwrap_or_default(),
17263 project_exprs: project_exprs__.unwrap_or_default(),
17264 })
17265 }
17266 }
17267 deserializer.deserialize_struct("stream_plan.UpstreamSinkInfo", FIELDS, GeneratedVisitor)
17268 }
17269}
17270impl serde::Serialize for UpstreamSinkUnionNode {
17271 #[allow(deprecated)]
17272 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17273 where
17274 S: serde::Serializer,
17275 {
17276 use serde::ser::SerializeStruct;
17277 let mut len = 0;
17278 if !self.init_upstreams.is_empty() {
17279 len += 1;
17280 }
17281 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkUnionNode", len)?;
17282 if !self.init_upstreams.is_empty() {
17283 struct_ser.serialize_field("initUpstreams", &self.init_upstreams)?;
17284 }
17285 struct_ser.end()
17286 }
17287}
17288impl<'de> serde::Deserialize<'de> for UpstreamSinkUnionNode {
17289 #[allow(deprecated)]
17290 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17291 where
17292 D: serde::Deserializer<'de>,
17293 {
17294 const FIELDS: &[&str] = &[
17295 "init_upstreams",
17296 "initUpstreams",
17297 ];
17298
17299 #[allow(clippy::enum_variant_names)]
17300 enum GeneratedField {
17301 InitUpstreams,
17302 }
17303 impl<'de> serde::Deserialize<'de> for GeneratedField {
17304 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17305 where
17306 D: serde::Deserializer<'de>,
17307 {
17308 struct GeneratedVisitor;
17309
17310 impl serde::de::Visitor<'_> for GeneratedVisitor {
17311 type Value = GeneratedField;
17312
17313 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17314 write!(formatter, "expected one of: {:?}", &FIELDS)
17315 }
17316
17317 #[allow(unused_variables)]
17318 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17319 where
17320 E: serde::de::Error,
17321 {
17322 match value {
17323 "initUpstreams" | "init_upstreams" => Ok(GeneratedField::InitUpstreams),
17324 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17325 }
17326 }
17327 }
17328 deserializer.deserialize_identifier(GeneratedVisitor)
17329 }
17330 }
17331 struct GeneratedVisitor;
17332 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17333 type Value = UpstreamSinkUnionNode;
17334
17335 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17336 formatter.write_str("struct stream_plan.UpstreamSinkUnionNode")
17337 }
17338
17339 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkUnionNode, V::Error>
17340 where
17341 V: serde::de::MapAccess<'de>,
17342 {
17343 let mut init_upstreams__ = None;
17344 while let Some(k) = map_.next_key()? {
17345 match k {
17346 GeneratedField::InitUpstreams => {
17347 if init_upstreams__.is_some() {
17348 return Err(serde::de::Error::duplicate_field("initUpstreams"));
17349 }
17350 init_upstreams__ = Some(map_.next_value()?);
17351 }
17352 }
17353 }
17354 Ok(UpstreamSinkUnionNode {
17355 init_upstreams: init_upstreams__.unwrap_or_default(),
17356 })
17357 }
17358 }
17359 deserializer.deserialize_struct("stream_plan.UpstreamSinkUnionNode", FIELDS, GeneratedVisitor)
17360 }
17361}
17362impl serde::Serialize for ValuesNode {
17363 #[allow(deprecated)]
17364 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17365 where
17366 S: serde::Serializer,
17367 {
17368 use serde::ser::SerializeStruct;
17369 let mut len = 0;
17370 if !self.tuples.is_empty() {
17371 len += 1;
17372 }
17373 if !self.fields.is_empty() {
17374 len += 1;
17375 }
17376 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode", len)?;
17377 if !self.tuples.is_empty() {
17378 struct_ser.serialize_field("tuples", &self.tuples)?;
17379 }
17380 if !self.fields.is_empty() {
17381 struct_ser.serialize_field("fields", &self.fields)?;
17382 }
17383 struct_ser.end()
17384 }
17385}
17386impl<'de> serde::Deserialize<'de> for ValuesNode {
17387 #[allow(deprecated)]
17388 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17389 where
17390 D: serde::Deserializer<'de>,
17391 {
17392 const FIELDS: &[&str] = &[
17393 "tuples",
17394 "fields",
17395 ];
17396
17397 #[allow(clippy::enum_variant_names)]
17398 enum GeneratedField {
17399 Tuples,
17400 Fields,
17401 }
17402 impl<'de> serde::Deserialize<'de> for GeneratedField {
17403 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17404 where
17405 D: serde::Deserializer<'de>,
17406 {
17407 struct GeneratedVisitor;
17408
17409 impl serde::de::Visitor<'_> for GeneratedVisitor {
17410 type Value = GeneratedField;
17411
17412 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17413 write!(formatter, "expected one of: {:?}", &FIELDS)
17414 }
17415
17416 #[allow(unused_variables)]
17417 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17418 where
17419 E: serde::de::Error,
17420 {
17421 match value {
17422 "tuples" => Ok(GeneratedField::Tuples),
17423 "fields" => Ok(GeneratedField::Fields),
17424 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17425 }
17426 }
17427 }
17428 deserializer.deserialize_identifier(GeneratedVisitor)
17429 }
17430 }
17431 struct GeneratedVisitor;
17432 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17433 type Value = ValuesNode;
17434
17435 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17436 formatter.write_str("struct stream_plan.ValuesNode")
17437 }
17438
17439 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
17440 where
17441 V: serde::de::MapAccess<'de>,
17442 {
17443 let mut tuples__ = None;
17444 let mut fields__ = None;
17445 while let Some(k) = map_.next_key()? {
17446 match k {
17447 GeneratedField::Tuples => {
17448 if tuples__.is_some() {
17449 return Err(serde::de::Error::duplicate_field("tuples"));
17450 }
17451 tuples__ = Some(map_.next_value()?);
17452 }
17453 GeneratedField::Fields => {
17454 if fields__.is_some() {
17455 return Err(serde::de::Error::duplicate_field("fields"));
17456 }
17457 fields__ = Some(map_.next_value()?);
17458 }
17459 }
17460 }
17461 Ok(ValuesNode {
17462 tuples: tuples__.unwrap_or_default(),
17463 fields: fields__.unwrap_or_default(),
17464 })
17465 }
17466 }
17467 deserializer.deserialize_struct("stream_plan.ValuesNode", FIELDS, GeneratedVisitor)
17468 }
17469}
17470impl serde::Serialize for values_node::ExprTuple {
17471 #[allow(deprecated)]
17472 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17473 where
17474 S: serde::Serializer,
17475 {
17476 use serde::ser::SerializeStruct;
17477 let mut len = 0;
17478 if !self.cells.is_empty() {
17479 len += 1;
17480 }
17481 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode.ExprTuple", len)?;
17482 if !self.cells.is_empty() {
17483 struct_ser.serialize_field("cells", &self.cells)?;
17484 }
17485 struct_ser.end()
17486 }
17487}
17488impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
17489 #[allow(deprecated)]
17490 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17491 where
17492 D: serde::Deserializer<'de>,
17493 {
17494 const FIELDS: &[&str] = &[
17495 "cells",
17496 ];
17497
17498 #[allow(clippy::enum_variant_names)]
17499 enum GeneratedField {
17500 Cells,
17501 }
17502 impl<'de> serde::Deserialize<'de> for GeneratedField {
17503 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17504 where
17505 D: serde::Deserializer<'de>,
17506 {
17507 struct GeneratedVisitor;
17508
17509 impl serde::de::Visitor<'_> for GeneratedVisitor {
17510 type Value = GeneratedField;
17511
17512 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17513 write!(formatter, "expected one of: {:?}", &FIELDS)
17514 }
17515
17516 #[allow(unused_variables)]
17517 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17518 where
17519 E: serde::de::Error,
17520 {
17521 match value {
17522 "cells" => Ok(GeneratedField::Cells),
17523 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17524 }
17525 }
17526 }
17527 deserializer.deserialize_identifier(GeneratedVisitor)
17528 }
17529 }
17530 struct GeneratedVisitor;
17531 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17532 type Value = values_node::ExprTuple;
17533
17534 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17535 formatter.write_str("struct stream_plan.ValuesNode.ExprTuple")
17536 }
17537
17538 fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
17539 where
17540 V: serde::de::MapAccess<'de>,
17541 {
17542 let mut cells__ = None;
17543 while let Some(k) = map_.next_key()? {
17544 match k {
17545 GeneratedField::Cells => {
17546 if cells__.is_some() {
17547 return Err(serde::de::Error::duplicate_field("cells"));
17548 }
17549 cells__ = Some(map_.next_value()?);
17550 }
17551 }
17552 }
17553 Ok(values_node::ExprTuple {
17554 cells: cells__.unwrap_or_default(),
17555 })
17556 }
17557 }
17558 deserializer.deserialize_struct("stream_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
17559 }
17560}
17561impl serde::Serialize for VectorIndexLookupJoinNode {
17562 #[allow(deprecated)]
17563 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17564 where
17565 S: serde::Serializer,
17566 {
17567 use serde::ser::SerializeStruct;
17568 let mut len = 0;
17569 if self.reader_desc.is_some() {
17570 len += 1;
17571 }
17572 if self.vector_column_idx != 0 {
17573 len += 1;
17574 }
17575 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexLookupJoinNode", len)?;
17576 if let Some(v) = self.reader_desc.as_ref() {
17577 struct_ser.serialize_field("readerDesc", v)?;
17578 }
17579 if self.vector_column_idx != 0 {
17580 struct_ser.serialize_field("vectorColumnIdx", &self.vector_column_idx)?;
17581 }
17582 struct_ser.end()
17583 }
17584}
17585impl<'de> serde::Deserialize<'de> for VectorIndexLookupJoinNode {
17586 #[allow(deprecated)]
17587 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17588 where
17589 D: serde::Deserializer<'de>,
17590 {
17591 const FIELDS: &[&str] = &[
17592 "reader_desc",
17593 "readerDesc",
17594 "vector_column_idx",
17595 "vectorColumnIdx",
17596 ];
17597
17598 #[allow(clippy::enum_variant_names)]
17599 enum GeneratedField {
17600 ReaderDesc,
17601 VectorColumnIdx,
17602 }
17603 impl<'de> serde::Deserialize<'de> for GeneratedField {
17604 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17605 where
17606 D: serde::Deserializer<'de>,
17607 {
17608 struct GeneratedVisitor;
17609
17610 impl serde::de::Visitor<'_> for GeneratedVisitor {
17611 type Value = GeneratedField;
17612
17613 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17614 write!(formatter, "expected one of: {:?}", &FIELDS)
17615 }
17616
17617 #[allow(unused_variables)]
17618 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17619 where
17620 E: serde::de::Error,
17621 {
17622 match value {
17623 "readerDesc" | "reader_desc" => Ok(GeneratedField::ReaderDesc),
17624 "vectorColumnIdx" | "vector_column_idx" => Ok(GeneratedField::VectorColumnIdx),
17625 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17626 }
17627 }
17628 }
17629 deserializer.deserialize_identifier(GeneratedVisitor)
17630 }
17631 }
17632 struct GeneratedVisitor;
17633 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17634 type Value = VectorIndexLookupJoinNode;
17635
17636 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17637 formatter.write_str("struct stream_plan.VectorIndexLookupJoinNode")
17638 }
17639
17640 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexLookupJoinNode, V::Error>
17641 where
17642 V: serde::de::MapAccess<'de>,
17643 {
17644 let mut reader_desc__ = None;
17645 let mut vector_column_idx__ = None;
17646 while let Some(k) = map_.next_key()? {
17647 match k {
17648 GeneratedField::ReaderDesc => {
17649 if reader_desc__.is_some() {
17650 return Err(serde::de::Error::duplicate_field("readerDesc"));
17651 }
17652 reader_desc__ = map_.next_value()?;
17653 }
17654 GeneratedField::VectorColumnIdx => {
17655 if vector_column_idx__.is_some() {
17656 return Err(serde::de::Error::duplicate_field("vectorColumnIdx"));
17657 }
17658 vector_column_idx__ =
17659 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17660 ;
17661 }
17662 }
17663 }
17664 Ok(VectorIndexLookupJoinNode {
17665 reader_desc: reader_desc__,
17666 vector_column_idx: vector_column_idx__.unwrap_or_default(),
17667 })
17668 }
17669 }
17670 deserializer.deserialize_struct("stream_plan.VectorIndexLookupJoinNode", FIELDS, GeneratedVisitor)
17671 }
17672}
17673impl serde::Serialize for VectorIndexWriteNode {
17674 #[allow(deprecated)]
17675 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17676 where
17677 S: serde::Serializer,
17678 {
17679 use serde::ser::SerializeStruct;
17680 let mut len = 0;
17681 if self.table.is_some() {
17682 len += 1;
17683 }
17684 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexWriteNode", len)?;
17685 if let Some(v) = self.table.as_ref() {
17686 struct_ser.serialize_field("table", v)?;
17687 }
17688 struct_ser.end()
17689 }
17690}
17691impl<'de> serde::Deserialize<'de> for VectorIndexWriteNode {
17692 #[allow(deprecated)]
17693 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17694 where
17695 D: serde::Deserializer<'de>,
17696 {
17697 const FIELDS: &[&str] = &[
17698 "table",
17699 ];
17700
17701 #[allow(clippy::enum_variant_names)]
17702 enum GeneratedField {
17703 Table,
17704 }
17705 impl<'de> serde::Deserialize<'de> for GeneratedField {
17706 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17707 where
17708 D: serde::Deserializer<'de>,
17709 {
17710 struct GeneratedVisitor;
17711
17712 impl serde::de::Visitor<'_> for GeneratedVisitor {
17713 type Value = GeneratedField;
17714
17715 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17716 write!(formatter, "expected one of: {:?}", &FIELDS)
17717 }
17718
17719 #[allow(unused_variables)]
17720 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17721 where
17722 E: serde::de::Error,
17723 {
17724 match value {
17725 "table" => Ok(GeneratedField::Table),
17726 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17727 }
17728 }
17729 }
17730 deserializer.deserialize_identifier(GeneratedVisitor)
17731 }
17732 }
17733 struct GeneratedVisitor;
17734 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17735 type Value = VectorIndexWriteNode;
17736
17737 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17738 formatter.write_str("struct stream_plan.VectorIndexWriteNode")
17739 }
17740
17741 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexWriteNode, V::Error>
17742 where
17743 V: serde::de::MapAccess<'de>,
17744 {
17745 let mut table__ = None;
17746 while let Some(k) = map_.next_key()? {
17747 match k {
17748 GeneratedField::Table => {
17749 if table__.is_some() {
17750 return Err(serde::de::Error::duplicate_field("table"));
17751 }
17752 table__ = map_.next_value()?;
17753 }
17754 }
17755 }
17756 Ok(VectorIndexWriteNode {
17757 table: table__,
17758 })
17759 }
17760 }
17761 deserializer.deserialize_struct("stream_plan.VectorIndexWriteNode", FIELDS, GeneratedVisitor)
17762 }
17763}
17764impl serde::Serialize for Watermark {
17765 #[allow(deprecated)]
17766 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17767 where
17768 S: serde::Serializer,
17769 {
17770 use serde::ser::SerializeStruct;
17771 let mut len = 0;
17772 if self.column.is_some() {
17773 len += 1;
17774 }
17775 if self.val.is_some() {
17776 len += 1;
17777 }
17778 let mut struct_ser = serializer.serialize_struct("stream_plan.Watermark", len)?;
17779 if let Some(v) = self.column.as_ref() {
17780 struct_ser.serialize_field("column", v)?;
17781 }
17782 if let Some(v) = self.val.as_ref() {
17783 struct_ser.serialize_field("val", v)?;
17784 }
17785 struct_ser.end()
17786 }
17787}
17788impl<'de> serde::Deserialize<'de> for Watermark {
17789 #[allow(deprecated)]
17790 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17791 where
17792 D: serde::Deserializer<'de>,
17793 {
17794 const FIELDS: &[&str] = &[
17795 "column",
17796 "val",
17797 ];
17798
17799 #[allow(clippy::enum_variant_names)]
17800 enum GeneratedField {
17801 Column,
17802 Val,
17803 }
17804 impl<'de> serde::Deserialize<'de> for GeneratedField {
17805 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17806 where
17807 D: serde::Deserializer<'de>,
17808 {
17809 struct GeneratedVisitor;
17810
17811 impl serde::de::Visitor<'_> for GeneratedVisitor {
17812 type Value = GeneratedField;
17813
17814 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17815 write!(formatter, "expected one of: {:?}", &FIELDS)
17816 }
17817
17818 #[allow(unused_variables)]
17819 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17820 where
17821 E: serde::de::Error,
17822 {
17823 match value {
17824 "column" => Ok(GeneratedField::Column),
17825 "val" => Ok(GeneratedField::Val),
17826 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17827 }
17828 }
17829 }
17830 deserializer.deserialize_identifier(GeneratedVisitor)
17831 }
17832 }
17833 struct GeneratedVisitor;
17834 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17835 type Value = Watermark;
17836
17837 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17838 formatter.write_str("struct stream_plan.Watermark")
17839 }
17840
17841 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Watermark, V::Error>
17842 where
17843 V: serde::de::MapAccess<'de>,
17844 {
17845 let mut column__ = None;
17846 let mut val__ = None;
17847 while let Some(k) = map_.next_key()? {
17848 match k {
17849 GeneratedField::Column => {
17850 if column__.is_some() {
17851 return Err(serde::de::Error::duplicate_field("column"));
17852 }
17853 column__ = map_.next_value()?;
17854 }
17855 GeneratedField::Val => {
17856 if val__.is_some() {
17857 return Err(serde::de::Error::duplicate_field("val"));
17858 }
17859 val__ = map_.next_value()?;
17860 }
17861 }
17862 }
17863 Ok(Watermark {
17864 column: column__,
17865 val: val__,
17866 })
17867 }
17868 }
17869 deserializer.deserialize_struct("stream_plan.Watermark", FIELDS, GeneratedVisitor)
17870 }
17871}
17872impl serde::Serialize for WatermarkFilterNode {
17873 #[allow(deprecated)]
17874 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17875 where
17876 S: serde::Serializer,
17877 {
17878 use serde::ser::SerializeStruct;
17879 let mut len = 0;
17880 if !self.watermark_descs.is_empty() {
17881 len += 1;
17882 }
17883 if !self.tables.is_empty() {
17884 len += 1;
17885 }
17886 let mut struct_ser = serializer.serialize_struct("stream_plan.WatermarkFilterNode", len)?;
17887 if !self.watermark_descs.is_empty() {
17888 struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
17889 }
17890 if !self.tables.is_empty() {
17891 struct_ser.serialize_field("tables", &self.tables)?;
17892 }
17893 struct_ser.end()
17894 }
17895}
17896impl<'de> serde::Deserialize<'de> for WatermarkFilterNode {
17897 #[allow(deprecated)]
17898 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17899 where
17900 D: serde::Deserializer<'de>,
17901 {
17902 const FIELDS: &[&str] = &[
17903 "watermark_descs",
17904 "watermarkDescs",
17905 "tables",
17906 ];
17907
17908 #[allow(clippy::enum_variant_names)]
17909 enum GeneratedField {
17910 WatermarkDescs,
17911 Tables,
17912 }
17913 impl<'de> serde::Deserialize<'de> for GeneratedField {
17914 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17915 where
17916 D: serde::Deserializer<'de>,
17917 {
17918 struct GeneratedVisitor;
17919
17920 impl serde::de::Visitor<'_> for GeneratedVisitor {
17921 type Value = GeneratedField;
17922
17923 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17924 write!(formatter, "expected one of: {:?}", &FIELDS)
17925 }
17926
17927 #[allow(unused_variables)]
17928 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17929 where
17930 E: serde::de::Error,
17931 {
17932 match value {
17933 "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
17934 "tables" => Ok(GeneratedField::Tables),
17935 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17936 }
17937 }
17938 }
17939 deserializer.deserialize_identifier(GeneratedVisitor)
17940 }
17941 }
17942 struct GeneratedVisitor;
17943 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17944 type Value = WatermarkFilterNode;
17945
17946 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17947 formatter.write_str("struct stream_plan.WatermarkFilterNode")
17948 }
17949
17950 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkFilterNode, V::Error>
17951 where
17952 V: serde::de::MapAccess<'de>,
17953 {
17954 let mut watermark_descs__ = None;
17955 let mut tables__ = None;
17956 while let Some(k) = map_.next_key()? {
17957 match k {
17958 GeneratedField::WatermarkDescs => {
17959 if watermark_descs__.is_some() {
17960 return Err(serde::de::Error::duplicate_field("watermarkDescs"));
17961 }
17962 watermark_descs__ = Some(map_.next_value()?);
17963 }
17964 GeneratedField::Tables => {
17965 if tables__.is_some() {
17966 return Err(serde::de::Error::duplicate_field("tables"));
17967 }
17968 tables__ = Some(map_.next_value()?);
17969 }
17970 }
17971 }
17972 Ok(WatermarkFilterNode {
17973 watermark_descs: watermark_descs__.unwrap_or_default(),
17974 tables: tables__.unwrap_or_default(),
17975 })
17976 }
17977 }
17978 deserializer.deserialize_struct("stream_plan.WatermarkFilterNode", FIELDS, GeneratedVisitor)
17979 }
17980}