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 if !self.backfill_adaptive_parallelism_strategy.is_empty() {
12416 len += 1;
12417 }
12418 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamContext", len)?;
12419 if !self.timezone.is_empty() {
12420 struct_ser.serialize_field("timezone", &self.timezone)?;
12421 }
12422 if !self.config_override.is_empty() {
12423 struct_ser.serialize_field("configOverride", &self.config_override)?;
12424 }
12425 if !self.adaptive_parallelism_strategy.is_empty() {
12426 struct_ser.serialize_field("adaptiveParallelismStrategy", &self.adaptive_parallelism_strategy)?;
12427 }
12428 if !self.backfill_adaptive_parallelism_strategy.is_empty() {
12429 struct_ser.serialize_field("backfillAdaptiveParallelismStrategy", &self.backfill_adaptive_parallelism_strategy)?;
12430 }
12431 struct_ser.end()
12432 }
12433}
12434impl<'de> serde::Deserialize<'de> for StreamContext {
12435 #[allow(deprecated)]
12436 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12437 where
12438 D: serde::Deserializer<'de>,
12439 {
12440 const FIELDS: &[&str] = &[
12441 "timezone",
12442 "config_override",
12443 "configOverride",
12444 "adaptive_parallelism_strategy",
12445 "adaptiveParallelismStrategy",
12446 "backfill_adaptive_parallelism_strategy",
12447 "backfillAdaptiveParallelismStrategy",
12448 ];
12449
12450 #[allow(clippy::enum_variant_names)]
12451 enum GeneratedField {
12452 Timezone,
12453 ConfigOverride,
12454 AdaptiveParallelismStrategy,
12455 BackfillAdaptiveParallelismStrategy,
12456 }
12457 impl<'de> serde::Deserialize<'de> for GeneratedField {
12458 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12459 where
12460 D: serde::Deserializer<'de>,
12461 {
12462 struct GeneratedVisitor;
12463
12464 impl serde::de::Visitor<'_> for GeneratedVisitor {
12465 type Value = GeneratedField;
12466
12467 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12468 write!(formatter, "expected one of: {:?}", &FIELDS)
12469 }
12470
12471 #[allow(unused_variables)]
12472 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12473 where
12474 E: serde::de::Error,
12475 {
12476 match value {
12477 "timezone" => Ok(GeneratedField::Timezone),
12478 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
12479 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
12480 "backfillAdaptiveParallelismStrategy" | "backfill_adaptive_parallelism_strategy" => Ok(GeneratedField::BackfillAdaptiveParallelismStrategy),
12481 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12482 }
12483 }
12484 }
12485 deserializer.deserialize_identifier(GeneratedVisitor)
12486 }
12487 }
12488 struct GeneratedVisitor;
12489 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12490 type Value = StreamContext;
12491
12492 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12493 formatter.write_str("struct stream_plan.StreamContext")
12494 }
12495
12496 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamContext, V::Error>
12497 where
12498 V: serde::de::MapAccess<'de>,
12499 {
12500 let mut timezone__ = None;
12501 let mut config_override__ = None;
12502 let mut adaptive_parallelism_strategy__ = None;
12503 let mut backfill_adaptive_parallelism_strategy__ = None;
12504 while let Some(k) = map_.next_key()? {
12505 match k {
12506 GeneratedField::Timezone => {
12507 if timezone__.is_some() {
12508 return Err(serde::de::Error::duplicate_field("timezone"));
12509 }
12510 timezone__ = Some(map_.next_value()?);
12511 }
12512 GeneratedField::ConfigOverride => {
12513 if config_override__.is_some() {
12514 return Err(serde::de::Error::duplicate_field("configOverride"));
12515 }
12516 config_override__ = Some(map_.next_value()?);
12517 }
12518 GeneratedField::AdaptiveParallelismStrategy => {
12519 if adaptive_parallelism_strategy__.is_some() {
12520 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
12521 }
12522 adaptive_parallelism_strategy__ = Some(map_.next_value()?);
12523 }
12524 GeneratedField::BackfillAdaptiveParallelismStrategy => {
12525 if backfill_adaptive_parallelism_strategy__.is_some() {
12526 return Err(serde::de::Error::duplicate_field("backfillAdaptiveParallelismStrategy"));
12527 }
12528 backfill_adaptive_parallelism_strategy__ = Some(map_.next_value()?);
12529 }
12530 }
12531 }
12532 Ok(StreamContext {
12533 timezone: timezone__.unwrap_or_default(),
12534 config_override: config_override__.unwrap_or_default(),
12535 adaptive_parallelism_strategy: adaptive_parallelism_strategy__.unwrap_or_default(),
12536 backfill_adaptive_parallelism_strategy: backfill_adaptive_parallelism_strategy__.unwrap_or_default(),
12537 })
12538 }
12539 }
12540 deserializer.deserialize_struct("stream_plan.StreamContext", FIELDS, GeneratedVisitor)
12541 }
12542}
12543impl serde::Serialize for StreamFragmentGraph {
12544 #[allow(deprecated)]
12545 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12546 where
12547 S: serde::Serializer,
12548 {
12549 use serde::ser::SerializeStruct;
12550 let mut len = 0;
12551 if !self.fragments.is_empty() {
12552 len += 1;
12553 }
12554 if !self.edges.is_empty() {
12555 len += 1;
12556 }
12557 if !self.dependent_table_ids.is_empty() {
12558 len += 1;
12559 }
12560 if self.table_ids_cnt != 0 {
12561 len += 1;
12562 }
12563 if self.ctx.is_some() {
12564 len += 1;
12565 }
12566 if self.parallelism.is_some() {
12567 len += 1;
12568 }
12569 if self.backfill_parallelism.is_some() {
12570 len += 1;
12571 }
12572 if self.max_parallelism != 0 {
12573 len += 1;
12574 }
12575 if self.backfill_order.is_some() {
12576 len += 1;
12577 }
12578 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph", len)?;
12579 if !self.fragments.is_empty() {
12580 struct_ser.serialize_field("fragments", &self.fragments)?;
12581 }
12582 if !self.edges.is_empty() {
12583 struct_ser.serialize_field("edges", &self.edges)?;
12584 }
12585 if !self.dependent_table_ids.is_empty() {
12586 struct_ser.serialize_field("dependentTableIds", &self.dependent_table_ids)?;
12587 }
12588 if self.table_ids_cnt != 0 {
12589 struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
12590 }
12591 if let Some(v) = self.ctx.as_ref() {
12592 struct_ser.serialize_field("ctx", v)?;
12593 }
12594 if let Some(v) = self.parallelism.as_ref() {
12595 struct_ser.serialize_field("parallelism", v)?;
12596 }
12597 if let Some(v) = self.backfill_parallelism.as_ref() {
12598 struct_ser.serialize_field("backfillParallelism", v)?;
12599 }
12600 if self.max_parallelism != 0 {
12601 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
12602 }
12603 if let Some(v) = self.backfill_order.as_ref() {
12604 struct_ser.serialize_field("backfillOrder", v)?;
12605 }
12606 struct_ser.end()
12607 }
12608}
12609impl<'de> serde::Deserialize<'de> for StreamFragmentGraph {
12610 #[allow(deprecated)]
12611 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12612 where
12613 D: serde::Deserializer<'de>,
12614 {
12615 const FIELDS: &[&str] = &[
12616 "fragments",
12617 "edges",
12618 "dependent_table_ids",
12619 "dependentTableIds",
12620 "table_ids_cnt",
12621 "tableIdsCnt",
12622 "ctx",
12623 "parallelism",
12624 "backfill_parallelism",
12625 "backfillParallelism",
12626 "max_parallelism",
12627 "maxParallelism",
12628 "backfill_order",
12629 "backfillOrder",
12630 ];
12631
12632 #[allow(clippy::enum_variant_names)]
12633 enum GeneratedField {
12634 Fragments,
12635 Edges,
12636 DependentTableIds,
12637 TableIdsCnt,
12638 Ctx,
12639 Parallelism,
12640 BackfillParallelism,
12641 MaxParallelism,
12642 BackfillOrder,
12643 }
12644 impl<'de> serde::Deserialize<'de> for GeneratedField {
12645 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12646 where
12647 D: serde::Deserializer<'de>,
12648 {
12649 struct GeneratedVisitor;
12650
12651 impl serde::de::Visitor<'_> for GeneratedVisitor {
12652 type Value = GeneratedField;
12653
12654 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12655 write!(formatter, "expected one of: {:?}", &FIELDS)
12656 }
12657
12658 #[allow(unused_variables)]
12659 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12660 where
12661 E: serde::de::Error,
12662 {
12663 match value {
12664 "fragments" => Ok(GeneratedField::Fragments),
12665 "edges" => Ok(GeneratedField::Edges),
12666 "dependentTableIds" | "dependent_table_ids" => Ok(GeneratedField::DependentTableIds),
12667 "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
12668 "ctx" => Ok(GeneratedField::Ctx),
12669 "parallelism" => Ok(GeneratedField::Parallelism),
12670 "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
12671 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
12672 "backfillOrder" | "backfill_order" => Ok(GeneratedField::BackfillOrder),
12673 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12674 }
12675 }
12676 }
12677 deserializer.deserialize_identifier(GeneratedVisitor)
12678 }
12679 }
12680 struct GeneratedVisitor;
12681 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12682 type Value = StreamFragmentGraph;
12683
12684 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12685 formatter.write_str("struct stream_plan.StreamFragmentGraph")
12686 }
12687
12688 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFragmentGraph, V::Error>
12689 where
12690 V: serde::de::MapAccess<'de>,
12691 {
12692 let mut fragments__ = None;
12693 let mut edges__ = None;
12694 let mut dependent_table_ids__ = None;
12695 let mut table_ids_cnt__ = None;
12696 let mut ctx__ = None;
12697 let mut parallelism__ = None;
12698 let mut backfill_parallelism__ = None;
12699 let mut max_parallelism__ = None;
12700 let mut backfill_order__ = None;
12701 while let Some(k) = map_.next_key()? {
12702 match k {
12703 GeneratedField::Fragments => {
12704 if fragments__.is_some() {
12705 return Err(serde::de::Error::duplicate_field("fragments"));
12706 }
12707 fragments__ = Some(
12708 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
12709 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
12710 );
12711 }
12712 GeneratedField::Edges => {
12713 if edges__.is_some() {
12714 return Err(serde::de::Error::duplicate_field("edges"));
12715 }
12716 edges__ = Some(map_.next_value()?);
12717 }
12718 GeneratedField::DependentTableIds => {
12719 if dependent_table_ids__.is_some() {
12720 return Err(serde::de::Error::duplicate_field("dependentTableIds"));
12721 }
12722 dependent_table_ids__ =
12723 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12724 .into_iter().map(|x| x.0).collect())
12725 ;
12726 }
12727 GeneratedField::TableIdsCnt => {
12728 if table_ids_cnt__.is_some() {
12729 return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
12730 }
12731 table_ids_cnt__ =
12732 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12733 ;
12734 }
12735 GeneratedField::Ctx => {
12736 if ctx__.is_some() {
12737 return Err(serde::de::Error::duplicate_field("ctx"));
12738 }
12739 ctx__ = map_.next_value()?;
12740 }
12741 GeneratedField::Parallelism => {
12742 if parallelism__.is_some() {
12743 return Err(serde::de::Error::duplicate_field("parallelism"));
12744 }
12745 parallelism__ = map_.next_value()?;
12746 }
12747 GeneratedField::BackfillParallelism => {
12748 if backfill_parallelism__.is_some() {
12749 return Err(serde::de::Error::duplicate_field("backfillParallelism"));
12750 }
12751 backfill_parallelism__ = map_.next_value()?;
12752 }
12753 GeneratedField::MaxParallelism => {
12754 if max_parallelism__.is_some() {
12755 return Err(serde::de::Error::duplicate_field("maxParallelism"));
12756 }
12757 max_parallelism__ =
12758 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12759 ;
12760 }
12761 GeneratedField::BackfillOrder => {
12762 if backfill_order__.is_some() {
12763 return Err(serde::de::Error::duplicate_field("backfillOrder"));
12764 }
12765 backfill_order__ = map_.next_value()?;
12766 }
12767 }
12768 }
12769 Ok(StreamFragmentGraph {
12770 fragments: fragments__.unwrap_or_default(),
12771 edges: edges__.unwrap_or_default(),
12772 dependent_table_ids: dependent_table_ids__.unwrap_or_default(),
12773 table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
12774 ctx: ctx__,
12775 parallelism: parallelism__,
12776 backfill_parallelism: backfill_parallelism__,
12777 max_parallelism: max_parallelism__.unwrap_or_default(),
12778 backfill_order: backfill_order__,
12779 })
12780 }
12781 }
12782 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph", FIELDS, GeneratedVisitor)
12783 }
12784}
12785impl serde::Serialize for stream_fragment_graph::Parallelism {
12786 #[allow(deprecated)]
12787 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12788 where
12789 S: serde::Serializer,
12790 {
12791 use serde::ser::SerializeStruct;
12792 let mut len = 0;
12793 if self.parallelism != 0 {
12794 len += 1;
12795 }
12796 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.Parallelism", len)?;
12797 if self.parallelism != 0 {
12798 #[allow(clippy::needless_borrow)]
12799 #[allow(clippy::needless_borrows_for_generic_args)]
12800 struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
12801 }
12802 struct_ser.end()
12803 }
12804}
12805impl<'de> serde::Deserialize<'de> for stream_fragment_graph::Parallelism {
12806 #[allow(deprecated)]
12807 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12808 where
12809 D: serde::Deserializer<'de>,
12810 {
12811 const FIELDS: &[&str] = &[
12812 "parallelism",
12813 ];
12814
12815 #[allow(clippy::enum_variant_names)]
12816 enum GeneratedField {
12817 Parallelism,
12818 }
12819 impl<'de> serde::Deserialize<'de> for GeneratedField {
12820 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12821 where
12822 D: serde::Deserializer<'de>,
12823 {
12824 struct GeneratedVisitor;
12825
12826 impl serde::de::Visitor<'_> for GeneratedVisitor {
12827 type Value = GeneratedField;
12828
12829 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12830 write!(formatter, "expected one of: {:?}", &FIELDS)
12831 }
12832
12833 #[allow(unused_variables)]
12834 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12835 where
12836 E: serde::de::Error,
12837 {
12838 match value {
12839 "parallelism" => Ok(GeneratedField::Parallelism),
12840 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12841 }
12842 }
12843 }
12844 deserializer.deserialize_identifier(GeneratedVisitor)
12845 }
12846 }
12847 struct GeneratedVisitor;
12848 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12849 type Value = stream_fragment_graph::Parallelism;
12850
12851 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12852 formatter.write_str("struct stream_plan.StreamFragmentGraph.Parallelism")
12853 }
12854
12855 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::Parallelism, V::Error>
12856 where
12857 V: serde::de::MapAccess<'de>,
12858 {
12859 let mut parallelism__ = None;
12860 while let Some(k) = map_.next_key()? {
12861 match k {
12862 GeneratedField::Parallelism => {
12863 if parallelism__.is_some() {
12864 return Err(serde::de::Error::duplicate_field("parallelism"));
12865 }
12866 parallelism__ =
12867 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12868 ;
12869 }
12870 }
12871 }
12872 Ok(stream_fragment_graph::Parallelism {
12873 parallelism: parallelism__.unwrap_or_default(),
12874 })
12875 }
12876 }
12877 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.Parallelism", FIELDS, GeneratedVisitor)
12878 }
12879}
12880impl serde::Serialize for stream_fragment_graph::StreamFragment {
12881 #[allow(deprecated)]
12882 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12883 where
12884 S: serde::Serializer,
12885 {
12886 use serde::ser::SerializeStruct;
12887 let mut len = 0;
12888 if self.fragment_id != 0 {
12889 len += 1;
12890 }
12891 if self.node.is_some() {
12892 len += 1;
12893 }
12894 if self.fragment_type_mask != 0 {
12895 len += 1;
12896 }
12897 if self.requires_singleton {
12898 len += 1;
12899 }
12900 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", len)?;
12901 if self.fragment_id != 0 {
12902 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
12903 }
12904 if let Some(v) = self.node.as_ref() {
12905 struct_ser.serialize_field("node", v)?;
12906 }
12907 if self.fragment_type_mask != 0 {
12908 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
12909 }
12910 if self.requires_singleton {
12911 struct_ser.serialize_field("requiresSingleton", &self.requires_singleton)?;
12912 }
12913 struct_ser.end()
12914 }
12915}
12916impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragment {
12917 #[allow(deprecated)]
12918 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12919 where
12920 D: serde::Deserializer<'de>,
12921 {
12922 const FIELDS: &[&str] = &[
12923 "fragment_id",
12924 "fragmentId",
12925 "node",
12926 "fragment_type_mask",
12927 "fragmentTypeMask",
12928 "requires_singleton",
12929 "requiresSingleton",
12930 ];
12931
12932 #[allow(clippy::enum_variant_names)]
12933 enum GeneratedField {
12934 FragmentId,
12935 Node,
12936 FragmentTypeMask,
12937 RequiresSingleton,
12938 }
12939 impl<'de> serde::Deserialize<'de> for GeneratedField {
12940 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12941 where
12942 D: serde::Deserializer<'de>,
12943 {
12944 struct GeneratedVisitor;
12945
12946 impl serde::de::Visitor<'_> for GeneratedVisitor {
12947 type Value = GeneratedField;
12948
12949 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12950 write!(formatter, "expected one of: {:?}", &FIELDS)
12951 }
12952
12953 #[allow(unused_variables)]
12954 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12955 where
12956 E: serde::de::Error,
12957 {
12958 match value {
12959 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
12960 "node" => Ok(GeneratedField::Node),
12961 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
12962 "requiresSingleton" | "requires_singleton" => Ok(GeneratedField::RequiresSingleton),
12963 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12964 }
12965 }
12966 }
12967 deserializer.deserialize_identifier(GeneratedVisitor)
12968 }
12969 }
12970 struct GeneratedVisitor;
12971 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12972 type Value = stream_fragment_graph::StreamFragment;
12973
12974 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12975 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragment")
12976 }
12977
12978 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragment, V::Error>
12979 where
12980 V: serde::de::MapAccess<'de>,
12981 {
12982 let mut fragment_id__ = None;
12983 let mut node__ = None;
12984 let mut fragment_type_mask__ = None;
12985 let mut requires_singleton__ = None;
12986 while let Some(k) = map_.next_key()? {
12987 match k {
12988 GeneratedField::FragmentId => {
12989 if fragment_id__.is_some() {
12990 return Err(serde::de::Error::duplicate_field("fragmentId"));
12991 }
12992 fragment_id__ =
12993 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12994 ;
12995 }
12996 GeneratedField::Node => {
12997 if node__.is_some() {
12998 return Err(serde::de::Error::duplicate_field("node"));
12999 }
13000 node__ = map_.next_value()?;
13001 }
13002 GeneratedField::FragmentTypeMask => {
13003 if fragment_type_mask__.is_some() {
13004 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
13005 }
13006 fragment_type_mask__ =
13007 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13008 ;
13009 }
13010 GeneratedField::RequiresSingleton => {
13011 if requires_singleton__.is_some() {
13012 return Err(serde::de::Error::duplicate_field("requiresSingleton"));
13013 }
13014 requires_singleton__ = Some(map_.next_value()?);
13015 }
13016 }
13017 }
13018 Ok(stream_fragment_graph::StreamFragment {
13019 fragment_id: fragment_id__.unwrap_or_default(),
13020 node: node__,
13021 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
13022 requires_singleton: requires_singleton__.unwrap_or_default(),
13023 })
13024 }
13025 }
13026 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", FIELDS, GeneratedVisitor)
13027 }
13028}
13029impl serde::Serialize for stream_fragment_graph::StreamFragmentEdge {
13030 #[allow(deprecated)]
13031 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13032 where
13033 S: serde::Serializer,
13034 {
13035 use serde::ser::SerializeStruct;
13036 let mut len = 0;
13037 if self.dispatch_strategy.is_some() {
13038 len += 1;
13039 }
13040 if self.link_id != 0 {
13041 len += 1;
13042 }
13043 if self.upstream_id != 0 {
13044 len += 1;
13045 }
13046 if self.downstream_id != 0 {
13047 len += 1;
13048 }
13049 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", len)?;
13050 if let Some(v) = self.dispatch_strategy.as_ref() {
13051 struct_ser.serialize_field("dispatchStrategy", v)?;
13052 }
13053 if self.link_id != 0 {
13054 #[allow(clippy::needless_borrow)]
13055 #[allow(clippy::needless_borrows_for_generic_args)]
13056 struct_ser.serialize_field("linkId", ToString::to_string(&self.link_id).as_str())?;
13057 }
13058 if self.upstream_id != 0 {
13059 struct_ser.serialize_field("upstreamId", &self.upstream_id)?;
13060 }
13061 if self.downstream_id != 0 {
13062 struct_ser.serialize_field("downstreamId", &self.downstream_id)?;
13063 }
13064 struct_ser.end()
13065 }
13066}
13067impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragmentEdge {
13068 #[allow(deprecated)]
13069 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13070 where
13071 D: serde::Deserializer<'de>,
13072 {
13073 const FIELDS: &[&str] = &[
13074 "dispatch_strategy",
13075 "dispatchStrategy",
13076 "link_id",
13077 "linkId",
13078 "upstream_id",
13079 "upstreamId",
13080 "downstream_id",
13081 "downstreamId",
13082 ];
13083
13084 #[allow(clippy::enum_variant_names)]
13085 enum GeneratedField {
13086 DispatchStrategy,
13087 LinkId,
13088 UpstreamId,
13089 DownstreamId,
13090 }
13091 impl<'de> serde::Deserialize<'de> for GeneratedField {
13092 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13093 where
13094 D: serde::Deserializer<'de>,
13095 {
13096 struct GeneratedVisitor;
13097
13098 impl serde::de::Visitor<'_> for GeneratedVisitor {
13099 type Value = GeneratedField;
13100
13101 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13102 write!(formatter, "expected one of: {:?}", &FIELDS)
13103 }
13104
13105 #[allow(unused_variables)]
13106 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13107 where
13108 E: serde::de::Error,
13109 {
13110 match value {
13111 "dispatchStrategy" | "dispatch_strategy" => Ok(GeneratedField::DispatchStrategy),
13112 "linkId" | "link_id" => Ok(GeneratedField::LinkId),
13113 "upstreamId" | "upstream_id" => Ok(GeneratedField::UpstreamId),
13114 "downstreamId" | "downstream_id" => Ok(GeneratedField::DownstreamId),
13115 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13116 }
13117 }
13118 }
13119 deserializer.deserialize_identifier(GeneratedVisitor)
13120 }
13121 }
13122 struct GeneratedVisitor;
13123 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13124 type Value = stream_fragment_graph::StreamFragmentEdge;
13125
13126 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13127 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragmentEdge")
13128 }
13129
13130 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragmentEdge, V::Error>
13131 where
13132 V: serde::de::MapAccess<'de>,
13133 {
13134 let mut dispatch_strategy__ = None;
13135 let mut link_id__ = None;
13136 let mut upstream_id__ = None;
13137 let mut downstream_id__ = None;
13138 while let Some(k) = map_.next_key()? {
13139 match k {
13140 GeneratedField::DispatchStrategy => {
13141 if dispatch_strategy__.is_some() {
13142 return Err(serde::de::Error::duplicate_field("dispatchStrategy"));
13143 }
13144 dispatch_strategy__ = map_.next_value()?;
13145 }
13146 GeneratedField::LinkId => {
13147 if link_id__.is_some() {
13148 return Err(serde::de::Error::duplicate_field("linkId"));
13149 }
13150 link_id__ =
13151 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13152 ;
13153 }
13154 GeneratedField::UpstreamId => {
13155 if upstream_id__.is_some() {
13156 return Err(serde::de::Error::duplicate_field("upstreamId"));
13157 }
13158 upstream_id__ =
13159 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13160 ;
13161 }
13162 GeneratedField::DownstreamId => {
13163 if downstream_id__.is_some() {
13164 return Err(serde::de::Error::duplicate_field("downstreamId"));
13165 }
13166 downstream_id__ =
13167 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13168 ;
13169 }
13170 }
13171 }
13172 Ok(stream_fragment_graph::StreamFragmentEdge {
13173 dispatch_strategy: dispatch_strategy__,
13174 link_id: link_id__.unwrap_or_default(),
13175 upstream_id: upstream_id__.unwrap_or_default(),
13176 downstream_id: downstream_id__.unwrap_or_default(),
13177 })
13178 }
13179 }
13180 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", FIELDS, GeneratedVisitor)
13181 }
13182}
13183impl serde::Serialize for StreamFsFetch {
13184 #[allow(deprecated)]
13185 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13186 where
13187 S: serde::Serializer,
13188 {
13189 use serde::ser::SerializeStruct;
13190 let mut len = 0;
13191 if self.source_id != 0 {
13192 len += 1;
13193 }
13194 if self.state_table.is_some() {
13195 len += 1;
13196 }
13197 if self.row_id_index.is_some() {
13198 len += 1;
13199 }
13200 if !self.columns.is_empty() {
13201 len += 1;
13202 }
13203 if !self.with_properties.is_empty() {
13204 len += 1;
13205 }
13206 if self.info.is_some() {
13207 len += 1;
13208 }
13209 if !self.source_name.is_empty() {
13210 len += 1;
13211 }
13212 if self.rate_limit.is_some() {
13213 len += 1;
13214 }
13215 if !self.secret_refs.is_empty() {
13216 len += 1;
13217 }
13218 if self.refresh_mode.is_some() {
13219 len += 1;
13220 }
13221 if self.associated_table_id.is_some() {
13222 len += 1;
13223 }
13224 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetch", len)?;
13225 if self.source_id != 0 {
13226 struct_ser.serialize_field("sourceId", &self.source_id)?;
13227 }
13228 if let Some(v) = self.state_table.as_ref() {
13229 struct_ser.serialize_field("stateTable", v)?;
13230 }
13231 if let Some(v) = self.row_id_index.as_ref() {
13232 struct_ser.serialize_field("rowIdIndex", v)?;
13233 }
13234 if !self.columns.is_empty() {
13235 struct_ser.serialize_field("columns", &self.columns)?;
13236 }
13237 if !self.with_properties.is_empty() {
13238 struct_ser.serialize_field("withProperties", &self.with_properties)?;
13239 }
13240 if let Some(v) = self.info.as_ref() {
13241 struct_ser.serialize_field("info", v)?;
13242 }
13243 if !self.source_name.is_empty() {
13244 struct_ser.serialize_field("sourceName", &self.source_name)?;
13245 }
13246 if let Some(v) = self.rate_limit.as_ref() {
13247 struct_ser.serialize_field("rateLimit", v)?;
13248 }
13249 if !self.secret_refs.is_empty() {
13250 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
13251 }
13252 if let Some(v) = self.refresh_mode.as_ref() {
13253 struct_ser.serialize_field("refreshMode", v)?;
13254 }
13255 if let Some(v) = self.associated_table_id.as_ref() {
13256 struct_ser.serialize_field("associatedTableId", v)?;
13257 }
13258 struct_ser.end()
13259 }
13260}
13261impl<'de> serde::Deserialize<'de> for StreamFsFetch {
13262 #[allow(deprecated)]
13263 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13264 where
13265 D: serde::Deserializer<'de>,
13266 {
13267 const FIELDS: &[&str] = &[
13268 "source_id",
13269 "sourceId",
13270 "state_table",
13271 "stateTable",
13272 "row_id_index",
13273 "rowIdIndex",
13274 "columns",
13275 "with_properties",
13276 "withProperties",
13277 "info",
13278 "source_name",
13279 "sourceName",
13280 "rate_limit",
13281 "rateLimit",
13282 "secret_refs",
13283 "secretRefs",
13284 "refresh_mode",
13285 "refreshMode",
13286 "associated_table_id",
13287 "associatedTableId",
13288 ];
13289
13290 #[allow(clippy::enum_variant_names)]
13291 enum GeneratedField {
13292 SourceId,
13293 StateTable,
13294 RowIdIndex,
13295 Columns,
13296 WithProperties,
13297 Info,
13298 SourceName,
13299 RateLimit,
13300 SecretRefs,
13301 RefreshMode,
13302 AssociatedTableId,
13303 }
13304 impl<'de> serde::Deserialize<'de> for GeneratedField {
13305 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13306 where
13307 D: serde::Deserializer<'de>,
13308 {
13309 struct GeneratedVisitor;
13310
13311 impl serde::de::Visitor<'_> for GeneratedVisitor {
13312 type Value = GeneratedField;
13313
13314 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13315 write!(formatter, "expected one of: {:?}", &FIELDS)
13316 }
13317
13318 #[allow(unused_variables)]
13319 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13320 where
13321 E: serde::de::Error,
13322 {
13323 match value {
13324 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
13325 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
13326 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
13327 "columns" => Ok(GeneratedField::Columns),
13328 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
13329 "info" => Ok(GeneratedField::Info),
13330 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
13331 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
13332 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
13333 "refreshMode" | "refresh_mode" => Ok(GeneratedField::RefreshMode),
13334 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
13335 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13336 }
13337 }
13338 }
13339 deserializer.deserialize_identifier(GeneratedVisitor)
13340 }
13341 }
13342 struct GeneratedVisitor;
13343 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13344 type Value = StreamFsFetch;
13345
13346 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13347 formatter.write_str("struct stream_plan.StreamFsFetch")
13348 }
13349
13350 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetch, V::Error>
13351 where
13352 V: serde::de::MapAccess<'de>,
13353 {
13354 let mut source_id__ = None;
13355 let mut state_table__ = None;
13356 let mut row_id_index__ = None;
13357 let mut columns__ = None;
13358 let mut with_properties__ = None;
13359 let mut info__ = None;
13360 let mut source_name__ = None;
13361 let mut rate_limit__ = None;
13362 let mut secret_refs__ = None;
13363 let mut refresh_mode__ = None;
13364 let mut associated_table_id__ = None;
13365 while let Some(k) = map_.next_key()? {
13366 match k {
13367 GeneratedField::SourceId => {
13368 if source_id__.is_some() {
13369 return Err(serde::de::Error::duplicate_field("sourceId"));
13370 }
13371 source_id__ =
13372 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13373 ;
13374 }
13375 GeneratedField::StateTable => {
13376 if state_table__.is_some() {
13377 return Err(serde::de::Error::duplicate_field("stateTable"));
13378 }
13379 state_table__ = map_.next_value()?;
13380 }
13381 GeneratedField::RowIdIndex => {
13382 if row_id_index__.is_some() {
13383 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
13384 }
13385 row_id_index__ =
13386 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13387 ;
13388 }
13389 GeneratedField::Columns => {
13390 if columns__.is_some() {
13391 return Err(serde::de::Error::duplicate_field("columns"));
13392 }
13393 columns__ = Some(map_.next_value()?);
13394 }
13395 GeneratedField::WithProperties => {
13396 if with_properties__.is_some() {
13397 return Err(serde::de::Error::duplicate_field("withProperties"));
13398 }
13399 with_properties__ = Some(
13400 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13401 );
13402 }
13403 GeneratedField::Info => {
13404 if info__.is_some() {
13405 return Err(serde::de::Error::duplicate_field("info"));
13406 }
13407 info__ = map_.next_value()?;
13408 }
13409 GeneratedField::SourceName => {
13410 if source_name__.is_some() {
13411 return Err(serde::de::Error::duplicate_field("sourceName"));
13412 }
13413 source_name__ = Some(map_.next_value()?);
13414 }
13415 GeneratedField::RateLimit => {
13416 if rate_limit__.is_some() {
13417 return Err(serde::de::Error::duplicate_field("rateLimit"));
13418 }
13419 rate_limit__ =
13420 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13421 ;
13422 }
13423 GeneratedField::SecretRefs => {
13424 if secret_refs__.is_some() {
13425 return Err(serde::de::Error::duplicate_field("secretRefs"));
13426 }
13427 secret_refs__ = Some(
13428 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13429 );
13430 }
13431 GeneratedField::RefreshMode => {
13432 if refresh_mode__.is_some() {
13433 return Err(serde::de::Error::duplicate_field("refreshMode"));
13434 }
13435 refresh_mode__ = map_.next_value()?;
13436 }
13437 GeneratedField::AssociatedTableId => {
13438 if associated_table_id__.is_some() {
13439 return Err(serde::de::Error::duplicate_field("associatedTableId"));
13440 }
13441 associated_table_id__ =
13442 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13443 ;
13444 }
13445 }
13446 }
13447 Ok(StreamFsFetch {
13448 source_id: source_id__.unwrap_or_default(),
13449 state_table: state_table__,
13450 row_id_index: row_id_index__,
13451 columns: columns__.unwrap_or_default(),
13452 with_properties: with_properties__.unwrap_or_default(),
13453 info: info__,
13454 source_name: source_name__.unwrap_or_default(),
13455 rate_limit: rate_limit__,
13456 secret_refs: secret_refs__.unwrap_or_default(),
13457 refresh_mode: refresh_mode__,
13458 associated_table_id: associated_table_id__,
13459 })
13460 }
13461 }
13462 deserializer.deserialize_struct("stream_plan.StreamFsFetch", FIELDS, GeneratedVisitor)
13463 }
13464}
13465impl serde::Serialize for StreamFsFetchNode {
13466 #[allow(deprecated)]
13467 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13468 where
13469 S: serde::Serializer,
13470 {
13471 use serde::ser::SerializeStruct;
13472 let mut len = 0;
13473 if self.node_inner.is_some() {
13474 len += 1;
13475 }
13476 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetchNode", len)?;
13477 if let Some(v) = self.node_inner.as_ref() {
13478 struct_ser.serialize_field("nodeInner", v)?;
13479 }
13480 struct_ser.end()
13481 }
13482}
13483impl<'de> serde::Deserialize<'de> for StreamFsFetchNode {
13484 #[allow(deprecated)]
13485 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13486 where
13487 D: serde::Deserializer<'de>,
13488 {
13489 const FIELDS: &[&str] = &[
13490 "node_inner",
13491 "nodeInner",
13492 ];
13493
13494 #[allow(clippy::enum_variant_names)]
13495 enum GeneratedField {
13496 NodeInner,
13497 }
13498 impl<'de> serde::Deserialize<'de> for GeneratedField {
13499 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13500 where
13501 D: serde::Deserializer<'de>,
13502 {
13503 struct GeneratedVisitor;
13504
13505 impl serde::de::Visitor<'_> for GeneratedVisitor {
13506 type Value = GeneratedField;
13507
13508 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13509 write!(formatter, "expected one of: {:?}", &FIELDS)
13510 }
13511
13512 #[allow(unused_variables)]
13513 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13514 where
13515 E: serde::de::Error,
13516 {
13517 match value {
13518 "nodeInner" | "node_inner" => Ok(GeneratedField::NodeInner),
13519 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13520 }
13521 }
13522 }
13523 deserializer.deserialize_identifier(GeneratedVisitor)
13524 }
13525 }
13526 struct GeneratedVisitor;
13527 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13528 type Value = StreamFsFetchNode;
13529
13530 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13531 formatter.write_str("struct stream_plan.StreamFsFetchNode")
13532 }
13533
13534 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetchNode, V::Error>
13535 where
13536 V: serde::de::MapAccess<'de>,
13537 {
13538 let mut node_inner__ = None;
13539 while let Some(k) = map_.next_key()? {
13540 match k {
13541 GeneratedField::NodeInner => {
13542 if node_inner__.is_some() {
13543 return Err(serde::de::Error::duplicate_field("nodeInner"));
13544 }
13545 node_inner__ = map_.next_value()?;
13546 }
13547 }
13548 }
13549 Ok(StreamFsFetchNode {
13550 node_inner: node_inner__,
13551 })
13552 }
13553 }
13554 deserializer.deserialize_struct("stream_plan.StreamFsFetchNode", FIELDS, GeneratedVisitor)
13555 }
13556}
13557impl serde::Serialize for StreamMessage {
13558 #[allow(deprecated)]
13559 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13560 where
13561 S: serde::Serializer,
13562 {
13563 use serde::ser::SerializeStruct;
13564 let mut len = 0;
13565 if self.stream_message.is_some() {
13566 len += 1;
13567 }
13568 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessage", len)?;
13569 if let Some(v) = self.stream_message.as_ref() {
13570 match v {
13571 stream_message::StreamMessage::StreamChunk(v) => {
13572 struct_ser.serialize_field("streamChunk", v)?;
13573 }
13574 stream_message::StreamMessage::Barrier(v) => {
13575 struct_ser.serialize_field("barrier", v)?;
13576 }
13577 stream_message::StreamMessage::Watermark(v) => {
13578 struct_ser.serialize_field("watermark", v)?;
13579 }
13580 }
13581 }
13582 struct_ser.end()
13583 }
13584}
13585impl<'de> serde::Deserialize<'de> for StreamMessage {
13586 #[allow(deprecated)]
13587 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13588 where
13589 D: serde::Deserializer<'de>,
13590 {
13591 const FIELDS: &[&str] = &[
13592 "stream_chunk",
13593 "streamChunk",
13594 "barrier",
13595 "watermark",
13596 ];
13597
13598 #[allow(clippy::enum_variant_names)]
13599 enum GeneratedField {
13600 StreamChunk,
13601 Barrier,
13602 Watermark,
13603 }
13604 impl<'de> serde::Deserialize<'de> for GeneratedField {
13605 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13606 where
13607 D: serde::Deserializer<'de>,
13608 {
13609 struct GeneratedVisitor;
13610
13611 impl serde::de::Visitor<'_> for GeneratedVisitor {
13612 type Value = GeneratedField;
13613
13614 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13615 write!(formatter, "expected one of: {:?}", &FIELDS)
13616 }
13617
13618 #[allow(unused_variables)]
13619 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13620 where
13621 E: serde::de::Error,
13622 {
13623 match value {
13624 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
13625 "barrier" => Ok(GeneratedField::Barrier),
13626 "watermark" => Ok(GeneratedField::Watermark),
13627 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13628 }
13629 }
13630 }
13631 deserializer.deserialize_identifier(GeneratedVisitor)
13632 }
13633 }
13634 struct GeneratedVisitor;
13635 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13636 type Value = StreamMessage;
13637
13638 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13639 formatter.write_str("struct stream_plan.StreamMessage")
13640 }
13641
13642 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessage, V::Error>
13643 where
13644 V: serde::de::MapAccess<'de>,
13645 {
13646 let mut stream_message__ = None;
13647 while let Some(k) = map_.next_key()? {
13648 match k {
13649 GeneratedField::StreamChunk => {
13650 if stream_message__.is_some() {
13651 return Err(serde::de::Error::duplicate_field("streamChunk"));
13652 }
13653 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::StreamChunk)
13654;
13655 }
13656 GeneratedField::Barrier => {
13657 if stream_message__.is_some() {
13658 return Err(serde::de::Error::duplicate_field("barrier"));
13659 }
13660 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Barrier)
13661;
13662 }
13663 GeneratedField::Watermark => {
13664 if stream_message__.is_some() {
13665 return Err(serde::de::Error::duplicate_field("watermark"));
13666 }
13667 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Watermark)
13668;
13669 }
13670 }
13671 }
13672 Ok(StreamMessage {
13673 stream_message: stream_message__,
13674 })
13675 }
13676 }
13677 deserializer.deserialize_struct("stream_plan.StreamMessage", FIELDS, GeneratedVisitor)
13678 }
13679}
13680impl serde::Serialize for StreamMessageBatch {
13681 #[allow(deprecated)]
13682 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13683 where
13684 S: serde::Serializer,
13685 {
13686 use serde::ser::SerializeStruct;
13687 let mut len = 0;
13688 if self.stream_message_batch.is_some() {
13689 len += 1;
13690 }
13691 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch", len)?;
13692 if let Some(v) = self.stream_message_batch.as_ref() {
13693 match v {
13694 stream_message_batch::StreamMessageBatch::StreamChunk(v) => {
13695 struct_ser.serialize_field("streamChunk", v)?;
13696 }
13697 stream_message_batch::StreamMessageBatch::BarrierBatch(v) => {
13698 struct_ser.serialize_field("barrierBatch", v)?;
13699 }
13700 stream_message_batch::StreamMessageBatch::Watermark(v) => {
13701 struct_ser.serialize_field("watermark", v)?;
13702 }
13703 }
13704 }
13705 struct_ser.end()
13706 }
13707}
13708impl<'de> serde::Deserialize<'de> for StreamMessageBatch {
13709 #[allow(deprecated)]
13710 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13711 where
13712 D: serde::Deserializer<'de>,
13713 {
13714 const FIELDS: &[&str] = &[
13715 "stream_chunk",
13716 "streamChunk",
13717 "barrier_batch",
13718 "barrierBatch",
13719 "watermark",
13720 ];
13721
13722 #[allow(clippy::enum_variant_names)]
13723 enum GeneratedField {
13724 StreamChunk,
13725 BarrierBatch,
13726 Watermark,
13727 }
13728 impl<'de> serde::Deserialize<'de> for GeneratedField {
13729 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13730 where
13731 D: serde::Deserializer<'de>,
13732 {
13733 struct GeneratedVisitor;
13734
13735 impl serde::de::Visitor<'_> for GeneratedVisitor {
13736 type Value = GeneratedField;
13737
13738 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13739 write!(formatter, "expected one of: {:?}", &FIELDS)
13740 }
13741
13742 #[allow(unused_variables)]
13743 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13744 where
13745 E: serde::de::Error,
13746 {
13747 match value {
13748 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
13749 "barrierBatch" | "barrier_batch" => Ok(GeneratedField::BarrierBatch),
13750 "watermark" => Ok(GeneratedField::Watermark),
13751 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13752 }
13753 }
13754 }
13755 deserializer.deserialize_identifier(GeneratedVisitor)
13756 }
13757 }
13758 struct GeneratedVisitor;
13759 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13760 type Value = StreamMessageBatch;
13761
13762 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13763 formatter.write_str("struct stream_plan.StreamMessageBatch")
13764 }
13765
13766 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessageBatch, V::Error>
13767 where
13768 V: serde::de::MapAccess<'de>,
13769 {
13770 let mut stream_message_batch__ = None;
13771 while let Some(k) = map_.next_key()? {
13772 match k {
13773 GeneratedField::StreamChunk => {
13774 if stream_message_batch__.is_some() {
13775 return Err(serde::de::Error::duplicate_field("streamChunk"));
13776 }
13777 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::StreamChunk)
13778;
13779 }
13780 GeneratedField::BarrierBatch => {
13781 if stream_message_batch__.is_some() {
13782 return Err(serde::de::Error::duplicate_field("barrierBatch"));
13783 }
13784 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::BarrierBatch)
13785;
13786 }
13787 GeneratedField::Watermark => {
13788 if stream_message_batch__.is_some() {
13789 return Err(serde::de::Error::duplicate_field("watermark"));
13790 }
13791 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::Watermark)
13792;
13793 }
13794 }
13795 }
13796 Ok(StreamMessageBatch {
13797 stream_message_batch: stream_message_batch__,
13798 })
13799 }
13800 }
13801 deserializer.deserialize_struct("stream_plan.StreamMessageBatch", FIELDS, GeneratedVisitor)
13802 }
13803}
13804impl serde::Serialize for stream_message_batch::BarrierBatch {
13805 #[allow(deprecated)]
13806 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13807 where
13808 S: serde::Serializer,
13809 {
13810 use serde::ser::SerializeStruct;
13811 let mut len = 0;
13812 if !self.barriers.is_empty() {
13813 len += 1;
13814 }
13815 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", len)?;
13816 if !self.barriers.is_empty() {
13817 struct_ser.serialize_field("barriers", &self.barriers)?;
13818 }
13819 struct_ser.end()
13820 }
13821}
13822impl<'de> serde::Deserialize<'de> for stream_message_batch::BarrierBatch {
13823 #[allow(deprecated)]
13824 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13825 where
13826 D: serde::Deserializer<'de>,
13827 {
13828 const FIELDS: &[&str] = &[
13829 "barriers",
13830 ];
13831
13832 #[allow(clippy::enum_variant_names)]
13833 enum GeneratedField {
13834 Barriers,
13835 }
13836 impl<'de> serde::Deserialize<'de> for GeneratedField {
13837 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13838 where
13839 D: serde::Deserializer<'de>,
13840 {
13841 struct GeneratedVisitor;
13842
13843 impl serde::de::Visitor<'_> for GeneratedVisitor {
13844 type Value = GeneratedField;
13845
13846 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13847 write!(formatter, "expected one of: {:?}", &FIELDS)
13848 }
13849
13850 #[allow(unused_variables)]
13851 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13852 where
13853 E: serde::de::Error,
13854 {
13855 match value {
13856 "barriers" => Ok(GeneratedField::Barriers),
13857 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13858 }
13859 }
13860 }
13861 deserializer.deserialize_identifier(GeneratedVisitor)
13862 }
13863 }
13864 struct GeneratedVisitor;
13865 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13866 type Value = stream_message_batch::BarrierBatch;
13867
13868 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13869 formatter.write_str("struct stream_plan.StreamMessageBatch.BarrierBatch")
13870 }
13871
13872 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_message_batch::BarrierBatch, V::Error>
13873 where
13874 V: serde::de::MapAccess<'de>,
13875 {
13876 let mut barriers__ = None;
13877 while let Some(k) = map_.next_key()? {
13878 match k {
13879 GeneratedField::Barriers => {
13880 if barriers__.is_some() {
13881 return Err(serde::de::Error::duplicate_field("barriers"));
13882 }
13883 barriers__ = Some(map_.next_value()?);
13884 }
13885 }
13886 }
13887 Ok(stream_message_batch::BarrierBatch {
13888 barriers: barriers__.unwrap_or_default(),
13889 })
13890 }
13891 }
13892 deserializer.deserialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", FIELDS, GeneratedVisitor)
13893 }
13894}
13895impl serde::Serialize for StreamNode {
13896 #[allow(deprecated)]
13897 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13898 where
13899 S: serde::Serializer,
13900 {
13901 use serde::ser::SerializeStruct;
13902 let mut len = 0;
13903 if self.operator_id != 0 {
13904 len += 1;
13905 }
13906 if !self.input.is_empty() {
13907 len += 1;
13908 }
13909 if !self.stream_key.is_empty() {
13910 len += 1;
13911 }
13912 if self.stream_kind != 0 {
13913 len += 1;
13914 }
13915 if !self.identity.is_empty() {
13916 len += 1;
13917 }
13918 if !self.fields.is_empty() {
13919 len += 1;
13920 }
13921 if self.node_body.is_some() {
13922 len += 1;
13923 }
13924 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamNode", len)?;
13925 if self.operator_id != 0 {
13926 #[allow(clippy::needless_borrow)]
13927 #[allow(clippy::needless_borrows_for_generic_args)]
13928 struct_ser.serialize_field("operatorId", ToString::to_string(&self.operator_id).as_str())?;
13929 }
13930 if !self.input.is_empty() {
13931 struct_ser.serialize_field("input", &self.input)?;
13932 }
13933 if !self.stream_key.is_empty() {
13934 struct_ser.serialize_field("streamKey", &self.stream_key)?;
13935 }
13936 if self.stream_kind != 0 {
13937 let v = stream_node::StreamKind::try_from(self.stream_kind)
13938 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_kind)))?;
13939 struct_ser.serialize_field("streamKind", &v)?;
13940 }
13941 if !self.identity.is_empty() {
13942 struct_ser.serialize_field("identity", &self.identity)?;
13943 }
13944 if !self.fields.is_empty() {
13945 struct_ser.serialize_field("fields", &self.fields)?;
13946 }
13947 if let Some(v) = self.node_body.as_ref() {
13948 match v {
13949 stream_node::NodeBody::Source(v) => {
13950 struct_ser.serialize_field("source", v)?;
13951 }
13952 stream_node::NodeBody::Project(v) => {
13953 struct_ser.serialize_field("project", v)?;
13954 }
13955 stream_node::NodeBody::Filter(v) => {
13956 struct_ser.serialize_field("filter", v)?;
13957 }
13958 stream_node::NodeBody::Materialize(v) => {
13959 struct_ser.serialize_field("materialize", v)?;
13960 }
13961 stream_node::NodeBody::StatelessSimpleAgg(v) => {
13962 struct_ser.serialize_field("statelessSimpleAgg", v)?;
13963 }
13964 stream_node::NodeBody::SimpleAgg(v) => {
13965 struct_ser.serialize_field("simpleAgg", v)?;
13966 }
13967 stream_node::NodeBody::HashAgg(v) => {
13968 struct_ser.serialize_field("hashAgg", v)?;
13969 }
13970 stream_node::NodeBody::AppendOnlyTopN(v) => {
13971 struct_ser.serialize_field("appendOnlyTopN", v)?;
13972 }
13973 stream_node::NodeBody::HashJoin(v) => {
13974 struct_ser.serialize_field("hashJoin", v)?;
13975 }
13976 stream_node::NodeBody::TopN(v) => {
13977 struct_ser.serialize_field("topN", v)?;
13978 }
13979 stream_node::NodeBody::HopWindow(v) => {
13980 struct_ser.serialize_field("hopWindow", v)?;
13981 }
13982 stream_node::NodeBody::Merge(v) => {
13983 struct_ser.serialize_field("merge", v)?;
13984 }
13985 stream_node::NodeBody::Exchange(v) => {
13986 struct_ser.serialize_field("exchange", v)?;
13987 }
13988 stream_node::NodeBody::StreamScan(v) => {
13989 struct_ser.serialize_field("streamScan", v)?;
13990 }
13991 stream_node::NodeBody::BatchPlan(v) => {
13992 struct_ser.serialize_field("batchPlan", v)?;
13993 }
13994 stream_node::NodeBody::Lookup(v) => {
13995 struct_ser.serialize_field("lookup", v)?;
13996 }
13997 stream_node::NodeBody::Arrange(v) => {
13998 struct_ser.serialize_field("arrange", v)?;
13999 }
14000 stream_node::NodeBody::LookupUnion(v) => {
14001 struct_ser.serialize_field("lookupUnion", v)?;
14002 }
14003 stream_node::NodeBody::Union(v) => {
14004 struct_ser.serialize_field("union", v)?;
14005 }
14006 stream_node::NodeBody::DeltaIndexJoin(v) => {
14007 struct_ser.serialize_field("deltaIndexJoin", v)?;
14008 }
14009 stream_node::NodeBody::Sink(v) => {
14010 struct_ser.serialize_field("sink", v)?;
14011 }
14012 stream_node::NodeBody::Expand(v) => {
14013 struct_ser.serialize_field("expand", v)?;
14014 }
14015 stream_node::NodeBody::DynamicFilter(v) => {
14016 struct_ser.serialize_field("dynamicFilter", v)?;
14017 }
14018 stream_node::NodeBody::ProjectSet(v) => {
14019 struct_ser.serialize_field("projectSet", v)?;
14020 }
14021 stream_node::NodeBody::GroupTopN(v) => {
14022 struct_ser.serialize_field("groupTopN", v)?;
14023 }
14024 stream_node::NodeBody::Sort(v) => {
14025 struct_ser.serialize_field("sort", v)?;
14026 }
14027 stream_node::NodeBody::WatermarkFilter(v) => {
14028 struct_ser.serialize_field("watermarkFilter", v)?;
14029 }
14030 stream_node::NodeBody::Dml(v) => {
14031 struct_ser.serialize_field("dml", v)?;
14032 }
14033 stream_node::NodeBody::RowIdGen(v) => {
14034 struct_ser.serialize_field("rowIdGen", v)?;
14035 }
14036 stream_node::NodeBody::Now(v) => {
14037 struct_ser.serialize_field("now", v)?;
14038 }
14039 stream_node::NodeBody::AppendOnlyGroupTopN(v) => {
14040 struct_ser.serialize_field("appendOnlyGroupTopN", v)?;
14041 }
14042 stream_node::NodeBody::TemporalJoin(v) => {
14043 struct_ser.serialize_field("temporalJoin", v)?;
14044 }
14045 stream_node::NodeBody::BarrierRecv(v) => {
14046 struct_ser.serialize_field("barrierRecv", v)?;
14047 }
14048 stream_node::NodeBody::Values(v) => {
14049 struct_ser.serialize_field("values", v)?;
14050 }
14051 stream_node::NodeBody::AppendOnlyDedup(v) => {
14052 struct_ser.serialize_field("appendOnlyDedup", v)?;
14053 }
14054 stream_node::NodeBody::NoOp(v) => {
14055 struct_ser.serialize_field("noOp", v)?;
14056 }
14057 stream_node::NodeBody::EowcOverWindow(v) => {
14058 struct_ser.serialize_field("eowcOverWindow", v)?;
14059 }
14060 stream_node::NodeBody::OverWindow(v) => {
14061 struct_ser.serialize_field("overWindow", v)?;
14062 }
14063 stream_node::NodeBody::StreamFsFetch(v) => {
14064 struct_ser.serialize_field("streamFsFetch", v)?;
14065 }
14066 stream_node::NodeBody::StreamCdcScan(v) => {
14067 struct_ser.serialize_field("streamCdcScan", v)?;
14068 }
14069 stream_node::NodeBody::CdcFilter(v) => {
14070 struct_ser.serialize_field("cdcFilter", v)?;
14071 }
14072 stream_node::NodeBody::SourceBackfill(v) => {
14073 struct_ser.serialize_field("sourceBackfill", v)?;
14074 }
14075 stream_node::NodeBody::Changelog(v) => {
14076 struct_ser.serialize_field("changelog", v)?;
14077 }
14078 stream_node::NodeBody::LocalApproxPercentile(v) => {
14079 struct_ser.serialize_field("localApproxPercentile", v)?;
14080 }
14081 stream_node::NodeBody::GlobalApproxPercentile(v) => {
14082 struct_ser.serialize_field("globalApproxPercentile", v)?;
14083 }
14084 stream_node::NodeBody::RowMerge(v) => {
14085 struct_ser.serialize_field("rowMerge", v)?;
14086 }
14087 stream_node::NodeBody::AsOfJoin(v) => {
14088 struct_ser.serialize_field("asOfJoin", v)?;
14089 }
14090 stream_node::NodeBody::SyncLogStore(v) => {
14091 struct_ser.serialize_field("syncLogStore", v)?;
14092 }
14093 stream_node::NodeBody::MaterializedExprs(v) => {
14094 struct_ser.serialize_field("materializedExprs", v)?;
14095 }
14096 stream_node::NodeBody::VectorIndexWrite(v) => {
14097 struct_ser.serialize_field("vectorIndexWrite", v)?;
14098 }
14099 stream_node::NodeBody::UpstreamSinkUnion(v) => {
14100 struct_ser.serialize_field("upstreamSinkUnion", v)?;
14101 }
14102 stream_node::NodeBody::LocalityProvider(v) => {
14103 struct_ser.serialize_field("localityProvider", v)?;
14104 }
14105 stream_node::NodeBody::EowcGapFill(v) => {
14106 struct_ser.serialize_field("eowcGapFill", v)?;
14107 }
14108 stream_node::NodeBody::GapFill(v) => {
14109 struct_ser.serialize_field("gapFill", v)?;
14110 }
14111 stream_node::NodeBody::VectorIndexLookupJoin(v) => {
14112 struct_ser.serialize_field("vectorIndexLookupJoin", v)?;
14113 }
14114 }
14115 }
14116 struct_ser.end()
14117 }
14118}
14119impl<'de> serde::Deserialize<'de> for StreamNode {
14120 #[allow(deprecated)]
14121 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14122 where
14123 D: serde::Deserializer<'de>,
14124 {
14125 const FIELDS: &[&str] = &[
14126 "operator_id",
14127 "operatorId",
14128 "input",
14129 "stream_key",
14130 "streamKey",
14131 "stream_kind",
14132 "streamKind",
14133 "identity",
14134 "fields",
14135 "source",
14136 "project",
14137 "filter",
14138 "materialize",
14139 "stateless_simple_agg",
14140 "statelessSimpleAgg",
14141 "simple_agg",
14142 "simpleAgg",
14143 "hash_agg",
14144 "hashAgg",
14145 "append_only_top_n",
14146 "appendOnlyTopN",
14147 "hash_join",
14148 "hashJoin",
14149 "top_n",
14150 "topN",
14151 "hop_window",
14152 "hopWindow",
14153 "merge",
14154 "exchange",
14155 "stream_scan",
14156 "streamScan",
14157 "batch_plan",
14158 "batchPlan",
14159 "lookup",
14160 "arrange",
14161 "lookup_union",
14162 "lookupUnion",
14163 "union",
14164 "delta_index_join",
14165 "deltaIndexJoin",
14166 "sink",
14167 "expand",
14168 "dynamic_filter",
14169 "dynamicFilter",
14170 "project_set",
14171 "projectSet",
14172 "group_top_n",
14173 "groupTopN",
14174 "sort",
14175 "watermark_filter",
14176 "watermarkFilter",
14177 "dml",
14178 "row_id_gen",
14179 "rowIdGen",
14180 "now",
14181 "append_only_group_top_n",
14182 "appendOnlyGroupTopN",
14183 "temporal_join",
14184 "temporalJoin",
14185 "barrier_recv",
14186 "barrierRecv",
14187 "values",
14188 "append_only_dedup",
14189 "appendOnlyDedup",
14190 "no_op",
14191 "noOp",
14192 "eowc_over_window",
14193 "eowcOverWindow",
14194 "over_window",
14195 "overWindow",
14196 "stream_fs_fetch",
14197 "streamFsFetch",
14198 "stream_cdc_scan",
14199 "streamCdcScan",
14200 "cdc_filter",
14201 "cdcFilter",
14202 "source_backfill",
14203 "sourceBackfill",
14204 "changelog",
14205 "local_approx_percentile",
14206 "localApproxPercentile",
14207 "global_approx_percentile",
14208 "globalApproxPercentile",
14209 "row_merge",
14210 "rowMerge",
14211 "as_of_join",
14212 "asOfJoin",
14213 "sync_log_store",
14214 "syncLogStore",
14215 "materialized_exprs",
14216 "materializedExprs",
14217 "vector_index_write",
14218 "vectorIndexWrite",
14219 "upstream_sink_union",
14220 "upstreamSinkUnion",
14221 "locality_provider",
14222 "localityProvider",
14223 "eowc_gap_fill",
14224 "eowcGapFill",
14225 "gap_fill",
14226 "gapFill",
14227 "vector_index_lookup_join",
14228 "vectorIndexLookupJoin",
14229 ];
14230
14231 #[allow(clippy::enum_variant_names)]
14232 enum GeneratedField {
14233 OperatorId,
14234 Input,
14235 StreamKey,
14236 StreamKind,
14237 Identity,
14238 Fields,
14239 Source,
14240 Project,
14241 Filter,
14242 Materialize,
14243 StatelessSimpleAgg,
14244 SimpleAgg,
14245 HashAgg,
14246 AppendOnlyTopN,
14247 HashJoin,
14248 TopN,
14249 HopWindow,
14250 Merge,
14251 Exchange,
14252 StreamScan,
14253 BatchPlan,
14254 Lookup,
14255 Arrange,
14256 LookupUnion,
14257 Union,
14258 DeltaIndexJoin,
14259 Sink,
14260 Expand,
14261 DynamicFilter,
14262 ProjectSet,
14263 GroupTopN,
14264 Sort,
14265 WatermarkFilter,
14266 Dml,
14267 RowIdGen,
14268 Now,
14269 AppendOnlyGroupTopN,
14270 TemporalJoin,
14271 BarrierRecv,
14272 Values,
14273 AppendOnlyDedup,
14274 NoOp,
14275 EowcOverWindow,
14276 OverWindow,
14277 StreamFsFetch,
14278 StreamCdcScan,
14279 CdcFilter,
14280 SourceBackfill,
14281 Changelog,
14282 LocalApproxPercentile,
14283 GlobalApproxPercentile,
14284 RowMerge,
14285 AsOfJoin,
14286 SyncLogStore,
14287 MaterializedExprs,
14288 VectorIndexWrite,
14289 UpstreamSinkUnion,
14290 LocalityProvider,
14291 EowcGapFill,
14292 GapFill,
14293 VectorIndexLookupJoin,
14294 }
14295 impl<'de> serde::Deserialize<'de> for GeneratedField {
14296 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14297 where
14298 D: serde::Deserializer<'de>,
14299 {
14300 struct GeneratedVisitor;
14301
14302 impl serde::de::Visitor<'_> for GeneratedVisitor {
14303 type Value = GeneratedField;
14304
14305 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14306 write!(formatter, "expected one of: {:?}", &FIELDS)
14307 }
14308
14309 #[allow(unused_variables)]
14310 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14311 where
14312 E: serde::de::Error,
14313 {
14314 match value {
14315 "operatorId" | "operator_id" => Ok(GeneratedField::OperatorId),
14316 "input" => Ok(GeneratedField::Input),
14317 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
14318 "streamKind" | "stream_kind" => Ok(GeneratedField::StreamKind),
14319 "identity" => Ok(GeneratedField::Identity),
14320 "fields" => Ok(GeneratedField::Fields),
14321 "source" => Ok(GeneratedField::Source),
14322 "project" => Ok(GeneratedField::Project),
14323 "filter" => Ok(GeneratedField::Filter),
14324 "materialize" => Ok(GeneratedField::Materialize),
14325 "statelessSimpleAgg" | "stateless_simple_agg" => Ok(GeneratedField::StatelessSimpleAgg),
14326 "simpleAgg" | "simple_agg" => Ok(GeneratedField::SimpleAgg),
14327 "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
14328 "appendOnlyTopN" | "append_only_top_n" => Ok(GeneratedField::AppendOnlyTopN),
14329 "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
14330 "topN" | "top_n" => Ok(GeneratedField::TopN),
14331 "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
14332 "merge" => Ok(GeneratedField::Merge),
14333 "exchange" => Ok(GeneratedField::Exchange),
14334 "streamScan" | "stream_scan" => Ok(GeneratedField::StreamScan),
14335 "batchPlan" | "batch_plan" => Ok(GeneratedField::BatchPlan),
14336 "lookup" => Ok(GeneratedField::Lookup),
14337 "arrange" => Ok(GeneratedField::Arrange),
14338 "lookupUnion" | "lookup_union" => Ok(GeneratedField::LookupUnion),
14339 "union" => Ok(GeneratedField::Union),
14340 "deltaIndexJoin" | "delta_index_join" => Ok(GeneratedField::DeltaIndexJoin),
14341 "sink" => Ok(GeneratedField::Sink),
14342 "expand" => Ok(GeneratedField::Expand),
14343 "dynamicFilter" | "dynamic_filter" => Ok(GeneratedField::DynamicFilter),
14344 "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
14345 "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
14346 "sort" => Ok(GeneratedField::Sort),
14347 "watermarkFilter" | "watermark_filter" => Ok(GeneratedField::WatermarkFilter),
14348 "dml" => Ok(GeneratedField::Dml),
14349 "rowIdGen" | "row_id_gen" => Ok(GeneratedField::RowIdGen),
14350 "now" => Ok(GeneratedField::Now),
14351 "appendOnlyGroupTopN" | "append_only_group_top_n" => Ok(GeneratedField::AppendOnlyGroupTopN),
14352 "temporalJoin" | "temporal_join" => Ok(GeneratedField::TemporalJoin),
14353 "barrierRecv" | "barrier_recv" => Ok(GeneratedField::BarrierRecv),
14354 "values" => Ok(GeneratedField::Values),
14355 "appendOnlyDedup" | "append_only_dedup" => Ok(GeneratedField::AppendOnlyDedup),
14356 "noOp" | "no_op" => Ok(GeneratedField::NoOp),
14357 "eowcOverWindow" | "eowc_over_window" => Ok(GeneratedField::EowcOverWindow),
14358 "overWindow" | "over_window" => Ok(GeneratedField::OverWindow),
14359 "streamFsFetch" | "stream_fs_fetch" => Ok(GeneratedField::StreamFsFetch),
14360 "streamCdcScan" | "stream_cdc_scan" => Ok(GeneratedField::StreamCdcScan),
14361 "cdcFilter" | "cdc_filter" => Ok(GeneratedField::CdcFilter),
14362 "sourceBackfill" | "source_backfill" => Ok(GeneratedField::SourceBackfill),
14363 "changelog" => Ok(GeneratedField::Changelog),
14364 "localApproxPercentile" | "local_approx_percentile" => Ok(GeneratedField::LocalApproxPercentile),
14365 "globalApproxPercentile" | "global_approx_percentile" => Ok(GeneratedField::GlobalApproxPercentile),
14366 "rowMerge" | "row_merge" => Ok(GeneratedField::RowMerge),
14367 "asOfJoin" | "as_of_join" => Ok(GeneratedField::AsOfJoin),
14368 "syncLogStore" | "sync_log_store" => Ok(GeneratedField::SyncLogStore),
14369 "materializedExprs" | "materialized_exprs" => Ok(GeneratedField::MaterializedExprs),
14370 "vectorIndexWrite" | "vector_index_write" => Ok(GeneratedField::VectorIndexWrite),
14371 "upstreamSinkUnion" | "upstream_sink_union" => Ok(GeneratedField::UpstreamSinkUnion),
14372 "localityProvider" | "locality_provider" => Ok(GeneratedField::LocalityProvider),
14373 "eowcGapFill" | "eowc_gap_fill" => Ok(GeneratedField::EowcGapFill),
14374 "gapFill" | "gap_fill" => Ok(GeneratedField::GapFill),
14375 "vectorIndexLookupJoin" | "vector_index_lookup_join" => Ok(GeneratedField::VectorIndexLookupJoin),
14376 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14377 }
14378 }
14379 }
14380 deserializer.deserialize_identifier(GeneratedVisitor)
14381 }
14382 }
14383 struct GeneratedVisitor;
14384 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14385 type Value = StreamNode;
14386
14387 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14388 formatter.write_str("struct stream_plan.StreamNode")
14389 }
14390
14391 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamNode, V::Error>
14392 where
14393 V: serde::de::MapAccess<'de>,
14394 {
14395 let mut operator_id__ = None;
14396 let mut input__ = None;
14397 let mut stream_key__ = None;
14398 let mut stream_kind__ = None;
14399 let mut identity__ = None;
14400 let mut fields__ = None;
14401 let mut node_body__ = None;
14402 while let Some(k) = map_.next_key()? {
14403 match k {
14404 GeneratedField::OperatorId => {
14405 if operator_id__.is_some() {
14406 return Err(serde::de::Error::duplicate_field("operatorId"));
14407 }
14408 operator_id__ =
14409 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14410 ;
14411 }
14412 GeneratedField::Input => {
14413 if input__.is_some() {
14414 return Err(serde::de::Error::duplicate_field("input"));
14415 }
14416 input__ = Some(map_.next_value()?);
14417 }
14418 GeneratedField::StreamKey => {
14419 if stream_key__.is_some() {
14420 return Err(serde::de::Error::duplicate_field("streamKey"));
14421 }
14422 stream_key__ =
14423 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14424 .into_iter().map(|x| x.0).collect())
14425 ;
14426 }
14427 GeneratedField::StreamKind => {
14428 if stream_kind__.is_some() {
14429 return Err(serde::de::Error::duplicate_field("streamKind"));
14430 }
14431 stream_kind__ = Some(map_.next_value::<stream_node::StreamKind>()? as i32);
14432 }
14433 GeneratedField::Identity => {
14434 if identity__.is_some() {
14435 return Err(serde::de::Error::duplicate_field("identity"));
14436 }
14437 identity__ = Some(map_.next_value()?);
14438 }
14439 GeneratedField::Fields => {
14440 if fields__.is_some() {
14441 return Err(serde::de::Error::duplicate_field("fields"));
14442 }
14443 fields__ = Some(map_.next_value()?);
14444 }
14445 GeneratedField::Source => {
14446 if node_body__.is_some() {
14447 return Err(serde::de::Error::duplicate_field("source"));
14448 }
14449 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Source)
14450;
14451 }
14452 GeneratedField::Project => {
14453 if node_body__.is_some() {
14454 return Err(serde::de::Error::duplicate_field("project"));
14455 }
14456 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Project)
14457;
14458 }
14459 GeneratedField::Filter => {
14460 if node_body__.is_some() {
14461 return Err(serde::de::Error::duplicate_field("filter"));
14462 }
14463 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Filter)
14464;
14465 }
14466 GeneratedField::Materialize => {
14467 if node_body__.is_some() {
14468 return Err(serde::de::Error::duplicate_field("materialize"));
14469 }
14470 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Materialize)
14471;
14472 }
14473 GeneratedField::StatelessSimpleAgg => {
14474 if node_body__.is_some() {
14475 return Err(serde::de::Error::duplicate_field("statelessSimpleAgg"));
14476 }
14477 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StatelessSimpleAgg)
14478;
14479 }
14480 GeneratedField::SimpleAgg => {
14481 if node_body__.is_some() {
14482 return Err(serde::de::Error::duplicate_field("simpleAgg"));
14483 }
14484 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SimpleAgg)
14485;
14486 }
14487 GeneratedField::HashAgg => {
14488 if node_body__.is_some() {
14489 return Err(serde::de::Error::duplicate_field("hashAgg"));
14490 }
14491 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashAgg)
14492;
14493 }
14494 GeneratedField::AppendOnlyTopN => {
14495 if node_body__.is_some() {
14496 return Err(serde::de::Error::duplicate_field("appendOnlyTopN"));
14497 }
14498 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyTopN)
14499;
14500 }
14501 GeneratedField::HashJoin => {
14502 if node_body__.is_some() {
14503 return Err(serde::de::Error::duplicate_field("hashJoin"));
14504 }
14505 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashJoin)
14506;
14507 }
14508 GeneratedField::TopN => {
14509 if node_body__.is_some() {
14510 return Err(serde::de::Error::duplicate_field("topN"));
14511 }
14512 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TopN)
14513;
14514 }
14515 GeneratedField::HopWindow => {
14516 if node_body__.is_some() {
14517 return Err(serde::de::Error::duplicate_field("hopWindow"));
14518 }
14519 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HopWindow)
14520;
14521 }
14522 GeneratedField::Merge => {
14523 if node_body__.is_some() {
14524 return Err(serde::de::Error::duplicate_field("merge"));
14525 }
14526 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Merge)
14527;
14528 }
14529 GeneratedField::Exchange => {
14530 if node_body__.is_some() {
14531 return Err(serde::de::Error::duplicate_field("exchange"));
14532 }
14533 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Exchange)
14534;
14535 }
14536 GeneratedField::StreamScan => {
14537 if node_body__.is_some() {
14538 return Err(serde::de::Error::duplicate_field("streamScan"));
14539 }
14540 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamScan)
14541;
14542 }
14543 GeneratedField::BatchPlan => {
14544 if node_body__.is_some() {
14545 return Err(serde::de::Error::duplicate_field("batchPlan"));
14546 }
14547 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BatchPlan)
14548;
14549 }
14550 GeneratedField::Lookup => {
14551 if node_body__.is_some() {
14552 return Err(serde::de::Error::duplicate_field("lookup"));
14553 }
14554 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Lookup)
14555;
14556 }
14557 GeneratedField::Arrange => {
14558 if node_body__.is_some() {
14559 return Err(serde::de::Error::duplicate_field("arrange"));
14560 }
14561 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Arrange)
14562;
14563 }
14564 GeneratedField::LookupUnion => {
14565 if node_body__.is_some() {
14566 return Err(serde::de::Error::duplicate_field("lookupUnion"));
14567 }
14568 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LookupUnion)
14569;
14570 }
14571 GeneratedField::Union => {
14572 if node_body__.is_some() {
14573 return Err(serde::de::Error::duplicate_field("union"));
14574 }
14575 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Union)
14576;
14577 }
14578 GeneratedField::DeltaIndexJoin => {
14579 if node_body__.is_some() {
14580 return Err(serde::de::Error::duplicate_field("deltaIndexJoin"));
14581 }
14582 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DeltaIndexJoin)
14583;
14584 }
14585 GeneratedField::Sink => {
14586 if node_body__.is_some() {
14587 return Err(serde::de::Error::duplicate_field("sink"));
14588 }
14589 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sink)
14590;
14591 }
14592 GeneratedField::Expand => {
14593 if node_body__.is_some() {
14594 return Err(serde::de::Error::duplicate_field("expand"));
14595 }
14596 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Expand)
14597;
14598 }
14599 GeneratedField::DynamicFilter => {
14600 if node_body__.is_some() {
14601 return Err(serde::de::Error::duplicate_field("dynamicFilter"));
14602 }
14603 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DynamicFilter)
14604;
14605 }
14606 GeneratedField::ProjectSet => {
14607 if node_body__.is_some() {
14608 return Err(serde::de::Error::duplicate_field("projectSet"));
14609 }
14610 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::ProjectSet)
14611;
14612 }
14613 GeneratedField::GroupTopN => {
14614 if node_body__.is_some() {
14615 return Err(serde::de::Error::duplicate_field("groupTopN"));
14616 }
14617 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GroupTopN)
14618;
14619 }
14620 GeneratedField::Sort => {
14621 if node_body__.is_some() {
14622 return Err(serde::de::Error::duplicate_field("sort"));
14623 }
14624 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sort)
14625;
14626 }
14627 GeneratedField::WatermarkFilter => {
14628 if node_body__.is_some() {
14629 return Err(serde::de::Error::duplicate_field("watermarkFilter"));
14630 }
14631 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::WatermarkFilter)
14632;
14633 }
14634 GeneratedField::Dml => {
14635 if node_body__.is_some() {
14636 return Err(serde::de::Error::duplicate_field("dml"));
14637 }
14638 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Dml)
14639;
14640 }
14641 GeneratedField::RowIdGen => {
14642 if node_body__.is_some() {
14643 return Err(serde::de::Error::duplicate_field("rowIdGen"));
14644 }
14645 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowIdGen)
14646;
14647 }
14648 GeneratedField::Now => {
14649 if node_body__.is_some() {
14650 return Err(serde::de::Error::duplicate_field("now"));
14651 }
14652 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Now)
14653;
14654 }
14655 GeneratedField::AppendOnlyGroupTopN => {
14656 if node_body__.is_some() {
14657 return Err(serde::de::Error::duplicate_field("appendOnlyGroupTopN"));
14658 }
14659 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyGroupTopN)
14660;
14661 }
14662 GeneratedField::TemporalJoin => {
14663 if node_body__.is_some() {
14664 return Err(serde::de::Error::duplicate_field("temporalJoin"));
14665 }
14666 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TemporalJoin)
14667;
14668 }
14669 GeneratedField::BarrierRecv => {
14670 if node_body__.is_some() {
14671 return Err(serde::de::Error::duplicate_field("barrierRecv"));
14672 }
14673 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BarrierRecv)
14674;
14675 }
14676 GeneratedField::Values => {
14677 if node_body__.is_some() {
14678 return Err(serde::de::Error::duplicate_field("values"));
14679 }
14680 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Values)
14681;
14682 }
14683 GeneratedField::AppendOnlyDedup => {
14684 if node_body__.is_some() {
14685 return Err(serde::de::Error::duplicate_field("appendOnlyDedup"));
14686 }
14687 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyDedup)
14688;
14689 }
14690 GeneratedField::NoOp => {
14691 if node_body__.is_some() {
14692 return Err(serde::de::Error::duplicate_field("noOp"));
14693 }
14694 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::NoOp)
14695;
14696 }
14697 GeneratedField::EowcOverWindow => {
14698 if node_body__.is_some() {
14699 return Err(serde::de::Error::duplicate_field("eowcOverWindow"));
14700 }
14701 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcOverWindow)
14702;
14703 }
14704 GeneratedField::OverWindow => {
14705 if node_body__.is_some() {
14706 return Err(serde::de::Error::duplicate_field("overWindow"));
14707 }
14708 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::OverWindow)
14709;
14710 }
14711 GeneratedField::StreamFsFetch => {
14712 if node_body__.is_some() {
14713 return Err(serde::de::Error::duplicate_field("streamFsFetch"));
14714 }
14715 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamFsFetch)
14716;
14717 }
14718 GeneratedField::StreamCdcScan => {
14719 if node_body__.is_some() {
14720 return Err(serde::de::Error::duplicate_field("streamCdcScan"));
14721 }
14722 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamCdcScan)
14723;
14724 }
14725 GeneratedField::CdcFilter => {
14726 if node_body__.is_some() {
14727 return Err(serde::de::Error::duplicate_field("cdcFilter"));
14728 }
14729 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CdcFilter)
14730;
14731 }
14732 GeneratedField::SourceBackfill => {
14733 if node_body__.is_some() {
14734 return Err(serde::de::Error::duplicate_field("sourceBackfill"));
14735 }
14736 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SourceBackfill)
14737;
14738 }
14739 GeneratedField::Changelog => {
14740 if node_body__.is_some() {
14741 return Err(serde::de::Error::duplicate_field("changelog"));
14742 }
14743 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Changelog)
14744;
14745 }
14746 GeneratedField::LocalApproxPercentile => {
14747 if node_body__.is_some() {
14748 return Err(serde::de::Error::duplicate_field("localApproxPercentile"));
14749 }
14750 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalApproxPercentile)
14751;
14752 }
14753 GeneratedField::GlobalApproxPercentile => {
14754 if node_body__.is_some() {
14755 return Err(serde::de::Error::duplicate_field("globalApproxPercentile"));
14756 }
14757 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GlobalApproxPercentile)
14758;
14759 }
14760 GeneratedField::RowMerge => {
14761 if node_body__.is_some() {
14762 return Err(serde::de::Error::duplicate_field("rowMerge"));
14763 }
14764 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowMerge)
14765;
14766 }
14767 GeneratedField::AsOfJoin => {
14768 if node_body__.is_some() {
14769 return Err(serde::de::Error::duplicate_field("asOfJoin"));
14770 }
14771 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AsOfJoin)
14772;
14773 }
14774 GeneratedField::SyncLogStore => {
14775 if node_body__.is_some() {
14776 return Err(serde::de::Error::duplicate_field("syncLogStore"));
14777 }
14778 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SyncLogStore)
14779;
14780 }
14781 GeneratedField::MaterializedExprs => {
14782 if node_body__.is_some() {
14783 return Err(serde::de::Error::duplicate_field("materializedExprs"));
14784 }
14785 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MaterializedExprs)
14786;
14787 }
14788 GeneratedField::VectorIndexWrite => {
14789 if node_body__.is_some() {
14790 return Err(serde::de::Error::duplicate_field("vectorIndexWrite"));
14791 }
14792 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexWrite)
14793;
14794 }
14795 GeneratedField::UpstreamSinkUnion => {
14796 if node_body__.is_some() {
14797 return Err(serde::de::Error::duplicate_field("upstreamSinkUnion"));
14798 }
14799 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::UpstreamSinkUnion)
14800;
14801 }
14802 GeneratedField::LocalityProvider => {
14803 if node_body__.is_some() {
14804 return Err(serde::de::Error::duplicate_field("localityProvider"));
14805 }
14806 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalityProvider)
14807;
14808 }
14809 GeneratedField::EowcGapFill => {
14810 if node_body__.is_some() {
14811 return Err(serde::de::Error::duplicate_field("eowcGapFill"));
14812 }
14813 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcGapFill)
14814;
14815 }
14816 GeneratedField::GapFill => {
14817 if node_body__.is_some() {
14818 return Err(serde::de::Error::duplicate_field("gapFill"));
14819 }
14820 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GapFill)
14821;
14822 }
14823 GeneratedField::VectorIndexLookupJoin => {
14824 if node_body__.is_some() {
14825 return Err(serde::de::Error::duplicate_field("vectorIndexLookupJoin"));
14826 }
14827 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexLookupJoin)
14828;
14829 }
14830 }
14831 }
14832 Ok(StreamNode {
14833 operator_id: operator_id__.unwrap_or_default(),
14834 input: input__.unwrap_or_default(),
14835 stream_key: stream_key__.unwrap_or_default(),
14836 stream_kind: stream_kind__.unwrap_or_default(),
14837 identity: identity__.unwrap_or_default(),
14838 fields: fields__.unwrap_or_default(),
14839 node_body: node_body__,
14840 })
14841 }
14842 }
14843 deserializer.deserialize_struct("stream_plan.StreamNode", FIELDS, GeneratedVisitor)
14844 }
14845}
14846impl serde::Serialize for stream_node::StreamKind {
14847 #[allow(deprecated)]
14848 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14849 where
14850 S: serde::Serializer,
14851 {
14852 let variant = match self {
14853 Self::Retract => "STREAM_KIND_RETRACT",
14854 Self::AppendOnly => "STREAM_KIND_APPEND_ONLY",
14855 Self::Upsert => "STREAM_KIND_UPSERT",
14856 };
14857 serializer.serialize_str(variant)
14858 }
14859}
14860impl<'de> serde::Deserialize<'de> for stream_node::StreamKind {
14861 #[allow(deprecated)]
14862 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14863 where
14864 D: serde::Deserializer<'de>,
14865 {
14866 const FIELDS: &[&str] = &[
14867 "STREAM_KIND_RETRACT",
14868 "STREAM_KIND_APPEND_ONLY",
14869 "STREAM_KIND_UPSERT",
14870 ];
14871
14872 struct GeneratedVisitor;
14873
14874 impl serde::de::Visitor<'_> for GeneratedVisitor {
14875 type Value = stream_node::StreamKind;
14876
14877 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14878 write!(formatter, "expected one of: {:?}", &FIELDS)
14879 }
14880
14881 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14882 where
14883 E: serde::de::Error,
14884 {
14885 i32::try_from(v)
14886 .ok()
14887 .and_then(|x| x.try_into().ok())
14888 .ok_or_else(|| {
14889 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14890 })
14891 }
14892
14893 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14894 where
14895 E: serde::de::Error,
14896 {
14897 i32::try_from(v)
14898 .ok()
14899 .and_then(|x| x.try_into().ok())
14900 .ok_or_else(|| {
14901 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14902 })
14903 }
14904
14905 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14906 where
14907 E: serde::de::Error,
14908 {
14909 match value {
14910 "STREAM_KIND_RETRACT" => Ok(stream_node::StreamKind::Retract),
14911 "STREAM_KIND_APPEND_ONLY" => Ok(stream_node::StreamKind::AppendOnly),
14912 "STREAM_KIND_UPSERT" => Ok(stream_node::StreamKind::Upsert),
14913 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14914 }
14915 }
14916 }
14917 deserializer.deserialize_any(GeneratedVisitor)
14918 }
14919}
14920impl serde::Serialize for StreamScanNode {
14921 #[allow(deprecated)]
14922 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14923 where
14924 S: serde::Serializer,
14925 {
14926 use serde::ser::SerializeStruct;
14927 let mut len = 0;
14928 if self.table_id != 0 {
14929 len += 1;
14930 }
14931 if !self.upstream_column_ids.is_empty() {
14932 len += 1;
14933 }
14934 if !self.output_indices.is_empty() {
14935 len += 1;
14936 }
14937 if self.stream_scan_type != 0 {
14938 len += 1;
14939 }
14940 if self.state_table.is_some() {
14941 len += 1;
14942 }
14943 if self.table_desc.is_some() {
14944 len += 1;
14945 }
14946 if self.rate_limit.is_some() {
14947 len += 1;
14948 }
14949 if self.snapshot_read_barrier_interval != 0 {
14950 len += 1;
14951 }
14952 if self.arrangement_table.is_some() {
14953 len += 1;
14954 }
14955 if self.snapshot_backfill_epoch.is_some() {
14956 len += 1;
14957 }
14958 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamScanNode", len)?;
14959 if self.table_id != 0 {
14960 struct_ser.serialize_field("tableId", &self.table_id)?;
14961 }
14962 if !self.upstream_column_ids.is_empty() {
14963 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
14964 }
14965 if !self.output_indices.is_empty() {
14966 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
14967 }
14968 if self.stream_scan_type != 0 {
14969 let v = StreamScanType::try_from(self.stream_scan_type)
14970 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_scan_type)))?;
14971 struct_ser.serialize_field("streamScanType", &v)?;
14972 }
14973 if let Some(v) = self.state_table.as_ref() {
14974 struct_ser.serialize_field("stateTable", v)?;
14975 }
14976 if let Some(v) = self.table_desc.as_ref() {
14977 struct_ser.serialize_field("tableDesc", v)?;
14978 }
14979 if let Some(v) = self.rate_limit.as_ref() {
14980 struct_ser.serialize_field("rateLimit", v)?;
14981 }
14982 if self.snapshot_read_barrier_interval != 0 {
14983 struct_ser.serialize_field("snapshotReadBarrierInterval", &self.snapshot_read_barrier_interval)?;
14984 }
14985 if let Some(v) = self.arrangement_table.as_ref() {
14986 struct_ser.serialize_field("arrangementTable", v)?;
14987 }
14988 if let Some(v) = self.snapshot_backfill_epoch.as_ref() {
14989 #[allow(clippy::needless_borrow)]
14990 #[allow(clippy::needless_borrows_for_generic_args)]
14991 struct_ser.serialize_field("snapshotBackfillEpoch", ToString::to_string(&v).as_str())?;
14992 }
14993 struct_ser.end()
14994 }
14995}
14996impl<'de> serde::Deserialize<'de> for StreamScanNode {
14997 #[allow(deprecated)]
14998 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14999 where
15000 D: serde::Deserializer<'de>,
15001 {
15002 const FIELDS: &[&str] = &[
15003 "table_id",
15004 "tableId",
15005 "upstream_column_ids",
15006 "upstreamColumnIds",
15007 "output_indices",
15008 "outputIndices",
15009 "stream_scan_type",
15010 "streamScanType",
15011 "state_table",
15012 "stateTable",
15013 "table_desc",
15014 "tableDesc",
15015 "rate_limit",
15016 "rateLimit",
15017 "snapshot_read_barrier_interval",
15018 "snapshotReadBarrierInterval",
15019 "arrangement_table",
15020 "arrangementTable",
15021 "snapshot_backfill_epoch",
15022 "snapshotBackfillEpoch",
15023 ];
15024
15025 #[allow(clippy::enum_variant_names)]
15026 enum GeneratedField {
15027 TableId,
15028 UpstreamColumnIds,
15029 OutputIndices,
15030 StreamScanType,
15031 StateTable,
15032 TableDesc,
15033 RateLimit,
15034 SnapshotReadBarrierInterval,
15035 ArrangementTable,
15036 SnapshotBackfillEpoch,
15037 }
15038 impl<'de> serde::Deserialize<'de> for GeneratedField {
15039 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15040 where
15041 D: serde::Deserializer<'de>,
15042 {
15043 struct GeneratedVisitor;
15044
15045 impl serde::de::Visitor<'_> for GeneratedVisitor {
15046 type Value = GeneratedField;
15047
15048 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15049 write!(formatter, "expected one of: {:?}", &FIELDS)
15050 }
15051
15052 #[allow(unused_variables)]
15053 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15054 where
15055 E: serde::de::Error,
15056 {
15057 match value {
15058 "tableId" | "table_id" => Ok(GeneratedField::TableId),
15059 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
15060 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
15061 "streamScanType" | "stream_scan_type" => Ok(GeneratedField::StreamScanType),
15062 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
15063 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
15064 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
15065 "snapshotReadBarrierInterval" | "snapshot_read_barrier_interval" => Ok(GeneratedField::SnapshotReadBarrierInterval),
15066 "arrangementTable" | "arrangement_table" => Ok(GeneratedField::ArrangementTable),
15067 "snapshotBackfillEpoch" | "snapshot_backfill_epoch" => Ok(GeneratedField::SnapshotBackfillEpoch),
15068 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15069 }
15070 }
15071 }
15072 deserializer.deserialize_identifier(GeneratedVisitor)
15073 }
15074 }
15075 struct GeneratedVisitor;
15076 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15077 type Value = StreamScanNode;
15078
15079 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15080 formatter.write_str("struct stream_plan.StreamScanNode")
15081 }
15082
15083 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamScanNode, V::Error>
15084 where
15085 V: serde::de::MapAccess<'de>,
15086 {
15087 let mut table_id__ = None;
15088 let mut upstream_column_ids__ = None;
15089 let mut output_indices__ = None;
15090 let mut stream_scan_type__ = None;
15091 let mut state_table__ = None;
15092 let mut table_desc__ = None;
15093 let mut rate_limit__ = None;
15094 let mut snapshot_read_barrier_interval__ = None;
15095 let mut arrangement_table__ = None;
15096 let mut snapshot_backfill_epoch__ = None;
15097 while let Some(k) = map_.next_key()? {
15098 match k {
15099 GeneratedField::TableId => {
15100 if table_id__.is_some() {
15101 return Err(serde::de::Error::duplicate_field("tableId"));
15102 }
15103 table_id__ =
15104 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15105 ;
15106 }
15107 GeneratedField::UpstreamColumnIds => {
15108 if upstream_column_ids__.is_some() {
15109 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
15110 }
15111 upstream_column_ids__ =
15112 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15113 .into_iter().map(|x| x.0).collect())
15114 ;
15115 }
15116 GeneratedField::OutputIndices => {
15117 if output_indices__.is_some() {
15118 return Err(serde::de::Error::duplicate_field("outputIndices"));
15119 }
15120 output_indices__ =
15121 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15122 .into_iter().map(|x| x.0).collect())
15123 ;
15124 }
15125 GeneratedField::StreamScanType => {
15126 if stream_scan_type__.is_some() {
15127 return Err(serde::de::Error::duplicate_field("streamScanType"));
15128 }
15129 stream_scan_type__ = Some(map_.next_value::<StreamScanType>()? as i32);
15130 }
15131 GeneratedField::StateTable => {
15132 if state_table__.is_some() {
15133 return Err(serde::de::Error::duplicate_field("stateTable"));
15134 }
15135 state_table__ = map_.next_value()?;
15136 }
15137 GeneratedField::TableDesc => {
15138 if table_desc__.is_some() {
15139 return Err(serde::de::Error::duplicate_field("tableDesc"));
15140 }
15141 table_desc__ = map_.next_value()?;
15142 }
15143 GeneratedField::RateLimit => {
15144 if rate_limit__.is_some() {
15145 return Err(serde::de::Error::duplicate_field("rateLimit"));
15146 }
15147 rate_limit__ =
15148 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15149 ;
15150 }
15151 GeneratedField::SnapshotReadBarrierInterval => {
15152 if snapshot_read_barrier_interval__.is_some() {
15153 return Err(serde::de::Error::duplicate_field("snapshotReadBarrierInterval"));
15154 }
15155 snapshot_read_barrier_interval__ =
15156 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15157 ;
15158 }
15159 GeneratedField::ArrangementTable => {
15160 if arrangement_table__.is_some() {
15161 return Err(serde::de::Error::duplicate_field("arrangementTable"));
15162 }
15163 arrangement_table__ = map_.next_value()?;
15164 }
15165 GeneratedField::SnapshotBackfillEpoch => {
15166 if snapshot_backfill_epoch__.is_some() {
15167 return Err(serde::de::Error::duplicate_field("snapshotBackfillEpoch"));
15168 }
15169 snapshot_backfill_epoch__ =
15170 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15171 ;
15172 }
15173 }
15174 }
15175 Ok(StreamScanNode {
15176 table_id: table_id__.unwrap_or_default(),
15177 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
15178 output_indices: output_indices__.unwrap_or_default(),
15179 stream_scan_type: stream_scan_type__.unwrap_or_default(),
15180 state_table: state_table__,
15181 table_desc: table_desc__,
15182 rate_limit: rate_limit__,
15183 snapshot_read_barrier_interval: snapshot_read_barrier_interval__.unwrap_or_default(),
15184 arrangement_table: arrangement_table__,
15185 snapshot_backfill_epoch: snapshot_backfill_epoch__,
15186 })
15187 }
15188 }
15189 deserializer.deserialize_struct("stream_plan.StreamScanNode", FIELDS, GeneratedVisitor)
15190 }
15191}
15192impl serde::Serialize for StreamScanType {
15193 #[allow(deprecated)]
15194 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15195 where
15196 S: serde::Serializer,
15197 {
15198 let variant = match self {
15199 Self::Unspecified => "STREAM_SCAN_TYPE_UNSPECIFIED",
15200 Self::Chain => "STREAM_SCAN_TYPE_CHAIN",
15201 Self::Rearrange => "STREAM_SCAN_TYPE_REARRANGE",
15202 Self::Backfill => "STREAM_SCAN_TYPE_BACKFILL",
15203 Self::UpstreamOnly => "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
15204 Self::ArrangementBackfill => "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
15205 Self::SnapshotBackfill => "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
15206 Self::CrossDbSnapshotBackfill => "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
15207 };
15208 serializer.serialize_str(variant)
15209 }
15210}
15211impl<'de> serde::Deserialize<'de> for StreamScanType {
15212 #[allow(deprecated)]
15213 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15214 where
15215 D: serde::Deserializer<'de>,
15216 {
15217 const FIELDS: &[&str] = &[
15218 "STREAM_SCAN_TYPE_UNSPECIFIED",
15219 "STREAM_SCAN_TYPE_CHAIN",
15220 "STREAM_SCAN_TYPE_REARRANGE",
15221 "STREAM_SCAN_TYPE_BACKFILL",
15222 "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
15223 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
15224 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
15225 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
15226 ];
15227
15228 struct GeneratedVisitor;
15229
15230 impl serde::de::Visitor<'_> for GeneratedVisitor {
15231 type Value = StreamScanType;
15232
15233 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15234 write!(formatter, "expected one of: {:?}", &FIELDS)
15235 }
15236
15237 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15238 where
15239 E: serde::de::Error,
15240 {
15241 i32::try_from(v)
15242 .ok()
15243 .and_then(|x| x.try_into().ok())
15244 .ok_or_else(|| {
15245 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15246 })
15247 }
15248
15249 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15250 where
15251 E: serde::de::Error,
15252 {
15253 i32::try_from(v)
15254 .ok()
15255 .and_then(|x| x.try_into().ok())
15256 .ok_or_else(|| {
15257 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15258 })
15259 }
15260
15261 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15262 where
15263 E: serde::de::Error,
15264 {
15265 match value {
15266 "STREAM_SCAN_TYPE_UNSPECIFIED" => Ok(StreamScanType::Unspecified),
15267 "STREAM_SCAN_TYPE_CHAIN" => Ok(StreamScanType::Chain),
15268 "STREAM_SCAN_TYPE_REARRANGE" => Ok(StreamScanType::Rearrange),
15269 "STREAM_SCAN_TYPE_BACKFILL" => Ok(StreamScanType::Backfill),
15270 "STREAM_SCAN_TYPE_UPSTREAM_ONLY" => Ok(StreamScanType::UpstreamOnly),
15271 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL" => Ok(StreamScanType::ArrangementBackfill),
15272 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL" => Ok(StreamScanType::SnapshotBackfill),
15273 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL" => Ok(StreamScanType::CrossDbSnapshotBackfill),
15274 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15275 }
15276 }
15277 }
15278 deserializer.deserialize_any(GeneratedVisitor)
15279 }
15280}
15281impl serde::Serialize for StreamSource {
15282 #[allow(deprecated)]
15283 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15284 where
15285 S: serde::Serializer,
15286 {
15287 use serde::ser::SerializeStruct;
15288 let mut len = 0;
15289 if self.source_id != 0 {
15290 len += 1;
15291 }
15292 if self.state_table.is_some() {
15293 len += 1;
15294 }
15295 if self.row_id_index.is_some() {
15296 len += 1;
15297 }
15298 if !self.columns.is_empty() {
15299 len += 1;
15300 }
15301 if !self.with_properties.is_empty() {
15302 len += 1;
15303 }
15304 if self.info.is_some() {
15305 len += 1;
15306 }
15307 if !self.source_name.is_empty() {
15308 len += 1;
15309 }
15310 if self.rate_limit.is_some() {
15311 len += 1;
15312 }
15313 if !self.secret_refs.is_empty() {
15314 len += 1;
15315 }
15316 if self.downstream_columns.is_some() {
15317 len += 1;
15318 }
15319 if self.refresh_mode.is_some() {
15320 len += 1;
15321 }
15322 if self.associated_table_id.is_some() {
15323 len += 1;
15324 }
15325 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamSource", len)?;
15326 if self.source_id != 0 {
15327 struct_ser.serialize_field("sourceId", &self.source_id)?;
15328 }
15329 if let Some(v) = self.state_table.as_ref() {
15330 struct_ser.serialize_field("stateTable", v)?;
15331 }
15332 if let Some(v) = self.row_id_index.as_ref() {
15333 struct_ser.serialize_field("rowIdIndex", v)?;
15334 }
15335 if !self.columns.is_empty() {
15336 struct_ser.serialize_field("columns", &self.columns)?;
15337 }
15338 if !self.with_properties.is_empty() {
15339 struct_ser.serialize_field("withProperties", &self.with_properties)?;
15340 }
15341 if let Some(v) = self.info.as_ref() {
15342 struct_ser.serialize_field("info", v)?;
15343 }
15344 if !self.source_name.is_empty() {
15345 struct_ser.serialize_field("sourceName", &self.source_name)?;
15346 }
15347 if let Some(v) = self.rate_limit.as_ref() {
15348 struct_ser.serialize_field("rateLimit", v)?;
15349 }
15350 if !self.secret_refs.is_empty() {
15351 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
15352 }
15353 if let Some(v) = self.downstream_columns.as_ref() {
15354 struct_ser.serialize_field("downstreamColumns", v)?;
15355 }
15356 if let Some(v) = self.refresh_mode.as_ref() {
15357 struct_ser.serialize_field("refreshMode", v)?;
15358 }
15359 if let Some(v) = self.associated_table_id.as_ref() {
15360 struct_ser.serialize_field("associatedTableId", v)?;
15361 }
15362 struct_ser.end()
15363 }
15364}
15365impl<'de> serde::Deserialize<'de> for StreamSource {
15366 #[allow(deprecated)]
15367 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15368 where
15369 D: serde::Deserializer<'de>,
15370 {
15371 const FIELDS: &[&str] = &[
15372 "source_id",
15373 "sourceId",
15374 "state_table",
15375 "stateTable",
15376 "row_id_index",
15377 "rowIdIndex",
15378 "columns",
15379 "with_properties",
15380 "withProperties",
15381 "info",
15382 "source_name",
15383 "sourceName",
15384 "rate_limit",
15385 "rateLimit",
15386 "secret_refs",
15387 "secretRefs",
15388 "downstream_columns",
15389 "downstreamColumns",
15390 "refresh_mode",
15391 "refreshMode",
15392 "associated_table_id",
15393 "associatedTableId",
15394 ];
15395
15396 #[allow(clippy::enum_variant_names)]
15397 enum GeneratedField {
15398 SourceId,
15399 StateTable,
15400 RowIdIndex,
15401 Columns,
15402 WithProperties,
15403 Info,
15404 SourceName,
15405 RateLimit,
15406 SecretRefs,
15407 DownstreamColumns,
15408 RefreshMode,
15409 AssociatedTableId,
15410 }
15411 impl<'de> serde::Deserialize<'de> for GeneratedField {
15412 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15413 where
15414 D: serde::Deserializer<'de>,
15415 {
15416 struct GeneratedVisitor;
15417
15418 impl serde::de::Visitor<'_> for GeneratedVisitor {
15419 type Value = GeneratedField;
15420
15421 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15422 write!(formatter, "expected one of: {:?}", &FIELDS)
15423 }
15424
15425 #[allow(unused_variables)]
15426 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15427 where
15428 E: serde::de::Error,
15429 {
15430 match value {
15431 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
15432 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
15433 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
15434 "columns" => Ok(GeneratedField::Columns),
15435 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
15436 "info" => Ok(GeneratedField::Info),
15437 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
15438 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
15439 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
15440 "downstreamColumns" | "downstream_columns" => Ok(GeneratedField::DownstreamColumns),
15441 "refreshMode" | "refresh_mode" => Ok(GeneratedField::RefreshMode),
15442 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
15443 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15444 }
15445 }
15446 }
15447 deserializer.deserialize_identifier(GeneratedVisitor)
15448 }
15449 }
15450 struct GeneratedVisitor;
15451 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15452 type Value = StreamSource;
15453
15454 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15455 formatter.write_str("struct stream_plan.StreamSource")
15456 }
15457
15458 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSource, V::Error>
15459 where
15460 V: serde::de::MapAccess<'de>,
15461 {
15462 let mut source_id__ = None;
15463 let mut state_table__ = None;
15464 let mut row_id_index__ = None;
15465 let mut columns__ = None;
15466 let mut with_properties__ = None;
15467 let mut info__ = None;
15468 let mut source_name__ = None;
15469 let mut rate_limit__ = None;
15470 let mut secret_refs__ = None;
15471 let mut downstream_columns__ = None;
15472 let mut refresh_mode__ = None;
15473 let mut associated_table_id__ = None;
15474 while let Some(k) = map_.next_key()? {
15475 match k {
15476 GeneratedField::SourceId => {
15477 if source_id__.is_some() {
15478 return Err(serde::de::Error::duplicate_field("sourceId"));
15479 }
15480 source_id__ =
15481 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15482 ;
15483 }
15484 GeneratedField::StateTable => {
15485 if state_table__.is_some() {
15486 return Err(serde::de::Error::duplicate_field("stateTable"));
15487 }
15488 state_table__ = map_.next_value()?;
15489 }
15490 GeneratedField::RowIdIndex => {
15491 if row_id_index__.is_some() {
15492 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
15493 }
15494 row_id_index__ =
15495 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15496 ;
15497 }
15498 GeneratedField::Columns => {
15499 if columns__.is_some() {
15500 return Err(serde::de::Error::duplicate_field("columns"));
15501 }
15502 columns__ = Some(map_.next_value()?);
15503 }
15504 GeneratedField::WithProperties => {
15505 if with_properties__.is_some() {
15506 return Err(serde::de::Error::duplicate_field("withProperties"));
15507 }
15508 with_properties__ = Some(
15509 map_.next_value::<std::collections::BTreeMap<_, _>>()?
15510 );
15511 }
15512 GeneratedField::Info => {
15513 if info__.is_some() {
15514 return Err(serde::de::Error::duplicate_field("info"));
15515 }
15516 info__ = map_.next_value()?;
15517 }
15518 GeneratedField::SourceName => {
15519 if source_name__.is_some() {
15520 return Err(serde::de::Error::duplicate_field("sourceName"));
15521 }
15522 source_name__ = Some(map_.next_value()?);
15523 }
15524 GeneratedField::RateLimit => {
15525 if rate_limit__.is_some() {
15526 return Err(serde::de::Error::duplicate_field("rateLimit"));
15527 }
15528 rate_limit__ =
15529 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15530 ;
15531 }
15532 GeneratedField::SecretRefs => {
15533 if secret_refs__.is_some() {
15534 return Err(serde::de::Error::duplicate_field("secretRefs"));
15535 }
15536 secret_refs__ = Some(
15537 map_.next_value::<std::collections::BTreeMap<_, _>>()?
15538 );
15539 }
15540 GeneratedField::DownstreamColumns => {
15541 if downstream_columns__.is_some() {
15542 return Err(serde::de::Error::duplicate_field("downstreamColumns"));
15543 }
15544 downstream_columns__ = map_.next_value()?;
15545 }
15546 GeneratedField::RefreshMode => {
15547 if refresh_mode__.is_some() {
15548 return Err(serde::de::Error::duplicate_field("refreshMode"));
15549 }
15550 refresh_mode__ = map_.next_value()?;
15551 }
15552 GeneratedField::AssociatedTableId => {
15553 if associated_table_id__.is_some() {
15554 return Err(serde::de::Error::duplicate_field("associatedTableId"));
15555 }
15556 associated_table_id__ =
15557 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15558 ;
15559 }
15560 }
15561 }
15562 Ok(StreamSource {
15563 source_id: source_id__.unwrap_or_default(),
15564 state_table: state_table__,
15565 row_id_index: row_id_index__,
15566 columns: columns__.unwrap_or_default(),
15567 with_properties: with_properties__.unwrap_or_default(),
15568 info: info__,
15569 source_name: source_name__.unwrap_or_default(),
15570 rate_limit: rate_limit__,
15571 secret_refs: secret_refs__.unwrap_or_default(),
15572 downstream_columns: downstream_columns__,
15573 refresh_mode: refresh_mode__,
15574 associated_table_id: associated_table_id__,
15575 })
15576 }
15577 }
15578 deserializer.deserialize_struct("stream_plan.StreamSource", FIELDS, GeneratedVisitor)
15579 }
15580}
15581impl serde::Serialize for SubscriptionUpstreamInfo {
15582 #[allow(deprecated)]
15583 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15584 where
15585 S: serde::Serializer,
15586 {
15587 use serde::ser::SerializeStruct;
15588 let mut len = 0;
15589 if self.subscriber_id != 0 {
15590 len += 1;
15591 }
15592 if self.upstream_mv_table_id != 0 {
15593 len += 1;
15594 }
15595 let mut struct_ser = serializer.serialize_struct("stream_plan.SubscriptionUpstreamInfo", len)?;
15596 if self.subscriber_id != 0 {
15597 struct_ser.serialize_field("subscriberId", &self.subscriber_id)?;
15598 }
15599 if self.upstream_mv_table_id != 0 {
15600 struct_ser.serialize_field("upstreamMvTableId", &self.upstream_mv_table_id)?;
15601 }
15602 struct_ser.end()
15603 }
15604}
15605impl<'de> serde::Deserialize<'de> for SubscriptionUpstreamInfo {
15606 #[allow(deprecated)]
15607 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15608 where
15609 D: serde::Deserializer<'de>,
15610 {
15611 const FIELDS: &[&str] = &[
15612 "subscriber_id",
15613 "subscriberId",
15614 "upstream_mv_table_id",
15615 "upstreamMvTableId",
15616 ];
15617
15618 #[allow(clippy::enum_variant_names)]
15619 enum GeneratedField {
15620 SubscriberId,
15621 UpstreamMvTableId,
15622 }
15623 impl<'de> serde::Deserialize<'de> for GeneratedField {
15624 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15625 where
15626 D: serde::Deserializer<'de>,
15627 {
15628 struct GeneratedVisitor;
15629
15630 impl serde::de::Visitor<'_> for GeneratedVisitor {
15631 type Value = GeneratedField;
15632
15633 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15634 write!(formatter, "expected one of: {:?}", &FIELDS)
15635 }
15636
15637 #[allow(unused_variables)]
15638 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15639 where
15640 E: serde::de::Error,
15641 {
15642 match value {
15643 "subscriberId" | "subscriber_id" => Ok(GeneratedField::SubscriberId),
15644 "upstreamMvTableId" | "upstream_mv_table_id" => Ok(GeneratedField::UpstreamMvTableId),
15645 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15646 }
15647 }
15648 }
15649 deserializer.deserialize_identifier(GeneratedVisitor)
15650 }
15651 }
15652 struct GeneratedVisitor;
15653 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15654 type Value = SubscriptionUpstreamInfo;
15655
15656 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15657 formatter.write_str("struct stream_plan.SubscriptionUpstreamInfo")
15658 }
15659
15660 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscriptionUpstreamInfo, V::Error>
15661 where
15662 V: serde::de::MapAccess<'de>,
15663 {
15664 let mut subscriber_id__ = None;
15665 let mut upstream_mv_table_id__ = None;
15666 while let Some(k) = map_.next_key()? {
15667 match k {
15668 GeneratedField::SubscriberId => {
15669 if subscriber_id__.is_some() {
15670 return Err(serde::de::Error::duplicate_field("subscriberId"));
15671 }
15672 subscriber_id__ =
15673 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15674 ;
15675 }
15676 GeneratedField::UpstreamMvTableId => {
15677 if upstream_mv_table_id__.is_some() {
15678 return Err(serde::de::Error::duplicate_field("upstreamMvTableId"));
15679 }
15680 upstream_mv_table_id__ =
15681 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15682 ;
15683 }
15684 }
15685 }
15686 Ok(SubscriptionUpstreamInfo {
15687 subscriber_id: subscriber_id__.unwrap_or_default(),
15688 upstream_mv_table_id: upstream_mv_table_id__.unwrap_or_default(),
15689 })
15690 }
15691 }
15692 deserializer.deserialize_struct("stream_plan.SubscriptionUpstreamInfo", FIELDS, GeneratedVisitor)
15693 }
15694}
15695impl serde::Serialize for SyncLogStoreNode {
15696 #[allow(deprecated)]
15697 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15698 where
15699 S: serde::Serializer,
15700 {
15701 use serde::ser::SerializeStruct;
15702 let mut len = 0;
15703 if self.log_store_table.is_some() {
15704 len += 1;
15705 }
15706 if self.pause_duration_ms.is_some() {
15707 len += 1;
15708 }
15709 if self.buffer_size.is_some() {
15710 len += 1;
15711 }
15712 if self.aligned {
15713 len += 1;
15714 }
15715 let mut struct_ser = serializer.serialize_struct("stream_plan.SyncLogStoreNode", len)?;
15716 if let Some(v) = self.log_store_table.as_ref() {
15717 struct_ser.serialize_field("logStoreTable", v)?;
15718 }
15719 if let Some(v) = self.pause_duration_ms.as_ref() {
15720 struct_ser.serialize_field("pauseDurationMs", v)?;
15721 }
15722 if let Some(v) = self.buffer_size.as_ref() {
15723 struct_ser.serialize_field("bufferSize", v)?;
15724 }
15725 if self.aligned {
15726 struct_ser.serialize_field("aligned", &self.aligned)?;
15727 }
15728 struct_ser.end()
15729 }
15730}
15731impl<'de> serde::Deserialize<'de> for SyncLogStoreNode {
15732 #[allow(deprecated)]
15733 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15734 where
15735 D: serde::Deserializer<'de>,
15736 {
15737 const FIELDS: &[&str] = &[
15738 "log_store_table",
15739 "logStoreTable",
15740 "pause_duration_ms",
15741 "pauseDurationMs",
15742 "buffer_size",
15743 "bufferSize",
15744 "aligned",
15745 ];
15746
15747 #[allow(clippy::enum_variant_names)]
15748 enum GeneratedField {
15749 LogStoreTable,
15750 PauseDurationMs,
15751 BufferSize,
15752 Aligned,
15753 }
15754 impl<'de> serde::Deserialize<'de> for GeneratedField {
15755 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15756 where
15757 D: serde::Deserializer<'de>,
15758 {
15759 struct GeneratedVisitor;
15760
15761 impl serde::de::Visitor<'_> for GeneratedVisitor {
15762 type Value = GeneratedField;
15763
15764 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15765 write!(formatter, "expected one of: {:?}", &FIELDS)
15766 }
15767
15768 #[allow(unused_variables)]
15769 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15770 where
15771 E: serde::de::Error,
15772 {
15773 match value {
15774 "logStoreTable" | "log_store_table" => Ok(GeneratedField::LogStoreTable),
15775 "pauseDurationMs" | "pause_duration_ms" => Ok(GeneratedField::PauseDurationMs),
15776 "bufferSize" | "buffer_size" => Ok(GeneratedField::BufferSize),
15777 "aligned" => Ok(GeneratedField::Aligned),
15778 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15779 }
15780 }
15781 }
15782 deserializer.deserialize_identifier(GeneratedVisitor)
15783 }
15784 }
15785 struct GeneratedVisitor;
15786 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15787 type Value = SyncLogStoreNode;
15788
15789 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15790 formatter.write_str("struct stream_plan.SyncLogStoreNode")
15791 }
15792
15793 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SyncLogStoreNode, V::Error>
15794 where
15795 V: serde::de::MapAccess<'de>,
15796 {
15797 let mut log_store_table__ = None;
15798 let mut pause_duration_ms__ = None;
15799 let mut buffer_size__ = None;
15800 let mut aligned__ = None;
15801 while let Some(k) = map_.next_key()? {
15802 match k {
15803 GeneratedField::LogStoreTable => {
15804 if log_store_table__.is_some() {
15805 return Err(serde::de::Error::duplicate_field("logStoreTable"));
15806 }
15807 log_store_table__ = map_.next_value()?;
15808 }
15809 GeneratedField::PauseDurationMs => {
15810 if pause_duration_ms__.is_some() {
15811 return Err(serde::de::Error::duplicate_field("pauseDurationMs"));
15812 }
15813 pause_duration_ms__ =
15814 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15815 ;
15816 }
15817 GeneratedField::BufferSize => {
15818 if buffer_size__.is_some() {
15819 return Err(serde::de::Error::duplicate_field("bufferSize"));
15820 }
15821 buffer_size__ =
15822 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15823 ;
15824 }
15825 GeneratedField::Aligned => {
15826 if aligned__.is_some() {
15827 return Err(serde::de::Error::duplicate_field("aligned"));
15828 }
15829 aligned__ = Some(map_.next_value()?);
15830 }
15831 }
15832 }
15833 Ok(SyncLogStoreNode {
15834 log_store_table: log_store_table__,
15835 pause_duration_ms: pause_duration_ms__,
15836 buffer_size: buffer_size__,
15837 aligned: aligned__.unwrap_or_default(),
15838 })
15839 }
15840 }
15841 deserializer.deserialize_struct("stream_plan.SyncLogStoreNode", FIELDS, GeneratedVisitor)
15842 }
15843}
15844impl serde::Serialize for TemporalJoinNode {
15845 #[allow(deprecated)]
15846 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15847 where
15848 S: serde::Serializer,
15849 {
15850 use serde::ser::SerializeStruct;
15851 let mut len = 0;
15852 if self.join_type != 0 {
15853 len += 1;
15854 }
15855 if !self.left_key.is_empty() {
15856 len += 1;
15857 }
15858 if !self.right_key.is_empty() {
15859 len += 1;
15860 }
15861 if !self.null_safe.is_empty() {
15862 len += 1;
15863 }
15864 if self.condition.is_some() {
15865 len += 1;
15866 }
15867 if !self.output_indices.is_empty() {
15868 len += 1;
15869 }
15870 if self.table_desc.is_some() {
15871 len += 1;
15872 }
15873 if !self.table_output_indices.is_empty() {
15874 len += 1;
15875 }
15876 if self.memo_table.is_some() {
15877 len += 1;
15878 }
15879 if self.is_nested_loop {
15880 len += 1;
15881 }
15882 let mut struct_ser = serializer.serialize_struct("stream_plan.TemporalJoinNode", len)?;
15883 if self.join_type != 0 {
15884 let v = super::plan_common::JoinType::try_from(self.join_type)
15885 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
15886 struct_ser.serialize_field("joinType", &v)?;
15887 }
15888 if !self.left_key.is_empty() {
15889 struct_ser.serialize_field("leftKey", &self.left_key)?;
15890 }
15891 if !self.right_key.is_empty() {
15892 struct_ser.serialize_field("rightKey", &self.right_key)?;
15893 }
15894 if !self.null_safe.is_empty() {
15895 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
15896 }
15897 if let Some(v) = self.condition.as_ref() {
15898 struct_ser.serialize_field("condition", v)?;
15899 }
15900 if !self.output_indices.is_empty() {
15901 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
15902 }
15903 if let Some(v) = self.table_desc.as_ref() {
15904 struct_ser.serialize_field("tableDesc", v)?;
15905 }
15906 if !self.table_output_indices.is_empty() {
15907 struct_ser.serialize_field("tableOutputIndices", &self.table_output_indices)?;
15908 }
15909 if let Some(v) = self.memo_table.as_ref() {
15910 struct_ser.serialize_field("memoTable", v)?;
15911 }
15912 if self.is_nested_loop {
15913 struct_ser.serialize_field("isNestedLoop", &self.is_nested_loop)?;
15914 }
15915 struct_ser.end()
15916 }
15917}
15918impl<'de> serde::Deserialize<'de> for TemporalJoinNode {
15919 #[allow(deprecated)]
15920 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15921 where
15922 D: serde::Deserializer<'de>,
15923 {
15924 const FIELDS: &[&str] = &[
15925 "join_type",
15926 "joinType",
15927 "left_key",
15928 "leftKey",
15929 "right_key",
15930 "rightKey",
15931 "null_safe",
15932 "nullSafe",
15933 "condition",
15934 "output_indices",
15935 "outputIndices",
15936 "table_desc",
15937 "tableDesc",
15938 "table_output_indices",
15939 "tableOutputIndices",
15940 "memo_table",
15941 "memoTable",
15942 "is_nested_loop",
15943 "isNestedLoop",
15944 ];
15945
15946 #[allow(clippy::enum_variant_names)]
15947 enum GeneratedField {
15948 JoinType,
15949 LeftKey,
15950 RightKey,
15951 NullSafe,
15952 Condition,
15953 OutputIndices,
15954 TableDesc,
15955 TableOutputIndices,
15956 MemoTable,
15957 IsNestedLoop,
15958 }
15959 impl<'de> serde::Deserialize<'de> for GeneratedField {
15960 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15961 where
15962 D: serde::Deserializer<'de>,
15963 {
15964 struct GeneratedVisitor;
15965
15966 impl serde::de::Visitor<'_> for GeneratedVisitor {
15967 type Value = GeneratedField;
15968
15969 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15970 write!(formatter, "expected one of: {:?}", &FIELDS)
15971 }
15972
15973 #[allow(unused_variables)]
15974 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15975 where
15976 E: serde::de::Error,
15977 {
15978 match value {
15979 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
15980 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
15981 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
15982 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
15983 "condition" => Ok(GeneratedField::Condition),
15984 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
15985 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
15986 "tableOutputIndices" | "table_output_indices" => Ok(GeneratedField::TableOutputIndices),
15987 "memoTable" | "memo_table" => Ok(GeneratedField::MemoTable),
15988 "isNestedLoop" | "is_nested_loop" => Ok(GeneratedField::IsNestedLoop),
15989 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15990 }
15991 }
15992 }
15993 deserializer.deserialize_identifier(GeneratedVisitor)
15994 }
15995 }
15996 struct GeneratedVisitor;
15997 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15998 type Value = TemporalJoinNode;
15999
16000 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16001 formatter.write_str("struct stream_plan.TemporalJoinNode")
16002 }
16003
16004 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TemporalJoinNode, V::Error>
16005 where
16006 V: serde::de::MapAccess<'de>,
16007 {
16008 let mut join_type__ = None;
16009 let mut left_key__ = None;
16010 let mut right_key__ = None;
16011 let mut null_safe__ = None;
16012 let mut condition__ = None;
16013 let mut output_indices__ = None;
16014 let mut table_desc__ = None;
16015 let mut table_output_indices__ = None;
16016 let mut memo_table__ = None;
16017 let mut is_nested_loop__ = None;
16018 while let Some(k) = map_.next_key()? {
16019 match k {
16020 GeneratedField::JoinType => {
16021 if join_type__.is_some() {
16022 return Err(serde::de::Error::duplicate_field("joinType"));
16023 }
16024 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
16025 }
16026 GeneratedField::LeftKey => {
16027 if left_key__.is_some() {
16028 return Err(serde::de::Error::duplicate_field("leftKey"));
16029 }
16030 left_key__ =
16031 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16032 .into_iter().map(|x| x.0).collect())
16033 ;
16034 }
16035 GeneratedField::RightKey => {
16036 if right_key__.is_some() {
16037 return Err(serde::de::Error::duplicate_field("rightKey"));
16038 }
16039 right_key__ =
16040 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16041 .into_iter().map(|x| x.0).collect())
16042 ;
16043 }
16044 GeneratedField::NullSafe => {
16045 if null_safe__.is_some() {
16046 return Err(serde::de::Error::duplicate_field("nullSafe"));
16047 }
16048 null_safe__ = Some(map_.next_value()?);
16049 }
16050 GeneratedField::Condition => {
16051 if condition__.is_some() {
16052 return Err(serde::de::Error::duplicate_field("condition"));
16053 }
16054 condition__ = map_.next_value()?;
16055 }
16056 GeneratedField::OutputIndices => {
16057 if output_indices__.is_some() {
16058 return Err(serde::de::Error::duplicate_field("outputIndices"));
16059 }
16060 output_indices__ =
16061 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16062 .into_iter().map(|x| x.0).collect())
16063 ;
16064 }
16065 GeneratedField::TableDesc => {
16066 if table_desc__.is_some() {
16067 return Err(serde::de::Error::duplicate_field("tableDesc"));
16068 }
16069 table_desc__ = map_.next_value()?;
16070 }
16071 GeneratedField::TableOutputIndices => {
16072 if table_output_indices__.is_some() {
16073 return Err(serde::de::Error::duplicate_field("tableOutputIndices"));
16074 }
16075 table_output_indices__ =
16076 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16077 .into_iter().map(|x| x.0).collect())
16078 ;
16079 }
16080 GeneratedField::MemoTable => {
16081 if memo_table__.is_some() {
16082 return Err(serde::de::Error::duplicate_field("memoTable"));
16083 }
16084 memo_table__ = map_.next_value()?;
16085 }
16086 GeneratedField::IsNestedLoop => {
16087 if is_nested_loop__.is_some() {
16088 return Err(serde::de::Error::duplicate_field("isNestedLoop"));
16089 }
16090 is_nested_loop__ = Some(map_.next_value()?);
16091 }
16092 }
16093 }
16094 Ok(TemporalJoinNode {
16095 join_type: join_type__.unwrap_or_default(),
16096 left_key: left_key__.unwrap_or_default(),
16097 right_key: right_key__.unwrap_or_default(),
16098 null_safe: null_safe__.unwrap_or_default(),
16099 condition: condition__,
16100 output_indices: output_indices__.unwrap_or_default(),
16101 table_desc: table_desc__,
16102 table_output_indices: table_output_indices__.unwrap_or_default(),
16103 memo_table: memo_table__,
16104 is_nested_loop: is_nested_loop__.unwrap_or_default(),
16105 })
16106 }
16107 }
16108 deserializer.deserialize_struct("stream_plan.TemporalJoinNode", FIELDS, GeneratedVisitor)
16109 }
16110}
16111impl serde::Serialize for ThrottleMutation {
16112 #[allow(deprecated)]
16113 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16114 where
16115 S: serde::Serializer,
16116 {
16117 use serde::ser::SerializeStruct;
16118 let mut len = 0;
16119 if !self.fragment_throttle.is_empty() {
16120 len += 1;
16121 }
16122 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation", len)?;
16123 if !self.fragment_throttle.is_empty() {
16124 struct_ser.serialize_field("fragmentThrottle", &self.fragment_throttle)?;
16125 }
16126 struct_ser.end()
16127 }
16128}
16129impl<'de> serde::Deserialize<'de> for ThrottleMutation {
16130 #[allow(deprecated)]
16131 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16132 where
16133 D: serde::Deserializer<'de>,
16134 {
16135 const FIELDS: &[&str] = &[
16136 "fragment_throttle",
16137 "fragmentThrottle",
16138 ];
16139
16140 #[allow(clippy::enum_variant_names)]
16141 enum GeneratedField {
16142 FragmentThrottle,
16143 }
16144 impl<'de> serde::Deserialize<'de> for GeneratedField {
16145 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16146 where
16147 D: serde::Deserializer<'de>,
16148 {
16149 struct GeneratedVisitor;
16150
16151 impl serde::de::Visitor<'_> for GeneratedVisitor {
16152 type Value = GeneratedField;
16153
16154 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16155 write!(formatter, "expected one of: {:?}", &FIELDS)
16156 }
16157
16158 #[allow(unused_variables)]
16159 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16160 where
16161 E: serde::de::Error,
16162 {
16163 match value {
16164 "fragmentThrottle" | "fragment_throttle" => Ok(GeneratedField::FragmentThrottle),
16165 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16166 }
16167 }
16168 }
16169 deserializer.deserialize_identifier(GeneratedVisitor)
16170 }
16171 }
16172 struct GeneratedVisitor;
16173 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16174 type Value = ThrottleMutation;
16175
16176 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16177 formatter.write_str("struct stream_plan.ThrottleMutation")
16178 }
16179
16180 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ThrottleMutation, V::Error>
16181 where
16182 V: serde::de::MapAccess<'de>,
16183 {
16184 let mut fragment_throttle__ = None;
16185 while let Some(k) = map_.next_key()? {
16186 match k {
16187 GeneratedField::FragmentThrottle => {
16188 if fragment_throttle__.is_some() {
16189 return Err(serde::de::Error::duplicate_field("fragmentThrottle"));
16190 }
16191 fragment_throttle__ = Some(
16192 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
16193 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
16194 );
16195 }
16196 }
16197 }
16198 Ok(ThrottleMutation {
16199 fragment_throttle: fragment_throttle__.unwrap_or_default(),
16200 })
16201 }
16202 }
16203 deserializer.deserialize_struct("stream_plan.ThrottleMutation", FIELDS, GeneratedVisitor)
16204 }
16205}
16206impl serde::Serialize for throttle_mutation::ThrottleConfig {
16207 #[allow(deprecated)]
16208 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16209 where
16210 S: serde::Serializer,
16211 {
16212 use serde::ser::SerializeStruct;
16213 let mut len = 0;
16214 if self.rate_limit.is_some() {
16215 len += 1;
16216 }
16217 if self.throttle_type != 0 {
16218 len += 1;
16219 }
16220 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation.ThrottleConfig", len)?;
16221 if let Some(v) = self.rate_limit.as_ref() {
16222 struct_ser.serialize_field("rateLimit", v)?;
16223 }
16224 if self.throttle_type != 0 {
16225 let v = super::common::ThrottleType::try_from(self.throttle_type)
16226 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.throttle_type)))?;
16227 struct_ser.serialize_field("throttleType", &v)?;
16228 }
16229 struct_ser.end()
16230 }
16231}
16232impl<'de> serde::Deserialize<'de> for throttle_mutation::ThrottleConfig {
16233 #[allow(deprecated)]
16234 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16235 where
16236 D: serde::Deserializer<'de>,
16237 {
16238 const FIELDS: &[&str] = &[
16239 "rate_limit",
16240 "rateLimit",
16241 "throttle_type",
16242 "throttleType",
16243 ];
16244
16245 #[allow(clippy::enum_variant_names)]
16246 enum GeneratedField {
16247 RateLimit,
16248 ThrottleType,
16249 }
16250 impl<'de> serde::Deserialize<'de> for GeneratedField {
16251 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16252 where
16253 D: serde::Deserializer<'de>,
16254 {
16255 struct GeneratedVisitor;
16256
16257 impl serde::de::Visitor<'_> for GeneratedVisitor {
16258 type Value = GeneratedField;
16259
16260 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16261 write!(formatter, "expected one of: {:?}", &FIELDS)
16262 }
16263
16264 #[allow(unused_variables)]
16265 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16266 where
16267 E: serde::de::Error,
16268 {
16269 match value {
16270 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
16271 "throttleType" | "throttle_type" => Ok(GeneratedField::ThrottleType),
16272 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16273 }
16274 }
16275 }
16276 deserializer.deserialize_identifier(GeneratedVisitor)
16277 }
16278 }
16279 struct GeneratedVisitor;
16280 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16281 type Value = throttle_mutation::ThrottleConfig;
16282
16283 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16284 formatter.write_str("struct stream_plan.ThrottleMutation.ThrottleConfig")
16285 }
16286
16287 fn visit_map<V>(self, mut map_: V) -> std::result::Result<throttle_mutation::ThrottleConfig, V::Error>
16288 where
16289 V: serde::de::MapAccess<'de>,
16290 {
16291 let mut rate_limit__ = None;
16292 let mut throttle_type__ = None;
16293 while let Some(k) = map_.next_key()? {
16294 match k {
16295 GeneratedField::RateLimit => {
16296 if rate_limit__.is_some() {
16297 return Err(serde::de::Error::duplicate_field("rateLimit"));
16298 }
16299 rate_limit__ =
16300 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16301 ;
16302 }
16303 GeneratedField::ThrottleType => {
16304 if throttle_type__.is_some() {
16305 return Err(serde::de::Error::duplicate_field("throttleType"));
16306 }
16307 throttle_type__ = Some(map_.next_value::<super::common::ThrottleType>()? as i32);
16308 }
16309 }
16310 }
16311 Ok(throttle_mutation::ThrottleConfig {
16312 rate_limit: rate_limit__,
16313 throttle_type: throttle_type__.unwrap_or_default(),
16314 })
16315 }
16316 }
16317 deserializer.deserialize_struct("stream_plan.ThrottleMutation.ThrottleConfig", FIELDS, GeneratedVisitor)
16318 }
16319}
16320impl serde::Serialize for TopNNode {
16321 #[allow(deprecated)]
16322 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16323 where
16324 S: serde::Serializer,
16325 {
16326 use serde::ser::SerializeStruct;
16327 let mut len = 0;
16328 if self.limit != 0 {
16329 len += 1;
16330 }
16331 if self.offset != 0 {
16332 len += 1;
16333 }
16334 if self.table.is_some() {
16335 len += 1;
16336 }
16337 if !self.order_by.is_empty() {
16338 len += 1;
16339 }
16340 if self.with_ties {
16341 len += 1;
16342 }
16343 let mut struct_ser = serializer.serialize_struct("stream_plan.TopNNode", len)?;
16344 if self.limit != 0 {
16345 #[allow(clippy::needless_borrow)]
16346 #[allow(clippy::needless_borrows_for_generic_args)]
16347 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
16348 }
16349 if self.offset != 0 {
16350 #[allow(clippy::needless_borrow)]
16351 #[allow(clippy::needless_borrows_for_generic_args)]
16352 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
16353 }
16354 if let Some(v) = self.table.as_ref() {
16355 struct_ser.serialize_field("table", v)?;
16356 }
16357 if !self.order_by.is_empty() {
16358 struct_ser.serialize_field("orderBy", &self.order_by)?;
16359 }
16360 if self.with_ties {
16361 struct_ser.serialize_field("withTies", &self.with_ties)?;
16362 }
16363 struct_ser.end()
16364 }
16365}
16366impl<'de> serde::Deserialize<'de> for TopNNode {
16367 #[allow(deprecated)]
16368 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16369 where
16370 D: serde::Deserializer<'de>,
16371 {
16372 const FIELDS: &[&str] = &[
16373 "limit",
16374 "offset",
16375 "table",
16376 "order_by",
16377 "orderBy",
16378 "with_ties",
16379 "withTies",
16380 ];
16381
16382 #[allow(clippy::enum_variant_names)]
16383 enum GeneratedField {
16384 Limit,
16385 Offset,
16386 Table,
16387 OrderBy,
16388 WithTies,
16389 }
16390 impl<'de> serde::Deserialize<'de> for GeneratedField {
16391 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16392 where
16393 D: serde::Deserializer<'de>,
16394 {
16395 struct GeneratedVisitor;
16396
16397 impl serde::de::Visitor<'_> for GeneratedVisitor {
16398 type Value = GeneratedField;
16399
16400 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16401 write!(formatter, "expected one of: {:?}", &FIELDS)
16402 }
16403
16404 #[allow(unused_variables)]
16405 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16406 where
16407 E: serde::de::Error,
16408 {
16409 match value {
16410 "limit" => Ok(GeneratedField::Limit),
16411 "offset" => Ok(GeneratedField::Offset),
16412 "table" => Ok(GeneratedField::Table),
16413 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
16414 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
16415 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16416 }
16417 }
16418 }
16419 deserializer.deserialize_identifier(GeneratedVisitor)
16420 }
16421 }
16422 struct GeneratedVisitor;
16423 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16424 type Value = TopNNode;
16425
16426 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16427 formatter.write_str("struct stream_plan.TopNNode")
16428 }
16429
16430 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
16431 where
16432 V: serde::de::MapAccess<'de>,
16433 {
16434 let mut limit__ = None;
16435 let mut offset__ = None;
16436 let mut table__ = None;
16437 let mut order_by__ = None;
16438 let mut with_ties__ = None;
16439 while let Some(k) = map_.next_key()? {
16440 match k {
16441 GeneratedField::Limit => {
16442 if limit__.is_some() {
16443 return Err(serde::de::Error::duplicate_field("limit"));
16444 }
16445 limit__ =
16446 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16447 ;
16448 }
16449 GeneratedField::Offset => {
16450 if offset__.is_some() {
16451 return Err(serde::de::Error::duplicate_field("offset"));
16452 }
16453 offset__ =
16454 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16455 ;
16456 }
16457 GeneratedField::Table => {
16458 if table__.is_some() {
16459 return Err(serde::de::Error::duplicate_field("table"));
16460 }
16461 table__ = map_.next_value()?;
16462 }
16463 GeneratedField::OrderBy => {
16464 if order_by__.is_some() {
16465 return Err(serde::de::Error::duplicate_field("orderBy"));
16466 }
16467 order_by__ = Some(map_.next_value()?);
16468 }
16469 GeneratedField::WithTies => {
16470 if with_ties__.is_some() {
16471 return Err(serde::de::Error::duplicate_field("withTies"));
16472 }
16473 with_ties__ = Some(map_.next_value()?);
16474 }
16475 }
16476 }
16477 Ok(TopNNode {
16478 limit: limit__.unwrap_or_default(),
16479 offset: offset__.unwrap_or_default(),
16480 table: table__,
16481 order_by: order_by__.unwrap_or_default(),
16482 with_ties: with_ties__.unwrap_or_default(),
16483 })
16484 }
16485 }
16486 deserializer.deserialize_struct("stream_plan.TopNNode", FIELDS, GeneratedVisitor)
16487 }
16488}
16489impl serde::Serialize for UnionNode {
16490 #[allow(deprecated)]
16491 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16492 where
16493 S: serde::Serializer,
16494 {
16495 use serde::ser::SerializeStruct;
16496 let len = 0;
16497 let struct_ser = serializer.serialize_struct("stream_plan.UnionNode", len)?;
16498 struct_ser.end()
16499 }
16500}
16501impl<'de> serde::Deserialize<'de> for UnionNode {
16502 #[allow(deprecated)]
16503 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16504 where
16505 D: serde::Deserializer<'de>,
16506 {
16507 const FIELDS: &[&str] = &[
16508 ];
16509
16510 #[allow(clippy::enum_variant_names)]
16511 enum GeneratedField {
16512 }
16513 impl<'de> serde::Deserialize<'de> for GeneratedField {
16514 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16515 where
16516 D: serde::Deserializer<'de>,
16517 {
16518 struct GeneratedVisitor;
16519
16520 impl serde::de::Visitor<'_> for GeneratedVisitor {
16521 type Value = GeneratedField;
16522
16523 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16524 write!(formatter, "expected one of: {:?}", &FIELDS)
16525 }
16526
16527 #[allow(unused_variables)]
16528 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16529 where
16530 E: serde::de::Error,
16531 {
16532 Err(serde::de::Error::unknown_field(value, FIELDS))
16533 }
16534 }
16535 deserializer.deserialize_identifier(GeneratedVisitor)
16536 }
16537 }
16538 struct GeneratedVisitor;
16539 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16540 type Value = UnionNode;
16541
16542 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16543 formatter.write_str("struct stream_plan.UnionNode")
16544 }
16545
16546 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
16547 where
16548 V: serde::de::MapAccess<'de>,
16549 {
16550 while map_.next_key::<GeneratedField>()?.is_some() {
16551 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16552 }
16553 Ok(UnionNode {
16554 })
16555 }
16556 }
16557 deserializer.deserialize_struct("stream_plan.UnionNode", FIELDS, GeneratedVisitor)
16558 }
16559}
16560impl serde::Serialize for UpdateMutation {
16561 #[allow(deprecated)]
16562 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16563 where
16564 S: serde::Serializer,
16565 {
16566 use serde::ser::SerializeStruct;
16567 let mut len = 0;
16568 if !self.dispatcher_update.is_empty() {
16569 len += 1;
16570 }
16571 if !self.merge_update.is_empty() {
16572 len += 1;
16573 }
16574 if !self.actor_vnode_bitmap_update.is_empty() {
16575 len += 1;
16576 }
16577 if !self.dropped_actors.is_empty() {
16578 len += 1;
16579 }
16580 if !self.actor_splits.is_empty() {
16581 len += 1;
16582 }
16583 if !self.actor_new_dispatchers.is_empty() {
16584 len += 1;
16585 }
16586 if self.actor_cdc_table_snapshot_splits.is_some() {
16587 len += 1;
16588 }
16589 if !self.sink_schema_change.is_empty() {
16590 len += 1;
16591 }
16592 if !self.subscriptions_to_drop.is_empty() {
16593 len += 1;
16594 }
16595 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation", len)?;
16596 if !self.dispatcher_update.is_empty() {
16597 struct_ser.serialize_field("dispatcherUpdate", &self.dispatcher_update)?;
16598 }
16599 if !self.merge_update.is_empty() {
16600 struct_ser.serialize_field("mergeUpdate", &self.merge_update)?;
16601 }
16602 if !self.actor_vnode_bitmap_update.is_empty() {
16603 struct_ser.serialize_field("actorVnodeBitmapUpdate", &self.actor_vnode_bitmap_update)?;
16604 }
16605 if !self.dropped_actors.is_empty() {
16606 struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
16607 }
16608 if !self.actor_splits.is_empty() {
16609 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
16610 }
16611 if !self.actor_new_dispatchers.is_empty() {
16612 struct_ser.serialize_field("actorNewDispatchers", &self.actor_new_dispatchers)?;
16613 }
16614 if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
16615 struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
16616 }
16617 if !self.sink_schema_change.is_empty() {
16618 struct_ser.serialize_field("sinkSchemaChange", &self.sink_schema_change)?;
16619 }
16620 if !self.subscriptions_to_drop.is_empty() {
16621 struct_ser.serialize_field("subscriptionsToDrop", &self.subscriptions_to_drop)?;
16622 }
16623 struct_ser.end()
16624 }
16625}
16626impl<'de> serde::Deserialize<'de> for UpdateMutation {
16627 #[allow(deprecated)]
16628 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16629 where
16630 D: serde::Deserializer<'de>,
16631 {
16632 const FIELDS: &[&str] = &[
16633 "dispatcher_update",
16634 "dispatcherUpdate",
16635 "merge_update",
16636 "mergeUpdate",
16637 "actor_vnode_bitmap_update",
16638 "actorVnodeBitmapUpdate",
16639 "dropped_actors",
16640 "droppedActors",
16641 "actor_splits",
16642 "actorSplits",
16643 "actor_new_dispatchers",
16644 "actorNewDispatchers",
16645 "actor_cdc_table_snapshot_splits",
16646 "actorCdcTableSnapshotSplits",
16647 "sink_schema_change",
16648 "sinkSchemaChange",
16649 "subscriptions_to_drop",
16650 "subscriptionsToDrop",
16651 ];
16652
16653 #[allow(clippy::enum_variant_names)]
16654 enum GeneratedField {
16655 DispatcherUpdate,
16656 MergeUpdate,
16657 ActorVnodeBitmapUpdate,
16658 DroppedActors,
16659 ActorSplits,
16660 ActorNewDispatchers,
16661 ActorCdcTableSnapshotSplits,
16662 SinkSchemaChange,
16663 SubscriptionsToDrop,
16664 }
16665 impl<'de> serde::Deserialize<'de> for GeneratedField {
16666 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16667 where
16668 D: serde::Deserializer<'de>,
16669 {
16670 struct GeneratedVisitor;
16671
16672 impl serde::de::Visitor<'_> for GeneratedVisitor {
16673 type Value = GeneratedField;
16674
16675 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16676 write!(formatter, "expected one of: {:?}", &FIELDS)
16677 }
16678
16679 #[allow(unused_variables)]
16680 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16681 where
16682 E: serde::de::Error,
16683 {
16684 match value {
16685 "dispatcherUpdate" | "dispatcher_update" => Ok(GeneratedField::DispatcherUpdate),
16686 "mergeUpdate" | "merge_update" => Ok(GeneratedField::MergeUpdate),
16687 "actorVnodeBitmapUpdate" | "actor_vnode_bitmap_update" => Ok(GeneratedField::ActorVnodeBitmapUpdate),
16688 "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
16689 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
16690 "actorNewDispatchers" | "actor_new_dispatchers" => Ok(GeneratedField::ActorNewDispatchers),
16691 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
16692 "sinkSchemaChange" | "sink_schema_change" => Ok(GeneratedField::SinkSchemaChange),
16693 "subscriptionsToDrop" | "subscriptions_to_drop" => Ok(GeneratedField::SubscriptionsToDrop),
16694 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16695 }
16696 }
16697 }
16698 deserializer.deserialize_identifier(GeneratedVisitor)
16699 }
16700 }
16701 struct GeneratedVisitor;
16702 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16703 type Value = UpdateMutation;
16704
16705 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16706 formatter.write_str("struct stream_plan.UpdateMutation")
16707 }
16708
16709 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateMutation, V::Error>
16710 where
16711 V: serde::de::MapAccess<'de>,
16712 {
16713 let mut dispatcher_update__ = None;
16714 let mut merge_update__ = None;
16715 let mut actor_vnode_bitmap_update__ = None;
16716 let mut dropped_actors__ = None;
16717 let mut actor_splits__ = None;
16718 let mut actor_new_dispatchers__ = None;
16719 let mut actor_cdc_table_snapshot_splits__ = None;
16720 let mut sink_schema_change__ = None;
16721 let mut subscriptions_to_drop__ = None;
16722 while let Some(k) = map_.next_key()? {
16723 match k {
16724 GeneratedField::DispatcherUpdate => {
16725 if dispatcher_update__.is_some() {
16726 return Err(serde::de::Error::duplicate_field("dispatcherUpdate"));
16727 }
16728 dispatcher_update__ = Some(map_.next_value()?);
16729 }
16730 GeneratedField::MergeUpdate => {
16731 if merge_update__.is_some() {
16732 return Err(serde::de::Error::duplicate_field("mergeUpdate"));
16733 }
16734 merge_update__ = Some(map_.next_value()?);
16735 }
16736 GeneratedField::ActorVnodeBitmapUpdate => {
16737 if actor_vnode_bitmap_update__.is_some() {
16738 return Err(serde::de::Error::duplicate_field("actorVnodeBitmapUpdate"));
16739 }
16740 actor_vnode_bitmap_update__ = 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::DroppedActors => {
16746 if dropped_actors__.is_some() {
16747 return Err(serde::de::Error::duplicate_field("droppedActors"));
16748 }
16749 dropped_actors__ =
16750 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16751 .into_iter().map(|x| x.0).collect())
16752 ;
16753 }
16754 GeneratedField::ActorSplits => {
16755 if actor_splits__.is_some() {
16756 return Err(serde::de::Error::duplicate_field("actorSplits"));
16757 }
16758 actor_splits__ = Some(
16759 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
16760 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
16761 );
16762 }
16763 GeneratedField::ActorNewDispatchers => {
16764 if actor_new_dispatchers__.is_some() {
16765 return Err(serde::de::Error::duplicate_field("actorNewDispatchers"));
16766 }
16767 actor_new_dispatchers__ = Some(
16768 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
16769 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
16770 );
16771 }
16772 GeneratedField::ActorCdcTableSnapshotSplits => {
16773 if actor_cdc_table_snapshot_splits__.is_some() {
16774 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
16775 }
16776 actor_cdc_table_snapshot_splits__ = map_.next_value()?;
16777 }
16778 GeneratedField::SinkSchemaChange => {
16779 if sink_schema_change__.is_some() {
16780 return Err(serde::de::Error::duplicate_field("sinkSchemaChange"));
16781 }
16782 sink_schema_change__ = Some(
16783 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
16784 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
16785 );
16786 }
16787 GeneratedField::SubscriptionsToDrop => {
16788 if subscriptions_to_drop__.is_some() {
16789 return Err(serde::de::Error::duplicate_field("subscriptionsToDrop"));
16790 }
16791 subscriptions_to_drop__ = Some(map_.next_value()?);
16792 }
16793 }
16794 }
16795 Ok(UpdateMutation {
16796 dispatcher_update: dispatcher_update__.unwrap_or_default(),
16797 merge_update: merge_update__.unwrap_or_default(),
16798 actor_vnode_bitmap_update: actor_vnode_bitmap_update__.unwrap_or_default(),
16799 dropped_actors: dropped_actors__.unwrap_or_default(),
16800 actor_splits: actor_splits__.unwrap_or_default(),
16801 actor_new_dispatchers: actor_new_dispatchers__.unwrap_or_default(),
16802 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
16803 sink_schema_change: sink_schema_change__.unwrap_or_default(),
16804 subscriptions_to_drop: subscriptions_to_drop__.unwrap_or_default(),
16805 })
16806 }
16807 }
16808 deserializer.deserialize_struct("stream_plan.UpdateMutation", FIELDS, GeneratedVisitor)
16809 }
16810}
16811impl serde::Serialize for update_mutation::DispatcherUpdate {
16812 #[allow(deprecated)]
16813 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16814 where
16815 S: serde::Serializer,
16816 {
16817 use serde::ser::SerializeStruct;
16818 let mut len = 0;
16819 if self.actor_id != 0 {
16820 len += 1;
16821 }
16822 if self.dispatcher_id != 0 {
16823 len += 1;
16824 }
16825 if self.hash_mapping.is_some() {
16826 len += 1;
16827 }
16828 if !self.added_downstream_actor_id.is_empty() {
16829 len += 1;
16830 }
16831 if !self.removed_downstream_actor_id.is_empty() {
16832 len += 1;
16833 }
16834 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", len)?;
16835 if self.actor_id != 0 {
16836 struct_ser.serialize_field("actorId", &self.actor_id)?;
16837 }
16838 if self.dispatcher_id != 0 {
16839 struct_ser.serialize_field("dispatcherId", &self.dispatcher_id)?;
16840 }
16841 if let Some(v) = self.hash_mapping.as_ref() {
16842 struct_ser.serialize_field("hashMapping", v)?;
16843 }
16844 if !self.added_downstream_actor_id.is_empty() {
16845 struct_ser.serialize_field("addedDownstreamActorId", &self.added_downstream_actor_id)?;
16846 }
16847 if !self.removed_downstream_actor_id.is_empty() {
16848 struct_ser.serialize_field("removedDownstreamActorId", &self.removed_downstream_actor_id)?;
16849 }
16850 struct_ser.end()
16851 }
16852}
16853impl<'de> serde::Deserialize<'de> for update_mutation::DispatcherUpdate {
16854 #[allow(deprecated)]
16855 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16856 where
16857 D: serde::Deserializer<'de>,
16858 {
16859 const FIELDS: &[&str] = &[
16860 "actor_id",
16861 "actorId",
16862 "dispatcher_id",
16863 "dispatcherId",
16864 "hash_mapping",
16865 "hashMapping",
16866 "added_downstream_actor_id",
16867 "addedDownstreamActorId",
16868 "removed_downstream_actor_id",
16869 "removedDownstreamActorId",
16870 ];
16871
16872 #[allow(clippy::enum_variant_names)]
16873 enum GeneratedField {
16874 ActorId,
16875 DispatcherId,
16876 HashMapping,
16877 AddedDownstreamActorId,
16878 RemovedDownstreamActorId,
16879 }
16880 impl<'de> serde::Deserialize<'de> for GeneratedField {
16881 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16882 where
16883 D: serde::Deserializer<'de>,
16884 {
16885 struct GeneratedVisitor;
16886
16887 impl serde::de::Visitor<'_> for GeneratedVisitor {
16888 type Value = GeneratedField;
16889
16890 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16891 write!(formatter, "expected one of: {:?}", &FIELDS)
16892 }
16893
16894 #[allow(unused_variables)]
16895 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16896 where
16897 E: serde::de::Error,
16898 {
16899 match value {
16900 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
16901 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
16902 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
16903 "addedDownstreamActorId" | "added_downstream_actor_id" => Ok(GeneratedField::AddedDownstreamActorId),
16904 "removedDownstreamActorId" | "removed_downstream_actor_id" => Ok(GeneratedField::RemovedDownstreamActorId),
16905 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16906 }
16907 }
16908 }
16909 deserializer.deserialize_identifier(GeneratedVisitor)
16910 }
16911 }
16912 struct GeneratedVisitor;
16913 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16914 type Value = update_mutation::DispatcherUpdate;
16915
16916 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16917 formatter.write_str("struct stream_plan.UpdateMutation.DispatcherUpdate")
16918 }
16919
16920 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::DispatcherUpdate, V::Error>
16921 where
16922 V: serde::de::MapAccess<'de>,
16923 {
16924 let mut actor_id__ = None;
16925 let mut dispatcher_id__ = None;
16926 let mut hash_mapping__ = None;
16927 let mut added_downstream_actor_id__ = None;
16928 let mut removed_downstream_actor_id__ = None;
16929 while let Some(k) = map_.next_key()? {
16930 match k {
16931 GeneratedField::ActorId => {
16932 if actor_id__.is_some() {
16933 return Err(serde::de::Error::duplicate_field("actorId"));
16934 }
16935 actor_id__ =
16936 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16937 ;
16938 }
16939 GeneratedField::DispatcherId => {
16940 if dispatcher_id__.is_some() {
16941 return Err(serde::de::Error::duplicate_field("dispatcherId"));
16942 }
16943 dispatcher_id__ =
16944 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16945 ;
16946 }
16947 GeneratedField::HashMapping => {
16948 if hash_mapping__.is_some() {
16949 return Err(serde::de::Error::duplicate_field("hashMapping"));
16950 }
16951 hash_mapping__ = map_.next_value()?;
16952 }
16953 GeneratedField::AddedDownstreamActorId => {
16954 if added_downstream_actor_id__.is_some() {
16955 return Err(serde::de::Error::duplicate_field("addedDownstreamActorId"));
16956 }
16957 added_downstream_actor_id__ =
16958 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16959 .into_iter().map(|x| x.0).collect())
16960 ;
16961 }
16962 GeneratedField::RemovedDownstreamActorId => {
16963 if removed_downstream_actor_id__.is_some() {
16964 return Err(serde::de::Error::duplicate_field("removedDownstreamActorId"));
16965 }
16966 removed_downstream_actor_id__ =
16967 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16968 .into_iter().map(|x| x.0).collect())
16969 ;
16970 }
16971 }
16972 }
16973 Ok(update_mutation::DispatcherUpdate {
16974 actor_id: actor_id__.unwrap_or_default(),
16975 dispatcher_id: dispatcher_id__.unwrap_or_default(),
16976 hash_mapping: hash_mapping__,
16977 added_downstream_actor_id: added_downstream_actor_id__.unwrap_or_default(),
16978 removed_downstream_actor_id: removed_downstream_actor_id__.unwrap_or_default(),
16979 })
16980 }
16981 }
16982 deserializer.deserialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", FIELDS, GeneratedVisitor)
16983 }
16984}
16985impl serde::Serialize for update_mutation::MergeUpdate {
16986 #[allow(deprecated)]
16987 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16988 where
16989 S: serde::Serializer,
16990 {
16991 use serde::ser::SerializeStruct;
16992 let mut len = 0;
16993 if self.actor_id != 0 {
16994 len += 1;
16995 }
16996 if self.upstream_fragment_id != 0 {
16997 len += 1;
16998 }
16999 if self.new_upstream_fragment_id.is_some() {
17000 len += 1;
17001 }
17002 if !self.added_upstream_actors.is_empty() {
17003 len += 1;
17004 }
17005 if !self.removed_upstream_actor_id.is_empty() {
17006 len += 1;
17007 }
17008 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.MergeUpdate", len)?;
17009 if self.actor_id != 0 {
17010 struct_ser.serialize_field("actorId", &self.actor_id)?;
17011 }
17012 if self.upstream_fragment_id != 0 {
17013 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
17014 }
17015 if let Some(v) = self.new_upstream_fragment_id.as_ref() {
17016 struct_ser.serialize_field("newUpstreamFragmentId", v)?;
17017 }
17018 if !self.added_upstream_actors.is_empty() {
17019 struct_ser.serialize_field("addedUpstreamActors", &self.added_upstream_actors)?;
17020 }
17021 if !self.removed_upstream_actor_id.is_empty() {
17022 struct_ser.serialize_field("removedUpstreamActorId", &self.removed_upstream_actor_id)?;
17023 }
17024 struct_ser.end()
17025 }
17026}
17027impl<'de> serde::Deserialize<'de> for update_mutation::MergeUpdate {
17028 #[allow(deprecated)]
17029 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17030 where
17031 D: serde::Deserializer<'de>,
17032 {
17033 const FIELDS: &[&str] = &[
17034 "actor_id",
17035 "actorId",
17036 "upstream_fragment_id",
17037 "upstreamFragmentId",
17038 "new_upstream_fragment_id",
17039 "newUpstreamFragmentId",
17040 "added_upstream_actors",
17041 "addedUpstreamActors",
17042 "removed_upstream_actor_id",
17043 "removedUpstreamActorId",
17044 ];
17045
17046 #[allow(clippy::enum_variant_names)]
17047 enum GeneratedField {
17048 ActorId,
17049 UpstreamFragmentId,
17050 NewUpstreamFragmentId,
17051 AddedUpstreamActors,
17052 RemovedUpstreamActorId,
17053 }
17054 impl<'de> serde::Deserialize<'de> for GeneratedField {
17055 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17056 where
17057 D: serde::Deserializer<'de>,
17058 {
17059 struct GeneratedVisitor;
17060
17061 impl serde::de::Visitor<'_> for GeneratedVisitor {
17062 type Value = GeneratedField;
17063
17064 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17065 write!(formatter, "expected one of: {:?}", &FIELDS)
17066 }
17067
17068 #[allow(unused_variables)]
17069 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17070 where
17071 E: serde::de::Error,
17072 {
17073 match value {
17074 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
17075 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
17076 "newUpstreamFragmentId" | "new_upstream_fragment_id" => Ok(GeneratedField::NewUpstreamFragmentId),
17077 "addedUpstreamActors" | "added_upstream_actors" => Ok(GeneratedField::AddedUpstreamActors),
17078 "removedUpstreamActorId" | "removed_upstream_actor_id" => Ok(GeneratedField::RemovedUpstreamActorId),
17079 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17080 }
17081 }
17082 }
17083 deserializer.deserialize_identifier(GeneratedVisitor)
17084 }
17085 }
17086 struct GeneratedVisitor;
17087 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17088 type Value = update_mutation::MergeUpdate;
17089
17090 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17091 formatter.write_str("struct stream_plan.UpdateMutation.MergeUpdate")
17092 }
17093
17094 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::MergeUpdate, V::Error>
17095 where
17096 V: serde::de::MapAccess<'de>,
17097 {
17098 let mut actor_id__ = None;
17099 let mut upstream_fragment_id__ = None;
17100 let mut new_upstream_fragment_id__ = None;
17101 let mut added_upstream_actors__ = None;
17102 let mut removed_upstream_actor_id__ = None;
17103 while let Some(k) = map_.next_key()? {
17104 match k {
17105 GeneratedField::ActorId => {
17106 if actor_id__.is_some() {
17107 return Err(serde::de::Error::duplicate_field("actorId"));
17108 }
17109 actor_id__ =
17110 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17111 ;
17112 }
17113 GeneratedField::UpstreamFragmentId => {
17114 if upstream_fragment_id__.is_some() {
17115 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
17116 }
17117 upstream_fragment_id__ =
17118 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17119 ;
17120 }
17121 GeneratedField::NewUpstreamFragmentId => {
17122 if new_upstream_fragment_id__.is_some() {
17123 return Err(serde::de::Error::duplicate_field("newUpstreamFragmentId"));
17124 }
17125 new_upstream_fragment_id__ =
17126 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17127 ;
17128 }
17129 GeneratedField::AddedUpstreamActors => {
17130 if added_upstream_actors__.is_some() {
17131 return Err(serde::de::Error::duplicate_field("addedUpstreamActors"));
17132 }
17133 added_upstream_actors__ = Some(map_.next_value()?);
17134 }
17135 GeneratedField::RemovedUpstreamActorId => {
17136 if removed_upstream_actor_id__.is_some() {
17137 return Err(serde::de::Error::duplicate_field("removedUpstreamActorId"));
17138 }
17139 removed_upstream_actor_id__ =
17140 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17141 .into_iter().map(|x| x.0).collect())
17142 ;
17143 }
17144 }
17145 }
17146 Ok(update_mutation::MergeUpdate {
17147 actor_id: actor_id__.unwrap_or_default(),
17148 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
17149 new_upstream_fragment_id: new_upstream_fragment_id__,
17150 added_upstream_actors: added_upstream_actors__.unwrap_or_default(),
17151 removed_upstream_actor_id: removed_upstream_actor_id__.unwrap_or_default(),
17152 })
17153 }
17154 }
17155 deserializer.deserialize_struct("stream_plan.UpdateMutation.MergeUpdate", FIELDS, GeneratedVisitor)
17156 }
17157}
17158impl serde::Serialize for UpstreamSinkInfo {
17159 #[allow(deprecated)]
17160 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17161 where
17162 S: serde::Serializer,
17163 {
17164 use serde::ser::SerializeStruct;
17165 let mut len = 0;
17166 if self.upstream_fragment_id != 0 {
17167 len += 1;
17168 }
17169 if !self.sink_output_schema.is_empty() {
17170 len += 1;
17171 }
17172 if !self.project_exprs.is_empty() {
17173 len += 1;
17174 }
17175 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkInfo", len)?;
17176 if self.upstream_fragment_id != 0 {
17177 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
17178 }
17179 if !self.sink_output_schema.is_empty() {
17180 struct_ser.serialize_field("sinkOutputSchema", &self.sink_output_schema)?;
17181 }
17182 if !self.project_exprs.is_empty() {
17183 struct_ser.serialize_field("projectExprs", &self.project_exprs)?;
17184 }
17185 struct_ser.end()
17186 }
17187}
17188impl<'de> serde::Deserialize<'de> for UpstreamSinkInfo {
17189 #[allow(deprecated)]
17190 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17191 where
17192 D: serde::Deserializer<'de>,
17193 {
17194 const FIELDS: &[&str] = &[
17195 "upstream_fragment_id",
17196 "upstreamFragmentId",
17197 "sink_output_schema",
17198 "sinkOutputSchema",
17199 "project_exprs",
17200 "projectExprs",
17201 ];
17202
17203 #[allow(clippy::enum_variant_names)]
17204 enum GeneratedField {
17205 UpstreamFragmentId,
17206 SinkOutputSchema,
17207 ProjectExprs,
17208 }
17209 impl<'de> serde::Deserialize<'de> for GeneratedField {
17210 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17211 where
17212 D: serde::Deserializer<'de>,
17213 {
17214 struct GeneratedVisitor;
17215
17216 impl serde::de::Visitor<'_> for GeneratedVisitor {
17217 type Value = GeneratedField;
17218
17219 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17220 write!(formatter, "expected one of: {:?}", &FIELDS)
17221 }
17222
17223 #[allow(unused_variables)]
17224 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17225 where
17226 E: serde::de::Error,
17227 {
17228 match value {
17229 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
17230 "sinkOutputSchema" | "sink_output_schema" => Ok(GeneratedField::SinkOutputSchema),
17231 "projectExprs" | "project_exprs" => Ok(GeneratedField::ProjectExprs),
17232 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17233 }
17234 }
17235 }
17236 deserializer.deserialize_identifier(GeneratedVisitor)
17237 }
17238 }
17239 struct GeneratedVisitor;
17240 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17241 type Value = UpstreamSinkInfo;
17242
17243 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17244 formatter.write_str("struct stream_plan.UpstreamSinkInfo")
17245 }
17246
17247 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkInfo, V::Error>
17248 where
17249 V: serde::de::MapAccess<'de>,
17250 {
17251 let mut upstream_fragment_id__ = None;
17252 let mut sink_output_schema__ = None;
17253 let mut project_exprs__ = None;
17254 while let Some(k) = map_.next_key()? {
17255 match k {
17256 GeneratedField::UpstreamFragmentId => {
17257 if upstream_fragment_id__.is_some() {
17258 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
17259 }
17260 upstream_fragment_id__ =
17261 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17262 ;
17263 }
17264 GeneratedField::SinkOutputSchema => {
17265 if sink_output_schema__.is_some() {
17266 return Err(serde::de::Error::duplicate_field("sinkOutputSchema"));
17267 }
17268 sink_output_schema__ = Some(map_.next_value()?);
17269 }
17270 GeneratedField::ProjectExprs => {
17271 if project_exprs__.is_some() {
17272 return Err(serde::de::Error::duplicate_field("projectExprs"));
17273 }
17274 project_exprs__ = Some(map_.next_value()?);
17275 }
17276 }
17277 }
17278 Ok(UpstreamSinkInfo {
17279 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
17280 sink_output_schema: sink_output_schema__.unwrap_or_default(),
17281 project_exprs: project_exprs__.unwrap_or_default(),
17282 })
17283 }
17284 }
17285 deserializer.deserialize_struct("stream_plan.UpstreamSinkInfo", FIELDS, GeneratedVisitor)
17286 }
17287}
17288impl serde::Serialize for UpstreamSinkUnionNode {
17289 #[allow(deprecated)]
17290 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17291 where
17292 S: serde::Serializer,
17293 {
17294 use serde::ser::SerializeStruct;
17295 let mut len = 0;
17296 if !self.init_upstreams.is_empty() {
17297 len += 1;
17298 }
17299 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkUnionNode", len)?;
17300 if !self.init_upstreams.is_empty() {
17301 struct_ser.serialize_field("initUpstreams", &self.init_upstreams)?;
17302 }
17303 struct_ser.end()
17304 }
17305}
17306impl<'de> serde::Deserialize<'de> for UpstreamSinkUnionNode {
17307 #[allow(deprecated)]
17308 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17309 where
17310 D: serde::Deserializer<'de>,
17311 {
17312 const FIELDS: &[&str] = &[
17313 "init_upstreams",
17314 "initUpstreams",
17315 ];
17316
17317 #[allow(clippy::enum_variant_names)]
17318 enum GeneratedField {
17319 InitUpstreams,
17320 }
17321 impl<'de> serde::Deserialize<'de> for GeneratedField {
17322 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17323 where
17324 D: serde::Deserializer<'de>,
17325 {
17326 struct GeneratedVisitor;
17327
17328 impl serde::de::Visitor<'_> for GeneratedVisitor {
17329 type Value = GeneratedField;
17330
17331 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17332 write!(formatter, "expected one of: {:?}", &FIELDS)
17333 }
17334
17335 #[allow(unused_variables)]
17336 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17337 where
17338 E: serde::de::Error,
17339 {
17340 match value {
17341 "initUpstreams" | "init_upstreams" => Ok(GeneratedField::InitUpstreams),
17342 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17343 }
17344 }
17345 }
17346 deserializer.deserialize_identifier(GeneratedVisitor)
17347 }
17348 }
17349 struct GeneratedVisitor;
17350 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17351 type Value = UpstreamSinkUnionNode;
17352
17353 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17354 formatter.write_str("struct stream_plan.UpstreamSinkUnionNode")
17355 }
17356
17357 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkUnionNode, V::Error>
17358 where
17359 V: serde::de::MapAccess<'de>,
17360 {
17361 let mut init_upstreams__ = None;
17362 while let Some(k) = map_.next_key()? {
17363 match k {
17364 GeneratedField::InitUpstreams => {
17365 if init_upstreams__.is_some() {
17366 return Err(serde::de::Error::duplicate_field("initUpstreams"));
17367 }
17368 init_upstreams__ = Some(map_.next_value()?);
17369 }
17370 }
17371 }
17372 Ok(UpstreamSinkUnionNode {
17373 init_upstreams: init_upstreams__.unwrap_or_default(),
17374 })
17375 }
17376 }
17377 deserializer.deserialize_struct("stream_plan.UpstreamSinkUnionNode", FIELDS, GeneratedVisitor)
17378 }
17379}
17380impl serde::Serialize for ValuesNode {
17381 #[allow(deprecated)]
17382 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17383 where
17384 S: serde::Serializer,
17385 {
17386 use serde::ser::SerializeStruct;
17387 let mut len = 0;
17388 if !self.tuples.is_empty() {
17389 len += 1;
17390 }
17391 if !self.fields.is_empty() {
17392 len += 1;
17393 }
17394 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode", len)?;
17395 if !self.tuples.is_empty() {
17396 struct_ser.serialize_field("tuples", &self.tuples)?;
17397 }
17398 if !self.fields.is_empty() {
17399 struct_ser.serialize_field("fields", &self.fields)?;
17400 }
17401 struct_ser.end()
17402 }
17403}
17404impl<'de> serde::Deserialize<'de> for ValuesNode {
17405 #[allow(deprecated)]
17406 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17407 where
17408 D: serde::Deserializer<'de>,
17409 {
17410 const FIELDS: &[&str] = &[
17411 "tuples",
17412 "fields",
17413 ];
17414
17415 #[allow(clippy::enum_variant_names)]
17416 enum GeneratedField {
17417 Tuples,
17418 Fields,
17419 }
17420 impl<'de> serde::Deserialize<'de> for GeneratedField {
17421 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17422 where
17423 D: serde::Deserializer<'de>,
17424 {
17425 struct GeneratedVisitor;
17426
17427 impl serde::de::Visitor<'_> for GeneratedVisitor {
17428 type Value = GeneratedField;
17429
17430 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17431 write!(formatter, "expected one of: {:?}", &FIELDS)
17432 }
17433
17434 #[allow(unused_variables)]
17435 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17436 where
17437 E: serde::de::Error,
17438 {
17439 match value {
17440 "tuples" => Ok(GeneratedField::Tuples),
17441 "fields" => Ok(GeneratedField::Fields),
17442 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17443 }
17444 }
17445 }
17446 deserializer.deserialize_identifier(GeneratedVisitor)
17447 }
17448 }
17449 struct GeneratedVisitor;
17450 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17451 type Value = ValuesNode;
17452
17453 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17454 formatter.write_str("struct stream_plan.ValuesNode")
17455 }
17456
17457 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
17458 where
17459 V: serde::de::MapAccess<'de>,
17460 {
17461 let mut tuples__ = None;
17462 let mut fields__ = None;
17463 while let Some(k) = map_.next_key()? {
17464 match k {
17465 GeneratedField::Tuples => {
17466 if tuples__.is_some() {
17467 return Err(serde::de::Error::duplicate_field("tuples"));
17468 }
17469 tuples__ = Some(map_.next_value()?);
17470 }
17471 GeneratedField::Fields => {
17472 if fields__.is_some() {
17473 return Err(serde::de::Error::duplicate_field("fields"));
17474 }
17475 fields__ = Some(map_.next_value()?);
17476 }
17477 }
17478 }
17479 Ok(ValuesNode {
17480 tuples: tuples__.unwrap_or_default(),
17481 fields: fields__.unwrap_or_default(),
17482 })
17483 }
17484 }
17485 deserializer.deserialize_struct("stream_plan.ValuesNode", FIELDS, GeneratedVisitor)
17486 }
17487}
17488impl serde::Serialize for values_node::ExprTuple {
17489 #[allow(deprecated)]
17490 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17491 where
17492 S: serde::Serializer,
17493 {
17494 use serde::ser::SerializeStruct;
17495 let mut len = 0;
17496 if !self.cells.is_empty() {
17497 len += 1;
17498 }
17499 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode.ExprTuple", len)?;
17500 if !self.cells.is_empty() {
17501 struct_ser.serialize_field("cells", &self.cells)?;
17502 }
17503 struct_ser.end()
17504 }
17505}
17506impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
17507 #[allow(deprecated)]
17508 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17509 where
17510 D: serde::Deserializer<'de>,
17511 {
17512 const FIELDS: &[&str] = &[
17513 "cells",
17514 ];
17515
17516 #[allow(clippy::enum_variant_names)]
17517 enum GeneratedField {
17518 Cells,
17519 }
17520 impl<'de> serde::Deserialize<'de> for GeneratedField {
17521 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17522 where
17523 D: serde::Deserializer<'de>,
17524 {
17525 struct GeneratedVisitor;
17526
17527 impl serde::de::Visitor<'_> for GeneratedVisitor {
17528 type Value = GeneratedField;
17529
17530 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17531 write!(formatter, "expected one of: {:?}", &FIELDS)
17532 }
17533
17534 #[allow(unused_variables)]
17535 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17536 where
17537 E: serde::de::Error,
17538 {
17539 match value {
17540 "cells" => Ok(GeneratedField::Cells),
17541 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17542 }
17543 }
17544 }
17545 deserializer.deserialize_identifier(GeneratedVisitor)
17546 }
17547 }
17548 struct GeneratedVisitor;
17549 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17550 type Value = values_node::ExprTuple;
17551
17552 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17553 formatter.write_str("struct stream_plan.ValuesNode.ExprTuple")
17554 }
17555
17556 fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
17557 where
17558 V: serde::de::MapAccess<'de>,
17559 {
17560 let mut cells__ = None;
17561 while let Some(k) = map_.next_key()? {
17562 match k {
17563 GeneratedField::Cells => {
17564 if cells__.is_some() {
17565 return Err(serde::de::Error::duplicate_field("cells"));
17566 }
17567 cells__ = Some(map_.next_value()?);
17568 }
17569 }
17570 }
17571 Ok(values_node::ExprTuple {
17572 cells: cells__.unwrap_or_default(),
17573 })
17574 }
17575 }
17576 deserializer.deserialize_struct("stream_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
17577 }
17578}
17579impl serde::Serialize for VectorIndexLookupJoinNode {
17580 #[allow(deprecated)]
17581 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17582 where
17583 S: serde::Serializer,
17584 {
17585 use serde::ser::SerializeStruct;
17586 let mut len = 0;
17587 if self.reader_desc.is_some() {
17588 len += 1;
17589 }
17590 if self.vector_column_idx != 0 {
17591 len += 1;
17592 }
17593 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexLookupJoinNode", len)?;
17594 if let Some(v) = self.reader_desc.as_ref() {
17595 struct_ser.serialize_field("readerDesc", v)?;
17596 }
17597 if self.vector_column_idx != 0 {
17598 struct_ser.serialize_field("vectorColumnIdx", &self.vector_column_idx)?;
17599 }
17600 struct_ser.end()
17601 }
17602}
17603impl<'de> serde::Deserialize<'de> for VectorIndexLookupJoinNode {
17604 #[allow(deprecated)]
17605 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17606 where
17607 D: serde::Deserializer<'de>,
17608 {
17609 const FIELDS: &[&str] = &[
17610 "reader_desc",
17611 "readerDesc",
17612 "vector_column_idx",
17613 "vectorColumnIdx",
17614 ];
17615
17616 #[allow(clippy::enum_variant_names)]
17617 enum GeneratedField {
17618 ReaderDesc,
17619 VectorColumnIdx,
17620 }
17621 impl<'de> serde::Deserialize<'de> for GeneratedField {
17622 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17623 where
17624 D: serde::Deserializer<'de>,
17625 {
17626 struct GeneratedVisitor;
17627
17628 impl serde::de::Visitor<'_> for GeneratedVisitor {
17629 type Value = GeneratedField;
17630
17631 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17632 write!(formatter, "expected one of: {:?}", &FIELDS)
17633 }
17634
17635 #[allow(unused_variables)]
17636 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17637 where
17638 E: serde::de::Error,
17639 {
17640 match value {
17641 "readerDesc" | "reader_desc" => Ok(GeneratedField::ReaderDesc),
17642 "vectorColumnIdx" | "vector_column_idx" => Ok(GeneratedField::VectorColumnIdx),
17643 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17644 }
17645 }
17646 }
17647 deserializer.deserialize_identifier(GeneratedVisitor)
17648 }
17649 }
17650 struct GeneratedVisitor;
17651 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17652 type Value = VectorIndexLookupJoinNode;
17653
17654 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17655 formatter.write_str("struct stream_plan.VectorIndexLookupJoinNode")
17656 }
17657
17658 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexLookupJoinNode, V::Error>
17659 where
17660 V: serde::de::MapAccess<'de>,
17661 {
17662 let mut reader_desc__ = None;
17663 let mut vector_column_idx__ = None;
17664 while let Some(k) = map_.next_key()? {
17665 match k {
17666 GeneratedField::ReaderDesc => {
17667 if reader_desc__.is_some() {
17668 return Err(serde::de::Error::duplicate_field("readerDesc"));
17669 }
17670 reader_desc__ = map_.next_value()?;
17671 }
17672 GeneratedField::VectorColumnIdx => {
17673 if vector_column_idx__.is_some() {
17674 return Err(serde::de::Error::duplicate_field("vectorColumnIdx"));
17675 }
17676 vector_column_idx__ =
17677 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17678 ;
17679 }
17680 }
17681 }
17682 Ok(VectorIndexLookupJoinNode {
17683 reader_desc: reader_desc__,
17684 vector_column_idx: vector_column_idx__.unwrap_or_default(),
17685 })
17686 }
17687 }
17688 deserializer.deserialize_struct("stream_plan.VectorIndexLookupJoinNode", FIELDS, GeneratedVisitor)
17689 }
17690}
17691impl serde::Serialize for VectorIndexWriteNode {
17692 #[allow(deprecated)]
17693 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17694 where
17695 S: serde::Serializer,
17696 {
17697 use serde::ser::SerializeStruct;
17698 let mut len = 0;
17699 if self.table.is_some() {
17700 len += 1;
17701 }
17702 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexWriteNode", len)?;
17703 if let Some(v) = self.table.as_ref() {
17704 struct_ser.serialize_field("table", v)?;
17705 }
17706 struct_ser.end()
17707 }
17708}
17709impl<'de> serde::Deserialize<'de> for VectorIndexWriteNode {
17710 #[allow(deprecated)]
17711 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17712 where
17713 D: serde::Deserializer<'de>,
17714 {
17715 const FIELDS: &[&str] = &[
17716 "table",
17717 ];
17718
17719 #[allow(clippy::enum_variant_names)]
17720 enum GeneratedField {
17721 Table,
17722 }
17723 impl<'de> serde::Deserialize<'de> for GeneratedField {
17724 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17725 where
17726 D: serde::Deserializer<'de>,
17727 {
17728 struct GeneratedVisitor;
17729
17730 impl serde::de::Visitor<'_> for GeneratedVisitor {
17731 type Value = GeneratedField;
17732
17733 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17734 write!(formatter, "expected one of: {:?}", &FIELDS)
17735 }
17736
17737 #[allow(unused_variables)]
17738 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17739 where
17740 E: serde::de::Error,
17741 {
17742 match value {
17743 "table" => Ok(GeneratedField::Table),
17744 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17745 }
17746 }
17747 }
17748 deserializer.deserialize_identifier(GeneratedVisitor)
17749 }
17750 }
17751 struct GeneratedVisitor;
17752 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17753 type Value = VectorIndexWriteNode;
17754
17755 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17756 formatter.write_str("struct stream_plan.VectorIndexWriteNode")
17757 }
17758
17759 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexWriteNode, V::Error>
17760 where
17761 V: serde::de::MapAccess<'de>,
17762 {
17763 let mut table__ = None;
17764 while let Some(k) = map_.next_key()? {
17765 match k {
17766 GeneratedField::Table => {
17767 if table__.is_some() {
17768 return Err(serde::de::Error::duplicate_field("table"));
17769 }
17770 table__ = map_.next_value()?;
17771 }
17772 }
17773 }
17774 Ok(VectorIndexWriteNode {
17775 table: table__,
17776 })
17777 }
17778 }
17779 deserializer.deserialize_struct("stream_plan.VectorIndexWriteNode", FIELDS, GeneratedVisitor)
17780 }
17781}
17782impl serde::Serialize for Watermark {
17783 #[allow(deprecated)]
17784 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17785 where
17786 S: serde::Serializer,
17787 {
17788 use serde::ser::SerializeStruct;
17789 let mut len = 0;
17790 if self.column.is_some() {
17791 len += 1;
17792 }
17793 if self.val.is_some() {
17794 len += 1;
17795 }
17796 let mut struct_ser = serializer.serialize_struct("stream_plan.Watermark", len)?;
17797 if let Some(v) = self.column.as_ref() {
17798 struct_ser.serialize_field("column", v)?;
17799 }
17800 if let Some(v) = self.val.as_ref() {
17801 struct_ser.serialize_field("val", v)?;
17802 }
17803 struct_ser.end()
17804 }
17805}
17806impl<'de> serde::Deserialize<'de> for Watermark {
17807 #[allow(deprecated)]
17808 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17809 where
17810 D: serde::Deserializer<'de>,
17811 {
17812 const FIELDS: &[&str] = &[
17813 "column",
17814 "val",
17815 ];
17816
17817 #[allow(clippy::enum_variant_names)]
17818 enum GeneratedField {
17819 Column,
17820 Val,
17821 }
17822 impl<'de> serde::Deserialize<'de> for GeneratedField {
17823 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17824 where
17825 D: serde::Deserializer<'de>,
17826 {
17827 struct GeneratedVisitor;
17828
17829 impl serde::de::Visitor<'_> for GeneratedVisitor {
17830 type Value = GeneratedField;
17831
17832 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17833 write!(formatter, "expected one of: {:?}", &FIELDS)
17834 }
17835
17836 #[allow(unused_variables)]
17837 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17838 where
17839 E: serde::de::Error,
17840 {
17841 match value {
17842 "column" => Ok(GeneratedField::Column),
17843 "val" => Ok(GeneratedField::Val),
17844 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17845 }
17846 }
17847 }
17848 deserializer.deserialize_identifier(GeneratedVisitor)
17849 }
17850 }
17851 struct GeneratedVisitor;
17852 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17853 type Value = Watermark;
17854
17855 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17856 formatter.write_str("struct stream_plan.Watermark")
17857 }
17858
17859 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Watermark, V::Error>
17860 where
17861 V: serde::de::MapAccess<'de>,
17862 {
17863 let mut column__ = None;
17864 let mut val__ = None;
17865 while let Some(k) = map_.next_key()? {
17866 match k {
17867 GeneratedField::Column => {
17868 if column__.is_some() {
17869 return Err(serde::de::Error::duplicate_field("column"));
17870 }
17871 column__ = map_.next_value()?;
17872 }
17873 GeneratedField::Val => {
17874 if val__.is_some() {
17875 return Err(serde::de::Error::duplicate_field("val"));
17876 }
17877 val__ = map_.next_value()?;
17878 }
17879 }
17880 }
17881 Ok(Watermark {
17882 column: column__,
17883 val: val__,
17884 })
17885 }
17886 }
17887 deserializer.deserialize_struct("stream_plan.Watermark", FIELDS, GeneratedVisitor)
17888 }
17889}
17890impl serde::Serialize for WatermarkFilterNode {
17891 #[allow(deprecated)]
17892 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17893 where
17894 S: serde::Serializer,
17895 {
17896 use serde::ser::SerializeStruct;
17897 let mut len = 0;
17898 if !self.watermark_descs.is_empty() {
17899 len += 1;
17900 }
17901 if !self.tables.is_empty() {
17902 len += 1;
17903 }
17904 let mut struct_ser = serializer.serialize_struct("stream_plan.WatermarkFilterNode", len)?;
17905 if !self.watermark_descs.is_empty() {
17906 struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
17907 }
17908 if !self.tables.is_empty() {
17909 struct_ser.serialize_field("tables", &self.tables)?;
17910 }
17911 struct_ser.end()
17912 }
17913}
17914impl<'de> serde::Deserialize<'de> for WatermarkFilterNode {
17915 #[allow(deprecated)]
17916 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17917 where
17918 D: serde::Deserializer<'de>,
17919 {
17920 const FIELDS: &[&str] = &[
17921 "watermark_descs",
17922 "watermarkDescs",
17923 "tables",
17924 ];
17925
17926 #[allow(clippy::enum_variant_names)]
17927 enum GeneratedField {
17928 WatermarkDescs,
17929 Tables,
17930 }
17931 impl<'de> serde::Deserialize<'de> for GeneratedField {
17932 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17933 where
17934 D: serde::Deserializer<'de>,
17935 {
17936 struct GeneratedVisitor;
17937
17938 impl serde::de::Visitor<'_> for GeneratedVisitor {
17939 type Value = GeneratedField;
17940
17941 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17942 write!(formatter, "expected one of: {:?}", &FIELDS)
17943 }
17944
17945 #[allow(unused_variables)]
17946 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17947 where
17948 E: serde::de::Error,
17949 {
17950 match value {
17951 "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
17952 "tables" => Ok(GeneratedField::Tables),
17953 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17954 }
17955 }
17956 }
17957 deserializer.deserialize_identifier(GeneratedVisitor)
17958 }
17959 }
17960 struct GeneratedVisitor;
17961 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17962 type Value = WatermarkFilterNode;
17963
17964 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17965 formatter.write_str("struct stream_plan.WatermarkFilterNode")
17966 }
17967
17968 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkFilterNode, V::Error>
17969 where
17970 V: serde::de::MapAccess<'de>,
17971 {
17972 let mut watermark_descs__ = None;
17973 let mut tables__ = None;
17974 while let Some(k) = map_.next_key()? {
17975 match k {
17976 GeneratedField::WatermarkDescs => {
17977 if watermark_descs__.is_some() {
17978 return Err(serde::de::Error::duplicate_field("watermarkDescs"));
17979 }
17980 watermark_descs__ = Some(map_.next_value()?);
17981 }
17982 GeneratedField::Tables => {
17983 if tables__.is_some() {
17984 return Err(serde::de::Error::duplicate_field("tables"));
17985 }
17986 tables__ = Some(map_.next_value()?);
17987 }
17988 }
17989 }
17990 Ok(WatermarkFilterNode {
17991 watermark_descs: watermark_descs__.unwrap_or_default(),
17992 tables: tables__.unwrap_or_default(),
17993 })
17994 }
17995 }
17996 deserializer.deserialize_struct("stream_plan.WatermarkFilterNode", FIELDS, GeneratedVisitor)
17997 }
17998}