1use crate::stream_plan::*;
2impl serde::Serialize for ActorMapping {
3 #[allow(deprecated)]
4 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5 where
6 S: serde::Serializer,
7 {
8 use serde::ser::SerializeStruct;
9 let mut len = 0;
10 if !self.original_indices.is_empty() {
11 len += 1;
12 }
13 if !self.data.is_empty() {
14 len += 1;
15 }
16 let mut struct_ser = serializer.serialize_struct("stream_plan.ActorMapping", len)?;
17 if !self.original_indices.is_empty() {
18 struct_ser.serialize_field("originalIndices", &self.original_indices)?;
19 }
20 if !self.data.is_empty() {
21 struct_ser.serialize_field("data", &self.data)?;
22 }
23 struct_ser.end()
24 }
25}
26impl<'de> serde::Deserialize<'de> for ActorMapping {
27 #[allow(deprecated)]
28 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
29 where
30 D: serde::Deserializer<'de>,
31 {
32 const FIELDS: &[&str] = &[
33 "original_indices",
34 "originalIndices",
35 "data",
36 ];
37
38 #[allow(clippy::enum_variant_names)]
39 enum GeneratedField {
40 OriginalIndices,
41 Data,
42 }
43 impl<'de> serde::Deserialize<'de> for GeneratedField {
44 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
45 where
46 D: serde::Deserializer<'de>,
47 {
48 struct GeneratedVisitor;
49
50 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
51 type Value = GeneratedField;
52
53 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
54 write!(formatter, "expected one of: {:?}", &FIELDS)
55 }
56
57 #[allow(unused_variables)]
58 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
59 where
60 E: serde::de::Error,
61 {
62 match value {
63 "originalIndices" | "original_indices" => Ok(GeneratedField::OriginalIndices),
64 "data" => Ok(GeneratedField::Data),
65 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
66 }
67 }
68 }
69 deserializer.deserialize_identifier(GeneratedVisitor)
70 }
71 }
72 struct GeneratedVisitor;
73 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
74 type Value = ActorMapping;
75
76 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
77 formatter.write_str("struct stream_plan.ActorMapping")
78 }
79
80 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorMapping, V::Error>
81 where
82 V: serde::de::MapAccess<'de>,
83 {
84 let mut original_indices__ = None;
85 let mut data__ = None;
86 while let Some(k) = map_.next_key()? {
87 match k {
88 GeneratedField::OriginalIndices => {
89 if original_indices__.is_some() {
90 return Err(serde::de::Error::duplicate_field("originalIndices"));
91 }
92 original_indices__ =
93 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
94 .into_iter().map(|x| x.0).collect())
95 ;
96 }
97 GeneratedField::Data => {
98 if data__.is_some() {
99 return Err(serde::de::Error::duplicate_field("data"));
100 }
101 data__ =
102 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
103 .into_iter().map(|x| x.0).collect())
104 ;
105 }
106 }
107 }
108 Ok(ActorMapping {
109 original_indices: original_indices__.unwrap_or_default(),
110 data: data__.unwrap_or_default(),
111 })
112 }
113 }
114 deserializer.deserialize_struct("stream_plan.ActorMapping", FIELDS, GeneratedVisitor)
115 }
116}
117impl serde::Serialize for AddMutation {
118 #[allow(deprecated)]
119 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
120 where
121 S: serde::Serializer,
122 {
123 use serde::ser::SerializeStruct;
124 let mut len = 0;
125 if !self.actor_dispatchers.is_empty() {
126 len += 1;
127 }
128 if !self.added_actors.is_empty() {
129 len += 1;
130 }
131 if !self.actor_splits.is_empty() {
132 len += 1;
133 }
134 if self.pause {
135 len += 1;
136 }
137 if !self.subscriptions_to_add.is_empty() {
138 len += 1;
139 }
140 if !self.backfill_nodes_to_pause.is_empty() {
141 len += 1;
142 }
143 if self.actor_cdc_table_snapshot_splits.is_some() {
144 len += 1;
145 }
146 if !self.new_upstream_sinks.is_empty() {
147 len += 1;
148 }
149 let mut struct_ser = serializer.serialize_struct("stream_plan.AddMutation", len)?;
150 if !self.actor_dispatchers.is_empty() {
151 struct_ser.serialize_field("actorDispatchers", &self.actor_dispatchers)?;
152 }
153 if !self.added_actors.is_empty() {
154 struct_ser.serialize_field("addedActors", &self.added_actors)?;
155 }
156 if !self.actor_splits.is_empty() {
157 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
158 }
159 if self.pause {
160 struct_ser.serialize_field("pause", &self.pause)?;
161 }
162 if !self.subscriptions_to_add.is_empty() {
163 struct_ser.serialize_field("subscriptionsToAdd", &self.subscriptions_to_add)?;
164 }
165 if !self.backfill_nodes_to_pause.is_empty() {
166 struct_ser.serialize_field("backfillNodesToPause", &self.backfill_nodes_to_pause)?;
167 }
168 if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
169 struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
170 }
171 if !self.new_upstream_sinks.is_empty() {
172 struct_ser.serialize_field("newUpstreamSinks", &self.new_upstream_sinks)?;
173 }
174 struct_ser.end()
175 }
176}
177impl<'de> serde::Deserialize<'de> for AddMutation {
178 #[allow(deprecated)]
179 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
180 where
181 D: serde::Deserializer<'de>,
182 {
183 const FIELDS: &[&str] = &[
184 "actor_dispatchers",
185 "actorDispatchers",
186 "added_actors",
187 "addedActors",
188 "actor_splits",
189 "actorSplits",
190 "pause",
191 "subscriptions_to_add",
192 "subscriptionsToAdd",
193 "backfill_nodes_to_pause",
194 "backfillNodesToPause",
195 "actor_cdc_table_snapshot_splits",
196 "actorCdcTableSnapshotSplits",
197 "new_upstream_sinks",
198 "newUpstreamSinks",
199 ];
200
201 #[allow(clippy::enum_variant_names)]
202 enum GeneratedField {
203 ActorDispatchers,
204 AddedActors,
205 ActorSplits,
206 Pause,
207 SubscriptionsToAdd,
208 BackfillNodesToPause,
209 ActorCdcTableSnapshotSplits,
210 NewUpstreamSinks,
211 }
212 impl<'de> serde::Deserialize<'de> for GeneratedField {
213 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
214 where
215 D: serde::Deserializer<'de>,
216 {
217 struct GeneratedVisitor;
218
219 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
220 type Value = GeneratedField;
221
222 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
223 write!(formatter, "expected one of: {:?}", &FIELDS)
224 }
225
226 #[allow(unused_variables)]
227 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
228 where
229 E: serde::de::Error,
230 {
231 match value {
232 "actorDispatchers" | "actor_dispatchers" => Ok(GeneratedField::ActorDispatchers),
233 "addedActors" | "added_actors" => Ok(GeneratedField::AddedActors),
234 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
235 "pause" => Ok(GeneratedField::Pause),
236 "subscriptionsToAdd" | "subscriptions_to_add" => Ok(GeneratedField::SubscriptionsToAdd),
237 "backfillNodesToPause" | "backfill_nodes_to_pause" => Ok(GeneratedField::BackfillNodesToPause),
238 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
239 "newUpstreamSinks" | "new_upstream_sinks" => Ok(GeneratedField::NewUpstreamSinks),
240 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
241 }
242 }
243 }
244 deserializer.deserialize_identifier(GeneratedVisitor)
245 }
246 }
247 struct GeneratedVisitor;
248 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
249 type Value = AddMutation;
250
251 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
252 formatter.write_str("struct stream_plan.AddMutation")
253 }
254
255 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddMutation, V::Error>
256 where
257 V: serde::de::MapAccess<'de>,
258 {
259 let mut actor_dispatchers__ = None;
260 let mut added_actors__ = None;
261 let mut actor_splits__ = None;
262 let mut pause__ = None;
263 let mut subscriptions_to_add__ = None;
264 let mut backfill_nodes_to_pause__ = None;
265 let mut actor_cdc_table_snapshot_splits__ = None;
266 let mut new_upstream_sinks__ = None;
267 while let Some(k) = map_.next_key()? {
268 match k {
269 GeneratedField::ActorDispatchers => {
270 if actor_dispatchers__.is_some() {
271 return Err(serde::de::Error::duplicate_field("actorDispatchers"));
272 }
273 actor_dispatchers__ = Some(
274 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
275 .into_iter().map(|(k,v)| (k.0, v)).collect()
276 );
277 }
278 GeneratedField::AddedActors => {
279 if added_actors__.is_some() {
280 return Err(serde::de::Error::duplicate_field("addedActors"));
281 }
282 added_actors__ =
283 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
284 .into_iter().map(|x| x.0).collect())
285 ;
286 }
287 GeneratedField::ActorSplits => {
288 if actor_splits__.is_some() {
289 return Err(serde::de::Error::duplicate_field("actorSplits"));
290 }
291 actor_splits__ = Some(
292 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
293 .into_iter().map(|(k,v)| (k.0, v)).collect()
294 );
295 }
296 GeneratedField::Pause => {
297 if pause__.is_some() {
298 return Err(serde::de::Error::duplicate_field("pause"));
299 }
300 pause__ = Some(map_.next_value()?);
301 }
302 GeneratedField::SubscriptionsToAdd => {
303 if subscriptions_to_add__.is_some() {
304 return Err(serde::de::Error::duplicate_field("subscriptionsToAdd"));
305 }
306 subscriptions_to_add__ = Some(map_.next_value()?);
307 }
308 GeneratedField::BackfillNodesToPause => {
309 if backfill_nodes_to_pause__.is_some() {
310 return Err(serde::de::Error::duplicate_field("backfillNodesToPause"));
311 }
312 backfill_nodes_to_pause__ =
313 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
314 .into_iter().map(|x| x.0).collect())
315 ;
316 }
317 GeneratedField::ActorCdcTableSnapshotSplits => {
318 if actor_cdc_table_snapshot_splits__.is_some() {
319 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
320 }
321 actor_cdc_table_snapshot_splits__ = map_.next_value()?;
322 }
323 GeneratedField::NewUpstreamSinks => {
324 if new_upstream_sinks__.is_some() {
325 return Err(serde::de::Error::duplicate_field("newUpstreamSinks"));
326 }
327 new_upstream_sinks__ = Some(
328 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
329 .into_iter().map(|(k,v)| (k.0, v)).collect()
330 );
331 }
332 }
333 }
334 Ok(AddMutation {
335 actor_dispatchers: actor_dispatchers__.unwrap_or_default(),
336 added_actors: added_actors__.unwrap_or_default(),
337 actor_splits: actor_splits__.unwrap_or_default(),
338 pause: pause__.unwrap_or_default(),
339 subscriptions_to_add: subscriptions_to_add__.unwrap_or_default(),
340 backfill_nodes_to_pause: backfill_nodes_to_pause__.unwrap_or_default(),
341 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
342 new_upstream_sinks: new_upstream_sinks__.unwrap_or_default(),
343 })
344 }
345 }
346 deserializer.deserialize_struct("stream_plan.AddMutation", FIELDS, GeneratedVisitor)
347 }
348}
349impl serde::Serialize for add_mutation::NewUpstreamSink {
350 #[allow(deprecated)]
351 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
352 where
353 S: serde::Serializer,
354 {
355 use serde::ser::SerializeStruct;
356 let mut len = 0;
357 if self.info.is_some() {
358 len += 1;
359 }
360 if !self.upstream_actors.is_empty() {
361 len += 1;
362 }
363 let mut struct_ser = serializer.serialize_struct("stream_plan.AddMutation.NewUpstreamSink", len)?;
364 if let Some(v) = self.info.as_ref() {
365 struct_ser.serialize_field("info", v)?;
366 }
367 if !self.upstream_actors.is_empty() {
368 struct_ser.serialize_field("upstreamActors", &self.upstream_actors)?;
369 }
370 struct_ser.end()
371 }
372}
373impl<'de> serde::Deserialize<'de> for add_mutation::NewUpstreamSink {
374 #[allow(deprecated)]
375 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
376 where
377 D: serde::Deserializer<'de>,
378 {
379 const FIELDS: &[&str] = &[
380 "info",
381 "upstream_actors",
382 "upstreamActors",
383 ];
384
385 #[allow(clippy::enum_variant_names)]
386 enum GeneratedField {
387 Info,
388 UpstreamActors,
389 }
390 impl<'de> serde::Deserialize<'de> for GeneratedField {
391 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
392 where
393 D: serde::Deserializer<'de>,
394 {
395 struct GeneratedVisitor;
396
397 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
398 type Value = GeneratedField;
399
400 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
401 write!(formatter, "expected one of: {:?}", &FIELDS)
402 }
403
404 #[allow(unused_variables)]
405 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
406 where
407 E: serde::de::Error,
408 {
409 match value {
410 "info" => Ok(GeneratedField::Info),
411 "upstreamActors" | "upstream_actors" => Ok(GeneratedField::UpstreamActors),
412 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
413 }
414 }
415 }
416 deserializer.deserialize_identifier(GeneratedVisitor)
417 }
418 }
419 struct GeneratedVisitor;
420 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
421 type Value = add_mutation::NewUpstreamSink;
422
423 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
424 formatter.write_str("struct stream_plan.AddMutation.NewUpstreamSink")
425 }
426
427 fn visit_map<V>(self, mut map_: V) -> std::result::Result<add_mutation::NewUpstreamSink, V::Error>
428 where
429 V: serde::de::MapAccess<'de>,
430 {
431 let mut info__ = None;
432 let mut upstream_actors__ = None;
433 while let Some(k) = map_.next_key()? {
434 match k {
435 GeneratedField::Info => {
436 if info__.is_some() {
437 return Err(serde::de::Error::duplicate_field("info"));
438 }
439 info__ = map_.next_value()?;
440 }
441 GeneratedField::UpstreamActors => {
442 if upstream_actors__.is_some() {
443 return Err(serde::de::Error::duplicate_field("upstreamActors"));
444 }
445 upstream_actors__ = Some(map_.next_value()?);
446 }
447 }
448 }
449 Ok(add_mutation::NewUpstreamSink {
450 info: info__,
451 upstream_actors: upstream_actors__.unwrap_or_default(),
452 })
453 }
454 }
455 deserializer.deserialize_struct("stream_plan.AddMutation.NewUpstreamSink", FIELDS, GeneratedVisitor)
456 }
457}
458impl serde::Serialize for AggCallState {
459 #[allow(deprecated)]
460 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
461 where
462 S: serde::Serializer,
463 {
464 use serde::ser::SerializeStruct;
465 let mut len = 0;
466 if self.inner.is_some() {
467 len += 1;
468 }
469 let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState", len)?;
470 if let Some(v) = self.inner.as_ref() {
471 match v {
472 agg_call_state::Inner::ValueState(v) => {
473 struct_ser.serialize_field("valueState", v)?;
474 }
475 agg_call_state::Inner::MaterializedInputState(v) => {
476 struct_ser.serialize_field("materializedInputState", v)?;
477 }
478 }
479 }
480 struct_ser.end()
481 }
482}
483impl<'de> serde::Deserialize<'de> for AggCallState {
484 #[allow(deprecated)]
485 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
486 where
487 D: serde::Deserializer<'de>,
488 {
489 const FIELDS: &[&str] = &[
490 "value_state",
491 "valueState",
492 "materialized_input_state",
493 "materializedInputState",
494 ];
495
496 #[allow(clippy::enum_variant_names)]
497 enum GeneratedField {
498 ValueState,
499 MaterializedInputState,
500 }
501 impl<'de> serde::Deserialize<'de> for GeneratedField {
502 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
503 where
504 D: serde::Deserializer<'de>,
505 {
506 struct GeneratedVisitor;
507
508 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
509 type Value = GeneratedField;
510
511 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
512 write!(formatter, "expected one of: {:?}", &FIELDS)
513 }
514
515 #[allow(unused_variables)]
516 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
517 where
518 E: serde::de::Error,
519 {
520 match value {
521 "valueState" | "value_state" => Ok(GeneratedField::ValueState),
522 "materializedInputState" | "materialized_input_state" => Ok(GeneratedField::MaterializedInputState),
523 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
524 }
525 }
526 }
527 deserializer.deserialize_identifier(GeneratedVisitor)
528 }
529 }
530 struct GeneratedVisitor;
531 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
532 type Value = AggCallState;
533
534 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
535 formatter.write_str("struct stream_plan.AggCallState")
536 }
537
538 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AggCallState, V::Error>
539 where
540 V: serde::de::MapAccess<'de>,
541 {
542 let mut inner__ = None;
543 while let Some(k) = map_.next_key()? {
544 match k {
545 GeneratedField::ValueState => {
546 if inner__.is_some() {
547 return Err(serde::de::Error::duplicate_field("valueState"));
548 }
549 inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::ValueState)
550;
551 }
552 GeneratedField::MaterializedInputState => {
553 if inner__.is_some() {
554 return Err(serde::de::Error::duplicate_field("materializedInputState"));
555 }
556 inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::MaterializedInputState)
557;
558 }
559 }
560 }
561 Ok(AggCallState {
562 inner: inner__,
563 })
564 }
565 }
566 deserializer.deserialize_struct("stream_plan.AggCallState", FIELDS, GeneratedVisitor)
567 }
568}
569impl serde::Serialize for agg_call_state::MaterializedInputState {
570 #[allow(deprecated)]
571 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
572 where
573 S: serde::Serializer,
574 {
575 use serde::ser::SerializeStruct;
576 let mut len = 0;
577 if self.table.is_some() {
578 len += 1;
579 }
580 if !self.included_upstream_indices.is_empty() {
581 len += 1;
582 }
583 if !self.table_value_indices.is_empty() {
584 len += 1;
585 }
586 if !self.order_columns.is_empty() {
587 len += 1;
588 }
589 let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState.MaterializedInputState", len)?;
590 if let Some(v) = self.table.as_ref() {
591 struct_ser.serialize_field("table", v)?;
592 }
593 if !self.included_upstream_indices.is_empty() {
594 struct_ser.serialize_field("includedUpstreamIndices", &self.included_upstream_indices)?;
595 }
596 if !self.table_value_indices.is_empty() {
597 struct_ser.serialize_field("tableValueIndices", &self.table_value_indices)?;
598 }
599 if !self.order_columns.is_empty() {
600 struct_ser.serialize_field("orderColumns", &self.order_columns)?;
601 }
602 struct_ser.end()
603 }
604}
605impl<'de> serde::Deserialize<'de> for agg_call_state::MaterializedInputState {
606 #[allow(deprecated)]
607 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
608 where
609 D: serde::Deserializer<'de>,
610 {
611 const FIELDS: &[&str] = &[
612 "table",
613 "included_upstream_indices",
614 "includedUpstreamIndices",
615 "table_value_indices",
616 "tableValueIndices",
617 "order_columns",
618 "orderColumns",
619 ];
620
621 #[allow(clippy::enum_variant_names)]
622 enum GeneratedField {
623 Table,
624 IncludedUpstreamIndices,
625 TableValueIndices,
626 OrderColumns,
627 }
628 impl<'de> serde::Deserialize<'de> for GeneratedField {
629 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
630 where
631 D: serde::Deserializer<'de>,
632 {
633 struct GeneratedVisitor;
634
635 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
636 type Value = GeneratedField;
637
638 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
639 write!(formatter, "expected one of: {:?}", &FIELDS)
640 }
641
642 #[allow(unused_variables)]
643 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
644 where
645 E: serde::de::Error,
646 {
647 match value {
648 "table" => Ok(GeneratedField::Table),
649 "includedUpstreamIndices" | "included_upstream_indices" => Ok(GeneratedField::IncludedUpstreamIndices),
650 "tableValueIndices" | "table_value_indices" => Ok(GeneratedField::TableValueIndices),
651 "orderColumns" | "order_columns" => Ok(GeneratedField::OrderColumns),
652 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
653 }
654 }
655 }
656 deserializer.deserialize_identifier(GeneratedVisitor)
657 }
658 }
659 struct GeneratedVisitor;
660 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
661 type Value = agg_call_state::MaterializedInputState;
662
663 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
664 formatter.write_str("struct stream_plan.AggCallState.MaterializedInputState")
665 }
666
667 fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::MaterializedInputState, V::Error>
668 where
669 V: serde::de::MapAccess<'de>,
670 {
671 let mut table__ = None;
672 let mut included_upstream_indices__ = None;
673 let mut table_value_indices__ = None;
674 let mut order_columns__ = None;
675 while let Some(k) = map_.next_key()? {
676 match k {
677 GeneratedField::Table => {
678 if table__.is_some() {
679 return Err(serde::de::Error::duplicate_field("table"));
680 }
681 table__ = map_.next_value()?;
682 }
683 GeneratedField::IncludedUpstreamIndices => {
684 if included_upstream_indices__.is_some() {
685 return Err(serde::de::Error::duplicate_field("includedUpstreamIndices"));
686 }
687 included_upstream_indices__ =
688 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
689 .into_iter().map(|x| x.0).collect())
690 ;
691 }
692 GeneratedField::TableValueIndices => {
693 if table_value_indices__.is_some() {
694 return Err(serde::de::Error::duplicate_field("tableValueIndices"));
695 }
696 table_value_indices__ =
697 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
698 .into_iter().map(|x| x.0).collect())
699 ;
700 }
701 GeneratedField::OrderColumns => {
702 if order_columns__.is_some() {
703 return Err(serde::de::Error::duplicate_field("orderColumns"));
704 }
705 order_columns__ = Some(map_.next_value()?);
706 }
707 }
708 }
709 Ok(agg_call_state::MaterializedInputState {
710 table: table__,
711 included_upstream_indices: included_upstream_indices__.unwrap_or_default(),
712 table_value_indices: table_value_indices__.unwrap_or_default(),
713 order_columns: order_columns__.unwrap_or_default(),
714 })
715 }
716 }
717 deserializer.deserialize_struct("stream_plan.AggCallState.MaterializedInputState", FIELDS, GeneratedVisitor)
718 }
719}
720impl serde::Serialize for agg_call_state::ValueState {
721 #[allow(deprecated)]
722 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
723 where
724 S: serde::Serializer,
725 {
726 use serde::ser::SerializeStruct;
727 let len = 0;
728 let struct_ser = serializer.serialize_struct("stream_plan.AggCallState.ValueState", len)?;
729 struct_ser.end()
730 }
731}
732impl<'de> serde::Deserialize<'de> for agg_call_state::ValueState {
733 #[allow(deprecated)]
734 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
735 where
736 D: serde::Deserializer<'de>,
737 {
738 const FIELDS: &[&str] = &[
739 ];
740
741 #[allow(clippy::enum_variant_names)]
742 enum GeneratedField {
743 }
744 impl<'de> serde::Deserialize<'de> for GeneratedField {
745 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
746 where
747 D: serde::Deserializer<'de>,
748 {
749 struct GeneratedVisitor;
750
751 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
752 type Value = GeneratedField;
753
754 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
755 write!(formatter, "expected one of: {:?}", &FIELDS)
756 }
757
758 #[allow(unused_variables)]
759 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
760 where
761 E: serde::de::Error,
762 {
763 Err(serde::de::Error::unknown_field(value, FIELDS))
764 }
765 }
766 deserializer.deserialize_identifier(GeneratedVisitor)
767 }
768 }
769 struct GeneratedVisitor;
770 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
771 type Value = agg_call_state::ValueState;
772
773 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
774 formatter.write_str("struct stream_plan.AggCallState.ValueState")
775 }
776
777 fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::ValueState, V::Error>
778 where
779 V: serde::de::MapAccess<'de>,
780 {
781 while map_.next_key::<GeneratedField>()?.is_some() {
782 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
783 }
784 Ok(agg_call_state::ValueState {
785 })
786 }
787 }
788 deserializer.deserialize_struct("stream_plan.AggCallState.ValueState", FIELDS, GeneratedVisitor)
789 }
790}
791impl serde::Serialize for AggNodeVersion {
792 #[allow(deprecated)]
793 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
794 where
795 S: serde::Serializer,
796 {
797 let variant = match self {
798 Self::Unspecified => "AGG_NODE_VERSION_UNSPECIFIED",
799 Self::Issue12140 => "AGG_NODE_VERSION_ISSUE_12140",
800 Self::Issue13465 => "AGG_NODE_VERSION_ISSUE_13465",
801 };
802 serializer.serialize_str(variant)
803 }
804}
805impl<'de> serde::Deserialize<'de> for AggNodeVersion {
806 #[allow(deprecated)]
807 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
808 where
809 D: serde::Deserializer<'de>,
810 {
811 const FIELDS: &[&str] = &[
812 "AGG_NODE_VERSION_UNSPECIFIED",
813 "AGG_NODE_VERSION_ISSUE_12140",
814 "AGG_NODE_VERSION_ISSUE_13465",
815 ];
816
817 struct GeneratedVisitor;
818
819 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
820 type Value = AggNodeVersion;
821
822 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
823 write!(formatter, "expected one of: {:?}", &FIELDS)
824 }
825
826 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
827 where
828 E: serde::de::Error,
829 {
830 i32::try_from(v)
831 .ok()
832 .and_then(|x| x.try_into().ok())
833 .ok_or_else(|| {
834 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
835 })
836 }
837
838 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
839 where
840 E: serde::de::Error,
841 {
842 i32::try_from(v)
843 .ok()
844 .and_then(|x| x.try_into().ok())
845 .ok_or_else(|| {
846 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
847 })
848 }
849
850 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
851 where
852 E: serde::de::Error,
853 {
854 match value {
855 "AGG_NODE_VERSION_UNSPECIFIED" => Ok(AggNodeVersion::Unspecified),
856 "AGG_NODE_VERSION_ISSUE_12140" => Ok(AggNodeVersion::Issue12140),
857 "AGG_NODE_VERSION_ISSUE_13465" => Ok(AggNodeVersion::Issue13465),
858 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
859 }
860 }
861 }
862 deserializer.deserialize_any(GeneratedVisitor)
863 }
864}
865impl serde::Serialize for ArrangeNode {
866 #[allow(deprecated)]
867 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
868 where
869 S: serde::Serializer,
870 {
871 use serde::ser::SerializeStruct;
872 let mut len = 0;
873 if self.table_info.is_some() {
874 len += 1;
875 }
876 if !self.distribution_key.is_empty() {
877 len += 1;
878 }
879 if self.table.is_some() {
880 len += 1;
881 }
882 let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangeNode", len)?;
883 if let Some(v) = self.table_info.as_ref() {
884 struct_ser.serialize_field("tableInfo", v)?;
885 }
886 if !self.distribution_key.is_empty() {
887 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
888 }
889 if let Some(v) = self.table.as_ref() {
890 struct_ser.serialize_field("table", v)?;
891 }
892 struct_ser.end()
893 }
894}
895impl<'de> serde::Deserialize<'de> for ArrangeNode {
896 #[allow(deprecated)]
897 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
898 where
899 D: serde::Deserializer<'de>,
900 {
901 const FIELDS: &[&str] = &[
902 "table_info",
903 "tableInfo",
904 "distribution_key",
905 "distributionKey",
906 "table",
907 ];
908
909 #[allow(clippy::enum_variant_names)]
910 enum GeneratedField {
911 TableInfo,
912 DistributionKey,
913 Table,
914 }
915 impl<'de> serde::Deserialize<'de> for GeneratedField {
916 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
917 where
918 D: serde::Deserializer<'de>,
919 {
920 struct GeneratedVisitor;
921
922 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
923 type Value = GeneratedField;
924
925 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
926 write!(formatter, "expected one of: {:?}", &FIELDS)
927 }
928
929 #[allow(unused_variables)]
930 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
931 where
932 E: serde::de::Error,
933 {
934 match value {
935 "tableInfo" | "table_info" => Ok(GeneratedField::TableInfo),
936 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
937 "table" => Ok(GeneratedField::Table),
938 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
939 }
940 }
941 }
942 deserializer.deserialize_identifier(GeneratedVisitor)
943 }
944 }
945 struct GeneratedVisitor;
946 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
947 type Value = ArrangeNode;
948
949 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
950 formatter.write_str("struct stream_plan.ArrangeNode")
951 }
952
953 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangeNode, V::Error>
954 where
955 V: serde::de::MapAccess<'de>,
956 {
957 let mut table_info__ = None;
958 let mut distribution_key__ = None;
959 let mut table__ = None;
960 while let Some(k) = map_.next_key()? {
961 match k {
962 GeneratedField::TableInfo => {
963 if table_info__.is_some() {
964 return Err(serde::de::Error::duplicate_field("tableInfo"));
965 }
966 table_info__ = map_.next_value()?;
967 }
968 GeneratedField::DistributionKey => {
969 if distribution_key__.is_some() {
970 return Err(serde::de::Error::duplicate_field("distributionKey"));
971 }
972 distribution_key__ =
973 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
974 .into_iter().map(|x| x.0).collect())
975 ;
976 }
977 GeneratedField::Table => {
978 if table__.is_some() {
979 return Err(serde::de::Error::duplicate_field("table"));
980 }
981 table__ = map_.next_value()?;
982 }
983 }
984 }
985 Ok(ArrangeNode {
986 table_info: table_info__,
987 distribution_key: distribution_key__.unwrap_or_default(),
988 table: table__,
989 })
990 }
991 }
992 deserializer.deserialize_struct("stream_plan.ArrangeNode", FIELDS, GeneratedVisitor)
993 }
994}
995impl serde::Serialize for ArrangementInfo {
996 #[allow(deprecated)]
997 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
998 where
999 S: serde::Serializer,
1000 {
1001 use serde::ser::SerializeStruct;
1002 let mut len = 0;
1003 if !self.arrange_key_orders.is_empty() {
1004 len += 1;
1005 }
1006 if !self.column_descs.is_empty() {
1007 len += 1;
1008 }
1009 if self.table_desc.is_some() {
1010 len += 1;
1011 }
1012 if !self.output_col_idx.is_empty() {
1013 len += 1;
1014 }
1015 let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangementInfo", len)?;
1016 if !self.arrange_key_orders.is_empty() {
1017 struct_ser.serialize_field("arrangeKeyOrders", &self.arrange_key_orders)?;
1018 }
1019 if !self.column_descs.is_empty() {
1020 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
1021 }
1022 if let Some(v) = self.table_desc.as_ref() {
1023 struct_ser.serialize_field("tableDesc", v)?;
1024 }
1025 if !self.output_col_idx.is_empty() {
1026 struct_ser.serialize_field("outputColIdx", &self.output_col_idx)?;
1027 }
1028 struct_ser.end()
1029 }
1030}
1031impl<'de> serde::Deserialize<'de> for ArrangementInfo {
1032 #[allow(deprecated)]
1033 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1034 where
1035 D: serde::Deserializer<'de>,
1036 {
1037 const FIELDS: &[&str] = &[
1038 "arrange_key_orders",
1039 "arrangeKeyOrders",
1040 "column_descs",
1041 "columnDescs",
1042 "table_desc",
1043 "tableDesc",
1044 "output_col_idx",
1045 "outputColIdx",
1046 ];
1047
1048 #[allow(clippy::enum_variant_names)]
1049 enum GeneratedField {
1050 ArrangeKeyOrders,
1051 ColumnDescs,
1052 TableDesc,
1053 OutputColIdx,
1054 }
1055 impl<'de> serde::Deserialize<'de> for GeneratedField {
1056 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1057 where
1058 D: serde::Deserializer<'de>,
1059 {
1060 struct GeneratedVisitor;
1061
1062 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1063 type Value = GeneratedField;
1064
1065 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1066 write!(formatter, "expected one of: {:?}", &FIELDS)
1067 }
1068
1069 #[allow(unused_variables)]
1070 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1071 where
1072 E: serde::de::Error,
1073 {
1074 match value {
1075 "arrangeKeyOrders" | "arrange_key_orders" => Ok(GeneratedField::ArrangeKeyOrders),
1076 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
1077 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
1078 "outputColIdx" | "output_col_idx" => Ok(GeneratedField::OutputColIdx),
1079 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1080 }
1081 }
1082 }
1083 deserializer.deserialize_identifier(GeneratedVisitor)
1084 }
1085 }
1086 struct GeneratedVisitor;
1087 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1088 type Value = ArrangementInfo;
1089
1090 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1091 formatter.write_str("struct stream_plan.ArrangementInfo")
1092 }
1093
1094 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangementInfo, V::Error>
1095 where
1096 V: serde::de::MapAccess<'de>,
1097 {
1098 let mut arrange_key_orders__ = None;
1099 let mut column_descs__ = None;
1100 let mut table_desc__ = None;
1101 let mut output_col_idx__ = None;
1102 while let Some(k) = map_.next_key()? {
1103 match k {
1104 GeneratedField::ArrangeKeyOrders => {
1105 if arrange_key_orders__.is_some() {
1106 return Err(serde::de::Error::duplicate_field("arrangeKeyOrders"));
1107 }
1108 arrange_key_orders__ = Some(map_.next_value()?);
1109 }
1110 GeneratedField::ColumnDescs => {
1111 if column_descs__.is_some() {
1112 return Err(serde::de::Error::duplicate_field("columnDescs"));
1113 }
1114 column_descs__ = Some(map_.next_value()?);
1115 }
1116 GeneratedField::TableDesc => {
1117 if table_desc__.is_some() {
1118 return Err(serde::de::Error::duplicate_field("tableDesc"));
1119 }
1120 table_desc__ = map_.next_value()?;
1121 }
1122 GeneratedField::OutputColIdx => {
1123 if output_col_idx__.is_some() {
1124 return Err(serde::de::Error::duplicate_field("outputColIdx"));
1125 }
1126 output_col_idx__ =
1127 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1128 .into_iter().map(|x| x.0).collect())
1129 ;
1130 }
1131 }
1132 }
1133 Ok(ArrangementInfo {
1134 arrange_key_orders: arrange_key_orders__.unwrap_or_default(),
1135 column_descs: column_descs__.unwrap_or_default(),
1136 table_desc: table_desc__,
1137 output_col_idx: output_col_idx__.unwrap_or_default(),
1138 })
1139 }
1140 }
1141 deserializer.deserialize_struct("stream_plan.ArrangementInfo", FIELDS, GeneratedVisitor)
1142 }
1143}
1144impl serde::Serialize for AsOfJoinNode {
1145 #[allow(deprecated)]
1146 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1147 where
1148 S: serde::Serializer,
1149 {
1150 use serde::ser::SerializeStruct;
1151 let mut len = 0;
1152 if self.join_type != 0 {
1153 len += 1;
1154 }
1155 if !self.left_key.is_empty() {
1156 len += 1;
1157 }
1158 if !self.right_key.is_empty() {
1159 len += 1;
1160 }
1161 if self.left_table.is_some() {
1162 len += 1;
1163 }
1164 if self.right_table.is_some() {
1165 len += 1;
1166 }
1167 if !self.output_indices.is_empty() {
1168 len += 1;
1169 }
1170 if !self.left_deduped_input_pk_indices.is_empty() {
1171 len += 1;
1172 }
1173 if !self.right_deduped_input_pk_indices.is_empty() {
1174 len += 1;
1175 }
1176 if !self.null_safe.is_empty() {
1177 len += 1;
1178 }
1179 if self.asof_desc.is_some() {
1180 len += 1;
1181 }
1182 if self.join_encoding_type != 0 {
1183 len += 1;
1184 }
1185 let mut struct_ser = serializer.serialize_struct("stream_plan.AsOfJoinNode", len)?;
1186 if self.join_type != 0 {
1187 let v = super::plan_common::AsOfJoinType::try_from(self.join_type)
1188 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
1189 struct_ser.serialize_field("joinType", &v)?;
1190 }
1191 if !self.left_key.is_empty() {
1192 struct_ser.serialize_field("leftKey", &self.left_key)?;
1193 }
1194 if !self.right_key.is_empty() {
1195 struct_ser.serialize_field("rightKey", &self.right_key)?;
1196 }
1197 if let Some(v) = self.left_table.as_ref() {
1198 struct_ser.serialize_field("leftTable", v)?;
1199 }
1200 if let Some(v) = self.right_table.as_ref() {
1201 struct_ser.serialize_field("rightTable", v)?;
1202 }
1203 if !self.output_indices.is_empty() {
1204 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
1205 }
1206 if !self.left_deduped_input_pk_indices.is_empty() {
1207 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
1208 }
1209 if !self.right_deduped_input_pk_indices.is_empty() {
1210 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
1211 }
1212 if !self.null_safe.is_empty() {
1213 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
1214 }
1215 if let Some(v) = self.asof_desc.as_ref() {
1216 struct_ser.serialize_field("asofDesc", v)?;
1217 }
1218 if self.join_encoding_type != 0 {
1219 let v = JoinEncodingType::try_from(self.join_encoding_type)
1220 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
1221 struct_ser.serialize_field("joinEncodingType", &v)?;
1222 }
1223 struct_ser.end()
1224 }
1225}
1226impl<'de> serde::Deserialize<'de> for AsOfJoinNode {
1227 #[allow(deprecated)]
1228 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1229 where
1230 D: serde::Deserializer<'de>,
1231 {
1232 const FIELDS: &[&str] = &[
1233 "join_type",
1234 "joinType",
1235 "left_key",
1236 "leftKey",
1237 "right_key",
1238 "rightKey",
1239 "left_table",
1240 "leftTable",
1241 "right_table",
1242 "rightTable",
1243 "output_indices",
1244 "outputIndices",
1245 "left_deduped_input_pk_indices",
1246 "leftDedupedInputPkIndices",
1247 "right_deduped_input_pk_indices",
1248 "rightDedupedInputPkIndices",
1249 "null_safe",
1250 "nullSafe",
1251 "asof_desc",
1252 "asofDesc",
1253 "join_encoding_type",
1254 "joinEncodingType",
1255 ];
1256
1257 #[allow(clippy::enum_variant_names)]
1258 enum GeneratedField {
1259 JoinType,
1260 LeftKey,
1261 RightKey,
1262 LeftTable,
1263 RightTable,
1264 OutputIndices,
1265 LeftDedupedInputPkIndices,
1266 RightDedupedInputPkIndices,
1267 NullSafe,
1268 AsofDesc,
1269 JoinEncodingType,
1270 }
1271 impl<'de> serde::Deserialize<'de> for GeneratedField {
1272 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1273 where
1274 D: serde::Deserializer<'de>,
1275 {
1276 struct GeneratedVisitor;
1277
1278 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1279 type Value = GeneratedField;
1280
1281 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1282 write!(formatter, "expected one of: {:?}", &FIELDS)
1283 }
1284
1285 #[allow(unused_variables)]
1286 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1287 where
1288 E: serde::de::Error,
1289 {
1290 match value {
1291 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
1292 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
1293 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
1294 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
1295 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
1296 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
1297 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
1298 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
1299 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
1300 "asofDesc" | "asof_desc" => Ok(GeneratedField::AsofDesc),
1301 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
1302 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1303 }
1304 }
1305 }
1306 deserializer.deserialize_identifier(GeneratedVisitor)
1307 }
1308 }
1309 struct GeneratedVisitor;
1310 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1311 type Value = AsOfJoinNode;
1312
1313 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1314 formatter.write_str("struct stream_plan.AsOfJoinNode")
1315 }
1316
1317 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AsOfJoinNode, V::Error>
1318 where
1319 V: serde::de::MapAccess<'de>,
1320 {
1321 let mut join_type__ = None;
1322 let mut left_key__ = None;
1323 let mut right_key__ = None;
1324 let mut left_table__ = None;
1325 let mut right_table__ = None;
1326 let mut output_indices__ = None;
1327 let mut left_deduped_input_pk_indices__ = None;
1328 let mut right_deduped_input_pk_indices__ = None;
1329 let mut null_safe__ = None;
1330 let mut asof_desc__ = None;
1331 let mut join_encoding_type__ = None;
1332 while let Some(k) = map_.next_key()? {
1333 match k {
1334 GeneratedField::JoinType => {
1335 if join_type__.is_some() {
1336 return Err(serde::de::Error::duplicate_field("joinType"));
1337 }
1338 join_type__ = Some(map_.next_value::<super::plan_common::AsOfJoinType>()? as i32);
1339 }
1340 GeneratedField::LeftKey => {
1341 if left_key__.is_some() {
1342 return Err(serde::de::Error::duplicate_field("leftKey"));
1343 }
1344 left_key__ =
1345 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1346 .into_iter().map(|x| x.0).collect())
1347 ;
1348 }
1349 GeneratedField::RightKey => {
1350 if right_key__.is_some() {
1351 return Err(serde::de::Error::duplicate_field("rightKey"));
1352 }
1353 right_key__ =
1354 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1355 .into_iter().map(|x| x.0).collect())
1356 ;
1357 }
1358 GeneratedField::LeftTable => {
1359 if left_table__.is_some() {
1360 return Err(serde::de::Error::duplicate_field("leftTable"));
1361 }
1362 left_table__ = map_.next_value()?;
1363 }
1364 GeneratedField::RightTable => {
1365 if right_table__.is_some() {
1366 return Err(serde::de::Error::duplicate_field("rightTable"));
1367 }
1368 right_table__ = map_.next_value()?;
1369 }
1370 GeneratedField::OutputIndices => {
1371 if output_indices__.is_some() {
1372 return Err(serde::de::Error::duplicate_field("outputIndices"));
1373 }
1374 output_indices__ =
1375 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1376 .into_iter().map(|x| x.0).collect())
1377 ;
1378 }
1379 GeneratedField::LeftDedupedInputPkIndices => {
1380 if left_deduped_input_pk_indices__.is_some() {
1381 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
1382 }
1383 left_deduped_input_pk_indices__ =
1384 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1385 .into_iter().map(|x| x.0).collect())
1386 ;
1387 }
1388 GeneratedField::RightDedupedInputPkIndices => {
1389 if right_deduped_input_pk_indices__.is_some() {
1390 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
1391 }
1392 right_deduped_input_pk_indices__ =
1393 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1394 .into_iter().map(|x| x.0).collect())
1395 ;
1396 }
1397 GeneratedField::NullSafe => {
1398 if null_safe__.is_some() {
1399 return Err(serde::de::Error::duplicate_field("nullSafe"));
1400 }
1401 null_safe__ = Some(map_.next_value()?);
1402 }
1403 GeneratedField::AsofDesc => {
1404 if asof_desc__.is_some() {
1405 return Err(serde::de::Error::duplicate_field("asofDesc"));
1406 }
1407 asof_desc__ = map_.next_value()?;
1408 }
1409 GeneratedField::JoinEncodingType => {
1410 if join_encoding_type__.is_some() {
1411 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
1412 }
1413 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
1414 }
1415 }
1416 }
1417 Ok(AsOfJoinNode {
1418 join_type: join_type__.unwrap_or_default(),
1419 left_key: left_key__.unwrap_or_default(),
1420 right_key: right_key__.unwrap_or_default(),
1421 left_table: left_table__,
1422 right_table: right_table__,
1423 output_indices: output_indices__.unwrap_or_default(),
1424 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
1425 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
1426 null_safe: null_safe__.unwrap_or_default(),
1427 asof_desc: asof_desc__,
1428 join_encoding_type: join_encoding_type__.unwrap_or_default(),
1429 })
1430 }
1431 }
1432 deserializer.deserialize_struct("stream_plan.AsOfJoinNode", FIELDS, GeneratedVisitor)
1433 }
1434}
1435impl serde::Serialize for BackfillOrder {
1436 #[allow(deprecated)]
1437 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1438 where
1439 S: serde::Serializer,
1440 {
1441 use serde::ser::SerializeStruct;
1442 let mut len = 0;
1443 if !self.order.is_empty() {
1444 len += 1;
1445 }
1446 let mut struct_ser = serializer.serialize_struct("stream_plan.BackfillOrder", len)?;
1447 if !self.order.is_empty() {
1448 struct_ser.serialize_field("order", &self.order)?;
1449 }
1450 struct_ser.end()
1451 }
1452}
1453impl<'de> serde::Deserialize<'de> for BackfillOrder {
1454 #[allow(deprecated)]
1455 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1456 where
1457 D: serde::Deserializer<'de>,
1458 {
1459 const FIELDS: &[&str] = &[
1460 "order",
1461 ];
1462
1463 #[allow(clippy::enum_variant_names)]
1464 enum GeneratedField {
1465 Order,
1466 }
1467 impl<'de> serde::Deserialize<'de> for GeneratedField {
1468 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1469 where
1470 D: serde::Deserializer<'de>,
1471 {
1472 struct GeneratedVisitor;
1473
1474 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1475 type Value = GeneratedField;
1476
1477 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1478 write!(formatter, "expected one of: {:?}", &FIELDS)
1479 }
1480
1481 #[allow(unused_variables)]
1482 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1483 where
1484 E: serde::de::Error,
1485 {
1486 match value {
1487 "order" => Ok(GeneratedField::Order),
1488 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1489 }
1490 }
1491 }
1492 deserializer.deserialize_identifier(GeneratedVisitor)
1493 }
1494 }
1495 struct GeneratedVisitor;
1496 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1497 type Value = BackfillOrder;
1498
1499 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1500 formatter.write_str("struct stream_plan.BackfillOrder")
1501 }
1502
1503 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BackfillOrder, V::Error>
1504 where
1505 V: serde::de::MapAccess<'de>,
1506 {
1507 let mut order__ = None;
1508 while let Some(k) = map_.next_key()? {
1509 match k {
1510 GeneratedField::Order => {
1511 if order__.is_some() {
1512 return Err(serde::de::Error::duplicate_field("order"));
1513 }
1514 order__ = Some(
1515 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1516 .into_iter().map(|(k,v)| (k.0, v)).collect()
1517 );
1518 }
1519 }
1520 }
1521 Ok(BackfillOrder {
1522 order: order__.unwrap_or_default(),
1523 })
1524 }
1525 }
1526 deserializer.deserialize_struct("stream_plan.BackfillOrder", FIELDS, GeneratedVisitor)
1527 }
1528}
1529impl serde::Serialize for Barrier {
1530 #[allow(deprecated)]
1531 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1532 where
1533 S: serde::Serializer,
1534 {
1535 use serde::ser::SerializeStruct;
1536 let mut len = 0;
1537 if self.epoch.is_some() {
1538 len += 1;
1539 }
1540 if self.mutation.is_some() {
1541 len += 1;
1542 }
1543 if !self.tracing_context.is_empty() {
1544 len += 1;
1545 }
1546 if self.kind != 0 {
1547 len += 1;
1548 }
1549 if !self.passed_actors.is_empty() {
1550 len += 1;
1551 }
1552 let mut struct_ser = serializer.serialize_struct("stream_plan.Barrier", len)?;
1553 if let Some(v) = self.epoch.as_ref() {
1554 struct_ser.serialize_field("epoch", v)?;
1555 }
1556 if let Some(v) = self.mutation.as_ref() {
1557 struct_ser.serialize_field("mutation", v)?;
1558 }
1559 if !self.tracing_context.is_empty() {
1560 struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
1561 }
1562 if self.kind != 0 {
1563 let v = barrier::BarrierKind::try_from(self.kind)
1564 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
1565 struct_ser.serialize_field("kind", &v)?;
1566 }
1567 if !self.passed_actors.is_empty() {
1568 struct_ser.serialize_field("passedActors", &self.passed_actors)?;
1569 }
1570 struct_ser.end()
1571 }
1572}
1573impl<'de> serde::Deserialize<'de> for Barrier {
1574 #[allow(deprecated)]
1575 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1576 where
1577 D: serde::Deserializer<'de>,
1578 {
1579 const FIELDS: &[&str] = &[
1580 "epoch",
1581 "mutation",
1582 "tracing_context",
1583 "tracingContext",
1584 "kind",
1585 "passed_actors",
1586 "passedActors",
1587 ];
1588
1589 #[allow(clippy::enum_variant_names)]
1590 enum GeneratedField {
1591 Epoch,
1592 Mutation,
1593 TracingContext,
1594 Kind,
1595 PassedActors,
1596 }
1597 impl<'de> serde::Deserialize<'de> for GeneratedField {
1598 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1599 where
1600 D: serde::Deserializer<'de>,
1601 {
1602 struct GeneratedVisitor;
1603
1604 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1605 type Value = GeneratedField;
1606
1607 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1608 write!(formatter, "expected one of: {:?}", &FIELDS)
1609 }
1610
1611 #[allow(unused_variables)]
1612 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1613 where
1614 E: serde::de::Error,
1615 {
1616 match value {
1617 "epoch" => Ok(GeneratedField::Epoch),
1618 "mutation" => Ok(GeneratedField::Mutation),
1619 "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
1620 "kind" => Ok(GeneratedField::Kind),
1621 "passedActors" | "passed_actors" => Ok(GeneratedField::PassedActors),
1622 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1623 }
1624 }
1625 }
1626 deserializer.deserialize_identifier(GeneratedVisitor)
1627 }
1628 }
1629 struct GeneratedVisitor;
1630 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1631 type Value = Barrier;
1632
1633 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1634 formatter.write_str("struct stream_plan.Barrier")
1635 }
1636
1637 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Barrier, V::Error>
1638 where
1639 V: serde::de::MapAccess<'de>,
1640 {
1641 let mut epoch__ = None;
1642 let mut mutation__ = None;
1643 let mut tracing_context__ = None;
1644 let mut kind__ = None;
1645 let mut passed_actors__ = None;
1646 while let Some(k) = map_.next_key()? {
1647 match k {
1648 GeneratedField::Epoch => {
1649 if epoch__.is_some() {
1650 return Err(serde::de::Error::duplicate_field("epoch"));
1651 }
1652 epoch__ = map_.next_value()?;
1653 }
1654 GeneratedField::Mutation => {
1655 if mutation__.is_some() {
1656 return Err(serde::de::Error::duplicate_field("mutation"));
1657 }
1658 mutation__ = map_.next_value()?;
1659 }
1660 GeneratedField::TracingContext => {
1661 if tracing_context__.is_some() {
1662 return Err(serde::de::Error::duplicate_field("tracingContext"));
1663 }
1664 tracing_context__ = Some(
1665 map_.next_value::<std::collections::HashMap<_, _>>()?
1666 );
1667 }
1668 GeneratedField::Kind => {
1669 if kind__.is_some() {
1670 return Err(serde::de::Error::duplicate_field("kind"));
1671 }
1672 kind__ = Some(map_.next_value::<barrier::BarrierKind>()? as i32);
1673 }
1674 GeneratedField::PassedActors => {
1675 if passed_actors__.is_some() {
1676 return Err(serde::de::Error::duplicate_field("passedActors"));
1677 }
1678 passed_actors__ =
1679 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1680 .into_iter().map(|x| x.0).collect())
1681 ;
1682 }
1683 }
1684 }
1685 Ok(Barrier {
1686 epoch: epoch__,
1687 mutation: mutation__,
1688 tracing_context: tracing_context__.unwrap_or_default(),
1689 kind: kind__.unwrap_or_default(),
1690 passed_actors: passed_actors__.unwrap_or_default(),
1691 })
1692 }
1693 }
1694 deserializer.deserialize_struct("stream_plan.Barrier", FIELDS, GeneratedVisitor)
1695 }
1696}
1697impl serde::Serialize for barrier::BarrierKind {
1698 #[allow(deprecated)]
1699 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1700 where
1701 S: serde::Serializer,
1702 {
1703 let variant = match self {
1704 Self::Unspecified => "BARRIER_KIND_UNSPECIFIED",
1705 Self::Initial => "BARRIER_KIND_INITIAL",
1706 Self::Barrier => "BARRIER_KIND_BARRIER",
1707 Self::Checkpoint => "BARRIER_KIND_CHECKPOINT",
1708 };
1709 serializer.serialize_str(variant)
1710 }
1711}
1712impl<'de> serde::Deserialize<'de> for barrier::BarrierKind {
1713 #[allow(deprecated)]
1714 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1715 where
1716 D: serde::Deserializer<'de>,
1717 {
1718 const FIELDS: &[&str] = &[
1719 "BARRIER_KIND_UNSPECIFIED",
1720 "BARRIER_KIND_INITIAL",
1721 "BARRIER_KIND_BARRIER",
1722 "BARRIER_KIND_CHECKPOINT",
1723 ];
1724
1725 struct GeneratedVisitor;
1726
1727 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1728 type Value = barrier::BarrierKind;
1729
1730 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1731 write!(formatter, "expected one of: {:?}", &FIELDS)
1732 }
1733
1734 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1735 where
1736 E: serde::de::Error,
1737 {
1738 i32::try_from(v)
1739 .ok()
1740 .and_then(|x| x.try_into().ok())
1741 .ok_or_else(|| {
1742 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1743 })
1744 }
1745
1746 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1747 where
1748 E: serde::de::Error,
1749 {
1750 i32::try_from(v)
1751 .ok()
1752 .and_then(|x| x.try_into().ok())
1753 .ok_or_else(|| {
1754 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1755 })
1756 }
1757
1758 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1759 where
1760 E: serde::de::Error,
1761 {
1762 match value {
1763 "BARRIER_KIND_UNSPECIFIED" => Ok(barrier::BarrierKind::Unspecified),
1764 "BARRIER_KIND_INITIAL" => Ok(barrier::BarrierKind::Initial),
1765 "BARRIER_KIND_BARRIER" => Ok(barrier::BarrierKind::Barrier),
1766 "BARRIER_KIND_CHECKPOINT" => Ok(barrier::BarrierKind::Checkpoint),
1767 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1768 }
1769 }
1770 }
1771 deserializer.deserialize_any(GeneratedVisitor)
1772 }
1773}
1774impl serde::Serialize for BarrierMutation {
1775 #[allow(deprecated)]
1776 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1777 where
1778 S: serde::Serializer,
1779 {
1780 use serde::ser::SerializeStruct;
1781 let mut len = 0;
1782 if self.mutation.is_some() {
1783 len += 1;
1784 }
1785 let mut struct_ser = serializer.serialize_struct("stream_plan.BarrierMutation", len)?;
1786 if let Some(v) = self.mutation.as_ref() {
1787 match v {
1788 barrier_mutation::Mutation::Add(v) => {
1789 struct_ser.serialize_field("add", v)?;
1790 }
1791 barrier_mutation::Mutation::Stop(v) => {
1792 struct_ser.serialize_field("stop", v)?;
1793 }
1794 barrier_mutation::Mutation::Update(v) => {
1795 struct_ser.serialize_field("update", v)?;
1796 }
1797 barrier_mutation::Mutation::Splits(v) => {
1798 struct_ser.serialize_field("splits", v)?;
1799 }
1800 barrier_mutation::Mutation::Pause(v) => {
1801 struct_ser.serialize_field("pause", v)?;
1802 }
1803 barrier_mutation::Mutation::Resume(v) => {
1804 struct_ser.serialize_field("resume", v)?;
1805 }
1806 barrier_mutation::Mutation::Throttle(v) => {
1807 struct_ser.serialize_field("throttle", v)?;
1808 }
1809 barrier_mutation::Mutation::DropSubscriptions(v) => {
1810 struct_ser.serialize_field("dropSubscriptions", v)?;
1811 }
1812 barrier_mutation::Mutation::ConnectorPropsChange(v) => {
1813 struct_ser.serialize_field("connectorPropsChange", v)?;
1814 }
1815 barrier_mutation::Mutation::StartFragmentBackfill(v) => {
1816 struct_ser.serialize_field("startFragmentBackfill", v)?;
1817 }
1818 barrier_mutation::Mutation::RefreshStart(v) => {
1819 struct_ser.serialize_field("refreshStart", v)?;
1820 }
1821 barrier_mutation::Mutation::LoadFinish(v) => {
1822 struct_ser.serialize_field("loadFinish", v)?;
1823 }
1824 barrier_mutation::Mutation::ListFinish(v) => {
1825 struct_ser.serialize_field("listFinish", v)?;
1826 }
1827 barrier_mutation::Mutation::Combined(v) => {
1828 struct_ser.serialize_field("combined", v)?;
1829 }
1830 }
1831 }
1832 struct_ser.end()
1833 }
1834}
1835impl<'de> serde::Deserialize<'de> for BarrierMutation {
1836 #[allow(deprecated)]
1837 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1838 where
1839 D: serde::Deserializer<'de>,
1840 {
1841 const FIELDS: &[&str] = &[
1842 "add",
1843 "stop",
1844 "update",
1845 "splits",
1846 "pause",
1847 "resume",
1848 "throttle",
1849 "drop_subscriptions",
1850 "dropSubscriptions",
1851 "connector_props_change",
1852 "connectorPropsChange",
1853 "start_fragment_backfill",
1854 "startFragmentBackfill",
1855 "refresh_start",
1856 "refreshStart",
1857 "load_finish",
1858 "loadFinish",
1859 "list_finish",
1860 "listFinish",
1861 "combined",
1862 ];
1863
1864 #[allow(clippy::enum_variant_names)]
1865 enum GeneratedField {
1866 Add,
1867 Stop,
1868 Update,
1869 Splits,
1870 Pause,
1871 Resume,
1872 Throttle,
1873 DropSubscriptions,
1874 ConnectorPropsChange,
1875 StartFragmentBackfill,
1876 RefreshStart,
1877 LoadFinish,
1878 ListFinish,
1879 Combined,
1880 }
1881 impl<'de> serde::Deserialize<'de> for GeneratedField {
1882 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1883 where
1884 D: serde::Deserializer<'de>,
1885 {
1886 struct GeneratedVisitor;
1887
1888 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1889 type Value = GeneratedField;
1890
1891 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1892 write!(formatter, "expected one of: {:?}", &FIELDS)
1893 }
1894
1895 #[allow(unused_variables)]
1896 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1897 where
1898 E: serde::de::Error,
1899 {
1900 match value {
1901 "add" => Ok(GeneratedField::Add),
1902 "stop" => Ok(GeneratedField::Stop),
1903 "update" => Ok(GeneratedField::Update),
1904 "splits" => Ok(GeneratedField::Splits),
1905 "pause" => Ok(GeneratedField::Pause),
1906 "resume" => Ok(GeneratedField::Resume),
1907 "throttle" => Ok(GeneratedField::Throttle),
1908 "dropSubscriptions" | "drop_subscriptions" => Ok(GeneratedField::DropSubscriptions),
1909 "connectorPropsChange" | "connector_props_change" => Ok(GeneratedField::ConnectorPropsChange),
1910 "startFragmentBackfill" | "start_fragment_backfill" => Ok(GeneratedField::StartFragmentBackfill),
1911 "refreshStart" | "refresh_start" => Ok(GeneratedField::RefreshStart),
1912 "loadFinish" | "load_finish" => Ok(GeneratedField::LoadFinish),
1913 "listFinish" | "list_finish" => Ok(GeneratedField::ListFinish),
1914 "combined" => Ok(GeneratedField::Combined),
1915 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1916 }
1917 }
1918 }
1919 deserializer.deserialize_identifier(GeneratedVisitor)
1920 }
1921 }
1922 struct GeneratedVisitor;
1923 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1924 type Value = BarrierMutation;
1925
1926 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1927 formatter.write_str("struct stream_plan.BarrierMutation")
1928 }
1929
1930 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierMutation, V::Error>
1931 where
1932 V: serde::de::MapAccess<'de>,
1933 {
1934 let mut mutation__ = None;
1935 while let Some(k) = map_.next_key()? {
1936 match k {
1937 GeneratedField::Add => {
1938 if mutation__.is_some() {
1939 return Err(serde::de::Error::duplicate_field("add"));
1940 }
1941 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Add)
1942;
1943 }
1944 GeneratedField::Stop => {
1945 if mutation__.is_some() {
1946 return Err(serde::de::Error::duplicate_field("stop"));
1947 }
1948 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Stop)
1949;
1950 }
1951 GeneratedField::Update => {
1952 if mutation__.is_some() {
1953 return Err(serde::de::Error::duplicate_field("update"));
1954 }
1955 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Update)
1956;
1957 }
1958 GeneratedField::Splits => {
1959 if mutation__.is_some() {
1960 return Err(serde::de::Error::duplicate_field("splits"));
1961 }
1962 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Splits)
1963;
1964 }
1965 GeneratedField::Pause => {
1966 if mutation__.is_some() {
1967 return Err(serde::de::Error::duplicate_field("pause"));
1968 }
1969 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Pause)
1970;
1971 }
1972 GeneratedField::Resume => {
1973 if mutation__.is_some() {
1974 return Err(serde::de::Error::duplicate_field("resume"));
1975 }
1976 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Resume)
1977;
1978 }
1979 GeneratedField::Throttle => {
1980 if mutation__.is_some() {
1981 return Err(serde::de::Error::duplicate_field("throttle"));
1982 }
1983 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Throttle)
1984;
1985 }
1986 GeneratedField::DropSubscriptions => {
1987 if mutation__.is_some() {
1988 return Err(serde::de::Error::duplicate_field("dropSubscriptions"));
1989 }
1990 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::DropSubscriptions)
1991;
1992 }
1993 GeneratedField::ConnectorPropsChange => {
1994 if mutation__.is_some() {
1995 return Err(serde::de::Error::duplicate_field("connectorPropsChange"));
1996 }
1997 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ConnectorPropsChange)
1998;
1999 }
2000 GeneratedField::StartFragmentBackfill => {
2001 if mutation__.is_some() {
2002 return Err(serde::de::Error::duplicate_field("startFragmentBackfill"));
2003 }
2004 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::StartFragmentBackfill)
2005;
2006 }
2007 GeneratedField::RefreshStart => {
2008 if mutation__.is_some() {
2009 return Err(serde::de::Error::duplicate_field("refreshStart"));
2010 }
2011 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::RefreshStart)
2012;
2013 }
2014 GeneratedField::LoadFinish => {
2015 if mutation__.is_some() {
2016 return Err(serde::de::Error::duplicate_field("loadFinish"));
2017 }
2018 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::LoadFinish)
2019;
2020 }
2021 GeneratedField::ListFinish => {
2022 if mutation__.is_some() {
2023 return Err(serde::de::Error::duplicate_field("listFinish"));
2024 }
2025 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ListFinish)
2026;
2027 }
2028 GeneratedField::Combined => {
2029 if mutation__.is_some() {
2030 return Err(serde::de::Error::duplicate_field("combined"));
2031 }
2032 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Combined)
2033;
2034 }
2035 }
2036 }
2037 Ok(BarrierMutation {
2038 mutation: mutation__,
2039 })
2040 }
2041 }
2042 deserializer.deserialize_struct("stream_plan.BarrierMutation", FIELDS, GeneratedVisitor)
2043 }
2044}
2045impl serde::Serialize for BarrierRecvNode {
2046 #[allow(deprecated)]
2047 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2048 where
2049 S: serde::Serializer,
2050 {
2051 use serde::ser::SerializeStruct;
2052 let len = 0;
2053 let struct_ser = serializer.serialize_struct("stream_plan.BarrierRecvNode", len)?;
2054 struct_ser.end()
2055 }
2056}
2057impl<'de> serde::Deserialize<'de> for BarrierRecvNode {
2058 #[allow(deprecated)]
2059 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2060 where
2061 D: serde::Deserializer<'de>,
2062 {
2063 const FIELDS: &[&str] = &[
2064 ];
2065
2066 #[allow(clippy::enum_variant_names)]
2067 enum GeneratedField {
2068 }
2069 impl<'de> serde::Deserialize<'de> for GeneratedField {
2070 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2071 where
2072 D: serde::Deserializer<'de>,
2073 {
2074 struct GeneratedVisitor;
2075
2076 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2077 type Value = GeneratedField;
2078
2079 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2080 write!(formatter, "expected one of: {:?}", &FIELDS)
2081 }
2082
2083 #[allow(unused_variables)]
2084 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2085 where
2086 E: serde::de::Error,
2087 {
2088 Err(serde::de::Error::unknown_field(value, FIELDS))
2089 }
2090 }
2091 deserializer.deserialize_identifier(GeneratedVisitor)
2092 }
2093 }
2094 struct GeneratedVisitor;
2095 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2096 type Value = BarrierRecvNode;
2097
2098 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2099 formatter.write_str("struct stream_plan.BarrierRecvNode")
2100 }
2101
2102 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierRecvNode, V::Error>
2103 where
2104 V: serde::de::MapAccess<'de>,
2105 {
2106 while map_.next_key::<GeneratedField>()?.is_some() {
2107 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2108 }
2109 Ok(BarrierRecvNode {
2110 })
2111 }
2112 }
2113 deserializer.deserialize_struct("stream_plan.BarrierRecvNode", FIELDS, GeneratedVisitor)
2114 }
2115}
2116impl serde::Serialize for BatchPlanNode {
2117 #[allow(deprecated)]
2118 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2119 where
2120 S: serde::Serializer,
2121 {
2122 use serde::ser::SerializeStruct;
2123 let mut len = 0;
2124 if self.table_desc.is_some() {
2125 len += 1;
2126 }
2127 if !self.column_ids.is_empty() {
2128 len += 1;
2129 }
2130 let mut struct_ser = serializer.serialize_struct("stream_plan.BatchPlanNode", len)?;
2131 if let Some(v) = self.table_desc.as_ref() {
2132 struct_ser.serialize_field("tableDesc", v)?;
2133 }
2134 if !self.column_ids.is_empty() {
2135 struct_ser.serialize_field("columnIds", &self.column_ids)?;
2136 }
2137 struct_ser.end()
2138 }
2139}
2140impl<'de> serde::Deserialize<'de> for BatchPlanNode {
2141 #[allow(deprecated)]
2142 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2143 where
2144 D: serde::Deserializer<'de>,
2145 {
2146 const FIELDS: &[&str] = &[
2147 "table_desc",
2148 "tableDesc",
2149 "column_ids",
2150 "columnIds",
2151 ];
2152
2153 #[allow(clippy::enum_variant_names)]
2154 enum GeneratedField {
2155 TableDesc,
2156 ColumnIds,
2157 }
2158 impl<'de> serde::Deserialize<'de> for GeneratedField {
2159 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2160 where
2161 D: serde::Deserializer<'de>,
2162 {
2163 struct GeneratedVisitor;
2164
2165 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2166 type Value = GeneratedField;
2167
2168 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2169 write!(formatter, "expected one of: {:?}", &FIELDS)
2170 }
2171
2172 #[allow(unused_variables)]
2173 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2174 where
2175 E: serde::de::Error,
2176 {
2177 match value {
2178 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
2179 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
2180 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2181 }
2182 }
2183 }
2184 deserializer.deserialize_identifier(GeneratedVisitor)
2185 }
2186 }
2187 struct GeneratedVisitor;
2188 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2189 type Value = BatchPlanNode;
2190
2191 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2192 formatter.write_str("struct stream_plan.BatchPlanNode")
2193 }
2194
2195 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BatchPlanNode, V::Error>
2196 where
2197 V: serde::de::MapAccess<'de>,
2198 {
2199 let mut table_desc__ = None;
2200 let mut column_ids__ = None;
2201 while let Some(k) = map_.next_key()? {
2202 match k {
2203 GeneratedField::TableDesc => {
2204 if table_desc__.is_some() {
2205 return Err(serde::de::Error::duplicate_field("tableDesc"));
2206 }
2207 table_desc__ = map_.next_value()?;
2208 }
2209 GeneratedField::ColumnIds => {
2210 if column_ids__.is_some() {
2211 return Err(serde::de::Error::duplicate_field("columnIds"));
2212 }
2213 column_ids__ =
2214 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2215 .into_iter().map(|x| x.0).collect())
2216 ;
2217 }
2218 }
2219 }
2220 Ok(BatchPlanNode {
2221 table_desc: table_desc__,
2222 column_ids: column_ids__.unwrap_or_default(),
2223 })
2224 }
2225 }
2226 deserializer.deserialize_struct("stream_plan.BatchPlanNode", FIELDS, GeneratedVisitor)
2227 }
2228}
2229impl serde::Serialize for CdcFilterNode {
2230 #[allow(deprecated)]
2231 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2232 where
2233 S: serde::Serializer,
2234 {
2235 use serde::ser::SerializeStruct;
2236 let mut len = 0;
2237 if self.search_condition.is_some() {
2238 len += 1;
2239 }
2240 if self.upstream_source_id != 0 {
2241 len += 1;
2242 }
2243 let mut struct_ser = serializer.serialize_struct("stream_plan.CdcFilterNode", len)?;
2244 if let Some(v) = self.search_condition.as_ref() {
2245 struct_ser.serialize_field("searchCondition", v)?;
2246 }
2247 if self.upstream_source_id != 0 {
2248 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
2249 }
2250 struct_ser.end()
2251 }
2252}
2253impl<'de> serde::Deserialize<'de> for CdcFilterNode {
2254 #[allow(deprecated)]
2255 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2256 where
2257 D: serde::Deserializer<'de>,
2258 {
2259 const FIELDS: &[&str] = &[
2260 "search_condition",
2261 "searchCondition",
2262 "upstream_source_id",
2263 "upstreamSourceId",
2264 ];
2265
2266 #[allow(clippy::enum_variant_names)]
2267 enum GeneratedField {
2268 SearchCondition,
2269 UpstreamSourceId,
2270 }
2271 impl<'de> serde::Deserialize<'de> for GeneratedField {
2272 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2273 where
2274 D: serde::Deserializer<'de>,
2275 {
2276 struct GeneratedVisitor;
2277
2278 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2279 type Value = GeneratedField;
2280
2281 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2282 write!(formatter, "expected one of: {:?}", &FIELDS)
2283 }
2284
2285 #[allow(unused_variables)]
2286 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2287 where
2288 E: serde::de::Error,
2289 {
2290 match value {
2291 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
2292 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
2293 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2294 }
2295 }
2296 }
2297 deserializer.deserialize_identifier(GeneratedVisitor)
2298 }
2299 }
2300 struct GeneratedVisitor;
2301 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2302 type Value = CdcFilterNode;
2303
2304 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2305 formatter.write_str("struct stream_plan.CdcFilterNode")
2306 }
2307
2308 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcFilterNode, V::Error>
2309 where
2310 V: serde::de::MapAccess<'de>,
2311 {
2312 let mut search_condition__ = None;
2313 let mut upstream_source_id__ = None;
2314 while let Some(k) = map_.next_key()? {
2315 match k {
2316 GeneratedField::SearchCondition => {
2317 if search_condition__.is_some() {
2318 return Err(serde::de::Error::duplicate_field("searchCondition"));
2319 }
2320 search_condition__ = map_.next_value()?;
2321 }
2322 GeneratedField::UpstreamSourceId => {
2323 if upstream_source_id__.is_some() {
2324 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
2325 }
2326 upstream_source_id__ =
2327 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2328 ;
2329 }
2330 }
2331 }
2332 Ok(CdcFilterNode {
2333 search_condition: search_condition__,
2334 upstream_source_id: upstream_source_id__.unwrap_or_default(),
2335 })
2336 }
2337 }
2338 deserializer.deserialize_struct("stream_plan.CdcFilterNode", FIELDS, GeneratedVisitor)
2339 }
2340}
2341impl serde::Serialize for ChangeLogNode {
2342 #[allow(deprecated)]
2343 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2344 where
2345 S: serde::Serializer,
2346 {
2347 use serde::ser::SerializeStruct;
2348 let mut len = 0;
2349 if self.need_op {
2350 len += 1;
2351 }
2352 if !self.distribution_keys.is_empty() {
2353 len += 1;
2354 }
2355 let mut struct_ser = serializer.serialize_struct("stream_plan.ChangeLogNode", len)?;
2356 if self.need_op {
2357 struct_ser.serialize_field("needOp", &self.need_op)?;
2358 }
2359 if !self.distribution_keys.is_empty() {
2360 struct_ser.serialize_field("distributionKeys", &self.distribution_keys)?;
2361 }
2362 struct_ser.end()
2363 }
2364}
2365impl<'de> serde::Deserialize<'de> for ChangeLogNode {
2366 #[allow(deprecated)]
2367 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2368 where
2369 D: serde::Deserializer<'de>,
2370 {
2371 const FIELDS: &[&str] = &[
2372 "need_op",
2373 "needOp",
2374 "distribution_keys",
2375 "distributionKeys",
2376 ];
2377
2378 #[allow(clippy::enum_variant_names)]
2379 enum GeneratedField {
2380 NeedOp,
2381 DistributionKeys,
2382 }
2383 impl<'de> serde::Deserialize<'de> for GeneratedField {
2384 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2385 where
2386 D: serde::Deserializer<'de>,
2387 {
2388 struct GeneratedVisitor;
2389
2390 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2391 type Value = GeneratedField;
2392
2393 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2394 write!(formatter, "expected one of: {:?}", &FIELDS)
2395 }
2396
2397 #[allow(unused_variables)]
2398 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2399 where
2400 E: serde::de::Error,
2401 {
2402 match value {
2403 "needOp" | "need_op" => Ok(GeneratedField::NeedOp),
2404 "distributionKeys" | "distribution_keys" => Ok(GeneratedField::DistributionKeys),
2405 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2406 }
2407 }
2408 }
2409 deserializer.deserialize_identifier(GeneratedVisitor)
2410 }
2411 }
2412 struct GeneratedVisitor;
2413 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2414 type Value = ChangeLogNode;
2415
2416 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2417 formatter.write_str("struct stream_plan.ChangeLogNode")
2418 }
2419
2420 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ChangeLogNode, V::Error>
2421 where
2422 V: serde::de::MapAccess<'de>,
2423 {
2424 let mut need_op__ = None;
2425 let mut distribution_keys__ = None;
2426 while let Some(k) = map_.next_key()? {
2427 match k {
2428 GeneratedField::NeedOp => {
2429 if need_op__.is_some() {
2430 return Err(serde::de::Error::duplicate_field("needOp"));
2431 }
2432 need_op__ = Some(map_.next_value()?);
2433 }
2434 GeneratedField::DistributionKeys => {
2435 if distribution_keys__.is_some() {
2436 return Err(serde::de::Error::duplicate_field("distributionKeys"));
2437 }
2438 distribution_keys__ =
2439 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2440 .into_iter().map(|x| x.0).collect())
2441 ;
2442 }
2443 }
2444 }
2445 Ok(ChangeLogNode {
2446 need_op: need_op__.unwrap_or_default(),
2447 distribution_keys: distribution_keys__.unwrap_or_default(),
2448 })
2449 }
2450 }
2451 deserializer.deserialize_struct("stream_plan.ChangeLogNode", FIELDS, GeneratedVisitor)
2452 }
2453}
2454impl serde::Serialize for Columns {
2455 #[allow(deprecated)]
2456 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2457 where
2458 S: serde::Serializer,
2459 {
2460 use serde::ser::SerializeStruct;
2461 let mut len = 0;
2462 if !self.columns.is_empty() {
2463 len += 1;
2464 }
2465 let mut struct_ser = serializer.serialize_struct("stream_plan.Columns", len)?;
2466 if !self.columns.is_empty() {
2467 struct_ser.serialize_field("columns", &self.columns)?;
2468 }
2469 struct_ser.end()
2470 }
2471}
2472impl<'de> serde::Deserialize<'de> for Columns {
2473 #[allow(deprecated)]
2474 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2475 where
2476 D: serde::Deserializer<'de>,
2477 {
2478 const FIELDS: &[&str] = &[
2479 "columns",
2480 ];
2481
2482 #[allow(clippy::enum_variant_names)]
2483 enum GeneratedField {
2484 Columns,
2485 }
2486 impl<'de> serde::Deserialize<'de> for GeneratedField {
2487 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2488 where
2489 D: serde::Deserializer<'de>,
2490 {
2491 struct GeneratedVisitor;
2492
2493 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2494 type Value = GeneratedField;
2495
2496 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2497 write!(formatter, "expected one of: {:?}", &FIELDS)
2498 }
2499
2500 #[allow(unused_variables)]
2501 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2502 where
2503 E: serde::de::Error,
2504 {
2505 match value {
2506 "columns" => Ok(GeneratedField::Columns),
2507 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2508 }
2509 }
2510 }
2511 deserializer.deserialize_identifier(GeneratedVisitor)
2512 }
2513 }
2514 struct GeneratedVisitor;
2515 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2516 type Value = Columns;
2517
2518 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2519 formatter.write_str("struct stream_plan.Columns")
2520 }
2521
2522 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Columns, V::Error>
2523 where
2524 V: serde::de::MapAccess<'de>,
2525 {
2526 let mut columns__ = None;
2527 while let Some(k) = map_.next_key()? {
2528 match k {
2529 GeneratedField::Columns => {
2530 if columns__.is_some() {
2531 return Err(serde::de::Error::duplicate_field("columns"));
2532 }
2533 columns__ = Some(map_.next_value()?);
2534 }
2535 }
2536 }
2537 Ok(Columns {
2538 columns: columns__.unwrap_or_default(),
2539 })
2540 }
2541 }
2542 deserializer.deserialize_struct("stream_plan.Columns", FIELDS, GeneratedVisitor)
2543 }
2544}
2545impl serde::Serialize for CombinedMutation {
2546 #[allow(deprecated)]
2547 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2548 where
2549 S: serde::Serializer,
2550 {
2551 use serde::ser::SerializeStruct;
2552 let mut len = 0;
2553 if !self.mutations.is_empty() {
2554 len += 1;
2555 }
2556 let mut struct_ser = serializer.serialize_struct("stream_plan.CombinedMutation", len)?;
2557 if !self.mutations.is_empty() {
2558 struct_ser.serialize_field("mutations", &self.mutations)?;
2559 }
2560 struct_ser.end()
2561 }
2562}
2563impl<'de> serde::Deserialize<'de> for CombinedMutation {
2564 #[allow(deprecated)]
2565 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2566 where
2567 D: serde::Deserializer<'de>,
2568 {
2569 const FIELDS: &[&str] = &[
2570 "mutations",
2571 ];
2572
2573 #[allow(clippy::enum_variant_names)]
2574 enum GeneratedField {
2575 Mutations,
2576 }
2577 impl<'de> serde::Deserialize<'de> for GeneratedField {
2578 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2579 where
2580 D: serde::Deserializer<'de>,
2581 {
2582 struct GeneratedVisitor;
2583
2584 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2585 type Value = GeneratedField;
2586
2587 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2588 write!(formatter, "expected one of: {:?}", &FIELDS)
2589 }
2590
2591 #[allow(unused_variables)]
2592 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2593 where
2594 E: serde::de::Error,
2595 {
2596 match value {
2597 "mutations" => Ok(GeneratedField::Mutations),
2598 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2599 }
2600 }
2601 }
2602 deserializer.deserialize_identifier(GeneratedVisitor)
2603 }
2604 }
2605 struct GeneratedVisitor;
2606 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2607 type Value = CombinedMutation;
2608
2609 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2610 formatter.write_str("struct stream_plan.CombinedMutation")
2611 }
2612
2613 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CombinedMutation, V::Error>
2614 where
2615 V: serde::de::MapAccess<'de>,
2616 {
2617 let mut mutations__ = None;
2618 while let Some(k) = map_.next_key()? {
2619 match k {
2620 GeneratedField::Mutations => {
2621 if mutations__.is_some() {
2622 return Err(serde::de::Error::duplicate_field("mutations"));
2623 }
2624 mutations__ = Some(map_.next_value()?);
2625 }
2626 }
2627 }
2628 Ok(CombinedMutation {
2629 mutations: mutations__.unwrap_or_default(),
2630 })
2631 }
2632 }
2633 deserializer.deserialize_struct("stream_plan.CombinedMutation", FIELDS, GeneratedVisitor)
2634 }
2635}
2636impl serde::Serialize for ConnectorPropsChangeMutation {
2637 #[allow(deprecated)]
2638 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2639 where
2640 S: serde::Serializer,
2641 {
2642 use serde::ser::SerializeStruct;
2643 let mut len = 0;
2644 if !self.connector_props_infos.is_empty() {
2645 len += 1;
2646 }
2647 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation", len)?;
2648 if !self.connector_props_infos.is_empty() {
2649 struct_ser.serialize_field("connectorPropsInfos", &self.connector_props_infos)?;
2650 }
2651 struct_ser.end()
2652 }
2653}
2654impl<'de> serde::Deserialize<'de> for ConnectorPropsChangeMutation {
2655 #[allow(deprecated)]
2656 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2657 where
2658 D: serde::Deserializer<'de>,
2659 {
2660 const FIELDS: &[&str] = &[
2661 "connector_props_infos",
2662 "connectorPropsInfos",
2663 ];
2664
2665 #[allow(clippy::enum_variant_names)]
2666 enum GeneratedField {
2667 ConnectorPropsInfos,
2668 }
2669 impl<'de> serde::Deserialize<'de> for GeneratedField {
2670 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2671 where
2672 D: serde::Deserializer<'de>,
2673 {
2674 struct GeneratedVisitor;
2675
2676 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2677 type Value = GeneratedField;
2678
2679 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2680 write!(formatter, "expected one of: {:?}", &FIELDS)
2681 }
2682
2683 #[allow(unused_variables)]
2684 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2685 where
2686 E: serde::de::Error,
2687 {
2688 match value {
2689 "connectorPropsInfos" | "connector_props_infos" => Ok(GeneratedField::ConnectorPropsInfos),
2690 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2691 }
2692 }
2693 }
2694 deserializer.deserialize_identifier(GeneratedVisitor)
2695 }
2696 }
2697 struct GeneratedVisitor;
2698 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2699 type Value = ConnectorPropsChangeMutation;
2700
2701 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2702 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation")
2703 }
2704
2705 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectorPropsChangeMutation, V::Error>
2706 where
2707 V: serde::de::MapAccess<'de>,
2708 {
2709 let mut connector_props_infos__ = None;
2710 while let Some(k) = map_.next_key()? {
2711 match k {
2712 GeneratedField::ConnectorPropsInfos => {
2713 if connector_props_infos__.is_some() {
2714 return Err(serde::de::Error::duplicate_field("connectorPropsInfos"));
2715 }
2716 connector_props_infos__ = Some(
2717 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
2718 .into_iter().map(|(k,v)| (k.0, v)).collect()
2719 );
2720 }
2721 }
2722 }
2723 Ok(ConnectorPropsChangeMutation {
2724 connector_props_infos: connector_props_infos__.unwrap_or_default(),
2725 })
2726 }
2727 }
2728 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation", FIELDS, GeneratedVisitor)
2729 }
2730}
2731impl serde::Serialize for connector_props_change_mutation::ConnectorPropsInfo {
2732 #[allow(deprecated)]
2733 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2734 where
2735 S: serde::Serializer,
2736 {
2737 use serde::ser::SerializeStruct;
2738 let mut len = 0;
2739 if !self.connector_props_info.is_empty() {
2740 len += 1;
2741 }
2742 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", len)?;
2743 if !self.connector_props_info.is_empty() {
2744 struct_ser.serialize_field("connectorPropsInfo", &self.connector_props_info)?;
2745 }
2746 struct_ser.end()
2747 }
2748}
2749impl<'de> serde::Deserialize<'de> for connector_props_change_mutation::ConnectorPropsInfo {
2750 #[allow(deprecated)]
2751 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2752 where
2753 D: serde::Deserializer<'de>,
2754 {
2755 const FIELDS: &[&str] = &[
2756 "connector_props_info",
2757 "connectorPropsInfo",
2758 ];
2759
2760 #[allow(clippy::enum_variant_names)]
2761 enum GeneratedField {
2762 ConnectorPropsInfo,
2763 }
2764 impl<'de> serde::Deserialize<'de> for GeneratedField {
2765 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2766 where
2767 D: serde::Deserializer<'de>,
2768 {
2769 struct GeneratedVisitor;
2770
2771 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2772 type Value = GeneratedField;
2773
2774 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2775 write!(formatter, "expected one of: {:?}", &FIELDS)
2776 }
2777
2778 #[allow(unused_variables)]
2779 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2780 where
2781 E: serde::de::Error,
2782 {
2783 match value {
2784 "connectorPropsInfo" | "connector_props_info" => Ok(GeneratedField::ConnectorPropsInfo),
2785 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2786 }
2787 }
2788 }
2789 deserializer.deserialize_identifier(GeneratedVisitor)
2790 }
2791 }
2792 struct GeneratedVisitor;
2793 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2794 type Value = connector_props_change_mutation::ConnectorPropsInfo;
2795
2796 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2797 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo")
2798 }
2799
2800 fn visit_map<V>(self, mut map_: V) -> std::result::Result<connector_props_change_mutation::ConnectorPropsInfo, V::Error>
2801 where
2802 V: serde::de::MapAccess<'de>,
2803 {
2804 let mut connector_props_info__ = None;
2805 while let Some(k) = map_.next_key()? {
2806 match k {
2807 GeneratedField::ConnectorPropsInfo => {
2808 if connector_props_info__.is_some() {
2809 return Err(serde::de::Error::duplicate_field("connectorPropsInfo"));
2810 }
2811 connector_props_info__ = Some(
2812 map_.next_value::<std::collections::HashMap<_, _>>()?
2813 );
2814 }
2815 }
2816 }
2817 Ok(connector_props_change_mutation::ConnectorPropsInfo {
2818 connector_props_info: connector_props_info__.unwrap_or_default(),
2819 })
2820 }
2821 }
2822 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", FIELDS, GeneratedVisitor)
2823 }
2824}
2825impl serde::Serialize for DedupNode {
2826 #[allow(deprecated)]
2827 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2828 where
2829 S: serde::Serializer,
2830 {
2831 use serde::ser::SerializeStruct;
2832 let mut len = 0;
2833 if self.state_table.is_some() {
2834 len += 1;
2835 }
2836 if !self.dedup_column_indices.is_empty() {
2837 len += 1;
2838 }
2839 let mut struct_ser = serializer.serialize_struct("stream_plan.DedupNode", len)?;
2840 if let Some(v) = self.state_table.as_ref() {
2841 struct_ser.serialize_field("stateTable", v)?;
2842 }
2843 if !self.dedup_column_indices.is_empty() {
2844 struct_ser.serialize_field("dedupColumnIndices", &self.dedup_column_indices)?;
2845 }
2846 struct_ser.end()
2847 }
2848}
2849impl<'de> serde::Deserialize<'de> for DedupNode {
2850 #[allow(deprecated)]
2851 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2852 where
2853 D: serde::Deserializer<'de>,
2854 {
2855 const FIELDS: &[&str] = &[
2856 "state_table",
2857 "stateTable",
2858 "dedup_column_indices",
2859 "dedupColumnIndices",
2860 ];
2861
2862 #[allow(clippy::enum_variant_names)]
2863 enum GeneratedField {
2864 StateTable,
2865 DedupColumnIndices,
2866 }
2867 impl<'de> serde::Deserialize<'de> for GeneratedField {
2868 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2869 where
2870 D: serde::Deserializer<'de>,
2871 {
2872 struct GeneratedVisitor;
2873
2874 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2875 type Value = GeneratedField;
2876
2877 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2878 write!(formatter, "expected one of: {:?}", &FIELDS)
2879 }
2880
2881 #[allow(unused_variables)]
2882 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2883 where
2884 E: serde::de::Error,
2885 {
2886 match value {
2887 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
2888 "dedupColumnIndices" | "dedup_column_indices" => Ok(GeneratedField::DedupColumnIndices),
2889 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2890 }
2891 }
2892 }
2893 deserializer.deserialize_identifier(GeneratedVisitor)
2894 }
2895 }
2896 struct GeneratedVisitor;
2897 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2898 type Value = DedupNode;
2899
2900 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2901 formatter.write_str("struct stream_plan.DedupNode")
2902 }
2903
2904 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DedupNode, V::Error>
2905 where
2906 V: serde::de::MapAccess<'de>,
2907 {
2908 let mut state_table__ = None;
2909 let mut dedup_column_indices__ = None;
2910 while let Some(k) = map_.next_key()? {
2911 match k {
2912 GeneratedField::StateTable => {
2913 if state_table__.is_some() {
2914 return Err(serde::de::Error::duplicate_field("stateTable"));
2915 }
2916 state_table__ = map_.next_value()?;
2917 }
2918 GeneratedField::DedupColumnIndices => {
2919 if dedup_column_indices__.is_some() {
2920 return Err(serde::de::Error::duplicate_field("dedupColumnIndices"));
2921 }
2922 dedup_column_indices__ =
2923 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2924 .into_iter().map(|x| x.0).collect())
2925 ;
2926 }
2927 }
2928 }
2929 Ok(DedupNode {
2930 state_table: state_table__,
2931 dedup_column_indices: dedup_column_indices__.unwrap_or_default(),
2932 })
2933 }
2934 }
2935 deserializer.deserialize_struct("stream_plan.DedupNode", FIELDS, GeneratedVisitor)
2936 }
2937}
2938impl serde::Serialize for DeltaExpression {
2939 #[allow(deprecated)]
2940 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2941 where
2942 S: serde::Serializer,
2943 {
2944 use serde::ser::SerializeStruct;
2945 let mut len = 0;
2946 if self.delta_type != 0 {
2947 len += 1;
2948 }
2949 if self.delta.is_some() {
2950 len += 1;
2951 }
2952 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaExpression", len)?;
2953 if self.delta_type != 0 {
2954 let v = super::expr::expr_node::Type::try_from(self.delta_type)
2955 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.delta_type)))?;
2956 struct_ser.serialize_field("deltaType", &v)?;
2957 }
2958 if let Some(v) = self.delta.as_ref() {
2959 struct_ser.serialize_field("delta", v)?;
2960 }
2961 struct_ser.end()
2962 }
2963}
2964impl<'de> serde::Deserialize<'de> for DeltaExpression {
2965 #[allow(deprecated)]
2966 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2967 where
2968 D: serde::Deserializer<'de>,
2969 {
2970 const FIELDS: &[&str] = &[
2971 "delta_type",
2972 "deltaType",
2973 "delta",
2974 ];
2975
2976 #[allow(clippy::enum_variant_names)]
2977 enum GeneratedField {
2978 DeltaType,
2979 Delta,
2980 }
2981 impl<'de> serde::Deserialize<'de> for GeneratedField {
2982 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2983 where
2984 D: serde::Deserializer<'de>,
2985 {
2986 struct GeneratedVisitor;
2987
2988 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2989 type Value = GeneratedField;
2990
2991 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2992 write!(formatter, "expected one of: {:?}", &FIELDS)
2993 }
2994
2995 #[allow(unused_variables)]
2996 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2997 where
2998 E: serde::de::Error,
2999 {
3000 match value {
3001 "deltaType" | "delta_type" => Ok(GeneratedField::DeltaType),
3002 "delta" => Ok(GeneratedField::Delta),
3003 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3004 }
3005 }
3006 }
3007 deserializer.deserialize_identifier(GeneratedVisitor)
3008 }
3009 }
3010 struct GeneratedVisitor;
3011 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3012 type Value = DeltaExpression;
3013
3014 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3015 formatter.write_str("struct stream_plan.DeltaExpression")
3016 }
3017
3018 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaExpression, V::Error>
3019 where
3020 V: serde::de::MapAccess<'de>,
3021 {
3022 let mut delta_type__ = None;
3023 let mut delta__ = None;
3024 while let Some(k) = map_.next_key()? {
3025 match k {
3026 GeneratedField::DeltaType => {
3027 if delta_type__.is_some() {
3028 return Err(serde::de::Error::duplicate_field("deltaType"));
3029 }
3030 delta_type__ = Some(map_.next_value::<super::expr::expr_node::Type>()? as i32);
3031 }
3032 GeneratedField::Delta => {
3033 if delta__.is_some() {
3034 return Err(serde::de::Error::duplicate_field("delta"));
3035 }
3036 delta__ = map_.next_value()?;
3037 }
3038 }
3039 }
3040 Ok(DeltaExpression {
3041 delta_type: delta_type__.unwrap_or_default(),
3042 delta: delta__,
3043 })
3044 }
3045 }
3046 deserializer.deserialize_struct("stream_plan.DeltaExpression", FIELDS, GeneratedVisitor)
3047 }
3048}
3049impl serde::Serialize for DeltaIndexJoinNode {
3050 #[allow(deprecated)]
3051 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3052 where
3053 S: serde::Serializer,
3054 {
3055 use serde::ser::SerializeStruct;
3056 let mut len = 0;
3057 if self.join_type != 0 {
3058 len += 1;
3059 }
3060 if !self.left_key.is_empty() {
3061 len += 1;
3062 }
3063 if !self.right_key.is_empty() {
3064 len += 1;
3065 }
3066 if self.condition.is_some() {
3067 len += 1;
3068 }
3069 if self.left_table_id != 0 {
3070 len += 1;
3071 }
3072 if self.right_table_id != 0 {
3073 len += 1;
3074 }
3075 if self.left_info.is_some() {
3076 len += 1;
3077 }
3078 if self.right_info.is_some() {
3079 len += 1;
3080 }
3081 if !self.output_indices.is_empty() {
3082 len += 1;
3083 }
3084 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaIndexJoinNode", len)?;
3085 if self.join_type != 0 {
3086 let v = super::plan_common::JoinType::try_from(self.join_type)
3087 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
3088 struct_ser.serialize_field("joinType", &v)?;
3089 }
3090 if !self.left_key.is_empty() {
3091 struct_ser.serialize_field("leftKey", &self.left_key)?;
3092 }
3093 if !self.right_key.is_empty() {
3094 struct_ser.serialize_field("rightKey", &self.right_key)?;
3095 }
3096 if let Some(v) = self.condition.as_ref() {
3097 struct_ser.serialize_field("condition", v)?;
3098 }
3099 if self.left_table_id != 0 {
3100 struct_ser.serialize_field("leftTableId", &self.left_table_id)?;
3101 }
3102 if self.right_table_id != 0 {
3103 struct_ser.serialize_field("rightTableId", &self.right_table_id)?;
3104 }
3105 if let Some(v) = self.left_info.as_ref() {
3106 struct_ser.serialize_field("leftInfo", v)?;
3107 }
3108 if let Some(v) = self.right_info.as_ref() {
3109 struct_ser.serialize_field("rightInfo", v)?;
3110 }
3111 if !self.output_indices.is_empty() {
3112 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
3113 }
3114 struct_ser.end()
3115 }
3116}
3117impl<'de> serde::Deserialize<'de> for DeltaIndexJoinNode {
3118 #[allow(deprecated)]
3119 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3120 where
3121 D: serde::Deserializer<'de>,
3122 {
3123 const FIELDS: &[&str] = &[
3124 "join_type",
3125 "joinType",
3126 "left_key",
3127 "leftKey",
3128 "right_key",
3129 "rightKey",
3130 "condition",
3131 "left_table_id",
3132 "leftTableId",
3133 "right_table_id",
3134 "rightTableId",
3135 "left_info",
3136 "leftInfo",
3137 "right_info",
3138 "rightInfo",
3139 "output_indices",
3140 "outputIndices",
3141 ];
3142
3143 #[allow(clippy::enum_variant_names)]
3144 enum GeneratedField {
3145 JoinType,
3146 LeftKey,
3147 RightKey,
3148 Condition,
3149 LeftTableId,
3150 RightTableId,
3151 LeftInfo,
3152 RightInfo,
3153 OutputIndices,
3154 }
3155 impl<'de> serde::Deserialize<'de> for GeneratedField {
3156 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3157 where
3158 D: serde::Deserializer<'de>,
3159 {
3160 struct GeneratedVisitor;
3161
3162 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3163 type Value = GeneratedField;
3164
3165 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3166 write!(formatter, "expected one of: {:?}", &FIELDS)
3167 }
3168
3169 #[allow(unused_variables)]
3170 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3171 where
3172 E: serde::de::Error,
3173 {
3174 match value {
3175 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
3176 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
3177 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
3178 "condition" => Ok(GeneratedField::Condition),
3179 "leftTableId" | "left_table_id" => Ok(GeneratedField::LeftTableId),
3180 "rightTableId" | "right_table_id" => Ok(GeneratedField::RightTableId),
3181 "leftInfo" | "left_info" => Ok(GeneratedField::LeftInfo),
3182 "rightInfo" | "right_info" => Ok(GeneratedField::RightInfo),
3183 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
3184 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3185 }
3186 }
3187 }
3188 deserializer.deserialize_identifier(GeneratedVisitor)
3189 }
3190 }
3191 struct GeneratedVisitor;
3192 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3193 type Value = DeltaIndexJoinNode;
3194
3195 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3196 formatter.write_str("struct stream_plan.DeltaIndexJoinNode")
3197 }
3198
3199 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaIndexJoinNode, V::Error>
3200 where
3201 V: serde::de::MapAccess<'de>,
3202 {
3203 let mut join_type__ = None;
3204 let mut left_key__ = None;
3205 let mut right_key__ = None;
3206 let mut condition__ = None;
3207 let mut left_table_id__ = None;
3208 let mut right_table_id__ = None;
3209 let mut left_info__ = None;
3210 let mut right_info__ = None;
3211 let mut output_indices__ = None;
3212 while let Some(k) = map_.next_key()? {
3213 match k {
3214 GeneratedField::JoinType => {
3215 if join_type__.is_some() {
3216 return Err(serde::de::Error::duplicate_field("joinType"));
3217 }
3218 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
3219 }
3220 GeneratedField::LeftKey => {
3221 if left_key__.is_some() {
3222 return Err(serde::de::Error::duplicate_field("leftKey"));
3223 }
3224 left_key__ =
3225 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3226 .into_iter().map(|x| x.0).collect())
3227 ;
3228 }
3229 GeneratedField::RightKey => {
3230 if right_key__.is_some() {
3231 return Err(serde::de::Error::duplicate_field("rightKey"));
3232 }
3233 right_key__ =
3234 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3235 .into_iter().map(|x| x.0).collect())
3236 ;
3237 }
3238 GeneratedField::Condition => {
3239 if condition__.is_some() {
3240 return Err(serde::de::Error::duplicate_field("condition"));
3241 }
3242 condition__ = map_.next_value()?;
3243 }
3244 GeneratedField::LeftTableId => {
3245 if left_table_id__.is_some() {
3246 return Err(serde::de::Error::duplicate_field("leftTableId"));
3247 }
3248 left_table_id__ =
3249 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3250 ;
3251 }
3252 GeneratedField::RightTableId => {
3253 if right_table_id__.is_some() {
3254 return Err(serde::de::Error::duplicate_field("rightTableId"));
3255 }
3256 right_table_id__ =
3257 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3258 ;
3259 }
3260 GeneratedField::LeftInfo => {
3261 if left_info__.is_some() {
3262 return Err(serde::de::Error::duplicate_field("leftInfo"));
3263 }
3264 left_info__ = map_.next_value()?;
3265 }
3266 GeneratedField::RightInfo => {
3267 if right_info__.is_some() {
3268 return Err(serde::de::Error::duplicate_field("rightInfo"));
3269 }
3270 right_info__ = map_.next_value()?;
3271 }
3272 GeneratedField::OutputIndices => {
3273 if output_indices__.is_some() {
3274 return Err(serde::de::Error::duplicate_field("outputIndices"));
3275 }
3276 output_indices__ =
3277 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3278 .into_iter().map(|x| x.0).collect())
3279 ;
3280 }
3281 }
3282 }
3283 Ok(DeltaIndexJoinNode {
3284 join_type: join_type__.unwrap_or_default(),
3285 left_key: left_key__.unwrap_or_default(),
3286 right_key: right_key__.unwrap_or_default(),
3287 condition: condition__,
3288 left_table_id: left_table_id__.unwrap_or_default(),
3289 right_table_id: right_table_id__.unwrap_or_default(),
3290 left_info: left_info__,
3291 right_info: right_info__,
3292 output_indices: output_indices__.unwrap_or_default(),
3293 })
3294 }
3295 }
3296 deserializer.deserialize_struct("stream_plan.DeltaIndexJoinNode", FIELDS, GeneratedVisitor)
3297 }
3298}
3299impl serde::Serialize for DispatchOutputMapping {
3300 #[allow(deprecated)]
3301 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3302 where
3303 S: serde::Serializer,
3304 {
3305 use serde::ser::SerializeStruct;
3306 let mut len = 0;
3307 if !self.indices.is_empty() {
3308 len += 1;
3309 }
3310 if !self.types.is_empty() {
3311 len += 1;
3312 }
3313 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping", len)?;
3314 if !self.indices.is_empty() {
3315 struct_ser.serialize_field("indices", &self.indices)?;
3316 }
3317 if !self.types.is_empty() {
3318 struct_ser.serialize_field("types", &self.types)?;
3319 }
3320 struct_ser.end()
3321 }
3322}
3323impl<'de> serde::Deserialize<'de> for DispatchOutputMapping {
3324 #[allow(deprecated)]
3325 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3326 where
3327 D: serde::Deserializer<'de>,
3328 {
3329 const FIELDS: &[&str] = &[
3330 "indices",
3331 "types",
3332 ];
3333
3334 #[allow(clippy::enum_variant_names)]
3335 enum GeneratedField {
3336 Indices,
3337 Types,
3338 }
3339 impl<'de> serde::Deserialize<'de> for GeneratedField {
3340 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3341 where
3342 D: serde::Deserializer<'de>,
3343 {
3344 struct GeneratedVisitor;
3345
3346 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3347 type Value = GeneratedField;
3348
3349 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3350 write!(formatter, "expected one of: {:?}", &FIELDS)
3351 }
3352
3353 #[allow(unused_variables)]
3354 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3355 where
3356 E: serde::de::Error,
3357 {
3358 match value {
3359 "indices" => Ok(GeneratedField::Indices),
3360 "types" => Ok(GeneratedField::Types),
3361 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3362 }
3363 }
3364 }
3365 deserializer.deserialize_identifier(GeneratedVisitor)
3366 }
3367 }
3368 struct GeneratedVisitor;
3369 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3370 type Value = DispatchOutputMapping;
3371
3372 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3373 formatter.write_str("struct stream_plan.DispatchOutputMapping")
3374 }
3375
3376 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchOutputMapping, V::Error>
3377 where
3378 V: serde::de::MapAccess<'de>,
3379 {
3380 let mut indices__ = None;
3381 let mut types__ = None;
3382 while let Some(k) = map_.next_key()? {
3383 match k {
3384 GeneratedField::Indices => {
3385 if indices__.is_some() {
3386 return Err(serde::de::Error::duplicate_field("indices"));
3387 }
3388 indices__ =
3389 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3390 .into_iter().map(|x| x.0).collect())
3391 ;
3392 }
3393 GeneratedField::Types => {
3394 if types__.is_some() {
3395 return Err(serde::de::Error::duplicate_field("types"));
3396 }
3397 types__ = Some(map_.next_value()?);
3398 }
3399 }
3400 }
3401 Ok(DispatchOutputMapping {
3402 indices: indices__.unwrap_or_default(),
3403 types: types__.unwrap_or_default(),
3404 })
3405 }
3406 }
3407 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping", FIELDS, GeneratedVisitor)
3408 }
3409}
3410impl serde::Serialize for dispatch_output_mapping::TypePair {
3411 #[allow(deprecated)]
3412 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3413 where
3414 S: serde::Serializer,
3415 {
3416 use serde::ser::SerializeStruct;
3417 let mut len = 0;
3418 if self.upstream.is_some() {
3419 len += 1;
3420 }
3421 if self.downstream.is_some() {
3422 len += 1;
3423 }
3424 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping.TypePair", len)?;
3425 if let Some(v) = self.upstream.as_ref() {
3426 struct_ser.serialize_field("upstream", v)?;
3427 }
3428 if let Some(v) = self.downstream.as_ref() {
3429 struct_ser.serialize_field("downstream", v)?;
3430 }
3431 struct_ser.end()
3432 }
3433}
3434impl<'de> serde::Deserialize<'de> for dispatch_output_mapping::TypePair {
3435 #[allow(deprecated)]
3436 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3437 where
3438 D: serde::Deserializer<'de>,
3439 {
3440 const FIELDS: &[&str] = &[
3441 "upstream",
3442 "downstream",
3443 ];
3444
3445 #[allow(clippy::enum_variant_names)]
3446 enum GeneratedField {
3447 Upstream,
3448 Downstream,
3449 }
3450 impl<'de> serde::Deserialize<'de> for GeneratedField {
3451 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3452 where
3453 D: serde::Deserializer<'de>,
3454 {
3455 struct GeneratedVisitor;
3456
3457 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3458 type Value = GeneratedField;
3459
3460 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3461 write!(formatter, "expected one of: {:?}", &FIELDS)
3462 }
3463
3464 #[allow(unused_variables)]
3465 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3466 where
3467 E: serde::de::Error,
3468 {
3469 match value {
3470 "upstream" => Ok(GeneratedField::Upstream),
3471 "downstream" => Ok(GeneratedField::Downstream),
3472 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3473 }
3474 }
3475 }
3476 deserializer.deserialize_identifier(GeneratedVisitor)
3477 }
3478 }
3479 struct GeneratedVisitor;
3480 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3481 type Value = dispatch_output_mapping::TypePair;
3482
3483 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3484 formatter.write_str("struct stream_plan.DispatchOutputMapping.TypePair")
3485 }
3486
3487 fn visit_map<V>(self, mut map_: V) -> std::result::Result<dispatch_output_mapping::TypePair, V::Error>
3488 where
3489 V: serde::de::MapAccess<'de>,
3490 {
3491 let mut upstream__ = None;
3492 let mut downstream__ = None;
3493 while let Some(k) = map_.next_key()? {
3494 match k {
3495 GeneratedField::Upstream => {
3496 if upstream__.is_some() {
3497 return Err(serde::de::Error::duplicate_field("upstream"));
3498 }
3499 upstream__ = map_.next_value()?;
3500 }
3501 GeneratedField::Downstream => {
3502 if downstream__.is_some() {
3503 return Err(serde::de::Error::duplicate_field("downstream"));
3504 }
3505 downstream__ = map_.next_value()?;
3506 }
3507 }
3508 }
3509 Ok(dispatch_output_mapping::TypePair {
3510 upstream: upstream__,
3511 downstream: downstream__,
3512 })
3513 }
3514 }
3515 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping.TypePair", FIELDS, GeneratedVisitor)
3516 }
3517}
3518impl serde::Serialize for DispatchStrategy {
3519 #[allow(deprecated)]
3520 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3521 where
3522 S: serde::Serializer,
3523 {
3524 use serde::ser::SerializeStruct;
3525 let mut len = 0;
3526 if self.r#type != 0 {
3527 len += 1;
3528 }
3529 if !self.dist_key_indices.is_empty() {
3530 len += 1;
3531 }
3532 if self.output_mapping.is_some() {
3533 len += 1;
3534 }
3535 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchStrategy", len)?;
3536 if self.r#type != 0 {
3537 let v = DispatcherType::try_from(self.r#type)
3538 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3539 struct_ser.serialize_field("type", &v)?;
3540 }
3541 if !self.dist_key_indices.is_empty() {
3542 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3543 }
3544 if let Some(v) = self.output_mapping.as_ref() {
3545 struct_ser.serialize_field("outputMapping", v)?;
3546 }
3547 struct_ser.end()
3548 }
3549}
3550impl<'de> serde::Deserialize<'de> for DispatchStrategy {
3551 #[allow(deprecated)]
3552 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3553 where
3554 D: serde::Deserializer<'de>,
3555 {
3556 const FIELDS: &[&str] = &[
3557 "type",
3558 "dist_key_indices",
3559 "distKeyIndices",
3560 "output_mapping",
3561 "outputMapping",
3562 ];
3563
3564 #[allow(clippy::enum_variant_names)]
3565 enum GeneratedField {
3566 Type,
3567 DistKeyIndices,
3568 OutputMapping,
3569 }
3570 impl<'de> serde::Deserialize<'de> for GeneratedField {
3571 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3572 where
3573 D: serde::Deserializer<'de>,
3574 {
3575 struct GeneratedVisitor;
3576
3577 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3578 type Value = GeneratedField;
3579
3580 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3581 write!(formatter, "expected one of: {:?}", &FIELDS)
3582 }
3583
3584 #[allow(unused_variables)]
3585 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3586 where
3587 E: serde::de::Error,
3588 {
3589 match value {
3590 "type" => Ok(GeneratedField::Type),
3591 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3592 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3593 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3594 }
3595 }
3596 }
3597 deserializer.deserialize_identifier(GeneratedVisitor)
3598 }
3599 }
3600 struct GeneratedVisitor;
3601 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3602 type Value = DispatchStrategy;
3603
3604 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3605 formatter.write_str("struct stream_plan.DispatchStrategy")
3606 }
3607
3608 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchStrategy, V::Error>
3609 where
3610 V: serde::de::MapAccess<'de>,
3611 {
3612 let mut r#type__ = None;
3613 let mut dist_key_indices__ = None;
3614 let mut output_mapping__ = None;
3615 while let Some(k) = map_.next_key()? {
3616 match k {
3617 GeneratedField::Type => {
3618 if r#type__.is_some() {
3619 return Err(serde::de::Error::duplicate_field("type"));
3620 }
3621 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3622 }
3623 GeneratedField::DistKeyIndices => {
3624 if dist_key_indices__.is_some() {
3625 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3626 }
3627 dist_key_indices__ =
3628 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3629 .into_iter().map(|x| x.0).collect())
3630 ;
3631 }
3632 GeneratedField::OutputMapping => {
3633 if output_mapping__.is_some() {
3634 return Err(serde::de::Error::duplicate_field("outputMapping"));
3635 }
3636 output_mapping__ = map_.next_value()?;
3637 }
3638 }
3639 }
3640 Ok(DispatchStrategy {
3641 r#type: r#type__.unwrap_or_default(),
3642 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3643 output_mapping: output_mapping__,
3644 })
3645 }
3646 }
3647 deserializer.deserialize_struct("stream_plan.DispatchStrategy", FIELDS, GeneratedVisitor)
3648 }
3649}
3650impl serde::Serialize for Dispatcher {
3651 #[allow(deprecated)]
3652 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3653 where
3654 S: serde::Serializer,
3655 {
3656 use serde::ser::SerializeStruct;
3657 let mut len = 0;
3658 if self.r#type != 0 {
3659 len += 1;
3660 }
3661 if !self.dist_key_indices.is_empty() {
3662 len += 1;
3663 }
3664 if self.output_mapping.is_some() {
3665 len += 1;
3666 }
3667 if self.hash_mapping.is_some() {
3668 len += 1;
3669 }
3670 if self.dispatcher_id != 0 {
3671 len += 1;
3672 }
3673 if !self.downstream_actor_id.is_empty() {
3674 len += 1;
3675 }
3676 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatcher", len)?;
3677 if self.r#type != 0 {
3678 let v = DispatcherType::try_from(self.r#type)
3679 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3680 struct_ser.serialize_field("type", &v)?;
3681 }
3682 if !self.dist_key_indices.is_empty() {
3683 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3684 }
3685 if let Some(v) = self.output_mapping.as_ref() {
3686 struct_ser.serialize_field("outputMapping", v)?;
3687 }
3688 if let Some(v) = self.hash_mapping.as_ref() {
3689 struct_ser.serialize_field("hashMapping", v)?;
3690 }
3691 if self.dispatcher_id != 0 {
3692 #[allow(clippy::needless_borrow)]
3693 #[allow(clippy::needless_borrows_for_generic_args)]
3694 struct_ser.serialize_field("dispatcherId", ToString::to_string(&self.dispatcher_id).as_str())?;
3695 }
3696 if !self.downstream_actor_id.is_empty() {
3697 struct_ser.serialize_field("downstreamActorId", &self.downstream_actor_id)?;
3698 }
3699 struct_ser.end()
3700 }
3701}
3702impl<'de> serde::Deserialize<'de> for Dispatcher {
3703 #[allow(deprecated)]
3704 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3705 where
3706 D: serde::Deserializer<'de>,
3707 {
3708 const FIELDS: &[&str] = &[
3709 "type",
3710 "dist_key_indices",
3711 "distKeyIndices",
3712 "output_mapping",
3713 "outputMapping",
3714 "hash_mapping",
3715 "hashMapping",
3716 "dispatcher_id",
3717 "dispatcherId",
3718 "downstream_actor_id",
3719 "downstreamActorId",
3720 ];
3721
3722 #[allow(clippy::enum_variant_names)]
3723 enum GeneratedField {
3724 Type,
3725 DistKeyIndices,
3726 OutputMapping,
3727 HashMapping,
3728 DispatcherId,
3729 DownstreamActorId,
3730 }
3731 impl<'de> serde::Deserialize<'de> for GeneratedField {
3732 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3733 where
3734 D: serde::Deserializer<'de>,
3735 {
3736 struct GeneratedVisitor;
3737
3738 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3739 type Value = GeneratedField;
3740
3741 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3742 write!(formatter, "expected one of: {:?}", &FIELDS)
3743 }
3744
3745 #[allow(unused_variables)]
3746 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3747 where
3748 E: serde::de::Error,
3749 {
3750 match value {
3751 "type" => Ok(GeneratedField::Type),
3752 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3753 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3754 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
3755 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
3756 "downstreamActorId" | "downstream_actor_id" => Ok(GeneratedField::DownstreamActorId),
3757 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3758 }
3759 }
3760 }
3761 deserializer.deserialize_identifier(GeneratedVisitor)
3762 }
3763 }
3764 struct GeneratedVisitor;
3765 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3766 type Value = Dispatcher;
3767
3768 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3769 formatter.write_str("struct stream_plan.Dispatcher")
3770 }
3771
3772 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatcher, V::Error>
3773 where
3774 V: serde::de::MapAccess<'de>,
3775 {
3776 let mut r#type__ = None;
3777 let mut dist_key_indices__ = None;
3778 let mut output_mapping__ = None;
3779 let mut hash_mapping__ = None;
3780 let mut dispatcher_id__ = None;
3781 let mut downstream_actor_id__ = None;
3782 while let Some(k) = map_.next_key()? {
3783 match k {
3784 GeneratedField::Type => {
3785 if r#type__.is_some() {
3786 return Err(serde::de::Error::duplicate_field("type"));
3787 }
3788 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3789 }
3790 GeneratedField::DistKeyIndices => {
3791 if dist_key_indices__.is_some() {
3792 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3793 }
3794 dist_key_indices__ =
3795 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3796 .into_iter().map(|x| x.0).collect())
3797 ;
3798 }
3799 GeneratedField::OutputMapping => {
3800 if output_mapping__.is_some() {
3801 return Err(serde::de::Error::duplicate_field("outputMapping"));
3802 }
3803 output_mapping__ = map_.next_value()?;
3804 }
3805 GeneratedField::HashMapping => {
3806 if hash_mapping__.is_some() {
3807 return Err(serde::de::Error::duplicate_field("hashMapping"));
3808 }
3809 hash_mapping__ = map_.next_value()?;
3810 }
3811 GeneratedField::DispatcherId => {
3812 if dispatcher_id__.is_some() {
3813 return Err(serde::de::Error::duplicate_field("dispatcherId"));
3814 }
3815 dispatcher_id__ =
3816 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3817 ;
3818 }
3819 GeneratedField::DownstreamActorId => {
3820 if downstream_actor_id__.is_some() {
3821 return Err(serde::de::Error::duplicate_field("downstreamActorId"));
3822 }
3823 downstream_actor_id__ =
3824 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3825 .into_iter().map(|x| x.0).collect())
3826 ;
3827 }
3828 }
3829 }
3830 Ok(Dispatcher {
3831 r#type: r#type__.unwrap_or_default(),
3832 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3833 output_mapping: output_mapping__,
3834 hash_mapping: hash_mapping__,
3835 dispatcher_id: dispatcher_id__.unwrap_or_default(),
3836 downstream_actor_id: downstream_actor_id__.unwrap_or_default(),
3837 })
3838 }
3839 }
3840 deserializer.deserialize_struct("stream_plan.Dispatcher", FIELDS, GeneratedVisitor)
3841 }
3842}
3843impl serde::Serialize for DispatcherType {
3844 #[allow(deprecated)]
3845 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3846 where
3847 S: serde::Serializer,
3848 {
3849 let variant = match self {
3850 Self::Unspecified => "DISPATCHER_TYPE_UNSPECIFIED",
3851 Self::Hash => "DISPATCHER_TYPE_HASH",
3852 Self::Broadcast => "DISPATCHER_TYPE_BROADCAST",
3853 Self::Simple => "DISPATCHER_TYPE_SIMPLE",
3854 Self::NoShuffle => "DISPATCHER_TYPE_NO_SHUFFLE",
3855 };
3856 serializer.serialize_str(variant)
3857 }
3858}
3859impl<'de> serde::Deserialize<'de> for DispatcherType {
3860 #[allow(deprecated)]
3861 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3862 where
3863 D: serde::Deserializer<'de>,
3864 {
3865 const FIELDS: &[&str] = &[
3866 "DISPATCHER_TYPE_UNSPECIFIED",
3867 "DISPATCHER_TYPE_HASH",
3868 "DISPATCHER_TYPE_BROADCAST",
3869 "DISPATCHER_TYPE_SIMPLE",
3870 "DISPATCHER_TYPE_NO_SHUFFLE",
3871 ];
3872
3873 struct GeneratedVisitor;
3874
3875 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3876 type Value = DispatcherType;
3877
3878 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3879 write!(formatter, "expected one of: {:?}", &FIELDS)
3880 }
3881
3882 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3883 where
3884 E: serde::de::Error,
3885 {
3886 i32::try_from(v)
3887 .ok()
3888 .and_then(|x| x.try_into().ok())
3889 .ok_or_else(|| {
3890 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3891 })
3892 }
3893
3894 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3895 where
3896 E: serde::de::Error,
3897 {
3898 i32::try_from(v)
3899 .ok()
3900 .and_then(|x| x.try_into().ok())
3901 .ok_or_else(|| {
3902 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3903 })
3904 }
3905
3906 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3907 where
3908 E: serde::de::Error,
3909 {
3910 match value {
3911 "DISPATCHER_TYPE_UNSPECIFIED" => Ok(DispatcherType::Unspecified),
3912 "DISPATCHER_TYPE_HASH" => Ok(DispatcherType::Hash),
3913 "DISPATCHER_TYPE_BROADCAST" => Ok(DispatcherType::Broadcast),
3914 "DISPATCHER_TYPE_SIMPLE" => Ok(DispatcherType::Simple),
3915 "DISPATCHER_TYPE_NO_SHUFFLE" => Ok(DispatcherType::NoShuffle),
3916 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3917 }
3918 }
3919 }
3920 deserializer.deserialize_any(GeneratedVisitor)
3921 }
3922}
3923impl serde::Serialize for Dispatchers {
3924 #[allow(deprecated)]
3925 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3926 where
3927 S: serde::Serializer,
3928 {
3929 use serde::ser::SerializeStruct;
3930 let mut len = 0;
3931 if !self.dispatchers.is_empty() {
3932 len += 1;
3933 }
3934 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatchers", len)?;
3935 if !self.dispatchers.is_empty() {
3936 struct_ser.serialize_field("dispatchers", &self.dispatchers)?;
3937 }
3938 struct_ser.end()
3939 }
3940}
3941impl<'de> serde::Deserialize<'de> for Dispatchers {
3942 #[allow(deprecated)]
3943 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3944 where
3945 D: serde::Deserializer<'de>,
3946 {
3947 const FIELDS: &[&str] = &[
3948 "dispatchers",
3949 ];
3950
3951 #[allow(clippy::enum_variant_names)]
3952 enum GeneratedField {
3953 Dispatchers,
3954 }
3955 impl<'de> serde::Deserialize<'de> for GeneratedField {
3956 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3957 where
3958 D: serde::Deserializer<'de>,
3959 {
3960 struct GeneratedVisitor;
3961
3962 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3963 type Value = GeneratedField;
3964
3965 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3966 write!(formatter, "expected one of: {:?}", &FIELDS)
3967 }
3968
3969 #[allow(unused_variables)]
3970 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3971 where
3972 E: serde::de::Error,
3973 {
3974 match value {
3975 "dispatchers" => Ok(GeneratedField::Dispatchers),
3976 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3977 }
3978 }
3979 }
3980 deserializer.deserialize_identifier(GeneratedVisitor)
3981 }
3982 }
3983 struct GeneratedVisitor;
3984 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3985 type Value = Dispatchers;
3986
3987 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3988 formatter.write_str("struct stream_plan.Dispatchers")
3989 }
3990
3991 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatchers, V::Error>
3992 where
3993 V: serde::de::MapAccess<'de>,
3994 {
3995 let mut dispatchers__ = None;
3996 while let Some(k) = map_.next_key()? {
3997 match k {
3998 GeneratedField::Dispatchers => {
3999 if dispatchers__.is_some() {
4000 return Err(serde::de::Error::duplicate_field("dispatchers"));
4001 }
4002 dispatchers__ = Some(map_.next_value()?);
4003 }
4004 }
4005 }
4006 Ok(Dispatchers {
4007 dispatchers: dispatchers__.unwrap_or_default(),
4008 })
4009 }
4010 }
4011 deserializer.deserialize_struct("stream_plan.Dispatchers", FIELDS, GeneratedVisitor)
4012 }
4013}
4014impl serde::Serialize for DmlNode {
4015 #[allow(deprecated)]
4016 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4017 where
4018 S: serde::Serializer,
4019 {
4020 use serde::ser::SerializeStruct;
4021 let mut len = 0;
4022 if self.table_id != 0 {
4023 len += 1;
4024 }
4025 if self.table_version_id != 0 {
4026 len += 1;
4027 }
4028 if !self.column_descs.is_empty() {
4029 len += 1;
4030 }
4031 if self.rate_limit.is_some() {
4032 len += 1;
4033 }
4034 let mut struct_ser = serializer.serialize_struct("stream_plan.DmlNode", len)?;
4035 if self.table_id != 0 {
4036 struct_ser.serialize_field("tableId", &self.table_id)?;
4037 }
4038 if self.table_version_id != 0 {
4039 #[allow(clippy::needless_borrow)]
4040 #[allow(clippy::needless_borrows_for_generic_args)]
4041 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
4042 }
4043 if !self.column_descs.is_empty() {
4044 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
4045 }
4046 if let Some(v) = self.rate_limit.as_ref() {
4047 struct_ser.serialize_field("rateLimit", v)?;
4048 }
4049 struct_ser.end()
4050 }
4051}
4052impl<'de> serde::Deserialize<'de> for DmlNode {
4053 #[allow(deprecated)]
4054 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4055 where
4056 D: serde::Deserializer<'de>,
4057 {
4058 const FIELDS: &[&str] = &[
4059 "table_id",
4060 "tableId",
4061 "table_version_id",
4062 "tableVersionId",
4063 "column_descs",
4064 "columnDescs",
4065 "rate_limit",
4066 "rateLimit",
4067 ];
4068
4069 #[allow(clippy::enum_variant_names)]
4070 enum GeneratedField {
4071 TableId,
4072 TableVersionId,
4073 ColumnDescs,
4074 RateLimit,
4075 }
4076 impl<'de> serde::Deserialize<'de> for GeneratedField {
4077 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4078 where
4079 D: serde::Deserializer<'de>,
4080 {
4081 struct GeneratedVisitor;
4082
4083 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4084 type Value = GeneratedField;
4085
4086 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4087 write!(formatter, "expected one of: {:?}", &FIELDS)
4088 }
4089
4090 #[allow(unused_variables)]
4091 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4092 where
4093 E: serde::de::Error,
4094 {
4095 match value {
4096 "tableId" | "table_id" => Ok(GeneratedField::TableId),
4097 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
4098 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
4099 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
4100 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4101 }
4102 }
4103 }
4104 deserializer.deserialize_identifier(GeneratedVisitor)
4105 }
4106 }
4107 struct GeneratedVisitor;
4108 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4109 type Value = DmlNode;
4110
4111 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4112 formatter.write_str("struct stream_plan.DmlNode")
4113 }
4114
4115 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DmlNode, V::Error>
4116 where
4117 V: serde::de::MapAccess<'de>,
4118 {
4119 let mut table_id__ = None;
4120 let mut table_version_id__ = None;
4121 let mut column_descs__ = None;
4122 let mut rate_limit__ = None;
4123 while let Some(k) = map_.next_key()? {
4124 match k {
4125 GeneratedField::TableId => {
4126 if table_id__.is_some() {
4127 return Err(serde::de::Error::duplicate_field("tableId"));
4128 }
4129 table_id__ =
4130 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4131 ;
4132 }
4133 GeneratedField::TableVersionId => {
4134 if table_version_id__.is_some() {
4135 return Err(serde::de::Error::duplicate_field("tableVersionId"));
4136 }
4137 table_version_id__ =
4138 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4139 ;
4140 }
4141 GeneratedField::ColumnDescs => {
4142 if column_descs__.is_some() {
4143 return Err(serde::de::Error::duplicate_field("columnDescs"));
4144 }
4145 column_descs__ = Some(map_.next_value()?);
4146 }
4147 GeneratedField::RateLimit => {
4148 if rate_limit__.is_some() {
4149 return Err(serde::de::Error::duplicate_field("rateLimit"));
4150 }
4151 rate_limit__ =
4152 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4153 ;
4154 }
4155 }
4156 }
4157 Ok(DmlNode {
4158 table_id: table_id__.unwrap_or_default(),
4159 table_version_id: table_version_id__.unwrap_or_default(),
4160 column_descs: column_descs__.unwrap_or_default(),
4161 rate_limit: rate_limit__,
4162 })
4163 }
4164 }
4165 deserializer.deserialize_struct("stream_plan.DmlNode", FIELDS, GeneratedVisitor)
4166 }
4167}
4168impl serde::Serialize for DropSubscriptionsMutation {
4169 #[allow(deprecated)]
4170 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4171 where
4172 S: serde::Serializer,
4173 {
4174 use serde::ser::SerializeStruct;
4175 let mut len = 0;
4176 if !self.info.is_empty() {
4177 len += 1;
4178 }
4179 let mut struct_ser = serializer.serialize_struct("stream_plan.DropSubscriptionsMutation", len)?;
4180 if !self.info.is_empty() {
4181 struct_ser.serialize_field("info", &self.info)?;
4182 }
4183 struct_ser.end()
4184 }
4185}
4186impl<'de> serde::Deserialize<'de> for DropSubscriptionsMutation {
4187 #[allow(deprecated)]
4188 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4189 where
4190 D: serde::Deserializer<'de>,
4191 {
4192 const FIELDS: &[&str] = &[
4193 "info",
4194 ];
4195
4196 #[allow(clippy::enum_variant_names)]
4197 enum GeneratedField {
4198 Info,
4199 }
4200 impl<'de> serde::Deserialize<'de> for GeneratedField {
4201 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4202 where
4203 D: serde::Deserializer<'de>,
4204 {
4205 struct GeneratedVisitor;
4206
4207 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4208 type Value = GeneratedField;
4209
4210 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4211 write!(formatter, "expected one of: {:?}", &FIELDS)
4212 }
4213
4214 #[allow(unused_variables)]
4215 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4216 where
4217 E: serde::de::Error,
4218 {
4219 match value {
4220 "info" => Ok(GeneratedField::Info),
4221 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4222 }
4223 }
4224 }
4225 deserializer.deserialize_identifier(GeneratedVisitor)
4226 }
4227 }
4228 struct GeneratedVisitor;
4229 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4230 type Value = DropSubscriptionsMutation;
4231
4232 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4233 formatter.write_str("struct stream_plan.DropSubscriptionsMutation")
4234 }
4235
4236 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionsMutation, V::Error>
4237 where
4238 V: serde::de::MapAccess<'de>,
4239 {
4240 let mut info__ = None;
4241 while let Some(k) = map_.next_key()? {
4242 match k {
4243 GeneratedField::Info => {
4244 if info__.is_some() {
4245 return Err(serde::de::Error::duplicate_field("info"));
4246 }
4247 info__ = Some(map_.next_value()?);
4248 }
4249 }
4250 }
4251 Ok(DropSubscriptionsMutation {
4252 info: info__.unwrap_or_default(),
4253 })
4254 }
4255 }
4256 deserializer.deserialize_struct("stream_plan.DropSubscriptionsMutation", FIELDS, GeneratedVisitor)
4257 }
4258}
4259impl serde::Serialize for DynamicFilterNode {
4260 #[allow(deprecated)]
4261 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4262 where
4263 S: serde::Serializer,
4264 {
4265 use serde::ser::SerializeStruct;
4266 let mut len = 0;
4267 if self.left_key != 0 {
4268 len += 1;
4269 }
4270 if self.condition.is_some() {
4271 len += 1;
4272 }
4273 if self.left_table.is_some() {
4274 len += 1;
4275 }
4276 if self.right_table.is_some() {
4277 len += 1;
4278 }
4279 if self.condition_always_relax {
4280 len += 1;
4281 }
4282 let mut struct_ser = serializer.serialize_struct("stream_plan.DynamicFilterNode", len)?;
4283 if self.left_key != 0 {
4284 struct_ser.serialize_field("leftKey", &self.left_key)?;
4285 }
4286 if let Some(v) = self.condition.as_ref() {
4287 struct_ser.serialize_field("condition", v)?;
4288 }
4289 if let Some(v) = self.left_table.as_ref() {
4290 struct_ser.serialize_field("leftTable", v)?;
4291 }
4292 if let Some(v) = self.right_table.as_ref() {
4293 struct_ser.serialize_field("rightTable", v)?;
4294 }
4295 if self.condition_always_relax {
4296 struct_ser.serialize_field("conditionAlwaysRelax", &self.condition_always_relax)?;
4297 }
4298 struct_ser.end()
4299 }
4300}
4301impl<'de> serde::Deserialize<'de> for DynamicFilterNode {
4302 #[allow(deprecated)]
4303 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4304 where
4305 D: serde::Deserializer<'de>,
4306 {
4307 const FIELDS: &[&str] = &[
4308 "left_key",
4309 "leftKey",
4310 "condition",
4311 "left_table",
4312 "leftTable",
4313 "right_table",
4314 "rightTable",
4315 "condition_always_relax",
4316 "conditionAlwaysRelax",
4317 ];
4318
4319 #[allow(clippy::enum_variant_names)]
4320 enum GeneratedField {
4321 LeftKey,
4322 Condition,
4323 LeftTable,
4324 RightTable,
4325 ConditionAlwaysRelax,
4326 }
4327 impl<'de> serde::Deserialize<'de> for GeneratedField {
4328 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4329 where
4330 D: serde::Deserializer<'de>,
4331 {
4332 struct GeneratedVisitor;
4333
4334 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4335 type Value = GeneratedField;
4336
4337 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4338 write!(formatter, "expected one of: {:?}", &FIELDS)
4339 }
4340
4341 #[allow(unused_variables)]
4342 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4343 where
4344 E: serde::de::Error,
4345 {
4346 match value {
4347 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
4348 "condition" => Ok(GeneratedField::Condition),
4349 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
4350 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
4351 "conditionAlwaysRelax" | "condition_always_relax" => Ok(GeneratedField::ConditionAlwaysRelax),
4352 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4353 }
4354 }
4355 }
4356 deserializer.deserialize_identifier(GeneratedVisitor)
4357 }
4358 }
4359 struct GeneratedVisitor;
4360 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4361 type Value = DynamicFilterNode;
4362
4363 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4364 formatter.write_str("struct stream_plan.DynamicFilterNode")
4365 }
4366
4367 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DynamicFilterNode, V::Error>
4368 where
4369 V: serde::de::MapAccess<'de>,
4370 {
4371 let mut left_key__ = None;
4372 let mut condition__ = None;
4373 let mut left_table__ = None;
4374 let mut right_table__ = None;
4375 let mut condition_always_relax__ = None;
4376 while let Some(k) = map_.next_key()? {
4377 match k {
4378 GeneratedField::LeftKey => {
4379 if left_key__.is_some() {
4380 return Err(serde::de::Error::duplicate_field("leftKey"));
4381 }
4382 left_key__ =
4383 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4384 ;
4385 }
4386 GeneratedField::Condition => {
4387 if condition__.is_some() {
4388 return Err(serde::de::Error::duplicate_field("condition"));
4389 }
4390 condition__ = map_.next_value()?;
4391 }
4392 GeneratedField::LeftTable => {
4393 if left_table__.is_some() {
4394 return Err(serde::de::Error::duplicate_field("leftTable"));
4395 }
4396 left_table__ = map_.next_value()?;
4397 }
4398 GeneratedField::RightTable => {
4399 if right_table__.is_some() {
4400 return Err(serde::de::Error::duplicate_field("rightTable"));
4401 }
4402 right_table__ = map_.next_value()?;
4403 }
4404 GeneratedField::ConditionAlwaysRelax => {
4405 if condition_always_relax__.is_some() {
4406 return Err(serde::de::Error::duplicate_field("conditionAlwaysRelax"));
4407 }
4408 condition_always_relax__ = Some(map_.next_value()?);
4409 }
4410 }
4411 }
4412 Ok(DynamicFilterNode {
4413 left_key: left_key__.unwrap_or_default(),
4414 condition: condition__,
4415 left_table: left_table__,
4416 right_table: right_table__,
4417 condition_always_relax: condition_always_relax__.unwrap_or_default(),
4418 })
4419 }
4420 }
4421 deserializer.deserialize_struct("stream_plan.DynamicFilterNode", FIELDS, GeneratedVisitor)
4422 }
4423}
4424impl serde::Serialize for EowcGapFillNode {
4425 #[allow(deprecated)]
4426 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4427 where
4428 S: serde::Serializer,
4429 {
4430 use serde::ser::SerializeStruct;
4431 let mut len = 0;
4432 if self.time_column_index != 0 {
4433 len += 1;
4434 }
4435 if self.interval.is_some() {
4436 len += 1;
4437 }
4438 if !self.fill_columns.is_empty() {
4439 len += 1;
4440 }
4441 if !self.fill_strategies.is_empty() {
4442 len += 1;
4443 }
4444 if self.buffer_table.is_some() {
4445 len += 1;
4446 }
4447 if self.prev_row_table.is_some() {
4448 len += 1;
4449 }
4450 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcGapFillNode", len)?;
4451 if self.time_column_index != 0 {
4452 struct_ser.serialize_field("timeColumnIndex", &self.time_column_index)?;
4453 }
4454 if let Some(v) = self.interval.as_ref() {
4455 struct_ser.serialize_field("interval", v)?;
4456 }
4457 if !self.fill_columns.is_empty() {
4458 struct_ser.serialize_field("fillColumns", &self.fill_columns)?;
4459 }
4460 if !self.fill_strategies.is_empty() {
4461 struct_ser.serialize_field("fillStrategies", &self.fill_strategies)?;
4462 }
4463 if let Some(v) = self.buffer_table.as_ref() {
4464 struct_ser.serialize_field("bufferTable", v)?;
4465 }
4466 if let Some(v) = self.prev_row_table.as_ref() {
4467 struct_ser.serialize_field("prevRowTable", v)?;
4468 }
4469 struct_ser.end()
4470 }
4471}
4472impl<'de> serde::Deserialize<'de> for EowcGapFillNode {
4473 #[allow(deprecated)]
4474 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4475 where
4476 D: serde::Deserializer<'de>,
4477 {
4478 const FIELDS: &[&str] = &[
4479 "time_column_index",
4480 "timeColumnIndex",
4481 "interval",
4482 "fill_columns",
4483 "fillColumns",
4484 "fill_strategies",
4485 "fillStrategies",
4486 "buffer_table",
4487 "bufferTable",
4488 "prev_row_table",
4489 "prevRowTable",
4490 ];
4491
4492 #[allow(clippy::enum_variant_names)]
4493 enum GeneratedField {
4494 TimeColumnIndex,
4495 Interval,
4496 FillColumns,
4497 FillStrategies,
4498 BufferTable,
4499 PrevRowTable,
4500 }
4501 impl<'de> serde::Deserialize<'de> for GeneratedField {
4502 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4503 where
4504 D: serde::Deserializer<'de>,
4505 {
4506 struct GeneratedVisitor;
4507
4508 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4509 type Value = GeneratedField;
4510
4511 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4512 write!(formatter, "expected one of: {:?}", &FIELDS)
4513 }
4514
4515 #[allow(unused_variables)]
4516 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4517 where
4518 E: serde::de::Error,
4519 {
4520 match value {
4521 "timeColumnIndex" | "time_column_index" => Ok(GeneratedField::TimeColumnIndex),
4522 "interval" => Ok(GeneratedField::Interval),
4523 "fillColumns" | "fill_columns" => Ok(GeneratedField::FillColumns),
4524 "fillStrategies" | "fill_strategies" => Ok(GeneratedField::FillStrategies),
4525 "bufferTable" | "buffer_table" => Ok(GeneratedField::BufferTable),
4526 "prevRowTable" | "prev_row_table" => Ok(GeneratedField::PrevRowTable),
4527 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4528 }
4529 }
4530 }
4531 deserializer.deserialize_identifier(GeneratedVisitor)
4532 }
4533 }
4534 struct GeneratedVisitor;
4535 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4536 type Value = EowcGapFillNode;
4537
4538 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4539 formatter.write_str("struct stream_plan.EowcGapFillNode")
4540 }
4541
4542 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcGapFillNode, V::Error>
4543 where
4544 V: serde::de::MapAccess<'de>,
4545 {
4546 let mut time_column_index__ = None;
4547 let mut interval__ = None;
4548 let mut fill_columns__ = None;
4549 let mut fill_strategies__ = None;
4550 let mut buffer_table__ = None;
4551 let mut prev_row_table__ = None;
4552 while let Some(k) = map_.next_key()? {
4553 match k {
4554 GeneratedField::TimeColumnIndex => {
4555 if time_column_index__.is_some() {
4556 return Err(serde::de::Error::duplicate_field("timeColumnIndex"));
4557 }
4558 time_column_index__ =
4559 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4560 ;
4561 }
4562 GeneratedField::Interval => {
4563 if interval__.is_some() {
4564 return Err(serde::de::Error::duplicate_field("interval"));
4565 }
4566 interval__ = map_.next_value()?;
4567 }
4568 GeneratedField::FillColumns => {
4569 if fill_columns__.is_some() {
4570 return Err(serde::de::Error::duplicate_field("fillColumns"));
4571 }
4572 fill_columns__ =
4573 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4574 .into_iter().map(|x| x.0).collect())
4575 ;
4576 }
4577 GeneratedField::FillStrategies => {
4578 if fill_strategies__.is_some() {
4579 return Err(serde::de::Error::duplicate_field("fillStrategies"));
4580 }
4581 fill_strategies__ = Some(map_.next_value()?);
4582 }
4583 GeneratedField::BufferTable => {
4584 if buffer_table__.is_some() {
4585 return Err(serde::de::Error::duplicate_field("bufferTable"));
4586 }
4587 buffer_table__ = map_.next_value()?;
4588 }
4589 GeneratedField::PrevRowTable => {
4590 if prev_row_table__.is_some() {
4591 return Err(serde::de::Error::duplicate_field("prevRowTable"));
4592 }
4593 prev_row_table__ = map_.next_value()?;
4594 }
4595 }
4596 }
4597 Ok(EowcGapFillNode {
4598 time_column_index: time_column_index__.unwrap_or_default(),
4599 interval: interval__,
4600 fill_columns: fill_columns__.unwrap_or_default(),
4601 fill_strategies: fill_strategies__.unwrap_or_default(),
4602 buffer_table: buffer_table__,
4603 prev_row_table: prev_row_table__,
4604 })
4605 }
4606 }
4607 deserializer.deserialize_struct("stream_plan.EowcGapFillNode", FIELDS, GeneratedVisitor)
4608 }
4609}
4610impl serde::Serialize for EowcOverWindowNode {
4611 #[allow(deprecated)]
4612 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4613 where
4614 S: serde::Serializer,
4615 {
4616 use serde::ser::SerializeStruct;
4617 let mut len = 0;
4618 if !self.calls.is_empty() {
4619 len += 1;
4620 }
4621 if !self.partition_by.is_empty() {
4622 len += 1;
4623 }
4624 if !self.order_by.is_empty() {
4625 len += 1;
4626 }
4627 if self.state_table.is_some() {
4628 len += 1;
4629 }
4630 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcOverWindowNode", len)?;
4631 if !self.calls.is_empty() {
4632 struct_ser.serialize_field("calls", &self.calls)?;
4633 }
4634 if !self.partition_by.is_empty() {
4635 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
4636 }
4637 if !self.order_by.is_empty() {
4638 struct_ser.serialize_field("orderBy", &self.order_by)?;
4639 }
4640 if let Some(v) = self.state_table.as_ref() {
4641 struct_ser.serialize_field("stateTable", v)?;
4642 }
4643 struct_ser.end()
4644 }
4645}
4646impl<'de> serde::Deserialize<'de> for EowcOverWindowNode {
4647 #[allow(deprecated)]
4648 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4649 where
4650 D: serde::Deserializer<'de>,
4651 {
4652 const FIELDS: &[&str] = &[
4653 "calls",
4654 "partition_by",
4655 "partitionBy",
4656 "order_by",
4657 "orderBy",
4658 "state_table",
4659 "stateTable",
4660 ];
4661
4662 #[allow(clippy::enum_variant_names)]
4663 enum GeneratedField {
4664 Calls,
4665 PartitionBy,
4666 OrderBy,
4667 StateTable,
4668 }
4669 impl<'de> serde::Deserialize<'de> for GeneratedField {
4670 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4671 where
4672 D: serde::Deserializer<'de>,
4673 {
4674 struct GeneratedVisitor;
4675
4676 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4677 type Value = GeneratedField;
4678
4679 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4680 write!(formatter, "expected one of: {:?}", &FIELDS)
4681 }
4682
4683 #[allow(unused_variables)]
4684 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4685 where
4686 E: serde::de::Error,
4687 {
4688 match value {
4689 "calls" => Ok(GeneratedField::Calls),
4690 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
4691 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
4692 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
4693 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4694 }
4695 }
4696 }
4697 deserializer.deserialize_identifier(GeneratedVisitor)
4698 }
4699 }
4700 struct GeneratedVisitor;
4701 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4702 type Value = EowcOverWindowNode;
4703
4704 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4705 formatter.write_str("struct stream_plan.EowcOverWindowNode")
4706 }
4707
4708 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcOverWindowNode, V::Error>
4709 where
4710 V: serde::de::MapAccess<'de>,
4711 {
4712 let mut calls__ = None;
4713 let mut partition_by__ = None;
4714 let mut order_by__ = None;
4715 let mut state_table__ = None;
4716 while let Some(k) = map_.next_key()? {
4717 match k {
4718 GeneratedField::Calls => {
4719 if calls__.is_some() {
4720 return Err(serde::de::Error::duplicate_field("calls"));
4721 }
4722 calls__ = Some(map_.next_value()?);
4723 }
4724 GeneratedField::PartitionBy => {
4725 if partition_by__.is_some() {
4726 return Err(serde::de::Error::duplicate_field("partitionBy"));
4727 }
4728 partition_by__ =
4729 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4730 .into_iter().map(|x| x.0).collect())
4731 ;
4732 }
4733 GeneratedField::OrderBy => {
4734 if order_by__.is_some() {
4735 return Err(serde::de::Error::duplicate_field("orderBy"));
4736 }
4737 order_by__ = Some(map_.next_value()?);
4738 }
4739 GeneratedField::StateTable => {
4740 if state_table__.is_some() {
4741 return Err(serde::de::Error::duplicate_field("stateTable"));
4742 }
4743 state_table__ = map_.next_value()?;
4744 }
4745 }
4746 }
4747 Ok(EowcOverWindowNode {
4748 calls: calls__.unwrap_or_default(),
4749 partition_by: partition_by__.unwrap_or_default(),
4750 order_by: order_by__.unwrap_or_default(),
4751 state_table: state_table__,
4752 })
4753 }
4754 }
4755 deserializer.deserialize_struct("stream_plan.EowcOverWindowNode", FIELDS, GeneratedVisitor)
4756 }
4757}
4758impl serde::Serialize for ExchangeNode {
4759 #[allow(deprecated)]
4760 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4761 where
4762 S: serde::Serializer,
4763 {
4764 use serde::ser::SerializeStruct;
4765 let mut len = 0;
4766 if self.strategy.is_some() {
4767 len += 1;
4768 }
4769 let mut struct_ser = serializer.serialize_struct("stream_plan.ExchangeNode", len)?;
4770 if let Some(v) = self.strategy.as_ref() {
4771 struct_ser.serialize_field("strategy", v)?;
4772 }
4773 struct_ser.end()
4774 }
4775}
4776impl<'de> serde::Deserialize<'de> for ExchangeNode {
4777 #[allow(deprecated)]
4778 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4779 where
4780 D: serde::Deserializer<'de>,
4781 {
4782 const FIELDS: &[&str] = &[
4783 "strategy",
4784 ];
4785
4786 #[allow(clippy::enum_variant_names)]
4787 enum GeneratedField {
4788 Strategy,
4789 }
4790 impl<'de> serde::Deserialize<'de> for GeneratedField {
4791 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4792 where
4793 D: serde::Deserializer<'de>,
4794 {
4795 struct GeneratedVisitor;
4796
4797 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4798 type Value = GeneratedField;
4799
4800 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4801 write!(formatter, "expected one of: {:?}", &FIELDS)
4802 }
4803
4804 #[allow(unused_variables)]
4805 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4806 where
4807 E: serde::de::Error,
4808 {
4809 match value {
4810 "strategy" => Ok(GeneratedField::Strategy),
4811 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4812 }
4813 }
4814 }
4815 deserializer.deserialize_identifier(GeneratedVisitor)
4816 }
4817 }
4818 struct GeneratedVisitor;
4819 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4820 type Value = ExchangeNode;
4821
4822 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4823 formatter.write_str("struct stream_plan.ExchangeNode")
4824 }
4825
4826 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExchangeNode, V::Error>
4827 where
4828 V: serde::de::MapAccess<'de>,
4829 {
4830 let mut strategy__ = None;
4831 while let Some(k) = map_.next_key()? {
4832 match k {
4833 GeneratedField::Strategy => {
4834 if strategy__.is_some() {
4835 return Err(serde::de::Error::duplicate_field("strategy"));
4836 }
4837 strategy__ = map_.next_value()?;
4838 }
4839 }
4840 }
4841 Ok(ExchangeNode {
4842 strategy: strategy__,
4843 })
4844 }
4845 }
4846 deserializer.deserialize_struct("stream_plan.ExchangeNode", FIELDS, GeneratedVisitor)
4847 }
4848}
4849impl serde::Serialize for ExpandNode {
4850 #[allow(deprecated)]
4851 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4852 where
4853 S: serde::Serializer,
4854 {
4855 use serde::ser::SerializeStruct;
4856 let mut len = 0;
4857 if !self.column_subsets.is_empty() {
4858 len += 1;
4859 }
4860 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode", len)?;
4861 if !self.column_subsets.is_empty() {
4862 struct_ser.serialize_field("columnSubsets", &self.column_subsets)?;
4863 }
4864 struct_ser.end()
4865 }
4866}
4867impl<'de> serde::Deserialize<'de> for ExpandNode {
4868 #[allow(deprecated)]
4869 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4870 where
4871 D: serde::Deserializer<'de>,
4872 {
4873 const FIELDS: &[&str] = &[
4874 "column_subsets",
4875 "columnSubsets",
4876 ];
4877
4878 #[allow(clippy::enum_variant_names)]
4879 enum GeneratedField {
4880 ColumnSubsets,
4881 }
4882 impl<'de> serde::Deserialize<'de> for GeneratedField {
4883 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4884 where
4885 D: serde::Deserializer<'de>,
4886 {
4887 struct GeneratedVisitor;
4888
4889 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4890 type Value = GeneratedField;
4891
4892 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4893 write!(formatter, "expected one of: {:?}", &FIELDS)
4894 }
4895
4896 #[allow(unused_variables)]
4897 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4898 where
4899 E: serde::de::Error,
4900 {
4901 match value {
4902 "columnSubsets" | "column_subsets" => Ok(GeneratedField::ColumnSubsets),
4903 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4904 }
4905 }
4906 }
4907 deserializer.deserialize_identifier(GeneratedVisitor)
4908 }
4909 }
4910 struct GeneratedVisitor;
4911 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4912 type Value = ExpandNode;
4913
4914 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4915 formatter.write_str("struct stream_plan.ExpandNode")
4916 }
4917
4918 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpandNode, V::Error>
4919 where
4920 V: serde::de::MapAccess<'de>,
4921 {
4922 let mut column_subsets__ = None;
4923 while let Some(k) = map_.next_key()? {
4924 match k {
4925 GeneratedField::ColumnSubsets => {
4926 if column_subsets__.is_some() {
4927 return Err(serde::de::Error::duplicate_field("columnSubsets"));
4928 }
4929 column_subsets__ = Some(map_.next_value()?);
4930 }
4931 }
4932 }
4933 Ok(ExpandNode {
4934 column_subsets: column_subsets__.unwrap_or_default(),
4935 })
4936 }
4937 }
4938 deserializer.deserialize_struct("stream_plan.ExpandNode", FIELDS, GeneratedVisitor)
4939 }
4940}
4941impl serde::Serialize for expand_node::Subset {
4942 #[allow(deprecated)]
4943 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4944 where
4945 S: serde::Serializer,
4946 {
4947 use serde::ser::SerializeStruct;
4948 let mut len = 0;
4949 if !self.column_indices.is_empty() {
4950 len += 1;
4951 }
4952 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode.Subset", len)?;
4953 if !self.column_indices.is_empty() {
4954 struct_ser.serialize_field("columnIndices", &self.column_indices)?;
4955 }
4956 struct_ser.end()
4957 }
4958}
4959impl<'de> serde::Deserialize<'de> for expand_node::Subset {
4960 #[allow(deprecated)]
4961 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4962 where
4963 D: serde::Deserializer<'de>,
4964 {
4965 const FIELDS: &[&str] = &[
4966 "column_indices",
4967 "columnIndices",
4968 ];
4969
4970 #[allow(clippy::enum_variant_names)]
4971 enum GeneratedField {
4972 ColumnIndices,
4973 }
4974 impl<'de> serde::Deserialize<'de> for GeneratedField {
4975 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4976 where
4977 D: serde::Deserializer<'de>,
4978 {
4979 struct GeneratedVisitor;
4980
4981 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4982 type Value = GeneratedField;
4983
4984 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4985 write!(formatter, "expected one of: {:?}", &FIELDS)
4986 }
4987
4988 #[allow(unused_variables)]
4989 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4990 where
4991 E: serde::de::Error,
4992 {
4993 match value {
4994 "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
4995 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4996 }
4997 }
4998 }
4999 deserializer.deserialize_identifier(GeneratedVisitor)
5000 }
5001 }
5002 struct GeneratedVisitor;
5003 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5004 type Value = expand_node::Subset;
5005
5006 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5007 formatter.write_str("struct stream_plan.ExpandNode.Subset")
5008 }
5009
5010 fn visit_map<V>(self, mut map_: V) -> std::result::Result<expand_node::Subset, V::Error>
5011 where
5012 V: serde::de::MapAccess<'de>,
5013 {
5014 let mut column_indices__ = None;
5015 while let Some(k) = map_.next_key()? {
5016 match k {
5017 GeneratedField::ColumnIndices => {
5018 if column_indices__.is_some() {
5019 return Err(serde::de::Error::duplicate_field("columnIndices"));
5020 }
5021 column_indices__ =
5022 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5023 .into_iter().map(|x| x.0).collect())
5024 ;
5025 }
5026 }
5027 }
5028 Ok(expand_node::Subset {
5029 column_indices: column_indices__.unwrap_or_default(),
5030 })
5031 }
5032 }
5033 deserializer.deserialize_struct("stream_plan.ExpandNode.Subset", FIELDS, GeneratedVisitor)
5034 }
5035}
5036impl serde::Serialize for FilterNode {
5037 #[allow(deprecated)]
5038 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5039 where
5040 S: serde::Serializer,
5041 {
5042 use serde::ser::SerializeStruct;
5043 let mut len = 0;
5044 if self.search_condition.is_some() {
5045 len += 1;
5046 }
5047 let mut struct_ser = serializer.serialize_struct("stream_plan.FilterNode", len)?;
5048 if let Some(v) = self.search_condition.as_ref() {
5049 struct_ser.serialize_field("searchCondition", v)?;
5050 }
5051 struct_ser.end()
5052 }
5053}
5054impl<'de> serde::Deserialize<'de> for FilterNode {
5055 #[allow(deprecated)]
5056 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5057 where
5058 D: serde::Deserializer<'de>,
5059 {
5060 const FIELDS: &[&str] = &[
5061 "search_condition",
5062 "searchCondition",
5063 ];
5064
5065 #[allow(clippy::enum_variant_names)]
5066 enum GeneratedField {
5067 SearchCondition,
5068 }
5069 impl<'de> serde::Deserialize<'de> for GeneratedField {
5070 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5071 where
5072 D: serde::Deserializer<'de>,
5073 {
5074 struct GeneratedVisitor;
5075
5076 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5077 type Value = GeneratedField;
5078
5079 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5080 write!(formatter, "expected one of: {:?}", &FIELDS)
5081 }
5082
5083 #[allow(unused_variables)]
5084 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5085 where
5086 E: serde::de::Error,
5087 {
5088 match value {
5089 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
5090 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5091 }
5092 }
5093 }
5094 deserializer.deserialize_identifier(GeneratedVisitor)
5095 }
5096 }
5097 struct GeneratedVisitor;
5098 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5099 type Value = FilterNode;
5100
5101 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5102 formatter.write_str("struct stream_plan.FilterNode")
5103 }
5104
5105 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FilterNode, V::Error>
5106 where
5107 V: serde::de::MapAccess<'de>,
5108 {
5109 let mut search_condition__ = None;
5110 while let Some(k) = map_.next_key()? {
5111 match k {
5112 GeneratedField::SearchCondition => {
5113 if search_condition__.is_some() {
5114 return Err(serde::de::Error::duplicate_field("searchCondition"));
5115 }
5116 search_condition__ = map_.next_value()?;
5117 }
5118 }
5119 }
5120 Ok(FilterNode {
5121 search_condition: search_condition__,
5122 })
5123 }
5124 }
5125 deserializer.deserialize_struct("stream_plan.FilterNode", FIELDS, GeneratedVisitor)
5126 }
5127}
5128impl serde::Serialize for GapFillNode {
5129 #[allow(deprecated)]
5130 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5131 where
5132 S: serde::Serializer,
5133 {
5134 use serde::ser::SerializeStruct;
5135 let mut len = 0;
5136 if self.time_column_index != 0 {
5137 len += 1;
5138 }
5139 if self.interval.is_some() {
5140 len += 1;
5141 }
5142 if !self.fill_columns.is_empty() {
5143 len += 1;
5144 }
5145 if !self.fill_strategies.is_empty() {
5146 len += 1;
5147 }
5148 if self.state_table.is_some() {
5149 len += 1;
5150 }
5151 let mut struct_ser = serializer.serialize_struct("stream_plan.GapFillNode", len)?;
5152 if self.time_column_index != 0 {
5153 struct_ser.serialize_field("timeColumnIndex", &self.time_column_index)?;
5154 }
5155 if let Some(v) = self.interval.as_ref() {
5156 struct_ser.serialize_field("interval", v)?;
5157 }
5158 if !self.fill_columns.is_empty() {
5159 struct_ser.serialize_field("fillColumns", &self.fill_columns)?;
5160 }
5161 if !self.fill_strategies.is_empty() {
5162 struct_ser.serialize_field("fillStrategies", &self.fill_strategies)?;
5163 }
5164 if let Some(v) = self.state_table.as_ref() {
5165 struct_ser.serialize_field("stateTable", v)?;
5166 }
5167 struct_ser.end()
5168 }
5169}
5170impl<'de> serde::Deserialize<'de> for GapFillNode {
5171 #[allow(deprecated)]
5172 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5173 where
5174 D: serde::Deserializer<'de>,
5175 {
5176 const FIELDS: &[&str] = &[
5177 "time_column_index",
5178 "timeColumnIndex",
5179 "interval",
5180 "fill_columns",
5181 "fillColumns",
5182 "fill_strategies",
5183 "fillStrategies",
5184 "state_table",
5185 "stateTable",
5186 ];
5187
5188 #[allow(clippy::enum_variant_names)]
5189 enum GeneratedField {
5190 TimeColumnIndex,
5191 Interval,
5192 FillColumns,
5193 FillStrategies,
5194 StateTable,
5195 }
5196 impl<'de> serde::Deserialize<'de> for GeneratedField {
5197 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5198 where
5199 D: serde::Deserializer<'de>,
5200 {
5201 struct GeneratedVisitor;
5202
5203 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5204 type Value = GeneratedField;
5205
5206 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5207 write!(formatter, "expected one of: {:?}", &FIELDS)
5208 }
5209
5210 #[allow(unused_variables)]
5211 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5212 where
5213 E: serde::de::Error,
5214 {
5215 match value {
5216 "timeColumnIndex" | "time_column_index" => Ok(GeneratedField::TimeColumnIndex),
5217 "interval" => Ok(GeneratedField::Interval),
5218 "fillColumns" | "fill_columns" => Ok(GeneratedField::FillColumns),
5219 "fillStrategies" | "fill_strategies" => Ok(GeneratedField::FillStrategies),
5220 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
5221 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5222 }
5223 }
5224 }
5225 deserializer.deserialize_identifier(GeneratedVisitor)
5226 }
5227 }
5228 struct GeneratedVisitor;
5229 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5230 type Value = GapFillNode;
5231
5232 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5233 formatter.write_str("struct stream_plan.GapFillNode")
5234 }
5235
5236 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GapFillNode, V::Error>
5237 where
5238 V: serde::de::MapAccess<'de>,
5239 {
5240 let mut time_column_index__ = None;
5241 let mut interval__ = None;
5242 let mut fill_columns__ = None;
5243 let mut fill_strategies__ = None;
5244 let mut state_table__ = None;
5245 while let Some(k) = map_.next_key()? {
5246 match k {
5247 GeneratedField::TimeColumnIndex => {
5248 if time_column_index__.is_some() {
5249 return Err(serde::de::Error::duplicate_field("timeColumnIndex"));
5250 }
5251 time_column_index__ =
5252 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5253 ;
5254 }
5255 GeneratedField::Interval => {
5256 if interval__.is_some() {
5257 return Err(serde::de::Error::duplicate_field("interval"));
5258 }
5259 interval__ = map_.next_value()?;
5260 }
5261 GeneratedField::FillColumns => {
5262 if fill_columns__.is_some() {
5263 return Err(serde::de::Error::duplicate_field("fillColumns"));
5264 }
5265 fill_columns__ =
5266 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5267 .into_iter().map(|x| x.0).collect())
5268 ;
5269 }
5270 GeneratedField::FillStrategies => {
5271 if fill_strategies__.is_some() {
5272 return Err(serde::de::Error::duplicate_field("fillStrategies"));
5273 }
5274 fill_strategies__ = Some(map_.next_value()?);
5275 }
5276 GeneratedField::StateTable => {
5277 if state_table__.is_some() {
5278 return Err(serde::de::Error::duplicate_field("stateTable"));
5279 }
5280 state_table__ = map_.next_value()?;
5281 }
5282 }
5283 }
5284 Ok(GapFillNode {
5285 time_column_index: time_column_index__.unwrap_or_default(),
5286 interval: interval__,
5287 fill_columns: fill_columns__.unwrap_or_default(),
5288 fill_strategies: fill_strategies__.unwrap_or_default(),
5289 state_table: state_table__,
5290 })
5291 }
5292 }
5293 deserializer.deserialize_struct("stream_plan.GapFillNode", FIELDS, GeneratedVisitor)
5294 }
5295}
5296impl serde::Serialize for GlobalApproxPercentileNode {
5297 #[allow(deprecated)]
5298 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5299 where
5300 S: serde::Serializer,
5301 {
5302 use serde::ser::SerializeStruct;
5303 let mut len = 0;
5304 if self.base != 0. {
5305 len += 1;
5306 }
5307 if self.quantile != 0. {
5308 len += 1;
5309 }
5310 if self.bucket_state_table.is_some() {
5311 len += 1;
5312 }
5313 if self.count_state_table.is_some() {
5314 len += 1;
5315 }
5316 let mut struct_ser = serializer.serialize_struct("stream_plan.GlobalApproxPercentileNode", len)?;
5317 if self.base != 0. {
5318 struct_ser.serialize_field("base", &self.base)?;
5319 }
5320 if self.quantile != 0. {
5321 struct_ser.serialize_field("quantile", &self.quantile)?;
5322 }
5323 if let Some(v) = self.bucket_state_table.as_ref() {
5324 struct_ser.serialize_field("bucketStateTable", v)?;
5325 }
5326 if let Some(v) = self.count_state_table.as_ref() {
5327 struct_ser.serialize_field("countStateTable", v)?;
5328 }
5329 struct_ser.end()
5330 }
5331}
5332impl<'de> serde::Deserialize<'de> for GlobalApproxPercentileNode {
5333 #[allow(deprecated)]
5334 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5335 where
5336 D: serde::Deserializer<'de>,
5337 {
5338 const FIELDS: &[&str] = &[
5339 "base",
5340 "quantile",
5341 "bucket_state_table",
5342 "bucketStateTable",
5343 "count_state_table",
5344 "countStateTable",
5345 ];
5346
5347 #[allow(clippy::enum_variant_names)]
5348 enum GeneratedField {
5349 Base,
5350 Quantile,
5351 BucketStateTable,
5352 CountStateTable,
5353 }
5354 impl<'de> serde::Deserialize<'de> for GeneratedField {
5355 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5356 where
5357 D: serde::Deserializer<'de>,
5358 {
5359 struct GeneratedVisitor;
5360
5361 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5362 type Value = GeneratedField;
5363
5364 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5365 write!(formatter, "expected one of: {:?}", &FIELDS)
5366 }
5367
5368 #[allow(unused_variables)]
5369 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5370 where
5371 E: serde::de::Error,
5372 {
5373 match value {
5374 "base" => Ok(GeneratedField::Base),
5375 "quantile" => Ok(GeneratedField::Quantile),
5376 "bucketStateTable" | "bucket_state_table" => Ok(GeneratedField::BucketStateTable),
5377 "countStateTable" | "count_state_table" => Ok(GeneratedField::CountStateTable),
5378 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5379 }
5380 }
5381 }
5382 deserializer.deserialize_identifier(GeneratedVisitor)
5383 }
5384 }
5385 struct GeneratedVisitor;
5386 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5387 type Value = GlobalApproxPercentileNode;
5388
5389 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5390 formatter.write_str("struct stream_plan.GlobalApproxPercentileNode")
5391 }
5392
5393 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GlobalApproxPercentileNode, V::Error>
5394 where
5395 V: serde::de::MapAccess<'de>,
5396 {
5397 let mut base__ = None;
5398 let mut quantile__ = None;
5399 let mut bucket_state_table__ = None;
5400 let mut count_state_table__ = None;
5401 while let Some(k) = map_.next_key()? {
5402 match k {
5403 GeneratedField::Base => {
5404 if base__.is_some() {
5405 return Err(serde::de::Error::duplicate_field("base"));
5406 }
5407 base__ =
5408 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5409 ;
5410 }
5411 GeneratedField::Quantile => {
5412 if quantile__.is_some() {
5413 return Err(serde::de::Error::duplicate_field("quantile"));
5414 }
5415 quantile__ =
5416 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5417 ;
5418 }
5419 GeneratedField::BucketStateTable => {
5420 if bucket_state_table__.is_some() {
5421 return Err(serde::de::Error::duplicate_field("bucketStateTable"));
5422 }
5423 bucket_state_table__ = map_.next_value()?;
5424 }
5425 GeneratedField::CountStateTable => {
5426 if count_state_table__.is_some() {
5427 return Err(serde::de::Error::duplicate_field("countStateTable"));
5428 }
5429 count_state_table__ = map_.next_value()?;
5430 }
5431 }
5432 }
5433 Ok(GlobalApproxPercentileNode {
5434 base: base__.unwrap_or_default(),
5435 quantile: quantile__.unwrap_or_default(),
5436 bucket_state_table: bucket_state_table__,
5437 count_state_table: count_state_table__,
5438 })
5439 }
5440 }
5441 deserializer.deserialize_struct("stream_plan.GlobalApproxPercentileNode", FIELDS, GeneratedVisitor)
5442 }
5443}
5444impl serde::Serialize for GroupTopNNode {
5445 #[allow(deprecated)]
5446 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5447 where
5448 S: serde::Serializer,
5449 {
5450 use serde::ser::SerializeStruct;
5451 let mut len = 0;
5452 if self.limit != 0 {
5453 len += 1;
5454 }
5455 if self.offset != 0 {
5456 len += 1;
5457 }
5458 if !self.group_key.is_empty() {
5459 len += 1;
5460 }
5461 if self.table.is_some() {
5462 len += 1;
5463 }
5464 if !self.order_by.is_empty() {
5465 len += 1;
5466 }
5467 if self.with_ties {
5468 len += 1;
5469 }
5470 let mut struct_ser = serializer.serialize_struct("stream_plan.GroupTopNNode", len)?;
5471 if self.limit != 0 {
5472 #[allow(clippy::needless_borrow)]
5473 #[allow(clippy::needless_borrows_for_generic_args)]
5474 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
5475 }
5476 if self.offset != 0 {
5477 #[allow(clippy::needless_borrow)]
5478 #[allow(clippy::needless_borrows_for_generic_args)]
5479 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
5480 }
5481 if !self.group_key.is_empty() {
5482 struct_ser.serialize_field("groupKey", &self.group_key)?;
5483 }
5484 if let Some(v) = self.table.as_ref() {
5485 struct_ser.serialize_field("table", v)?;
5486 }
5487 if !self.order_by.is_empty() {
5488 struct_ser.serialize_field("orderBy", &self.order_by)?;
5489 }
5490 if self.with_ties {
5491 struct_ser.serialize_field("withTies", &self.with_ties)?;
5492 }
5493 struct_ser.end()
5494 }
5495}
5496impl<'de> serde::Deserialize<'de> for GroupTopNNode {
5497 #[allow(deprecated)]
5498 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5499 where
5500 D: serde::Deserializer<'de>,
5501 {
5502 const FIELDS: &[&str] = &[
5503 "limit",
5504 "offset",
5505 "group_key",
5506 "groupKey",
5507 "table",
5508 "order_by",
5509 "orderBy",
5510 "with_ties",
5511 "withTies",
5512 ];
5513
5514 #[allow(clippy::enum_variant_names)]
5515 enum GeneratedField {
5516 Limit,
5517 Offset,
5518 GroupKey,
5519 Table,
5520 OrderBy,
5521 WithTies,
5522 }
5523 impl<'de> serde::Deserialize<'de> for GeneratedField {
5524 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5525 where
5526 D: serde::Deserializer<'de>,
5527 {
5528 struct GeneratedVisitor;
5529
5530 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5531 type Value = GeneratedField;
5532
5533 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5534 write!(formatter, "expected one of: {:?}", &FIELDS)
5535 }
5536
5537 #[allow(unused_variables)]
5538 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5539 where
5540 E: serde::de::Error,
5541 {
5542 match value {
5543 "limit" => Ok(GeneratedField::Limit),
5544 "offset" => Ok(GeneratedField::Offset),
5545 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5546 "table" => Ok(GeneratedField::Table),
5547 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
5548 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
5549 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5550 }
5551 }
5552 }
5553 deserializer.deserialize_identifier(GeneratedVisitor)
5554 }
5555 }
5556 struct GeneratedVisitor;
5557 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5558 type Value = GroupTopNNode;
5559
5560 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5561 formatter.write_str("struct stream_plan.GroupTopNNode")
5562 }
5563
5564 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupTopNNode, V::Error>
5565 where
5566 V: serde::de::MapAccess<'de>,
5567 {
5568 let mut limit__ = None;
5569 let mut offset__ = None;
5570 let mut group_key__ = None;
5571 let mut table__ = None;
5572 let mut order_by__ = None;
5573 let mut with_ties__ = None;
5574 while let Some(k) = map_.next_key()? {
5575 match k {
5576 GeneratedField::Limit => {
5577 if limit__.is_some() {
5578 return Err(serde::de::Error::duplicate_field("limit"));
5579 }
5580 limit__ =
5581 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5582 ;
5583 }
5584 GeneratedField::Offset => {
5585 if offset__.is_some() {
5586 return Err(serde::de::Error::duplicate_field("offset"));
5587 }
5588 offset__ =
5589 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5590 ;
5591 }
5592 GeneratedField::GroupKey => {
5593 if group_key__.is_some() {
5594 return Err(serde::de::Error::duplicate_field("groupKey"));
5595 }
5596 group_key__ =
5597 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5598 .into_iter().map(|x| x.0).collect())
5599 ;
5600 }
5601 GeneratedField::Table => {
5602 if table__.is_some() {
5603 return Err(serde::de::Error::duplicate_field("table"));
5604 }
5605 table__ = map_.next_value()?;
5606 }
5607 GeneratedField::OrderBy => {
5608 if order_by__.is_some() {
5609 return Err(serde::de::Error::duplicate_field("orderBy"));
5610 }
5611 order_by__ = Some(map_.next_value()?);
5612 }
5613 GeneratedField::WithTies => {
5614 if with_ties__.is_some() {
5615 return Err(serde::de::Error::duplicate_field("withTies"));
5616 }
5617 with_ties__ = Some(map_.next_value()?);
5618 }
5619 }
5620 }
5621 Ok(GroupTopNNode {
5622 limit: limit__.unwrap_or_default(),
5623 offset: offset__.unwrap_or_default(),
5624 group_key: group_key__.unwrap_or_default(),
5625 table: table__,
5626 order_by: order_by__.unwrap_or_default(),
5627 with_ties: with_ties__.unwrap_or_default(),
5628 })
5629 }
5630 }
5631 deserializer.deserialize_struct("stream_plan.GroupTopNNode", FIELDS, GeneratedVisitor)
5632 }
5633}
5634impl serde::Serialize for HashAggNode {
5635 #[allow(deprecated)]
5636 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5637 where
5638 S: serde::Serializer,
5639 {
5640 use serde::ser::SerializeStruct;
5641 let mut len = 0;
5642 if !self.group_key.is_empty() {
5643 len += 1;
5644 }
5645 if !self.agg_calls.is_empty() {
5646 len += 1;
5647 }
5648 if !self.agg_call_states.is_empty() {
5649 len += 1;
5650 }
5651 if self.intermediate_state_table.is_some() {
5652 len += 1;
5653 }
5654 if self.is_append_only {
5655 len += 1;
5656 }
5657 if !self.distinct_dedup_tables.is_empty() {
5658 len += 1;
5659 }
5660 if self.row_count_index != 0 {
5661 len += 1;
5662 }
5663 if self.emit_on_window_close {
5664 len += 1;
5665 }
5666 if self.version != 0 {
5667 len += 1;
5668 }
5669 let mut struct_ser = serializer.serialize_struct("stream_plan.HashAggNode", len)?;
5670 if !self.group_key.is_empty() {
5671 struct_ser.serialize_field("groupKey", &self.group_key)?;
5672 }
5673 if !self.agg_calls.is_empty() {
5674 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
5675 }
5676 if !self.agg_call_states.is_empty() {
5677 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
5678 }
5679 if let Some(v) = self.intermediate_state_table.as_ref() {
5680 struct_ser.serialize_field("intermediateStateTable", v)?;
5681 }
5682 if self.is_append_only {
5683 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5684 }
5685 if !self.distinct_dedup_tables.is_empty() {
5686 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
5687 }
5688 if self.row_count_index != 0 {
5689 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
5690 }
5691 if self.emit_on_window_close {
5692 struct_ser.serialize_field("emitOnWindowClose", &self.emit_on_window_close)?;
5693 }
5694 if self.version != 0 {
5695 let v = AggNodeVersion::try_from(self.version)
5696 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
5697 struct_ser.serialize_field("version", &v)?;
5698 }
5699 struct_ser.end()
5700 }
5701}
5702impl<'de> serde::Deserialize<'de> for HashAggNode {
5703 #[allow(deprecated)]
5704 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5705 where
5706 D: serde::Deserializer<'de>,
5707 {
5708 const FIELDS: &[&str] = &[
5709 "group_key",
5710 "groupKey",
5711 "agg_calls",
5712 "aggCalls",
5713 "agg_call_states",
5714 "aggCallStates",
5715 "intermediate_state_table",
5716 "intermediateStateTable",
5717 "is_append_only",
5718 "isAppendOnly",
5719 "distinct_dedup_tables",
5720 "distinctDedupTables",
5721 "row_count_index",
5722 "rowCountIndex",
5723 "emit_on_window_close",
5724 "emitOnWindowClose",
5725 "version",
5726 ];
5727
5728 #[allow(clippy::enum_variant_names)]
5729 enum GeneratedField {
5730 GroupKey,
5731 AggCalls,
5732 AggCallStates,
5733 IntermediateStateTable,
5734 IsAppendOnly,
5735 DistinctDedupTables,
5736 RowCountIndex,
5737 EmitOnWindowClose,
5738 Version,
5739 }
5740 impl<'de> serde::Deserialize<'de> for GeneratedField {
5741 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5742 where
5743 D: serde::Deserializer<'de>,
5744 {
5745 struct GeneratedVisitor;
5746
5747 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5748 type Value = GeneratedField;
5749
5750 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5751 write!(formatter, "expected one of: {:?}", &FIELDS)
5752 }
5753
5754 #[allow(unused_variables)]
5755 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5756 where
5757 E: serde::de::Error,
5758 {
5759 match value {
5760 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5761 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
5762 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
5763 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
5764 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5765 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
5766 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
5767 "emitOnWindowClose" | "emit_on_window_close" => Ok(GeneratedField::EmitOnWindowClose),
5768 "version" => Ok(GeneratedField::Version),
5769 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5770 }
5771 }
5772 }
5773 deserializer.deserialize_identifier(GeneratedVisitor)
5774 }
5775 }
5776 struct GeneratedVisitor;
5777 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5778 type Value = HashAggNode;
5779
5780 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5781 formatter.write_str("struct stream_plan.HashAggNode")
5782 }
5783
5784 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashAggNode, V::Error>
5785 where
5786 V: serde::de::MapAccess<'de>,
5787 {
5788 let mut group_key__ = None;
5789 let mut agg_calls__ = None;
5790 let mut agg_call_states__ = None;
5791 let mut intermediate_state_table__ = None;
5792 let mut is_append_only__ = None;
5793 let mut distinct_dedup_tables__ = None;
5794 let mut row_count_index__ = None;
5795 let mut emit_on_window_close__ = None;
5796 let mut version__ = None;
5797 while let Some(k) = map_.next_key()? {
5798 match k {
5799 GeneratedField::GroupKey => {
5800 if group_key__.is_some() {
5801 return Err(serde::de::Error::duplicate_field("groupKey"));
5802 }
5803 group_key__ =
5804 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5805 .into_iter().map(|x| x.0).collect())
5806 ;
5807 }
5808 GeneratedField::AggCalls => {
5809 if agg_calls__.is_some() {
5810 return Err(serde::de::Error::duplicate_field("aggCalls"));
5811 }
5812 agg_calls__ = Some(map_.next_value()?);
5813 }
5814 GeneratedField::AggCallStates => {
5815 if agg_call_states__.is_some() {
5816 return Err(serde::de::Error::duplicate_field("aggCallStates"));
5817 }
5818 agg_call_states__ = Some(map_.next_value()?);
5819 }
5820 GeneratedField::IntermediateStateTable => {
5821 if intermediate_state_table__.is_some() {
5822 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
5823 }
5824 intermediate_state_table__ = map_.next_value()?;
5825 }
5826 GeneratedField::IsAppendOnly => {
5827 if is_append_only__.is_some() {
5828 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
5829 }
5830 is_append_only__ = Some(map_.next_value()?);
5831 }
5832 GeneratedField::DistinctDedupTables => {
5833 if distinct_dedup_tables__.is_some() {
5834 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
5835 }
5836 distinct_dedup_tables__ = Some(
5837 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5838 .into_iter().map(|(k,v)| (k.0, v)).collect()
5839 );
5840 }
5841 GeneratedField::RowCountIndex => {
5842 if row_count_index__.is_some() {
5843 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
5844 }
5845 row_count_index__ =
5846 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5847 ;
5848 }
5849 GeneratedField::EmitOnWindowClose => {
5850 if emit_on_window_close__.is_some() {
5851 return Err(serde::de::Error::duplicate_field("emitOnWindowClose"));
5852 }
5853 emit_on_window_close__ = Some(map_.next_value()?);
5854 }
5855 GeneratedField::Version => {
5856 if version__.is_some() {
5857 return Err(serde::de::Error::duplicate_field("version"));
5858 }
5859 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
5860 }
5861 }
5862 }
5863 Ok(HashAggNode {
5864 group_key: group_key__.unwrap_or_default(),
5865 agg_calls: agg_calls__.unwrap_or_default(),
5866 agg_call_states: agg_call_states__.unwrap_or_default(),
5867 intermediate_state_table: intermediate_state_table__,
5868 is_append_only: is_append_only__.unwrap_or_default(),
5869 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
5870 row_count_index: row_count_index__.unwrap_or_default(),
5871 emit_on_window_close: emit_on_window_close__.unwrap_or_default(),
5872 version: version__.unwrap_or_default(),
5873 })
5874 }
5875 }
5876 deserializer.deserialize_struct("stream_plan.HashAggNode", FIELDS, GeneratedVisitor)
5877 }
5878}
5879impl serde::Serialize for HashJoinNode {
5880 #[allow(deprecated)]
5881 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5882 where
5883 S: serde::Serializer,
5884 {
5885 use serde::ser::SerializeStruct;
5886 let mut len = 0;
5887 if self.join_type != 0 {
5888 len += 1;
5889 }
5890 if !self.left_key.is_empty() {
5891 len += 1;
5892 }
5893 if !self.right_key.is_empty() {
5894 len += 1;
5895 }
5896 if self.condition.is_some() {
5897 len += 1;
5898 }
5899 if !self.inequality_pairs.is_empty() {
5900 len += 1;
5901 }
5902 if self.left_table.is_some() {
5903 len += 1;
5904 }
5905 if self.right_table.is_some() {
5906 len += 1;
5907 }
5908 if self.left_degree_table.is_some() {
5909 len += 1;
5910 }
5911 if self.right_degree_table.is_some() {
5912 len += 1;
5913 }
5914 if !self.output_indices.is_empty() {
5915 len += 1;
5916 }
5917 if !self.left_deduped_input_pk_indices.is_empty() {
5918 len += 1;
5919 }
5920 if !self.right_deduped_input_pk_indices.is_empty() {
5921 len += 1;
5922 }
5923 if !self.null_safe.is_empty() {
5924 len += 1;
5925 }
5926 if self.is_append_only {
5927 len += 1;
5928 }
5929 if self.join_encoding_type != 0 {
5930 len += 1;
5931 }
5932 let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinNode", len)?;
5933 if self.join_type != 0 {
5934 let v = super::plan_common::JoinType::try_from(self.join_type)
5935 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
5936 struct_ser.serialize_field("joinType", &v)?;
5937 }
5938 if !self.left_key.is_empty() {
5939 struct_ser.serialize_field("leftKey", &self.left_key)?;
5940 }
5941 if !self.right_key.is_empty() {
5942 struct_ser.serialize_field("rightKey", &self.right_key)?;
5943 }
5944 if let Some(v) = self.condition.as_ref() {
5945 struct_ser.serialize_field("condition", v)?;
5946 }
5947 if !self.inequality_pairs.is_empty() {
5948 struct_ser.serialize_field("inequalityPairs", &self.inequality_pairs)?;
5949 }
5950 if let Some(v) = self.left_table.as_ref() {
5951 struct_ser.serialize_field("leftTable", v)?;
5952 }
5953 if let Some(v) = self.right_table.as_ref() {
5954 struct_ser.serialize_field("rightTable", v)?;
5955 }
5956 if let Some(v) = self.left_degree_table.as_ref() {
5957 struct_ser.serialize_field("leftDegreeTable", v)?;
5958 }
5959 if let Some(v) = self.right_degree_table.as_ref() {
5960 struct_ser.serialize_field("rightDegreeTable", v)?;
5961 }
5962 if !self.output_indices.is_empty() {
5963 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
5964 }
5965 if !self.left_deduped_input_pk_indices.is_empty() {
5966 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
5967 }
5968 if !self.right_deduped_input_pk_indices.is_empty() {
5969 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
5970 }
5971 if !self.null_safe.is_empty() {
5972 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
5973 }
5974 if self.is_append_only {
5975 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5976 }
5977 if self.join_encoding_type != 0 {
5978 let v = JoinEncodingType::try_from(self.join_encoding_type)
5979 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
5980 struct_ser.serialize_field("joinEncodingType", &v)?;
5981 }
5982 struct_ser.end()
5983 }
5984}
5985impl<'de> serde::Deserialize<'de> for HashJoinNode {
5986 #[allow(deprecated)]
5987 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5988 where
5989 D: serde::Deserializer<'de>,
5990 {
5991 const FIELDS: &[&str] = &[
5992 "join_type",
5993 "joinType",
5994 "left_key",
5995 "leftKey",
5996 "right_key",
5997 "rightKey",
5998 "condition",
5999 "inequality_pairs",
6000 "inequalityPairs",
6001 "left_table",
6002 "leftTable",
6003 "right_table",
6004 "rightTable",
6005 "left_degree_table",
6006 "leftDegreeTable",
6007 "right_degree_table",
6008 "rightDegreeTable",
6009 "output_indices",
6010 "outputIndices",
6011 "left_deduped_input_pk_indices",
6012 "leftDedupedInputPkIndices",
6013 "right_deduped_input_pk_indices",
6014 "rightDedupedInputPkIndices",
6015 "null_safe",
6016 "nullSafe",
6017 "is_append_only",
6018 "isAppendOnly",
6019 "join_encoding_type",
6020 "joinEncodingType",
6021 ];
6022
6023 #[allow(clippy::enum_variant_names)]
6024 enum GeneratedField {
6025 JoinType,
6026 LeftKey,
6027 RightKey,
6028 Condition,
6029 InequalityPairs,
6030 LeftTable,
6031 RightTable,
6032 LeftDegreeTable,
6033 RightDegreeTable,
6034 OutputIndices,
6035 LeftDedupedInputPkIndices,
6036 RightDedupedInputPkIndices,
6037 NullSafe,
6038 IsAppendOnly,
6039 JoinEncodingType,
6040 }
6041 impl<'de> serde::Deserialize<'de> for GeneratedField {
6042 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6043 where
6044 D: serde::Deserializer<'de>,
6045 {
6046 struct GeneratedVisitor;
6047
6048 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6049 type Value = GeneratedField;
6050
6051 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6052 write!(formatter, "expected one of: {:?}", &FIELDS)
6053 }
6054
6055 #[allow(unused_variables)]
6056 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6057 where
6058 E: serde::de::Error,
6059 {
6060 match value {
6061 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
6062 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
6063 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
6064 "condition" => Ok(GeneratedField::Condition),
6065 "inequalityPairs" | "inequality_pairs" => Ok(GeneratedField::InequalityPairs),
6066 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
6067 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
6068 "leftDegreeTable" | "left_degree_table" => Ok(GeneratedField::LeftDegreeTable),
6069 "rightDegreeTable" | "right_degree_table" => Ok(GeneratedField::RightDegreeTable),
6070 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
6071 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
6072 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
6073 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
6074 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
6075 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
6076 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6077 }
6078 }
6079 }
6080 deserializer.deserialize_identifier(GeneratedVisitor)
6081 }
6082 }
6083 struct GeneratedVisitor;
6084 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6085 type Value = HashJoinNode;
6086
6087 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6088 formatter.write_str("struct stream_plan.HashJoinNode")
6089 }
6090
6091 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinNode, V::Error>
6092 where
6093 V: serde::de::MapAccess<'de>,
6094 {
6095 let mut join_type__ = None;
6096 let mut left_key__ = None;
6097 let mut right_key__ = None;
6098 let mut condition__ = None;
6099 let mut inequality_pairs__ = None;
6100 let mut left_table__ = None;
6101 let mut right_table__ = None;
6102 let mut left_degree_table__ = None;
6103 let mut right_degree_table__ = None;
6104 let mut output_indices__ = None;
6105 let mut left_deduped_input_pk_indices__ = None;
6106 let mut right_deduped_input_pk_indices__ = None;
6107 let mut null_safe__ = None;
6108 let mut is_append_only__ = None;
6109 let mut join_encoding_type__ = None;
6110 while let Some(k) = map_.next_key()? {
6111 match k {
6112 GeneratedField::JoinType => {
6113 if join_type__.is_some() {
6114 return Err(serde::de::Error::duplicate_field("joinType"));
6115 }
6116 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
6117 }
6118 GeneratedField::LeftKey => {
6119 if left_key__.is_some() {
6120 return Err(serde::de::Error::duplicate_field("leftKey"));
6121 }
6122 left_key__ =
6123 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6124 .into_iter().map(|x| x.0).collect())
6125 ;
6126 }
6127 GeneratedField::RightKey => {
6128 if right_key__.is_some() {
6129 return Err(serde::de::Error::duplicate_field("rightKey"));
6130 }
6131 right_key__ =
6132 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6133 .into_iter().map(|x| x.0).collect())
6134 ;
6135 }
6136 GeneratedField::Condition => {
6137 if condition__.is_some() {
6138 return Err(serde::de::Error::duplicate_field("condition"));
6139 }
6140 condition__ = map_.next_value()?;
6141 }
6142 GeneratedField::InequalityPairs => {
6143 if inequality_pairs__.is_some() {
6144 return Err(serde::de::Error::duplicate_field("inequalityPairs"));
6145 }
6146 inequality_pairs__ = Some(map_.next_value()?);
6147 }
6148 GeneratedField::LeftTable => {
6149 if left_table__.is_some() {
6150 return Err(serde::de::Error::duplicate_field("leftTable"));
6151 }
6152 left_table__ = map_.next_value()?;
6153 }
6154 GeneratedField::RightTable => {
6155 if right_table__.is_some() {
6156 return Err(serde::de::Error::duplicate_field("rightTable"));
6157 }
6158 right_table__ = map_.next_value()?;
6159 }
6160 GeneratedField::LeftDegreeTable => {
6161 if left_degree_table__.is_some() {
6162 return Err(serde::de::Error::duplicate_field("leftDegreeTable"));
6163 }
6164 left_degree_table__ = map_.next_value()?;
6165 }
6166 GeneratedField::RightDegreeTable => {
6167 if right_degree_table__.is_some() {
6168 return Err(serde::de::Error::duplicate_field("rightDegreeTable"));
6169 }
6170 right_degree_table__ = map_.next_value()?;
6171 }
6172 GeneratedField::OutputIndices => {
6173 if output_indices__.is_some() {
6174 return Err(serde::de::Error::duplicate_field("outputIndices"));
6175 }
6176 output_indices__ =
6177 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6178 .into_iter().map(|x| x.0).collect())
6179 ;
6180 }
6181 GeneratedField::LeftDedupedInputPkIndices => {
6182 if left_deduped_input_pk_indices__.is_some() {
6183 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
6184 }
6185 left_deduped_input_pk_indices__ =
6186 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6187 .into_iter().map(|x| x.0).collect())
6188 ;
6189 }
6190 GeneratedField::RightDedupedInputPkIndices => {
6191 if right_deduped_input_pk_indices__.is_some() {
6192 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
6193 }
6194 right_deduped_input_pk_indices__ =
6195 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6196 .into_iter().map(|x| x.0).collect())
6197 ;
6198 }
6199 GeneratedField::NullSafe => {
6200 if null_safe__.is_some() {
6201 return Err(serde::de::Error::duplicate_field("nullSafe"));
6202 }
6203 null_safe__ = Some(map_.next_value()?);
6204 }
6205 GeneratedField::IsAppendOnly => {
6206 if is_append_only__.is_some() {
6207 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
6208 }
6209 is_append_only__ = Some(map_.next_value()?);
6210 }
6211 GeneratedField::JoinEncodingType => {
6212 if join_encoding_type__.is_some() {
6213 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
6214 }
6215 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
6216 }
6217 }
6218 }
6219 Ok(HashJoinNode {
6220 join_type: join_type__.unwrap_or_default(),
6221 left_key: left_key__.unwrap_or_default(),
6222 right_key: right_key__.unwrap_or_default(),
6223 condition: condition__,
6224 inequality_pairs: inequality_pairs__.unwrap_or_default(),
6225 left_table: left_table__,
6226 right_table: right_table__,
6227 left_degree_table: left_degree_table__,
6228 right_degree_table: right_degree_table__,
6229 output_indices: output_indices__.unwrap_or_default(),
6230 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
6231 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
6232 null_safe: null_safe__.unwrap_or_default(),
6233 is_append_only: is_append_only__.unwrap_or_default(),
6234 join_encoding_type: join_encoding_type__.unwrap_or_default(),
6235 })
6236 }
6237 }
6238 deserializer.deserialize_struct("stream_plan.HashJoinNode", FIELDS, GeneratedVisitor)
6239 }
6240}
6241impl serde::Serialize for HopWindowNode {
6242 #[allow(deprecated)]
6243 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6244 where
6245 S: serde::Serializer,
6246 {
6247 use serde::ser::SerializeStruct;
6248 let mut len = 0;
6249 if self.time_col != 0 {
6250 len += 1;
6251 }
6252 if self.window_slide.is_some() {
6253 len += 1;
6254 }
6255 if self.window_size.is_some() {
6256 len += 1;
6257 }
6258 if !self.output_indices.is_empty() {
6259 len += 1;
6260 }
6261 if !self.window_start_exprs.is_empty() {
6262 len += 1;
6263 }
6264 if !self.window_end_exprs.is_empty() {
6265 len += 1;
6266 }
6267 let mut struct_ser = serializer.serialize_struct("stream_plan.HopWindowNode", len)?;
6268 if self.time_col != 0 {
6269 struct_ser.serialize_field("timeCol", &self.time_col)?;
6270 }
6271 if let Some(v) = self.window_slide.as_ref() {
6272 struct_ser.serialize_field("windowSlide", v)?;
6273 }
6274 if let Some(v) = self.window_size.as_ref() {
6275 struct_ser.serialize_field("windowSize", v)?;
6276 }
6277 if !self.output_indices.is_empty() {
6278 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
6279 }
6280 if !self.window_start_exprs.is_empty() {
6281 struct_ser.serialize_field("windowStartExprs", &self.window_start_exprs)?;
6282 }
6283 if !self.window_end_exprs.is_empty() {
6284 struct_ser.serialize_field("windowEndExprs", &self.window_end_exprs)?;
6285 }
6286 struct_ser.end()
6287 }
6288}
6289impl<'de> serde::Deserialize<'de> for HopWindowNode {
6290 #[allow(deprecated)]
6291 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6292 where
6293 D: serde::Deserializer<'de>,
6294 {
6295 const FIELDS: &[&str] = &[
6296 "time_col",
6297 "timeCol",
6298 "window_slide",
6299 "windowSlide",
6300 "window_size",
6301 "windowSize",
6302 "output_indices",
6303 "outputIndices",
6304 "window_start_exprs",
6305 "windowStartExprs",
6306 "window_end_exprs",
6307 "windowEndExprs",
6308 ];
6309
6310 #[allow(clippy::enum_variant_names)]
6311 enum GeneratedField {
6312 TimeCol,
6313 WindowSlide,
6314 WindowSize,
6315 OutputIndices,
6316 WindowStartExprs,
6317 WindowEndExprs,
6318 }
6319 impl<'de> serde::Deserialize<'de> for GeneratedField {
6320 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6321 where
6322 D: serde::Deserializer<'de>,
6323 {
6324 struct GeneratedVisitor;
6325
6326 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6327 type Value = GeneratedField;
6328
6329 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6330 write!(formatter, "expected one of: {:?}", &FIELDS)
6331 }
6332
6333 #[allow(unused_variables)]
6334 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6335 where
6336 E: serde::de::Error,
6337 {
6338 match value {
6339 "timeCol" | "time_col" => Ok(GeneratedField::TimeCol),
6340 "windowSlide" | "window_slide" => Ok(GeneratedField::WindowSlide),
6341 "windowSize" | "window_size" => Ok(GeneratedField::WindowSize),
6342 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
6343 "windowStartExprs" | "window_start_exprs" => Ok(GeneratedField::WindowStartExprs),
6344 "windowEndExprs" | "window_end_exprs" => Ok(GeneratedField::WindowEndExprs),
6345 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6346 }
6347 }
6348 }
6349 deserializer.deserialize_identifier(GeneratedVisitor)
6350 }
6351 }
6352 struct GeneratedVisitor;
6353 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6354 type Value = HopWindowNode;
6355
6356 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6357 formatter.write_str("struct stream_plan.HopWindowNode")
6358 }
6359
6360 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HopWindowNode, V::Error>
6361 where
6362 V: serde::de::MapAccess<'de>,
6363 {
6364 let mut time_col__ = None;
6365 let mut window_slide__ = None;
6366 let mut window_size__ = None;
6367 let mut output_indices__ = None;
6368 let mut window_start_exprs__ = None;
6369 let mut window_end_exprs__ = None;
6370 while let Some(k) = map_.next_key()? {
6371 match k {
6372 GeneratedField::TimeCol => {
6373 if time_col__.is_some() {
6374 return Err(serde::de::Error::duplicate_field("timeCol"));
6375 }
6376 time_col__ =
6377 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6378 ;
6379 }
6380 GeneratedField::WindowSlide => {
6381 if window_slide__.is_some() {
6382 return Err(serde::de::Error::duplicate_field("windowSlide"));
6383 }
6384 window_slide__ = map_.next_value()?;
6385 }
6386 GeneratedField::WindowSize => {
6387 if window_size__.is_some() {
6388 return Err(serde::de::Error::duplicate_field("windowSize"));
6389 }
6390 window_size__ = map_.next_value()?;
6391 }
6392 GeneratedField::OutputIndices => {
6393 if output_indices__.is_some() {
6394 return Err(serde::de::Error::duplicate_field("outputIndices"));
6395 }
6396 output_indices__ =
6397 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6398 .into_iter().map(|x| x.0).collect())
6399 ;
6400 }
6401 GeneratedField::WindowStartExprs => {
6402 if window_start_exprs__.is_some() {
6403 return Err(serde::de::Error::duplicate_field("windowStartExprs"));
6404 }
6405 window_start_exprs__ = Some(map_.next_value()?);
6406 }
6407 GeneratedField::WindowEndExprs => {
6408 if window_end_exprs__.is_some() {
6409 return Err(serde::de::Error::duplicate_field("windowEndExprs"));
6410 }
6411 window_end_exprs__ = Some(map_.next_value()?);
6412 }
6413 }
6414 }
6415 Ok(HopWindowNode {
6416 time_col: time_col__.unwrap_or_default(),
6417 window_slide: window_slide__,
6418 window_size: window_size__,
6419 output_indices: output_indices__.unwrap_or_default(),
6420 window_start_exprs: window_start_exprs__.unwrap_or_default(),
6421 window_end_exprs: window_end_exprs__.unwrap_or_default(),
6422 })
6423 }
6424 }
6425 deserializer.deserialize_struct("stream_plan.HopWindowNode", FIELDS, GeneratedVisitor)
6426 }
6427}
6428impl serde::Serialize for InequalityPair {
6429 #[allow(deprecated)]
6430 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6431 where
6432 S: serde::Serializer,
6433 {
6434 use serde::ser::SerializeStruct;
6435 let mut len = 0;
6436 if self.key_required_larger != 0 {
6437 len += 1;
6438 }
6439 if self.key_required_smaller != 0 {
6440 len += 1;
6441 }
6442 if self.clean_state {
6443 len += 1;
6444 }
6445 if self.delta_expression.is_some() {
6446 len += 1;
6447 }
6448 let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPair", len)?;
6449 if self.key_required_larger != 0 {
6450 struct_ser.serialize_field("keyRequiredLarger", &self.key_required_larger)?;
6451 }
6452 if self.key_required_smaller != 0 {
6453 struct_ser.serialize_field("keyRequiredSmaller", &self.key_required_smaller)?;
6454 }
6455 if self.clean_state {
6456 struct_ser.serialize_field("cleanState", &self.clean_state)?;
6457 }
6458 if let Some(v) = self.delta_expression.as_ref() {
6459 struct_ser.serialize_field("deltaExpression", v)?;
6460 }
6461 struct_ser.end()
6462 }
6463}
6464impl<'de> serde::Deserialize<'de> for InequalityPair {
6465 #[allow(deprecated)]
6466 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6467 where
6468 D: serde::Deserializer<'de>,
6469 {
6470 const FIELDS: &[&str] = &[
6471 "key_required_larger",
6472 "keyRequiredLarger",
6473 "key_required_smaller",
6474 "keyRequiredSmaller",
6475 "clean_state",
6476 "cleanState",
6477 "delta_expression",
6478 "deltaExpression",
6479 ];
6480
6481 #[allow(clippy::enum_variant_names)]
6482 enum GeneratedField {
6483 KeyRequiredLarger,
6484 KeyRequiredSmaller,
6485 CleanState,
6486 DeltaExpression,
6487 }
6488 impl<'de> serde::Deserialize<'de> for GeneratedField {
6489 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6490 where
6491 D: serde::Deserializer<'de>,
6492 {
6493 struct GeneratedVisitor;
6494
6495 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6496 type Value = GeneratedField;
6497
6498 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6499 write!(formatter, "expected one of: {:?}", &FIELDS)
6500 }
6501
6502 #[allow(unused_variables)]
6503 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6504 where
6505 E: serde::de::Error,
6506 {
6507 match value {
6508 "keyRequiredLarger" | "key_required_larger" => Ok(GeneratedField::KeyRequiredLarger),
6509 "keyRequiredSmaller" | "key_required_smaller" => Ok(GeneratedField::KeyRequiredSmaller),
6510 "cleanState" | "clean_state" => Ok(GeneratedField::CleanState),
6511 "deltaExpression" | "delta_expression" => Ok(GeneratedField::DeltaExpression),
6512 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6513 }
6514 }
6515 }
6516 deserializer.deserialize_identifier(GeneratedVisitor)
6517 }
6518 }
6519 struct GeneratedVisitor;
6520 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6521 type Value = InequalityPair;
6522
6523 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6524 formatter.write_str("struct stream_plan.InequalityPair")
6525 }
6526
6527 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPair, V::Error>
6528 where
6529 V: serde::de::MapAccess<'de>,
6530 {
6531 let mut key_required_larger__ = None;
6532 let mut key_required_smaller__ = None;
6533 let mut clean_state__ = None;
6534 let mut delta_expression__ = None;
6535 while let Some(k) = map_.next_key()? {
6536 match k {
6537 GeneratedField::KeyRequiredLarger => {
6538 if key_required_larger__.is_some() {
6539 return Err(serde::de::Error::duplicate_field("keyRequiredLarger"));
6540 }
6541 key_required_larger__ =
6542 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6543 ;
6544 }
6545 GeneratedField::KeyRequiredSmaller => {
6546 if key_required_smaller__.is_some() {
6547 return Err(serde::de::Error::duplicate_field("keyRequiredSmaller"));
6548 }
6549 key_required_smaller__ =
6550 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6551 ;
6552 }
6553 GeneratedField::CleanState => {
6554 if clean_state__.is_some() {
6555 return Err(serde::de::Error::duplicate_field("cleanState"));
6556 }
6557 clean_state__ = Some(map_.next_value()?);
6558 }
6559 GeneratedField::DeltaExpression => {
6560 if delta_expression__.is_some() {
6561 return Err(serde::de::Error::duplicate_field("deltaExpression"));
6562 }
6563 delta_expression__ = map_.next_value()?;
6564 }
6565 }
6566 }
6567 Ok(InequalityPair {
6568 key_required_larger: key_required_larger__.unwrap_or_default(),
6569 key_required_smaller: key_required_smaller__.unwrap_or_default(),
6570 clean_state: clean_state__.unwrap_or_default(),
6571 delta_expression: delta_expression__,
6572 })
6573 }
6574 }
6575 deserializer.deserialize_struct("stream_plan.InequalityPair", FIELDS, GeneratedVisitor)
6576 }
6577}
6578impl serde::Serialize for JoinEncodingType {
6579 #[allow(deprecated)]
6580 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6581 where
6582 S: serde::Serializer,
6583 {
6584 let variant = match self {
6585 Self::Unspecified => "UNSPECIFIED",
6586 Self::MemoryOptimized => "MEMORY_OPTIMIZED",
6587 Self::CpuOptimized => "CPU_OPTIMIZED",
6588 };
6589 serializer.serialize_str(variant)
6590 }
6591}
6592impl<'de> serde::Deserialize<'de> for JoinEncodingType {
6593 #[allow(deprecated)]
6594 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6595 where
6596 D: serde::Deserializer<'de>,
6597 {
6598 const FIELDS: &[&str] = &[
6599 "UNSPECIFIED",
6600 "MEMORY_OPTIMIZED",
6601 "CPU_OPTIMIZED",
6602 ];
6603
6604 struct GeneratedVisitor;
6605
6606 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6607 type Value = JoinEncodingType;
6608
6609 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6610 write!(formatter, "expected one of: {:?}", &FIELDS)
6611 }
6612
6613 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6614 where
6615 E: serde::de::Error,
6616 {
6617 i32::try_from(v)
6618 .ok()
6619 .and_then(|x| x.try_into().ok())
6620 .ok_or_else(|| {
6621 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6622 })
6623 }
6624
6625 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6626 where
6627 E: serde::de::Error,
6628 {
6629 i32::try_from(v)
6630 .ok()
6631 .and_then(|x| x.try_into().ok())
6632 .ok_or_else(|| {
6633 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6634 })
6635 }
6636
6637 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6638 where
6639 E: serde::de::Error,
6640 {
6641 match value {
6642 "UNSPECIFIED" => Ok(JoinEncodingType::Unspecified),
6643 "MEMORY_OPTIMIZED" => Ok(JoinEncodingType::MemoryOptimized),
6644 "CPU_OPTIMIZED" => Ok(JoinEncodingType::CpuOptimized),
6645 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6646 }
6647 }
6648 }
6649 deserializer.deserialize_any(GeneratedVisitor)
6650 }
6651}
6652impl serde::Serialize for ListFinishMutation {
6653 #[allow(deprecated)]
6654 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6655 where
6656 S: serde::Serializer,
6657 {
6658 use serde::ser::SerializeStruct;
6659 let mut len = 0;
6660 if self.associated_source_id != 0 {
6661 len += 1;
6662 }
6663 let mut struct_ser = serializer.serialize_struct("stream_plan.ListFinishMutation", len)?;
6664 if self.associated_source_id != 0 {
6665 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
6666 }
6667 struct_ser.end()
6668 }
6669}
6670impl<'de> serde::Deserialize<'de> for ListFinishMutation {
6671 #[allow(deprecated)]
6672 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6673 where
6674 D: serde::Deserializer<'de>,
6675 {
6676 const FIELDS: &[&str] = &[
6677 "associated_source_id",
6678 "associatedSourceId",
6679 ];
6680
6681 #[allow(clippy::enum_variant_names)]
6682 enum GeneratedField {
6683 AssociatedSourceId,
6684 }
6685 impl<'de> serde::Deserialize<'de> for GeneratedField {
6686 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6687 where
6688 D: serde::Deserializer<'de>,
6689 {
6690 struct GeneratedVisitor;
6691
6692 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6693 type Value = GeneratedField;
6694
6695 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6696 write!(formatter, "expected one of: {:?}", &FIELDS)
6697 }
6698
6699 #[allow(unused_variables)]
6700 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6701 where
6702 E: serde::de::Error,
6703 {
6704 match value {
6705 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
6706 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6707 }
6708 }
6709 }
6710 deserializer.deserialize_identifier(GeneratedVisitor)
6711 }
6712 }
6713 struct GeneratedVisitor;
6714 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6715 type Value = ListFinishMutation;
6716
6717 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6718 formatter.write_str("struct stream_plan.ListFinishMutation")
6719 }
6720
6721 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFinishMutation, V::Error>
6722 where
6723 V: serde::de::MapAccess<'de>,
6724 {
6725 let mut associated_source_id__ = None;
6726 while let Some(k) = map_.next_key()? {
6727 match k {
6728 GeneratedField::AssociatedSourceId => {
6729 if associated_source_id__.is_some() {
6730 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
6731 }
6732 associated_source_id__ =
6733 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6734 ;
6735 }
6736 }
6737 }
6738 Ok(ListFinishMutation {
6739 associated_source_id: associated_source_id__.unwrap_or_default(),
6740 })
6741 }
6742 }
6743 deserializer.deserialize_struct("stream_plan.ListFinishMutation", FIELDS, GeneratedVisitor)
6744 }
6745}
6746impl serde::Serialize for LoadFinishMutation {
6747 #[allow(deprecated)]
6748 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6749 where
6750 S: serde::Serializer,
6751 {
6752 use serde::ser::SerializeStruct;
6753 let mut len = 0;
6754 if self.associated_source_id != 0 {
6755 len += 1;
6756 }
6757 let mut struct_ser = serializer.serialize_struct("stream_plan.LoadFinishMutation", len)?;
6758 if self.associated_source_id != 0 {
6759 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
6760 }
6761 struct_ser.end()
6762 }
6763}
6764impl<'de> serde::Deserialize<'de> for LoadFinishMutation {
6765 #[allow(deprecated)]
6766 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6767 where
6768 D: serde::Deserializer<'de>,
6769 {
6770 const FIELDS: &[&str] = &[
6771 "associated_source_id",
6772 "associatedSourceId",
6773 ];
6774
6775 #[allow(clippy::enum_variant_names)]
6776 enum GeneratedField {
6777 AssociatedSourceId,
6778 }
6779 impl<'de> serde::Deserialize<'de> for GeneratedField {
6780 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6781 where
6782 D: serde::Deserializer<'de>,
6783 {
6784 struct GeneratedVisitor;
6785
6786 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6787 type Value = GeneratedField;
6788
6789 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6790 write!(formatter, "expected one of: {:?}", &FIELDS)
6791 }
6792
6793 #[allow(unused_variables)]
6794 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6795 where
6796 E: serde::de::Error,
6797 {
6798 match value {
6799 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
6800 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6801 }
6802 }
6803 }
6804 deserializer.deserialize_identifier(GeneratedVisitor)
6805 }
6806 }
6807 struct GeneratedVisitor;
6808 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6809 type Value = LoadFinishMutation;
6810
6811 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6812 formatter.write_str("struct stream_plan.LoadFinishMutation")
6813 }
6814
6815 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LoadFinishMutation, V::Error>
6816 where
6817 V: serde::de::MapAccess<'de>,
6818 {
6819 let mut associated_source_id__ = None;
6820 while let Some(k) = map_.next_key()? {
6821 match k {
6822 GeneratedField::AssociatedSourceId => {
6823 if associated_source_id__.is_some() {
6824 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
6825 }
6826 associated_source_id__ =
6827 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6828 ;
6829 }
6830 }
6831 }
6832 Ok(LoadFinishMutation {
6833 associated_source_id: associated_source_id__.unwrap_or_default(),
6834 })
6835 }
6836 }
6837 deserializer.deserialize_struct("stream_plan.LoadFinishMutation", FIELDS, GeneratedVisitor)
6838 }
6839}
6840impl serde::Serialize for LocalApproxPercentileNode {
6841 #[allow(deprecated)]
6842 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6843 where
6844 S: serde::Serializer,
6845 {
6846 use serde::ser::SerializeStruct;
6847 let mut len = 0;
6848 if self.base != 0. {
6849 len += 1;
6850 }
6851 if self.percentile_index != 0 {
6852 len += 1;
6853 }
6854 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalApproxPercentileNode", len)?;
6855 if self.base != 0. {
6856 struct_ser.serialize_field("base", &self.base)?;
6857 }
6858 if self.percentile_index != 0 {
6859 struct_ser.serialize_field("percentileIndex", &self.percentile_index)?;
6860 }
6861 struct_ser.end()
6862 }
6863}
6864impl<'de> serde::Deserialize<'de> for LocalApproxPercentileNode {
6865 #[allow(deprecated)]
6866 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6867 where
6868 D: serde::Deserializer<'de>,
6869 {
6870 const FIELDS: &[&str] = &[
6871 "base",
6872 "percentile_index",
6873 "percentileIndex",
6874 ];
6875
6876 #[allow(clippy::enum_variant_names)]
6877 enum GeneratedField {
6878 Base,
6879 PercentileIndex,
6880 }
6881 impl<'de> serde::Deserialize<'de> for GeneratedField {
6882 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6883 where
6884 D: serde::Deserializer<'de>,
6885 {
6886 struct GeneratedVisitor;
6887
6888 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6889 type Value = GeneratedField;
6890
6891 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6892 write!(formatter, "expected one of: {:?}", &FIELDS)
6893 }
6894
6895 #[allow(unused_variables)]
6896 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6897 where
6898 E: serde::de::Error,
6899 {
6900 match value {
6901 "base" => Ok(GeneratedField::Base),
6902 "percentileIndex" | "percentile_index" => Ok(GeneratedField::PercentileIndex),
6903 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6904 }
6905 }
6906 }
6907 deserializer.deserialize_identifier(GeneratedVisitor)
6908 }
6909 }
6910 struct GeneratedVisitor;
6911 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6912 type Value = LocalApproxPercentileNode;
6913
6914 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6915 formatter.write_str("struct stream_plan.LocalApproxPercentileNode")
6916 }
6917
6918 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalApproxPercentileNode, V::Error>
6919 where
6920 V: serde::de::MapAccess<'de>,
6921 {
6922 let mut base__ = None;
6923 let mut percentile_index__ = None;
6924 while let Some(k) = map_.next_key()? {
6925 match k {
6926 GeneratedField::Base => {
6927 if base__.is_some() {
6928 return Err(serde::de::Error::duplicate_field("base"));
6929 }
6930 base__ =
6931 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6932 ;
6933 }
6934 GeneratedField::PercentileIndex => {
6935 if percentile_index__.is_some() {
6936 return Err(serde::de::Error::duplicate_field("percentileIndex"));
6937 }
6938 percentile_index__ =
6939 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6940 ;
6941 }
6942 }
6943 }
6944 Ok(LocalApproxPercentileNode {
6945 base: base__.unwrap_or_default(),
6946 percentile_index: percentile_index__.unwrap_or_default(),
6947 })
6948 }
6949 }
6950 deserializer.deserialize_struct("stream_plan.LocalApproxPercentileNode", FIELDS, GeneratedVisitor)
6951 }
6952}
6953impl serde::Serialize for LocalityProviderNode {
6954 #[allow(deprecated)]
6955 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6956 where
6957 S: serde::Serializer,
6958 {
6959 use serde::ser::SerializeStruct;
6960 let mut len = 0;
6961 if !self.locality_columns.is_empty() {
6962 len += 1;
6963 }
6964 if self.state_table.is_some() {
6965 len += 1;
6966 }
6967 if self.progress_table.is_some() {
6968 len += 1;
6969 }
6970 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalityProviderNode", len)?;
6971 if !self.locality_columns.is_empty() {
6972 struct_ser.serialize_field("localityColumns", &self.locality_columns)?;
6973 }
6974 if let Some(v) = self.state_table.as_ref() {
6975 struct_ser.serialize_field("stateTable", v)?;
6976 }
6977 if let Some(v) = self.progress_table.as_ref() {
6978 struct_ser.serialize_field("progressTable", v)?;
6979 }
6980 struct_ser.end()
6981 }
6982}
6983impl<'de> serde::Deserialize<'de> for LocalityProviderNode {
6984 #[allow(deprecated)]
6985 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6986 where
6987 D: serde::Deserializer<'de>,
6988 {
6989 const FIELDS: &[&str] = &[
6990 "locality_columns",
6991 "localityColumns",
6992 "state_table",
6993 "stateTable",
6994 "progress_table",
6995 "progressTable",
6996 ];
6997
6998 #[allow(clippy::enum_variant_names)]
6999 enum GeneratedField {
7000 LocalityColumns,
7001 StateTable,
7002 ProgressTable,
7003 }
7004 impl<'de> serde::Deserialize<'de> for GeneratedField {
7005 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7006 where
7007 D: serde::Deserializer<'de>,
7008 {
7009 struct GeneratedVisitor;
7010
7011 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7012 type Value = GeneratedField;
7013
7014 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7015 write!(formatter, "expected one of: {:?}", &FIELDS)
7016 }
7017
7018 #[allow(unused_variables)]
7019 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7020 where
7021 E: serde::de::Error,
7022 {
7023 match value {
7024 "localityColumns" | "locality_columns" => Ok(GeneratedField::LocalityColumns),
7025 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7026 "progressTable" | "progress_table" => Ok(GeneratedField::ProgressTable),
7027 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7028 }
7029 }
7030 }
7031 deserializer.deserialize_identifier(GeneratedVisitor)
7032 }
7033 }
7034 struct GeneratedVisitor;
7035 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7036 type Value = LocalityProviderNode;
7037
7038 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7039 formatter.write_str("struct stream_plan.LocalityProviderNode")
7040 }
7041
7042 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalityProviderNode, V::Error>
7043 where
7044 V: serde::de::MapAccess<'de>,
7045 {
7046 let mut locality_columns__ = None;
7047 let mut state_table__ = None;
7048 let mut progress_table__ = None;
7049 while let Some(k) = map_.next_key()? {
7050 match k {
7051 GeneratedField::LocalityColumns => {
7052 if locality_columns__.is_some() {
7053 return Err(serde::de::Error::duplicate_field("localityColumns"));
7054 }
7055 locality_columns__ =
7056 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7057 .into_iter().map(|x| x.0).collect())
7058 ;
7059 }
7060 GeneratedField::StateTable => {
7061 if state_table__.is_some() {
7062 return Err(serde::de::Error::duplicate_field("stateTable"));
7063 }
7064 state_table__ = map_.next_value()?;
7065 }
7066 GeneratedField::ProgressTable => {
7067 if progress_table__.is_some() {
7068 return Err(serde::de::Error::duplicate_field("progressTable"));
7069 }
7070 progress_table__ = map_.next_value()?;
7071 }
7072 }
7073 }
7074 Ok(LocalityProviderNode {
7075 locality_columns: locality_columns__.unwrap_or_default(),
7076 state_table: state_table__,
7077 progress_table: progress_table__,
7078 })
7079 }
7080 }
7081 deserializer.deserialize_struct("stream_plan.LocalityProviderNode", FIELDS, GeneratedVisitor)
7082 }
7083}
7084impl serde::Serialize for LookupNode {
7085 #[allow(deprecated)]
7086 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7087 where
7088 S: serde::Serializer,
7089 {
7090 use serde::ser::SerializeStruct;
7091 let mut len = 0;
7092 if !self.arrange_key.is_empty() {
7093 len += 1;
7094 }
7095 if !self.stream_key.is_empty() {
7096 len += 1;
7097 }
7098 if self.use_current_epoch {
7099 len += 1;
7100 }
7101 if !self.column_mapping.is_empty() {
7102 len += 1;
7103 }
7104 if self.arrangement_table_info.is_some() {
7105 len += 1;
7106 }
7107 if self.arrangement_table_id.is_some() {
7108 len += 1;
7109 }
7110 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupNode", len)?;
7111 if !self.arrange_key.is_empty() {
7112 struct_ser.serialize_field("arrangeKey", &self.arrange_key)?;
7113 }
7114 if !self.stream_key.is_empty() {
7115 struct_ser.serialize_field("streamKey", &self.stream_key)?;
7116 }
7117 if self.use_current_epoch {
7118 struct_ser.serialize_field("useCurrentEpoch", &self.use_current_epoch)?;
7119 }
7120 if !self.column_mapping.is_empty() {
7121 struct_ser.serialize_field("columnMapping", &self.column_mapping)?;
7122 }
7123 if let Some(v) = self.arrangement_table_info.as_ref() {
7124 struct_ser.serialize_field("arrangementTableInfo", v)?;
7125 }
7126 if let Some(v) = self.arrangement_table_id.as_ref() {
7127 match v {
7128 lookup_node::ArrangementTableId::TableId(v) => {
7129 struct_ser.serialize_field("tableId", v)?;
7130 }
7131 lookup_node::ArrangementTableId::IndexId(v) => {
7132 struct_ser.serialize_field("indexId", v)?;
7133 }
7134 }
7135 }
7136 struct_ser.end()
7137 }
7138}
7139impl<'de> serde::Deserialize<'de> for LookupNode {
7140 #[allow(deprecated)]
7141 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7142 where
7143 D: serde::Deserializer<'de>,
7144 {
7145 const FIELDS: &[&str] = &[
7146 "arrange_key",
7147 "arrangeKey",
7148 "stream_key",
7149 "streamKey",
7150 "use_current_epoch",
7151 "useCurrentEpoch",
7152 "column_mapping",
7153 "columnMapping",
7154 "arrangement_table_info",
7155 "arrangementTableInfo",
7156 "table_id",
7157 "tableId",
7158 "index_id",
7159 "indexId",
7160 ];
7161
7162 #[allow(clippy::enum_variant_names)]
7163 enum GeneratedField {
7164 ArrangeKey,
7165 StreamKey,
7166 UseCurrentEpoch,
7167 ColumnMapping,
7168 ArrangementTableInfo,
7169 TableId,
7170 IndexId,
7171 }
7172 impl<'de> serde::Deserialize<'de> for GeneratedField {
7173 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7174 where
7175 D: serde::Deserializer<'de>,
7176 {
7177 struct GeneratedVisitor;
7178
7179 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7180 type Value = GeneratedField;
7181
7182 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7183 write!(formatter, "expected one of: {:?}", &FIELDS)
7184 }
7185
7186 #[allow(unused_variables)]
7187 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7188 where
7189 E: serde::de::Error,
7190 {
7191 match value {
7192 "arrangeKey" | "arrange_key" => Ok(GeneratedField::ArrangeKey),
7193 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
7194 "useCurrentEpoch" | "use_current_epoch" => Ok(GeneratedField::UseCurrentEpoch),
7195 "columnMapping" | "column_mapping" => Ok(GeneratedField::ColumnMapping),
7196 "arrangementTableInfo" | "arrangement_table_info" => Ok(GeneratedField::ArrangementTableInfo),
7197 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7198 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
7199 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7200 }
7201 }
7202 }
7203 deserializer.deserialize_identifier(GeneratedVisitor)
7204 }
7205 }
7206 struct GeneratedVisitor;
7207 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7208 type Value = LookupNode;
7209
7210 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7211 formatter.write_str("struct stream_plan.LookupNode")
7212 }
7213
7214 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupNode, V::Error>
7215 where
7216 V: serde::de::MapAccess<'de>,
7217 {
7218 let mut arrange_key__ = None;
7219 let mut stream_key__ = None;
7220 let mut use_current_epoch__ = None;
7221 let mut column_mapping__ = None;
7222 let mut arrangement_table_info__ = None;
7223 let mut arrangement_table_id__ = None;
7224 while let Some(k) = map_.next_key()? {
7225 match k {
7226 GeneratedField::ArrangeKey => {
7227 if arrange_key__.is_some() {
7228 return Err(serde::de::Error::duplicate_field("arrangeKey"));
7229 }
7230 arrange_key__ =
7231 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7232 .into_iter().map(|x| x.0).collect())
7233 ;
7234 }
7235 GeneratedField::StreamKey => {
7236 if stream_key__.is_some() {
7237 return Err(serde::de::Error::duplicate_field("streamKey"));
7238 }
7239 stream_key__ =
7240 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7241 .into_iter().map(|x| x.0).collect())
7242 ;
7243 }
7244 GeneratedField::UseCurrentEpoch => {
7245 if use_current_epoch__.is_some() {
7246 return Err(serde::de::Error::duplicate_field("useCurrentEpoch"));
7247 }
7248 use_current_epoch__ = Some(map_.next_value()?);
7249 }
7250 GeneratedField::ColumnMapping => {
7251 if column_mapping__.is_some() {
7252 return Err(serde::de::Error::duplicate_field("columnMapping"));
7253 }
7254 column_mapping__ =
7255 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7256 .into_iter().map(|x| x.0).collect())
7257 ;
7258 }
7259 GeneratedField::ArrangementTableInfo => {
7260 if arrangement_table_info__.is_some() {
7261 return Err(serde::de::Error::duplicate_field("arrangementTableInfo"));
7262 }
7263 arrangement_table_info__ = map_.next_value()?;
7264 }
7265 GeneratedField::TableId => {
7266 if arrangement_table_id__.is_some() {
7267 return Err(serde::de::Error::duplicate_field("tableId"));
7268 }
7269 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::TableId(x.0));
7270 }
7271 GeneratedField::IndexId => {
7272 if arrangement_table_id__.is_some() {
7273 return Err(serde::de::Error::duplicate_field("indexId"));
7274 }
7275 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::IndexId(x.0));
7276 }
7277 }
7278 }
7279 Ok(LookupNode {
7280 arrange_key: arrange_key__.unwrap_or_default(),
7281 stream_key: stream_key__.unwrap_or_default(),
7282 use_current_epoch: use_current_epoch__.unwrap_or_default(),
7283 column_mapping: column_mapping__.unwrap_or_default(),
7284 arrangement_table_info: arrangement_table_info__,
7285 arrangement_table_id: arrangement_table_id__,
7286 })
7287 }
7288 }
7289 deserializer.deserialize_struct("stream_plan.LookupNode", FIELDS, GeneratedVisitor)
7290 }
7291}
7292impl serde::Serialize for LookupUnionNode {
7293 #[allow(deprecated)]
7294 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7295 where
7296 S: serde::Serializer,
7297 {
7298 use serde::ser::SerializeStruct;
7299 let mut len = 0;
7300 if !self.order.is_empty() {
7301 len += 1;
7302 }
7303 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupUnionNode", len)?;
7304 if !self.order.is_empty() {
7305 struct_ser.serialize_field("order", &self.order)?;
7306 }
7307 struct_ser.end()
7308 }
7309}
7310impl<'de> serde::Deserialize<'de> for LookupUnionNode {
7311 #[allow(deprecated)]
7312 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7313 where
7314 D: serde::Deserializer<'de>,
7315 {
7316 const FIELDS: &[&str] = &[
7317 "order",
7318 ];
7319
7320 #[allow(clippy::enum_variant_names)]
7321 enum GeneratedField {
7322 Order,
7323 }
7324 impl<'de> serde::Deserialize<'de> for GeneratedField {
7325 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7326 where
7327 D: serde::Deserializer<'de>,
7328 {
7329 struct GeneratedVisitor;
7330
7331 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7332 type Value = GeneratedField;
7333
7334 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7335 write!(formatter, "expected one of: {:?}", &FIELDS)
7336 }
7337
7338 #[allow(unused_variables)]
7339 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7340 where
7341 E: serde::de::Error,
7342 {
7343 match value {
7344 "order" => Ok(GeneratedField::Order),
7345 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7346 }
7347 }
7348 }
7349 deserializer.deserialize_identifier(GeneratedVisitor)
7350 }
7351 }
7352 struct GeneratedVisitor;
7353 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7354 type Value = LookupUnionNode;
7355
7356 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7357 formatter.write_str("struct stream_plan.LookupUnionNode")
7358 }
7359
7360 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupUnionNode, V::Error>
7361 where
7362 V: serde::de::MapAccess<'de>,
7363 {
7364 let mut order__ = None;
7365 while let Some(k) = map_.next_key()? {
7366 match k {
7367 GeneratedField::Order => {
7368 if order__.is_some() {
7369 return Err(serde::de::Error::duplicate_field("order"));
7370 }
7371 order__ =
7372 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7373 .into_iter().map(|x| x.0).collect())
7374 ;
7375 }
7376 }
7377 }
7378 Ok(LookupUnionNode {
7379 order: order__.unwrap_or_default(),
7380 })
7381 }
7382 }
7383 deserializer.deserialize_struct("stream_plan.LookupUnionNode", FIELDS, GeneratedVisitor)
7384 }
7385}
7386impl serde::Serialize for MaterializeNode {
7387 #[allow(deprecated)]
7388 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7389 where
7390 S: serde::Serializer,
7391 {
7392 use serde::ser::SerializeStruct;
7393 let mut len = 0;
7394 if self.table_id != 0 {
7395 len += 1;
7396 }
7397 if !self.column_orders.is_empty() {
7398 len += 1;
7399 }
7400 if self.table.is_some() {
7401 len += 1;
7402 }
7403 if self.staging_table.is_some() {
7404 len += 1;
7405 }
7406 if self.refresh_progress_table.is_some() {
7407 len += 1;
7408 }
7409 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializeNode", len)?;
7410 if self.table_id != 0 {
7411 struct_ser.serialize_field("tableId", &self.table_id)?;
7412 }
7413 if !self.column_orders.is_empty() {
7414 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
7415 }
7416 if let Some(v) = self.table.as_ref() {
7417 struct_ser.serialize_field("table", v)?;
7418 }
7419 if let Some(v) = self.staging_table.as_ref() {
7420 struct_ser.serialize_field("stagingTable", v)?;
7421 }
7422 if let Some(v) = self.refresh_progress_table.as_ref() {
7423 struct_ser.serialize_field("refreshProgressTable", v)?;
7424 }
7425 struct_ser.end()
7426 }
7427}
7428impl<'de> serde::Deserialize<'de> for MaterializeNode {
7429 #[allow(deprecated)]
7430 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7431 where
7432 D: serde::Deserializer<'de>,
7433 {
7434 const FIELDS: &[&str] = &[
7435 "table_id",
7436 "tableId",
7437 "column_orders",
7438 "columnOrders",
7439 "table",
7440 "staging_table",
7441 "stagingTable",
7442 "refresh_progress_table",
7443 "refreshProgressTable",
7444 ];
7445
7446 #[allow(clippy::enum_variant_names)]
7447 enum GeneratedField {
7448 TableId,
7449 ColumnOrders,
7450 Table,
7451 StagingTable,
7452 RefreshProgressTable,
7453 }
7454 impl<'de> serde::Deserialize<'de> for GeneratedField {
7455 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7456 where
7457 D: serde::Deserializer<'de>,
7458 {
7459 struct GeneratedVisitor;
7460
7461 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7462 type Value = GeneratedField;
7463
7464 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7465 write!(formatter, "expected one of: {:?}", &FIELDS)
7466 }
7467
7468 #[allow(unused_variables)]
7469 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7470 where
7471 E: serde::de::Error,
7472 {
7473 match value {
7474 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7475 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
7476 "table" => Ok(GeneratedField::Table),
7477 "stagingTable" | "staging_table" => Ok(GeneratedField::StagingTable),
7478 "refreshProgressTable" | "refresh_progress_table" => Ok(GeneratedField::RefreshProgressTable),
7479 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7480 }
7481 }
7482 }
7483 deserializer.deserialize_identifier(GeneratedVisitor)
7484 }
7485 }
7486 struct GeneratedVisitor;
7487 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7488 type Value = MaterializeNode;
7489
7490 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7491 formatter.write_str("struct stream_plan.MaterializeNode")
7492 }
7493
7494 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializeNode, V::Error>
7495 where
7496 V: serde::de::MapAccess<'de>,
7497 {
7498 let mut table_id__ = None;
7499 let mut column_orders__ = None;
7500 let mut table__ = None;
7501 let mut staging_table__ = None;
7502 let mut refresh_progress_table__ = None;
7503 while let Some(k) = map_.next_key()? {
7504 match k {
7505 GeneratedField::TableId => {
7506 if table_id__.is_some() {
7507 return Err(serde::de::Error::duplicate_field("tableId"));
7508 }
7509 table_id__ =
7510 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7511 ;
7512 }
7513 GeneratedField::ColumnOrders => {
7514 if column_orders__.is_some() {
7515 return Err(serde::de::Error::duplicate_field("columnOrders"));
7516 }
7517 column_orders__ = Some(map_.next_value()?);
7518 }
7519 GeneratedField::Table => {
7520 if table__.is_some() {
7521 return Err(serde::de::Error::duplicate_field("table"));
7522 }
7523 table__ = map_.next_value()?;
7524 }
7525 GeneratedField::StagingTable => {
7526 if staging_table__.is_some() {
7527 return Err(serde::de::Error::duplicate_field("stagingTable"));
7528 }
7529 staging_table__ = map_.next_value()?;
7530 }
7531 GeneratedField::RefreshProgressTable => {
7532 if refresh_progress_table__.is_some() {
7533 return Err(serde::de::Error::duplicate_field("refreshProgressTable"));
7534 }
7535 refresh_progress_table__ = map_.next_value()?;
7536 }
7537 }
7538 }
7539 Ok(MaterializeNode {
7540 table_id: table_id__.unwrap_or_default(),
7541 column_orders: column_orders__.unwrap_or_default(),
7542 table: table__,
7543 staging_table: staging_table__,
7544 refresh_progress_table: refresh_progress_table__,
7545 })
7546 }
7547 }
7548 deserializer.deserialize_struct("stream_plan.MaterializeNode", FIELDS, GeneratedVisitor)
7549 }
7550}
7551impl serde::Serialize for MaterializedExprsNode {
7552 #[allow(deprecated)]
7553 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7554 where
7555 S: serde::Serializer,
7556 {
7557 use serde::ser::SerializeStruct;
7558 let mut len = 0;
7559 if !self.exprs.is_empty() {
7560 len += 1;
7561 }
7562 if self.state_table.is_some() {
7563 len += 1;
7564 }
7565 if self.state_clean_col_idx.is_some() {
7566 len += 1;
7567 }
7568 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializedExprsNode", len)?;
7569 if !self.exprs.is_empty() {
7570 struct_ser.serialize_field("exprs", &self.exprs)?;
7571 }
7572 if let Some(v) = self.state_table.as_ref() {
7573 struct_ser.serialize_field("stateTable", v)?;
7574 }
7575 if let Some(v) = self.state_clean_col_idx.as_ref() {
7576 struct_ser.serialize_field("stateCleanColIdx", v)?;
7577 }
7578 struct_ser.end()
7579 }
7580}
7581impl<'de> serde::Deserialize<'de> for MaterializedExprsNode {
7582 #[allow(deprecated)]
7583 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7584 where
7585 D: serde::Deserializer<'de>,
7586 {
7587 const FIELDS: &[&str] = &[
7588 "exprs",
7589 "state_table",
7590 "stateTable",
7591 "state_clean_col_idx",
7592 "stateCleanColIdx",
7593 ];
7594
7595 #[allow(clippy::enum_variant_names)]
7596 enum GeneratedField {
7597 Exprs,
7598 StateTable,
7599 StateCleanColIdx,
7600 }
7601 impl<'de> serde::Deserialize<'de> for GeneratedField {
7602 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7603 where
7604 D: serde::Deserializer<'de>,
7605 {
7606 struct GeneratedVisitor;
7607
7608 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7609 type Value = GeneratedField;
7610
7611 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7612 write!(formatter, "expected one of: {:?}", &FIELDS)
7613 }
7614
7615 #[allow(unused_variables)]
7616 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7617 where
7618 E: serde::de::Error,
7619 {
7620 match value {
7621 "exprs" => Ok(GeneratedField::Exprs),
7622 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7623 "stateCleanColIdx" | "state_clean_col_idx" => Ok(GeneratedField::StateCleanColIdx),
7624 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7625 }
7626 }
7627 }
7628 deserializer.deserialize_identifier(GeneratedVisitor)
7629 }
7630 }
7631 struct GeneratedVisitor;
7632 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7633 type Value = MaterializedExprsNode;
7634
7635 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7636 formatter.write_str("struct stream_plan.MaterializedExprsNode")
7637 }
7638
7639 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializedExprsNode, V::Error>
7640 where
7641 V: serde::de::MapAccess<'de>,
7642 {
7643 let mut exprs__ = None;
7644 let mut state_table__ = None;
7645 let mut state_clean_col_idx__ = None;
7646 while let Some(k) = map_.next_key()? {
7647 match k {
7648 GeneratedField::Exprs => {
7649 if exprs__.is_some() {
7650 return Err(serde::de::Error::duplicate_field("exprs"));
7651 }
7652 exprs__ = Some(map_.next_value()?);
7653 }
7654 GeneratedField::StateTable => {
7655 if state_table__.is_some() {
7656 return Err(serde::de::Error::duplicate_field("stateTable"));
7657 }
7658 state_table__ = map_.next_value()?;
7659 }
7660 GeneratedField::StateCleanColIdx => {
7661 if state_clean_col_idx__.is_some() {
7662 return Err(serde::de::Error::duplicate_field("stateCleanColIdx"));
7663 }
7664 state_clean_col_idx__ =
7665 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
7666 ;
7667 }
7668 }
7669 }
7670 Ok(MaterializedExprsNode {
7671 exprs: exprs__.unwrap_or_default(),
7672 state_table: state_table__,
7673 state_clean_col_idx: state_clean_col_idx__,
7674 })
7675 }
7676 }
7677 deserializer.deserialize_struct("stream_plan.MaterializedExprsNode", FIELDS, GeneratedVisitor)
7678 }
7679}
7680impl serde::Serialize for MergeNode {
7681 #[allow(deprecated)]
7682 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7683 where
7684 S: serde::Serializer,
7685 {
7686 use serde::ser::SerializeStruct;
7687 let mut len = 0;
7688 if !self.upstream_actor_id.is_empty() {
7689 len += 1;
7690 }
7691 if self.upstream_fragment_id != 0 {
7692 len += 1;
7693 }
7694 if self.upstream_dispatcher_type != 0 {
7695 len += 1;
7696 }
7697 if !self.fields.is_empty() {
7698 len += 1;
7699 }
7700 let mut struct_ser = serializer.serialize_struct("stream_plan.MergeNode", len)?;
7701 if !self.upstream_actor_id.is_empty() {
7702 struct_ser.serialize_field("upstreamActorId", &self.upstream_actor_id)?;
7703 }
7704 if self.upstream_fragment_id != 0 {
7705 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
7706 }
7707 if self.upstream_dispatcher_type != 0 {
7708 let v = DispatcherType::try_from(self.upstream_dispatcher_type)
7709 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.upstream_dispatcher_type)))?;
7710 struct_ser.serialize_field("upstreamDispatcherType", &v)?;
7711 }
7712 if !self.fields.is_empty() {
7713 struct_ser.serialize_field("fields", &self.fields)?;
7714 }
7715 struct_ser.end()
7716 }
7717}
7718impl<'de> serde::Deserialize<'de> for MergeNode {
7719 #[allow(deprecated)]
7720 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7721 where
7722 D: serde::Deserializer<'de>,
7723 {
7724 const FIELDS: &[&str] = &[
7725 "upstream_actor_id",
7726 "upstreamActorId",
7727 "upstream_fragment_id",
7728 "upstreamFragmentId",
7729 "upstream_dispatcher_type",
7730 "upstreamDispatcherType",
7731 "fields",
7732 ];
7733
7734 #[allow(clippy::enum_variant_names)]
7735 enum GeneratedField {
7736 UpstreamActorId,
7737 UpstreamFragmentId,
7738 UpstreamDispatcherType,
7739 Fields,
7740 }
7741 impl<'de> serde::Deserialize<'de> for GeneratedField {
7742 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7743 where
7744 D: serde::Deserializer<'de>,
7745 {
7746 struct GeneratedVisitor;
7747
7748 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7749 type Value = GeneratedField;
7750
7751 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7752 write!(formatter, "expected one of: {:?}", &FIELDS)
7753 }
7754
7755 #[allow(unused_variables)]
7756 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7757 where
7758 E: serde::de::Error,
7759 {
7760 match value {
7761 "upstreamActorId" | "upstream_actor_id" => Ok(GeneratedField::UpstreamActorId),
7762 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
7763 "upstreamDispatcherType" | "upstream_dispatcher_type" => Ok(GeneratedField::UpstreamDispatcherType),
7764 "fields" => Ok(GeneratedField::Fields),
7765 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7766 }
7767 }
7768 }
7769 deserializer.deserialize_identifier(GeneratedVisitor)
7770 }
7771 }
7772 struct GeneratedVisitor;
7773 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7774 type Value = MergeNode;
7775
7776 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7777 formatter.write_str("struct stream_plan.MergeNode")
7778 }
7779
7780 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeNode, V::Error>
7781 where
7782 V: serde::de::MapAccess<'de>,
7783 {
7784 let mut upstream_actor_id__ = None;
7785 let mut upstream_fragment_id__ = None;
7786 let mut upstream_dispatcher_type__ = None;
7787 let mut fields__ = None;
7788 while let Some(k) = map_.next_key()? {
7789 match k {
7790 GeneratedField::UpstreamActorId => {
7791 if upstream_actor_id__.is_some() {
7792 return Err(serde::de::Error::duplicate_field("upstreamActorId"));
7793 }
7794 upstream_actor_id__ =
7795 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7796 .into_iter().map(|x| x.0).collect())
7797 ;
7798 }
7799 GeneratedField::UpstreamFragmentId => {
7800 if upstream_fragment_id__.is_some() {
7801 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
7802 }
7803 upstream_fragment_id__ =
7804 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7805 ;
7806 }
7807 GeneratedField::UpstreamDispatcherType => {
7808 if upstream_dispatcher_type__.is_some() {
7809 return Err(serde::de::Error::duplicate_field("upstreamDispatcherType"));
7810 }
7811 upstream_dispatcher_type__ = Some(map_.next_value::<DispatcherType>()? as i32);
7812 }
7813 GeneratedField::Fields => {
7814 if fields__.is_some() {
7815 return Err(serde::de::Error::duplicate_field("fields"));
7816 }
7817 fields__ = Some(map_.next_value()?);
7818 }
7819 }
7820 }
7821 Ok(MergeNode {
7822 upstream_actor_id: upstream_actor_id__.unwrap_or_default(),
7823 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
7824 upstream_dispatcher_type: upstream_dispatcher_type__.unwrap_or_default(),
7825 fields: fields__.unwrap_or_default(),
7826 })
7827 }
7828 }
7829 deserializer.deserialize_struct("stream_plan.MergeNode", FIELDS, GeneratedVisitor)
7830 }
7831}
7832impl serde::Serialize for NoOpNode {
7833 #[allow(deprecated)]
7834 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7835 where
7836 S: serde::Serializer,
7837 {
7838 use serde::ser::SerializeStruct;
7839 let len = 0;
7840 let struct_ser = serializer.serialize_struct("stream_plan.NoOpNode", len)?;
7841 struct_ser.end()
7842 }
7843}
7844impl<'de> serde::Deserialize<'de> for NoOpNode {
7845 #[allow(deprecated)]
7846 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7847 where
7848 D: serde::Deserializer<'de>,
7849 {
7850 const FIELDS: &[&str] = &[
7851 ];
7852
7853 #[allow(clippy::enum_variant_names)]
7854 enum GeneratedField {
7855 }
7856 impl<'de> serde::Deserialize<'de> for GeneratedField {
7857 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7858 where
7859 D: serde::Deserializer<'de>,
7860 {
7861 struct GeneratedVisitor;
7862
7863 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7864 type Value = GeneratedField;
7865
7866 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7867 write!(formatter, "expected one of: {:?}", &FIELDS)
7868 }
7869
7870 #[allow(unused_variables)]
7871 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7872 where
7873 E: serde::de::Error,
7874 {
7875 Err(serde::de::Error::unknown_field(value, FIELDS))
7876 }
7877 }
7878 deserializer.deserialize_identifier(GeneratedVisitor)
7879 }
7880 }
7881 struct GeneratedVisitor;
7882 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7883 type Value = NoOpNode;
7884
7885 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7886 formatter.write_str("struct stream_plan.NoOpNode")
7887 }
7888
7889 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NoOpNode, V::Error>
7890 where
7891 V: serde::de::MapAccess<'de>,
7892 {
7893 while map_.next_key::<GeneratedField>()?.is_some() {
7894 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7895 }
7896 Ok(NoOpNode {
7897 })
7898 }
7899 }
7900 deserializer.deserialize_struct("stream_plan.NoOpNode", FIELDS, GeneratedVisitor)
7901 }
7902}
7903impl serde::Serialize for NowModeGenerateSeries {
7904 #[allow(deprecated)]
7905 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7906 where
7907 S: serde::Serializer,
7908 {
7909 use serde::ser::SerializeStruct;
7910 let mut len = 0;
7911 if self.start_timestamp.is_some() {
7912 len += 1;
7913 }
7914 if self.interval.is_some() {
7915 len += 1;
7916 }
7917 let mut struct_ser = serializer.serialize_struct("stream_plan.NowModeGenerateSeries", len)?;
7918 if let Some(v) = self.start_timestamp.as_ref() {
7919 struct_ser.serialize_field("startTimestamp", v)?;
7920 }
7921 if let Some(v) = self.interval.as_ref() {
7922 struct_ser.serialize_field("interval", v)?;
7923 }
7924 struct_ser.end()
7925 }
7926}
7927impl<'de> serde::Deserialize<'de> for NowModeGenerateSeries {
7928 #[allow(deprecated)]
7929 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7930 where
7931 D: serde::Deserializer<'de>,
7932 {
7933 const FIELDS: &[&str] = &[
7934 "start_timestamp",
7935 "startTimestamp",
7936 "interval",
7937 ];
7938
7939 #[allow(clippy::enum_variant_names)]
7940 enum GeneratedField {
7941 StartTimestamp,
7942 Interval,
7943 }
7944 impl<'de> serde::Deserialize<'de> for GeneratedField {
7945 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7946 where
7947 D: serde::Deserializer<'de>,
7948 {
7949 struct GeneratedVisitor;
7950
7951 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7952 type Value = GeneratedField;
7953
7954 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7955 write!(formatter, "expected one of: {:?}", &FIELDS)
7956 }
7957
7958 #[allow(unused_variables)]
7959 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7960 where
7961 E: serde::de::Error,
7962 {
7963 match value {
7964 "startTimestamp" | "start_timestamp" => Ok(GeneratedField::StartTimestamp),
7965 "interval" => Ok(GeneratedField::Interval),
7966 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7967 }
7968 }
7969 }
7970 deserializer.deserialize_identifier(GeneratedVisitor)
7971 }
7972 }
7973 struct GeneratedVisitor;
7974 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7975 type Value = NowModeGenerateSeries;
7976
7977 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7978 formatter.write_str("struct stream_plan.NowModeGenerateSeries")
7979 }
7980
7981 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeGenerateSeries, V::Error>
7982 where
7983 V: serde::de::MapAccess<'de>,
7984 {
7985 let mut start_timestamp__ = None;
7986 let mut interval__ = None;
7987 while let Some(k) = map_.next_key()? {
7988 match k {
7989 GeneratedField::StartTimestamp => {
7990 if start_timestamp__.is_some() {
7991 return Err(serde::de::Error::duplicate_field("startTimestamp"));
7992 }
7993 start_timestamp__ = map_.next_value()?;
7994 }
7995 GeneratedField::Interval => {
7996 if interval__.is_some() {
7997 return Err(serde::de::Error::duplicate_field("interval"));
7998 }
7999 interval__ = map_.next_value()?;
8000 }
8001 }
8002 }
8003 Ok(NowModeGenerateSeries {
8004 start_timestamp: start_timestamp__,
8005 interval: interval__,
8006 })
8007 }
8008 }
8009 deserializer.deserialize_struct("stream_plan.NowModeGenerateSeries", FIELDS, GeneratedVisitor)
8010 }
8011}
8012impl serde::Serialize for NowModeUpdateCurrent {
8013 #[allow(deprecated)]
8014 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8015 where
8016 S: serde::Serializer,
8017 {
8018 use serde::ser::SerializeStruct;
8019 let len = 0;
8020 let struct_ser = serializer.serialize_struct("stream_plan.NowModeUpdateCurrent", len)?;
8021 struct_ser.end()
8022 }
8023}
8024impl<'de> serde::Deserialize<'de> for NowModeUpdateCurrent {
8025 #[allow(deprecated)]
8026 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8027 where
8028 D: serde::Deserializer<'de>,
8029 {
8030 const FIELDS: &[&str] = &[
8031 ];
8032
8033 #[allow(clippy::enum_variant_names)]
8034 enum GeneratedField {
8035 }
8036 impl<'de> serde::Deserialize<'de> for GeneratedField {
8037 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8038 where
8039 D: serde::Deserializer<'de>,
8040 {
8041 struct GeneratedVisitor;
8042
8043 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8044 type Value = GeneratedField;
8045
8046 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8047 write!(formatter, "expected one of: {:?}", &FIELDS)
8048 }
8049
8050 #[allow(unused_variables)]
8051 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8052 where
8053 E: serde::de::Error,
8054 {
8055 Err(serde::de::Error::unknown_field(value, FIELDS))
8056 }
8057 }
8058 deserializer.deserialize_identifier(GeneratedVisitor)
8059 }
8060 }
8061 struct GeneratedVisitor;
8062 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8063 type Value = NowModeUpdateCurrent;
8064
8065 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8066 formatter.write_str("struct stream_plan.NowModeUpdateCurrent")
8067 }
8068
8069 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeUpdateCurrent, V::Error>
8070 where
8071 V: serde::de::MapAccess<'de>,
8072 {
8073 while map_.next_key::<GeneratedField>()?.is_some() {
8074 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8075 }
8076 Ok(NowModeUpdateCurrent {
8077 })
8078 }
8079 }
8080 deserializer.deserialize_struct("stream_plan.NowModeUpdateCurrent", FIELDS, GeneratedVisitor)
8081 }
8082}
8083impl serde::Serialize for NowNode {
8084 #[allow(deprecated)]
8085 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8086 where
8087 S: serde::Serializer,
8088 {
8089 use serde::ser::SerializeStruct;
8090 let mut len = 0;
8091 if self.state_table.is_some() {
8092 len += 1;
8093 }
8094 if self.mode.is_some() {
8095 len += 1;
8096 }
8097 let mut struct_ser = serializer.serialize_struct("stream_plan.NowNode", len)?;
8098 if let Some(v) = self.state_table.as_ref() {
8099 struct_ser.serialize_field("stateTable", v)?;
8100 }
8101 if let Some(v) = self.mode.as_ref() {
8102 match v {
8103 now_node::Mode::UpdateCurrent(v) => {
8104 struct_ser.serialize_field("updateCurrent", v)?;
8105 }
8106 now_node::Mode::GenerateSeries(v) => {
8107 struct_ser.serialize_field("generateSeries", v)?;
8108 }
8109 }
8110 }
8111 struct_ser.end()
8112 }
8113}
8114impl<'de> serde::Deserialize<'de> for NowNode {
8115 #[allow(deprecated)]
8116 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8117 where
8118 D: serde::Deserializer<'de>,
8119 {
8120 const FIELDS: &[&str] = &[
8121 "state_table",
8122 "stateTable",
8123 "update_current",
8124 "updateCurrent",
8125 "generate_series",
8126 "generateSeries",
8127 ];
8128
8129 #[allow(clippy::enum_variant_names)]
8130 enum GeneratedField {
8131 StateTable,
8132 UpdateCurrent,
8133 GenerateSeries,
8134 }
8135 impl<'de> serde::Deserialize<'de> for GeneratedField {
8136 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8137 where
8138 D: serde::Deserializer<'de>,
8139 {
8140 struct GeneratedVisitor;
8141
8142 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8143 type Value = GeneratedField;
8144
8145 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8146 write!(formatter, "expected one of: {:?}", &FIELDS)
8147 }
8148
8149 #[allow(unused_variables)]
8150 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8151 where
8152 E: serde::de::Error,
8153 {
8154 match value {
8155 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
8156 "updateCurrent" | "update_current" => Ok(GeneratedField::UpdateCurrent),
8157 "generateSeries" | "generate_series" => Ok(GeneratedField::GenerateSeries),
8158 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8159 }
8160 }
8161 }
8162 deserializer.deserialize_identifier(GeneratedVisitor)
8163 }
8164 }
8165 struct GeneratedVisitor;
8166 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8167 type Value = NowNode;
8168
8169 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8170 formatter.write_str("struct stream_plan.NowNode")
8171 }
8172
8173 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowNode, V::Error>
8174 where
8175 V: serde::de::MapAccess<'de>,
8176 {
8177 let mut state_table__ = None;
8178 let mut mode__ = None;
8179 while let Some(k) = map_.next_key()? {
8180 match k {
8181 GeneratedField::StateTable => {
8182 if state_table__.is_some() {
8183 return Err(serde::de::Error::duplicate_field("stateTable"));
8184 }
8185 state_table__ = map_.next_value()?;
8186 }
8187 GeneratedField::UpdateCurrent => {
8188 if mode__.is_some() {
8189 return Err(serde::de::Error::duplicate_field("updateCurrent"));
8190 }
8191 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::UpdateCurrent)
8192;
8193 }
8194 GeneratedField::GenerateSeries => {
8195 if mode__.is_some() {
8196 return Err(serde::de::Error::duplicate_field("generateSeries"));
8197 }
8198 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::GenerateSeries)
8199;
8200 }
8201 }
8202 }
8203 Ok(NowNode {
8204 state_table: state_table__,
8205 mode: mode__,
8206 })
8207 }
8208 }
8209 deserializer.deserialize_struct("stream_plan.NowNode", FIELDS, GeneratedVisitor)
8210 }
8211}
8212impl serde::Serialize for OverWindowCachePolicy {
8213 #[allow(deprecated)]
8214 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8215 where
8216 S: serde::Serializer,
8217 {
8218 let variant = match self {
8219 Self::Unspecified => "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
8220 Self::Full => "OVER_WINDOW_CACHE_POLICY_FULL",
8221 Self::Recent => "OVER_WINDOW_CACHE_POLICY_RECENT",
8222 Self::RecentFirstN => "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
8223 Self::RecentLastN => "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
8224 };
8225 serializer.serialize_str(variant)
8226 }
8227}
8228impl<'de> serde::Deserialize<'de> for OverWindowCachePolicy {
8229 #[allow(deprecated)]
8230 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8231 where
8232 D: serde::Deserializer<'de>,
8233 {
8234 const FIELDS: &[&str] = &[
8235 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
8236 "OVER_WINDOW_CACHE_POLICY_FULL",
8237 "OVER_WINDOW_CACHE_POLICY_RECENT",
8238 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
8239 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
8240 ];
8241
8242 struct GeneratedVisitor;
8243
8244 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8245 type Value = OverWindowCachePolicy;
8246
8247 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8248 write!(formatter, "expected one of: {:?}", &FIELDS)
8249 }
8250
8251 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8252 where
8253 E: serde::de::Error,
8254 {
8255 i32::try_from(v)
8256 .ok()
8257 .and_then(|x| x.try_into().ok())
8258 .ok_or_else(|| {
8259 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8260 })
8261 }
8262
8263 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8264 where
8265 E: serde::de::Error,
8266 {
8267 i32::try_from(v)
8268 .ok()
8269 .and_then(|x| x.try_into().ok())
8270 .ok_or_else(|| {
8271 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8272 })
8273 }
8274
8275 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8276 where
8277 E: serde::de::Error,
8278 {
8279 match value {
8280 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED" => Ok(OverWindowCachePolicy::Unspecified),
8281 "OVER_WINDOW_CACHE_POLICY_FULL" => Ok(OverWindowCachePolicy::Full),
8282 "OVER_WINDOW_CACHE_POLICY_RECENT" => Ok(OverWindowCachePolicy::Recent),
8283 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N" => Ok(OverWindowCachePolicy::RecentFirstN),
8284 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N" => Ok(OverWindowCachePolicy::RecentLastN),
8285 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8286 }
8287 }
8288 }
8289 deserializer.deserialize_any(GeneratedVisitor)
8290 }
8291}
8292impl serde::Serialize for OverWindowNode {
8293 #[allow(deprecated)]
8294 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8295 where
8296 S: serde::Serializer,
8297 {
8298 use serde::ser::SerializeStruct;
8299 let mut len = 0;
8300 if !self.calls.is_empty() {
8301 len += 1;
8302 }
8303 if !self.partition_by.is_empty() {
8304 len += 1;
8305 }
8306 if !self.order_by.is_empty() {
8307 len += 1;
8308 }
8309 if self.state_table.is_some() {
8310 len += 1;
8311 }
8312 if self.cache_policy != 0 {
8313 len += 1;
8314 }
8315 let mut struct_ser = serializer.serialize_struct("stream_plan.OverWindowNode", len)?;
8316 if !self.calls.is_empty() {
8317 struct_ser.serialize_field("calls", &self.calls)?;
8318 }
8319 if !self.partition_by.is_empty() {
8320 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
8321 }
8322 if !self.order_by.is_empty() {
8323 struct_ser.serialize_field("orderBy", &self.order_by)?;
8324 }
8325 if let Some(v) = self.state_table.as_ref() {
8326 struct_ser.serialize_field("stateTable", v)?;
8327 }
8328 if self.cache_policy != 0 {
8329 let v = OverWindowCachePolicy::try_from(self.cache_policy)
8330 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cache_policy)))?;
8331 struct_ser.serialize_field("cachePolicy", &v)?;
8332 }
8333 struct_ser.end()
8334 }
8335}
8336impl<'de> serde::Deserialize<'de> for OverWindowNode {
8337 #[allow(deprecated)]
8338 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8339 where
8340 D: serde::Deserializer<'de>,
8341 {
8342 const FIELDS: &[&str] = &[
8343 "calls",
8344 "partition_by",
8345 "partitionBy",
8346 "order_by",
8347 "orderBy",
8348 "state_table",
8349 "stateTable",
8350 "cache_policy",
8351 "cachePolicy",
8352 ];
8353
8354 #[allow(clippy::enum_variant_names)]
8355 enum GeneratedField {
8356 Calls,
8357 PartitionBy,
8358 OrderBy,
8359 StateTable,
8360 CachePolicy,
8361 }
8362 impl<'de> serde::Deserialize<'de> for GeneratedField {
8363 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8364 where
8365 D: serde::Deserializer<'de>,
8366 {
8367 struct GeneratedVisitor;
8368
8369 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8370 type Value = GeneratedField;
8371
8372 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8373 write!(formatter, "expected one of: {:?}", &FIELDS)
8374 }
8375
8376 #[allow(unused_variables)]
8377 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8378 where
8379 E: serde::de::Error,
8380 {
8381 match value {
8382 "calls" => Ok(GeneratedField::Calls),
8383 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
8384 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
8385 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
8386 "cachePolicy" | "cache_policy" => Ok(GeneratedField::CachePolicy),
8387 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8388 }
8389 }
8390 }
8391 deserializer.deserialize_identifier(GeneratedVisitor)
8392 }
8393 }
8394 struct GeneratedVisitor;
8395 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8396 type Value = OverWindowNode;
8397
8398 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8399 formatter.write_str("struct stream_plan.OverWindowNode")
8400 }
8401
8402 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverWindowNode, V::Error>
8403 where
8404 V: serde::de::MapAccess<'de>,
8405 {
8406 let mut calls__ = None;
8407 let mut partition_by__ = None;
8408 let mut order_by__ = None;
8409 let mut state_table__ = None;
8410 let mut cache_policy__ = None;
8411 while let Some(k) = map_.next_key()? {
8412 match k {
8413 GeneratedField::Calls => {
8414 if calls__.is_some() {
8415 return Err(serde::de::Error::duplicate_field("calls"));
8416 }
8417 calls__ = Some(map_.next_value()?);
8418 }
8419 GeneratedField::PartitionBy => {
8420 if partition_by__.is_some() {
8421 return Err(serde::de::Error::duplicate_field("partitionBy"));
8422 }
8423 partition_by__ =
8424 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8425 .into_iter().map(|x| x.0).collect())
8426 ;
8427 }
8428 GeneratedField::OrderBy => {
8429 if order_by__.is_some() {
8430 return Err(serde::de::Error::duplicate_field("orderBy"));
8431 }
8432 order_by__ = Some(map_.next_value()?);
8433 }
8434 GeneratedField::StateTable => {
8435 if state_table__.is_some() {
8436 return Err(serde::de::Error::duplicate_field("stateTable"));
8437 }
8438 state_table__ = map_.next_value()?;
8439 }
8440 GeneratedField::CachePolicy => {
8441 if cache_policy__.is_some() {
8442 return Err(serde::de::Error::duplicate_field("cachePolicy"));
8443 }
8444 cache_policy__ = Some(map_.next_value::<OverWindowCachePolicy>()? as i32);
8445 }
8446 }
8447 }
8448 Ok(OverWindowNode {
8449 calls: calls__.unwrap_or_default(),
8450 partition_by: partition_by__.unwrap_or_default(),
8451 order_by: order_by__.unwrap_or_default(),
8452 state_table: state_table__,
8453 cache_policy: cache_policy__.unwrap_or_default(),
8454 })
8455 }
8456 }
8457 deserializer.deserialize_struct("stream_plan.OverWindowNode", FIELDS, GeneratedVisitor)
8458 }
8459}
8460impl serde::Serialize for PauseMutation {
8461 #[allow(deprecated)]
8462 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8463 where
8464 S: serde::Serializer,
8465 {
8466 use serde::ser::SerializeStruct;
8467 let len = 0;
8468 let struct_ser = serializer.serialize_struct("stream_plan.PauseMutation", len)?;
8469 struct_ser.end()
8470 }
8471}
8472impl<'de> serde::Deserialize<'de> for PauseMutation {
8473 #[allow(deprecated)]
8474 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8475 where
8476 D: serde::Deserializer<'de>,
8477 {
8478 const FIELDS: &[&str] = &[
8479 ];
8480
8481 #[allow(clippy::enum_variant_names)]
8482 enum GeneratedField {
8483 }
8484 impl<'de> serde::Deserialize<'de> for GeneratedField {
8485 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8486 where
8487 D: serde::Deserializer<'de>,
8488 {
8489 struct GeneratedVisitor;
8490
8491 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8492 type Value = GeneratedField;
8493
8494 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8495 write!(formatter, "expected one of: {:?}", &FIELDS)
8496 }
8497
8498 #[allow(unused_variables)]
8499 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8500 where
8501 E: serde::de::Error,
8502 {
8503 Err(serde::de::Error::unknown_field(value, FIELDS))
8504 }
8505 }
8506 deserializer.deserialize_identifier(GeneratedVisitor)
8507 }
8508 }
8509 struct GeneratedVisitor;
8510 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8511 type Value = PauseMutation;
8512
8513 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8514 formatter.write_str("struct stream_plan.PauseMutation")
8515 }
8516
8517 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseMutation, V::Error>
8518 where
8519 V: serde::de::MapAccess<'de>,
8520 {
8521 while map_.next_key::<GeneratedField>()?.is_some() {
8522 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8523 }
8524 Ok(PauseMutation {
8525 })
8526 }
8527 }
8528 deserializer.deserialize_struct("stream_plan.PauseMutation", FIELDS, GeneratedVisitor)
8529 }
8530}
8531impl serde::Serialize for ProjectNode {
8532 #[allow(deprecated)]
8533 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8534 where
8535 S: serde::Serializer,
8536 {
8537 use serde::ser::SerializeStruct;
8538 let mut len = 0;
8539 if !self.select_list.is_empty() {
8540 len += 1;
8541 }
8542 if !self.watermark_input_cols.is_empty() {
8543 len += 1;
8544 }
8545 if !self.watermark_output_cols.is_empty() {
8546 len += 1;
8547 }
8548 if !self.nondecreasing_exprs.is_empty() {
8549 len += 1;
8550 }
8551 if self.noop_update_hint {
8552 len += 1;
8553 }
8554 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectNode", len)?;
8555 if !self.select_list.is_empty() {
8556 struct_ser.serialize_field("selectList", &self.select_list)?;
8557 }
8558 if !self.watermark_input_cols.is_empty() {
8559 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
8560 }
8561 if !self.watermark_output_cols.is_empty() {
8562 struct_ser.serialize_field("watermarkOutputCols", &self.watermark_output_cols)?;
8563 }
8564 if !self.nondecreasing_exprs.is_empty() {
8565 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
8566 }
8567 if self.noop_update_hint {
8568 struct_ser.serialize_field("noopUpdateHint", &self.noop_update_hint)?;
8569 }
8570 struct_ser.end()
8571 }
8572}
8573impl<'de> serde::Deserialize<'de> for ProjectNode {
8574 #[allow(deprecated)]
8575 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8576 where
8577 D: serde::Deserializer<'de>,
8578 {
8579 const FIELDS: &[&str] = &[
8580 "select_list",
8581 "selectList",
8582 "watermark_input_cols",
8583 "watermarkInputCols",
8584 "watermark_output_cols",
8585 "watermarkOutputCols",
8586 "nondecreasing_exprs",
8587 "nondecreasingExprs",
8588 "noop_update_hint",
8589 "noopUpdateHint",
8590 ];
8591
8592 #[allow(clippy::enum_variant_names)]
8593 enum GeneratedField {
8594 SelectList,
8595 WatermarkInputCols,
8596 WatermarkOutputCols,
8597 NondecreasingExprs,
8598 NoopUpdateHint,
8599 }
8600 impl<'de> serde::Deserialize<'de> for GeneratedField {
8601 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8602 where
8603 D: serde::Deserializer<'de>,
8604 {
8605 struct GeneratedVisitor;
8606
8607 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8608 type Value = GeneratedField;
8609
8610 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8611 write!(formatter, "expected one of: {:?}", &FIELDS)
8612 }
8613
8614 #[allow(unused_variables)]
8615 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8616 where
8617 E: serde::de::Error,
8618 {
8619 match value {
8620 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
8621 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
8622 "watermarkOutputCols" | "watermark_output_cols" => Ok(GeneratedField::WatermarkOutputCols),
8623 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
8624 "noopUpdateHint" | "noop_update_hint" => Ok(GeneratedField::NoopUpdateHint),
8625 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8626 }
8627 }
8628 }
8629 deserializer.deserialize_identifier(GeneratedVisitor)
8630 }
8631 }
8632 struct GeneratedVisitor;
8633 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8634 type Value = ProjectNode;
8635
8636 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8637 formatter.write_str("struct stream_plan.ProjectNode")
8638 }
8639
8640 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
8641 where
8642 V: serde::de::MapAccess<'de>,
8643 {
8644 let mut select_list__ = None;
8645 let mut watermark_input_cols__ = None;
8646 let mut watermark_output_cols__ = None;
8647 let mut nondecreasing_exprs__ = None;
8648 let mut noop_update_hint__ = None;
8649 while let Some(k) = map_.next_key()? {
8650 match k {
8651 GeneratedField::SelectList => {
8652 if select_list__.is_some() {
8653 return Err(serde::de::Error::duplicate_field("selectList"));
8654 }
8655 select_list__ = Some(map_.next_value()?);
8656 }
8657 GeneratedField::WatermarkInputCols => {
8658 if watermark_input_cols__.is_some() {
8659 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
8660 }
8661 watermark_input_cols__ =
8662 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8663 .into_iter().map(|x| x.0).collect())
8664 ;
8665 }
8666 GeneratedField::WatermarkOutputCols => {
8667 if watermark_output_cols__.is_some() {
8668 return Err(serde::de::Error::duplicate_field("watermarkOutputCols"));
8669 }
8670 watermark_output_cols__ =
8671 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8672 .into_iter().map(|x| x.0).collect())
8673 ;
8674 }
8675 GeneratedField::NondecreasingExprs => {
8676 if nondecreasing_exprs__.is_some() {
8677 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
8678 }
8679 nondecreasing_exprs__ =
8680 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8681 .into_iter().map(|x| x.0).collect())
8682 ;
8683 }
8684 GeneratedField::NoopUpdateHint => {
8685 if noop_update_hint__.is_some() {
8686 return Err(serde::de::Error::duplicate_field("noopUpdateHint"));
8687 }
8688 noop_update_hint__ = Some(map_.next_value()?);
8689 }
8690 }
8691 }
8692 Ok(ProjectNode {
8693 select_list: select_list__.unwrap_or_default(),
8694 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
8695 watermark_output_cols: watermark_output_cols__.unwrap_or_default(),
8696 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
8697 noop_update_hint: noop_update_hint__.unwrap_or_default(),
8698 })
8699 }
8700 }
8701 deserializer.deserialize_struct("stream_plan.ProjectNode", FIELDS, GeneratedVisitor)
8702 }
8703}
8704impl serde::Serialize for ProjectSetNode {
8705 #[allow(deprecated)]
8706 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8707 where
8708 S: serde::Serializer,
8709 {
8710 use serde::ser::SerializeStruct;
8711 let mut len = 0;
8712 if !self.select_list.is_empty() {
8713 len += 1;
8714 }
8715 if !self.watermark_input_cols.is_empty() {
8716 len += 1;
8717 }
8718 if !self.watermark_expr_indices.is_empty() {
8719 len += 1;
8720 }
8721 if !self.nondecreasing_exprs.is_empty() {
8722 len += 1;
8723 }
8724 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectSetNode", len)?;
8725 if !self.select_list.is_empty() {
8726 struct_ser.serialize_field("selectList", &self.select_list)?;
8727 }
8728 if !self.watermark_input_cols.is_empty() {
8729 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
8730 }
8731 if !self.watermark_expr_indices.is_empty() {
8732 struct_ser.serialize_field("watermarkExprIndices", &self.watermark_expr_indices)?;
8733 }
8734 if !self.nondecreasing_exprs.is_empty() {
8735 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
8736 }
8737 struct_ser.end()
8738 }
8739}
8740impl<'de> serde::Deserialize<'de> for ProjectSetNode {
8741 #[allow(deprecated)]
8742 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8743 where
8744 D: serde::Deserializer<'de>,
8745 {
8746 const FIELDS: &[&str] = &[
8747 "select_list",
8748 "selectList",
8749 "watermark_input_cols",
8750 "watermarkInputCols",
8751 "watermark_expr_indices",
8752 "watermarkExprIndices",
8753 "nondecreasing_exprs",
8754 "nondecreasingExprs",
8755 ];
8756
8757 #[allow(clippy::enum_variant_names)]
8758 enum GeneratedField {
8759 SelectList,
8760 WatermarkInputCols,
8761 WatermarkExprIndices,
8762 NondecreasingExprs,
8763 }
8764 impl<'de> serde::Deserialize<'de> for GeneratedField {
8765 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8766 where
8767 D: serde::Deserializer<'de>,
8768 {
8769 struct GeneratedVisitor;
8770
8771 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8772 type Value = GeneratedField;
8773
8774 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8775 write!(formatter, "expected one of: {:?}", &FIELDS)
8776 }
8777
8778 #[allow(unused_variables)]
8779 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8780 where
8781 E: serde::de::Error,
8782 {
8783 match value {
8784 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
8785 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
8786 "watermarkExprIndices" | "watermark_expr_indices" => Ok(GeneratedField::WatermarkExprIndices),
8787 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
8788 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8789 }
8790 }
8791 }
8792 deserializer.deserialize_identifier(GeneratedVisitor)
8793 }
8794 }
8795 struct GeneratedVisitor;
8796 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8797 type Value = ProjectSetNode;
8798
8799 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8800 formatter.write_str("struct stream_plan.ProjectSetNode")
8801 }
8802
8803 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
8804 where
8805 V: serde::de::MapAccess<'de>,
8806 {
8807 let mut select_list__ = None;
8808 let mut watermark_input_cols__ = None;
8809 let mut watermark_expr_indices__ = None;
8810 let mut nondecreasing_exprs__ = None;
8811 while let Some(k) = map_.next_key()? {
8812 match k {
8813 GeneratedField::SelectList => {
8814 if select_list__.is_some() {
8815 return Err(serde::de::Error::duplicate_field("selectList"));
8816 }
8817 select_list__ = Some(map_.next_value()?);
8818 }
8819 GeneratedField::WatermarkInputCols => {
8820 if watermark_input_cols__.is_some() {
8821 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
8822 }
8823 watermark_input_cols__ =
8824 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8825 .into_iter().map(|x| x.0).collect())
8826 ;
8827 }
8828 GeneratedField::WatermarkExprIndices => {
8829 if watermark_expr_indices__.is_some() {
8830 return Err(serde::de::Error::duplicate_field("watermarkExprIndices"));
8831 }
8832 watermark_expr_indices__ =
8833 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8834 .into_iter().map(|x| x.0).collect())
8835 ;
8836 }
8837 GeneratedField::NondecreasingExprs => {
8838 if nondecreasing_exprs__.is_some() {
8839 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
8840 }
8841 nondecreasing_exprs__ =
8842 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8843 .into_iter().map(|x| x.0).collect())
8844 ;
8845 }
8846 }
8847 }
8848 Ok(ProjectSetNode {
8849 select_list: select_list__.unwrap_or_default(),
8850 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
8851 watermark_expr_indices: watermark_expr_indices__.unwrap_or_default(),
8852 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
8853 })
8854 }
8855 }
8856 deserializer.deserialize_struct("stream_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
8857 }
8858}
8859impl serde::Serialize for RefreshStartMutation {
8860 #[allow(deprecated)]
8861 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8862 where
8863 S: serde::Serializer,
8864 {
8865 use serde::ser::SerializeStruct;
8866 let mut len = 0;
8867 if self.table_id != 0 {
8868 len += 1;
8869 }
8870 if self.associated_source_id != 0 {
8871 len += 1;
8872 }
8873 let mut struct_ser = serializer.serialize_struct("stream_plan.RefreshStartMutation", len)?;
8874 if self.table_id != 0 {
8875 struct_ser.serialize_field("tableId", &self.table_id)?;
8876 }
8877 if self.associated_source_id != 0 {
8878 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
8879 }
8880 struct_ser.end()
8881 }
8882}
8883impl<'de> serde::Deserialize<'de> for RefreshStartMutation {
8884 #[allow(deprecated)]
8885 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8886 where
8887 D: serde::Deserializer<'de>,
8888 {
8889 const FIELDS: &[&str] = &[
8890 "table_id",
8891 "tableId",
8892 "associated_source_id",
8893 "associatedSourceId",
8894 ];
8895
8896 #[allow(clippy::enum_variant_names)]
8897 enum GeneratedField {
8898 TableId,
8899 AssociatedSourceId,
8900 }
8901 impl<'de> serde::Deserialize<'de> for GeneratedField {
8902 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8903 where
8904 D: serde::Deserializer<'de>,
8905 {
8906 struct GeneratedVisitor;
8907
8908 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8909 type Value = GeneratedField;
8910
8911 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8912 write!(formatter, "expected one of: {:?}", &FIELDS)
8913 }
8914
8915 #[allow(unused_variables)]
8916 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8917 where
8918 E: serde::de::Error,
8919 {
8920 match value {
8921 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8922 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
8923 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8924 }
8925 }
8926 }
8927 deserializer.deserialize_identifier(GeneratedVisitor)
8928 }
8929 }
8930 struct GeneratedVisitor;
8931 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8932 type Value = RefreshStartMutation;
8933
8934 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8935 formatter.write_str("struct stream_plan.RefreshStartMutation")
8936 }
8937
8938 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshStartMutation, V::Error>
8939 where
8940 V: serde::de::MapAccess<'de>,
8941 {
8942 let mut table_id__ = None;
8943 let mut associated_source_id__ = None;
8944 while let Some(k) = map_.next_key()? {
8945 match k {
8946 GeneratedField::TableId => {
8947 if table_id__.is_some() {
8948 return Err(serde::de::Error::duplicate_field("tableId"));
8949 }
8950 table_id__ =
8951 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8952 ;
8953 }
8954 GeneratedField::AssociatedSourceId => {
8955 if associated_source_id__.is_some() {
8956 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
8957 }
8958 associated_source_id__ =
8959 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8960 ;
8961 }
8962 }
8963 }
8964 Ok(RefreshStartMutation {
8965 table_id: table_id__.unwrap_or_default(),
8966 associated_source_id: associated_source_id__.unwrap_or_default(),
8967 })
8968 }
8969 }
8970 deserializer.deserialize_struct("stream_plan.RefreshStartMutation", FIELDS, GeneratedVisitor)
8971 }
8972}
8973impl serde::Serialize for ResumeMutation {
8974 #[allow(deprecated)]
8975 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8976 where
8977 S: serde::Serializer,
8978 {
8979 use serde::ser::SerializeStruct;
8980 let len = 0;
8981 let struct_ser = serializer.serialize_struct("stream_plan.ResumeMutation", len)?;
8982 struct_ser.end()
8983 }
8984}
8985impl<'de> serde::Deserialize<'de> for ResumeMutation {
8986 #[allow(deprecated)]
8987 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8988 where
8989 D: serde::Deserializer<'de>,
8990 {
8991 const FIELDS: &[&str] = &[
8992 ];
8993
8994 #[allow(clippy::enum_variant_names)]
8995 enum GeneratedField {
8996 }
8997 impl<'de> serde::Deserialize<'de> for GeneratedField {
8998 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8999 where
9000 D: serde::Deserializer<'de>,
9001 {
9002 struct GeneratedVisitor;
9003
9004 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9005 type Value = GeneratedField;
9006
9007 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9008 write!(formatter, "expected one of: {:?}", &FIELDS)
9009 }
9010
9011 #[allow(unused_variables)]
9012 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9013 where
9014 E: serde::de::Error,
9015 {
9016 Err(serde::de::Error::unknown_field(value, FIELDS))
9017 }
9018 }
9019 deserializer.deserialize_identifier(GeneratedVisitor)
9020 }
9021 }
9022 struct GeneratedVisitor;
9023 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9024 type Value = ResumeMutation;
9025
9026 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9027 formatter.write_str("struct stream_plan.ResumeMutation")
9028 }
9029
9030 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeMutation, V::Error>
9031 where
9032 V: serde::de::MapAccess<'de>,
9033 {
9034 while map_.next_key::<GeneratedField>()?.is_some() {
9035 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9036 }
9037 Ok(ResumeMutation {
9038 })
9039 }
9040 }
9041 deserializer.deserialize_struct("stream_plan.ResumeMutation", FIELDS, GeneratedVisitor)
9042 }
9043}
9044impl serde::Serialize for RowIdGenNode {
9045 #[allow(deprecated)]
9046 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9047 where
9048 S: serde::Serializer,
9049 {
9050 use serde::ser::SerializeStruct;
9051 let mut len = 0;
9052 if self.row_id_index != 0 {
9053 len += 1;
9054 }
9055 let mut struct_ser = serializer.serialize_struct("stream_plan.RowIdGenNode", len)?;
9056 if self.row_id_index != 0 {
9057 #[allow(clippy::needless_borrow)]
9058 #[allow(clippy::needless_borrows_for_generic_args)]
9059 struct_ser.serialize_field("rowIdIndex", ToString::to_string(&self.row_id_index).as_str())?;
9060 }
9061 struct_ser.end()
9062 }
9063}
9064impl<'de> serde::Deserialize<'de> for RowIdGenNode {
9065 #[allow(deprecated)]
9066 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9067 where
9068 D: serde::Deserializer<'de>,
9069 {
9070 const FIELDS: &[&str] = &[
9071 "row_id_index",
9072 "rowIdIndex",
9073 ];
9074
9075 #[allow(clippy::enum_variant_names)]
9076 enum GeneratedField {
9077 RowIdIndex,
9078 }
9079 impl<'de> serde::Deserialize<'de> for GeneratedField {
9080 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9081 where
9082 D: serde::Deserializer<'de>,
9083 {
9084 struct GeneratedVisitor;
9085
9086 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9087 type Value = GeneratedField;
9088
9089 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9090 write!(formatter, "expected one of: {:?}", &FIELDS)
9091 }
9092
9093 #[allow(unused_variables)]
9094 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9095 where
9096 E: serde::de::Error,
9097 {
9098 match value {
9099 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
9100 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9101 }
9102 }
9103 }
9104 deserializer.deserialize_identifier(GeneratedVisitor)
9105 }
9106 }
9107 struct GeneratedVisitor;
9108 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9109 type Value = RowIdGenNode;
9110
9111 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9112 formatter.write_str("struct stream_plan.RowIdGenNode")
9113 }
9114
9115 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowIdGenNode, V::Error>
9116 where
9117 V: serde::de::MapAccess<'de>,
9118 {
9119 let mut row_id_index__ = None;
9120 while let Some(k) = map_.next_key()? {
9121 match k {
9122 GeneratedField::RowIdIndex => {
9123 if row_id_index__.is_some() {
9124 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
9125 }
9126 row_id_index__ =
9127 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9128 ;
9129 }
9130 }
9131 }
9132 Ok(RowIdGenNode {
9133 row_id_index: row_id_index__.unwrap_or_default(),
9134 })
9135 }
9136 }
9137 deserializer.deserialize_struct("stream_plan.RowIdGenNode", FIELDS, GeneratedVisitor)
9138 }
9139}
9140impl serde::Serialize for RowMergeNode {
9141 #[allow(deprecated)]
9142 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9143 where
9144 S: serde::Serializer,
9145 {
9146 use serde::ser::SerializeStruct;
9147 let mut len = 0;
9148 if self.lhs_mapping.is_some() {
9149 len += 1;
9150 }
9151 if self.rhs_mapping.is_some() {
9152 len += 1;
9153 }
9154 let mut struct_ser = serializer.serialize_struct("stream_plan.RowMergeNode", len)?;
9155 if let Some(v) = self.lhs_mapping.as_ref() {
9156 struct_ser.serialize_field("lhsMapping", v)?;
9157 }
9158 if let Some(v) = self.rhs_mapping.as_ref() {
9159 struct_ser.serialize_field("rhsMapping", v)?;
9160 }
9161 struct_ser.end()
9162 }
9163}
9164impl<'de> serde::Deserialize<'de> for RowMergeNode {
9165 #[allow(deprecated)]
9166 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9167 where
9168 D: serde::Deserializer<'de>,
9169 {
9170 const FIELDS: &[&str] = &[
9171 "lhs_mapping",
9172 "lhsMapping",
9173 "rhs_mapping",
9174 "rhsMapping",
9175 ];
9176
9177 #[allow(clippy::enum_variant_names)]
9178 enum GeneratedField {
9179 LhsMapping,
9180 RhsMapping,
9181 }
9182 impl<'de> serde::Deserialize<'de> for GeneratedField {
9183 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9184 where
9185 D: serde::Deserializer<'de>,
9186 {
9187 struct GeneratedVisitor;
9188
9189 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9190 type Value = GeneratedField;
9191
9192 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9193 write!(formatter, "expected one of: {:?}", &FIELDS)
9194 }
9195
9196 #[allow(unused_variables)]
9197 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9198 where
9199 E: serde::de::Error,
9200 {
9201 match value {
9202 "lhsMapping" | "lhs_mapping" => Ok(GeneratedField::LhsMapping),
9203 "rhsMapping" | "rhs_mapping" => Ok(GeneratedField::RhsMapping),
9204 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9205 }
9206 }
9207 }
9208 deserializer.deserialize_identifier(GeneratedVisitor)
9209 }
9210 }
9211 struct GeneratedVisitor;
9212 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9213 type Value = RowMergeNode;
9214
9215 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9216 formatter.write_str("struct stream_plan.RowMergeNode")
9217 }
9218
9219 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowMergeNode, V::Error>
9220 where
9221 V: serde::de::MapAccess<'de>,
9222 {
9223 let mut lhs_mapping__ = None;
9224 let mut rhs_mapping__ = None;
9225 while let Some(k) = map_.next_key()? {
9226 match k {
9227 GeneratedField::LhsMapping => {
9228 if lhs_mapping__.is_some() {
9229 return Err(serde::de::Error::duplicate_field("lhsMapping"));
9230 }
9231 lhs_mapping__ = map_.next_value()?;
9232 }
9233 GeneratedField::RhsMapping => {
9234 if rhs_mapping__.is_some() {
9235 return Err(serde::de::Error::duplicate_field("rhsMapping"));
9236 }
9237 rhs_mapping__ = map_.next_value()?;
9238 }
9239 }
9240 }
9241 Ok(RowMergeNode {
9242 lhs_mapping: lhs_mapping__,
9243 rhs_mapping: rhs_mapping__,
9244 })
9245 }
9246 }
9247 deserializer.deserialize_struct("stream_plan.RowMergeNode", FIELDS, GeneratedVisitor)
9248 }
9249}
9250impl serde::Serialize for SimpleAggNode {
9251 #[allow(deprecated)]
9252 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9253 where
9254 S: serde::Serializer,
9255 {
9256 use serde::ser::SerializeStruct;
9257 let mut len = 0;
9258 if !self.agg_calls.is_empty() {
9259 len += 1;
9260 }
9261 if !self.agg_call_states.is_empty() {
9262 len += 1;
9263 }
9264 if self.intermediate_state_table.is_some() {
9265 len += 1;
9266 }
9267 if self.is_append_only {
9268 len += 1;
9269 }
9270 if !self.distinct_dedup_tables.is_empty() {
9271 len += 1;
9272 }
9273 if self.row_count_index != 0 {
9274 len += 1;
9275 }
9276 if self.version != 0 {
9277 len += 1;
9278 }
9279 if self.must_output_per_barrier {
9280 len += 1;
9281 }
9282 let mut struct_ser = serializer.serialize_struct("stream_plan.SimpleAggNode", len)?;
9283 if !self.agg_calls.is_empty() {
9284 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
9285 }
9286 if !self.agg_call_states.is_empty() {
9287 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
9288 }
9289 if let Some(v) = self.intermediate_state_table.as_ref() {
9290 struct_ser.serialize_field("intermediateStateTable", v)?;
9291 }
9292 if self.is_append_only {
9293 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
9294 }
9295 if !self.distinct_dedup_tables.is_empty() {
9296 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
9297 }
9298 if self.row_count_index != 0 {
9299 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
9300 }
9301 if self.version != 0 {
9302 let v = AggNodeVersion::try_from(self.version)
9303 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
9304 struct_ser.serialize_field("version", &v)?;
9305 }
9306 if self.must_output_per_barrier {
9307 struct_ser.serialize_field("mustOutputPerBarrier", &self.must_output_per_barrier)?;
9308 }
9309 struct_ser.end()
9310 }
9311}
9312impl<'de> serde::Deserialize<'de> for SimpleAggNode {
9313 #[allow(deprecated)]
9314 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9315 where
9316 D: serde::Deserializer<'de>,
9317 {
9318 const FIELDS: &[&str] = &[
9319 "agg_calls",
9320 "aggCalls",
9321 "agg_call_states",
9322 "aggCallStates",
9323 "intermediate_state_table",
9324 "intermediateStateTable",
9325 "is_append_only",
9326 "isAppendOnly",
9327 "distinct_dedup_tables",
9328 "distinctDedupTables",
9329 "row_count_index",
9330 "rowCountIndex",
9331 "version",
9332 "must_output_per_barrier",
9333 "mustOutputPerBarrier",
9334 ];
9335
9336 #[allow(clippy::enum_variant_names)]
9337 enum GeneratedField {
9338 AggCalls,
9339 AggCallStates,
9340 IntermediateStateTable,
9341 IsAppendOnly,
9342 DistinctDedupTables,
9343 RowCountIndex,
9344 Version,
9345 MustOutputPerBarrier,
9346 }
9347 impl<'de> serde::Deserialize<'de> for GeneratedField {
9348 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9349 where
9350 D: serde::Deserializer<'de>,
9351 {
9352 struct GeneratedVisitor;
9353
9354 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9355 type Value = GeneratedField;
9356
9357 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9358 write!(formatter, "expected one of: {:?}", &FIELDS)
9359 }
9360
9361 #[allow(unused_variables)]
9362 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9363 where
9364 E: serde::de::Error,
9365 {
9366 match value {
9367 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
9368 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
9369 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
9370 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
9371 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
9372 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
9373 "version" => Ok(GeneratedField::Version),
9374 "mustOutputPerBarrier" | "must_output_per_barrier" => Ok(GeneratedField::MustOutputPerBarrier),
9375 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9376 }
9377 }
9378 }
9379 deserializer.deserialize_identifier(GeneratedVisitor)
9380 }
9381 }
9382 struct GeneratedVisitor;
9383 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9384 type Value = SimpleAggNode;
9385
9386 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9387 formatter.write_str("struct stream_plan.SimpleAggNode")
9388 }
9389
9390 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SimpleAggNode, V::Error>
9391 where
9392 V: serde::de::MapAccess<'de>,
9393 {
9394 let mut agg_calls__ = None;
9395 let mut agg_call_states__ = None;
9396 let mut intermediate_state_table__ = None;
9397 let mut is_append_only__ = None;
9398 let mut distinct_dedup_tables__ = None;
9399 let mut row_count_index__ = None;
9400 let mut version__ = None;
9401 let mut must_output_per_barrier__ = None;
9402 while let Some(k) = map_.next_key()? {
9403 match k {
9404 GeneratedField::AggCalls => {
9405 if agg_calls__.is_some() {
9406 return Err(serde::de::Error::duplicate_field("aggCalls"));
9407 }
9408 agg_calls__ = Some(map_.next_value()?);
9409 }
9410 GeneratedField::AggCallStates => {
9411 if agg_call_states__.is_some() {
9412 return Err(serde::de::Error::duplicate_field("aggCallStates"));
9413 }
9414 agg_call_states__ = Some(map_.next_value()?);
9415 }
9416 GeneratedField::IntermediateStateTable => {
9417 if intermediate_state_table__.is_some() {
9418 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
9419 }
9420 intermediate_state_table__ = map_.next_value()?;
9421 }
9422 GeneratedField::IsAppendOnly => {
9423 if is_append_only__.is_some() {
9424 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
9425 }
9426 is_append_only__ = Some(map_.next_value()?);
9427 }
9428 GeneratedField::DistinctDedupTables => {
9429 if distinct_dedup_tables__.is_some() {
9430 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
9431 }
9432 distinct_dedup_tables__ = Some(
9433 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
9434 .into_iter().map(|(k,v)| (k.0, v)).collect()
9435 );
9436 }
9437 GeneratedField::RowCountIndex => {
9438 if row_count_index__.is_some() {
9439 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
9440 }
9441 row_count_index__ =
9442 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9443 ;
9444 }
9445 GeneratedField::Version => {
9446 if version__.is_some() {
9447 return Err(serde::de::Error::duplicate_field("version"));
9448 }
9449 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
9450 }
9451 GeneratedField::MustOutputPerBarrier => {
9452 if must_output_per_barrier__.is_some() {
9453 return Err(serde::de::Error::duplicate_field("mustOutputPerBarrier"));
9454 }
9455 must_output_per_barrier__ = Some(map_.next_value()?);
9456 }
9457 }
9458 }
9459 Ok(SimpleAggNode {
9460 agg_calls: agg_calls__.unwrap_or_default(),
9461 agg_call_states: agg_call_states__.unwrap_or_default(),
9462 intermediate_state_table: intermediate_state_table__,
9463 is_append_only: is_append_only__.unwrap_or_default(),
9464 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
9465 row_count_index: row_count_index__.unwrap_or_default(),
9466 version: version__.unwrap_or_default(),
9467 must_output_per_barrier: must_output_per_barrier__.unwrap_or_default(),
9468 })
9469 }
9470 }
9471 deserializer.deserialize_struct("stream_plan.SimpleAggNode", FIELDS, GeneratedVisitor)
9472 }
9473}
9474impl serde::Serialize for SinkAddColumns {
9475 #[allow(deprecated)]
9476 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9477 where
9478 S: serde::Serializer,
9479 {
9480 use serde::ser::SerializeStruct;
9481 let mut len = 0;
9482 if !self.fields.is_empty() {
9483 len += 1;
9484 }
9485 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkAddColumns", len)?;
9486 if !self.fields.is_empty() {
9487 struct_ser.serialize_field("fields", &self.fields)?;
9488 }
9489 struct_ser.end()
9490 }
9491}
9492impl<'de> serde::Deserialize<'de> for SinkAddColumns {
9493 #[allow(deprecated)]
9494 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9495 where
9496 D: serde::Deserializer<'de>,
9497 {
9498 const FIELDS: &[&str] = &[
9499 "fields",
9500 ];
9501
9502 #[allow(clippy::enum_variant_names)]
9503 enum GeneratedField {
9504 Fields,
9505 }
9506 impl<'de> serde::Deserialize<'de> for GeneratedField {
9507 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9508 where
9509 D: serde::Deserializer<'de>,
9510 {
9511 struct GeneratedVisitor;
9512
9513 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9514 type Value = GeneratedField;
9515
9516 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9517 write!(formatter, "expected one of: {:?}", &FIELDS)
9518 }
9519
9520 #[allow(unused_variables)]
9521 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9522 where
9523 E: serde::de::Error,
9524 {
9525 match value {
9526 "fields" => Ok(GeneratedField::Fields),
9527 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9528 }
9529 }
9530 }
9531 deserializer.deserialize_identifier(GeneratedVisitor)
9532 }
9533 }
9534 struct GeneratedVisitor;
9535 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9536 type Value = SinkAddColumns;
9537
9538 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9539 formatter.write_str("struct stream_plan.SinkAddColumns")
9540 }
9541
9542 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkAddColumns, V::Error>
9543 where
9544 V: serde::de::MapAccess<'de>,
9545 {
9546 let mut fields__ = None;
9547 while let Some(k) = map_.next_key()? {
9548 match k {
9549 GeneratedField::Fields => {
9550 if fields__.is_some() {
9551 return Err(serde::de::Error::duplicate_field("fields"));
9552 }
9553 fields__ = Some(map_.next_value()?);
9554 }
9555 }
9556 }
9557 Ok(SinkAddColumns {
9558 fields: fields__.unwrap_or_default(),
9559 })
9560 }
9561 }
9562 deserializer.deserialize_struct("stream_plan.SinkAddColumns", FIELDS, GeneratedVisitor)
9563 }
9564}
9565impl serde::Serialize for SinkDesc {
9566 #[allow(deprecated)]
9567 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9568 where
9569 S: serde::Serializer,
9570 {
9571 use serde::ser::SerializeStruct;
9572 let mut len = 0;
9573 if self.id != 0 {
9574 len += 1;
9575 }
9576 if !self.name.is_empty() {
9577 len += 1;
9578 }
9579 if !self.definition.is_empty() {
9580 len += 1;
9581 }
9582 if !self.plan_pk.is_empty() {
9583 len += 1;
9584 }
9585 if !self.downstream_pk.is_empty() {
9586 len += 1;
9587 }
9588 if !self.distribution_key.is_empty() {
9589 len += 1;
9590 }
9591 if !self.properties.is_empty() {
9592 len += 1;
9593 }
9594 if self.sink_type != 0 {
9595 len += 1;
9596 }
9597 if !self.column_catalogs.is_empty() {
9598 len += 1;
9599 }
9600 if !self.db_name.is_empty() {
9601 len += 1;
9602 }
9603 if !self.sink_from_name.is_empty() {
9604 len += 1;
9605 }
9606 if self.format_desc.is_some() {
9607 len += 1;
9608 }
9609 if self.target_table.is_some() {
9610 len += 1;
9611 }
9612 if self.extra_partition_col_idx.is_some() {
9613 len += 1;
9614 }
9615 if !self.secret_refs.is_empty() {
9616 len += 1;
9617 }
9618 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDesc", len)?;
9619 if self.id != 0 {
9620 struct_ser.serialize_field("id", &self.id)?;
9621 }
9622 if !self.name.is_empty() {
9623 struct_ser.serialize_field("name", &self.name)?;
9624 }
9625 if !self.definition.is_empty() {
9626 struct_ser.serialize_field("definition", &self.definition)?;
9627 }
9628 if !self.plan_pk.is_empty() {
9629 struct_ser.serialize_field("planPk", &self.plan_pk)?;
9630 }
9631 if !self.downstream_pk.is_empty() {
9632 struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
9633 }
9634 if !self.distribution_key.is_empty() {
9635 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
9636 }
9637 if !self.properties.is_empty() {
9638 struct_ser.serialize_field("properties", &self.properties)?;
9639 }
9640 if self.sink_type != 0 {
9641 let v = super::catalog::SinkType::try_from(self.sink_type)
9642 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
9643 struct_ser.serialize_field("sinkType", &v)?;
9644 }
9645 if !self.column_catalogs.is_empty() {
9646 struct_ser.serialize_field("columnCatalogs", &self.column_catalogs)?;
9647 }
9648 if !self.db_name.is_empty() {
9649 struct_ser.serialize_field("dbName", &self.db_name)?;
9650 }
9651 if !self.sink_from_name.is_empty() {
9652 struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
9653 }
9654 if let Some(v) = self.format_desc.as_ref() {
9655 struct_ser.serialize_field("formatDesc", v)?;
9656 }
9657 if let Some(v) = self.target_table.as_ref() {
9658 struct_ser.serialize_field("targetTable", v)?;
9659 }
9660 if let Some(v) = self.extra_partition_col_idx.as_ref() {
9661 #[allow(clippy::needless_borrow)]
9662 #[allow(clippy::needless_borrows_for_generic_args)]
9663 struct_ser.serialize_field("extraPartitionColIdx", ToString::to_string(&v).as_str())?;
9664 }
9665 if !self.secret_refs.is_empty() {
9666 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
9667 }
9668 struct_ser.end()
9669 }
9670}
9671impl<'de> serde::Deserialize<'de> for SinkDesc {
9672 #[allow(deprecated)]
9673 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9674 where
9675 D: serde::Deserializer<'de>,
9676 {
9677 const FIELDS: &[&str] = &[
9678 "id",
9679 "name",
9680 "definition",
9681 "plan_pk",
9682 "planPk",
9683 "downstream_pk",
9684 "downstreamPk",
9685 "distribution_key",
9686 "distributionKey",
9687 "properties",
9688 "sink_type",
9689 "sinkType",
9690 "column_catalogs",
9691 "columnCatalogs",
9692 "db_name",
9693 "dbName",
9694 "sink_from_name",
9695 "sinkFromName",
9696 "format_desc",
9697 "formatDesc",
9698 "target_table",
9699 "targetTable",
9700 "extra_partition_col_idx",
9701 "extraPartitionColIdx",
9702 "secret_refs",
9703 "secretRefs",
9704 ];
9705
9706 #[allow(clippy::enum_variant_names)]
9707 enum GeneratedField {
9708 Id,
9709 Name,
9710 Definition,
9711 PlanPk,
9712 DownstreamPk,
9713 DistributionKey,
9714 Properties,
9715 SinkType,
9716 ColumnCatalogs,
9717 DbName,
9718 SinkFromName,
9719 FormatDesc,
9720 TargetTable,
9721 ExtraPartitionColIdx,
9722 SecretRefs,
9723 }
9724 impl<'de> serde::Deserialize<'de> for GeneratedField {
9725 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9726 where
9727 D: serde::Deserializer<'de>,
9728 {
9729 struct GeneratedVisitor;
9730
9731 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9732 type Value = GeneratedField;
9733
9734 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9735 write!(formatter, "expected one of: {:?}", &FIELDS)
9736 }
9737
9738 #[allow(unused_variables)]
9739 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9740 where
9741 E: serde::de::Error,
9742 {
9743 match value {
9744 "id" => Ok(GeneratedField::Id),
9745 "name" => Ok(GeneratedField::Name),
9746 "definition" => Ok(GeneratedField::Definition),
9747 "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
9748 "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
9749 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
9750 "properties" => Ok(GeneratedField::Properties),
9751 "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
9752 "columnCatalogs" | "column_catalogs" => Ok(GeneratedField::ColumnCatalogs),
9753 "dbName" | "db_name" => Ok(GeneratedField::DbName),
9754 "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
9755 "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
9756 "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
9757 "extraPartitionColIdx" | "extra_partition_col_idx" => Ok(GeneratedField::ExtraPartitionColIdx),
9758 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
9759 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9760 }
9761 }
9762 }
9763 deserializer.deserialize_identifier(GeneratedVisitor)
9764 }
9765 }
9766 struct GeneratedVisitor;
9767 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9768 type Value = SinkDesc;
9769
9770 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9771 formatter.write_str("struct stream_plan.SinkDesc")
9772 }
9773
9774 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDesc, V::Error>
9775 where
9776 V: serde::de::MapAccess<'de>,
9777 {
9778 let mut id__ = None;
9779 let mut name__ = None;
9780 let mut definition__ = None;
9781 let mut plan_pk__ = None;
9782 let mut downstream_pk__ = None;
9783 let mut distribution_key__ = None;
9784 let mut properties__ = None;
9785 let mut sink_type__ = None;
9786 let mut column_catalogs__ = None;
9787 let mut db_name__ = None;
9788 let mut sink_from_name__ = None;
9789 let mut format_desc__ = None;
9790 let mut target_table__ = None;
9791 let mut extra_partition_col_idx__ = None;
9792 let mut secret_refs__ = None;
9793 while let Some(k) = map_.next_key()? {
9794 match k {
9795 GeneratedField::Id => {
9796 if id__.is_some() {
9797 return Err(serde::de::Error::duplicate_field("id"));
9798 }
9799 id__ =
9800 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9801 ;
9802 }
9803 GeneratedField::Name => {
9804 if name__.is_some() {
9805 return Err(serde::de::Error::duplicate_field("name"));
9806 }
9807 name__ = Some(map_.next_value()?);
9808 }
9809 GeneratedField::Definition => {
9810 if definition__.is_some() {
9811 return Err(serde::de::Error::duplicate_field("definition"));
9812 }
9813 definition__ = Some(map_.next_value()?);
9814 }
9815 GeneratedField::PlanPk => {
9816 if plan_pk__.is_some() {
9817 return Err(serde::de::Error::duplicate_field("planPk"));
9818 }
9819 plan_pk__ = Some(map_.next_value()?);
9820 }
9821 GeneratedField::DownstreamPk => {
9822 if downstream_pk__.is_some() {
9823 return Err(serde::de::Error::duplicate_field("downstreamPk"));
9824 }
9825 downstream_pk__ =
9826 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9827 .into_iter().map(|x| x.0).collect())
9828 ;
9829 }
9830 GeneratedField::DistributionKey => {
9831 if distribution_key__.is_some() {
9832 return Err(serde::de::Error::duplicate_field("distributionKey"));
9833 }
9834 distribution_key__ =
9835 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9836 .into_iter().map(|x| x.0).collect())
9837 ;
9838 }
9839 GeneratedField::Properties => {
9840 if properties__.is_some() {
9841 return Err(serde::de::Error::duplicate_field("properties"));
9842 }
9843 properties__ = Some(
9844 map_.next_value::<std::collections::BTreeMap<_, _>>()?
9845 );
9846 }
9847 GeneratedField::SinkType => {
9848 if sink_type__.is_some() {
9849 return Err(serde::de::Error::duplicate_field("sinkType"));
9850 }
9851 sink_type__ = Some(map_.next_value::<super::catalog::SinkType>()? as i32);
9852 }
9853 GeneratedField::ColumnCatalogs => {
9854 if column_catalogs__.is_some() {
9855 return Err(serde::de::Error::duplicate_field("columnCatalogs"));
9856 }
9857 column_catalogs__ = Some(map_.next_value()?);
9858 }
9859 GeneratedField::DbName => {
9860 if db_name__.is_some() {
9861 return Err(serde::de::Error::duplicate_field("dbName"));
9862 }
9863 db_name__ = Some(map_.next_value()?);
9864 }
9865 GeneratedField::SinkFromName => {
9866 if sink_from_name__.is_some() {
9867 return Err(serde::de::Error::duplicate_field("sinkFromName"));
9868 }
9869 sink_from_name__ = Some(map_.next_value()?);
9870 }
9871 GeneratedField::FormatDesc => {
9872 if format_desc__.is_some() {
9873 return Err(serde::de::Error::duplicate_field("formatDesc"));
9874 }
9875 format_desc__ = map_.next_value()?;
9876 }
9877 GeneratedField::TargetTable => {
9878 if target_table__.is_some() {
9879 return Err(serde::de::Error::duplicate_field("targetTable"));
9880 }
9881 target_table__ =
9882 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9883 ;
9884 }
9885 GeneratedField::ExtraPartitionColIdx => {
9886 if extra_partition_col_idx__.is_some() {
9887 return Err(serde::de::Error::duplicate_field("extraPartitionColIdx"));
9888 }
9889 extra_partition_col_idx__ =
9890 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9891 ;
9892 }
9893 GeneratedField::SecretRefs => {
9894 if secret_refs__.is_some() {
9895 return Err(serde::de::Error::duplicate_field("secretRefs"));
9896 }
9897 secret_refs__ = Some(
9898 map_.next_value::<std::collections::BTreeMap<_, _>>()?
9899 );
9900 }
9901 }
9902 }
9903 Ok(SinkDesc {
9904 id: id__.unwrap_or_default(),
9905 name: name__.unwrap_or_default(),
9906 definition: definition__.unwrap_or_default(),
9907 plan_pk: plan_pk__.unwrap_or_default(),
9908 downstream_pk: downstream_pk__.unwrap_or_default(),
9909 distribution_key: distribution_key__.unwrap_or_default(),
9910 properties: properties__.unwrap_or_default(),
9911 sink_type: sink_type__.unwrap_or_default(),
9912 column_catalogs: column_catalogs__.unwrap_or_default(),
9913 db_name: db_name__.unwrap_or_default(),
9914 sink_from_name: sink_from_name__.unwrap_or_default(),
9915 format_desc: format_desc__,
9916 target_table: target_table__,
9917 extra_partition_col_idx: extra_partition_col_idx__,
9918 secret_refs: secret_refs__.unwrap_or_default(),
9919 })
9920 }
9921 }
9922 deserializer.deserialize_struct("stream_plan.SinkDesc", FIELDS, GeneratedVisitor)
9923 }
9924}
9925impl serde::Serialize for SinkLogStoreType {
9926 #[allow(deprecated)]
9927 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9928 where
9929 S: serde::Serializer,
9930 {
9931 let variant = match self {
9932 Self::Unspecified => "SINK_LOG_STORE_TYPE_UNSPECIFIED",
9933 Self::KvLogStore => "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
9934 Self::InMemoryLogStore => "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
9935 };
9936 serializer.serialize_str(variant)
9937 }
9938}
9939impl<'de> serde::Deserialize<'de> for SinkLogStoreType {
9940 #[allow(deprecated)]
9941 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9942 where
9943 D: serde::Deserializer<'de>,
9944 {
9945 const FIELDS: &[&str] = &[
9946 "SINK_LOG_STORE_TYPE_UNSPECIFIED",
9947 "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
9948 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
9949 ];
9950
9951 struct GeneratedVisitor;
9952
9953 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9954 type Value = SinkLogStoreType;
9955
9956 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9957 write!(formatter, "expected one of: {:?}", &FIELDS)
9958 }
9959
9960 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9961 where
9962 E: serde::de::Error,
9963 {
9964 i32::try_from(v)
9965 .ok()
9966 .and_then(|x| x.try_into().ok())
9967 .ok_or_else(|| {
9968 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9969 })
9970 }
9971
9972 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9973 where
9974 E: serde::de::Error,
9975 {
9976 i32::try_from(v)
9977 .ok()
9978 .and_then(|x| x.try_into().ok())
9979 .ok_or_else(|| {
9980 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9981 })
9982 }
9983
9984 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9985 where
9986 E: serde::de::Error,
9987 {
9988 match value {
9989 "SINK_LOG_STORE_TYPE_UNSPECIFIED" => Ok(SinkLogStoreType::Unspecified),
9990 "SINK_LOG_STORE_TYPE_KV_LOG_STORE" => Ok(SinkLogStoreType::KvLogStore),
9991 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE" => Ok(SinkLogStoreType::InMemoryLogStore),
9992 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9993 }
9994 }
9995 }
9996 deserializer.deserialize_any(GeneratedVisitor)
9997 }
9998}
9999impl serde::Serialize for SinkNode {
10000 #[allow(deprecated)]
10001 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10002 where
10003 S: serde::Serializer,
10004 {
10005 use serde::ser::SerializeStruct;
10006 let mut len = 0;
10007 if self.sink_desc.is_some() {
10008 len += 1;
10009 }
10010 if self.table.is_some() {
10011 len += 1;
10012 }
10013 if self.log_store_type != 0 {
10014 len += 1;
10015 }
10016 if self.rate_limit.is_some() {
10017 len += 1;
10018 }
10019 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkNode", len)?;
10020 if let Some(v) = self.sink_desc.as_ref() {
10021 struct_ser.serialize_field("sinkDesc", v)?;
10022 }
10023 if let Some(v) = self.table.as_ref() {
10024 struct_ser.serialize_field("table", v)?;
10025 }
10026 if self.log_store_type != 0 {
10027 let v = SinkLogStoreType::try_from(self.log_store_type)
10028 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.log_store_type)))?;
10029 struct_ser.serialize_field("logStoreType", &v)?;
10030 }
10031 if let Some(v) = self.rate_limit.as_ref() {
10032 struct_ser.serialize_field("rateLimit", v)?;
10033 }
10034 struct_ser.end()
10035 }
10036}
10037impl<'de> serde::Deserialize<'de> for SinkNode {
10038 #[allow(deprecated)]
10039 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10040 where
10041 D: serde::Deserializer<'de>,
10042 {
10043 const FIELDS: &[&str] = &[
10044 "sink_desc",
10045 "sinkDesc",
10046 "table",
10047 "log_store_type",
10048 "logStoreType",
10049 "rate_limit",
10050 "rateLimit",
10051 ];
10052
10053 #[allow(clippy::enum_variant_names)]
10054 enum GeneratedField {
10055 SinkDesc,
10056 Table,
10057 LogStoreType,
10058 RateLimit,
10059 }
10060 impl<'de> serde::Deserialize<'de> for GeneratedField {
10061 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10062 where
10063 D: serde::Deserializer<'de>,
10064 {
10065 struct GeneratedVisitor;
10066
10067 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10068 type Value = GeneratedField;
10069
10070 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10071 write!(formatter, "expected one of: {:?}", &FIELDS)
10072 }
10073
10074 #[allow(unused_variables)]
10075 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10076 where
10077 E: serde::de::Error,
10078 {
10079 match value {
10080 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
10081 "table" => Ok(GeneratedField::Table),
10082 "logStoreType" | "log_store_type" => Ok(GeneratedField::LogStoreType),
10083 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
10084 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10085 }
10086 }
10087 }
10088 deserializer.deserialize_identifier(GeneratedVisitor)
10089 }
10090 }
10091 struct GeneratedVisitor;
10092 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10093 type Value = SinkNode;
10094
10095 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10096 formatter.write_str("struct stream_plan.SinkNode")
10097 }
10098
10099 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkNode, V::Error>
10100 where
10101 V: serde::de::MapAccess<'de>,
10102 {
10103 let mut sink_desc__ = None;
10104 let mut table__ = None;
10105 let mut log_store_type__ = None;
10106 let mut rate_limit__ = None;
10107 while let Some(k) = map_.next_key()? {
10108 match k {
10109 GeneratedField::SinkDesc => {
10110 if sink_desc__.is_some() {
10111 return Err(serde::de::Error::duplicate_field("sinkDesc"));
10112 }
10113 sink_desc__ = map_.next_value()?;
10114 }
10115 GeneratedField::Table => {
10116 if table__.is_some() {
10117 return Err(serde::de::Error::duplicate_field("table"));
10118 }
10119 table__ = map_.next_value()?;
10120 }
10121 GeneratedField::LogStoreType => {
10122 if log_store_type__.is_some() {
10123 return Err(serde::de::Error::duplicate_field("logStoreType"));
10124 }
10125 log_store_type__ = Some(map_.next_value::<SinkLogStoreType>()? as i32);
10126 }
10127 GeneratedField::RateLimit => {
10128 if rate_limit__.is_some() {
10129 return Err(serde::de::Error::duplicate_field("rateLimit"));
10130 }
10131 rate_limit__ =
10132 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10133 ;
10134 }
10135 }
10136 }
10137 Ok(SinkNode {
10138 sink_desc: sink_desc__,
10139 table: table__,
10140 log_store_type: log_store_type__.unwrap_or_default(),
10141 rate_limit: rate_limit__,
10142 })
10143 }
10144 }
10145 deserializer.deserialize_struct("stream_plan.SinkNode", FIELDS, GeneratedVisitor)
10146 }
10147}
10148impl serde::Serialize for SortNode {
10149 #[allow(deprecated)]
10150 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10151 where
10152 S: serde::Serializer,
10153 {
10154 use serde::ser::SerializeStruct;
10155 let mut len = 0;
10156 if self.state_table.is_some() {
10157 len += 1;
10158 }
10159 if self.sort_column_index != 0 {
10160 len += 1;
10161 }
10162 let mut struct_ser = serializer.serialize_struct("stream_plan.SortNode", len)?;
10163 if let Some(v) = self.state_table.as_ref() {
10164 struct_ser.serialize_field("stateTable", v)?;
10165 }
10166 if self.sort_column_index != 0 {
10167 struct_ser.serialize_field("sortColumnIndex", &self.sort_column_index)?;
10168 }
10169 struct_ser.end()
10170 }
10171}
10172impl<'de> serde::Deserialize<'de> for SortNode {
10173 #[allow(deprecated)]
10174 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10175 where
10176 D: serde::Deserializer<'de>,
10177 {
10178 const FIELDS: &[&str] = &[
10179 "state_table",
10180 "stateTable",
10181 "sort_column_index",
10182 "sortColumnIndex",
10183 ];
10184
10185 #[allow(clippy::enum_variant_names)]
10186 enum GeneratedField {
10187 StateTable,
10188 SortColumnIndex,
10189 }
10190 impl<'de> serde::Deserialize<'de> for GeneratedField {
10191 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10192 where
10193 D: serde::Deserializer<'de>,
10194 {
10195 struct GeneratedVisitor;
10196
10197 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10198 type Value = GeneratedField;
10199
10200 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10201 write!(formatter, "expected one of: {:?}", &FIELDS)
10202 }
10203
10204 #[allow(unused_variables)]
10205 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10206 where
10207 E: serde::de::Error,
10208 {
10209 match value {
10210 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
10211 "sortColumnIndex" | "sort_column_index" => Ok(GeneratedField::SortColumnIndex),
10212 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10213 }
10214 }
10215 }
10216 deserializer.deserialize_identifier(GeneratedVisitor)
10217 }
10218 }
10219 struct GeneratedVisitor;
10220 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10221 type Value = SortNode;
10222
10223 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10224 formatter.write_str("struct stream_plan.SortNode")
10225 }
10226
10227 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
10228 where
10229 V: serde::de::MapAccess<'de>,
10230 {
10231 let mut state_table__ = None;
10232 let mut sort_column_index__ = None;
10233 while let Some(k) = map_.next_key()? {
10234 match k {
10235 GeneratedField::StateTable => {
10236 if state_table__.is_some() {
10237 return Err(serde::de::Error::duplicate_field("stateTable"));
10238 }
10239 state_table__ = map_.next_value()?;
10240 }
10241 GeneratedField::SortColumnIndex => {
10242 if sort_column_index__.is_some() {
10243 return Err(serde::de::Error::duplicate_field("sortColumnIndex"));
10244 }
10245 sort_column_index__ =
10246 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10247 ;
10248 }
10249 }
10250 }
10251 Ok(SortNode {
10252 state_table: state_table__,
10253 sort_column_index: sort_column_index__.unwrap_or_default(),
10254 })
10255 }
10256 }
10257 deserializer.deserialize_struct("stream_plan.SortNode", FIELDS, GeneratedVisitor)
10258 }
10259}
10260impl serde::Serialize for SourceBackfillNode {
10261 #[allow(deprecated)]
10262 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10263 where
10264 S: serde::Serializer,
10265 {
10266 use serde::ser::SerializeStruct;
10267 let mut len = 0;
10268 if self.upstream_source_id != 0 {
10269 len += 1;
10270 }
10271 if self.row_id_index.is_some() {
10272 len += 1;
10273 }
10274 if !self.columns.is_empty() {
10275 len += 1;
10276 }
10277 if self.info.is_some() {
10278 len += 1;
10279 }
10280 if !self.source_name.is_empty() {
10281 len += 1;
10282 }
10283 if !self.with_properties.is_empty() {
10284 len += 1;
10285 }
10286 if self.rate_limit.is_some() {
10287 len += 1;
10288 }
10289 if self.state_table.is_some() {
10290 len += 1;
10291 }
10292 if !self.secret_refs.is_empty() {
10293 len += 1;
10294 }
10295 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceBackfillNode", len)?;
10296 if self.upstream_source_id != 0 {
10297 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
10298 }
10299 if let Some(v) = self.row_id_index.as_ref() {
10300 struct_ser.serialize_field("rowIdIndex", v)?;
10301 }
10302 if !self.columns.is_empty() {
10303 struct_ser.serialize_field("columns", &self.columns)?;
10304 }
10305 if let Some(v) = self.info.as_ref() {
10306 struct_ser.serialize_field("info", v)?;
10307 }
10308 if !self.source_name.is_empty() {
10309 struct_ser.serialize_field("sourceName", &self.source_name)?;
10310 }
10311 if !self.with_properties.is_empty() {
10312 struct_ser.serialize_field("withProperties", &self.with_properties)?;
10313 }
10314 if let Some(v) = self.rate_limit.as_ref() {
10315 struct_ser.serialize_field("rateLimit", v)?;
10316 }
10317 if let Some(v) = self.state_table.as_ref() {
10318 struct_ser.serialize_field("stateTable", v)?;
10319 }
10320 if !self.secret_refs.is_empty() {
10321 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
10322 }
10323 struct_ser.end()
10324 }
10325}
10326impl<'de> serde::Deserialize<'de> for SourceBackfillNode {
10327 #[allow(deprecated)]
10328 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10329 where
10330 D: serde::Deserializer<'de>,
10331 {
10332 const FIELDS: &[&str] = &[
10333 "upstream_source_id",
10334 "upstreamSourceId",
10335 "row_id_index",
10336 "rowIdIndex",
10337 "columns",
10338 "info",
10339 "source_name",
10340 "sourceName",
10341 "with_properties",
10342 "withProperties",
10343 "rate_limit",
10344 "rateLimit",
10345 "state_table",
10346 "stateTable",
10347 "secret_refs",
10348 "secretRefs",
10349 ];
10350
10351 #[allow(clippy::enum_variant_names)]
10352 enum GeneratedField {
10353 UpstreamSourceId,
10354 RowIdIndex,
10355 Columns,
10356 Info,
10357 SourceName,
10358 WithProperties,
10359 RateLimit,
10360 StateTable,
10361 SecretRefs,
10362 }
10363 impl<'de> serde::Deserialize<'de> for GeneratedField {
10364 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10365 where
10366 D: serde::Deserializer<'de>,
10367 {
10368 struct GeneratedVisitor;
10369
10370 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10371 type Value = GeneratedField;
10372
10373 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10374 write!(formatter, "expected one of: {:?}", &FIELDS)
10375 }
10376
10377 #[allow(unused_variables)]
10378 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10379 where
10380 E: serde::de::Error,
10381 {
10382 match value {
10383 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
10384 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
10385 "columns" => Ok(GeneratedField::Columns),
10386 "info" => Ok(GeneratedField::Info),
10387 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
10388 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
10389 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
10390 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
10391 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
10392 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10393 }
10394 }
10395 }
10396 deserializer.deserialize_identifier(GeneratedVisitor)
10397 }
10398 }
10399 struct GeneratedVisitor;
10400 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10401 type Value = SourceBackfillNode;
10402
10403 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10404 formatter.write_str("struct stream_plan.SourceBackfillNode")
10405 }
10406
10407 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceBackfillNode, V::Error>
10408 where
10409 V: serde::de::MapAccess<'de>,
10410 {
10411 let mut upstream_source_id__ = None;
10412 let mut row_id_index__ = None;
10413 let mut columns__ = None;
10414 let mut info__ = None;
10415 let mut source_name__ = None;
10416 let mut with_properties__ = None;
10417 let mut rate_limit__ = None;
10418 let mut state_table__ = None;
10419 let mut secret_refs__ = None;
10420 while let Some(k) = map_.next_key()? {
10421 match k {
10422 GeneratedField::UpstreamSourceId => {
10423 if upstream_source_id__.is_some() {
10424 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
10425 }
10426 upstream_source_id__ =
10427 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10428 ;
10429 }
10430 GeneratedField::RowIdIndex => {
10431 if row_id_index__.is_some() {
10432 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
10433 }
10434 row_id_index__ =
10435 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10436 ;
10437 }
10438 GeneratedField::Columns => {
10439 if columns__.is_some() {
10440 return Err(serde::de::Error::duplicate_field("columns"));
10441 }
10442 columns__ = Some(map_.next_value()?);
10443 }
10444 GeneratedField::Info => {
10445 if info__.is_some() {
10446 return Err(serde::de::Error::duplicate_field("info"));
10447 }
10448 info__ = map_.next_value()?;
10449 }
10450 GeneratedField::SourceName => {
10451 if source_name__.is_some() {
10452 return Err(serde::de::Error::duplicate_field("sourceName"));
10453 }
10454 source_name__ = Some(map_.next_value()?);
10455 }
10456 GeneratedField::WithProperties => {
10457 if with_properties__.is_some() {
10458 return Err(serde::de::Error::duplicate_field("withProperties"));
10459 }
10460 with_properties__ = Some(
10461 map_.next_value::<std::collections::BTreeMap<_, _>>()?
10462 );
10463 }
10464 GeneratedField::RateLimit => {
10465 if rate_limit__.is_some() {
10466 return Err(serde::de::Error::duplicate_field("rateLimit"));
10467 }
10468 rate_limit__ =
10469 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10470 ;
10471 }
10472 GeneratedField::StateTable => {
10473 if state_table__.is_some() {
10474 return Err(serde::de::Error::duplicate_field("stateTable"));
10475 }
10476 state_table__ = map_.next_value()?;
10477 }
10478 GeneratedField::SecretRefs => {
10479 if secret_refs__.is_some() {
10480 return Err(serde::de::Error::duplicate_field("secretRefs"));
10481 }
10482 secret_refs__ = Some(
10483 map_.next_value::<std::collections::BTreeMap<_, _>>()?
10484 );
10485 }
10486 }
10487 }
10488 Ok(SourceBackfillNode {
10489 upstream_source_id: upstream_source_id__.unwrap_or_default(),
10490 row_id_index: row_id_index__,
10491 columns: columns__.unwrap_or_default(),
10492 info: info__,
10493 source_name: source_name__.unwrap_or_default(),
10494 with_properties: with_properties__.unwrap_or_default(),
10495 rate_limit: rate_limit__,
10496 state_table: state_table__,
10497 secret_refs: secret_refs__.unwrap_or_default(),
10498 })
10499 }
10500 }
10501 deserializer.deserialize_struct("stream_plan.SourceBackfillNode", FIELDS, GeneratedVisitor)
10502 }
10503}
10504impl serde::Serialize for SourceChangeSplitMutation {
10505 #[allow(deprecated)]
10506 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10507 where
10508 S: serde::Serializer,
10509 {
10510 use serde::ser::SerializeStruct;
10511 let mut len = 0;
10512 if !self.actor_splits.is_empty() {
10513 len += 1;
10514 }
10515 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceChangeSplitMutation", len)?;
10516 if !self.actor_splits.is_empty() {
10517 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
10518 }
10519 struct_ser.end()
10520 }
10521}
10522impl<'de> serde::Deserialize<'de> for SourceChangeSplitMutation {
10523 #[allow(deprecated)]
10524 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10525 where
10526 D: serde::Deserializer<'de>,
10527 {
10528 const FIELDS: &[&str] = &[
10529 "actor_splits",
10530 "actorSplits",
10531 ];
10532
10533 #[allow(clippy::enum_variant_names)]
10534 enum GeneratedField {
10535 ActorSplits,
10536 }
10537 impl<'de> serde::Deserialize<'de> for GeneratedField {
10538 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10539 where
10540 D: serde::Deserializer<'de>,
10541 {
10542 struct GeneratedVisitor;
10543
10544 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10545 type Value = GeneratedField;
10546
10547 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10548 write!(formatter, "expected one of: {:?}", &FIELDS)
10549 }
10550
10551 #[allow(unused_variables)]
10552 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10553 where
10554 E: serde::de::Error,
10555 {
10556 match value {
10557 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
10558 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10559 }
10560 }
10561 }
10562 deserializer.deserialize_identifier(GeneratedVisitor)
10563 }
10564 }
10565 struct GeneratedVisitor;
10566 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10567 type Value = SourceChangeSplitMutation;
10568
10569 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10570 formatter.write_str("struct stream_plan.SourceChangeSplitMutation")
10571 }
10572
10573 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceChangeSplitMutation, V::Error>
10574 where
10575 V: serde::de::MapAccess<'de>,
10576 {
10577 let mut actor_splits__ = None;
10578 while let Some(k) = map_.next_key()? {
10579 match k {
10580 GeneratedField::ActorSplits => {
10581 if actor_splits__.is_some() {
10582 return Err(serde::de::Error::duplicate_field("actorSplits"));
10583 }
10584 actor_splits__ = Some(
10585 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10586 .into_iter().map(|(k,v)| (k.0, v)).collect()
10587 );
10588 }
10589 }
10590 }
10591 Ok(SourceChangeSplitMutation {
10592 actor_splits: actor_splits__.unwrap_or_default(),
10593 })
10594 }
10595 }
10596 deserializer.deserialize_struct("stream_plan.SourceChangeSplitMutation", FIELDS, GeneratedVisitor)
10597 }
10598}
10599impl serde::Serialize for SourceNode {
10600 #[allow(deprecated)]
10601 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10602 where
10603 S: serde::Serializer,
10604 {
10605 use serde::ser::SerializeStruct;
10606 let mut len = 0;
10607 if self.source_inner.is_some() {
10608 len += 1;
10609 }
10610 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceNode", len)?;
10611 if let Some(v) = self.source_inner.as_ref() {
10612 struct_ser.serialize_field("sourceInner", v)?;
10613 }
10614 struct_ser.end()
10615 }
10616}
10617impl<'de> serde::Deserialize<'de> for SourceNode {
10618 #[allow(deprecated)]
10619 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10620 where
10621 D: serde::Deserializer<'de>,
10622 {
10623 const FIELDS: &[&str] = &[
10624 "source_inner",
10625 "sourceInner",
10626 ];
10627
10628 #[allow(clippy::enum_variant_names)]
10629 enum GeneratedField {
10630 SourceInner,
10631 }
10632 impl<'de> serde::Deserialize<'de> for GeneratedField {
10633 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10634 where
10635 D: serde::Deserializer<'de>,
10636 {
10637 struct GeneratedVisitor;
10638
10639 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10640 type Value = GeneratedField;
10641
10642 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10643 write!(formatter, "expected one of: {:?}", &FIELDS)
10644 }
10645
10646 #[allow(unused_variables)]
10647 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10648 where
10649 E: serde::de::Error,
10650 {
10651 match value {
10652 "sourceInner" | "source_inner" => Ok(GeneratedField::SourceInner),
10653 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10654 }
10655 }
10656 }
10657 deserializer.deserialize_identifier(GeneratedVisitor)
10658 }
10659 }
10660 struct GeneratedVisitor;
10661 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10662 type Value = SourceNode;
10663
10664 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10665 formatter.write_str("struct stream_plan.SourceNode")
10666 }
10667
10668 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
10669 where
10670 V: serde::de::MapAccess<'de>,
10671 {
10672 let mut source_inner__ = None;
10673 while let Some(k) = map_.next_key()? {
10674 match k {
10675 GeneratedField::SourceInner => {
10676 if source_inner__.is_some() {
10677 return Err(serde::de::Error::duplicate_field("sourceInner"));
10678 }
10679 source_inner__ = map_.next_value()?;
10680 }
10681 }
10682 }
10683 Ok(SourceNode {
10684 source_inner: source_inner__,
10685 })
10686 }
10687 }
10688 deserializer.deserialize_struct("stream_plan.SourceNode", FIELDS, GeneratedVisitor)
10689 }
10690}
10691impl serde::Serialize for StartFragmentBackfillMutation {
10692 #[allow(deprecated)]
10693 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10694 where
10695 S: serde::Serializer,
10696 {
10697 use serde::ser::SerializeStruct;
10698 let mut len = 0;
10699 if !self.fragment_ids.is_empty() {
10700 len += 1;
10701 }
10702 let mut struct_ser = serializer.serialize_struct("stream_plan.StartFragmentBackfillMutation", len)?;
10703 if !self.fragment_ids.is_empty() {
10704 struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
10705 }
10706 struct_ser.end()
10707 }
10708}
10709impl<'de> serde::Deserialize<'de> for StartFragmentBackfillMutation {
10710 #[allow(deprecated)]
10711 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10712 where
10713 D: serde::Deserializer<'de>,
10714 {
10715 const FIELDS: &[&str] = &[
10716 "fragment_ids",
10717 "fragmentIds",
10718 ];
10719
10720 #[allow(clippy::enum_variant_names)]
10721 enum GeneratedField {
10722 FragmentIds,
10723 }
10724 impl<'de> serde::Deserialize<'de> for GeneratedField {
10725 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10726 where
10727 D: serde::Deserializer<'de>,
10728 {
10729 struct GeneratedVisitor;
10730
10731 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10732 type Value = GeneratedField;
10733
10734 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10735 write!(formatter, "expected one of: {:?}", &FIELDS)
10736 }
10737
10738 #[allow(unused_variables)]
10739 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10740 where
10741 E: serde::de::Error,
10742 {
10743 match value {
10744 "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
10745 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10746 }
10747 }
10748 }
10749 deserializer.deserialize_identifier(GeneratedVisitor)
10750 }
10751 }
10752 struct GeneratedVisitor;
10753 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10754 type Value = StartFragmentBackfillMutation;
10755
10756 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10757 formatter.write_str("struct stream_plan.StartFragmentBackfillMutation")
10758 }
10759
10760 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StartFragmentBackfillMutation, V::Error>
10761 where
10762 V: serde::de::MapAccess<'de>,
10763 {
10764 let mut fragment_ids__ = None;
10765 while let Some(k) = map_.next_key()? {
10766 match k {
10767 GeneratedField::FragmentIds => {
10768 if fragment_ids__.is_some() {
10769 return Err(serde::de::Error::duplicate_field("fragmentIds"));
10770 }
10771 fragment_ids__ =
10772 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10773 .into_iter().map(|x| x.0).collect())
10774 ;
10775 }
10776 }
10777 }
10778 Ok(StartFragmentBackfillMutation {
10779 fragment_ids: fragment_ids__.unwrap_or_default(),
10780 })
10781 }
10782 }
10783 deserializer.deserialize_struct("stream_plan.StartFragmentBackfillMutation", FIELDS, GeneratedVisitor)
10784 }
10785}
10786impl serde::Serialize for StopMutation {
10787 #[allow(deprecated)]
10788 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10789 where
10790 S: serde::Serializer,
10791 {
10792 use serde::ser::SerializeStruct;
10793 let mut len = 0;
10794 if !self.actors.is_empty() {
10795 len += 1;
10796 }
10797 if !self.dropped_sink_fragments.is_empty() {
10798 len += 1;
10799 }
10800 let mut struct_ser = serializer.serialize_struct("stream_plan.StopMutation", len)?;
10801 if !self.actors.is_empty() {
10802 struct_ser.serialize_field("actors", &self.actors)?;
10803 }
10804 if !self.dropped_sink_fragments.is_empty() {
10805 struct_ser.serialize_field("droppedSinkFragments", &self.dropped_sink_fragments)?;
10806 }
10807 struct_ser.end()
10808 }
10809}
10810impl<'de> serde::Deserialize<'de> for StopMutation {
10811 #[allow(deprecated)]
10812 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10813 where
10814 D: serde::Deserializer<'de>,
10815 {
10816 const FIELDS: &[&str] = &[
10817 "actors",
10818 "dropped_sink_fragments",
10819 "droppedSinkFragments",
10820 ];
10821
10822 #[allow(clippy::enum_variant_names)]
10823 enum GeneratedField {
10824 Actors,
10825 DroppedSinkFragments,
10826 }
10827 impl<'de> serde::Deserialize<'de> for GeneratedField {
10828 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10829 where
10830 D: serde::Deserializer<'de>,
10831 {
10832 struct GeneratedVisitor;
10833
10834 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10835 type Value = GeneratedField;
10836
10837 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10838 write!(formatter, "expected one of: {:?}", &FIELDS)
10839 }
10840
10841 #[allow(unused_variables)]
10842 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10843 where
10844 E: serde::de::Error,
10845 {
10846 match value {
10847 "actors" => Ok(GeneratedField::Actors),
10848 "droppedSinkFragments" | "dropped_sink_fragments" => Ok(GeneratedField::DroppedSinkFragments),
10849 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10850 }
10851 }
10852 }
10853 deserializer.deserialize_identifier(GeneratedVisitor)
10854 }
10855 }
10856 struct GeneratedVisitor;
10857 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10858 type Value = StopMutation;
10859
10860 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10861 formatter.write_str("struct stream_plan.StopMutation")
10862 }
10863
10864 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopMutation, V::Error>
10865 where
10866 V: serde::de::MapAccess<'de>,
10867 {
10868 let mut actors__ = None;
10869 let mut dropped_sink_fragments__ = None;
10870 while let Some(k) = map_.next_key()? {
10871 match k {
10872 GeneratedField::Actors => {
10873 if actors__.is_some() {
10874 return Err(serde::de::Error::duplicate_field("actors"));
10875 }
10876 actors__ =
10877 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10878 .into_iter().map(|x| x.0).collect())
10879 ;
10880 }
10881 GeneratedField::DroppedSinkFragments => {
10882 if dropped_sink_fragments__.is_some() {
10883 return Err(serde::de::Error::duplicate_field("droppedSinkFragments"));
10884 }
10885 dropped_sink_fragments__ =
10886 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10887 .into_iter().map(|x| x.0).collect())
10888 ;
10889 }
10890 }
10891 }
10892 Ok(StopMutation {
10893 actors: actors__.unwrap_or_default(),
10894 dropped_sink_fragments: dropped_sink_fragments__.unwrap_or_default(),
10895 })
10896 }
10897 }
10898 deserializer.deserialize_struct("stream_plan.StopMutation", FIELDS, GeneratedVisitor)
10899 }
10900}
10901impl serde::Serialize for StreamActor {
10902 #[allow(deprecated)]
10903 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10904 where
10905 S: serde::Serializer,
10906 {
10907 use serde::ser::SerializeStruct;
10908 let mut len = 0;
10909 if self.actor_id != 0 {
10910 len += 1;
10911 }
10912 if self.fragment_id != 0 {
10913 len += 1;
10914 }
10915 if !self.dispatcher.is_empty() {
10916 len += 1;
10917 }
10918 if self.vnode_bitmap.is_some() {
10919 len += 1;
10920 }
10921 if !self.mview_definition.is_empty() {
10922 len += 1;
10923 }
10924 if self.expr_context.is_some() {
10925 len += 1;
10926 }
10927 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamActor", len)?;
10928 if self.actor_id != 0 {
10929 struct_ser.serialize_field("actorId", &self.actor_id)?;
10930 }
10931 if self.fragment_id != 0 {
10932 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
10933 }
10934 if !self.dispatcher.is_empty() {
10935 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
10936 }
10937 if let Some(v) = self.vnode_bitmap.as_ref() {
10938 struct_ser.serialize_field("vnodeBitmap", v)?;
10939 }
10940 if !self.mview_definition.is_empty() {
10941 struct_ser.serialize_field("mviewDefinition", &self.mview_definition)?;
10942 }
10943 if let Some(v) = self.expr_context.as_ref() {
10944 struct_ser.serialize_field("exprContext", v)?;
10945 }
10946 struct_ser.end()
10947 }
10948}
10949impl<'de> serde::Deserialize<'de> for StreamActor {
10950 #[allow(deprecated)]
10951 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10952 where
10953 D: serde::Deserializer<'de>,
10954 {
10955 const FIELDS: &[&str] = &[
10956 "actor_id",
10957 "actorId",
10958 "fragment_id",
10959 "fragmentId",
10960 "dispatcher",
10961 "vnode_bitmap",
10962 "vnodeBitmap",
10963 "mview_definition",
10964 "mviewDefinition",
10965 "expr_context",
10966 "exprContext",
10967 ];
10968
10969 #[allow(clippy::enum_variant_names)]
10970 enum GeneratedField {
10971 ActorId,
10972 FragmentId,
10973 Dispatcher,
10974 VnodeBitmap,
10975 MviewDefinition,
10976 ExprContext,
10977 }
10978 impl<'de> serde::Deserialize<'de> for GeneratedField {
10979 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10980 where
10981 D: serde::Deserializer<'de>,
10982 {
10983 struct GeneratedVisitor;
10984
10985 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10986 type Value = GeneratedField;
10987
10988 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10989 write!(formatter, "expected one of: {:?}", &FIELDS)
10990 }
10991
10992 #[allow(unused_variables)]
10993 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10994 where
10995 E: serde::de::Error,
10996 {
10997 match value {
10998 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
10999 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
11000 "dispatcher" => Ok(GeneratedField::Dispatcher),
11001 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
11002 "mviewDefinition" | "mview_definition" => Ok(GeneratedField::MviewDefinition),
11003 "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
11004 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11005 }
11006 }
11007 }
11008 deserializer.deserialize_identifier(GeneratedVisitor)
11009 }
11010 }
11011 struct GeneratedVisitor;
11012 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11013 type Value = StreamActor;
11014
11015 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11016 formatter.write_str("struct stream_plan.StreamActor")
11017 }
11018
11019 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamActor, V::Error>
11020 where
11021 V: serde::de::MapAccess<'de>,
11022 {
11023 let mut actor_id__ = None;
11024 let mut fragment_id__ = None;
11025 let mut dispatcher__ = None;
11026 let mut vnode_bitmap__ = None;
11027 let mut mview_definition__ = None;
11028 let mut expr_context__ = None;
11029 while let Some(k) = map_.next_key()? {
11030 match k {
11031 GeneratedField::ActorId => {
11032 if actor_id__.is_some() {
11033 return Err(serde::de::Error::duplicate_field("actorId"));
11034 }
11035 actor_id__ =
11036 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11037 ;
11038 }
11039 GeneratedField::FragmentId => {
11040 if fragment_id__.is_some() {
11041 return Err(serde::de::Error::duplicate_field("fragmentId"));
11042 }
11043 fragment_id__ =
11044 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11045 ;
11046 }
11047 GeneratedField::Dispatcher => {
11048 if dispatcher__.is_some() {
11049 return Err(serde::de::Error::duplicate_field("dispatcher"));
11050 }
11051 dispatcher__ = Some(map_.next_value()?);
11052 }
11053 GeneratedField::VnodeBitmap => {
11054 if vnode_bitmap__.is_some() {
11055 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
11056 }
11057 vnode_bitmap__ = map_.next_value()?;
11058 }
11059 GeneratedField::MviewDefinition => {
11060 if mview_definition__.is_some() {
11061 return Err(serde::de::Error::duplicate_field("mviewDefinition"));
11062 }
11063 mview_definition__ = Some(map_.next_value()?);
11064 }
11065 GeneratedField::ExprContext => {
11066 if expr_context__.is_some() {
11067 return Err(serde::de::Error::duplicate_field("exprContext"));
11068 }
11069 expr_context__ = map_.next_value()?;
11070 }
11071 }
11072 }
11073 Ok(StreamActor {
11074 actor_id: actor_id__.unwrap_or_default(),
11075 fragment_id: fragment_id__.unwrap_or_default(),
11076 dispatcher: dispatcher__.unwrap_or_default(),
11077 vnode_bitmap: vnode_bitmap__,
11078 mview_definition: mview_definition__.unwrap_or_default(),
11079 expr_context: expr_context__,
11080 })
11081 }
11082 }
11083 deserializer.deserialize_struct("stream_plan.StreamActor", FIELDS, GeneratedVisitor)
11084 }
11085}
11086impl serde::Serialize for StreamCdcScanNode {
11087 #[allow(deprecated)]
11088 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11089 where
11090 S: serde::Serializer,
11091 {
11092 use serde::ser::SerializeStruct;
11093 let mut len = 0;
11094 if self.table_id != 0 {
11095 len += 1;
11096 }
11097 if !self.upstream_column_ids.is_empty() {
11098 len += 1;
11099 }
11100 if !self.output_indices.is_empty() {
11101 len += 1;
11102 }
11103 if self.state_table.is_some() {
11104 len += 1;
11105 }
11106 if self.cdc_table_desc.is_some() {
11107 len += 1;
11108 }
11109 if self.rate_limit.is_some() {
11110 len += 1;
11111 }
11112 if self.disable_backfill {
11113 len += 1;
11114 }
11115 if self.options.is_some() {
11116 len += 1;
11117 }
11118 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanNode", len)?;
11119 if self.table_id != 0 {
11120 struct_ser.serialize_field("tableId", &self.table_id)?;
11121 }
11122 if !self.upstream_column_ids.is_empty() {
11123 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
11124 }
11125 if !self.output_indices.is_empty() {
11126 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
11127 }
11128 if let Some(v) = self.state_table.as_ref() {
11129 struct_ser.serialize_field("stateTable", v)?;
11130 }
11131 if let Some(v) = self.cdc_table_desc.as_ref() {
11132 struct_ser.serialize_field("cdcTableDesc", v)?;
11133 }
11134 if let Some(v) = self.rate_limit.as_ref() {
11135 struct_ser.serialize_field("rateLimit", v)?;
11136 }
11137 if self.disable_backfill {
11138 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
11139 }
11140 if let Some(v) = self.options.as_ref() {
11141 struct_ser.serialize_field("options", v)?;
11142 }
11143 struct_ser.end()
11144 }
11145}
11146impl<'de> serde::Deserialize<'de> for StreamCdcScanNode {
11147 #[allow(deprecated)]
11148 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11149 where
11150 D: serde::Deserializer<'de>,
11151 {
11152 const FIELDS: &[&str] = &[
11153 "table_id",
11154 "tableId",
11155 "upstream_column_ids",
11156 "upstreamColumnIds",
11157 "output_indices",
11158 "outputIndices",
11159 "state_table",
11160 "stateTable",
11161 "cdc_table_desc",
11162 "cdcTableDesc",
11163 "rate_limit",
11164 "rateLimit",
11165 "disable_backfill",
11166 "disableBackfill",
11167 "options",
11168 ];
11169
11170 #[allow(clippy::enum_variant_names)]
11171 enum GeneratedField {
11172 TableId,
11173 UpstreamColumnIds,
11174 OutputIndices,
11175 StateTable,
11176 CdcTableDesc,
11177 RateLimit,
11178 DisableBackfill,
11179 Options,
11180 }
11181 impl<'de> serde::Deserialize<'de> for GeneratedField {
11182 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11183 where
11184 D: serde::Deserializer<'de>,
11185 {
11186 struct GeneratedVisitor;
11187
11188 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11189 type Value = GeneratedField;
11190
11191 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11192 write!(formatter, "expected one of: {:?}", &FIELDS)
11193 }
11194
11195 #[allow(unused_variables)]
11196 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11197 where
11198 E: serde::de::Error,
11199 {
11200 match value {
11201 "tableId" | "table_id" => Ok(GeneratedField::TableId),
11202 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
11203 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
11204 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11205 "cdcTableDesc" | "cdc_table_desc" => Ok(GeneratedField::CdcTableDesc),
11206 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11207 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
11208 "options" => Ok(GeneratedField::Options),
11209 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11210 }
11211 }
11212 }
11213 deserializer.deserialize_identifier(GeneratedVisitor)
11214 }
11215 }
11216 struct GeneratedVisitor;
11217 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11218 type Value = StreamCdcScanNode;
11219
11220 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11221 formatter.write_str("struct stream_plan.StreamCdcScanNode")
11222 }
11223
11224 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanNode, V::Error>
11225 where
11226 V: serde::de::MapAccess<'de>,
11227 {
11228 let mut table_id__ = None;
11229 let mut upstream_column_ids__ = None;
11230 let mut output_indices__ = None;
11231 let mut state_table__ = None;
11232 let mut cdc_table_desc__ = None;
11233 let mut rate_limit__ = None;
11234 let mut disable_backfill__ = None;
11235 let mut options__ = None;
11236 while let Some(k) = map_.next_key()? {
11237 match k {
11238 GeneratedField::TableId => {
11239 if table_id__.is_some() {
11240 return Err(serde::de::Error::duplicate_field("tableId"));
11241 }
11242 table_id__ =
11243 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11244 ;
11245 }
11246 GeneratedField::UpstreamColumnIds => {
11247 if upstream_column_ids__.is_some() {
11248 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
11249 }
11250 upstream_column_ids__ =
11251 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11252 .into_iter().map(|x| x.0).collect())
11253 ;
11254 }
11255 GeneratedField::OutputIndices => {
11256 if output_indices__.is_some() {
11257 return Err(serde::de::Error::duplicate_field("outputIndices"));
11258 }
11259 output_indices__ =
11260 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11261 .into_iter().map(|x| x.0).collect())
11262 ;
11263 }
11264 GeneratedField::StateTable => {
11265 if state_table__.is_some() {
11266 return Err(serde::de::Error::duplicate_field("stateTable"));
11267 }
11268 state_table__ = map_.next_value()?;
11269 }
11270 GeneratedField::CdcTableDesc => {
11271 if cdc_table_desc__.is_some() {
11272 return Err(serde::de::Error::duplicate_field("cdcTableDesc"));
11273 }
11274 cdc_table_desc__ = map_.next_value()?;
11275 }
11276 GeneratedField::RateLimit => {
11277 if rate_limit__.is_some() {
11278 return Err(serde::de::Error::duplicate_field("rateLimit"));
11279 }
11280 rate_limit__ =
11281 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11282 ;
11283 }
11284 GeneratedField::DisableBackfill => {
11285 if disable_backfill__.is_some() {
11286 return Err(serde::de::Error::duplicate_field("disableBackfill"));
11287 }
11288 disable_backfill__ = Some(map_.next_value()?);
11289 }
11290 GeneratedField::Options => {
11291 if options__.is_some() {
11292 return Err(serde::de::Error::duplicate_field("options"));
11293 }
11294 options__ = map_.next_value()?;
11295 }
11296 }
11297 }
11298 Ok(StreamCdcScanNode {
11299 table_id: table_id__.unwrap_or_default(),
11300 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
11301 output_indices: output_indices__.unwrap_or_default(),
11302 state_table: state_table__,
11303 cdc_table_desc: cdc_table_desc__,
11304 rate_limit: rate_limit__,
11305 disable_backfill: disable_backfill__.unwrap_or_default(),
11306 options: options__,
11307 })
11308 }
11309 }
11310 deserializer.deserialize_struct("stream_plan.StreamCdcScanNode", FIELDS, GeneratedVisitor)
11311 }
11312}
11313impl serde::Serialize for StreamCdcScanOptions {
11314 #[allow(deprecated)]
11315 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11316 where
11317 S: serde::Serializer,
11318 {
11319 use serde::ser::SerializeStruct;
11320 let mut len = 0;
11321 if self.disable_backfill {
11322 len += 1;
11323 }
11324 if self.snapshot_barrier_interval != 0 {
11325 len += 1;
11326 }
11327 if self.snapshot_batch_size != 0 {
11328 len += 1;
11329 }
11330 if self.backfill_parallelism != 0 {
11331 len += 1;
11332 }
11333 if self.backfill_num_rows_per_split != 0 {
11334 len += 1;
11335 }
11336 if self.backfill_as_even_splits {
11337 len += 1;
11338 }
11339 if self.backfill_split_pk_column_index != 0 {
11340 len += 1;
11341 }
11342 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanOptions", len)?;
11343 if self.disable_backfill {
11344 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
11345 }
11346 if self.snapshot_barrier_interval != 0 {
11347 struct_ser.serialize_field("snapshotBarrierInterval", &self.snapshot_barrier_interval)?;
11348 }
11349 if self.snapshot_batch_size != 0 {
11350 struct_ser.serialize_field("snapshotBatchSize", &self.snapshot_batch_size)?;
11351 }
11352 if self.backfill_parallelism != 0 {
11353 struct_ser.serialize_field("backfillParallelism", &self.backfill_parallelism)?;
11354 }
11355 if self.backfill_num_rows_per_split != 0 {
11356 #[allow(clippy::needless_borrow)]
11357 #[allow(clippy::needless_borrows_for_generic_args)]
11358 struct_ser.serialize_field("backfillNumRowsPerSplit", ToString::to_string(&self.backfill_num_rows_per_split).as_str())?;
11359 }
11360 if self.backfill_as_even_splits {
11361 struct_ser.serialize_field("backfillAsEvenSplits", &self.backfill_as_even_splits)?;
11362 }
11363 if self.backfill_split_pk_column_index != 0 {
11364 struct_ser.serialize_field("backfillSplitPkColumnIndex", &self.backfill_split_pk_column_index)?;
11365 }
11366 struct_ser.end()
11367 }
11368}
11369impl<'de> serde::Deserialize<'de> for StreamCdcScanOptions {
11370 #[allow(deprecated)]
11371 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11372 where
11373 D: serde::Deserializer<'de>,
11374 {
11375 const FIELDS: &[&str] = &[
11376 "disable_backfill",
11377 "disableBackfill",
11378 "snapshot_barrier_interval",
11379 "snapshotBarrierInterval",
11380 "snapshot_batch_size",
11381 "snapshotBatchSize",
11382 "backfill_parallelism",
11383 "backfillParallelism",
11384 "backfill_num_rows_per_split",
11385 "backfillNumRowsPerSplit",
11386 "backfill_as_even_splits",
11387 "backfillAsEvenSplits",
11388 "backfill_split_pk_column_index",
11389 "backfillSplitPkColumnIndex",
11390 ];
11391
11392 #[allow(clippy::enum_variant_names)]
11393 enum GeneratedField {
11394 DisableBackfill,
11395 SnapshotBarrierInterval,
11396 SnapshotBatchSize,
11397 BackfillParallelism,
11398 BackfillNumRowsPerSplit,
11399 BackfillAsEvenSplits,
11400 BackfillSplitPkColumnIndex,
11401 }
11402 impl<'de> serde::Deserialize<'de> for GeneratedField {
11403 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11404 where
11405 D: serde::Deserializer<'de>,
11406 {
11407 struct GeneratedVisitor;
11408
11409 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11410 type Value = GeneratedField;
11411
11412 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11413 write!(formatter, "expected one of: {:?}", &FIELDS)
11414 }
11415
11416 #[allow(unused_variables)]
11417 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11418 where
11419 E: serde::de::Error,
11420 {
11421 match value {
11422 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
11423 "snapshotBarrierInterval" | "snapshot_barrier_interval" => Ok(GeneratedField::SnapshotBarrierInterval),
11424 "snapshotBatchSize" | "snapshot_batch_size" => Ok(GeneratedField::SnapshotBatchSize),
11425 "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
11426 "backfillNumRowsPerSplit" | "backfill_num_rows_per_split" => Ok(GeneratedField::BackfillNumRowsPerSplit),
11427 "backfillAsEvenSplits" | "backfill_as_even_splits" => Ok(GeneratedField::BackfillAsEvenSplits),
11428 "backfillSplitPkColumnIndex" | "backfill_split_pk_column_index" => Ok(GeneratedField::BackfillSplitPkColumnIndex),
11429 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11430 }
11431 }
11432 }
11433 deserializer.deserialize_identifier(GeneratedVisitor)
11434 }
11435 }
11436 struct GeneratedVisitor;
11437 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11438 type Value = StreamCdcScanOptions;
11439
11440 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11441 formatter.write_str("struct stream_plan.StreamCdcScanOptions")
11442 }
11443
11444 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanOptions, V::Error>
11445 where
11446 V: serde::de::MapAccess<'de>,
11447 {
11448 let mut disable_backfill__ = None;
11449 let mut snapshot_barrier_interval__ = None;
11450 let mut snapshot_batch_size__ = None;
11451 let mut backfill_parallelism__ = None;
11452 let mut backfill_num_rows_per_split__ = None;
11453 let mut backfill_as_even_splits__ = None;
11454 let mut backfill_split_pk_column_index__ = None;
11455 while let Some(k) = map_.next_key()? {
11456 match k {
11457 GeneratedField::DisableBackfill => {
11458 if disable_backfill__.is_some() {
11459 return Err(serde::de::Error::duplicate_field("disableBackfill"));
11460 }
11461 disable_backfill__ = Some(map_.next_value()?);
11462 }
11463 GeneratedField::SnapshotBarrierInterval => {
11464 if snapshot_barrier_interval__.is_some() {
11465 return Err(serde::de::Error::duplicate_field("snapshotBarrierInterval"));
11466 }
11467 snapshot_barrier_interval__ =
11468 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11469 ;
11470 }
11471 GeneratedField::SnapshotBatchSize => {
11472 if snapshot_batch_size__.is_some() {
11473 return Err(serde::de::Error::duplicate_field("snapshotBatchSize"));
11474 }
11475 snapshot_batch_size__ =
11476 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11477 ;
11478 }
11479 GeneratedField::BackfillParallelism => {
11480 if backfill_parallelism__.is_some() {
11481 return Err(serde::de::Error::duplicate_field("backfillParallelism"));
11482 }
11483 backfill_parallelism__ =
11484 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11485 ;
11486 }
11487 GeneratedField::BackfillNumRowsPerSplit => {
11488 if backfill_num_rows_per_split__.is_some() {
11489 return Err(serde::de::Error::duplicate_field("backfillNumRowsPerSplit"));
11490 }
11491 backfill_num_rows_per_split__ =
11492 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11493 ;
11494 }
11495 GeneratedField::BackfillAsEvenSplits => {
11496 if backfill_as_even_splits__.is_some() {
11497 return Err(serde::de::Error::duplicate_field("backfillAsEvenSplits"));
11498 }
11499 backfill_as_even_splits__ = Some(map_.next_value()?);
11500 }
11501 GeneratedField::BackfillSplitPkColumnIndex => {
11502 if backfill_split_pk_column_index__.is_some() {
11503 return Err(serde::de::Error::duplicate_field("backfillSplitPkColumnIndex"));
11504 }
11505 backfill_split_pk_column_index__ =
11506 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11507 ;
11508 }
11509 }
11510 }
11511 Ok(StreamCdcScanOptions {
11512 disable_backfill: disable_backfill__.unwrap_or_default(),
11513 snapshot_barrier_interval: snapshot_barrier_interval__.unwrap_or_default(),
11514 snapshot_batch_size: snapshot_batch_size__.unwrap_or_default(),
11515 backfill_parallelism: backfill_parallelism__.unwrap_or_default(),
11516 backfill_num_rows_per_split: backfill_num_rows_per_split__.unwrap_or_default(),
11517 backfill_as_even_splits: backfill_as_even_splits__.unwrap_or_default(),
11518 backfill_split_pk_column_index: backfill_split_pk_column_index__.unwrap_or_default(),
11519 })
11520 }
11521 }
11522 deserializer.deserialize_struct("stream_plan.StreamCdcScanOptions", FIELDS, GeneratedVisitor)
11523 }
11524}
11525impl serde::Serialize for StreamContext {
11526 #[allow(deprecated)]
11527 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11528 where
11529 S: serde::Serializer,
11530 {
11531 use serde::ser::SerializeStruct;
11532 let mut len = 0;
11533 if !self.timezone.is_empty() {
11534 len += 1;
11535 }
11536 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamContext", len)?;
11537 if !self.timezone.is_empty() {
11538 struct_ser.serialize_field("timezone", &self.timezone)?;
11539 }
11540 struct_ser.end()
11541 }
11542}
11543impl<'de> serde::Deserialize<'de> for StreamContext {
11544 #[allow(deprecated)]
11545 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11546 where
11547 D: serde::Deserializer<'de>,
11548 {
11549 const FIELDS: &[&str] = &[
11550 "timezone",
11551 ];
11552
11553 #[allow(clippy::enum_variant_names)]
11554 enum GeneratedField {
11555 Timezone,
11556 }
11557 impl<'de> serde::Deserialize<'de> for GeneratedField {
11558 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11559 where
11560 D: serde::Deserializer<'de>,
11561 {
11562 struct GeneratedVisitor;
11563
11564 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11565 type Value = GeneratedField;
11566
11567 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11568 write!(formatter, "expected one of: {:?}", &FIELDS)
11569 }
11570
11571 #[allow(unused_variables)]
11572 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11573 where
11574 E: serde::de::Error,
11575 {
11576 match value {
11577 "timezone" => Ok(GeneratedField::Timezone),
11578 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11579 }
11580 }
11581 }
11582 deserializer.deserialize_identifier(GeneratedVisitor)
11583 }
11584 }
11585 struct GeneratedVisitor;
11586 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11587 type Value = StreamContext;
11588
11589 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11590 formatter.write_str("struct stream_plan.StreamContext")
11591 }
11592
11593 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamContext, V::Error>
11594 where
11595 V: serde::de::MapAccess<'de>,
11596 {
11597 let mut timezone__ = None;
11598 while let Some(k) = map_.next_key()? {
11599 match k {
11600 GeneratedField::Timezone => {
11601 if timezone__.is_some() {
11602 return Err(serde::de::Error::duplicate_field("timezone"));
11603 }
11604 timezone__ = Some(map_.next_value()?);
11605 }
11606 }
11607 }
11608 Ok(StreamContext {
11609 timezone: timezone__.unwrap_or_default(),
11610 })
11611 }
11612 }
11613 deserializer.deserialize_struct("stream_plan.StreamContext", FIELDS, GeneratedVisitor)
11614 }
11615}
11616impl serde::Serialize for StreamFragmentGraph {
11617 #[allow(deprecated)]
11618 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11619 where
11620 S: serde::Serializer,
11621 {
11622 use serde::ser::SerializeStruct;
11623 let mut len = 0;
11624 if !self.fragments.is_empty() {
11625 len += 1;
11626 }
11627 if !self.edges.is_empty() {
11628 len += 1;
11629 }
11630 if !self.dependent_table_ids.is_empty() {
11631 len += 1;
11632 }
11633 if self.table_ids_cnt != 0 {
11634 len += 1;
11635 }
11636 if self.ctx.is_some() {
11637 len += 1;
11638 }
11639 if self.parallelism.is_some() {
11640 len += 1;
11641 }
11642 if self.max_parallelism != 0 {
11643 len += 1;
11644 }
11645 if self.backfill_order.is_some() {
11646 len += 1;
11647 }
11648 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph", len)?;
11649 if !self.fragments.is_empty() {
11650 struct_ser.serialize_field("fragments", &self.fragments)?;
11651 }
11652 if !self.edges.is_empty() {
11653 struct_ser.serialize_field("edges", &self.edges)?;
11654 }
11655 if !self.dependent_table_ids.is_empty() {
11656 struct_ser.serialize_field("dependentTableIds", &self.dependent_table_ids)?;
11657 }
11658 if self.table_ids_cnt != 0 {
11659 struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
11660 }
11661 if let Some(v) = self.ctx.as_ref() {
11662 struct_ser.serialize_field("ctx", v)?;
11663 }
11664 if let Some(v) = self.parallelism.as_ref() {
11665 struct_ser.serialize_field("parallelism", v)?;
11666 }
11667 if self.max_parallelism != 0 {
11668 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
11669 }
11670 if let Some(v) = self.backfill_order.as_ref() {
11671 struct_ser.serialize_field("backfillOrder", v)?;
11672 }
11673 struct_ser.end()
11674 }
11675}
11676impl<'de> serde::Deserialize<'de> for StreamFragmentGraph {
11677 #[allow(deprecated)]
11678 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11679 where
11680 D: serde::Deserializer<'de>,
11681 {
11682 const FIELDS: &[&str] = &[
11683 "fragments",
11684 "edges",
11685 "dependent_table_ids",
11686 "dependentTableIds",
11687 "table_ids_cnt",
11688 "tableIdsCnt",
11689 "ctx",
11690 "parallelism",
11691 "max_parallelism",
11692 "maxParallelism",
11693 "backfill_order",
11694 "backfillOrder",
11695 ];
11696
11697 #[allow(clippy::enum_variant_names)]
11698 enum GeneratedField {
11699 Fragments,
11700 Edges,
11701 DependentTableIds,
11702 TableIdsCnt,
11703 Ctx,
11704 Parallelism,
11705 MaxParallelism,
11706 BackfillOrder,
11707 }
11708 impl<'de> serde::Deserialize<'de> for GeneratedField {
11709 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11710 where
11711 D: serde::Deserializer<'de>,
11712 {
11713 struct GeneratedVisitor;
11714
11715 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11716 type Value = GeneratedField;
11717
11718 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11719 write!(formatter, "expected one of: {:?}", &FIELDS)
11720 }
11721
11722 #[allow(unused_variables)]
11723 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11724 where
11725 E: serde::de::Error,
11726 {
11727 match value {
11728 "fragments" => Ok(GeneratedField::Fragments),
11729 "edges" => Ok(GeneratedField::Edges),
11730 "dependentTableIds" | "dependent_table_ids" => Ok(GeneratedField::DependentTableIds),
11731 "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
11732 "ctx" => Ok(GeneratedField::Ctx),
11733 "parallelism" => Ok(GeneratedField::Parallelism),
11734 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
11735 "backfillOrder" | "backfill_order" => Ok(GeneratedField::BackfillOrder),
11736 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11737 }
11738 }
11739 }
11740 deserializer.deserialize_identifier(GeneratedVisitor)
11741 }
11742 }
11743 struct GeneratedVisitor;
11744 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11745 type Value = StreamFragmentGraph;
11746
11747 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11748 formatter.write_str("struct stream_plan.StreamFragmentGraph")
11749 }
11750
11751 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFragmentGraph, V::Error>
11752 where
11753 V: serde::de::MapAccess<'de>,
11754 {
11755 let mut fragments__ = None;
11756 let mut edges__ = None;
11757 let mut dependent_table_ids__ = None;
11758 let mut table_ids_cnt__ = None;
11759 let mut ctx__ = None;
11760 let mut parallelism__ = None;
11761 let mut max_parallelism__ = None;
11762 let mut backfill_order__ = None;
11763 while let Some(k) = map_.next_key()? {
11764 match k {
11765 GeneratedField::Fragments => {
11766 if fragments__.is_some() {
11767 return Err(serde::de::Error::duplicate_field("fragments"));
11768 }
11769 fragments__ = Some(
11770 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11771 .into_iter().map(|(k,v)| (k.0, v)).collect()
11772 );
11773 }
11774 GeneratedField::Edges => {
11775 if edges__.is_some() {
11776 return Err(serde::de::Error::duplicate_field("edges"));
11777 }
11778 edges__ = Some(map_.next_value()?);
11779 }
11780 GeneratedField::DependentTableIds => {
11781 if dependent_table_ids__.is_some() {
11782 return Err(serde::de::Error::duplicate_field("dependentTableIds"));
11783 }
11784 dependent_table_ids__ =
11785 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11786 .into_iter().map(|x| x.0).collect())
11787 ;
11788 }
11789 GeneratedField::TableIdsCnt => {
11790 if table_ids_cnt__.is_some() {
11791 return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
11792 }
11793 table_ids_cnt__ =
11794 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11795 ;
11796 }
11797 GeneratedField::Ctx => {
11798 if ctx__.is_some() {
11799 return Err(serde::de::Error::duplicate_field("ctx"));
11800 }
11801 ctx__ = map_.next_value()?;
11802 }
11803 GeneratedField::Parallelism => {
11804 if parallelism__.is_some() {
11805 return Err(serde::de::Error::duplicate_field("parallelism"));
11806 }
11807 parallelism__ = map_.next_value()?;
11808 }
11809 GeneratedField::MaxParallelism => {
11810 if max_parallelism__.is_some() {
11811 return Err(serde::de::Error::duplicate_field("maxParallelism"));
11812 }
11813 max_parallelism__ =
11814 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11815 ;
11816 }
11817 GeneratedField::BackfillOrder => {
11818 if backfill_order__.is_some() {
11819 return Err(serde::de::Error::duplicate_field("backfillOrder"));
11820 }
11821 backfill_order__ = map_.next_value()?;
11822 }
11823 }
11824 }
11825 Ok(StreamFragmentGraph {
11826 fragments: fragments__.unwrap_or_default(),
11827 edges: edges__.unwrap_or_default(),
11828 dependent_table_ids: dependent_table_ids__.unwrap_or_default(),
11829 table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
11830 ctx: ctx__,
11831 parallelism: parallelism__,
11832 max_parallelism: max_parallelism__.unwrap_or_default(),
11833 backfill_order: backfill_order__,
11834 })
11835 }
11836 }
11837 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph", FIELDS, GeneratedVisitor)
11838 }
11839}
11840impl serde::Serialize for stream_fragment_graph::Parallelism {
11841 #[allow(deprecated)]
11842 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11843 where
11844 S: serde::Serializer,
11845 {
11846 use serde::ser::SerializeStruct;
11847 let mut len = 0;
11848 if self.parallelism != 0 {
11849 len += 1;
11850 }
11851 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.Parallelism", len)?;
11852 if self.parallelism != 0 {
11853 #[allow(clippy::needless_borrow)]
11854 #[allow(clippy::needless_borrows_for_generic_args)]
11855 struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
11856 }
11857 struct_ser.end()
11858 }
11859}
11860impl<'de> serde::Deserialize<'de> for stream_fragment_graph::Parallelism {
11861 #[allow(deprecated)]
11862 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11863 where
11864 D: serde::Deserializer<'de>,
11865 {
11866 const FIELDS: &[&str] = &[
11867 "parallelism",
11868 ];
11869
11870 #[allow(clippy::enum_variant_names)]
11871 enum GeneratedField {
11872 Parallelism,
11873 }
11874 impl<'de> serde::Deserialize<'de> for GeneratedField {
11875 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11876 where
11877 D: serde::Deserializer<'de>,
11878 {
11879 struct GeneratedVisitor;
11880
11881 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11882 type Value = GeneratedField;
11883
11884 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11885 write!(formatter, "expected one of: {:?}", &FIELDS)
11886 }
11887
11888 #[allow(unused_variables)]
11889 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11890 where
11891 E: serde::de::Error,
11892 {
11893 match value {
11894 "parallelism" => Ok(GeneratedField::Parallelism),
11895 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11896 }
11897 }
11898 }
11899 deserializer.deserialize_identifier(GeneratedVisitor)
11900 }
11901 }
11902 struct GeneratedVisitor;
11903 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11904 type Value = stream_fragment_graph::Parallelism;
11905
11906 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11907 formatter.write_str("struct stream_plan.StreamFragmentGraph.Parallelism")
11908 }
11909
11910 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::Parallelism, V::Error>
11911 where
11912 V: serde::de::MapAccess<'de>,
11913 {
11914 let mut parallelism__ = None;
11915 while let Some(k) = map_.next_key()? {
11916 match k {
11917 GeneratedField::Parallelism => {
11918 if parallelism__.is_some() {
11919 return Err(serde::de::Error::duplicate_field("parallelism"));
11920 }
11921 parallelism__ =
11922 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11923 ;
11924 }
11925 }
11926 }
11927 Ok(stream_fragment_graph::Parallelism {
11928 parallelism: parallelism__.unwrap_or_default(),
11929 })
11930 }
11931 }
11932 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.Parallelism", FIELDS, GeneratedVisitor)
11933 }
11934}
11935impl serde::Serialize for stream_fragment_graph::StreamFragment {
11936 #[allow(deprecated)]
11937 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11938 where
11939 S: serde::Serializer,
11940 {
11941 use serde::ser::SerializeStruct;
11942 let mut len = 0;
11943 if self.fragment_id != 0 {
11944 len += 1;
11945 }
11946 if self.node.is_some() {
11947 len += 1;
11948 }
11949 if self.fragment_type_mask != 0 {
11950 len += 1;
11951 }
11952 if self.requires_singleton {
11953 len += 1;
11954 }
11955 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", len)?;
11956 if self.fragment_id != 0 {
11957 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
11958 }
11959 if let Some(v) = self.node.as_ref() {
11960 struct_ser.serialize_field("node", v)?;
11961 }
11962 if self.fragment_type_mask != 0 {
11963 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
11964 }
11965 if self.requires_singleton {
11966 struct_ser.serialize_field("requiresSingleton", &self.requires_singleton)?;
11967 }
11968 struct_ser.end()
11969 }
11970}
11971impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragment {
11972 #[allow(deprecated)]
11973 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11974 where
11975 D: serde::Deserializer<'de>,
11976 {
11977 const FIELDS: &[&str] = &[
11978 "fragment_id",
11979 "fragmentId",
11980 "node",
11981 "fragment_type_mask",
11982 "fragmentTypeMask",
11983 "requires_singleton",
11984 "requiresSingleton",
11985 ];
11986
11987 #[allow(clippy::enum_variant_names)]
11988 enum GeneratedField {
11989 FragmentId,
11990 Node,
11991 FragmentTypeMask,
11992 RequiresSingleton,
11993 }
11994 impl<'de> serde::Deserialize<'de> for GeneratedField {
11995 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11996 where
11997 D: serde::Deserializer<'de>,
11998 {
11999 struct GeneratedVisitor;
12000
12001 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12002 type Value = GeneratedField;
12003
12004 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12005 write!(formatter, "expected one of: {:?}", &FIELDS)
12006 }
12007
12008 #[allow(unused_variables)]
12009 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12010 where
12011 E: serde::de::Error,
12012 {
12013 match value {
12014 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
12015 "node" => Ok(GeneratedField::Node),
12016 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
12017 "requiresSingleton" | "requires_singleton" => Ok(GeneratedField::RequiresSingleton),
12018 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12019 }
12020 }
12021 }
12022 deserializer.deserialize_identifier(GeneratedVisitor)
12023 }
12024 }
12025 struct GeneratedVisitor;
12026 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12027 type Value = stream_fragment_graph::StreamFragment;
12028
12029 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12030 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragment")
12031 }
12032
12033 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragment, V::Error>
12034 where
12035 V: serde::de::MapAccess<'de>,
12036 {
12037 let mut fragment_id__ = None;
12038 let mut node__ = None;
12039 let mut fragment_type_mask__ = None;
12040 let mut requires_singleton__ = None;
12041 while let Some(k) = map_.next_key()? {
12042 match k {
12043 GeneratedField::FragmentId => {
12044 if fragment_id__.is_some() {
12045 return Err(serde::de::Error::duplicate_field("fragmentId"));
12046 }
12047 fragment_id__ =
12048 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12049 ;
12050 }
12051 GeneratedField::Node => {
12052 if node__.is_some() {
12053 return Err(serde::de::Error::duplicate_field("node"));
12054 }
12055 node__ = map_.next_value()?;
12056 }
12057 GeneratedField::FragmentTypeMask => {
12058 if fragment_type_mask__.is_some() {
12059 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
12060 }
12061 fragment_type_mask__ =
12062 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12063 ;
12064 }
12065 GeneratedField::RequiresSingleton => {
12066 if requires_singleton__.is_some() {
12067 return Err(serde::de::Error::duplicate_field("requiresSingleton"));
12068 }
12069 requires_singleton__ = Some(map_.next_value()?);
12070 }
12071 }
12072 }
12073 Ok(stream_fragment_graph::StreamFragment {
12074 fragment_id: fragment_id__.unwrap_or_default(),
12075 node: node__,
12076 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
12077 requires_singleton: requires_singleton__.unwrap_or_default(),
12078 })
12079 }
12080 }
12081 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", FIELDS, GeneratedVisitor)
12082 }
12083}
12084impl serde::Serialize for stream_fragment_graph::StreamFragmentEdge {
12085 #[allow(deprecated)]
12086 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12087 where
12088 S: serde::Serializer,
12089 {
12090 use serde::ser::SerializeStruct;
12091 let mut len = 0;
12092 if self.dispatch_strategy.is_some() {
12093 len += 1;
12094 }
12095 if self.link_id != 0 {
12096 len += 1;
12097 }
12098 if self.upstream_id != 0 {
12099 len += 1;
12100 }
12101 if self.downstream_id != 0 {
12102 len += 1;
12103 }
12104 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", len)?;
12105 if let Some(v) = self.dispatch_strategy.as_ref() {
12106 struct_ser.serialize_field("dispatchStrategy", v)?;
12107 }
12108 if self.link_id != 0 {
12109 #[allow(clippy::needless_borrow)]
12110 #[allow(clippy::needless_borrows_for_generic_args)]
12111 struct_ser.serialize_field("linkId", ToString::to_string(&self.link_id).as_str())?;
12112 }
12113 if self.upstream_id != 0 {
12114 struct_ser.serialize_field("upstreamId", &self.upstream_id)?;
12115 }
12116 if self.downstream_id != 0 {
12117 struct_ser.serialize_field("downstreamId", &self.downstream_id)?;
12118 }
12119 struct_ser.end()
12120 }
12121}
12122impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragmentEdge {
12123 #[allow(deprecated)]
12124 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12125 where
12126 D: serde::Deserializer<'de>,
12127 {
12128 const FIELDS: &[&str] = &[
12129 "dispatch_strategy",
12130 "dispatchStrategy",
12131 "link_id",
12132 "linkId",
12133 "upstream_id",
12134 "upstreamId",
12135 "downstream_id",
12136 "downstreamId",
12137 ];
12138
12139 #[allow(clippy::enum_variant_names)]
12140 enum GeneratedField {
12141 DispatchStrategy,
12142 LinkId,
12143 UpstreamId,
12144 DownstreamId,
12145 }
12146 impl<'de> serde::Deserialize<'de> for GeneratedField {
12147 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12148 where
12149 D: serde::Deserializer<'de>,
12150 {
12151 struct GeneratedVisitor;
12152
12153 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12154 type Value = GeneratedField;
12155
12156 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12157 write!(formatter, "expected one of: {:?}", &FIELDS)
12158 }
12159
12160 #[allow(unused_variables)]
12161 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12162 where
12163 E: serde::de::Error,
12164 {
12165 match value {
12166 "dispatchStrategy" | "dispatch_strategy" => Ok(GeneratedField::DispatchStrategy),
12167 "linkId" | "link_id" => Ok(GeneratedField::LinkId),
12168 "upstreamId" | "upstream_id" => Ok(GeneratedField::UpstreamId),
12169 "downstreamId" | "downstream_id" => Ok(GeneratedField::DownstreamId),
12170 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12171 }
12172 }
12173 }
12174 deserializer.deserialize_identifier(GeneratedVisitor)
12175 }
12176 }
12177 struct GeneratedVisitor;
12178 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12179 type Value = stream_fragment_graph::StreamFragmentEdge;
12180
12181 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12182 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragmentEdge")
12183 }
12184
12185 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragmentEdge, V::Error>
12186 where
12187 V: serde::de::MapAccess<'de>,
12188 {
12189 let mut dispatch_strategy__ = None;
12190 let mut link_id__ = None;
12191 let mut upstream_id__ = None;
12192 let mut downstream_id__ = None;
12193 while let Some(k) = map_.next_key()? {
12194 match k {
12195 GeneratedField::DispatchStrategy => {
12196 if dispatch_strategy__.is_some() {
12197 return Err(serde::de::Error::duplicate_field("dispatchStrategy"));
12198 }
12199 dispatch_strategy__ = map_.next_value()?;
12200 }
12201 GeneratedField::LinkId => {
12202 if link_id__.is_some() {
12203 return Err(serde::de::Error::duplicate_field("linkId"));
12204 }
12205 link_id__ =
12206 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12207 ;
12208 }
12209 GeneratedField::UpstreamId => {
12210 if upstream_id__.is_some() {
12211 return Err(serde::de::Error::duplicate_field("upstreamId"));
12212 }
12213 upstream_id__ =
12214 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12215 ;
12216 }
12217 GeneratedField::DownstreamId => {
12218 if downstream_id__.is_some() {
12219 return Err(serde::de::Error::duplicate_field("downstreamId"));
12220 }
12221 downstream_id__ =
12222 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12223 ;
12224 }
12225 }
12226 }
12227 Ok(stream_fragment_graph::StreamFragmentEdge {
12228 dispatch_strategy: dispatch_strategy__,
12229 link_id: link_id__.unwrap_or_default(),
12230 upstream_id: upstream_id__.unwrap_or_default(),
12231 downstream_id: downstream_id__.unwrap_or_default(),
12232 })
12233 }
12234 }
12235 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", FIELDS, GeneratedVisitor)
12236 }
12237}
12238impl serde::Serialize for StreamFsFetch {
12239 #[allow(deprecated)]
12240 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12241 where
12242 S: serde::Serializer,
12243 {
12244 use serde::ser::SerializeStruct;
12245 let mut len = 0;
12246 if self.source_id != 0 {
12247 len += 1;
12248 }
12249 if self.state_table.is_some() {
12250 len += 1;
12251 }
12252 if self.row_id_index.is_some() {
12253 len += 1;
12254 }
12255 if !self.columns.is_empty() {
12256 len += 1;
12257 }
12258 if !self.with_properties.is_empty() {
12259 len += 1;
12260 }
12261 if self.info.is_some() {
12262 len += 1;
12263 }
12264 if !self.source_name.is_empty() {
12265 len += 1;
12266 }
12267 if self.rate_limit.is_some() {
12268 len += 1;
12269 }
12270 if !self.secret_refs.is_empty() {
12271 len += 1;
12272 }
12273 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetch", len)?;
12274 if self.source_id != 0 {
12275 struct_ser.serialize_field("sourceId", &self.source_id)?;
12276 }
12277 if let Some(v) = self.state_table.as_ref() {
12278 struct_ser.serialize_field("stateTable", v)?;
12279 }
12280 if let Some(v) = self.row_id_index.as_ref() {
12281 struct_ser.serialize_field("rowIdIndex", v)?;
12282 }
12283 if !self.columns.is_empty() {
12284 struct_ser.serialize_field("columns", &self.columns)?;
12285 }
12286 if !self.with_properties.is_empty() {
12287 struct_ser.serialize_field("withProperties", &self.with_properties)?;
12288 }
12289 if let Some(v) = self.info.as_ref() {
12290 struct_ser.serialize_field("info", v)?;
12291 }
12292 if !self.source_name.is_empty() {
12293 struct_ser.serialize_field("sourceName", &self.source_name)?;
12294 }
12295 if let Some(v) = self.rate_limit.as_ref() {
12296 struct_ser.serialize_field("rateLimit", v)?;
12297 }
12298 if !self.secret_refs.is_empty() {
12299 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
12300 }
12301 struct_ser.end()
12302 }
12303}
12304impl<'de> serde::Deserialize<'de> for StreamFsFetch {
12305 #[allow(deprecated)]
12306 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12307 where
12308 D: serde::Deserializer<'de>,
12309 {
12310 const FIELDS: &[&str] = &[
12311 "source_id",
12312 "sourceId",
12313 "state_table",
12314 "stateTable",
12315 "row_id_index",
12316 "rowIdIndex",
12317 "columns",
12318 "with_properties",
12319 "withProperties",
12320 "info",
12321 "source_name",
12322 "sourceName",
12323 "rate_limit",
12324 "rateLimit",
12325 "secret_refs",
12326 "secretRefs",
12327 ];
12328
12329 #[allow(clippy::enum_variant_names)]
12330 enum GeneratedField {
12331 SourceId,
12332 StateTable,
12333 RowIdIndex,
12334 Columns,
12335 WithProperties,
12336 Info,
12337 SourceName,
12338 RateLimit,
12339 SecretRefs,
12340 }
12341 impl<'de> serde::Deserialize<'de> for GeneratedField {
12342 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12343 where
12344 D: serde::Deserializer<'de>,
12345 {
12346 struct GeneratedVisitor;
12347
12348 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12349 type Value = GeneratedField;
12350
12351 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12352 write!(formatter, "expected one of: {:?}", &FIELDS)
12353 }
12354
12355 #[allow(unused_variables)]
12356 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12357 where
12358 E: serde::de::Error,
12359 {
12360 match value {
12361 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
12362 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
12363 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
12364 "columns" => Ok(GeneratedField::Columns),
12365 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
12366 "info" => Ok(GeneratedField::Info),
12367 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
12368 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
12369 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
12370 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12371 }
12372 }
12373 }
12374 deserializer.deserialize_identifier(GeneratedVisitor)
12375 }
12376 }
12377 struct GeneratedVisitor;
12378 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12379 type Value = StreamFsFetch;
12380
12381 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12382 formatter.write_str("struct stream_plan.StreamFsFetch")
12383 }
12384
12385 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetch, V::Error>
12386 where
12387 V: serde::de::MapAccess<'de>,
12388 {
12389 let mut source_id__ = None;
12390 let mut state_table__ = None;
12391 let mut row_id_index__ = None;
12392 let mut columns__ = None;
12393 let mut with_properties__ = None;
12394 let mut info__ = None;
12395 let mut source_name__ = None;
12396 let mut rate_limit__ = None;
12397 let mut secret_refs__ = None;
12398 while let Some(k) = map_.next_key()? {
12399 match k {
12400 GeneratedField::SourceId => {
12401 if source_id__.is_some() {
12402 return Err(serde::de::Error::duplicate_field("sourceId"));
12403 }
12404 source_id__ =
12405 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12406 ;
12407 }
12408 GeneratedField::StateTable => {
12409 if state_table__.is_some() {
12410 return Err(serde::de::Error::duplicate_field("stateTable"));
12411 }
12412 state_table__ = map_.next_value()?;
12413 }
12414 GeneratedField::RowIdIndex => {
12415 if row_id_index__.is_some() {
12416 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
12417 }
12418 row_id_index__ =
12419 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12420 ;
12421 }
12422 GeneratedField::Columns => {
12423 if columns__.is_some() {
12424 return Err(serde::de::Error::duplicate_field("columns"));
12425 }
12426 columns__ = Some(map_.next_value()?);
12427 }
12428 GeneratedField::WithProperties => {
12429 if with_properties__.is_some() {
12430 return Err(serde::de::Error::duplicate_field("withProperties"));
12431 }
12432 with_properties__ = Some(
12433 map_.next_value::<std::collections::BTreeMap<_, _>>()?
12434 );
12435 }
12436 GeneratedField::Info => {
12437 if info__.is_some() {
12438 return Err(serde::de::Error::duplicate_field("info"));
12439 }
12440 info__ = map_.next_value()?;
12441 }
12442 GeneratedField::SourceName => {
12443 if source_name__.is_some() {
12444 return Err(serde::de::Error::duplicate_field("sourceName"));
12445 }
12446 source_name__ = Some(map_.next_value()?);
12447 }
12448 GeneratedField::RateLimit => {
12449 if rate_limit__.is_some() {
12450 return Err(serde::de::Error::duplicate_field("rateLimit"));
12451 }
12452 rate_limit__ =
12453 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12454 ;
12455 }
12456 GeneratedField::SecretRefs => {
12457 if secret_refs__.is_some() {
12458 return Err(serde::de::Error::duplicate_field("secretRefs"));
12459 }
12460 secret_refs__ = Some(
12461 map_.next_value::<std::collections::BTreeMap<_, _>>()?
12462 );
12463 }
12464 }
12465 }
12466 Ok(StreamFsFetch {
12467 source_id: source_id__.unwrap_or_default(),
12468 state_table: state_table__,
12469 row_id_index: row_id_index__,
12470 columns: columns__.unwrap_or_default(),
12471 with_properties: with_properties__.unwrap_or_default(),
12472 info: info__,
12473 source_name: source_name__.unwrap_or_default(),
12474 rate_limit: rate_limit__,
12475 secret_refs: secret_refs__.unwrap_or_default(),
12476 })
12477 }
12478 }
12479 deserializer.deserialize_struct("stream_plan.StreamFsFetch", FIELDS, GeneratedVisitor)
12480 }
12481}
12482impl serde::Serialize for StreamFsFetchNode {
12483 #[allow(deprecated)]
12484 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12485 where
12486 S: serde::Serializer,
12487 {
12488 use serde::ser::SerializeStruct;
12489 let mut len = 0;
12490 if self.node_inner.is_some() {
12491 len += 1;
12492 }
12493 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetchNode", len)?;
12494 if let Some(v) = self.node_inner.as_ref() {
12495 struct_ser.serialize_field("nodeInner", v)?;
12496 }
12497 struct_ser.end()
12498 }
12499}
12500impl<'de> serde::Deserialize<'de> for StreamFsFetchNode {
12501 #[allow(deprecated)]
12502 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12503 where
12504 D: serde::Deserializer<'de>,
12505 {
12506 const FIELDS: &[&str] = &[
12507 "node_inner",
12508 "nodeInner",
12509 ];
12510
12511 #[allow(clippy::enum_variant_names)]
12512 enum GeneratedField {
12513 NodeInner,
12514 }
12515 impl<'de> serde::Deserialize<'de> for GeneratedField {
12516 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12517 where
12518 D: serde::Deserializer<'de>,
12519 {
12520 struct GeneratedVisitor;
12521
12522 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12523 type Value = GeneratedField;
12524
12525 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12526 write!(formatter, "expected one of: {:?}", &FIELDS)
12527 }
12528
12529 #[allow(unused_variables)]
12530 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12531 where
12532 E: serde::de::Error,
12533 {
12534 match value {
12535 "nodeInner" | "node_inner" => Ok(GeneratedField::NodeInner),
12536 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12537 }
12538 }
12539 }
12540 deserializer.deserialize_identifier(GeneratedVisitor)
12541 }
12542 }
12543 struct GeneratedVisitor;
12544 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12545 type Value = StreamFsFetchNode;
12546
12547 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12548 formatter.write_str("struct stream_plan.StreamFsFetchNode")
12549 }
12550
12551 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetchNode, V::Error>
12552 where
12553 V: serde::de::MapAccess<'de>,
12554 {
12555 let mut node_inner__ = None;
12556 while let Some(k) = map_.next_key()? {
12557 match k {
12558 GeneratedField::NodeInner => {
12559 if node_inner__.is_some() {
12560 return Err(serde::de::Error::duplicate_field("nodeInner"));
12561 }
12562 node_inner__ = map_.next_value()?;
12563 }
12564 }
12565 }
12566 Ok(StreamFsFetchNode {
12567 node_inner: node_inner__,
12568 })
12569 }
12570 }
12571 deserializer.deserialize_struct("stream_plan.StreamFsFetchNode", FIELDS, GeneratedVisitor)
12572 }
12573}
12574impl serde::Serialize for StreamMessage {
12575 #[allow(deprecated)]
12576 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12577 where
12578 S: serde::Serializer,
12579 {
12580 use serde::ser::SerializeStruct;
12581 let mut len = 0;
12582 if self.stream_message.is_some() {
12583 len += 1;
12584 }
12585 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessage", len)?;
12586 if let Some(v) = self.stream_message.as_ref() {
12587 match v {
12588 stream_message::StreamMessage::StreamChunk(v) => {
12589 struct_ser.serialize_field("streamChunk", v)?;
12590 }
12591 stream_message::StreamMessage::Barrier(v) => {
12592 struct_ser.serialize_field("barrier", v)?;
12593 }
12594 stream_message::StreamMessage::Watermark(v) => {
12595 struct_ser.serialize_field("watermark", v)?;
12596 }
12597 }
12598 }
12599 struct_ser.end()
12600 }
12601}
12602impl<'de> serde::Deserialize<'de> for StreamMessage {
12603 #[allow(deprecated)]
12604 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12605 where
12606 D: serde::Deserializer<'de>,
12607 {
12608 const FIELDS: &[&str] = &[
12609 "stream_chunk",
12610 "streamChunk",
12611 "barrier",
12612 "watermark",
12613 ];
12614
12615 #[allow(clippy::enum_variant_names)]
12616 enum GeneratedField {
12617 StreamChunk,
12618 Barrier,
12619 Watermark,
12620 }
12621 impl<'de> serde::Deserialize<'de> for GeneratedField {
12622 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12623 where
12624 D: serde::Deserializer<'de>,
12625 {
12626 struct GeneratedVisitor;
12627
12628 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12629 type Value = GeneratedField;
12630
12631 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12632 write!(formatter, "expected one of: {:?}", &FIELDS)
12633 }
12634
12635 #[allow(unused_variables)]
12636 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12637 where
12638 E: serde::de::Error,
12639 {
12640 match value {
12641 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
12642 "barrier" => Ok(GeneratedField::Barrier),
12643 "watermark" => Ok(GeneratedField::Watermark),
12644 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12645 }
12646 }
12647 }
12648 deserializer.deserialize_identifier(GeneratedVisitor)
12649 }
12650 }
12651 struct GeneratedVisitor;
12652 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12653 type Value = StreamMessage;
12654
12655 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12656 formatter.write_str("struct stream_plan.StreamMessage")
12657 }
12658
12659 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessage, V::Error>
12660 where
12661 V: serde::de::MapAccess<'de>,
12662 {
12663 let mut stream_message__ = None;
12664 while let Some(k) = map_.next_key()? {
12665 match k {
12666 GeneratedField::StreamChunk => {
12667 if stream_message__.is_some() {
12668 return Err(serde::de::Error::duplicate_field("streamChunk"));
12669 }
12670 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::StreamChunk)
12671;
12672 }
12673 GeneratedField::Barrier => {
12674 if stream_message__.is_some() {
12675 return Err(serde::de::Error::duplicate_field("barrier"));
12676 }
12677 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Barrier)
12678;
12679 }
12680 GeneratedField::Watermark => {
12681 if stream_message__.is_some() {
12682 return Err(serde::de::Error::duplicate_field("watermark"));
12683 }
12684 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Watermark)
12685;
12686 }
12687 }
12688 }
12689 Ok(StreamMessage {
12690 stream_message: stream_message__,
12691 })
12692 }
12693 }
12694 deserializer.deserialize_struct("stream_plan.StreamMessage", FIELDS, GeneratedVisitor)
12695 }
12696}
12697impl serde::Serialize for StreamMessageBatch {
12698 #[allow(deprecated)]
12699 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12700 where
12701 S: serde::Serializer,
12702 {
12703 use serde::ser::SerializeStruct;
12704 let mut len = 0;
12705 if self.stream_message_batch.is_some() {
12706 len += 1;
12707 }
12708 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch", len)?;
12709 if let Some(v) = self.stream_message_batch.as_ref() {
12710 match v {
12711 stream_message_batch::StreamMessageBatch::StreamChunk(v) => {
12712 struct_ser.serialize_field("streamChunk", v)?;
12713 }
12714 stream_message_batch::StreamMessageBatch::BarrierBatch(v) => {
12715 struct_ser.serialize_field("barrierBatch", v)?;
12716 }
12717 stream_message_batch::StreamMessageBatch::Watermark(v) => {
12718 struct_ser.serialize_field("watermark", v)?;
12719 }
12720 }
12721 }
12722 struct_ser.end()
12723 }
12724}
12725impl<'de> serde::Deserialize<'de> for StreamMessageBatch {
12726 #[allow(deprecated)]
12727 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12728 where
12729 D: serde::Deserializer<'de>,
12730 {
12731 const FIELDS: &[&str] = &[
12732 "stream_chunk",
12733 "streamChunk",
12734 "barrier_batch",
12735 "barrierBatch",
12736 "watermark",
12737 ];
12738
12739 #[allow(clippy::enum_variant_names)]
12740 enum GeneratedField {
12741 StreamChunk,
12742 BarrierBatch,
12743 Watermark,
12744 }
12745 impl<'de> serde::Deserialize<'de> for GeneratedField {
12746 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12747 where
12748 D: serde::Deserializer<'de>,
12749 {
12750 struct GeneratedVisitor;
12751
12752 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12753 type Value = GeneratedField;
12754
12755 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12756 write!(formatter, "expected one of: {:?}", &FIELDS)
12757 }
12758
12759 #[allow(unused_variables)]
12760 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12761 where
12762 E: serde::de::Error,
12763 {
12764 match value {
12765 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
12766 "barrierBatch" | "barrier_batch" => Ok(GeneratedField::BarrierBatch),
12767 "watermark" => Ok(GeneratedField::Watermark),
12768 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12769 }
12770 }
12771 }
12772 deserializer.deserialize_identifier(GeneratedVisitor)
12773 }
12774 }
12775 struct GeneratedVisitor;
12776 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12777 type Value = StreamMessageBatch;
12778
12779 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12780 formatter.write_str("struct stream_plan.StreamMessageBatch")
12781 }
12782
12783 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessageBatch, V::Error>
12784 where
12785 V: serde::de::MapAccess<'de>,
12786 {
12787 let mut stream_message_batch__ = None;
12788 while let Some(k) = map_.next_key()? {
12789 match k {
12790 GeneratedField::StreamChunk => {
12791 if stream_message_batch__.is_some() {
12792 return Err(serde::de::Error::duplicate_field("streamChunk"));
12793 }
12794 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::StreamChunk)
12795;
12796 }
12797 GeneratedField::BarrierBatch => {
12798 if stream_message_batch__.is_some() {
12799 return Err(serde::de::Error::duplicate_field("barrierBatch"));
12800 }
12801 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::BarrierBatch)
12802;
12803 }
12804 GeneratedField::Watermark => {
12805 if stream_message_batch__.is_some() {
12806 return Err(serde::de::Error::duplicate_field("watermark"));
12807 }
12808 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::Watermark)
12809;
12810 }
12811 }
12812 }
12813 Ok(StreamMessageBatch {
12814 stream_message_batch: stream_message_batch__,
12815 })
12816 }
12817 }
12818 deserializer.deserialize_struct("stream_plan.StreamMessageBatch", FIELDS, GeneratedVisitor)
12819 }
12820}
12821impl serde::Serialize for stream_message_batch::BarrierBatch {
12822 #[allow(deprecated)]
12823 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12824 where
12825 S: serde::Serializer,
12826 {
12827 use serde::ser::SerializeStruct;
12828 let mut len = 0;
12829 if !self.barriers.is_empty() {
12830 len += 1;
12831 }
12832 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", len)?;
12833 if !self.barriers.is_empty() {
12834 struct_ser.serialize_field("barriers", &self.barriers)?;
12835 }
12836 struct_ser.end()
12837 }
12838}
12839impl<'de> serde::Deserialize<'de> for stream_message_batch::BarrierBatch {
12840 #[allow(deprecated)]
12841 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12842 where
12843 D: serde::Deserializer<'de>,
12844 {
12845 const FIELDS: &[&str] = &[
12846 "barriers",
12847 ];
12848
12849 #[allow(clippy::enum_variant_names)]
12850 enum GeneratedField {
12851 Barriers,
12852 }
12853 impl<'de> serde::Deserialize<'de> for GeneratedField {
12854 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12855 where
12856 D: serde::Deserializer<'de>,
12857 {
12858 struct GeneratedVisitor;
12859
12860 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12861 type Value = GeneratedField;
12862
12863 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12864 write!(formatter, "expected one of: {:?}", &FIELDS)
12865 }
12866
12867 #[allow(unused_variables)]
12868 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12869 where
12870 E: serde::de::Error,
12871 {
12872 match value {
12873 "barriers" => Ok(GeneratedField::Barriers),
12874 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12875 }
12876 }
12877 }
12878 deserializer.deserialize_identifier(GeneratedVisitor)
12879 }
12880 }
12881 struct GeneratedVisitor;
12882 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12883 type Value = stream_message_batch::BarrierBatch;
12884
12885 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12886 formatter.write_str("struct stream_plan.StreamMessageBatch.BarrierBatch")
12887 }
12888
12889 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_message_batch::BarrierBatch, V::Error>
12890 where
12891 V: serde::de::MapAccess<'de>,
12892 {
12893 let mut barriers__ = None;
12894 while let Some(k) = map_.next_key()? {
12895 match k {
12896 GeneratedField::Barriers => {
12897 if barriers__.is_some() {
12898 return Err(serde::de::Error::duplicate_field("barriers"));
12899 }
12900 barriers__ = Some(map_.next_value()?);
12901 }
12902 }
12903 }
12904 Ok(stream_message_batch::BarrierBatch {
12905 barriers: barriers__.unwrap_or_default(),
12906 })
12907 }
12908 }
12909 deserializer.deserialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", FIELDS, GeneratedVisitor)
12910 }
12911}
12912impl serde::Serialize for StreamNode {
12913 #[allow(deprecated)]
12914 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12915 where
12916 S: serde::Serializer,
12917 {
12918 use serde::ser::SerializeStruct;
12919 let mut len = 0;
12920 if self.operator_id != 0 {
12921 len += 1;
12922 }
12923 if !self.input.is_empty() {
12924 len += 1;
12925 }
12926 if !self.stream_key.is_empty() {
12927 len += 1;
12928 }
12929 if self.stream_kind != 0 {
12930 len += 1;
12931 }
12932 if !self.identity.is_empty() {
12933 len += 1;
12934 }
12935 if !self.fields.is_empty() {
12936 len += 1;
12937 }
12938 if self.node_body.is_some() {
12939 len += 1;
12940 }
12941 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamNode", len)?;
12942 if self.operator_id != 0 {
12943 #[allow(clippy::needless_borrow)]
12944 #[allow(clippy::needless_borrows_for_generic_args)]
12945 struct_ser.serialize_field("operatorId", ToString::to_string(&self.operator_id).as_str())?;
12946 }
12947 if !self.input.is_empty() {
12948 struct_ser.serialize_field("input", &self.input)?;
12949 }
12950 if !self.stream_key.is_empty() {
12951 struct_ser.serialize_field("streamKey", &self.stream_key)?;
12952 }
12953 if self.stream_kind != 0 {
12954 let v = stream_node::StreamKind::try_from(self.stream_kind)
12955 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_kind)))?;
12956 struct_ser.serialize_field("streamKind", &v)?;
12957 }
12958 if !self.identity.is_empty() {
12959 struct_ser.serialize_field("identity", &self.identity)?;
12960 }
12961 if !self.fields.is_empty() {
12962 struct_ser.serialize_field("fields", &self.fields)?;
12963 }
12964 if let Some(v) = self.node_body.as_ref() {
12965 match v {
12966 stream_node::NodeBody::Source(v) => {
12967 struct_ser.serialize_field("source", v)?;
12968 }
12969 stream_node::NodeBody::Project(v) => {
12970 struct_ser.serialize_field("project", v)?;
12971 }
12972 stream_node::NodeBody::Filter(v) => {
12973 struct_ser.serialize_field("filter", v)?;
12974 }
12975 stream_node::NodeBody::Materialize(v) => {
12976 struct_ser.serialize_field("materialize", v)?;
12977 }
12978 stream_node::NodeBody::StatelessSimpleAgg(v) => {
12979 struct_ser.serialize_field("statelessSimpleAgg", v)?;
12980 }
12981 stream_node::NodeBody::SimpleAgg(v) => {
12982 struct_ser.serialize_field("simpleAgg", v)?;
12983 }
12984 stream_node::NodeBody::HashAgg(v) => {
12985 struct_ser.serialize_field("hashAgg", v)?;
12986 }
12987 stream_node::NodeBody::AppendOnlyTopN(v) => {
12988 struct_ser.serialize_field("appendOnlyTopN", v)?;
12989 }
12990 stream_node::NodeBody::HashJoin(v) => {
12991 struct_ser.serialize_field("hashJoin", v)?;
12992 }
12993 stream_node::NodeBody::TopN(v) => {
12994 struct_ser.serialize_field("topN", v)?;
12995 }
12996 stream_node::NodeBody::HopWindow(v) => {
12997 struct_ser.serialize_field("hopWindow", v)?;
12998 }
12999 stream_node::NodeBody::Merge(v) => {
13000 struct_ser.serialize_field("merge", v)?;
13001 }
13002 stream_node::NodeBody::Exchange(v) => {
13003 struct_ser.serialize_field("exchange", v)?;
13004 }
13005 stream_node::NodeBody::StreamScan(v) => {
13006 struct_ser.serialize_field("streamScan", v)?;
13007 }
13008 stream_node::NodeBody::BatchPlan(v) => {
13009 struct_ser.serialize_field("batchPlan", v)?;
13010 }
13011 stream_node::NodeBody::Lookup(v) => {
13012 struct_ser.serialize_field("lookup", v)?;
13013 }
13014 stream_node::NodeBody::Arrange(v) => {
13015 struct_ser.serialize_field("arrange", v)?;
13016 }
13017 stream_node::NodeBody::LookupUnion(v) => {
13018 struct_ser.serialize_field("lookupUnion", v)?;
13019 }
13020 stream_node::NodeBody::Union(v) => {
13021 struct_ser.serialize_field("union", v)?;
13022 }
13023 stream_node::NodeBody::DeltaIndexJoin(v) => {
13024 struct_ser.serialize_field("deltaIndexJoin", v)?;
13025 }
13026 stream_node::NodeBody::Sink(v) => {
13027 struct_ser.serialize_field("sink", v)?;
13028 }
13029 stream_node::NodeBody::Expand(v) => {
13030 struct_ser.serialize_field("expand", v)?;
13031 }
13032 stream_node::NodeBody::DynamicFilter(v) => {
13033 struct_ser.serialize_field("dynamicFilter", v)?;
13034 }
13035 stream_node::NodeBody::ProjectSet(v) => {
13036 struct_ser.serialize_field("projectSet", v)?;
13037 }
13038 stream_node::NodeBody::GroupTopN(v) => {
13039 struct_ser.serialize_field("groupTopN", v)?;
13040 }
13041 stream_node::NodeBody::Sort(v) => {
13042 struct_ser.serialize_field("sort", v)?;
13043 }
13044 stream_node::NodeBody::WatermarkFilter(v) => {
13045 struct_ser.serialize_field("watermarkFilter", v)?;
13046 }
13047 stream_node::NodeBody::Dml(v) => {
13048 struct_ser.serialize_field("dml", v)?;
13049 }
13050 stream_node::NodeBody::RowIdGen(v) => {
13051 struct_ser.serialize_field("rowIdGen", v)?;
13052 }
13053 stream_node::NodeBody::Now(v) => {
13054 struct_ser.serialize_field("now", v)?;
13055 }
13056 stream_node::NodeBody::AppendOnlyGroupTopN(v) => {
13057 struct_ser.serialize_field("appendOnlyGroupTopN", v)?;
13058 }
13059 stream_node::NodeBody::TemporalJoin(v) => {
13060 struct_ser.serialize_field("temporalJoin", v)?;
13061 }
13062 stream_node::NodeBody::BarrierRecv(v) => {
13063 struct_ser.serialize_field("barrierRecv", v)?;
13064 }
13065 stream_node::NodeBody::Values(v) => {
13066 struct_ser.serialize_field("values", v)?;
13067 }
13068 stream_node::NodeBody::AppendOnlyDedup(v) => {
13069 struct_ser.serialize_field("appendOnlyDedup", v)?;
13070 }
13071 stream_node::NodeBody::NoOp(v) => {
13072 struct_ser.serialize_field("noOp", v)?;
13073 }
13074 stream_node::NodeBody::EowcOverWindow(v) => {
13075 struct_ser.serialize_field("eowcOverWindow", v)?;
13076 }
13077 stream_node::NodeBody::OverWindow(v) => {
13078 struct_ser.serialize_field("overWindow", v)?;
13079 }
13080 stream_node::NodeBody::StreamFsFetch(v) => {
13081 struct_ser.serialize_field("streamFsFetch", v)?;
13082 }
13083 stream_node::NodeBody::StreamCdcScan(v) => {
13084 struct_ser.serialize_field("streamCdcScan", v)?;
13085 }
13086 stream_node::NodeBody::CdcFilter(v) => {
13087 struct_ser.serialize_field("cdcFilter", v)?;
13088 }
13089 stream_node::NodeBody::SourceBackfill(v) => {
13090 struct_ser.serialize_field("sourceBackfill", v)?;
13091 }
13092 stream_node::NodeBody::Changelog(v) => {
13093 struct_ser.serialize_field("changelog", v)?;
13094 }
13095 stream_node::NodeBody::LocalApproxPercentile(v) => {
13096 struct_ser.serialize_field("localApproxPercentile", v)?;
13097 }
13098 stream_node::NodeBody::GlobalApproxPercentile(v) => {
13099 struct_ser.serialize_field("globalApproxPercentile", v)?;
13100 }
13101 stream_node::NodeBody::RowMerge(v) => {
13102 struct_ser.serialize_field("rowMerge", v)?;
13103 }
13104 stream_node::NodeBody::AsOfJoin(v) => {
13105 struct_ser.serialize_field("asOfJoin", v)?;
13106 }
13107 stream_node::NodeBody::SyncLogStore(v) => {
13108 struct_ser.serialize_field("syncLogStore", v)?;
13109 }
13110 stream_node::NodeBody::MaterializedExprs(v) => {
13111 struct_ser.serialize_field("materializedExprs", v)?;
13112 }
13113 stream_node::NodeBody::VectorIndexWrite(v) => {
13114 struct_ser.serialize_field("vectorIndexWrite", v)?;
13115 }
13116 stream_node::NodeBody::UpstreamSinkUnion(v) => {
13117 struct_ser.serialize_field("upstreamSinkUnion", v)?;
13118 }
13119 stream_node::NodeBody::LocalityProvider(v) => {
13120 struct_ser.serialize_field("localityProvider", v)?;
13121 }
13122 stream_node::NodeBody::EowcGapFill(v) => {
13123 struct_ser.serialize_field("eowcGapFill", v)?;
13124 }
13125 stream_node::NodeBody::GapFill(v) => {
13126 struct_ser.serialize_field("gapFill", v)?;
13127 }
13128 }
13129 }
13130 struct_ser.end()
13131 }
13132}
13133impl<'de> serde::Deserialize<'de> for StreamNode {
13134 #[allow(deprecated)]
13135 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13136 where
13137 D: serde::Deserializer<'de>,
13138 {
13139 const FIELDS: &[&str] = &[
13140 "operator_id",
13141 "operatorId",
13142 "input",
13143 "stream_key",
13144 "streamKey",
13145 "stream_kind",
13146 "streamKind",
13147 "identity",
13148 "fields",
13149 "source",
13150 "project",
13151 "filter",
13152 "materialize",
13153 "stateless_simple_agg",
13154 "statelessSimpleAgg",
13155 "simple_agg",
13156 "simpleAgg",
13157 "hash_agg",
13158 "hashAgg",
13159 "append_only_top_n",
13160 "appendOnlyTopN",
13161 "hash_join",
13162 "hashJoin",
13163 "top_n",
13164 "topN",
13165 "hop_window",
13166 "hopWindow",
13167 "merge",
13168 "exchange",
13169 "stream_scan",
13170 "streamScan",
13171 "batch_plan",
13172 "batchPlan",
13173 "lookup",
13174 "arrange",
13175 "lookup_union",
13176 "lookupUnion",
13177 "union",
13178 "delta_index_join",
13179 "deltaIndexJoin",
13180 "sink",
13181 "expand",
13182 "dynamic_filter",
13183 "dynamicFilter",
13184 "project_set",
13185 "projectSet",
13186 "group_top_n",
13187 "groupTopN",
13188 "sort",
13189 "watermark_filter",
13190 "watermarkFilter",
13191 "dml",
13192 "row_id_gen",
13193 "rowIdGen",
13194 "now",
13195 "append_only_group_top_n",
13196 "appendOnlyGroupTopN",
13197 "temporal_join",
13198 "temporalJoin",
13199 "barrier_recv",
13200 "barrierRecv",
13201 "values",
13202 "append_only_dedup",
13203 "appendOnlyDedup",
13204 "no_op",
13205 "noOp",
13206 "eowc_over_window",
13207 "eowcOverWindow",
13208 "over_window",
13209 "overWindow",
13210 "stream_fs_fetch",
13211 "streamFsFetch",
13212 "stream_cdc_scan",
13213 "streamCdcScan",
13214 "cdc_filter",
13215 "cdcFilter",
13216 "source_backfill",
13217 "sourceBackfill",
13218 "changelog",
13219 "local_approx_percentile",
13220 "localApproxPercentile",
13221 "global_approx_percentile",
13222 "globalApproxPercentile",
13223 "row_merge",
13224 "rowMerge",
13225 "as_of_join",
13226 "asOfJoin",
13227 "sync_log_store",
13228 "syncLogStore",
13229 "materialized_exprs",
13230 "materializedExprs",
13231 "vector_index_write",
13232 "vectorIndexWrite",
13233 "upstream_sink_union",
13234 "upstreamSinkUnion",
13235 "locality_provider",
13236 "localityProvider",
13237 "eowc_gap_fill",
13238 "eowcGapFill",
13239 "gap_fill",
13240 "gapFill",
13241 ];
13242
13243 #[allow(clippy::enum_variant_names)]
13244 enum GeneratedField {
13245 OperatorId,
13246 Input,
13247 StreamKey,
13248 StreamKind,
13249 Identity,
13250 Fields,
13251 Source,
13252 Project,
13253 Filter,
13254 Materialize,
13255 StatelessSimpleAgg,
13256 SimpleAgg,
13257 HashAgg,
13258 AppendOnlyTopN,
13259 HashJoin,
13260 TopN,
13261 HopWindow,
13262 Merge,
13263 Exchange,
13264 StreamScan,
13265 BatchPlan,
13266 Lookup,
13267 Arrange,
13268 LookupUnion,
13269 Union,
13270 DeltaIndexJoin,
13271 Sink,
13272 Expand,
13273 DynamicFilter,
13274 ProjectSet,
13275 GroupTopN,
13276 Sort,
13277 WatermarkFilter,
13278 Dml,
13279 RowIdGen,
13280 Now,
13281 AppendOnlyGroupTopN,
13282 TemporalJoin,
13283 BarrierRecv,
13284 Values,
13285 AppendOnlyDedup,
13286 NoOp,
13287 EowcOverWindow,
13288 OverWindow,
13289 StreamFsFetch,
13290 StreamCdcScan,
13291 CdcFilter,
13292 SourceBackfill,
13293 Changelog,
13294 LocalApproxPercentile,
13295 GlobalApproxPercentile,
13296 RowMerge,
13297 AsOfJoin,
13298 SyncLogStore,
13299 MaterializedExprs,
13300 VectorIndexWrite,
13301 UpstreamSinkUnion,
13302 LocalityProvider,
13303 EowcGapFill,
13304 GapFill,
13305 }
13306 impl<'de> serde::Deserialize<'de> for GeneratedField {
13307 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13308 where
13309 D: serde::Deserializer<'de>,
13310 {
13311 struct GeneratedVisitor;
13312
13313 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13314 type Value = GeneratedField;
13315
13316 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13317 write!(formatter, "expected one of: {:?}", &FIELDS)
13318 }
13319
13320 #[allow(unused_variables)]
13321 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13322 where
13323 E: serde::de::Error,
13324 {
13325 match value {
13326 "operatorId" | "operator_id" => Ok(GeneratedField::OperatorId),
13327 "input" => Ok(GeneratedField::Input),
13328 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
13329 "streamKind" | "stream_kind" => Ok(GeneratedField::StreamKind),
13330 "identity" => Ok(GeneratedField::Identity),
13331 "fields" => Ok(GeneratedField::Fields),
13332 "source" => Ok(GeneratedField::Source),
13333 "project" => Ok(GeneratedField::Project),
13334 "filter" => Ok(GeneratedField::Filter),
13335 "materialize" => Ok(GeneratedField::Materialize),
13336 "statelessSimpleAgg" | "stateless_simple_agg" => Ok(GeneratedField::StatelessSimpleAgg),
13337 "simpleAgg" | "simple_agg" => Ok(GeneratedField::SimpleAgg),
13338 "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
13339 "appendOnlyTopN" | "append_only_top_n" => Ok(GeneratedField::AppendOnlyTopN),
13340 "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
13341 "topN" | "top_n" => Ok(GeneratedField::TopN),
13342 "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
13343 "merge" => Ok(GeneratedField::Merge),
13344 "exchange" => Ok(GeneratedField::Exchange),
13345 "streamScan" | "stream_scan" => Ok(GeneratedField::StreamScan),
13346 "batchPlan" | "batch_plan" => Ok(GeneratedField::BatchPlan),
13347 "lookup" => Ok(GeneratedField::Lookup),
13348 "arrange" => Ok(GeneratedField::Arrange),
13349 "lookupUnion" | "lookup_union" => Ok(GeneratedField::LookupUnion),
13350 "union" => Ok(GeneratedField::Union),
13351 "deltaIndexJoin" | "delta_index_join" => Ok(GeneratedField::DeltaIndexJoin),
13352 "sink" => Ok(GeneratedField::Sink),
13353 "expand" => Ok(GeneratedField::Expand),
13354 "dynamicFilter" | "dynamic_filter" => Ok(GeneratedField::DynamicFilter),
13355 "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
13356 "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
13357 "sort" => Ok(GeneratedField::Sort),
13358 "watermarkFilter" | "watermark_filter" => Ok(GeneratedField::WatermarkFilter),
13359 "dml" => Ok(GeneratedField::Dml),
13360 "rowIdGen" | "row_id_gen" => Ok(GeneratedField::RowIdGen),
13361 "now" => Ok(GeneratedField::Now),
13362 "appendOnlyGroupTopN" | "append_only_group_top_n" => Ok(GeneratedField::AppendOnlyGroupTopN),
13363 "temporalJoin" | "temporal_join" => Ok(GeneratedField::TemporalJoin),
13364 "barrierRecv" | "barrier_recv" => Ok(GeneratedField::BarrierRecv),
13365 "values" => Ok(GeneratedField::Values),
13366 "appendOnlyDedup" | "append_only_dedup" => Ok(GeneratedField::AppendOnlyDedup),
13367 "noOp" | "no_op" => Ok(GeneratedField::NoOp),
13368 "eowcOverWindow" | "eowc_over_window" => Ok(GeneratedField::EowcOverWindow),
13369 "overWindow" | "over_window" => Ok(GeneratedField::OverWindow),
13370 "streamFsFetch" | "stream_fs_fetch" => Ok(GeneratedField::StreamFsFetch),
13371 "streamCdcScan" | "stream_cdc_scan" => Ok(GeneratedField::StreamCdcScan),
13372 "cdcFilter" | "cdc_filter" => Ok(GeneratedField::CdcFilter),
13373 "sourceBackfill" | "source_backfill" => Ok(GeneratedField::SourceBackfill),
13374 "changelog" => Ok(GeneratedField::Changelog),
13375 "localApproxPercentile" | "local_approx_percentile" => Ok(GeneratedField::LocalApproxPercentile),
13376 "globalApproxPercentile" | "global_approx_percentile" => Ok(GeneratedField::GlobalApproxPercentile),
13377 "rowMerge" | "row_merge" => Ok(GeneratedField::RowMerge),
13378 "asOfJoin" | "as_of_join" => Ok(GeneratedField::AsOfJoin),
13379 "syncLogStore" | "sync_log_store" => Ok(GeneratedField::SyncLogStore),
13380 "materializedExprs" | "materialized_exprs" => Ok(GeneratedField::MaterializedExprs),
13381 "vectorIndexWrite" | "vector_index_write" => Ok(GeneratedField::VectorIndexWrite),
13382 "upstreamSinkUnion" | "upstream_sink_union" => Ok(GeneratedField::UpstreamSinkUnion),
13383 "localityProvider" | "locality_provider" => Ok(GeneratedField::LocalityProvider),
13384 "eowcGapFill" | "eowc_gap_fill" => Ok(GeneratedField::EowcGapFill),
13385 "gapFill" | "gap_fill" => Ok(GeneratedField::GapFill),
13386 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13387 }
13388 }
13389 }
13390 deserializer.deserialize_identifier(GeneratedVisitor)
13391 }
13392 }
13393 struct GeneratedVisitor;
13394 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13395 type Value = StreamNode;
13396
13397 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13398 formatter.write_str("struct stream_plan.StreamNode")
13399 }
13400
13401 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamNode, V::Error>
13402 where
13403 V: serde::de::MapAccess<'de>,
13404 {
13405 let mut operator_id__ = None;
13406 let mut input__ = None;
13407 let mut stream_key__ = None;
13408 let mut stream_kind__ = None;
13409 let mut identity__ = None;
13410 let mut fields__ = None;
13411 let mut node_body__ = None;
13412 while let Some(k) = map_.next_key()? {
13413 match k {
13414 GeneratedField::OperatorId => {
13415 if operator_id__.is_some() {
13416 return Err(serde::de::Error::duplicate_field("operatorId"));
13417 }
13418 operator_id__ =
13419 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13420 ;
13421 }
13422 GeneratedField::Input => {
13423 if input__.is_some() {
13424 return Err(serde::de::Error::duplicate_field("input"));
13425 }
13426 input__ = Some(map_.next_value()?);
13427 }
13428 GeneratedField::StreamKey => {
13429 if stream_key__.is_some() {
13430 return Err(serde::de::Error::duplicate_field("streamKey"));
13431 }
13432 stream_key__ =
13433 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13434 .into_iter().map(|x| x.0).collect())
13435 ;
13436 }
13437 GeneratedField::StreamKind => {
13438 if stream_kind__.is_some() {
13439 return Err(serde::de::Error::duplicate_field("streamKind"));
13440 }
13441 stream_kind__ = Some(map_.next_value::<stream_node::StreamKind>()? as i32);
13442 }
13443 GeneratedField::Identity => {
13444 if identity__.is_some() {
13445 return Err(serde::de::Error::duplicate_field("identity"));
13446 }
13447 identity__ = Some(map_.next_value()?);
13448 }
13449 GeneratedField::Fields => {
13450 if fields__.is_some() {
13451 return Err(serde::de::Error::duplicate_field("fields"));
13452 }
13453 fields__ = Some(map_.next_value()?);
13454 }
13455 GeneratedField::Source => {
13456 if node_body__.is_some() {
13457 return Err(serde::de::Error::duplicate_field("source"));
13458 }
13459 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Source)
13460;
13461 }
13462 GeneratedField::Project => {
13463 if node_body__.is_some() {
13464 return Err(serde::de::Error::duplicate_field("project"));
13465 }
13466 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Project)
13467;
13468 }
13469 GeneratedField::Filter => {
13470 if node_body__.is_some() {
13471 return Err(serde::de::Error::duplicate_field("filter"));
13472 }
13473 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Filter)
13474;
13475 }
13476 GeneratedField::Materialize => {
13477 if node_body__.is_some() {
13478 return Err(serde::de::Error::duplicate_field("materialize"));
13479 }
13480 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Materialize)
13481;
13482 }
13483 GeneratedField::StatelessSimpleAgg => {
13484 if node_body__.is_some() {
13485 return Err(serde::de::Error::duplicate_field("statelessSimpleAgg"));
13486 }
13487 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StatelessSimpleAgg)
13488;
13489 }
13490 GeneratedField::SimpleAgg => {
13491 if node_body__.is_some() {
13492 return Err(serde::de::Error::duplicate_field("simpleAgg"));
13493 }
13494 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SimpleAgg)
13495;
13496 }
13497 GeneratedField::HashAgg => {
13498 if node_body__.is_some() {
13499 return Err(serde::de::Error::duplicate_field("hashAgg"));
13500 }
13501 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashAgg)
13502;
13503 }
13504 GeneratedField::AppendOnlyTopN => {
13505 if node_body__.is_some() {
13506 return Err(serde::de::Error::duplicate_field("appendOnlyTopN"));
13507 }
13508 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyTopN)
13509;
13510 }
13511 GeneratedField::HashJoin => {
13512 if node_body__.is_some() {
13513 return Err(serde::de::Error::duplicate_field("hashJoin"));
13514 }
13515 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashJoin)
13516;
13517 }
13518 GeneratedField::TopN => {
13519 if node_body__.is_some() {
13520 return Err(serde::de::Error::duplicate_field("topN"));
13521 }
13522 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TopN)
13523;
13524 }
13525 GeneratedField::HopWindow => {
13526 if node_body__.is_some() {
13527 return Err(serde::de::Error::duplicate_field("hopWindow"));
13528 }
13529 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HopWindow)
13530;
13531 }
13532 GeneratedField::Merge => {
13533 if node_body__.is_some() {
13534 return Err(serde::de::Error::duplicate_field("merge"));
13535 }
13536 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Merge)
13537;
13538 }
13539 GeneratedField::Exchange => {
13540 if node_body__.is_some() {
13541 return Err(serde::de::Error::duplicate_field("exchange"));
13542 }
13543 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Exchange)
13544;
13545 }
13546 GeneratedField::StreamScan => {
13547 if node_body__.is_some() {
13548 return Err(serde::de::Error::duplicate_field("streamScan"));
13549 }
13550 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamScan)
13551;
13552 }
13553 GeneratedField::BatchPlan => {
13554 if node_body__.is_some() {
13555 return Err(serde::de::Error::duplicate_field("batchPlan"));
13556 }
13557 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BatchPlan)
13558;
13559 }
13560 GeneratedField::Lookup => {
13561 if node_body__.is_some() {
13562 return Err(serde::de::Error::duplicate_field("lookup"));
13563 }
13564 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Lookup)
13565;
13566 }
13567 GeneratedField::Arrange => {
13568 if node_body__.is_some() {
13569 return Err(serde::de::Error::duplicate_field("arrange"));
13570 }
13571 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Arrange)
13572;
13573 }
13574 GeneratedField::LookupUnion => {
13575 if node_body__.is_some() {
13576 return Err(serde::de::Error::duplicate_field("lookupUnion"));
13577 }
13578 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LookupUnion)
13579;
13580 }
13581 GeneratedField::Union => {
13582 if node_body__.is_some() {
13583 return Err(serde::de::Error::duplicate_field("union"));
13584 }
13585 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Union)
13586;
13587 }
13588 GeneratedField::DeltaIndexJoin => {
13589 if node_body__.is_some() {
13590 return Err(serde::de::Error::duplicate_field("deltaIndexJoin"));
13591 }
13592 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DeltaIndexJoin)
13593;
13594 }
13595 GeneratedField::Sink => {
13596 if node_body__.is_some() {
13597 return Err(serde::de::Error::duplicate_field("sink"));
13598 }
13599 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sink)
13600;
13601 }
13602 GeneratedField::Expand => {
13603 if node_body__.is_some() {
13604 return Err(serde::de::Error::duplicate_field("expand"));
13605 }
13606 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Expand)
13607;
13608 }
13609 GeneratedField::DynamicFilter => {
13610 if node_body__.is_some() {
13611 return Err(serde::de::Error::duplicate_field("dynamicFilter"));
13612 }
13613 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DynamicFilter)
13614;
13615 }
13616 GeneratedField::ProjectSet => {
13617 if node_body__.is_some() {
13618 return Err(serde::de::Error::duplicate_field("projectSet"));
13619 }
13620 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::ProjectSet)
13621;
13622 }
13623 GeneratedField::GroupTopN => {
13624 if node_body__.is_some() {
13625 return Err(serde::de::Error::duplicate_field("groupTopN"));
13626 }
13627 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GroupTopN)
13628;
13629 }
13630 GeneratedField::Sort => {
13631 if node_body__.is_some() {
13632 return Err(serde::de::Error::duplicate_field("sort"));
13633 }
13634 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sort)
13635;
13636 }
13637 GeneratedField::WatermarkFilter => {
13638 if node_body__.is_some() {
13639 return Err(serde::de::Error::duplicate_field("watermarkFilter"));
13640 }
13641 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::WatermarkFilter)
13642;
13643 }
13644 GeneratedField::Dml => {
13645 if node_body__.is_some() {
13646 return Err(serde::de::Error::duplicate_field("dml"));
13647 }
13648 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Dml)
13649;
13650 }
13651 GeneratedField::RowIdGen => {
13652 if node_body__.is_some() {
13653 return Err(serde::de::Error::duplicate_field("rowIdGen"));
13654 }
13655 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowIdGen)
13656;
13657 }
13658 GeneratedField::Now => {
13659 if node_body__.is_some() {
13660 return Err(serde::de::Error::duplicate_field("now"));
13661 }
13662 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Now)
13663;
13664 }
13665 GeneratedField::AppendOnlyGroupTopN => {
13666 if node_body__.is_some() {
13667 return Err(serde::de::Error::duplicate_field("appendOnlyGroupTopN"));
13668 }
13669 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyGroupTopN)
13670;
13671 }
13672 GeneratedField::TemporalJoin => {
13673 if node_body__.is_some() {
13674 return Err(serde::de::Error::duplicate_field("temporalJoin"));
13675 }
13676 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TemporalJoin)
13677;
13678 }
13679 GeneratedField::BarrierRecv => {
13680 if node_body__.is_some() {
13681 return Err(serde::de::Error::duplicate_field("barrierRecv"));
13682 }
13683 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BarrierRecv)
13684;
13685 }
13686 GeneratedField::Values => {
13687 if node_body__.is_some() {
13688 return Err(serde::de::Error::duplicate_field("values"));
13689 }
13690 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Values)
13691;
13692 }
13693 GeneratedField::AppendOnlyDedup => {
13694 if node_body__.is_some() {
13695 return Err(serde::de::Error::duplicate_field("appendOnlyDedup"));
13696 }
13697 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyDedup)
13698;
13699 }
13700 GeneratedField::NoOp => {
13701 if node_body__.is_some() {
13702 return Err(serde::de::Error::duplicate_field("noOp"));
13703 }
13704 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::NoOp)
13705;
13706 }
13707 GeneratedField::EowcOverWindow => {
13708 if node_body__.is_some() {
13709 return Err(serde::de::Error::duplicate_field("eowcOverWindow"));
13710 }
13711 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcOverWindow)
13712;
13713 }
13714 GeneratedField::OverWindow => {
13715 if node_body__.is_some() {
13716 return Err(serde::de::Error::duplicate_field("overWindow"));
13717 }
13718 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::OverWindow)
13719;
13720 }
13721 GeneratedField::StreamFsFetch => {
13722 if node_body__.is_some() {
13723 return Err(serde::de::Error::duplicate_field("streamFsFetch"));
13724 }
13725 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamFsFetch)
13726;
13727 }
13728 GeneratedField::StreamCdcScan => {
13729 if node_body__.is_some() {
13730 return Err(serde::de::Error::duplicate_field("streamCdcScan"));
13731 }
13732 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamCdcScan)
13733;
13734 }
13735 GeneratedField::CdcFilter => {
13736 if node_body__.is_some() {
13737 return Err(serde::de::Error::duplicate_field("cdcFilter"));
13738 }
13739 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CdcFilter)
13740;
13741 }
13742 GeneratedField::SourceBackfill => {
13743 if node_body__.is_some() {
13744 return Err(serde::de::Error::duplicate_field("sourceBackfill"));
13745 }
13746 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SourceBackfill)
13747;
13748 }
13749 GeneratedField::Changelog => {
13750 if node_body__.is_some() {
13751 return Err(serde::de::Error::duplicate_field("changelog"));
13752 }
13753 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Changelog)
13754;
13755 }
13756 GeneratedField::LocalApproxPercentile => {
13757 if node_body__.is_some() {
13758 return Err(serde::de::Error::duplicate_field("localApproxPercentile"));
13759 }
13760 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalApproxPercentile)
13761;
13762 }
13763 GeneratedField::GlobalApproxPercentile => {
13764 if node_body__.is_some() {
13765 return Err(serde::de::Error::duplicate_field("globalApproxPercentile"));
13766 }
13767 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GlobalApproxPercentile)
13768;
13769 }
13770 GeneratedField::RowMerge => {
13771 if node_body__.is_some() {
13772 return Err(serde::de::Error::duplicate_field("rowMerge"));
13773 }
13774 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowMerge)
13775;
13776 }
13777 GeneratedField::AsOfJoin => {
13778 if node_body__.is_some() {
13779 return Err(serde::de::Error::duplicate_field("asOfJoin"));
13780 }
13781 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AsOfJoin)
13782;
13783 }
13784 GeneratedField::SyncLogStore => {
13785 if node_body__.is_some() {
13786 return Err(serde::de::Error::duplicate_field("syncLogStore"));
13787 }
13788 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SyncLogStore)
13789;
13790 }
13791 GeneratedField::MaterializedExprs => {
13792 if node_body__.is_some() {
13793 return Err(serde::de::Error::duplicate_field("materializedExprs"));
13794 }
13795 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MaterializedExprs)
13796;
13797 }
13798 GeneratedField::VectorIndexWrite => {
13799 if node_body__.is_some() {
13800 return Err(serde::de::Error::duplicate_field("vectorIndexWrite"));
13801 }
13802 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexWrite)
13803;
13804 }
13805 GeneratedField::UpstreamSinkUnion => {
13806 if node_body__.is_some() {
13807 return Err(serde::de::Error::duplicate_field("upstreamSinkUnion"));
13808 }
13809 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::UpstreamSinkUnion)
13810;
13811 }
13812 GeneratedField::LocalityProvider => {
13813 if node_body__.is_some() {
13814 return Err(serde::de::Error::duplicate_field("localityProvider"));
13815 }
13816 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalityProvider)
13817;
13818 }
13819 GeneratedField::EowcGapFill => {
13820 if node_body__.is_some() {
13821 return Err(serde::de::Error::duplicate_field("eowcGapFill"));
13822 }
13823 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcGapFill)
13824;
13825 }
13826 GeneratedField::GapFill => {
13827 if node_body__.is_some() {
13828 return Err(serde::de::Error::duplicate_field("gapFill"));
13829 }
13830 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GapFill)
13831;
13832 }
13833 }
13834 }
13835 Ok(StreamNode {
13836 operator_id: operator_id__.unwrap_or_default(),
13837 input: input__.unwrap_or_default(),
13838 stream_key: stream_key__.unwrap_or_default(),
13839 stream_kind: stream_kind__.unwrap_or_default(),
13840 identity: identity__.unwrap_or_default(),
13841 fields: fields__.unwrap_or_default(),
13842 node_body: node_body__,
13843 })
13844 }
13845 }
13846 deserializer.deserialize_struct("stream_plan.StreamNode", FIELDS, GeneratedVisitor)
13847 }
13848}
13849impl serde::Serialize for stream_node::StreamKind {
13850 #[allow(deprecated)]
13851 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13852 where
13853 S: serde::Serializer,
13854 {
13855 let variant = match self {
13856 Self::Retract => "STREAM_KIND_RETRACT",
13857 Self::AppendOnly => "STREAM_KIND_APPEND_ONLY",
13858 Self::Upsert => "STREAM_KIND_UPSERT",
13859 };
13860 serializer.serialize_str(variant)
13861 }
13862}
13863impl<'de> serde::Deserialize<'de> for stream_node::StreamKind {
13864 #[allow(deprecated)]
13865 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13866 where
13867 D: serde::Deserializer<'de>,
13868 {
13869 const FIELDS: &[&str] = &[
13870 "STREAM_KIND_RETRACT",
13871 "STREAM_KIND_APPEND_ONLY",
13872 "STREAM_KIND_UPSERT",
13873 ];
13874
13875 struct GeneratedVisitor;
13876
13877 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13878 type Value = stream_node::StreamKind;
13879
13880 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13881 write!(formatter, "expected one of: {:?}", &FIELDS)
13882 }
13883
13884 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13885 where
13886 E: serde::de::Error,
13887 {
13888 i32::try_from(v)
13889 .ok()
13890 .and_then(|x| x.try_into().ok())
13891 .ok_or_else(|| {
13892 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13893 })
13894 }
13895
13896 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13897 where
13898 E: serde::de::Error,
13899 {
13900 i32::try_from(v)
13901 .ok()
13902 .and_then(|x| x.try_into().ok())
13903 .ok_or_else(|| {
13904 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13905 })
13906 }
13907
13908 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13909 where
13910 E: serde::de::Error,
13911 {
13912 match value {
13913 "STREAM_KIND_RETRACT" => Ok(stream_node::StreamKind::Retract),
13914 "STREAM_KIND_APPEND_ONLY" => Ok(stream_node::StreamKind::AppendOnly),
13915 "STREAM_KIND_UPSERT" => Ok(stream_node::StreamKind::Upsert),
13916 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13917 }
13918 }
13919 }
13920 deserializer.deserialize_any(GeneratedVisitor)
13921 }
13922}
13923impl serde::Serialize for StreamScanNode {
13924 #[allow(deprecated)]
13925 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13926 where
13927 S: serde::Serializer,
13928 {
13929 use serde::ser::SerializeStruct;
13930 let mut len = 0;
13931 if self.table_id != 0 {
13932 len += 1;
13933 }
13934 if !self.upstream_column_ids.is_empty() {
13935 len += 1;
13936 }
13937 if !self.output_indices.is_empty() {
13938 len += 1;
13939 }
13940 if self.stream_scan_type != 0 {
13941 len += 1;
13942 }
13943 if self.state_table.is_some() {
13944 len += 1;
13945 }
13946 if self.table_desc.is_some() {
13947 len += 1;
13948 }
13949 if self.rate_limit.is_some() {
13950 len += 1;
13951 }
13952 if self.snapshot_read_barrier_interval != 0 {
13953 len += 1;
13954 }
13955 if self.arrangement_table.is_some() {
13956 len += 1;
13957 }
13958 if self.snapshot_backfill_epoch.is_some() {
13959 len += 1;
13960 }
13961 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamScanNode", len)?;
13962 if self.table_id != 0 {
13963 struct_ser.serialize_field("tableId", &self.table_id)?;
13964 }
13965 if !self.upstream_column_ids.is_empty() {
13966 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
13967 }
13968 if !self.output_indices.is_empty() {
13969 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
13970 }
13971 if self.stream_scan_type != 0 {
13972 let v = StreamScanType::try_from(self.stream_scan_type)
13973 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_scan_type)))?;
13974 struct_ser.serialize_field("streamScanType", &v)?;
13975 }
13976 if let Some(v) = self.state_table.as_ref() {
13977 struct_ser.serialize_field("stateTable", v)?;
13978 }
13979 if let Some(v) = self.table_desc.as_ref() {
13980 struct_ser.serialize_field("tableDesc", v)?;
13981 }
13982 if let Some(v) = self.rate_limit.as_ref() {
13983 struct_ser.serialize_field("rateLimit", v)?;
13984 }
13985 if self.snapshot_read_barrier_interval != 0 {
13986 struct_ser.serialize_field("snapshotReadBarrierInterval", &self.snapshot_read_barrier_interval)?;
13987 }
13988 if let Some(v) = self.arrangement_table.as_ref() {
13989 struct_ser.serialize_field("arrangementTable", v)?;
13990 }
13991 if let Some(v) = self.snapshot_backfill_epoch.as_ref() {
13992 #[allow(clippy::needless_borrow)]
13993 #[allow(clippy::needless_borrows_for_generic_args)]
13994 struct_ser.serialize_field("snapshotBackfillEpoch", ToString::to_string(&v).as_str())?;
13995 }
13996 struct_ser.end()
13997 }
13998}
13999impl<'de> serde::Deserialize<'de> for StreamScanNode {
14000 #[allow(deprecated)]
14001 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14002 where
14003 D: serde::Deserializer<'de>,
14004 {
14005 const FIELDS: &[&str] = &[
14006 "table_id",
14007 "tableId",
14008 "upstream_column_ids",
14009 "upstreamColumnIds",
14010 "output_indices",
14011 "outputIndices",
14012 "stream_scan_type",
14013 "streamScanType",
14014 "state_table",
14015 "stateTable",
14016 "table_desc",
14017 "tableDesc",
14018 "rate_limit",
14019 "rateLimit",
14020 "snapshot_read_barrier_interval",
14021 "snapshotReadBarrierInterval",
14022 "arrangement_table",
14023 "arrangementTable",
14024 "snapshot_backfill_epoch",
14025 "snapshotBackfillEpoch",
14026 ];
14027
14028 #[allow(clippy::enum_variant_names)]
14029 enum GeneratedField {
14030 TableId,
14031 UpstreamColumnIds,
14032 OutputIndices,
14033 StreamScanType,
14034 StateTable,
14035 TableDesc,
14036 RateLimit,
14037 SnapshotReadBarrierInterval,
14038 ArrangementTable,
14039 SnapshotBackfillEpoch,
14040 }
14041 impl<'de> serde::Deserialize<'de> for GeneratedField {
14042 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14043 where
14044 D: serde::Deserializer<'de>,
14045 {
14046 struct GeneratedVisitor;
14047
14048 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14049 type Value = GeneratedField;
14050
14051 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14052 write!(formatter, "expected one of: {:?}", &FIELDS)
14053 }
14054
14055 #[allow(unused_variables)]
14056 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14057 where
14058 E: serde::de::Error,
14059 {
14060 match value {
14061 "tableId" | "table_id" => Ok(GeneratedField::TableId),
14062 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
14063 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
14064 "streamScanType" | "stream_scan_type" => Ok(GeneratedField::StreamScanType),
14065 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
14066 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
14067 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
14068 "snapshotReadBarrierInterval" | "snapshot_read_barrier_interval" => Ok(GeneratedField::SnapshotReadBarrierInterval),
14069 "arrangementTable" | "arrangement_table" => Ok(GeneratedField::ArrangementTable),
14070 "snapshotBackfillEpoch" | "snapshot_backfill_epoch" => Ok(GeneratedField::SnapshotBackfillEpoch),
14071 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14072 }
14073 }
14074 }
14075 deserializer.deserialize_identifier(GeneratedVisitor)
14076 }
14077 }
14078 struct GeneratedVisitor;
14079 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14080 type Value = StreamScanNode;
14081
14082 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14083 formatter.write_str("struct stream_plan.StreamScanNode")
14084 }
14085
14086 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamScanNode, V::Error>
14087 where
14088 V: serde::de::MapAccess<'de>,
14089 {
14090 let mut table_id__ = None;
14091 let mut upstream_column_ids__ = None;
14092 let mut output_indices__ = None;
14093 let mut stream_scan_type__ = None;
14094 let mut state_table__ = None;
14095 let mut table_desc__ = None;
14096 let mut rate_limit__ = None;
14097 let mut snapshot_read_barrier_interval__ = None;
14098 let mut arrangement_table__ = None;
14099 let mut snapshot_backfill_epoch__ = None;
14100 while let Some(k) = map_.next_key()? {
14101 match k {
14102 GeneratedField::TableId => {
14103 if table_id__.is_some() {
14104 return Err(serde::de::Error::duplicate_field("tableId"));
14105 }
14106 table_id__ =
14107 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14108 ;
14109 }
14110 GeneratedField::UpstreamColumnIds => {
14111 if upstream_column_ids__.is_some() {
14112 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
14113 }
14114 upstream_column_ids__ =
14115 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14116 .into_iter().map(|x| x.0).collect())
14117 ;
14118 }
14119 GeneratedField::OutputIndices => {
14120 if output_indices__.is_some() {
14121 return Err(serde::de::Error::duplicate_field("outputIndices"));
14122 }
14123 output_indices__ =
14124 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14125 .into_iter().map(|x| x.0).collect())
14126 ;
14127 }
14128 GeneratedField::StreamScanType => {
14129 if stream_scan_type__.is_some() {
14130 return Err(serde::de::Error::duplicate_field("streamScanType"));
14131 }
14132 stream_scan_type__ = Some(map_.next_value::<StreamScanType>()? as i32);
14133 }
14134 GeneratedField::StateTable => {
14135 if state_table__.is_some() {
14136 return Err(serde::de::Error::duplicate_field("stateTable"));
14137 }
14138 state_table__ = map_.next_value()?;
14139 }
14140 GeneratedField::TableDesc => {
14141 if table_desc__.is_some() {
14142 return Err(serde::de::Error::duplicate_field("tableDesc"));
14143 }
14144 table_desc__ = map_.next_value()?;
14145 }
14146 GeneratedField::RateLimit => {
14147 if rate_limit__.is_some() {
14148 return Err(serde::de::Error::duplicate_field("rateLimit"));
14149 }
14150 rate_limit__ =
14151 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14152 ;
14153 }
14154 GeneratedField::SnapshotReadBarrierInterval => {
14155 if snapshot_read_barrier_interval__.is_some() {
14156 return Err(serde::de::Error::duplicate_field("snapshotReadBarrierInterval"));
14157 }
14158 snapshot_read_barrier_interval__ =
14159 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14160 ;
14161 }
14162 GeneratedField::ArrangementTable => {
14163 if arrangement_table__.is_some() {
14164 return Err(serde::de::Error::duplicate_field("arrangementTable"));
14165 }
14166 arrangement_table__ = map_.next_value()?;
14167 }
14168 GeneratedField::SnapshotBackfillEpoch => {
14169 if snapshot_backfill_epoch__.is_some() {
14170 return Err(serde::de::Error::duplicate_field("snapshotBackfillEpoch"));
14171 }
14172 snapshot_backfill_epoch__ =
14173 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14174 ;
14175 }
14176 }
14177 }
14178 Ok(StreamScanNode {
14179 table_id: table_id__.unwrap_or_default(),
14180 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
14181 output_indices: output_indices__.unwrap_or_default(),
14182 stream_scan_type: stream_scan_type__.unwrap_or_default(),
14183 state_table: state_table__,
14184 table_desc: table_desc__,
14185 rate_limit: rate_limit__,
14186 snapshot_read_barrier_interval: snapshot_read_barrier_interval__.unwrap_or_default(),
14187 arrangement_table: arrangement_table__,
14188 snapshot_backfill_epoch: snapshot_backfill_epoch__,
14189 })
14190 }
14191 }
14192 deserializer.deserialize_struct("stream_plan.StreamScanNode", FIELDS, GeneratedVisitor)
14193 }
14194}
14195impl serde::Serialize for StreamScanType {
14196 #[allow(deprecated)]
14197 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14198 where
14199 S: serde::Serializer,
14200 {
14201 let variant = match self {
14202 Self::Unspecified => "STREAM_SCAN_TYPE_UNSPECIFIED",
14203 Self::Chain => "STREAM_SCAN_TYPE_CHAIN",
14204 Self::Rearrange => "STREAM_SCAN_TYPE_REARRANGE",
14205 Self::Backfill => "STREAM_SCAN_TYPE_BACKFILL",
14206 Self::UpstreamOnly => "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
14207 Self::ArrangementBackfill => "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
14208 Self::SnapshotBackfill => "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
14209 Self::CrossDbSnapshotBackfill => "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
14210 };
14211 serializer.serialize_str(variant)
14212 }
14213}
14214impl<'de> serde::Deserialize<'de> for StreamScanType {
14215 #[allow(deprecated)]
14216 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14217 where
14218 D: serde::Deserializer<'de>,
14219 {
14220 const FIELDS: &[&str] = &[
14221 "STREAM_SCAN_TYPE_UNSPECIFIED",
14222 "STREAM_SCAN_TYPE_CHAIN",
14223 "STREAM_SCAN_TYPE_REARRANGE",
14224 "STREAM_SCAN_TYPE_BACKFILL",
14225 "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
14226 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
14227 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
14228 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
14229 ];
14230
14231 struct GeneratedVisitor;
14232
14233 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14234 type Value = StreamScanType;
14235
14236 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14237 write!(formatter, "expected one of: {:?}", &FIELDS)
14238 }
14239
14240 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14241 where
14242 E: serde::de::Error,
14243 {
14244 i32::try_from(v)
14245 .ok()
14246 .and_then(|x| x.try_into().ok())
14247 .ok_or_else(|| {
14248 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14249 })
14250 }
14251
14252 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14253 where
14254 E: serde::de::Error,
14255 {
14256 i32::try_from(v)
14257 .ok()
14258 .and_then(|x| x.try_into().ok())
14259 .ok_or_else(|| {
14260 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14261 })
14262 }
14263
14264 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14265 where
14266 E: serde::de::Error,
14267 {
14268 match value {
14269 "STREAM_SCAN_TYPE_UNSPECIFIED" => Ok(StreamScanType::Unspecified),
14270 "STREAM_SCAN_TYPE_CHAIN" => Ok(StreamScanType::Chain),
14271 "STREAM_SCAN_TYPE_REARRANGE" => Ok(StreamScanType::Rearrange),
14272 "STREAM_SCAN_TYPE_BACKFILL" => Ok(StreamScanType::Backfill),
14273 "STREAM_SCAN_TYPE_UPSTREAM_ONLY" => Ok(StreamScanType::UpstreamOnly),
14274 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL" => Ok(StreamScanType::ArrangementBackfill),
14275 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL" => Ok(StreamScanType::SnapshotBackfill),
14276 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL" => Ok(StreamScanType::CrossDbSnapshotBackfill),
14277 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14278 }
14279 }
14280 }
14281 deserializer.deserialize_any(GeneratedVisitor)
14282 }
14283}
14284impl serde::Serialize for StreamSource {
14285 #[allow(deprecated)]
14286 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14287 where
14288 S: serde::Serializer,
14289 {
14290 use serde::ser::SerializeStruct;
14291 let mut len = 0;
14292 if self.source_id != 0 {
14293 len += 1;
14294 }
14295 if self.state_table.is_some() {
14296 len += 1;
14297 }
14298 if self.row_id_index.is_some() {
14299 len += 1;
14300 }
14301 if !self.columns.is_empty() {
14302 len += 1;
14303 }
14304 if !self.with_properties.is_empty() {
14305 len += 1;
14306 }
14307 if self.info.is_some() {
14308 len += 1;
14309 }
14310 if !self.source_name.is_empty() {
14311 len += 1;
14312 }
14313 if self.rate_limit.is_some() {
14314 len += 1;
14315 }
14316 if !self.secret_refs.is_empty() {
14317 len += 1;
14318 }
14319 if self.downstream_columns.is_some() {
14320 len += 1;
14321 }
14322 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamSource", len)?;
14323 if self.source_id != 0 {
14324 struct_ser.serialize_field("sourceId", &self.source_id)?;
14325 }
14326 if let Some(v) = self.state_table.as_ref() {
14327 struct_ser.serialize_field("stateTable", v)?;
14328 }
14329 if let Some(v) = self.row_id_index.as_ref() {
14330 struct_ser.serialize_field("rowIdIndex", v)?;
14331 }
14332 if !self.columns.is_empty() {
14333 struct_ser.serialize_field("columns", &self.columns)?;
14334 }
14335 if !self.with_properties.is_empty() {
14336 struct_ser.serialize_field("withProperties", &self.with_properties)?;
14337 }
14338 if let Some(v) = self.info.as_ref() {
14339 struct_ser.serialize_field("info", v)?;
14340 }
14341 if !self.source_name.is_empty() {
14342 struct_ser.serialize_field("sourceName", &self.source_name)?;
14343 }
14344 if let Some(v) = self.rate_limit.as_ref() {
14345 struct_ser.serialize_field("rateLimit", v)?;
14346 }
14347 if !self.secret_refs.is_empty() {
14348 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
14349 }
14350 if let Some(v) = self.downstream_columns.as_ref() {
14351 struct_ser.serialize_field("downstreamColumns", v)?;
14352 }
14353 struct_ser.end()
14354 }
14355}
14356impl<'de> serde::Deserialize<'de> for StreamSource {
14357 #[allow(deprecated)]
14358 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14359 where
14360 D: serde::Deserializer<'de>,
14361 {
14362 const FIELDS: &[&str] = &[
14363 "source_id",
14364 "sourceId",
14365 "state_table",
14366 "stateTable",
14367 "row_id_index",
14368 "rowIdIndex",
14369 "columns",
14370 "with_properties",
14371 "withProperties",
14372 "info",
14373 "source_name",
14374 "sourceName",
14375 "rate_limit",
14376 "rateLimit",
14377 "secret_refs",
14378 "secretRefs",
14379 "downstream_columns",
14380 "downstreamColumns",
14381 ];
14382
14383 #[allow(clippy::enum_variant_names)]
14384 enum GeneratedField {
14385 SourceId,
14386 StateTable,
14387 RowIdIndex,
14388 Columns,
14389 WithProperties,
14390 Info,
14391 SourceName,
14392 RateLimit,
14393 SecretRefs,
14394 DownstreamColumns,
14395 }
14396 impl<'de> serde::Deserialize<'de> for GeneratedField {
14397 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14398 where
14399 D: serde::Deserializer<'de>,
14400 {
14401 struct GeneratedVisitor;
14402
14403 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14404 type Value = GeneratedField;
14405
14406 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14407 write!(formatter, "expected one of: {:?}", &FIELDS)
14408 }
14409
14410 #[allow(unused_variables)]
14411 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14412 where
14413 E: serde::de::Error,
14414 {
14415 match value {
14416 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
14417 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
14418 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
14419 "columns" => Ok(GeneratedField::Columns),
14420 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
14421 "info" => Ok(GeneratedField::Info),
14422 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
14423 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
14424 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
14425 "downstreamColumns" | "downstream_columns" => Ok(GeneratedField::DownstreamColumns),
14426 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14427 }
14428 }
14429 }
14430 deserializer.deserialize_identifier(GeneratedVisitor)
14431 }
14432 }
14433 struct GeneratedVisitor;
14434 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14435 type Value = StreamSource;
14436
14437 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14438 formatter.write_str("struct stream_plan.StreamSource")
14439 }
14440
14441 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSource, V::Error>
14442 where
14443 V: serde::de::MapAccess<'de>,
14444 {
14445 let mut source_id__ = None;
14446 let mut state_table__ = None;
14447 let mut row_id_index__ = None;
14448 let mut columns__ = None;
14449 let mut with_properties__ = None;
14450 let mut info__ = None;
14451 let mut source_name__ = None;
14452 let mut rate_limit__ = None;
14453 let mut secret_refs__ = None;
14454 let mut downstream_columns__ = None;
14455 while let Some(k) = map_.next_key()? {
14456 match k {
14457 GeneratedField::SourceId => {
14458 if source_id__.is_some() {
14459 return Err(serde::de::Error::duplicate_field("sourceId"));
14460 }
14461 source_id__ =
14462 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14463 ;
14464 }
14465 GeneratedField::StateTable => {
14466 if state_table__.is_some() {
14467 return Err(serde::de::Error::duplicate_field("stateTable"));
14468 }
14469 state_table__ = map_.next_value()?;
14470 }
14471 GeneratedField::RowIdIndex => {
14472 if row_id_index__.is_some() {
14473 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
14474 }
14475 row_id_index__ =
14476 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14477 ;
14478 }
14479 GeneratedField::Columns => {
14480 if columns__.is_some() {
14481 return Err(serde::de::Error::duplicate_field("columns"));
14482 }
14483 columns__ = Some(map_.next_value()?);
14484 }
14485 GeneratedField::WithProperties => {
14486 if with_properties__.is_some() {
14487 return Err(serde::de::Error::duplicate_field("withProperties"));
14488 }
14489 with_properties__ = Some(
14490 map_.next_value::<std::collections::BTreeMap<_, _>>()?
14491 );
14492 }
14493 GeneratedField::Info => {
14494 if info__.is_some() {
14495 return Err(serde::de::Error::duplicate_field("info"));
14496 }
14497 info__ = map_.next_value()?;
14498 }
14499 GeneratedField::SourceName => {
14500 if source_name__.is_some() {
14501 return Err(serde::de::Error::duplicate_field("sourceName"));
14502 }
14503 source_name__ = Some(map_.next_value()?);
14504 }
14505 GeneratedField::RateLimit => {
14506 if rate_limit__.is_some() {
14507 return Err(serde::de::Error::duplicate_field("rateLimit"));
14508 }
14509 rate_limit__ =
14510 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14511 ;
14512 }
14513 GeneratedField::SecretRefs => {
14514 if secret_refs__.is_some() {
14515 return Err(serde::de::Error::duplicate_field("secretRefs"));
14516 }
14517 secret_refs__ = Some(
14518 map_.next_value::<std::collections::BTreeMap<_, _>>()?
14519 );
14520 }
14521 GeneratedField::DownstreamColumns => {
14522 if downstream_columns__.is_some() {
14523 return Err(serde::de::Error::duplicate_field("downstreamColumns"));
14524 }
14525 downstream_columns__ = map_.next_value()?;
14526 }
14527 }
14528 }
14529 Ok(StreamSource {
14530 source_id: source_id__.unwrap_or_default(),
14531 state_table: state_table__,
14532 row_id_index: row_id_index__,
14533 columns: columns__.unwrap_or_default(),
14534 with_properties: with_properties__.unwrap_or_default(),
14535 info: info__,
14536 source_name: source_name__.unwrap_or_default(),
14537 rate_limit: rate_limit__,
14538 secret_refs: secret_refs__.unwrap_or_default(),
14539 downstream_columns: downstream_columns__,
14540 })
14541 }
14542 }
14543 deserializer.deserialize_struct("stream_plan.StreamSource", FIELDS, GeneratedVisitor)
14544 }
14545}
14546impl serde::Serialize for SubscriptionUpstreamInfo {
14547 #[allow(deprecated)]
14548 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14549 where
14550 S: serde::Serializer,
14551 {
14552 use serde::ser::SerializeStruct;
14553 let mut len = 0;
14554 if self.subscriber_id != 0 {
14555 len += 1;
14556 }
14557 if self.upstream_mv_table_id != 0 {
14558 len += 1;
14559 }
14560 let mut struct_ser = serializer.serialize_struct("stream_plan.SubscriptionUpstreamInfo", len)?;
14561 if self.subscriber_id != 0 {
14562 struct_ser.serialize_field("subscriberId", &self.subscriber_id)?;
14563 }
14564 if self.upstream_mv_table_id != 0 {
14565 struct_ser.serialize_field("upstreamMvTableId", &self.upstream_mv_table_id)?;
14566 }
14567 struct_ser.end()
14568 }
14569}
14570impl<'de> serde::Deserialize<'de> for SubscriptionUpstreamInfo {
14571 #[allow(deprecated)]
14572 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14573 where
14574 D: serde::Deserializer<'de>,
14575 {
14576 const FIELDS: &[&str] = &[
14577 "subscriber_id",
14578 "subscriberId",
14579 "upstream_mv_table_id",
14580 "upstreamMvTableId",
14581 ];
14582
14583 #[allow(clippy::enum_variant_names)]
14584 enum GeneratedField {
14585 SubscriberId,
14586 UpstreamMvTableId,
14587 }
14588 impl<'de> serde::Deserialize<'de> for GeneratedField {
14589 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14590 where
14591 D: serde::Deserializer<'de>,
14592 {
14593 struct GeneratedVisitor;
14594
14595 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14596 type Value = GeneratedField;
14597
14598 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14599 write!(formatter, "expected one of: {:?}", &FIELDS)
14600 }
14601
14602 #[allow(unused_variables)]
14603 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14604 where
14605 E: serde::de::Error,
14606 {
14607 match value {
14608 "subscriberId" | "subscriber_id" => Ok(GeneratedField::SubscriberId),
14609 "upstreamMvTableId" | "upstream_mv_table_id" => Ok(GeneratedField::UpstreamMvTableId),
14610 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14611 }
14612 }
14613 }
14614 deserializer.deserialize_identifier(GeneratedVisitor)
14615 }
14616 }
14617 struct GeneratedVisitor;
14618 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14619 type Value = SubscriptionUpstreamInfo;
14620
14621 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14622 formatter.write_str("struct stream_plan.SubscriptionUpstreamInfo")
14623 }
14624
14625 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscriptionUpstreamInfo, V::Error>
14626 where
14627 V: serde::de::MapAccess<'de>,
14628 {
14629 let mut subscriber_id__ = None;
14630 let mut upstream_mv_table_id__ = None;
14631 while let Some(k) = map_.next_key()? {
14632 match k {
14633 GeneratedField::SubscriberId => {
14634 if subscriber_id__.is_some() {
14635 return Err(serde::de::Error::duplicate_field("subscriberId"));
14636 }
14637 subscriber_id__ =
14638 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14639 ;
14640 }
14641 GeneratedField::UpstreamMvTableId => {
14642 if upstream_mv_table_id__.is_some() {
14643 return Err(serde::de::Error::duplicate_field("upstreamMvTableId"));
14644 }
14645 upstream_mv_table_id__ =
14646 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14647 ;
14648 }
14649 }
14650 }
14651 Ok(SubscriptionUpstreamInfo {
14652 subscriber_id: subscriber_id__.unwrap_or_default(),
14653 upstream_mv_table_id: upstream_mv_table_id__.unwrap_or_default(),
14654 })
14655 }
14656 }
14657 deserializer.deserialize_struct("stream_plan.SubscriptionUpstreamInfo", FIELDS, GeneratedVisitor)
14658 }
14659}
14660impl serde::Serialize for SyncLogStoreNode {
14661 #[allow(deprecated)]
14662 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14663 where
14664 S: serde::Serializer,
14665 {
14666 use serde::ser::SerializeStruct;
14667 let mut len = 0;
14668 if self.log_store_table.is_some() {
14669 len += 1;
14670 }
14671 if self.pause_duration_ms != 0 {
14672 len += 1;
14673 }
14674 if self.buffer_size != 0 {
14675 len += 1;
14676 }
14677 if self.aligned {
14678 len += 1;
14679 }
14680 let mut struct_ser = serializer.serialize_struct("stream_plan.SyncLogStoreNode", len)?;
14681 if let Some(v) = self.log_store_table.as_ref() {
14682 struct_ser.serialize_field("logStoreTable", v)?;
14683 }
14684 if self.pause_duration_ms != 0 {
14685 struct_ser.serialize_field("pauseDurationMs", &self.pause_duration_ms)?;
14686 }
14687 if self.buffer_size != 0 {
14688 struct_ser.serialize_field("bufferSize", &self.buffer_size)?;
14689 }
14690 if self.aligned {
14691 struct_ser.serialize_field("aligned", &self.aligned)?;
14692 }
14693 struct_ser.end()
14694 }
14695}
14696impl<'de> serde::Deserialize<'de> for SyncLogStoreNode {
14697 #[allow(deprecated)]
14698 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14699 where
14700 D: serde::Deserializer<'de>,
14701 {
14702 const FIELDS: &[&str] = &[
14703 "log_store_table",
14704 "logStoreTable",
14705 "pause_duration_ms",
14706 "pauseDurationMs",
14707 "buffer_size",
14708 "bufferSize",
14709 "aligned",
14710 ];
14711
14712 #[allow(clippy::enum_variant_names)]
14713 enum GeneratedField {
14714 LogStoreTable,
14715 PauseDurationMs,
14716 BufferSize,
14717 Aligned,
14718 }
14719 impl<'de> serde::Deserialize<'de> for GeneratedField {
14720 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14721 where
14722 D: serde::Deserializer<'de>,
14723 {
14724 struct GeneratedVisitor;
14725
14726 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14727 type Value = GeneratedField;
14728
14729 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14730 write!(formatter, "expected one of: {:?}", &FIELDS)
14731 }
14732
14733 #[allow(unused_variables)]
14734 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14735 where
14736 E: serde::de::Error,
14737 {
14738 match value {
14739 "logStoreTable" | "log_store_table" => Ok(GeneratedField::LogStoreTable),
14740 "pauseDurationMs" | "pause_duration_ms" => Ok(GeneratedField::PauseDurationMs),
14741 "bufferSize" | "buffer_size" => Ok(GeneratedField::BufferSize),
14742 "aligned" => Ok(GeneratedField::Aligned),
14743 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14744 }
14745 }
14746 }
14747 deserializer.deserialize_identifier(GeneratedVisitor)
14748 }
14749 }
14750 struct GeneratedVisitor;
14751 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14752 type Value = SyncLogStoreNode;
14753
14754 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14755 formatter.write_str("struct stream_plan.SyncLogStoreNode")
14756 }
14757
14758 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SyncLogStoreNode, V::Error>
14759 where
14760 V: serde::de::MapAccess<'de>,
14761 {
14762 let mut log_store_table__ = None;
14763 let mut pause_duration_ms__ = None;
14764 let mut buffer_size__ = None;
14765 let mut aligned__ = None;
14766 while let Some(k) = map_.next_key()? {
14767 match k {
14768 GeneratedField::LogStoreTable => {
14769 if log_store_table__.is_some() {
14770 return Err(serde::de::Error::duplicate_field("logStoreTable"));
14771 }
14772 log_store_table__ = map_.next_value()?;
14773 }
14774 GeneratedField::PauseDurationMs => {
14775 if pause_duration_ms__.is_some() {
14776 return Err(serde::de::Error::duplicate_field("pauseDurationMs"));
14777 }
14778 pause_duration_ms__ =
14779 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14780 ;
14781 }
14782 GeneratedField::BufferSize => {
14783 if buffer_size__.is_some() {
14784 return Err(serde::de::Error::duplicate_field("bufferSize"));
14785 }
14786 buffer_size__ =
14787 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14788 ;
14789 }
14790 GeneratedField::Aligned => {
14791 if aligned__.is_some() {
14792 return Err(serde::de::Error::duplicate_field("aligned"));
14793 }
14794 aligned__ = Some(map_.next_value()?);
14795 }
14796 }
14797 }
14798 Ok(SyncLogStoreNode {
14799 log_store_table: log_store_table__,
14800 pause_duration_ms: pause_duration_ms__.unwrap_or_default(),
14801 buffer_size: buffer_size__.unwrap_or_default(),
14802 aligned: aligned__.unwrap_or_default(),
14803 })
14804 }
14805 }
14806 deserializer.deserialize_struct("stream_plan.SyncLogStoreNode", FIELDS, GeneratedVisitor)
14807 }
14808}
14809impl serde::Serialize for TemporalJoinNode {
14810 #[allow(deprecated)]
14811 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14812 where
14813 S: serde::Serializer,
14814 {
14815 use serde::ser::SerializeStruct;
14816 let mut len = 0;
14817 if self.join_type != 0 {
14818 len += 1;
14819 }
14820 if !self.left_key.is_empty() {
14821 len += 1;
14822 }
14823 if !self.right_key.is_empty() {
14824 len += 1;
14825 }
14826 if !self.null_safe.is_empty() {
14827 len += 1;
14828 }
14829 if self.condition.is_some() {
14830 len += 1;
14831 }
14832 if !self.output_indices.is_empty() {
14833 len += 1;
14834 }
14835 if self.table_desc.is_some() {
14836 len += 1;
14837 }
14838 if !self.table_output_indices.is_empty() {
14839 len += 1;
14840 }
14841 if self.memo_table.is_some() {
14842 len += 1;
14843 }
14844 if self.is_nested_loop {
14845 len += 1;
14846 }
14847 let mut struct_ser = serializer.serialize_struct("stream_plan.TemporalJoinNode", len)?;
14848 if self.join_type != 0 {
14849 let v = super::plan_common::JoinType::try_from(self.join_type)
14850 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
14851 struct_ser.serialize_field("joinType", &v)?;
14852 }
14853 if !self.left_key.is_empty() {
14854 struct_ser.serialize_field("leftKey", &self.left_key)?;
14855 }
14856 if !self.right_key.is_empty() {
14857 struct_ser.serialize_field("rightKey", &self.right_key)?;
14858 }
14859 if !self.null_safe.is_empty() {
14860 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
14861 }
14862 if let Some(v) = self.condition.as_ref() {
14863 struct_ser.serialize_field("condition", v)?;
14864 }
14865 if !self.output_indices.is_empty() {
14866 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
14867 }
14868 if let Some(v) = self.table_desc.as_ref() {
14869 struct_ser.serialize_field("tableDesc", v)?;
14870 }
14871 if !self.table_output_indices.is_empty() {
14872 struct_ser.serialize_field("tableOutputIndices", &self.table_output_indices)?;
14873 }
14874 if let Some(v) = self.memo_table.as_ref() {
14875 struct_ser.serialize_field("memoTable", v)?;
14876 }
14877 if self.is_nested_loop {
14878 struct_ser.serialize_field("isNestedLoop", &self.is_nested_loop)?;
14879 }
14880 struct_ser.end()
14881 }
14882}
14883impl<'de> serde::Deserialize<'de> for TemporalJoinNode {
14884 #[allow(deprecated)]
14885 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14886 where
14887 D: serde::Deserializer<'de>,
14888 {
14889 const FIELDS: &[&str] = &[
14890 "join_type",
14891 "joinType",
14892 "left_key",
14893 "leftKey",
14894 "right_key",
14895 "rightKey",
14896 "null_safe",
14897 "nullSafe",
14898 "condition",
14899 "output_indices",
14900 "outputIndices",
14901 "table_desc",
14902 "tableDesc",
14903 "table_output_indices",
14904 "tableOutputIndices",
14905 "memo_table",
14906 "memoTable",
14907 "is_nested_loop",
14908 "isNestedLoop",
14909 ];
14910
14911 #[allow(clippy::enum_variant_names)]
14912 enum GeneratedField {
14913 JoinType,
14914 LeftKey,
14915 RightKey,
14916 NullSafe,
14917 Condition,
14918 OutputIndices,
14919 TableDesc,
14920 TableOutputIndices,
14921 MemoTable,
14922 IsNestedLoop,
14923 }
14924 impl<'de> serde::Deserialize<'de> for GeneratedField {
14925 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14926 where
14927 D: serde::Deserializer<'de>,
14928 {
14929 struct GeneratedVisitor;
14930
14931 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14932 type Value = GeneratedField;
14933
14934 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14935 write!(formatter, "expected one of: {:?}", &FIELDS)
14936 }
14937
14938 #[allow(unused_variables)]
14939 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14940 where
14941 E: serde::de::Error,
14942 {
14943 match value {
14944 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
14945 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
14946 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
14947 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
14948 "condition" => Ok(GeneratedField::Condition),
14949 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
14950 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
14951 "tableOutputIndices" | "table_output_indices" => Ok(GeneratedField::TableOutputIndices),
14952 "memoTable" | "memo_table" => Ok(GeneratedField::MemoTable),
14953 "isNestedLoop" | "is_nested_loop" => Ok(GeneratedField::IsNestedLoop),
14954 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14955 }
14956 }
14957 }
14958 deserializer.deserialize_identifier(GeneratedVisitor)
14959 }
14960 }
14961 struct GeneratedVisitor;
14962 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14963 type Value = TemporalJoinNode;
14964
14965 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14966 formatter.write_str("struct stream_plan.TemporalJoinNode")
14967 }
14968
14969 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TemporalJoinNode, V::Error>
14970 where
14971 V: serde::de::MapAccess<'de>,
14972 {
14973 let mut join_type__ = None;
14974 let mut left_key__ = None;
14975 let mut right_key__ = None;
14976 let mut null_safe__ = None;
14977 let mut condition__ = None;
14978 let mut output_indices__ = None;
14979 let mut table_desc__ = None;
14980 let mut table_output_indices__ = None;
14981 let mut memo_table__ = None;
14982 let mut is_nested_loop__ = None;
14983 while let Some(k) = map_.next_key()? {
14984 match k {
14985 GeneratedField::JoinType => {
14986 if join_type__.is_some() {
14987 return Err(serde::de::Error::duplicate_field("joinType"));
14988 }
14989 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
14990 }
14991 GeneratedField::LeftKey => {
14992 if left_key__.is_some() {
14993 return Err(serde::de::Error::duplicate_field("leftKey"));
14994 }
14995 left_key__ =
14996 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14997 .into_iter().map(|x| x.0).collect())
14998 ;
14999 }
15000 GeneratedField::RightKey => {
15001 if right_key__.is_some() {
15002 return Err(serde::de::Error::duplicate_field("rightKey"));
15003 }
15004 right_key__ =
15005 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15006 .into_iter().map(|x| x.0).collect())
15007 ;
15008 }
15009 GeneratedField::NullSafe => {
15010 if null_safe__.is_some() {
15011 return Err(serde::de::Error::duplicate_field("nullSafe"));
15012 }
15013 null_safe__ = Some(map_.next_value()?);
15014 }
15015 GeneratedField::Condition => {
15016 if condition__.is_some() {
15017 return Err(serde::de::Error::duplicate_field("condition"));
15018 }
15019 condition__ = map_.next_value()?;
15020 }
15021 GeneratedField::OutputIndices => {
15022 if output_indices__.is_some() {
15023 return Err(serde::de::Error::duplicate_field("outputIndices"));
15024 }
15025 output_indices__ =
15026 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15027 .into_iter().map(|x| x.0).collect())
15028 ;
15029 }
15030 GeneratedField::TableDesc => {
15031 if table_desc__.is_some() {
15032 return Err(serde::de::Error::duplicate_field("tableDesc"));
15033 }
15034 table_desc__ = map_.next_value()?;
15035 }
15036 GeneratedField::TableOutputIndices => {
15037 if table_output_indices__.is_some() {
15038 return Err(serde::de::Error::duplicate_field("tableOutputIndices"));
15039 }
15040 table_output_indices__ =
15041 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15042 .into_iter().map(|x| x.0).collect())
15043 ;
15044 }
15045 GeneratedField::MemoTable => {
15046 if memo_table__.is_some() {
15047 return Err(serde::de::Error::duplicate_field("memoTable"));
15048 }
15049 memo_table__ = map_.next_value()?;
15050 }
15051 GeneratedField::IsNestedLoop => {
15052 if is_nested_loop__.is_some() {
15053 return Err(serde::de::Error::duplicate_field("isNestedLoop"));
15054 }
15055 is_nested_loop__ = Some(map_.next_value()?);
15056 }
15057 }
15058 }
15059 Ok(TemporalJoinNode {
15060 join_type: join_type__.unwrap_or_default(),
15061 left_key: left_key__.unwrap_or_default(),
15062 right_key: right_key__.unwrap_or_default(),
15063 null_safe: null_safe__.unwrap_or_default(),
15064 condition: condition__,
15065 output_indices: output_indices__.unwrap_or_default(),
15066 table_desc: table_desc__,
15067 table_output_indices: table_output_indices__.unwrap_or_default(),
15068 memo_table: memo_table__,
15069 is_nested_loop: is_nested_loop__.unwrap_or_default(),
15070 })
15071 }
15072 }
15073 deserializer.deserialize_struct("stream_plan.TemporalJoinNode", FIELDS, GeneratedVisitor)
15074 }
15075}
15076impl serde::Serialize for ThrottleMutation {
15077 #[allow(deprecated)]
15078 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15079 where
15080 S: serde::Serializer,
15081 {
15082 use serde::ser::SerializeStruct;
15083 let mut len = 0;
15084 if !self.actor_throttle.is_empty() {
15085 len += 1;
15086 }
15087 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation", len)?;
15088 if !self.actor_throttle.is_empty() {
15089 struct_ser.serialize_field("actorThrottle", &self.actor_throttle)?;
15090 }
15091 struct_ser.end()
15092 }
15093}
15094impl<'de> serde::Deserialize<'de> for ThrottleMutation {
15095 #[allow(deprecated)]
15096 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15097 where
15098 D: serde::Deserializer<'de>,
15099 {
15100 const FIELDS: &[&str] = &[
15101 "actor_throttle",
15102 "actorThrottle",
15103 ];
15104
15105 #[allow(clippy::enum_variant_names)]
15106 enum GeneratedField {
15107 ActorThrottle,
15108 }
15109 impl<'de> serde::Deserialize<'de> for GeneratedField {
15110 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15111 where
15112 D: serde::Deserializer<'de>,
15113 {
15114 struct GeneratedVisitor;
15115
15116 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15117 type Value = GeneratedField;
15118
15119 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15120 write!(formatter, "expected one of: {:?}", &FIELDS)
15121 }
15122
15123 #[allow(unused_variables)]
15124 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15125 where
15126 E: serde::de::Error,
15127 {
15128 match value {
15129 "actorThrottle" | "actor_throttle" => Ok(GeneratedField::ActorThrottle),
15130 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15131 }
15132 }
15133 }
15134 deserializer.deserialize_identifier(GeneratedVisitor)
15135 }
15136 }
15137 struct GeneratedVisitor;
15138 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15139 type Value = ThrottleMutation;
15140
15141 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15142 formatter.write_str("struct stream_plan.ThrottleMutation")
15143 }
15144
15145 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ThrottleMutation, V::Error>
15146 where
15147 V: serde::de::MapAccess<'de>,
15148 {
15149 let mut actor_throttle__ = None;
15150 while let Some(k) = map_.next_key()? {
15151 match k {
15152 GeneratedField::ActorThrottle => {
15153 if actor_throttle__.is_some() {
15154 return Err(serde::de::Error::duplicate_field("actorThrottle"));
15155 }
15156 actor_throttle__ = Some(
15157 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15158 .into_iter().map(|(k,v)| (k.0, v)).collect()
15159 );
15160 }
15161 }
15162 }
15163 Ok(ThrottleMutation {
15164 actor_throttle: actor_throttle__.unwrap_or_default(),
15165 })
15166 }
15167 }
15168 deserializer.deserialize_struct("stream_plan.ThrottleMutation", FIELDS, GeneratedVisitor)
15169 }
15170}
15171impl serde::Serialize for throttle_mutation::RateLimit {
15172 #[allow(deprecated)]
15173 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15174 where
15175 S: serde::Serializer,
15176 {
15177 use serde::ser::SerializeStruct;
15178 let mut len = 0;
15179 if self.rate_limit.is_some() {
15180 len += 1;
15181 }
15182 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation.RateLimit", len)?;
15183 if let Some(v) = self.rate_limit.as_ref() {
15184 struct_ser.serialize_field("rateLimit", v)?;
15185 }
15186 struct_ser.end()
15187 }
15188}
15189impl<'de> serde::Deserialize<'de> for throttle_mutation::RateLimit {
15190 #[allow(deprecated)]
15191 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15192 where
15193 D: serde::Deserializer<'de>,
15194 {
15195 const FIELDS: &[&str] = &[
15196 "rate_limit",
15197 "rateLimit",
15198 ];
15199
15200 #[allow(clippy::enum_variant_names)]
15201 enum GeneratedField {
15202 RateLimit,
15203 }
15204 impl<'de> serde::Deserialize<'de> for GeneratedField {
15205 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15206 where
15207 D: serde::Deserializer<'de>,
15208 {
15209 struct GeneratedVisitor;
15210
15211 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15212 type Value = GeneratedField;
15213
15214 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15215 write!(formatter, "expected one of: {:?}", &FIELDS)
15216 }
15217
15218 #[allow(unused_variables)]
15219 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15220 where
15221 E: serde::de::Error,
15222 {
15223 match value {
15224 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
15225 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15226 }
15227 }
15228 }
15229 deserializer.deserialize_identifier(GeneratedVisitor)
15230 }
15231 }
15232 struct GeneratedVisitor;
15233 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15234 type Value = throttle_mutation::RateLimit;
15235
15236 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15237 formatter.write_str("struct stream_plan.ThrottleMutation.RateLimit")
15238 }
15239
15240 fn visit_map<V>(self, mut map_: V) -> std::result::Result<throttle_mutation::RateLimit, V::Error>
15241 where
15242 V: serde::de::MapAccess<'de>,
15243 {
15244 let mut rate_limit__ = None;
15245 while let Some(k) = map_.next_key()? {
15246 match k {
15247 GeneratedField::RateLimit => {
15248 if rate_limit__.is_some() {
15249 return Err(serde::de::Error::duplicate_field("rateLimit"));
15250 }
15251 rate_limit__ =
15252 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15253 ;
15254 }
15255 }
15256 }
15257 Ok(throttle_mutation::RateLimit {
15258 rate_limit: rate_limit__,
15259 })
15260 }
15261 }
15262 deserializer.deserialize_struct("stream_plan.ThrottleMutation.RateLimit", FIELDS, GeneratedVisitor)
15263 }
15264}
15265impl serde::Serialize for TopNNode {
15266 #[allow(deprecated)]
15267 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15268 where
15269 S: serde::Serializer,
15270 {
15271 use serde::ser::SerializeStruct;
15272 let mut len = 0;
15273 if self.limit != 0 {
15274 len += 1;
15275 }
15276 if self.offset != 0 {
15277 len += 1;
15278 }
15279 if self.table.is_some() {
15280 len += 1;
15281 }
15282 if !self.order_by.is_empty() {
15283 len += 1;
15284 }
15285 if self.with_ties {
15286 len += 1;
15287 }
15288 let mut struct_ser = serializer.serialize_struct("stream_plan.TopNNode", len)?;
15289 if self.limit != 0 {
15290 #[allow(clippy::needless_borrow)]
15291 #[allow(clippy::needless_borrows_for_generic_args)]
15292 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
15293 }
15294 if self.offset != 0 {
15295 #[allow(clippy::needless_borrow)]
15296 #[allow(clippy::needless_borrows_for_generic_args)]
15297 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
15298 }
15299 if let Some(v) = self.table.as_ref() {
15300 struct_ser.serialize_field("table", v)?;
15301 }
15302 if !self.order_by.is_empty() {
15303 struct_ser.serialize_field("orderBy", &self.order_by)?;
15304 }
15305 if self.with_ties {
15306 struct_ser.serialize_field("withTies", &self.with_ties)?;
15307 }
15308 struct_ser.end()
15309 }
15310}
15311impl<'de> serde::Deserialize<'de> for TopNNode {
15312 #[allow(deprecated)]
15313 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15314 where
15315 D: serde::Deserializer<'de>,
15316 {
15317 const FIELDS: &[&str] = &[
15318 "limit",
15319 "offset",
15320 "table",
15321 "order_by",
15322 "orderBy",
15323 "with_ties",
15324 "withTies",
15325 ];
15326
15327 #[allow(clippy::enum_variant_names)]
15328 enum GeneratedField {
15329 Limit,
15330 Offset,
15331 Table,
15332 OrderBy,
15333 WithTies,
15334 }
15335 impl<'de> serde::Deserialize<'de> for GeneratedField {
15336 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15337 where
15338 D: serde::Deserializer<'de>,
15339 {
15340 struct GeneratedVisitor;
15341
15342 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15343 type Value = GeneratedField;
15344
15345 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15346 write!(formatter, "expected one of: {:?}", &FIELDS)
15347 }
15348
15349 #[allow(unused_variables)]
15350 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15351 where
15352 E: serde::de::Error,
15353 {
15354 match value {
15355 "limit" => Ok(GeneratedField::Limit),
15356 "offset" => Ok(GeneratedField::Offset),
15357 "table" => Ok(GeneratedField::Table),
15358 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
15359 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
15360 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15361 }
15362 }
15363 }
15364 deserializer.deserialize_identifier(GeneratedVisitor)
15365 }
15366 }
15367 struct GeneratedVisitor;
15368 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15369 type Value = TopNNode;
15370
15371 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15372 formatter.write_str("struct stream_plan.TopNNode")
15373 }
15374
15375 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
15376 where
15377 V: serde::de::MapAccess<'de>,
15378 {
15379 let mut limit__ = None;
15380 let mut offset__ = None;
15381 let mut table__ = None;
15382 let mut order_by__ = None;
15383 let mut with_ties__ = None;
15384 while let Some(k) = map_.next_key()? {
15385 match k {
15386 GeneratedField::Limit => {
15387 if limit__.is_some() {
15388 return Err(serde::de::Error::duplicate_field("limit"));
15389 }
15390 limit__ =
15391 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15392 ;
15393 }
15394 GeneratedField::Offset => {
15395 if offset__.is_some() {
15396 return Err(serde::de::Error::duplicate_field("offset"));
15397 }
15398 offset__ =
15399 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15400 ;
15401 }
15402 GeneratedField::Table => {
15403 if table__.is_some() {
15404 return Err(serde::de::Error::duplicate_field("table"));
15405 }
15406 table__ = map_.next_value()?;
15407 }
15408 GeneratedField::OrderBy => {
15409 if order_by__.is_some() {
15410 return Err(serde::de::Error::duplicate_field("orderBy"));
15411 }
15412 order_by__ = Some(map_.next_value()?);
15413 }
15414 GeneratedField::WithTies => {
15415 if with_ties__.is_some() {
15416 return Err(serde::de::Error::duplicate_field("withTies"));
15417 }
15418 with_ties__ = Some(map_.next_value()?);
15419 }
15420 }
15421 }
15422 Ok(TopNNode {
15423 limit: limit__.unwrap_or_default(),
15424 offset: offset__.unwrap_or_default(),
15425 table: table__,
15426 order_by: order_by__.unwrap_or_default(),
15427 with_ties: with_ties__.unwrap_or_default(),
15428 })
15429 }
15430 }
15431 deserializer.deserialize_struct("stream_plan.TopNNode", FIELDS, GeneratedVisitor)
15432 }
15433}
15434impl serde::Serialize for UnionNode {
15435 #[allow(deprecated)]
15436 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15437 where
15438 S: serde::Serializer,
15439 {
15440 use serde::ser::SerializeStruct;
15441 let len = 0;
15442 let struct_ser = serializer.serialize_struct("stream_plan.UnionNode", len)?;
15443 struct_ser.end()
15444 }
15445}
15446impl<'de> serde::Deserialize<'de> for UnionNode {
15447 #[allow(deprecated)]
15448 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15449 where
15450 D: serde::Deserializer<'de>,
15451 {
15452 const FIELDS: &[&str] = &[
15453 ];
15454
15455 #[allow(clippy::enum_variant_names)]
15456 enum GeneratedField {
15457 }
15458 impl<'de> serde::Deserialize<'de> for GeneratedField {
15459 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15460 where
15461 D: serde::Deserializer<'de>,
15462 {
15463 struct GeneratedVisitor;
15464
15465 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15466 type Value = GeneratedField;
15467
15468 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15469 write!(formatter, "expected one of: {:?}", &FIELDS)
15470 }
15471
15472 #[allow(unused_variables)]
15473 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15474 where
15475 E: serde::de::Error,
15476 {
15477 Err(serde::de::Error::unknown_field(value, FIELDS))
15478 }
15479 }
15480 deserializer.deserialize_identifier(GeneratedVisitor)
15481 }
15482 }
15483 struct GeneratedVisitor;
15484 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15485 type Value = UnionNode;
15486
15487 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15488 formatter.write_str("struct stream_plan.UnionNode")
15489 }
15490
15491 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
15492 where
15493 V: serde::de::MapAccess<'de>,
15494 {
15495 while map_.next_key::<GeneratedField>()?.is_some() {
15496 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15497 }
15498 Ok(UnionNode {
15499 })
15500 }
15501 }
15502 deserializer.deserialize_struct("stream_plan.UnionNode", FIELDS, GeneratedVisitor)
15503 }
15504}
15505impl serde::Serialize for UpdateMutation {
15506 #[allow(deprecated)]
15507 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15508 where
15509 S: serde::Serializer,
15510 {
15511 use serde::ser::SerializeStruct;
15512 let mut len = 0;
15513 if !self.dispatcher_update.is_empty() {
15514 len += 1;
15515 }
15516 if !self.merge_update.is_empty() {
15517 len += 1;
15518 }
15519 if !self.actor_vnode_bitmap_update.is_empty() {
15520 len += 1;
15521 }
15522 if !self.dropped_actors.is_empty() {
15523 len += 1;
15524 }
15525 if !self.actor_splits.is_empty() {
15526 len += 1;
15527 }
15528 if !self.actor_new_dispatchers.is_empty() {
15529 len += 1;
15530 }
15531 if self.actor_cdc_table_snapshot_splits.is_some() {
15532 len += 1;
15533 }
15534 if !self.sink_add_columns.is_empty() {
15535 len += 1;
15536 }
15537 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation", len)?;
15538 if !self.dispatcher_update.is_empty() {
15539 struct_ser.serialize_field("dispatcherUpdate", &self.dispatcher_update)?;
15540 }
15541 if !self.merge_update.is_empty() {
15542 struct_ser.serialize_field("mergeUpdate", &self.merge_update)?;
15543 }
15544 if !self.actor_vnode_bitmap_update.is_empty() {
15545 struct_ser.serialize_field("actorVnodeBitmapUpdate", &self.actor_vnode_bitmap_update)?;
15546 }
15547 if !self.dropped_actors.is_empty() {
15548 struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
15549 }
15550 if !self.actor_splits.is_empty() {
15551 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
15552 }
15553 if !self.actor_new_dispatchers.is_empty() {
15554 struct_ser.serialize_field("actorNewDispatchers", &self.actor_new_dispatchers)?;
15555 }
15556 if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
15557 struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
15558 }
15559 if !self.sink_add_columns.is_empty() {
15560 struct_ser.serialize_field("sinkAddColumns", &self.sink_add_columns)?;
15561 }
15562 struct_ser.end()
15563 }
15564}
15565impl<'de> serde::Deserialize<'de> for UpdateMutation {
15566 #[allow(deprecated)]
15567 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15568 where
15569 D: serde::Deserializer<'de>,
15570 {
15571 const FIELDS: &[&str] = &[
15572 "dispatcher_update",
15573 "dispatcherUpdate",
15574 "merge_update",
15575 "mergeUpdate",
15576 "actor_vnode_bitmap_update",
15577 "actorVnodeBitmapUpdate",
15578 "dropped_actors",
15579 "droppedActors",
15580 "actor_splits",
15581 "actorSplits",
15582 "actor_new_dispatchers",
15583 "actorNewDispatchers",
15584 "actor_cdc_table_snapshot_splits",
15585 "actorCdcTableSnapshotSplits",
15586 "sink_add_columns",
15587 "sinkAddColumns",
15588 ];
15589
15590 #[allow(clippy::enum_variant_names)]
15591 enum GeneratedField {
15592 DispatcherUpdate,
15593 MergeUpdate,
15594 ActorVnodeBitmapUpdate,
15595 DroppedActors,
15596 ActorSplits,
15597 ActorNewDispatchers,
15598 ActorCdcTableSnapshotSplits,
15599 SinkAddColumns,
15600 }
15601 impl<'de> serde::Deserialize<'de> for GeneratedField {
15602 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15603 where
15604 D: serde::Deserializer<'de>,
15605 {
15606 struct GeneratedVisitor;
15607
15608 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15609 type Value = GeneratedField;
15610
15611 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15612 write!(formatter, "expected one of: {:?}", &FIELDS)
15613 }
15614
15615 #[allow(unused_variables)]
15616 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15617 where
15618 E: serde::de::Error,
15619 {
15620 match value {
15621 "dispatcherUpdate" | "dispatcher_update" => Ok(GeneratedField::DispatcherUpdate),
15622 "mergeUpdate" | "merge_update" => Ok(GeneratedField::MergeUpdate),
15623 "actorVnodeBitmapUpdate" | "actor_vnode_bitmap_update" => Ok(GeneratedField::ActorVnodeBitmapUpdate),
15624 "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
15625 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
15626 "actorNewDispatchers" | "actor_new_dispatchers" => Ok(GeneratedField::ActorNewDispatchers),
15627 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
15628 "sinkAddColumns" | "sink_add_columns" => Ok(GeneratedField::SinkAddColumns),
15629 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15630 }
15631 }
15632 }
15633 deserializer.deserialize_identifier(GeneratedVisitor)
15634 }
15635 }
15636 struct GeneratedVisitor;
15637 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15638 type Value = UpdateMutation;
15639
15640 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15641 formatter.write_str("struct stream_plan.UpdateMutation")
15642 }
15643
15644 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateMutation, V::Error>
15645 where
15646 V: serde::de::MapAccess<'de>,
15647 {
15648 let mut dispatcher_update__ = None;
15649 let mut merge_update__ = None;
15650 let mut actor_vnode_bitmap_update__ = None;
15651 let mut dropped_actors__ = None;
15652 let mut actor_splits__ = None;
15653 let mut actor_new_dispatchers__ = None;
15654 let mut actor_cdc_table_snapshot_splits__ = None;
15655 let mut sink_add_columns__ = None;
15656 while let Some(k) = map_.next_key()? {
15657 match k {
15658 GeneratedField::DispatcherUpdate => {
15659 if dispatcher_update__.is_some() {
15660 return Err(serde::de::Error::duplicate_field("dispatcherUpdate"));
15661 }
15662 dispatcher_update__ = Some(map_.next_value()?);
15663 }
15664 GeneratedField::MergeUpdate => {
15665 if merge_update__.is_some() {
15666 return Err(serde::de::Error::duplicate_field("mergeUpdate"));
15667 }
15668 merge_update__ = Some(map_.next_value()?);
15669 }
15670 GeneratedField::ActorVnodeBitmapUpdate => {
15671 if actor_vnode_bitmap_update__.is_some() {
15672 return Err(serde::de::Error::duplicate_field("actorVnodeBitmapUpdate"));
15673 }
15674 actor_vnode_bitmap_update__ = Some(
15675 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15676 .into_iter().map(|(k,v)| (k.0, v)).collect()
15677 );
15678 }
15679 GeneratedField::DroppedActors => {
15680 if dropped_actors__.is_some() {
15681 return Err(serde::de::Error::duplicate_field("droppedActors"));
15682 }
15683 dropped_actors__ =
15684 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15685 .into_iter().map(|x| x.0).collect())
15686 ;
15687 }
15688 GeneratedField::ActorSplits => {
15689 if actor_splits__.is_some() {
15690 return Err(serde::de::Error::duplicate_field("actorSplits"));
15691 }
15692 actor_splits__ = Some(
15693 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15694 .into_iter().map(|(k,v)| (k.0, v)).collect()
15695 );
15696 }
15697 GeneratedField::ActorNewDispatchers => {
15698 if actor_new_dispatchers__.is_some() {
15699 return Err(serde::de::Error::duplicate_field("actorNewDispatchers"));
15700 }
15701 actor_new_dispatchers__ = Some(
15702 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15703 .into_iter().map(|(k,v)| (k.0, v)).collect()
15704 );
15705 }
15706 GeneratedField::ActorCdcTableSnapshotSplits => {
15707 if actor_cdc_table_snapshot_splits__.is_some() {
15708 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
15709 }
15710 actor_cdc_table_snapshot_splits__ = map_.next_value()?;
15711 }
15712 GeneratedField::SinkAddColumns => {
15713 if sink_add_columns__.is_some() {
15714 return Err(serde::de::Error::duplicate_field("sinkAddColumns"));
15715 }
15716 sink_add_columns__ = Some(
15717 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15718 .into_iter().map(|(k,v)| (k.0, v)).collect()
15719 );
15720 }
15721 }
15722 }
15723 Ok(UpdateMutation {
15724 dispatcher_update: dispatcher_update__.unwrap_or_default(),
15725 merge_update: merge_update__.unwrap_or_default(),
15726 actor_vnode_bitmap_update: actor_vnode_bitmap_update__.unwrap_or_default(),
15727 dropped_actors: dropped_actors__.unwrap_or_default(),
15728 actor_splits: actor_splits__.unwrap_or_default(),
15729 actor_new_dispatchers: actor_new_dispatchers__.unwrap_or_default(),
15730 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
15731 sink_add_columns: sink_add_columns__.unwrap_or_default(),
15732 })
15733 }
15734 }
15735 deserializer.deserialize_struct("stream_plan.UpdateMutation", FIELDS, GeneratedVisitor)
15736 }
15737}
15738impl serde::Serialize for update_mutation::DispatcherUpdate {
15739 #[allow(deprecated)]
15740 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15741 where
15742 S: serde::Serializer,
15743 {
15744 use serde::ser::SerializeStruct;
15745 let mut len = 0;
15746 if self.actor_id != 0 {
15747 len += 1;
15748 }
15749 if self.dispatcher_id != 0 {
15750 len += 1;
15751 }
15752 if self.hash_mapping.is_some() {
15753 len += 1;
15754 }
15755 if !self.added_downstream_actor_id.is_empty() {
15756 len += 1;
15757 }
15758 if !self.removed_downstream_actor_id.is_empty() {
15759 len += 1;
15760 }
15761 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", len)?;
15762 if self.actor_id != 0 {
15763 struct_ser.serialize_field("actorId", &self.actor_id)?;
15764 }
15765 if self.dispatcher_id != 0 {
15766 #[allow(clippy::needless_borrow)]
15767 #[allow(clippy::needless_borrows_for_generic_args)]
15768 struct_ser.serialize_field("dispatcherId", ToString::to_string(&self.dispatcher_id).as_str())?;
15769 }
15770 if let Some(v) = self.hash_mapping.as_ref() {
15771 struct_ser.serialize_field("hashMapping", v)?;
15772 }
15773 if !self.added_downstream_actor_id.is_empty() {
15774 struct_ser.serialize_field("addedDownstreamActorId", &self.added_downstream_actor_id)?;
15775 }
15776 if !self.removed_downstream_actor_id.is_empty() {
15777 struct_ser.serialize_field("removedDownstreamActorId", &self.removed_downstream_actor_id)?;
15778 }
15779 struct_ser.end()
15780 }
15781}
15782impl<'de> serde::Deserialize<'de> for update_mutation::DispatcherUpdate {
15783 #[allow(deprecated)]
15784 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15785 where
15786 D: serde::Deserializer<'de>,
15787 {
15788 const FIELDS: &[&str] = &[
15789 "actor_id",
15790 "actorId",
15791 "dispatcher_id",
15792 "dispatcherId",
15793 "hash_mapping",
15794 "hashMapping",
15795 "added_downstream_actor_id",
15796 "addedDownstreamActorId",
15797 "removed_downstream_actor_id",
15798 "removedDownstreamActorId",
15799 ];
15800
15801 #[allow(clippy::enum_variant_names)]
15802 enum GeneratedField {
15803 ActorId,
15804 DispatcherId,
15805 HashMapping,
15806 AddedDownstreamActorId,
15807 RemovedDownstreamActorId,
15808 }
15809 impl<'de> serde::Deserialize<'de> for GeneratedField {
15810 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15811 where
15812 D: serde::Deserializer<'de>,
15813 {
15814 struct GeneratedVisitor;
15815
15816 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15817 type Value = GeneratedField;
15818
15819 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15820 write!(formatter, "expected one of: {:?}", &FIELDS)
15821 }
15822
15823 #[allow(unused_variables)]
15824 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15825 where
15826 E: serde::de::Error,
15827 {
15828 match value {
15829 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
15830 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
15831 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
15832 "addedDownstreamActorId" | "added_downstream_actor_id" => Ok(GeneratedField::AddedDownstreamActorId),
15833 "removedDownstreamActorId" | "removed_downstream_actor_id" => Ok(GeneratedField::RemovedDownstreamActorId),
15834 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15835 }
15836 }
15837 }
15838 deserializer.deserialize_identifier(GeneratedVisitor)
15839 }
15840 }
15841 struct GeneratedVisitor;
15842 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15843 type Value = update_mutation::DispatcherUpdate;
15844
15845 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15846 formatter.write_str("struct stream_plan.UpdateMutation.DispatcherUpdate")
15847 }
15848
15849 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::DispatcherUpdate, V::Error>
15850 where
15851 V: serde::de::MapAccess<'de>,
15852 {
15853 let mut actor_id__ = None;
15854 let mut dispatcher_id__ = None;
15855 let mut hash_mapping__ = None;
15856 let mut added_downstream_actor_id__ = None;
15857 let mut removed_downstream_actor_id__ = None;
15858 while let Some(k) = map_.next_key()? {
15859 match k {
15860 GeneratedField::ActorId => {
15861 if actor_id__.is_some() {
15862 return Err(serde::de::Error::duplicate_field("actorId"));
15863 }
15864 actor_id__ =
15865 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15866 ;
15867 }
15868 GeneratedField::DispatcherId => {
15869 if dispatcher_id__.is_some() {
15870 return Err(serde::de::Error::duplicate_field("dispatcherId"));
15871 }
15872 dispatcher_id__ =
15873 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15874 ;
15875 }
15876 GeneratedField::HashMapping => {
15877 if hash_mapping__.is_some() {
15878 return Err(serde::de::Error::duplicate_field("hashMapping"));
15879 }
15880 hash_mapping__ = map_.next_value()?;
15881 }
15882 GeneratedField::AddedDownstreamActorId => {
15883 if added_downstream_actor_id__.is_some() {
15884 return Err(serde::de::Error::duplicate_field("addedDownstreamActorId"));
15885 }
15886 added_downstream_actor_id__ =
15887 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15888 .into_iter().map(|x| x.0).collect())
15889 ;
15890 }
15891 GeneratedField::RemovedDownstreamActorId => {
15892 if removed_downstream_actor_id__.is_some() {
15893 return Err(serde::de::Error::duplicate_field("removedDownstreamActorId"));
15894 }
15895 removed_downstream_actor_id__ =
15896 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15897 .into_iter().map(|x| x.0).collect())
15898 ;
15899 }
15900 }
15901 }
15902 Ok(update_mutation::DispatcherUpdate {
15903 actor_id: actor_id__.unwrap_or_default(),
15904 dispatcher_id: dispatcher_id__.unwrap_or_default(),
15905 hash_mapping: hash_mapping__,
15906 added_downstream_actor_id: added_downstream_actor_id__.unwrap_or_default(),
15907 removed_downstream_actor_id: removed_downstream_actor_id__.unwrap_or_default(),
15908 })
15909 }
15910 }
15911 deserializer.deserialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", FIELDS, GeneratedVisitor)
15912 }
15913}
15914impl serde::Serialize for update_mutation::MergeUpdate {
15915 #[allow(deprecated)]
15916 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15917 where
15918 S: serde::Serializer,
15919 {
15920 use serde::ser::SerializeStruct;
15921 let mut len = 0;
15922 if self.actor_id != 0 {
15923 len += 1;
15924 }
15925 if self.upstream_fragment_id != 0 {
15926 len += 1;
15927 }
15928 if self.new_upstream_fragment_id.is_some() {
15929 len += 1;
15930 }
15931 if !self.added_upstream_actors.is_empty() {
15932 len += 1;
15933 }
15934 if !self.removed_upstream_actor_id.is_empty() {
15935 len += 1;
15936 }
15937 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.MergeUpdate", len)?;
15938 if self.actor_id != 0 {
15939 struct_ser.serialize_field("actorId", &self.actor_id)?;
15940 }
15941 if self.upstream_fragment_id != 0 {
15942 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
15943 }
15944 if let Some(v) = self.new_upstream_fragment_id.as_ref() {
15945 struct_ser.serialize_field("newUpstreamFragmentId", v)?;
15946 }
15947 if !self.added_upstream_actors.is_empty() {
15948 struct_ser.serialize_field("addedUpstreamActors", &self.added_upstream_actors)?;
15949 }
15950 if !self.removed_upstream_actor_id.is_empty() {
15951 struct_ser.serialize_field("removedUpstreamActorId", &self.removed_upstream_actor_id)?;
15952 }
15953 struct_ser.end()
15954 }
15955}
15956impl<'de> serde::Deserialize<'de> for update_mutation::MergeUpdate {
15957 #[allow(deprecated)]
15958 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15959 where
15960 D: serde::Deserializer<'de>,
15961 {
15962 const FIELDS: &[&str] = &[
15963 "actor_id",
15964 "actorId",
15965 "upstream_fragment_id",
15966 "upstreamFragmentId",
15967 "new_upstream_fragment_id",
15968 "newUpstreamFragmentId",
15969 "added_upstream_actors",
15970 "addedUpstreamActors",
15971 "removed_upstream_actor_id",
15972 "removedUpstreamActorId",
15973 ];
15974
15975 #[allow(clippy::enum_variant_names)]
15976 enum GeneratedField {
15977 ActorId,
15978 UpstreamFragmentId,
15979 NewUpstreamFragmentId,
15980 AddedUpstreamActors,
15981 RemovedUpstreamActorId,
15982 }
15983 impl<'de> serde::Deserialize<'de> for GeneratedField {
15984 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15985 where
15986 D: serde::Deserializer<'de>,
15987 {
15988 struct GeneratedVisitor;
15989
15990 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15991 type Value = GeneratedField;
15992
15993 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15994 write!(formatter, "expected one of: {:?}", &FIELDS)
15995 }
15996
15997 #[allow(unused_variables)]
15998 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15999 where
16000 E: serde::de::Error,
16001 {
16002 match value {
16003 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
16004 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
16005 "newUpstreamFragmentId" | "new_upstream_fragment_id" => Ok(GeneratedField::NewUpstreamFragmentId),
16006 "addedUpstreamActors" | "added_upstream_actors" => Ok(GeneratedField::AddedUpstreamActors),
16007 "removedUpstreamActorId" | "removed_upstream_actor_id" => Ok(GeneratedField::RemovedUpstreamActorId),
16008 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16009 }
16010 }
16011 }
16012 deserializer.deserialize_identifier(GeneratedVisitor)
16013 }
16014 }
16015 struct GeneratedVisitor;
16016 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16017 type Value = update_mutation::MergeUpdate;
16018
16019 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16020 formatter.write_str("struct stream_plan.UpdateMutation.MergeUpdate")
16021 }
16022
16023 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::MergeUpdate, V::Error>
16024 where
16025 V: serde::de::MapAccess<'de>,
16026 {
16027 let mut actor_id__ = None;
16028 let mut upstream_fragment_id__ = None;
16029 let mut new_upstream_fragment_id__ = None;
16030 let mut added_upstream_actors__ = None;
16031 let mut removed_upstream_actor_id__ = None;
16032 while let Some(k) = map_.next_key()? {
16033 match k {
16034 GeneratedField::ActorId => {
16035 if actor_id__.is_some() {
16036 return Err(serde::de::Error::duplicate_field("actorId"));
16037 }
16038 actor_id__ =
16039 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16040 ;
16041 }
16042 GeneratedField::UpstreamFragmentId => {
16043 if upstream_fragment_id__.is_some() {
16044 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
16045 }
16046 upstream_fragment_id__ =
16047 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16048 ;
16049 }
16050 GeneratedField::NewUpstreamFragmentId => {
16051 if new_upstream_fragment_id__.is_some() {
16052 return Err(serde::de::Error::duplicate_field("newUpstreamFragmentId"));
16053 }
16054 new_upstream_fragment_id__ =
16055 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16056 ;
16057 }
16058 GeneratedField::AddedUpstreamActors => {
16059 if added_upstream_actors__.is_some() {
16060 return Err(serde::de::Error::duplicate_field("addedUpstreamActors"));
16061 }
16062 added_upstream_actors__ = Some(map_.next_value()?);
16063 }
16064 GeneratedField::RemovedUpstreamActorId => {
16065 if removed_upstream_actor_id__.is_some() {
16066 return Err(serde::de::Error::duplicate_field("removedUpstreamActorId"));
16067 }
16068 removed_upstream_actor_id__ =
16069 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16070 .into_iter().map(|x| x.0).collect())
16071 ;
16072 }
16073 }
16074 }
16075 Ok(update_mutation::MergeUpdate {
16076 actor_id: actor_id__.unwrap_or_default(),
16077 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
16078 new_upstream_fragment_id: new_upstream_fragment_id__,
16079 added_upstream_actors: added_upstream_actors__.unwrap_or_default(),
16080 removed_upstream_actor_id: removed_upstream_actor_id__.unwrap_or_default(),
16081 })
16082 }
16083 }
16084 deserializer.deserialize_struct("stream_plan.UpdateMutation.MergeUpdate", FIELDS, GeneratedVisitor)
16085 }
16086}
16087impl serde::Serialize for UpstreamSinkInfo {
16088 #[allow(deprecated)]
16089 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16090 where
16091 S: serde::Serializer,
16092 {
16093 use serde::ser::SerializeStruct;
16094 let mut len = 0;
16095 if self.upstream_fragment_id != 0 {
16096 len += 1;
16097 }
16098 if !self.sink_output_schema.is_empty() {
16099 len += 1;
16100 }
16101 if !self.project_exprs.is_empty() {
16102 len += 1;
16103 }
16104 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkInfo", len)?;
16105 if self.upstream_fragment_id != 0 {
16106 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
16107 }
16108 if !self.sink_output_schema.is_empty() {
16109 struct_ser.serialize_field("sinkOutputSchema", &self.sink_output_schema)?;
16110 }
16111 if !self.project_exprs.is_empty() {
16112 struct_ser.serialize_field("projectExprs", &self.project_exprs)?;
16113 }
16114 struct_ser.end()
16115 }
16116}
16117impl<'de> serde::Deserialize<'de> for UpstreamSinkInfo {
16118 #[allow(deprecated)]
16119 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16120 where
16121 D: serde::Deserializer<'de>,
16122 {
16123 const FIELDS: &[&str] = &[
16124 "upstream_fragment_id",
16125 "upstreamFragmentId",
16126 "sink_output_schema",
16127 "sinkOutputSchema",
16128 "project_exprs",
16129 "projectExprs",
16130 ];
16131
16132 #[allow(clippy::enum_variant_names)]
16133 enum GeneratedField {
16134 UpstreamFragmentId,
16135 SinkOutputSchema,
16136 ProjectExprs,
16137 }
16138 impl<'de> serde::Deserialize<'de> for GeneratedField {
16139 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16140 where
16141 D: serde::Deserializer<'de>,
16142 {
16143 struct GeneratedVisitor;
16144
16145 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16146 type Value = GeneratedField;
16147
16148 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16149 write!(formatter, "expected one of: {:?}", &FIELDS)
16150 }
16151
16152 #[allow(unused_variables)]
16153 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16154 where
16155 E: serde::de::Error,
16156 {
16157 match value {
16158 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
16159 "sinkOutputSchema" | "sink_output_schema" => Ok(GeneratedField::SinkOutputSchema),
16160 "projectExprs" | "project_exprs" => Ok(GeneratedField::ProjectExprs),
16161 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16162 }
16163 }
16164 }
16165 deserializer.deserialize_identifier(GeneratedVisitor)
16166 }
16167 }
16168 struct GeneratedVisitor;
16169 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16170 type Value = UpstreamSinkInfo;
16171
16172 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16173 formatter.write_str("struct stream_plan.UpstreamSinkInfo")
16174 }
16175
16176 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkInfo, V::Error>
16177 where
16178 V: serde::de::MapAccess<'de>,
16179 {
16180 let mut upstream_fragment_id__ = None;
16181 let mut sink_output_schema__ = None;
16182 let mut project_exprs__ = None;
16183 while let Some(k) = map_.next_key()? {
16184 match k {
16185 GeneratedField::UpstreamFragmentId => {
16186 if upstream_fragment_id__.is_some() {
16187 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
16188 }
16189 upstream_fragment_id__ =
16190 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16191 ;
16192 }
16193 GeneratedField::SinkOutputSchema => {
16194 if sink_output_schema__.is_some() {
16195 return Err(serde::de::Error::duplicate_field("sinkOutputSchema"));
16196 }
16197 sink_output_schema__ = Some(map_.next_value()?);
16198 }
16199 GeneratedField::ProjectExprs => {
16200 if project_exprs__.is_some() {
16201 return Err(serde::de::Error::duplicate_field("projectExprs"));
16202 }
16203 project_exprs__ = Some(map_.next_value()?);
16204 }
16205 }
16206 }
16207 Ok(UpstreamSinkInfo {
16208 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
16209 sink_output_schema: sink_output_schema__.unwrap_or_default(),
16210 project_exprs: project_exprs__.unwrap_or_default(),
16211 })
16212 }
16213 }
16214 deserializer.deserialize_struct("stream_plan.UpstreamSinkInfo", FIELDS, GeneratedVisitor)
16215 }
16216}
16217impl serde::Serialize for UpstreamSinkUnionNode {
16218 #[allow(deprecated)]
16219 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16220 where
16221 S: serde::Serializer,
16222 {
16223 use serde::ser::SerializeStruct;
16224 let mut len = 0;
16225 if !self.init_upstreams.is_empty() {
16226 len += 1;
16227 }
16228 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkUnionNode", len)?;
16229 if !self.init_upstreams.is_empty() {
16230 struct_ser.serialize_field("initUpstreams", &self.init_upstreams)?;
16231 }
16232 struct_ser.end()
16233 }
16234}
16235impl<'de> serde::Deserialize<'de> for UpstreamSinkUnionNode {
16236 #[allow(deprecated)]
16237 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16238 where
16239 D: serde::Deserializer<'de>,
16240 {
16241 const FIELDS: &[&str] = &[
16242 "init_upstreams",
16243 "initUpstreams",
16244 ];
16245
16246 #[allow(clippy::enum_variant_names)]
16247 enum GeneratedField {
16248 InitUpstreams,
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<'de> serde::de::Visitor<'de> 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 "initUpstreams" | "init_upstreams" => Ok(GeneratedField::InitUpstreams),
16271 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16272 }
16273 }
16274 }
16275 deserializer.deserialize_identifier(GeneratedVisitor)
16276 }
16277 }
16278 struct GeneratedVisitor;
16279 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16280 type Value = UpstreamSinkUnionNode;
16281
16282 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16283 formatter.write_str("struct stream_plan.UpstreamSinkUnionNode")
16284 }
16285
16286 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkUnionNode, V::Error>
16287 where
16288 V: serde::de::MapAccess<'de>,
16289 {
16290 let mut init_upstreams__ = None;
16291 while let Some(k) = map_.next_key()? {
16292 match k {
16293 GeneratedField::InitUpstreams => {
16294 if init_upstreams__.is_some() {
16295 return Err(serde::de::Error::duplicate_field("initUpstreams"));
16296 }
16297 init_upstreams__ = Some(map_.next_value()?);
16298 }
16299 }
16300 }
16301 Ok(UpstreamSinkUnionNode {
16302 init_upstreams: init_upstreams__.unwrap_or_default(),
16303 })
16304 }
16305 }
16306 deserializer.deserialize_struct("stream_plan.UpstreamSinkUnionNode", FIELDS, GeneratedVisitor)
16307 }
16308}
16309impl serde::Serialize for ValuesNode {
16310 #[allow(deprecated)]
16311 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16312 where
16313 S: serde::Serializer,
16314 {
16315 use serde::ser::SerializeStruct;
16316 let mut len = 0;
16317 if !self.tuples.is_empty() {
16318 len += 1;
16319 }
16320 if !self.fields.is_empty() {
16321 len += 1;
16322 }
16323 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode", len)?;
16324 if !self.tuples.is_empty() {
16325 struct_ser.serialize_field("tuples", &self.tuples)?;
16326 }
16327 if !self.fields.is_empty() {
16328 struct_ser.serialize_field("fields", &self.fields)?;
16329 }
16330 struct_ser.end()
16331 }
16332}
16333impl<'de> serde::Deserialize<'de> for ValuesNode {
16334 #[allow(deprecated)]
16335 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16336 where
16337 D: serde::Deserializer<'de>,
16338 {
16339 const FIELDS: &[&str] = &[
16340 "tuples",
16341 "fields",
16342 ];
16343
16344 #[allow(clippy::enum_variant_names)]
16345 enum GeneratedField {
16346 Tuples,
16347 Fields,
16348 }
16349 impl<'de> serde::Deserialize<'de> for GeneratedField {
16350 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16351 where
16352 D: serde::Deserializer<'de>,
16353 {
16354 struct GeneratedVisitor;
16355
16356 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16357 type Value = GeneratedField;
16358
16359 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16360 write!(formatter, "expected one of: {:?}", &FIELDS)
16361 }
16362
16363 #[allow(unused_variables)]
16364 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16365 where
16366 E: serde::de::Error,
16367 {
16368 match value {
16369 "tuples" => Ok(GeneratedField::Tuples),
16370 "fields" => Ok(GeneratedField::Fields),
16371 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16372 }
16373 }
16374 }
16375 deserializer.deserialize_identifier(GeneratedVisitor)
16376 }
16377 }
16378 struct GeneratedVisitor;
16379 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16380 type Value = ValuesNode;
16381
16382 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16383 formatter.write_str("struct stream_plan.ValuesNode")
16384 }
16385
16386 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
16387 where
16388 V: serde::de::MapAccess<'de>,
16389 {
16390 let mut tuples__ = None;
16391 let mut fields__ = None;
16392 while let Some(k) = map_.next_key()? {
16393 match k {
16394 GeneratedField::Tuples => {
16395 if tuples__.is_some() {
16396 return Err(serde::de::Error::duplicate_field("tuples"));
16397 }
16398 tuples__ = Some(map_.next_value()?);
16399 }
16400 GeneratedField::Fields => {
16401 if fields__.is_some() {
16402 return Err(serde::de::Error::duplicate_field("fields"));
16403 }
16404 fields__ = Some(map_.next_value()?);
16405 }
16406 }
16407 }
16408 Ok(ValuesNode {
16409 tuples: tuples__.unwrap_or_default(),
16410 fields: fields__.unwrap_or_default(),
16411 })
16412 }
16413 }
16414 deserializer.deserialize_struct("stream_plan.ValuesNode", FIELDS, GeneratedVisitor)
16415 }
16416}
16417impl serde::Serialize for values_node::ExprTuple {
16418 #[allow(deprecated)]
16419 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16420 where
16421 S: serde::Serializer,
16422 {
16423 use serde::ser::SerializeStruct;
16424 let mut len = 0;
16425 if !self.cells.is_empty() {
16426 len += 1;
16427 }
16428 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode.ExprTuple", len)?;
16429 if !self.cells.is_empty() {
16430 struct_ser.serialize_field("cells", &self.cells)?;
16431 }
16432 struct_ser.end()
16433 }
16434}
16435impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
16436 #[allow(deprecated)]
16437 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16438 where
16439 D: serde::Deserializer<'de>,
16440 {
16441 const FIELDS: &[&str] = &[
16442 "cells",
16443 ];
16444
16445 #[allow(clippy::enum_variant_names)]
16446 enum GeneratedField {
16447 Cells,
16448 }
16449 impl<'de> serde::Deserialize<'de> for GeneratedField {
16450 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16451 where
16452 D: serde::Deserializer<'de>,
16453 {
16454 struct GeneratedVisitor;
16455
16456 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16457 type Value = GeneratedField;
16458
16459 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16460 write!(formatter, "expected one of: {:?}", &FIELDS)
16461 }
16462
16463 #[allow(unused_variables)]
16464 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16465 where
16466 E: serde::de::Error,
16467 {
16468 match value {
16469 "cells" => Ok(GeneratedField::Cells),
16470 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16471 }
16472 }
16473 }
16474 deserializer.deserialize_identifier(GeneratedVisitor)
16475 }
16476 }
16477 struct GeneratedVisitor;
16478 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16479 type Value = values_node::ExprTuple;
16480
16481 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16482 formatter.write_str("struct stream_plan.ValuesNode.ExprTuple")
16483 }
16484
16485 fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
16486 where
16487 V: serde::de::MapAccess<'de>,
16488 {
16489 let mut cells__ = None;
16490 while let Some(k) = map_.next_key()? {
16491 match k {
16492 GeneratedField::Cells => {
16493 if cells__.is_some() {
16494 return Err(serde::de::Error::duplicate_field("cells"));
16495 }
16496 cells__ = Some(map_.next_value()?);
16497 }
16498 }
16499 }
16500 Ok(values_node::ExprTuple {
16501 cells: cells__.unwrap_or_default(),
16502 })
16503 }
16504 }
16505 deserializer.deserialize_struct("stream_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
16506 }
16507}
16508impl serde::Serialize for VectorIndexWriteNode {
16509 #[allow(deprecated)]
16510 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16511 where
16512 S: serde::Serializer,
16513 {
16514 use serde::ser::SerializeStruct;
16515 let mut len = 0;
16516 if self.table.is_some() {
16517 len += 1;
16518 }
16519 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexWriteNode", len)?;
16520 if let Some(v) = self.table.as_ref() {
16521 struct_ser.serialize_field("table", v)?;
16522 }
16523 struct_ser.end()
16524 }
16525}
16526impl<'de> serde::Deserialize<'de> for VectorIndexWriteNode {
16527 #[allow(deprecated)]
16528 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16529 where
16530 D: serde::Deserializer<'de>,
16531 {
16532 const FIELDS: &[&str] = &[
16533 "table",
16534 ];
16535
16536 #[allow(clippy::enum_variant_names)]
16537 enum GeneratedField {
16538 Table,
16539 }
16540 impl<'de> serde::Deserialize<'de> for GeneratedField {
16541 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16542 where
16543 D: serde::Deserializer<'de>,
16544 {
16545 struct GeneratedVisitor;
16546
16547 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16548 type Value = GeneratedField;
16549
16550 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16551 write!(formatter, "expected one of: {:?}", &FIELDS)
16552 }
16553
16554 #[allow(unused_variables)]
16555 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16556 where
16557 E: serde::de::Error,
16558 {
16559 match value {
16560 "table" => Ok(GeneratedField::Table),
16561 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16562 }
16563 }
16564 }
16565 deserializer.deserialize_identifier(GeneratedVisitor)
16566 }
16567 }
16568 struct GeneratedVisitor;
16569 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16570 type Value = VectorIndexWriteNode;
16571
16572 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16573 formatter.write_str("struct stream_plan.VectorIndexWriteNode")
16574 }
16575
16576 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexWriteNode, V::Error>
16577 where
16578 V: serde::de::MapAccess<'de>,
16579 {
16580 let mut table__ = None;
16581 while let Some(k) = map_.next_key()? {
16582 match k {
16583 GeneratedField::Table => {
16584 if table__.is_some() {
16585 return Err(serde::de::Error::duplicate_field("table"));
16586 }
16587 table__ = map_.next_value()?;
16588 }
16589 }
16590 }
16591 Ok(VectorIndexWriteNode {
16592 table: table__,
16593 })
16594 }
16595 }
16596 deserializer.deserialize_struct("stream_plan.VectorIndexWriteNode", FIELDS, GeneratedVisitor)
16597 }
16598}
16599impl serde::Serialize for Watermark {
16600 #[allow(deprecated)]
16601 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16602 where
16603 S: serde::Serializer,
16604 {
16605 use serde::ser::SerializeStruct;
16606 let mut len = 0;
16607 if self.column.is_some() {
16608 len += 1;
16609 }
16610 if self.val.is_some() {
16611 len += 1;
16612 }
16613 let mut struct_ser = serializer.serialize_struct("stream_plan.Watermark", len)?;
16614 if let Some(v) = self.column.as_ref() {
16615 struct_ser.serialize_field("column", v)?;
16616 }
16617 if let Some(v) = self.val.as_ref() {
16618 struct_ser.serialize_field("val", v)?;
16619 }
16620 struct_ser.end()
16621 }
16622}
16623impl<'de> serde::Deserialize<'de> for Watermark {
16624 #[allow(deprecated)]
16625 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16626 where
16627 D: serde::Deserializer<'de>,
16628 {
16629 const FIELDS: &[&str] = &[
16630 "column",
16631 "val",
16632 ];
16633
16634 #[allow(clippy::enum_variant_names)]
16635 enum GeneratedField {
16636 Column,
16637 Val,
16638 }
16639 impl<'de> serde::Deserialize<'de> for GeneratedField {
16640 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16641 where
16642 D: serde::Deserializer<'de>,
16643 {
16644 struct GeneratedVisitor;
16645
16646 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16647 type Value = GeneratedField;
16648
16649 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16650 write!(formatter, "expected one of: {:?}", &FIELDS)
16651 }
16652
16653 #[allow(unused_variables)]
16654 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16655 where
16656 E: serde::de::Error,
16657 {
16658 match value {
16659 "column" => Ok(GeneratedField::Column),
16660 "val" => Ok(GeneratedField::Val),
16661 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16662 }
16663 }
16664 }
16665 deserializer.deserialize_identifier(GeneratedVisitor)
16666 }
16667 }
16668 struct GeneratedVisitor;
16669 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16670 type Value = Watermark;
16671
16672 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16673 formatter.write_str("struct stream_plan.Watermark")
16674 }
16675
16676 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Watermark, V::Error>
16677 where
16678 V: serde::de::MapAccess<'de>,
16679 {
16680 let mut column__ = None;
16681 let mut val__ = None;
16682 while let Some(k) = map_.next_key()? {
16683 match k {
16684 GeneratedField::Column => {
16685 if column__.is_some() {
16686 return Err(serde::de::Error::duplicate_field("column"));
16687 }
16688 column__ = map_.next_value()?;
16689 }
16690 GeneratedField::Val => {
16691 if val__.is_some() {
16692 return Err(serde::de::Error::duplicate_field("val"));
16693 }
16694 val__ = map_.next_value()?;
16695 }
16696 }
16697 }
16698 Ok(Watermark {
16699 column: column__,
16700 val: val__,
16701 })
16702 }
16703 }
16704 deserializer.deserialize_struct("stream_plan.Watermark", FIELDS, GeneratedVisitor)
16705 }
16706}
16707impl serde::Serialize for WatermarkFilterNode {
16708 #[allow(deprecated)]
16709 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16710 where
16711 S: serde::Serializer,
16712 {
16713 use serde::ser::SerializeStruct;
16714 let mut len = 0;
16715 if !self.watermark_descs.is_empty() {
16716 len += 1;
16717 }
16718 if !self.tables.is_empty() {
16719 len += 1;
16720 }
16721 let mut struct_ser = serializer.serialize_struct("stream_plan.WatermarkFilterNode", len)?;
16722 if !self.watermark_descs.is_empty() {
16723 struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
16724 }
16725 if !self.tables.is_empty() {
16726 struct_ser.serialize_field("tables", &self.tables)?;
16727 }
16728 struct_ser.end()
16729 }
16730}
16731impl<'de> serde::Deserialize<'de> for WatermarkFilterNode {
16732 #[allow(deprecated)]
16733 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16734 where
16735 D: serde::Deserializer<'de>,
16736 {
16737 const FIELDS: &[&str] = &[
16738 "watermark_descs",
16739 "watermarkDescs",
16740 "tables",
16741 ];
16742
16743 #[allow(clippy::enum_variant_names)]
16744 enum GeneratedField {
16745 WatermarkDescs,
16746 Tables,
16747 }
16748 impl<'de> serde::Deserialize<'de> for GeneratedField {
16749 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16750 where
16751 D: serde::Deserializer<'de>,
16752 {
16753 struct GeneratedVisitor;
16754
16755 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16756 type Value = GeneratedField;
16757
16758 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16759 write!(formatter, "expected one of: {:?}", &FIELDS)
16760 }
16761
16762 #[allow(unused_variables)]
16763 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16764 where
16765 E: serde::de::Error,
16766 {
16767 match value {
16768 "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
16769 "tables" => Ok(GeneratedField::Tables),
16770 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16771 }
16772 }
16773 }
16774 deserializer.deserialize_identifier(GeneratedVisitor)
16775 }
16776 }
16777 struct GeneratedVisitor;
16778 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16779 type Value = WatermarkFilterNode;
16780
16781 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16782 formatter.write_str("struct stream_plan.WatermarkFilterNode")
16783 }
16784
16785 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkFilterNode, V::Error>
16786 where
16787 V: serde::de::MapAccess<'de>,
16788 {
16789 let mut watermark_descs__ = None;
16790 let mut tables__ = None;
16791 while let Some(k) = map_.next_key()? {
16792 match k {
16793 GeneratedField::WatermarkDescs => {
16794 if watermark_descs__.is_some() {
16795 return Err(serde::de::Error::duplicate_field("watermarkDescs"));
16796 }
16797 watermark_descs__ = Some(map_.next_value()?);
16798 }
16799 GeneratedField::Tables => {
16800 if tables__.is_some() {
16801 return Err(serde::de::Error::duplicate_field("tables"));
16802 }
16803 tables__ = Some(map_.next_value()?);
16804 }
16805 }
16806 }
16807 Ok(WatermarkFilterNode {
16808 watermark_descs: watermark_descs__.unwrap_or_default(),
16809 tables: tables__.unwrap_or_default(),
16810 })
16811 }
16812 }
16813 deserializer.deserialize_struct("stream_plan.WatermarkFilterNode", FIELDS, GeneratedVisitor)
16814 }
16815}