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::Combined(v) => {
1825 struct_ser.serialize_field("combined", v)?;
1826 }
1827 }
1828 }
1829 struct_ser.end()
1830 }
1831}
1832impl<'de> serde::Deserialize<'de> for BarrierMutation {
1833 #[allow(deprecated)]
1834 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1835 where
1836 D: serde::Deserializer<'de>,
1837 {
1838 const FIELDS: &[&str] = &[
1839 "add",
1840 "stop",
1841 "update",
1842 "splits",
1843 "pause",
1844 "resume",
1845 "throttle",
1846 "drop_subscriptions",
1847 "dropSubscriptions",
1848 "connector_props_change",
1849 "connectorPropsChange",
1850 "start_fragment_backfill",
1851 "startFragmentBackfill",
1852 "refresh_start",
1853 "refreshStart",
1854 "load_finish",
1855 "loadFinish",
1856 "combined",
1857 ];
1858
1859 #[allow(clippy::enum_variant_names)]
1860 enum GeneratedField {
1861 Add,
1862 Stop,
1863 Update,
1864 Splits,
1865 Pause,
1866 Resume,
1867 Throttle,
1868 DropSubscriptions,
1869 ConnectorPropsChange,
1870 StartFragmentBackfill,
1871 RefreshStart,
1872 LoadFinish,
1873 Combined,
1874 }
1875 impl<'de> serde::Deserialize<'de> for GeneratedField {
1876 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1877 where
1878 D: serde::Deserializer<'de>,
1879 {
1880 struct GeneratedVisitor;
1881
1882 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1883 type Value = GeneratedField;
1884
1885 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1886 write!(formatter, "expected one of: {:?}", &FIELDS)
1887 }
1888
1889 #[allow(unused_variables)]
1890 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1891 where
1892 E: serde::de::Error,
1893 {
1894 match value {
1895 "add" => Ok(GeneratedField::Add),
1896 "stop" => Ok(GeneratedField::Stop),
1897 "update" => Ok(GeneratedField::Update),
1898 "splits" => Ok(GeneratedField::Splits),
1899 "pause" => Ok(GeneratedField::Pause),
1900 "resume" => Ok(GeneratedField::Resume),
1901 "throttle" => Ok(GeneratedField::Throttle),
1902 "dropSubscriptions" | "drop_subscriptions" => Ok(GeneratedField::DropSubscriptions),
1903 "connectorPropsChange" | "connector_props_change" => Ok(GeneratedField::ConnectorPropsChange),
1904 "startFragmentBackfill" | "start_fragment_backfill" => Ok(GeneratedField::StartFragmentBackfill),
1905 "refreshStart" | "refresh_start" => Ok(GeneratedField::RefreshStart),
1906 "loadFinish" | "load_finish" => Ok(GeneratedField::LoadFinish),
1907 "combined" => Ok(GeneratedField::Combined),
1908 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1909 }
1910 }
1911 }
1912 deserializer.deserialize_identifier(GeneratedVisitor)
1913 }
1914 }
1915 struct GeneratedVisitor;
1916 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1917 type Value = BarrierMutation;
1918
1919 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1920 formatter.write_str("struct stream_plan.BarrierMutation")
1921 }
1922
1923 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierMutation, V::Error>
1924 where
1925 V: serde::de::MapAccess<'de>,
1926 {
1927 let mut mutation__ = None;
1928 while let Some(k) = map_.next_key()? {
1929 match k {
1930 GeneratedField::Add => {
1931 if mutation__.is_some() {
1932 return Err(serde::de::Error::duplicate_field("add"));
1933 }
1934 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Add)
1935;
1936 }
1937 GeneratedField::Stop => {
1938 if mutation__.is_some() {
1939 return Err(serde::de::Error::duplicate_field("stop"));
1940 }
1941 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Stop)
1942;
1943 }
1944 GeneratedField::Update => {
1945 if mutation__.is_some() {
1946 return Err(serde::de::Error::duplicate_field("update"));
1947 }
1948 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Update)
1949;
1950 }
1951 GeneratedField::Splits => {
1952 if mutation__.is_some() {
1953 return Err(serde::de::Error::duplicate_field("splits"));
1954 }
1955 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Splits)
1956;
1957 }
1958 GeneratedField::Pause => {
1959 if mutation__.is_some() {
1960 return Err(serde::de::Error::duplicate_field("pause"));
1961 }
1962 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Pause)
1963;
1964 }
1965 GeneratedField::Resume => {
1966 if mutation__.is_some() {
1967 return Err(serde::de::Error::duplicate_field("resume"));
1968 }
1969 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Resume)
1970;
1971 }
1972 GeneratedField::Throttle => {
1973 if mutation__.is_some() {
1974 return Err(serde::de::Error::duplicate_field("throttle"));
1975 }
1976 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Throttle)
1977;
1978 }
1979 GeneratedField::DropSubscriptions => {
1980 if mutation__.is_some() {
1981 return Err(serde::de::Error::duplicate_field("dropSubscriptions"));
1982 }
1983 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::DropSubscriptions)
1984;
1985 }
1986 GeneratedField::ConnectorPropsChange => {
1987 if mutation__.is_some() {
1988 return Err(serde::de::Error::duplicate_field("connectorPropsChange"));
1989 }
1990 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ConnectorPropsChange)
1991;
1992 }
1993 GeneratedField::StartFragmentBackfill => {
1994 if mutation__.is_some() {
1995 return Err(serde::de::Error::duplicate_field("startFragmentBackfill"));
1996 }
1997 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::StartFragmentBackfill)
1998;
1999 }
2000 GeneratedField::RefreshStart => {
2001 if mutation__.is_some() {
2002 return Err(serde::de::Error::duplicate_field("refreshStart"));
2003 }
2004 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::RefreshStart)
2005;
2006 }
2007 GeneratedField::LoadFinish => {
2008 if mutation__.is_some() {
2009 return Err(serde::de::Error::duplicate_field("loadFinish"));
2010 }
2011 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::LoadFinish)
2012;
2013 }
2014 GeneratedField::Combined => {
2015 if mutation__.is_some() {
2016 return Err(serde::de::Error::duplicate_field("combined"));
2017 }
2018 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Combined)
2019;
2020 }
2021 }
2022 }
2023 Ok(BarrierMutation {
2024 mutation: mutation__,
2025 })
2026 }
2027 }
2028 deserializer.deserialize_struct("stream_plan.BarrierMutation", FIELDS, GeneratedVisitor)
2029 }
2030}
2031impl serde::Serialize for BarrierRecvNode {
2032 #[allow(deprecated)]
2033 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2034 where
2035 S: serde::Serializer,
2036 {
2037 use serde::ser::SerializeStruct;
2038 let len = 0;
2039 let struct_ser = serializer.serialize_struct("stream_plan.BarrierRecvNode", len)?;
2040 struct_ser.end()
2041 }
2042}
2043impl<'de> serde::Deserialize<'de> for BarrierRecvNode {
2044 #[allow(deprecated)]
2045 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2046 where
2047 D: serde::Deserializer<'de>,
2048 {
2049 const FIELDS: &[&str] = &[
2050 ];
2051
2052 #[allow(clippy::enum_variant_names)]
2053 enum GeneratedField {
2054 }
2055 impl<'de> serde::Deserialize<'de> for GeneratedField {
2056 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2057 where
2058 D: serde::Deserializer<'de>,
2059 {
2060 struct GeneratedVisitor;
2061
2062 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2063 type Value = GeneratedField;
2064
2065 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2066 write!(formatter, "expected one of: {:?}", &FIELDS)
2067 }
2068
2069 #[allow(unused_variables)]
2070 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2071 where
2072 E: serde::de::Error,
2073 {
2074 Err(serde::de::Error::unknown_field(value, FIELDS))
2075 }
2076 }
2077 deserializer.deserialize_identifier(GeneratedVisitor)
2078 }
2079 }
2080 struct GeneratedVisitor;
2081 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2082 type Value = BarrierRecvNode;
2083
2084 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2085 formatter.write_str("struct stream_plan.BarrierRecvNode")
2086 }
2087
2088 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierRecvNode, V::Error>
2089 where
2090 V: serde::de::MapAccess<'de>,
2091 {
2092 while map_.next_key::<GeneratedField>()?.is_some() {
2093 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2094 }
2095 Ok(BarrierRecvNode {
2096 })
2097 }
2098 }
2099 deserializer.deserialize_struct("stream_plan.BarrierRecvNode", FIELDS, GeneratedVisitor)
2100 }
2101}
2102impl serde::Serialize for BatchPlanNode {
2103 #[allow(deprecated)]
2104 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2105 where
2106 S: serde::Serializer,
2107 {
2108 use serde::ser::SerializeStruct;
2109 let mut len = 0;
2110 if self.table_desc.is_some() {
2111 len += 1;
2112 }
2113 if !self.column_ids.is_empty() {
2114 len += 1;
2115 }
2116 let mut struct_ser = serializer.serialize_struct("stream_plan.BatchPlanNode", len)?;
2117 if let Some(v) = self.table_desc.as_ref() {
2118 struct_ser.serialize_field("tableDesc", v)?;
2119 }
2120 if !self.column_ids.is_empty() {
2121 struct_ser.serialize_field("columnIds", &self.column_ids)?;
2122 }
2123 struct_ser.end()
2124 }
2125}
2126impl<'de> serde::Deserialize<'de> for BatchPlanNode {
2127 #[allow(deprecated)]
2128 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2129 where
2130 D: serde::Deserializer<'de>,
2131 {
2132 const FIELDS: &[&str] = &[
2133 "table_desc",
2134 "tableDesc",
2135 "column_ids",
2136 "columnIds",
2137 ];
2138
2139 #[allow(clippy::enum_variant_names)]
2140 enum GeneratedField {
2141 TableDesc,
2142 ColumnIds,
2143 }
2144 impl<'de> serde::Deserialize<'de> for GeneratedField {
2145 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2146 where
2147 D: serde::Deserializer<'de>,
2148 {
2149 struct GeneratedVisitor;
2150
2151 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2152 type Value = GeneratedField;
2153
2154 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2155 write!(formatter, "expected one of: {:?}", &FIELDS)
2156 }
2157
2158 #[allow(unused_variables)]
2159 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2160 where
2161 E: serde::de::Error,
2162 {
2163 match value {
2164 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
2165 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
2166 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2167 }
2168 }
2169 }
2170 deserializer.deserialize_identifier(GeneratedVisitor)
2171 }
2172 }
2173 struct GeneratedVisitor;
2174 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2175 type Value = BatchPlanNode;
2176
2177 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2178 formatter.write_str("struct stream_plan.BatchPlanNode")
2179 }
2180
2181 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BatchPlanNode, V::Error>
2182 where
2183 V: serde::de::MapAccess<'de>,
2184 {
2185 let mut table_desc__ = None;
2186 let mut column_ids__ = None;
2187 while let Some(k) = map_.next_key()? {
2188 match k {
2189 GeneratedField::TableDesc => {
2190 if table_desc__.is_some() {
2191 return Err(serde::de::Error::duplicate_field("tableDesc"));
2192 }
2193 table_desc__ = map_.next_value()?;
2194 }
2195 GeneratedField::ColumnIds => {
2196 if column_ids__.is_some() {
2197 return Err(serde::de::Error::duplicate_field("columnIds"));
2198 }
2199 column_ids__ =
2200 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2201 .into_iter().map(|x| x.0).collect())
2202 ;
2203 }
2204 }
2205 }
2206 Ok(BatchPlanNode {
2207 table_desc: table_desc__,
2208 column_ids: column_ids__.unwrap_or_default(),
2209 })
2210 }
2211 }
2212 deserializer.deserialize_struct("stream_plan.BatchPlanNode", FIELDS, GeneratedVisitor)
2213 }
2214}
2215impl serde::Serialize for CdcFilterNode {
2216 #[allow(deprecated)]
2217 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2218 where
2219 S: serde::Serializer,
2220 {
2221 use serde::ser::SerializeStruct;
2222 let mut len = 0;
2223 if self.search_condition.is_some() {
2224 len += 1;
2225 }
2226 if self.upstream_source_id != 0 {
2227 len += 1;
2228 }
2229 let mut struct_ser = serializer.serialize_struct("stream_plan.CdcFilterNode", len)?;
2230 if let Some(v) = self.search_condition.as_ref() {
2231 struct_ser.serialize_field("searchCondition", v)?;
2232 }
2233 if self.upstream_source_id != 0 {
2234 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
2235 }
2236 struct_ser.end()
2237 }
2238}
2239impl<'de> serde::Deserialize<'de> for CdcFilterNode {
2240 #[allow(deprecated)]
2241 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2242 where
2243 D: serde::Deserializer<'de>,
2244 {
2245 const FIELDS: &[&str] = &[
2246 "search_condition",
2247 "searchCondition",
2248 "upstream_source_id",
2249 "upstreamSourceId",
2250 ];
2251
2252 #[allow(clippy::enum_variant_names)]
2253 enum GeneratedField {
2254 SearchCondition,
2255 UpstreamSourceId,
2256 }
2257 impl<'de> serde::Deserialize<'de> for GeneratedField {
2258 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2259 where
2260 D: serde::Deserializer<'de>,
2261 {
2262 struct GeneratedVisitor;
2263
2264 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2265 type Value = GeneratedField;
2266
2267 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2268 write!(formatter, "expected one of: {:?}", &FIELDS)
2269 }
2270
2271 #[allow(unused_variables)]
2272 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2273 where
2274 E: serde::de::Error,
2275 {
2276 match value {
2277 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
2278 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
2279 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2280 }
2281 }
2282 }
2283 deserializer.deserialize_identifier(GeneratedVisitor)
2284 }
2285 }
2286 struct GeneratedVisitor;
2287 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2288 type Value = CdcFilterNode;
2289
2290 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2291 formatter.write_str("struct stream_plan.CdcFilterNode")
2292 }
2293
2294 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcFilterNode, V::Error>
2295 where
2296 V: serde::de::MapAccess<'de>,
2297 {
2298 let mut search_condition__ = None;
2299 let mut upstream_source_id__ = None;
2300 while let Some(k) = map_.next_key()? {
2301 match k {
2302 GeneratedField::SearchCondition => {
2303 if search_condition__.is_some() {
2304 return Err(serde::de::Error::duplicate_field("searchCondition"));
2305 }
2306 search_condition__ = map_.next_value()?;
2307 }
2308 GeneratedField::UpstreamSourceId => {
2309 if upstream_source_id__.is_some() {
2310 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
2311 }
2312 upstream_source_id__ =
2313 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2314 ;
2315 }
2316 }
2317 }
2318 Ok(CdcFilterNode {
2319 search_condition: search_condition__,
2320 upstream_source_id: upstream_source_id__.unwrap_or_default(),
2321 })
2322 }
2323 }
2324 deserializer.deserialize_struct("stream_plan.CdcFilterNode", FIELDS, GeneratedVisitor)
2325 }
2326}
2327impl serde::Serialize for ChangeLogNode {
2328 #[allow(deprecated)]
2329 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2330 where
2331 S: serde::Serializer,
2332 {
2333 use serde::ser::SerializeStruct;
2334 let mut len = 0;
2335 if self.need_op {
2336 len += 1;
2337 }
2338 if !self.distribution_keys.is_empty() {
2339 len += 1;
2340 }
2341 let mut struct_ser = serializer.serialize_struct("stream_plan.ChangeLogNode", len)?;
2342 if self.need_op {
2343 struct_ser.serialize_field("needOp", &self.need_op)?;
2344 }
2345 if !self.distribution_keys.is_empty() {
2346 struct_ser.serialize_field("distributionKeys", &self.distribution_keys)?;
2347 }
2348 struct_ser.end()
2349 }
2350}
2351impl<'de> serde::Deserialize<'de> for ChangeLogNode {
2352 #[allow(deprecated)]
2353 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2354 where
2355 D: serde::Deserializer<'de>,
2356 {
2357 const FIELDS: &[&str] = &[
2358 "need_op",
2359 "needOp",
2360 "distribution_keys",
2361 "distributionKeys",
2362 ];
2363
2364 #[allow(clippy::enum_variant_names)]
2365 enum GeneratedField {
2366 NeedOp,
2367 DistributionKeys,
2368 }
2369 impl<'de> serde::Deserialize<'de> for GeneratedField {
2370 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2371 where
2372 D: serde::Deserializer<'de>,
2373 {
2374 struct GeneratedVisitor;
2375
2376 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2377 type Value = GeneratedField;
2378
2379 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2380 write!(formatter, "expected one of: {:?}", &FIELDS)
2381 }
2382
2383 #[allow(unused_variables)]
2384 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2385 where
2386 E: serde::de::Error,
2387 {
2388 match value {
2389 "needOp" | "need_op" => Ok(GeneratedField::NeedOp),
2390 "distributionKeys" | "distribution_keys" => Ok(GeneratedField::DistributionKeys),
2391 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2392 }
2393 }
2394 }
2395 deserializer.deserialize_identifier(GeneratedVisitor)
2396 }
2397 }
2398 struct GeneratedVisitor;
2399 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2400 type Value = ChangeLogNode;
2401
2402 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2403 formatter.write_str("struct stream_plan.ChangeLogNode")
2404 }
2405
2406 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ChangeLogNode, V::Error>
2407 where
2408 V: serde::de::MapAccess<'de>,
2409 {
2410 let mut need_op__ = None;
2411 let mut distribution_keys__ = None;
2412 while let Some(k) = map_.next_key()? {
2413 match k {
2414 GeneratedField::NeedOp => {
2415 if need_op__.is_some() {
2416 return Err(serde::de::Error::duplicate_field("needOp"));
2417 }
2418 need_op__ = Some(map_.next_value()?);
2419 }
2420 GeneratedField::DistributionKeys => {
2421 if distribution_keys__.is_some() {
2422 return Err(serde::de::Error::duplicate_field("distributionKeys"));
2423 }
2424 distribution_keys__ =
2425 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2426 .into_iter().map(|x| x.0).collect())
2427 ;
2428 }
2429 }
2430 }
2431 Ok(ChangeLogNode {
2432 need_op: need_op__.unwrap_or_default(),
2433 distribution_keys: distribution_keys__.unwrap_or_default(),
2434 })
2435 }
2436 }
2437 deserializer.deserialize_struct("stream_plan.ChangeLogNode", FIELDS, GeneratedVisitor)
2438 }
2439}
2440impl serde::Serialize for CombinedMutation {
2441 #[allow(deprecated)]
2442 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2443 where
2444 S: serde::Serializer,
2445 {
2446 use serde::ser::SerializeStruct;
2447 let mut len = 0;
2448 if !self.mutations.is_empty() {
2449 len += 1;
2450 }
2451 let mut struct_ser = serializer.serialize_struct("stream_plan.CombinedMutation", len)?;
2452 if !self.mutations.is_empty() {
2453 struct_ser.serialize_field("mutations", &self.mutations)?;
2454 }
2455 struct_ser.end()
2456 }
2457}
2458impl<'de> serde::Deserialize<'de> for CombinedMutation {
2459 #[allow(deprecated)]
2460 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2461 where
2462 D: serde::Deserializer<'de>,
2463 {
2464 const FIELDS: &[&str] = &[
2465 "mutations",
2466 ];
2467
2468 #[allow(clippy::enum_variant_names)]
2469 enum GeneratedField {
2470 Mutations,
2471 }
2472 impl<'de> serde::Deserialize<'de> for GeneratedField {
2473 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2474 where
2475 D: serde::Deserializer<'de>,
2476 {
2477 struct GeneratedVisitor;
2478
2479 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2480 type Value = GeneratedField;
2481
2482 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2483 write!(formatter, "expected one of: {:?}", &FIELDS)
2484 }
2485
2486 #[allow(unused_variables)]
2487 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2488 where
2489 E: serde::de::Error,
2490 {
2491 match value {
2492 "mutations" => Ok(GeneratedField::Mutations),
2493 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2494 }
2495 }
2496 }
2497 deserializer.deserialize_identifier(GeneratedVisitor)
2498 }
2499 }
2500 struct GeneratedVisitor;
2501 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2502 type Value = CombinedMutation;
2503
2504 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2505 formatter.write_str("struct stream_plan.CombinedMutation")
2506 }
2507
2508 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CombinedMutation, V::Error>
2509 where
2510 V: serde::de::MapAccess<'de>,
2511 {
2512 let mut mutations__ = None;
2513 while let Some(k) = map_.next_key()? {
2514 match k {
2515 GeneratedField::Mutations => {
2516 if mutations__.is_some() {
2517 return Err(serde::de::Error::duplicate_field("mutations"));
2518 }
2519 mutations__ = Some(map_.next_value()?);
2520 }
2521 }
2522 }
2523 Ok(CombinedMutation {
2524 mutations: mutations__.unwrap_or_default(),
2525 })
2526 }
2527 }
2528 deserializer.deserialize_struct("stream_plan.CombinedMutation", FIELDS, GeneratedVisitor)
2529 }
2530}
2531impl serde::Serialize for ConnectorPropsChangeMutation {
2532 #[allow(deprecated)]
2533 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2534 where
2535 S: serde::Serializer,
2536 {
2537 use serde::ser::SerializeStruct;
2538 let mut len = 0;
2539 if !self.connector_props_infos.is_empty() {
2540 len += 1;
2541 }
2542 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation", len)?;
2543 if !self.connector_props_infos.is_empty() {
2544 struct_ser.serialize_field("connectorPropsInfos", &self.connector_props_infos)?;
2545 }
2546 struct_ser.end()
2547 }
2548}
2549impl<'de> serde::Deserialize<'de> for ConnectorPropsChangeMutation {
2550 #[allow(deprecated)]
2551 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2552 where
2553 D: serde::Deserializer<'de>,
2554 {
2555 const FIELDS: &[&str] = &[
2556 "connector_props_infos",
2557 "connectorPropsInfos",
2558 ];
2559
2560 #[allow(clippy::enum_variant_names)]
2561 enum GeneratedField {
2562 ConnectorPropsInfos,
2563 }
2564 impl<'de> serde::Deserialize<'de> for GeneratedField {
2565 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2566 where
2567 D: serde::Deserializer<'de>,
2568 {
2569 struct GeneratedVisitor;
2570
2571 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2572 type Value = GeneratedField;
2573
2574 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2575 write!(formatter, "expected one of: {:?}", &FIELDS)
2576 }
2577
2578 #[allow(unused_variables)]
2579 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2580 where
2581 E: serde::de::Error,
2582 {
2583 match value {
2584 "connectorPropsInfos" | "connector_props_infos" => Ok(GeneratedField::ConnectorPropsInfos),
2585 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2586 }
2587 }
2588 }
2589 deserializer.deserialize_identifier(GeneratedVisitor)
2590 }
2591 }
2592 struct GeneratedVisitor;
2593 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2594 type Value = ConnectorPropsChangeMutation;
2595
2596 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2597 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation")
2598 }
2599
2600 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectorPropsChangeMutation, V::Error>
2601 where
2602 V: serde::de::MapAccess<'de>,
2603 {
2604 let mut connector_props_infos__ = None;
2605 while let Some(k) = map_.next_key()? {
2606 match k {
2607 GeneratedField::ConnectorPropsInfos => {
2608 if connector_props_infos__.is_some() {
2609 return Err(serde::de::Error::duplicate_field("connectorPropsInfos"));
2610 }
2611 connector_props_infos__ = Some(
2612 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
2613 .into_iter().map(|(k,v)| (k.0, v)).collect()
2614 );
2615 }
2616 }
2617 }
2618 Ok(ConnectorPropsChangeMutation {
2619 connector_props_infos: connector_props_infos__.unwrap_or_default(),
2620 })
2621 }
2622 }
2623 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation", FIELDS, GeneratedVisitor)
2624 }
2625}
2626impl serde::Serialize for connector_props_change_mutation::ConnectorPropsInfo {
2627 #[allow(deprecated)]
2628 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2629 where
2630 S: serde::Serializer,
2631 {
2632 use serde::ser::SerializeStruct;
2633 let mut len = 0;
2634 if !self.connector_props_info.is_empty() {
2635 len += 1;
2636 }
2637 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", len)?;
2638 if !self.connector_props_info.is_empty() {
2639 struct_ser.serialize_field("connectorPropsInfo", &self.connector_props_info)?;
2640 }
2641 struct_ser.end()
2642 }
2643}
2644impl<'de> serde::Deserialize<'de> for connector_props_change_mutation::ConnectorPropsInfo {
2645 #[allow(deprecated)]
2646 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2647 where
2648 D: serde::Deserializer<'de>,
2649 {
2650 const FIELDS: &[&str] = &[
2651 "connector_props_info",
2652 "connectorPropsInfo",
2653 ];
2654
2655 #[allow(clippy::enum_variant_names)]
2656 enum GeneratedField {
2657 ConnectorPropsInfo,
2658 }
2659 impl<'de> serde::Deserialize<'de> for GeneratedField {
2660 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2661 where
2662 D: serde::Deserializer<'de>,
2663 {
2664 struct GeneratedVisitor;
2665
2666 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2667 type Value = GeneratedField;
2668
2669 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2670 write!(formatter, "expected one of: {:?}", &FIELDS)
2671 }
2672
2673 #[allow(unused_variables)]
2674 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2675 where
2676 E: serde::de::Error,
2677 {
2678 match value {
2679 "connectorPropsInfo" | "connector_props_info" => Ok(GeneratedField::ConnectorPropsInfo),
2680 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2681 }
2682 }
2683 }
2684 deserializer.deserialize_identifier(GeneratedVisitor)
2685 }
2686 }
2687 struct GeneratedVisitor;
2688 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2689 type Value = connector_props_change_mutation::ConnectorPropsInfo;
2690
2691 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2692 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo")
2693 }
2694
2695 fn visit_map<V>(self, mut map_: V) -> std::result::Result<connector_props_change_mutation::ConnectorPropsInfo, V::Error>
2696 where
2697 V: serde::de::MapAccess<'de>,
2698 {
2699 let mut connector_props_info__ = None;
2700 while let Some(k) = map_.next_key()? {
2701 match k {
2702 GeneratedField::ConnectorPropsInfo => {
2703 if connector_props_info__.is_some() {
2704 return Err(serde::de::Error::duplicate_field("connectorPropsInfo"));
2705 }
2706 connector_props_info__ = Some(
2707 map_.next_value::<std::collections::HashMap<_, _>>()?
2708 );
2709 }
2710 }
2711 }
2712 Ok(connector_props_change_mutation::ConnectorPropsInfo {
2713 connector_props_info: connector_props_info__.unwrap_or_default(),
2714 })
2715 }
2716 }
2717 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", FIELDS, GeneratedVisitor)
2718 }
2719}
2720impl serde::Serialize for DedupNode {
2721 #[allow(deprecated)]
2722 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2723 where
2724 S: serde::Serializer,
2725 {
2726 use serde::ser::SerializeStruct;
2727 let mut len = 0;
2728 if self.state_table.is_some() {
2729 len += 1;
2730 }
2731 if !self.dedup_column_indices.is_empty() {
2732 len += 1;
2733 }
2734 let mut struct_ser = serializer.serialize_struct("stream_plan.DedupNode", len)?;
2735 if let Some(v) = self.state_table.as_ref() {
2736 struct_ser.serialize_field("stateTable", v)?;
2737 }
2738 if !self.dedup_column_indices.is_empty() {
2739 struct_ser.serialize_field("dedupColumnIndices", &self.dedup_column_indices)?;
2740 }
2741 struct_ser.end()
2742 }
2743}
2744impl<'de> serde::Deserialize<'de> for DedupNode {
2745 #[allow(deprecated)]
2746 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2747 where
2748 D: serde::Deserializer<'de>,
2749 {
2750 const FIELDS: &[&str] = &[
2751 "state_table",
2752 "stateTable",
2753 "dedup_column_indices",
2754 "dedupColumnIndices",
2755 ];
2756
2757 #[allow(clippy::enum_variant_names)]
2758 enum GeneratedField {
2759 StateTable,
2760 DedupColumnIndices,
2761 }
2762 impl<'de> serde::Deserialize<'de> for GeneratedField {
2763 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2764 where
2765 D: serde::Deserializer<'de>,
2766 {
2767 struct GeneratedVisitor;
2768
2769 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2770 type Value = GeneratedField;
2771
2772 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2773 write!(formatter, "expected one of: {:?}", &FIELDS)
2774 }
2775
2776 #[allow(unused_variables)]
2777 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2778 where
2779 E: serde::de::Error,
2780 {
2781 match value {
2782 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
2783 "dedupColumnIndices" | "dedup_column_indices" => Ok(GeneratedField::DedupColumnIndices),
2784 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2785 }
2786 }
2787 }
2788 deserializer.deserialize_identifier(GeneratedVisitor)
2789 }
2790 }
2791 struct GeneratedVisitor;
2792 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2793 type Value = DedupNode;
2794
2795 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2796 formatter.write_str("struct stream_plan.DedupNode")
2797 }
2798
2799 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DedupNode, V::Error>
2800 where
2801 V: serde::de::MapAccess<'de>,
2802 {
2803 let mut state_table__ = None;
2804 let mut dedup_column_indices__ = None;
2805 while let Some(k) = map_.next_key()? {
2806 match k {
2807 GeneratedField::StateTable => {
2808 if state_table__.is_some() {
2809 return Err(serde::de::Error::duplicate_field("stateTable"));
2810 }
2811 state_table__ = map_.next_value()?;
2812 }
2813 GeneratedField::DedupColumnIndices => {
2814 if dedup_column_indices__.is_some() {
2815 return Err(serde::de::Error::duplicate_field("dedupColumnIndices"));
2816 }
2817 dedup_column_indices__ =
2818 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2819 .into_iter().map(|x| x.0).collect())
2820 ;
2821 }
2822 }
2823 }
2824 Ok(DedupNode {
2825 state_table: state_table__,
2826 dedup_column_indices: dedup_column_indices__.unwrap_or_default(),
2827 })
2828 }
2829 }
2830 deserializer.deserialize_struct("stream_plan.DedupNode", FIELDS, GeneratedVisitor)
2831 }
2832}
2833impl serde::Serialize for DeltaExpression {
2834 #[allow(deprecated)]
2835 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2836 where
2837 S: serde::Serializer,
2838 {
2839 use serde::ser::SerializeStruct;
2840 let mut len = 0;
2841 if self.delta_type != 0 {
2842 len += 1;
2843 }
2844 if self.delta.is_some() {
2845 len += 1;
2846 }
2847 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaExpression", len)?;
2848 if self.delta_type != 0 {
2849 let v = super::expr::expr_node::Type::try_from(self.delta_type)
2850 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.delta_type)))?;
2851 struct_ser.serialize_field("deltaType", &v)?;
2852 }
2853 if let Some(v) = self.delta.as_ref() {
2854 struct_ser.serialize_field("delta", v)?;
2855 }
2856 struct_ser.end()
2857 }
2858}
2859impl<'de> serde::Deserialize<'de> for DeltaExpression {
2860 #[allow(deprecated)]
2861 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2862 where
2863 D: serde::Deserializer<'de>,
2864 {
2865 const FIELDS: &[&str] = &[
2866 "delta_type",
2867 "deltaType",
2868 "delta",
2869 ];
2870
2871 #[allow(clippy::enum_variant_names)]
2872 enum GeneratedField {
2873 DeltaType,
2874 Delta,
2875 }
2876 impl<'de> serde::Deserialize<'de> for GeneratedField {
2877 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2878 where
2879 D: serde::Deserializer<'de>,
2880 {
2881 struct GeneratedVisitor;
2882
2883 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2884 type Value = GeneratedField;
2885
2886 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2887 write!(formatter, "expected one of: {:?}", &FIELDS)
2888 }
2889
2890 #[allow(unused_variables)]
2891 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2892 where
2893 E: serde::de::Error,
2894 {
2895 match value {
2896 "deltaType" | "delta_type" => Ok(GeneratedField::DeltaType),
2897 "delta" => Ok(GeneratedField::Delta),
2898 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2899 }
2900 }
2901 }
2902 deserializer.deserialize_identifier(GeneratedVisitor)
2903 }
2904 }
2905 struct GeneratedVisitor;
2906 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2907 type Value = DeltaExpression;
2908
2909 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2910 formatter.write_str("struct stream_plan.DeltaExpression")
2911 }
2912
2913 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaExpression, V::Error>
2914 where
2915 V: serde::de::MapAccess<'de>,
2916 {
2917 let mut delta_type__ = None;
2918 let mut delta__ = None;
2919 while let Some(k) = map_.next_key()? {
2920 match k {
2921 GeneratedField::DeltaType => {
2922 if delta_type__.is_some() {
2923 return Err(serde::de::Error::duplicate_field("deltaType"));
2924 }
2925 delta_type__ = Some(map_.next_value::<super::expr::expr_node::Type>()? as i32);
2926 }
2927 GeneratedField::Delta => {
2928 if delta__.is_some() {
2929 return Err(serde::de::Error::duplicate_field("delta"));
2930 }
2931 delta__ = map_.next_value()?;
2932 }
2933 }
2934 }
2935 Ok(DeltaExpression {
2936 delta_type: delta_type__.unwrap_or_default(),
2937 delta: delta__,
2938 })
2939 }
2940 }
2941 deserializer.deserialize_struct("stream_plan.DeltaExpression", FIELDS, GeneratedVisitor)
2942 }
2943}
2944impl serde::Serialize for DeltaIndexJoinNode {
2945 #[allow(deprecated)]
2946 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2947 where
2948 S: serde::Serializer,
2949 {
2950 use serde::ser::SerializeStruct;
2951 let mut len = 0;
2952 if self.join_type != 0 {
2953 len += 1;
2954 }
2955 if !self.left_key.is_empty() {
2956 len += 1;
2957 }
2958 if !self.right_key.is_empty() {
2959 len += 1;
2960 }
2961 if self.condition.is_some() {
2962 len += 1;
2963 }
2964 if self.left_table_id != 0 {
2965 len += 1;
2966 }
2967 if self.right_table_id != 0 {
2968 len += 1;
2969 }
2970 if self.left_info.is_some() {
2971 len += 1;
2972 }
2973 if self.right_info.is_some() {
2974 len += 1;
2975 }
2976 if !self.output_indices.is_empty() {
2977 len += 1;
2978 }
2979 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaIndexJoinNode", len)?;
2980 if self.join_type != 0 {
2981 let v = super::plan_common::JoinType::try_from(self.join_type)
2982 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
2983 struct_ser.serialize_field("joinType", &v)?;
2984 }
2985 if !self.left_key.is_empty() {
2986 struct_ser.serialize_field("leftKey", &self.left_key)?;
2987 }
2988 if !self.right_key.is_empty() {
2989 struct_ser.serialize_field("rightKey", &self.right_key)?;
2990 }
2991 if let Some(v) = self.condition.as_ref() {
2992 struct_ser.serialize_field("condition", v)?;
2993 }
2994 if self.left_table_id != 0 {
2995 struct_ser.serialize_field("leftTableId", &self.left_table_id)?;
2996 }
2997 if self.right_table_id != 0 {
2998 struct_ser.serialize_field("rightTableId", &self.right_table_id)?;
2999 }
3000 if let Some(v) = self.left_info.as_ref() {
3001 struct_ser.serialize_field("leftInfo", v)?;
3002 }
3003 if let Some(v) = self.right_info.as_ref() {
3004 struct_ser.serialize_field("rightInfo", v)?;
3005 }
3006 if !self.output_indices.is_empty() {
3007 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
3008 }
3009 struct_ser.end()
3010 }
3011}
3012impl<'de> serde::Deserialize<'de> for DeltaIndexJoinNode {
3013 #[allow(deprecated)]
3014 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3015 where
3016 D: serde::Deserializer<'de>,
3017 {
3018 const FIELDS: &[&str] = &[
3019 "join_type",
3020 "joinType",
3021 "left_key",
3022 "leftKey",
3023 "right_key",
3024 "rightKey",
3025 "condition",
3026 "left_table_id",
3027 "leftTableId",
3028 "right_table_id",
3029 "rightTableId",
3030 "left_info",
3031 "leftInfo",
3032 "right_info",
3033 "rightInfo",
3034 "output_indices",
3035 "outputIndices",
3036 ];
3037
3038 #[allow(clippy::enum_variant_names)]
3039 enum GeneratedField {
3040 JoinType,
3041 LeftKey,
3042 RightKey,
3043 Condition,
3044 LeftTableId,
3045 RightTableId,
3046 LeftInfo,
3047 RightInfo,
3048 OutputIndices,
3049 }
3050 impl<'de> serde::Deserialize<'de> for GeneratedField {
3051 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3052 where
3053 D: serde::Deserializer<'de>,
3054 {
3055 struct GeneratedVisitor;
3056
3057 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3058 type Value = GeneratedField;
3059
3060 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3061 write!(formatter, "expected one of: {:?}", &FIELDS)
3062 }
3063
3064 #[allow(unused_variables)]
3065 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3066 where
3067 E: serde::de::Error,
3068 {
3069 match value {
3070 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
3071 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
3072 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
3073 "condition" => Ok(GeneratedField::Condition),
3074 "leftTableId" | "left_table_id" => Ok(GeneratedField::LeftTableId),
3075 "rightTableId" | "right_table_id" => Ok(GeneratedField::RightTableId),
3076 "leftInfo" | "left_info" => Ok(GeneratedField::LeftInfo),
3077 "rightInfo" | "right_info" => Ok(GeneratedField::RightInfo),
3078 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
3079 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3080 }
3081 }
3082 }
3083 deserializer.deserialize_identifier(GeneratedVisitor)
3084 }
3085 }
3086 struct GeneratedVisitor;
3087 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3088 type Value = DeltaIndexJoinNode;
3089
3090 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3091 formatter.write_str("struct stream_plan.DeltaIndexJoinNode")
3092 }
3093
3094 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaIndexJoinNode, V::Error>
3095 where
3096 V: serde::de::MapAccess<'de>,
3097 {
3098 let mut join_type__ = None;
3099 let mut left_key__ = None;
3100 let mut right_key__ = None;
3101 let mut condition__ = None;
3102 let mut left_table_id__ = None;
3103 let mut right_table_id__ = None;
3104 let mut left_info__ = None;
3105 let mut right_info__ = None;
3106 let mut output_indices__ = None;
3107 while let Some(k) = map_.next_key()? {
3108 match k {
3109 GeneratedField::JoinType => {
3110 if join_type__.is_some() {
3111 return Err(serde::de::Error::duplicate_field("joinType"));
3112 }
3113 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
3114 }
3115 GeneratedField::LeftKey => {
3116 if left_key__.is_some() {
3117 return Err(serde::de::Error::duplicate_field("leftKey"));
3118 }
3119 left_key__ =
3120 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3121 .into_iter().map(|x| x.0).collect())
3122 ;
3123 }
3124 GeneratedField::RightKey => {
3125 if right_key__.is_some() {
3126 return Err(serde::de::Error::duplicate_field("rightKey"));
3127 }
3128 right_key__ =
3129 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3130 .into_iter().map(|x| x.0).collect())
3131 ;
3132 }
3133 GeneratedField::Condition => {
3134 if condition__.is_some() {
3135 return Err(serde::de::Error::duplicate_field("condition"));
3136 }
3137 condition__ = map_.next_value()?;
3138 }
3139 GeneratedField::LeftTableId => {
3140 if left_table_id__.is_some() {
3141 return Err(serde::de::Error::duplicate_field("leftTableId"));
3142 }
3143 left_table_id__ =
3144 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3145 ;
3146 }
3147 GeneratedField::RightTableId => {
3148 if right_table_id__.is_some() {
3149 return Err(serde::de::Error::duplicate_field("rightTableId"));
3150 }
3151 right_table_id__ =
3152 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3153 ;
3154 }
3155 GeneratedField::LeftInfo => {
3156 if left_info__.is_some() {
3157 return Err(serde::de::Error::duplicate_field("leftInfo"));
3158 }
3159 left_info__ = map_.next_value()?;
3160 }
3161 GeneratedField::RightInfo => {
3162 if right_info__.is_some() {
3163 return Err(serde::de::Error::duplicate_field("rightInfo"));
3164 }
3165 right_info__ = map_.next_value()?;
3166 }
3167 GeneratedField::OutputIndices => {
3168 if output_indices__.is_some() {
3169 return Err(serde::de::Error::duplicate_field("outputIndices"));
3170 }
3171 output_indices__ =
3172 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3173 .into_iter().map(|x| x.0).collect())
3174 ;
3175 }
3176 }
3177 }
3178 Ok(DeltaIndexJoinNode {
3179 join_type: join_type__.unwrap_or_default(),
3180 left_key: left_key__.unwrap_or_default(),
3181 right_key: right_key__.unwrap_or_default(),
3182 condition: condition__,
3183 left_table_id: left_table_id__.unwrap_or_default(),
3184 right_table_id: right_table_id__.unwrap_or_default(),
3185 left_info: left_info__,
3186 right_info: right_info__,
3187 output_indices: output_indices__.unwrap_or_default(),
3188 })
3189 }
3190 }
3191 deserializer.deserialize_struct("stream_plan.DeltaIndexJoinNode", FIELDS, GeneratedVisitor)
3192 }
3193}
3194impl serde::Serialize for DispatchOutputMapping {
3195 #[allow(deprecated)]
3196 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3197 where
3198 S: serde::Serializer,
3199 {
3200 use serde::ser::SerializeStruct;
3201 let mut len = 0;
3202 if !self.indices.is_empty() {
3203 len += 1;
3204 }
3205 if !self.types.is_empty() {
3206 len += 1;
3207 }
3208 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping", len)?;
3209 if !self.indices.is_empty() {
3210 struct_ser.serialize_field("indices", &self.indices)?;
3211 }
3212 if !self.types.is_empty() {
3213 struct_ser.serialize_field("types", &self.types)?;
3214 }
3215 struct_ser.end()
3216 }
3217}
3218impl<'de> serde::Deserialize<'de> for DispatchOutputMapping {
3219 #[allow(deprecated)]
3220 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3221 where
3222 D: serde::Deserializer<'de>,
3223 {
3224 const FIELDS: &[&str] = &[
3225 "indices",
3226 "types",
3227 ];
3228
3229 #[allow(clippy::enum_variant_names)]
3230 enum GeneratedField {
3231 Indices,
3232 Types,
3233 }
3234 impl<'de> serde::Deserialize<'de> for GeneratedField {
3235 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3236 where
3237 D: serde::Deserializer<'de>,
3238 {
3239 struct GeneratedVisitor;
3240
3241 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3242 type Value = GeneratedField;
3243
3244 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3245 write!(formatter, "expected one of: {:?}", &FIELDS)
3246 }
3247
3248 #[allow(unused_variables)]
3249 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3250 where
3251 E: serde::de::Error,
3252 {
3253 match value {
3254 "indices" => Ok(GeneratedField::Indices),
3255 "types" => Ok(GeneratedField::Types),
3256 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3257 }
3258 }
3259 }
3260 deserializer.deserialize_identifier(GeneratedVisitor)
3261 }
3262 }
3263 struct GeneratedVisitor;
3264 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3265 type Value = DispatchOutputMapping;
3266
3267 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3268 formatter.write_str("struct stream_plan.DispatchOutputMapping")
3269 }
3270
3271 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchOutputMapping, V::Error>
3272 where
3273 V: serde::de::MapAccess<'de>,
3274 {
3275 let mut indices__ = None;
3276 let mut types__ = None;
3277 while let Some(k) = map_.next_key()? {
3278 match k {
3279 GeneratedField::Indices => {
3280 if indices__.is_some() {
3281 return Err(serde::de::Error::duplicate_field("indices"));
3282 }
3283 indices__ =
3284 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3285 .into_iter().map(|x| x.0).collect())
3286 ;
3287 }
3288 GeneratedField::Types => {
3289 if types__.is_some() {
3290 return Err(serde::de::Error::duplicate_field("types"));
3291 }
3292 types__ = Some(map_.next_value()?);
3293 }
3294 }
3295 }
3296 Ok(DispatchOutputMapping {
3297 indices: indices__.unwrap_or_default(),
3298 types: types__.unwrap_or_default(),
3299 })
3300 }
3301 }
3302 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping", FIELDS, GeneratedVisitor)
3303 }
3304}
3305impl serde::Serialize for dispatch_output_mapping::TypePair {
3306 #[allow(deprecated)]
3307 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3308 where
3309 S: serde::Serializer,
3310 {
3311 use serde::ser::SerializeStruct;
3312 let mut len = 0;
3313 if self.upstream.is_some() {
3314 len += 1;
3315 }
3316 if self.downstream.is_some() {
3317 len += 1;
3318 }
3319 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping.TypePair", len)?;
3320 if let Some(v) = self.upstream.as_ref() {
3321 struct_ser.serialize_field("upstream", v)?;
3322 }
3323 if let Some(v) = self.downstream.as_ref() {
3324 struct_ser.serialize_field("downstream", v)?;
3325 }
3326 struct_ser.end()
3327 }
3328}
3329impl<'de> serde::Deserialize<'de> for dispatch_output_mapping::TypePair {
3330 #[allow(deprecated)]
3331 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3332 where
3333 D: serde::Deserializer<'de>,
3334 {
3335 const FIELDS: &[&str] = &[
3336 "upstream",
3337 "downstream",
3338 ];
3339
3340 #[allow(clippy::enum_variant_names)]
3341 enum GeneratedField {
3342 Upstream,
3343 Downstream,
3344 }
3345 impl<'de> serde::Deserialize<'de> for GeneratedField {
3346 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3347 where
3348 D: serde::Deserializer<'de>,
3349 {
3350 struct GeneratedVisitor;
3351
3352 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3353 type Value = GeneratedField;
3354
3355 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3356 write!(formatter, "expected one of: {:?}", &FIELDS)
3357 }
3358
3359 #[allow(unused_variables)]
3360 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3361 where
3362 E: serde::de::Error,
3363 {
3364 match value {
3365 "upstream" => Ok(GeneratedField::Upstream),
3366 "downstream" => Ok(GeneratedField::Downstream),
3367 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3368 }
3369 }
3370 }
3371 deserializer.deserialize_identifier(GeneratedVisitor)
3372 }
3373 }
3374 struct GeneratedVisitor;
3375 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3376 type Value = dispatch_output_mapping::TypePair;
3377
3378 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3379 formatter.write_str("struct stream_plan.DispatchOutputMapping.TypePair")
3380 }
3381
3382 fn visit_map<V>(self, mut map_: V) -> std::result::Result<dispatch_output_mapping::TypePair, V::Error>
3383 where
3384 V: serde::de::MapAccess<'de>,
3385 {
3386 let mut upstream__ = None;
3387 let mut downstream__ = None;
3388 while let Some(k) = map_.next_key()? {
3389 match k {
3390 GeneratedField::Upstream => {
3391 if upstream__.is_some() {
3392 return Err(serde::de::Error::duplicate_field("upstream"));
3393 }
3394 upstream__ = map_.next_value()?;
3395 }
3396 GeneratedField::Downstream => {
3397 if downstream__.is_some() {
3398 return Err(serde::de::Error::duplicate_field("downstream"));
3399 }
3400 downstream__ = map_.next_value()?;
3401 }
3402 }
3403 }
3404 Ok(dispatch_output_mapping::TypePair {
3405 upstream: upstream__,
3406 downstream: downstream__,
3407 })
3408 }
3409 }
3410 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping.TypePair", FIELDS, GeneratedVisitor)
3411 }
3412}
3413impl serde::Serialize for DispatchStrategy {
3414 #[allow(deprecated)]
3415 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3416 where
3417 S: serde::Serializer,
3418 {
3419 use serde::ser::SerializeStruct;
3420 let mut len = 0;
3421 if self.r#type != 0 {
3422 len += 1;
3423 }
3424 if !self.dist_key_indices.is_empty() {
3425 len += 1;
3426 }
3427 if self.output_mapping.is_some() {
3428 len += 1;
3429 }
3430 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchStrategy", len)?;
3431 if self.r#type != 0 {
3432 let v = DispatcherType::try_from(self.r#type)
3433 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3434 struct_ser.serialize_field("type", &v)?;
3435 }
3436 if !self.dist_key_indices.is_empty() {
3437 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3438 }
3439 if let Some(v) = self.output_mapping.as_ref() {
3440 struct_ser.serialize_field("outputMapping", v)?;
3441 }
3442 struct_ser.end()
3443 }
3444}
3445impl<'de> serde::Deserialize<'de> for DispatchStrategy {
3446 #[allow(deprecated)]
3447 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3448 where
3449 D: serde::Deserializer<'de>,
3450 {
3451 const FIELDS: &[&str] = &[
3452 "type",
3453 "dist_key_indices",
3454 "distKeyIndices",
3455 "output_mapping",
3456 "outputMapping",
3457 ];
3458
3459 #[allow(clippy::enum_variant_names)]
3460 enum GeneratedField {
3461 Type,
3462 DistKeyIndices,
3463 OutputMapping,
3464 }
3465 impl<'de> serde::Deserialize<'de> for GeneratedField {
3466 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3467 where
3468 D: serde::Deserializer<'de>,
3469 {
3470 struct GeneratedVisitor;
3471
3472 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3473 type Value = GeneratedField;
3474
3475 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3476 write!(formatter, "expected one of: {:?}", &FIELDS)
3477 }
3478
3479 #[allow(unused_variables)]
3480 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3481 where
3482 E: serde::de::Error,
3483 {
3484 match value {
3485 "type" => Ok(GeneratedField::Type),
3486 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3487 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3488 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3489 }
3490 }
3491 }
3492 deserializer.deserialize_identifier(GeneratedVisitor)
3493 }
3494 }
3495 struct GeneratedVisitor;
3496 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3497 type Value = DispatchStrategy;
3498
3499 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3500 formatter.write_str("struct stream_plan.DispatchStrategy")
3501 }
3502
3503 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchStrategy, V::Error>
3504 where
3505 V: serde::de::MapAccess<'de>,
3506 {
3507 let mut r#type__ = None;
3508 let mut dist_key_indices__ = None;
3509 let mut output_mapping__ = None;
3510 while let Some(k) = map_.next_key()? {
3511 match k {
3512 GeneratedField::Type => {
3513 if r#type__.is_some() {
3514 return Err(serde::de::Error::duplicate_field("type"));
3515 }
3516 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3517 }
3518 GeneratedField::DistKeyIndices => {
3519 if dist_key_indices__.is_some() {
3520 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3521 }
3522 dist_key_indices__ =
3523 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3524 .into_iter().map(|x| x.0).collect())
3525 ;
3526 }
3527 GeneratedField::OutputMapping => {
3528 if output_mapping__.is_some() {
3529 return Err(serde::de::Error::duplicate_field("outputMapping"));
3530 }
3531 output_mapping__ = map_.next_value()?;
3532 }
3533 }
3534 }
3535 Ok(DispatchStrategy {
3536 r#type: r#type__.unwrap_or_default(),
3537 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3538 output_mapping: output_mapping__,
3539 })
3540 }
3541 }
3542 deserializer.deserialize_struct("stream_plan.DispatchStrategy", FIELDS, GeneratedVisitor)
3543 }
3544}
3545impl serde::Serialize for Dispatcher {
3546 #[allow(deprecated)]
3547 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3548 where
3549 S: serde::Serializer,
3550 {
3551 use serde::ser::SerializeStruct;
3552 let mut len = 0;
3553 if self.r#type != 0 {
3554 len += 1;
3555 }
3556 if !self.dist_key_indices.is_empty() {
3557 len += 1;
3558 }
3559 if self.output_mapping.is_some() {
3560 len += 1;
3561 }
3562 if self.hash_mapping.is_some() {
3563 len += 1;
3564 }
3565 if self.dispatcher_id != 0 {
3566 len += 1;
3567 }
3568 if !self.downstream_actor_id.is_empty() {
3569 len += 1;
3570 }
3571 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatcher", len)?;
3572 if self.r#type != 0 {
3573 let v = DispatcherType::try_from(self.r#type)
3574 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3575 struct_ser.serialize_field("type", &v)?;
3576 }
3577 if !self.dist_key_indices.is_empty() {
3578 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3579 }
3580 if let Some(v) = self.output_mapping.as_ref() {
3581 struct_ser.serialize_field("outputMapping", v)?;
3582 }
3583 if let Some(v) = self.hash_mapping.as_ref() {
3584 struct_ser.serialize_field("hashMapping", v)?;
3585 }
3586 if self.dispatcher_id != 0 {
3587 #[allow(clippy::needless_borrow)]
3588 #[allow(clippy::needless_borrows_for_generic_args)]
3589 struct_ser.serialize_field("dispatcherId", ToString::to_string(&self.dispatcher_id).as_str())?;
3590 }
3591 if !self.downstream_actor_id.is_empty() {
3592 struct_ser.serialize_field("downstreamActorId", &self.downstream_actor_id)?;
3593 }
3594 struct_ser.end()
3595 }
3596}
3597impl<'de> serde::Deserialize<'de> for Dispatcher {
3598 #[allow(deprecated)]
3599 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3600 where
3601 D: serde::Deserializer<'de>,
3602 {
3603 const FIELDS: &[&str] = &[
3604 "type",
3605 "dist_key_indices",
3606 "distKeyIndices",
3607 "output_mapping",
3608 "outputMapping",
3609 "hash_mapping",
3610 "hashMapping",
3611 "dispatcher_id",
3612 "dispatcherId",
3613 "downstream_actor_id",
3614 "downstreamActorId",
3615 ];
3616
3617 #[allow(clippy::enum_variant_names)]
3618 enum GeneratedField {
3619 Type,
3620 DistKeyIndices,
3621 OutputMapping,
3622 HashMapping,
3623 DispatcherId,
3624 DownstreamActorId,
3625 }
3626 impl<'de> serde::Deserialize<'de> for GeneratedField {
3627 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3628 where
3629 D: serde::Deserializer<'de>,
3630 {
3631 struct GeneratedVisitor;
3632
3633 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3634 type Value = GeneratedField;
3635
3636 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3637 write!(formatter, "expected one of: {:?}", &FIELDS)
3638 }
3639
3640 #[allow(unused_variables)]
3641 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3642 where
3643 E: serde::de::Error,
3644 {
3645 match value {
3646 "type" => Ok(GeneratedField::Type),
3647 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3648 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3649 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
3650 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
3651 "downstreamActorId" | "downstream_actor_id" => Ok(GeneratedField::DownstreamActorId),
3652 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3653 }
3654 }
3655 }
3656 deserializer.deserialize_identifier(GeneratedVisitor)
3657 }
3658 }
3659 struct GeneratedVisitor;
3660 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3661 type Value = Dispatcher;
3662
3663 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3664 formatter.write_str("struct stream_plan.Dispatcher")
3665 }
3666
3667 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatcher, V::Error>
3668 where
3669 V: serde::de::MapAccess<'de>,
3670 {
3671 let mut r#type__ = None;
3672 let mut dist_key_indices__ = None;
3673 let mut output_mapping__ = None;
3674 let mut hash_mapping__ = None;
3675 let mut dispatcher_id__ = None;
3676 let mut downstream_actor_id__ = None;
3677 while let Some(k) = map_.next_key()? {
3678 match k {
3679 GeneratedField::Type => {
3680 if r#type__.is_some() {
3681 return Err(serde::de::Error::duplicate_field("type"));
3682 }
3683 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3684 }
3685 GeneratedField::DistKeyIndices => {
3686 if dist_key_indices__.is_some() {
3687 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3688 }
3689 dist_key_indices__ =
3690 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3691 .into_iter().map(|x| x.0).collect())
3692 ;
3693 }
3694 GeneratedField::OutputMapping => {
3695 if output_mapping__.is_some() {
3696 return Err(serde::de::Error::duplicate_field("outputMapping"));
3697 }
3698 output_mapping__ = map_.next_value()?;
3699 }
3700 GeneratedField::HashMapping => {
3701 if hash_mapping__.is_some() {
3702 return Err(serde::de::Error::duplicate_field("hashMapping"));
3703 }
3704 hash_mapping__ = map_.next_value()?;
3705 }
3706 GeneratedField::DispatcherId => {
3707 if dispatcher_id__.is_some() {
3708 return Err(serde::de::Error::duplicate_field("dispatcherId"));
3709 }
3710 dispatcher_id__ =
3711 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3712 ;
3713 }
3714 GeneratedField::DownstreamActorId => {
3715 if downstream_actor_id__.is_some() {
3716 return Err(serde::de::Error::duplicate_field("downstreamActorId"));
3717 }
3718 downstream_actor_id__ =
3719 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3720 .into_iter().map(|x| x.0).collect())
3721 ;
3722 }
3723 }
3724 }
3725 Ok(Dispatcher {
3726 r#type: r#type__.unwrap_or_default(),
3727 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3728 output_mapping: output_mapping__,
3729 hash_mapping: hash_mapping__,
3730 dispatcher_id: dispatcher_id__.unwrap_or_default(),
3731 downstream_actor_id: downstream_actor_id__.unwrap_or_default(),
3732 })
3733 }
3734 }
3735 deserializer.deserialize_struct("stream_plan.Dispatcher", FIELDS, GeneratedVisitor)
3736 }
3737}
3738impl serde::Serialize for DispatcherType {
3739 #[allow(deprecated)]
3740 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3741 where
3742 S: serde::Serializer,
3743 {
3744 let variant = match self {
3745 Self::Unspecified => "DISPATCHER_TYPE_UNSPECIFIED",
3746 Self::Hash => "DISPATCHER_TYPE_HASH",
3747 Self::Broadcast => "DISPATCHER_TYPE_BROADCAST",
3748 Self::Simple => "DISPATCHER_TYPE_SIMPLE",
3749 Self::NoShuffle => "DISPATCHER_TYPE_NO_SHUFFLE",
3750 };
3751 serializer.serialize_str(variant)
3752 }
3753}
3754impl<'de> serde::Deserialize<'de> for DispatcherType {
3755 #[allow(deprecated)]
3756 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3757 where
3758 D: serde::Deserializer<'de>,
3759 {
3760 const FIELDS: &[&str] = &[
3761 "DISPATCHER_TYPE_UNSPECIFIED",
3762 "DISPATCHER_TYPE_HASH",
3763 "DISPATCHER_TYPE_BROADCAST",
3764 "DISPATCHER_TYPE_SIMPLE",
3765 "DISPATCHER_TYPE_NO_SHUFFLE",
3766 ];
3767
3768 struct GeneratedVisitor;
3769
3770 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3771 type Value = DispatcherType;
3772
3773 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3774 write!(formatter, "expected one of: {:?}", &FIELDS)
3775 }
3776
3777 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3778 where
3779 E: serde::de::Error,
3780 {
3781 i32::try_from(v)
3782 .ok()
3783 .and_then(|x| x.try_into().ok())
3784 .ok_or_else(|| {
3785 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3786 })
3787 }
3788
3789 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3790 where
3791 E: serde::de::Error,
3792 {
3793 i32::try_from(v)
3794 .ok()
3795 .and_then(|x| x.try_into().ok())
3796 .ok_or_else(|| {
3797 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3798 })
3799 }
3800
3801 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3802 where
3803 E: serde::de::Error,
3804 {
3805 match value {
3806 "DISPATCHER_TYPE_UNSPECIFIED" => Ok(DispatcherType::Unspecified),
3807 "DISPATCHER_TYPE_HASH" => Ok(DispatcherType::Hash),
3808 "DISPATCHER_TYPE_BROADCAST" => Ok(DispatcherType::Broadcast),
3809 "DISPATCHER_TYPE_SIMPLE" => Ok(DispatcherType::Simple),
3810 "DISPATCHER_TYPE_NO_SHUFFLE" => Ok(DispatcherType::NoShuffle),
3811 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3812 }
3813 }
3814 }
3815 deserializer.deserialize_any(GeneratedVisitor)
3816 }
3817}
3818impl serde::Serialize for Dispatchers {
3819 #[allow(deprecated)]
3820 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3821 where
3822 S: serde::Serializer,
3823 {
3824 use serde::ser::SerializeStruct;
3825 let mut len = 0;
3826 if !self.dispatchers.is_empty() {
3827 len += 1;
3828 }
3829 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatchers", len)?;
3830 if !self.dispatchers.is_empty() {
3831 struct_ser.serialize_field("dispatchers", &self.dispatchers)?;
3832 }
3833 struct_ser.end()
3834 }
3835}
3836impl<'de> serde::Deserialize<'de> for Dispatchers {
3837 #[allow(deprecated)]
3838 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3839 where
3840 D: serde::Deserializer<'de>,
3841 {
3842 const FIELDS: &[&str] = &[
3843 "dispatchers",
3844 ];
3845
3846 #[allow(clippy::enum_variant_names)]
3847 enum GeneratedField {
3848 Dispatchers,
3849 }
3850 impl<'de> serde::Deserialize<'de> for GeneratedField {
3851 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3852 where
3853 D: serde::Deserializer<'de>,
3854 {
3855 struct GeneratedVisitor;
3856
3857 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3858 type Value = GeneratedField;
3859
3860 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3861 write!(formatter, "expected one of: {:?}", &FIELDS)
3862 }
3863
3864 #[allow(unused_variables)]
3865 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3866 where
3867 E: serde::de::Error,
3868 {
3869 match value {
3870 "dispatchers" => Ok(GeneratedField::Dispatchers),
3871 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3872 }
3873 }
3874 }
3875 deserializer.deserialize_identifier(GeneratedVisitor)
3876 }
3877 }
3878 struct GeneratedVisitor;
3879 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3880 type Value = Dispatchers;
3881
3882 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3883 formatter.write_str("struct stream_plan.Dispatchers")
3884 }
3885
3886 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatchers, V::Error>
3887 where
3888 V: serde::de::MapAccess<'de>,
3889 {
3890 let mut dispatchers__ = None;
3891 while let Some(k) = map_.next_key()? {
3892 match k {
3893 GeneratedField::Dispatchers => {
3894 if dispatchers__.is_some() {
3895 return Err(serde::de::Error::duplicate_field("dispatchers"));
3896 }
3897 dispatchers__ = Some(map_.next_value()?);
3898 }
3899 }
3900 }
3901 Ok(Dispatchers {
3902 dispatchers: dispatchers__.unwrap_or_default(),
3903 })
3904 }
3905 }
3906 deserializer.deserialize_struct("stream_plan.Dispatchers", FIELDS, GeneratedVisitor)
3907 }
3908}
3909impl serde::Serialize for DmlNode {
3910 #[allow(deprecated)]
3911 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3912 where
3913 S: serde::Serializer,
3914 {
3915 use serde::ser::SerializeStruct;
3916 let mut len = 0;
3917 if self.table_id != 0 {
3918 len += 1;
3919 }
3920 if self.table_version_id != 0 {
3921 len += 1;
3922 }
3923 if !self.column_descs.is_empty() {
3924 len += 1;
3925 }
3926 if self.rate_limit.is_some() {
3927 len += 1;
3928 }
3929 let mut struct_ser = serializer.serialize_struct("stream_plan.DmlNode", len)?;
3930 if self.table_id != 0 {
3931 struct_ser.serialize_field("tableId", &self.table_id)?;
3932 }
3933 if self.table_version_id != 0 {
3934 #[allow(clippy::needless_borrow)]
3935 #[allow(clippy::needless_borrows_for_generic_args)]
3936 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
3937 }
3938 if !self.column_descs.is_empty() {
3939 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
3940 }
3941 if let Some(v) = self.rate_limit.as_ref() {
3942 struct_ser.serialize_field("rateLimit", v)?;
3943 }
3944 struct_ser.end()
3945 }
3946}
3947impl<'de> serde::Deserialize<'de> for DmlNode {
3948 #[allow(deprecated)]
3949 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3950 where
3951 D: serde::Deserializer<'de>,
3952 {
3953 const FIELDS: &[&str] = &[
3954 "table_id",
3955 "tableId",
3956 "table_version_id",
3957 "tableVersionId",
3958 "column_descs",
3959 "columnDescs",
3960 "rate_limit",
3961 "rateLimit",
3962 ];
3963
3964 #[allow(clippy::enum_variant_names)]
3965 enum GeneratedField {
3966 TableId,
3967 TableVersionId,
3968 ColumnDescs,
3969 RateLimit,
3970 }
3971 impl<'de> serde::Deserialize<'de> for GeneratedField {
3972 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3973 where
3974 D: serde::Deserializer<'de>,
3975 {
3976 struct GeneratedVisitor;
3977
3978 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3979 type Value = GeneratedField;
3980
3981 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3982 write!(formatter, "expected one of: {:?}", &FIELDS)
3983 }
3984
3985 #[allow(unused_variables)]
3986 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3987 where
3988 E: serde::de::Error,
3989 {
3990 match value {
3991 "tableId" | "table_id" => Ok(GeneratedField::TableId),
3992 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
3993 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
3994 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
3995 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3996 }
3997 }
3998 }
3999 deserializer.deserialize_identifier(GeneratedVisitor)
4000 }
4001 }
4002 struct GeneratedVisitor;
4003 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4004 type Value = DmlNode;
4005
4006 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4007 formatter.write_str("struct stream_plan.DmlNode")
4008 }
4009
4010 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DmlNode, V::Error>
4011 where
4012 V: serde::de::MapAccess<'de>,
4013 {
4014 let mut table_id__ = None;
4015 let mut table_version_id__ = None;
4016 let mut column_descs__ = None;
4017 let mut rate_limit__ = None;
4018 while let Some(k) = map_.next_key()? {
4019 match k {
4020 GeneratedField::TableId => {
4021 if table_id__.is_some() {
4022 return Err(serde::de::Error::duplicate_field("tableId"));
4023 }
4024 table_id__ =
4025 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4026 ;
4027 }
4028 GeneratedField::TableVersionId => {
4029 if table_version_id__.is_some() {
4030 return Err(serde::de::Error::duplicate_field("tableVersionId"));
4031 }
4032 table_version_id__ =
4033 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4034 ;
4035 }
4036 GeneratedField::ColumnDescs => {
4037 if column_descs__.is_some() {
4038 return Err(serde::de::Error::duplicate_field("columnDescs"));
4039 }
4040 column_descs__ = Some(map_.next_value()?);
4041 }
4042 GeneratedField::RateLimit => {
4043 if rate_limit__.is_some() {
4044 return Err(serde::de::Error::duplicate_field("rateLimit"));
4045 }
4046 rate_limit__ =
4047 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4048 ;
4049 }
4050 }
4051 }
4052 Ok(DmlNode {
4053 table_id: table_id__.unwrap_or_default(),
4054 table_version_id: table_version_id__.unwrap_or_default(),
4055 column_descs: column_descs__.unwrap_or_default(),
4056 rate_limit: rate_limit__,
4057 })
4058 }
4059 }
4060 deserializer.deserialize_struct("stream_plan.DmlNode", FIELDS, GeneratedVisitor)
4061 }
4062}
4063impl serde::Serialize for DropSubscriptionsMutation {
4064 #[allow(deprecated)]
4065 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4066 where
4067 S: serde::Serializer,
4068 {
4069 use serde::ser::SerializeStruct;
4070 let mut len = 0;
4071 if !self.info.is_empty() {
4072 len += 1;
4073 }
4074 let mut struct_ser = serializer.serialize_struct("stream_plan.DropSubscriptionsMutation", len)?;
4075 if !self.info.is_empty() {
4076 struct_ser.serialize_field("info", &self.info)?;
4077 }
4078 struct_ser.end()
4079 }
4080}
4081impl<'de> serde::Deserialize<'de> for DropSubscriptionsMutation {
4082 #[allow(deprecated)]
4083 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4084 where
4085 D: serde::Deserializer<'de>,
4086 {
4087 const FIELDS: &[&str] = &[
4088 "info",
4089 ];
4090
4091 #[allow(clippy::enum_variant_names)]
4092 enum GeneratedField {
4093 Info,
4094 }
4095 impl<'de> serde::Deserialize<'de> for GeneratedField {
4096 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4097 where
4098 D: serde::Deserializer<'de>,
4099 {
4100 struct GeneratedVisitor;
4101
4102 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4103 type Value = GeneratedField;
4104
4105 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4106 write!(formatter, "expected one of: {:?}", &FIELDS)
4107 }
4108
4109 #[allow(unused_variables)]
4110 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4111 where
4112 E: serde::de::Error,
4113 {
4114 match value {
4115 "info" => Ok(GeneratedField::Info),
4116 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4117 }
4118 }
4119 }
4120 deserializer.deserialize_identifier(GeneratedVisitor)
4121 }
4122 }
4123 struct GeneratedVisitor;
4124 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4125 type Value = DropSubscriptionsMutation;
4126
4127 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4128 formatter.write_str("struct stream_plan.DropSubscriptionsMutation")
4129 }
4130
4131 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionsMutation, V::Error>
4132 where
4133 V: serde::de::MapAccess<'de>,
4134 {
4135 let mut info__ = None;
4136 while let Some(k) = map_.next_key()? {
4137 match k {
4138 GeneratedField::Info => {
4139 if info__.is_some() {
4140 return Err(serde::de::Error::duplicate_field("info"));
4141 }
4142 info__ = Some(map_.next_value()?);
4143 }
4144 }
4145 }
4146 Ok(DropSubscriptionsMutation {
4147 info: info__.unwrap_or_default(),
4148 })
4149 }
4150 }
4151 deserializer.deserialize_struct("stream_plan.DropSubscriptionsMutation", FIELDS, GeneratedVisitor)
4152 }
4153}
4154impl serde::Serialize for DynamicFilterNode {
4155 #[allow(deprecated)]
4156 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4157 where
4158 S: serde::Serializer,
4159 {
4160 use serde::ser::SerializeStruct;
4161 let mut len = 0;
4162 if self.left_key != 0 {
4163 len += 1;
4164 }
4165 if self.condition.is_some() {
4166 len += 1;
4167 }
4168 if self.left_table.is_some() {
4169 len += 1;
4170 }
4171 if self.right_table.is_some() {
4172 len += 1;
4173 }
4174 if self.condition_always_relax {
4175 len += 1;
4176 }
4177 let mut struct_ser = serializer.serialize_struct("stream_plan.DynamicFilterNode", len)?;
4178 if self.left_key != 0 {
4179 struct_ser.serialize_field("leftKey", &self.left_key)?;
4180 }
4181 if let Some(v) = self.condition.as_ref() {
4182 struct_ser.serialize_field("condition", v)?;
4183 }
4184 if let Some(v) = self.left_table.as_ref() {
4185 struct_ser.serialize_field("leftTable", v)?;
4186 }
4187 if let Some(v) = self.right_table.as_ref() {
4188 struct_ser.serialize_field("rightTable", v)?;
4189 }
4190 if self.condition_always_relax {
4191 struct_ser.serialize_field("conditionAlwaysRelax", &self.condition_always_relax)?;
4192 }
4193 struct_ser.end()
4194 }
4195}
4196impl<'de> serde::Deserialize<'de> for DynamicFilterNode {
4197 #[allow(deprecated)]
4198 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4199 where
4200 D: serde::Deserializer<'de>,
4201 {
4202 const FIELDS: &[&str] = &[
4203 "left_key",
4204 "leftKey",
4205 "condition",
4206 "left_table",
4207 "leftTable",
4208 "right_table",
4209 "rightTable",
4210 "condition_always_relax",
4211 "conditionAlwaysRelax",
4212 ];
4213
4214 #[allow(clippy::enum_variant_names)]
4215 enum GeneratedField {
4216 LeftKey,
4217 Condition,
4218 LeftTable,
4219 RightTable,
4220 ConditionAlwaysRelax,
4221 }
4222 impl<'de> serde::Deserialize<'de> for GeneratedField {
4223 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4224 where
4225 D: serde::Deserializer<'de>,
4226 {
4227 struct GeneratedVisitor;
4228
4229 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4230 type Value = GeneratedField;
4231
4232 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4233 write!(formatter, "expected one of: {:?}", &FIELDS)
4234 }
4235
4236 #[allow(unused_variables)]
4237 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4238 where
4239 E: serde::de::Error,
4240 {
4241 match value {
4242 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
4243 "condition" => Ok(GeneratedField::Condition),
4244 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
4245 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
4246 "conditionAlwaysRelax" | "condition_always_relax" => Ok(GeneratedField::ConditionAlwaysRelax),
4247 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4248 }
4249 }
4250 }
4251 deserializer.deserialize_identifier(GeneratedVisitor)
4252 }
4253 }
4254 struct GeneratedVisitor;
4255 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4256 type Value = DynamicFilterNode;
4257
4258 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4259 formatter.write_str("struct stream_plan.DynamicFilterNode")
4260 }
4261
4262 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DynamicFilterNode, V::Error>
4263 where
4264 V: serde::de::MapAccess<'de>,
4265 {
4266 let mut left_key__ = None;
4267 let mut condition__ = None;
4268 let mut left_table__ = None;
4269 let mut right_table__ = None;
4270 let mut condition_always_relax__ = None;
4271 while let Some(k) = map_.next_key()? {
4272 match k {
4273 GeneratedField::LeftKey => {
4274 if left_key__.is_some() {
4275 return Err(serde::de::Error::duplicate_field("leftKey"));
4276 }
4277 left_key__ =
4278 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4279 ;
4280 }
4281 GeneratedField::Condition => {
4282 if condition__.is_some() {
4283 return Err(serde::de::Error::duplicate_field("condition"));
4284 }
4285 condition__ = map_.next_value()?;
4286 }
4287 GeneratedField::LeftTable => {
4288 if left_table__.is_some() {
4289 return Err(serde::de::Error::duplicate_field("leftTable"));
4290 }
4291 left_table__ = map_.next_value()?;
4292 }
4293 GeneratedField::RightTable => {
4294 if right_table__.is_some() {
4295 return Err(serde::de::Error::duplicate_field("rightTable"));
4296 }
4297 right_table__ = map_.next_value()?;
4298 }
4299 GeneratedField::ConditionAlwaysRelax => {
4300 if condition_always_relax__.is_some() {
4301 return Err(serde::de::Error::duplicate_field("conditionAlwaysRelax"));
4302 }
4303 condition_always_relax__ = Some(map_.next_value()?);
4304 }
4305 }
4306 }
4307 Ok(DynamicFilterNode {
4308 left_key: left_key__.unwrap_or_default(),
4309 condition: condition__,
4310 left_table: left_table__,
4311 right_table: right_table__,
4312 condition_always_relax: condition_always_relax__.unwrap_or_default(),
4313 })
4314 }
4315 }
4316 deserializer.deserialize_struct("stream_plan.DynamicFilterNode", FIELDS, GeneratedVisitor)
4317 }
4318}
4319impl serde::Serialize for EowcOverWindowNode {
4320 #[allow(deprecated)]
4321 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4322 where
4323 S: serde::Serializer,
4324 {
4325 use serde::ser::SerializeStruct;
4326 let mut len = 0;
4327 if !self.calls.is_empty() {
4328 len += 1;
4329 }
4330 if !self.partition_by.is_empty() {
4331 len += 1;
4332 }
4333 if !self.order_by.is_empty() {
4334 len += 1;
4335 }
4336 if self.state_table.is_some() {
4337 len += 1;
4338 }
4339 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcOverWindowNode", len)?;
4340 if !self.calls.is_empty() {
4341 struct_ser.serialize_field("calls", &self.calls)?;
4342 }
4343 if !self.partition_by.is_empty() {
4344 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
4345 }
4346 if !self.order_by.is_empty() {
4347 struct_ser.serialize_field("orderBy", &self.order_by)?;
4348 }
4349 if let Some(v) = self.state_table.as_ref() {
4350 struct_ser.serialize_field("stateTable", v)?;
4351 }
4352 struct_ser.end()
4353 }
4354}
4355impl<'de> serde::Deserialize<'de> for EowcOverWindowNode {
4356 #[allow(deprecated)]
4357 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4358 where
4359 D: serde::Deserializer<'de>,
4360 {
4361 const FIELDS: &[&str] = &[
4362 "calls",
4363 "partition_by",
4364 "partitionBy",
4365 "order_by",
4366 "orderBy",
4367 "state_table",
4368 "stateTable",
4369 ];
4370
4371 #[allow(clippy::enum_variant_names)]
4372 enum GeneratedField {
4373 Calls,
4374 PartitionBy,
4375 OrderBy,
4376 StateTable,
4377 }
4378 impl<'de> serde::Deserialize<'de> for GeneratedField {
4379 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4380 where
4381 D: serde::Deserializer<'de>,
4382 {
4383 struct GeneratedVisitor;
4384
4385 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4386 type Value = GeneratedField;
4387
4388 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4389 write!(formatter, "expected one of: {:?}", &FIELDS)
4390 }
4391
4392 #[allow(unused_variables)]
4393 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4394 where
4395 E: serde::de::Error,
4396 {
4397 match value {
4398 "calls" => Ok(GeneratedField::Calls),
4399 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
4400 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
4401 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
4402 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4403 }
4404 }
4405 }
4406 deserializer.deserialize_identifier(GeneratedVisitor)
4407 }
4408 }
4409 struct GeneratedVisitor;
4410 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4411 type Value = EowcOverWindowNode;
4412
4413 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4414 formatter.write_str("struct stream_plan.EowcOverWindowNode")
4415 }
4416
4417 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcOverWindowNode, V::Error>
4418 where
4419 V: serde::de::MapAccess<'de>,
4420 {
4421 let mut calls__ = None;
4422 let mut partition_by__ = None;
4423 let mut order_by__ = None;
4424 let mut state_table__ = None;
4425 while let Some(k) = map_.next_key()? {
4426 match k {
4427 GeneratedField::Calls => {
4428 if calls__.is_some() {
4429 return Err(serde::de::Error::duplicate_field("calls"));
4430 }
4431 calls__ = Some(map_.next_value()?);
4432 }
4433 GeneratedField::PartitionBy => {
4434 if partition_by__.is_some() {
4435 return Err(serde::de::Error::duplicate_field("partitionBy"));
4436 }
4437 partition_by__ =
4438 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4439 .into_iter().map(|x| x.0).collect())
4440 ;
4441 }
4442 GeneratedField::OrderBy => {
4443 if order_by__.is_some() {
4444 return Err(serde::de::Error::duplicate_field("orderBy"));
4445 }
4446 order_by__ = Some(map_.next_value()?);
4447 }
4448 GeneratedField::StateTable => {
4449 if state_table__.is_some() {
4450 return Err(serde::de::Error::duplicate_field("stateTable"));
4451 }
4452 state_table__ = map_.next_value()?;
4453 }
4454 }
4455 }
4456 Ok(EowcOverWindowNode {
4457 calls: calls__.unwrap_or_default(),
4458 partition_by: partition_by__.unwrap_or_default(),
4459 order_by: order_by__.unwrap_or_default(),
4460 state_table: state_table__,
4461 })
4462 }
4463 }
4464 deserializer.deserialize_struct("stream_plan.EowcOverWindowNode", FIELDS, GeneratedVisitor)
4465 }
4466}
4467impl serde::Serialize for ExchangeNode {
4468 #[allow(deprecated)]
4469 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4470 where
4471 S: serde::Serializer,
4472 {
4473 use serde::ser::SerializeStruct;
4474 let mut len = 0;
4475 if self.strategy.is_some() {
4476 len += 1;
4477 }
4478 let mut struct_ser = serializer.serialize_struct("stream_plan.ExchangeNode", len)?;
4479 if let Some(v) = self.strategy.as_ref() {
4480 struct_ser.serialize_field("strategy", v)?;
4481 }
4482 struct_ser.end()
4483 }
4484}
4485impl<'de> serde::Deserialize<'de> for ExchangeNode {
4486 #[allow(deprecated)]
4487 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4488 where
4489 D: serde::Deserializer<'de>,
4490 {
4491 const FIELDS: &[&str] = &[
4492 "strategy",
4493 ];
4494
4495 #[allow(clippy::enum_variant_names)]
4496 enum GeneratedField {
4497 Strategy,
4498 }
4499 impl<'de> serde::Deserialize<'de> for GeneratedField {
4500 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4501 where
4502 D: serde::Deserializer<'de>,
4503 {
4504 struct GeneratedVisitor;
4505
4506 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4507 type Value = GeneratedField;
4508
4509 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4510 write!(formatter, "expected one of: {:?}", &FIELDS)
4511 }
4512
4513 #[allow(unused_variables)]
4514 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4515 where
4516 E: serde::de::Error,
4517 {
4518 match value {
4519 "strategy" => Ok(GeneratedField::Strategy),
4520 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4521 }
4522 }
4523 }
4524 deserializer.deserialize_identifier(GeneratedVisitor)
4525 }
4526 }
4527 struct GeneratedVisitor;
4528 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4529 type Value = ExchangeNode;
4530
4531 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4532 formatter.write_str("struct stream_plan.ExchangeNode")
4533 }
4534
4535 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExchangeNode, V::Error>
4536 where
4537 V: serde::de::MapAccess<'de>,
4538 {
4539 let mut strategy__ = None;
4540 while let Some(k) = map_.next_key()? {
4541 match k {
4542 GeneratedField::Strategy => {
4543 if strategy__.is_some() {
4544 return Err(serde::de::Error::duplicate_field("strategy"));
4545 }
4546 strategy__ = map_.next_value()?;
4547 }
4548 }
4549 }
4550 Ok(ExchangeNode {
4551 strategy: strategy__,
4552 })
4553 }
4554 }
4555 deserializer.deserialize_struct("stream_plan.ExchangeNode", FIELDS, GeneratedVisitor)
4556 }
4557}
4558impl serde::Serialize for ExpandNode {
4559 #[allow(deprecated)]
4560 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4561 where
4562 S: serde::Serializer,
4563 {
4564 use serde::ser::SerializeStruct;
4565 let mut len = 0;
4566 if !self.column_subsets.is_empty() {
4567 len += 1;
4568 }
4569 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode", len)?;
4570 if !self.column_subsets.is_empty() {
4571 struct_ser.serialize_field("columnSubsets", &self.column_subsets)?;
4572 }
4573 struct_ser.end()
4574 }
4575}
4576impl<'de> serde::Deserialize<'de> for ExpandNode {
4577 #[allow(deprecated)]
4578 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4579 where
4580 D: serde::Deserializer<'de>,
4581 {
4582 const FIELDS: &[&str] = &[
4583 "column_subsets",
4584 "columnSubsets",
4585 ];
4586
4587 #[allow(clippy::enum_variant_names)]
4588 enum GeneratedField {
4589 ColumnSubsets,
4590 }
4591 impl<'de> serde::Deserialize<'de> for GeneratedField {
4592 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4593 where
4594 D: serde::Deserializer<'de>,
4595 {
4596 struct GeneratedVisitor;
4597
4598 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4599 type Value = GeneratedField;
4600
4601 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4602 write!(formatter, "expected one of: {:?}", &FIELDS)
4603 }
4604
4605 #[allow(unused_variables)]
4606 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4607 where
4608 E: serde::de::Error,
4609 {
4610 match value {
4611 "columnSubsets" | "column_subsets" => Ok(GeneratedField::ColumnSubsets),
4612 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4613 }
4614 }
4615 }
4616 deserializer.deserialize_identifier(GeneratedVisitor)
4617 }
4618 }
4619 struct GeneratedVisitor;
4620 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4621 type Value = ExpandNode;
4622
4623 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4624 formatter.write_str("struct stream_plan.ExpandNode")
4625 }
4626
4627 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpandNode, V::Error>
4628 where
4629 V: serde::de::MapAccess<'de>,
4630 {
4631 let mut column_subsets__ = None;
4632 while let Some(k) = map_.next_key()? {
4633 match k {
4634 GeneratedField::ColumnSubsets => {
4635 if column_subsets__.is_some() {
4636 return Err(serde::de::Error::duplicate_field("columnSubsets"));
4637 }
4638 column_subsets__ = Some(map_.next_value()?);
4639 }
4640 }
4641 }
4642 Ok(ExpandNode {
4643 column_subsets: column_subsets__.unwrap_or_default(),
4644 })
4645 }
4646 }
4647 deserializer.deserialize_struct("stream_plan.ExpandNode", FIELDS, GeneratedVisitor)
4648 }
4649}
4650impl serde::Serialize for expand_node::Subset {
4651 #[allow(deprecated)]
4652 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4653 where
4654 S: serde::Serializer,
4655 {
4656 use serde::ser::SerializeStruct;
4657 let mut len = 0;
4658 if !self.column_indices.is_empty() {
4659 len += 1;
4660 }
4661 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode.Subset", len)?;
4662 if !self.column_indices.is_empty() {
4663 struct_ser.serialize_field("columnIndices", &self.column_indices)?;
4664 }
4665 struct_ser.end()
4666 }
4667}
4668impl<'de> serde::Deserialize<'de> for expand_node::Subset {
4669 #[allow(deprecated)]
4670 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4671 where
4672 D: serde::Deserializer<'de>,
4673 {
4674 const FIELDS: &[&str] = &[
4675 "column_indices",
4676 "columnIndices",
4677 ];
4678
4679 #[allow(clippy::enum_variant_names)]
4680 enum GeneratedField {
4681 ColumnIndices,
4682 }
4683 impl<'de> serde::Deserialize<'de> for GeneratedField {
4684 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4685 where
4686 D: serde::Deserializer<'de>,
4687 {
4688 struct GeneratedVisitor;
4689
4690 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4691 type Value = GeneratedField;
4692
4693 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4694 write!(formatter, "expected one of: {:?}", &FIELDS)
4695 }
4696
4697 #[allow(unused_variables)]
4698 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4699 where
4700 E: serde::de::Error,
4701 {
4702 match value {
4703 "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
4704 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4705 }
4706 }
4707 }
4708 deserializer.deserialize_identifier(GeneratedVisitor)
4709 }
4710 }
4711 struct GeneratedVisitor;
4712 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4713 type Value = expand_node::Subset;
4714
4715 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4716 formatter.write_str("struct stream_plan.ExpandNode.Subset")
4717 }
4718
4719 fn visit_map<V>(self, mut map_: V) -> std::result::Result<expand_node::Subset, V::Error>
4720 where
4721 V: serde::de::MapAccess<'de>,
4722 {
4723 let mut column_indices__ = None;
4724 while let Some(k) = map_.next_key()? {
4725 match k {
4726 GeneratedField::ColumnIndices => {
4727 if column_indices__.is_some() {
4728 return Err(serde::de::Error::duplicate_field("columnIndices"));
4729 }
4730 column_indices__ =
4731 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4732 .into_iter().map(|x| x.0).collect())
4733 ;
4734 }
4735 }
4736 }
4737 Ok(expand_node::Subset {
4738 column_indices: column_indices__.unwrap_or_default(),
4739 })
4740 }
4741 }
4742 deserializer.deserialize_struct("stream_plan.ExpandNode.Subset", FIELDS, GeneratedVisitor)
4743 }
4744}
4745impl serde::Serialize for FilterNode {
4746 #[allow(deprecated)]
4747 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4748 where
4749 S: serde::Serializer,
4750 {
4751 use serde::ser::SerializeStruct;
4752 let mut len = 0;
4753 if self.search_condition.is_some() {
4754 len += 1;
4755 }
4756 let mut struct_ser = serializer.serialize_struct("stream_plan.FilterNode", len)?;
4757 if let Some(v) = self.search_condition.as_ref() {
4758 struct_ser.serialize_field("searchCondition", v)?;
4759 }
4760 struct_ser.end()
4761 }
4762}
4763impl<'de> serde::Deserialize<'de> for FilterNode {
4764 #[allow(deprecated)]
4765 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4766 where
4767 D: serde::Deserializer<'de>,
4768 {
4769 const FIELDS: &[&str] = &[
4770 "search_condition",
4771 "searchCondition",
4772 ];
4773
4774 #[allow(clippy::enum_variant_names)]
4775 enum GeneratedField {
4776 SearchCondition,
4777 }
4778 impl<'de> serde::Deserialize<'de> for GeneratedField {
4779 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4780 where
4781 D: serde::Deserializer<'de>,
4782 {
4783 struct GeneratedVisitor;
4784
4785 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4786 type Value = GeneratedField;
4787
4788 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4789 write!(formatter, "expected one of: {:?}", &FIELDS)
4790 }
4791
4792 #[allow(unused_variables)]
4793 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4794 where
4795 E: serde::de::Error,
4796 {
4797 match value {
4798 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
4799 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4800 }
4801 }
4802 }
4803 deserializer.deserialize_identifier(GeneratedVisitor)
4804 }
4805 }
4806 struct GeneratedVisitor;
4807 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4808 type Value = FilterNode;
4809
4810 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4811 formatter.write_str("struct stream_plan.FilterNode")
4812 }
4813
4814 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FilterNode, V::Error>
4815 where
4816 V: serde::de::MapAccess<'de>,
4817 {
4818 let mut search_condition__ = None;
4819 while let Some(k) = map_.next_key()? {
4820 match k {
4821 GeneratedField::SearchCondition => {
4822 if search_condition__.is_some() {
4823 return Err(serde::de::Error::duplicate_field("searchCondition"));
4824 }
4825 search_condition__ = map_.next_value()?;
4826 }
4827 }
4828 }
4829 Ok(FilterNode {
4830 search_condition: search_condition__,
4831 })
4832 }
4833 }
4834 deserializer.deserialize_struct("stream_plan.FilterNode", FIELDS, GeneratedVisitor)
4835 }
4836}
4837impl serde::Serialize for GlobalApproxPercentileNode {
4838 #[allow(deprecated)]
4839 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4840 where
4841 S: serde::Serializer,
4842 {
4843 use serde::ser::SerializeStruct;
4844 let mut len = 0;
4845 if self.base != 0. {
4846 len += 1;
4847 }
4848 if self.quantile != 0. {
4849 len += 1;
4850 }
4851 if self.bucket_state_table.is_some() {
4852 len += 1;
4853 }
4854 if self.count_state_table.is_some() {
4855 len += 1;
4856 }
4857 let mut struct_ser = serializer.serialize_struct("stream_plan.GlobalApproxPercentileNode", len)?;
4858 if self.base != 0. {
4859 struct_ser.serialize_field("base", &self.base)?;
4860 }
4861 if self.quantile != 0. {
4862 struct_ser.serialize_field("quantile", &self.quantile)?;
4863 }
4864 if let Some(v) = self.bucket_state_table.as_ref() {
4865 struct_ser.serialize_field("bucketStateTable", v)?;
4866 }
4867 if let Some(v) = self.count_state_table.as_ref() {
4868 struct_ser.serialize_field("countStateTable", v)?;
4869 }
4870 struct_ser.end()
4871 }
4872}
4873impl<'de> serde::Deserialize<'de> for GlobalApproxPercentileNode {
4874 #[allow(deprecated)]
4875 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4876 where
4877 D: serde::Deserializer<'de>,
4878 {
4879 const FIELDS: &[&str] = &[
4880 "base",
4881 "quantile",
4882 "bucket_state_table",
4883 "bucketStateTable",
4884 "count_state_table",
4885 "countStateTable",
4886 ];
4887
4888 #[allow(clippy::enum_variant_names)]
4889 enum GeneratedField {
4890 Base,
4891 Quantile,
4892 BucketStateTable,
4893 CountStateTable,
4894 }
4895 impl<'de> serde::Deserialize<'de> for GeneratedField {
4896 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4897 where
4898 D: serde::Deserializer<'de>,
4899 {
4900 struct GeneratedVisitor;
4901
4902 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4903 type Value = GeneratedField;
4904
4905 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4906 write!(formatter, "expected one of: {:?}", &FIELDS)
4907 }
4908
4909 #[allow(unused_variables)]
4910 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4911 where
4912 E: serde::de::Error,
4913 {
4914 match value {
4915 "base" => Ok(GeneratedField::Base),
4916 "quantile" => Ok(GeneratedField::Quantile),
4917 "bucketStateTable" | "bucket_state_table" => Ok(GeneratedField::BucketStateTable),
4918 "countStateTable" | "count_state_table" => Ok(GeneratedField::CountStateTable),
4919 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4920 }
4921 }
4922 }
4923 deserializer.deserialize_identifier(GeneratedVisitor)
4924 }
4925 }
4926 struct GeneratedVisitor;
4927 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4928 type Value = GlobalApproxPercentileNode;
4929
4930 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4931 formatter.write_str("struct stream_plan.GlobalApproxPercentileNode")
4932 }
4933
4934 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GlobalApproxPercentileNode, V::Error>
4935 where
4936 V: serde::de::MapAccess<'de>,
4937 {
4938 let mut base__ = None;
4939 let mut quantile__ = None;
4940 let mut bucket_state_table__ = None;
4941 let mut count_state_table__ = None;
4942 while let Some(k) = map_.next_key()? {
4943 match k {
4944 GeneratedField::Base => {
4945 if base__.is_some() {
4946 return Err(serde::de::Error::duplicate_field("base"));
4947 }
4948 base__ =
4949 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4950 ;
4951 }
4952 GeneratedField::Quantile => {
4953 if quantile__.is_some() {
4954 return Err(serde::de::Error::duplicate_field("quantile"));
4955 }
4956 quantile__ =
4957 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4958 ;
4959 }
4960 GeneratedField::BucketStateTable => {
4961 if bucket_state_table__.is_some() {
4962 return Err(serde::de::Error::duplicate_field("bucketStateTable"));
4963 }
4964 bucket_state_table__ = map_.next_value()?;
4965 }
4966 GeneratedField::CountStateTable => {
4967 if count_state_table__.is_some() {
4968 return Err(serde::de::Error::duplicate_field("countStateTable"));
4969 }
4970 count_state_table__ = map_.next_value()?;
4971 }
4972 }
4973 }
4974 Ok(GlobalApproxPercentileNode {
4975 base: base__.unwrap_or_default(),
4976 quantile: quantile__.unwrap_or_default(),
4977 bucket_state_table: bucket_state_table__,
4978 count_state_table: count_state_table__,
4979 })
4980 }
4981 }
4982 deserializer.deserialize_struct("stream_plan.GlobalApproxPercentileNode", FIELDS, GeneratedVisitor)
4983 }
4984}
4985impl serde::Serialize for GroupTopNNode {
4986 #[allow(deprecated)]
4987 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4988 where
4989 S: serde::Serializer,
4990 {
4991 use serde::ser::SerializeStruct;
4992 let mut len = 0;
4993 if self.limit != 0 {
4994 len += 1;
4995 }
4996 if self.offset != 0 {
4997 len += 1;
4998 }
4999 if !self.group_key.is_empty() {
5000 len += 1;
5001 }
5002 if self.table.is_some() {
5003 len += 1;
5004 }
5005 if !self.order_by.is_empty() {
5006 len += 1;
5007 }
5008 if self.with_ties {
5009 len += 1;
5010 }
5011 let mut struct_ser = serializer.serialize_struct("stream_plan.GroupTopNNode", len)?;
5012 if self.limit != 0 {
5013 #[allow(clippy::needless_borrow)]
5014 #[allow(clippy::needless_borrows_for_generic_args)]
5015 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
5016 }
5017 if self.offset != 0 {
5018 #[allow(clippy::needless_borrow)]
5019 #[allow(clippy::needless_borrows_for_generic_args)]
5020 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
5021 }
5022 if !self.group_key.is_empty() {
5023 struct_ser.serialize_field("groupKey", &self.group_key)?;
5024 }
5025 if let Some(v) = self.table.as_ref() {
5026 struct_ser.serialize_field("table", v)?;
5027 }
5028 if !self.order_by.is_empty() {
5029 struct_ser.serialize_field("orderBy", &self.order_by)?;
5030 }
5031 if self.with_ties {
5032 struct_ser.serialize_field("withTies", &self.with_ties)?;
5033 }
5034 struct_ser.end()
5035 }
5036}
5037impl<'de> serde::Deserialize<'de> for GroupTopNNode {
5038 #[allow(deprecated)]
5039 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5040 where
5041 D: serde::Deserializer<'de>,
5042 {
5043 const FIELDS: &[&str] = &[
5044 "limit",
5045 "offset",
5046 "group_key",
5047 "groupKey",
5048 "table",
5049 "order_by",
5050 "orderBy",
5051 "with_ties",
5052 "withTies",
5053 ];
5054
5055 #[allow(clippy::enum_variant_names)]
5056 enum GeneratedField {
5057 Limit,
5058 Offset,
5059 GroupKey,
5060 Table,
5061 OrderBy,
5062 WithTies,
5063 }
5064 impl<'de> serde::Deserialize<'de> for GeneratedField {
5065 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5066 where
5067 D: serde::Deserializer<'de>,
5068 {
5069 struct GeneratedVisitor;
5070
5071 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5072 type Value = GeneratedField;
5073
5074 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5075 write!(formatter, "expected one of: {:?}", &FIELDS)
5076 }
5077
5078 #[allow(unused_variables)]
5079 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5080 where
5081 E: serde::de::Error,
5082 {
5083 match value {
5084 "limit" => Ok(GeneratedField::Limit),
5085 "offset" => Ok(GeneratedField::Offset),
5086 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5087 "table" => Ok(GeneratedField::Table),
5088 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
5089 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
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 = GroupTopNNode;
5100
5101 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5102 formatter.write_str("struct stream_plan.GroupTopNNode")
5103 }
5104
5105 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupTopNNode, V::Error>
5106 where
5107 V: serde::de::MapAccess<'de>,
5108 {
5109 let mut limit__ = None;
5110 let mut offset__ = None;
5111 let mut group_key__ = None;
5112 let mut table__ = None;
5113 let mut order_by__ = None;
5114 let mut with_ties__ = None;
5115 while let Some(k) = map_.next_key()? {
5116 match k {
5117 GeneratedField::Limit => {
5118 if limit__.is_some() {
5119 return Err(serde::de::Error::duplicate_field("limit"));
5120 }
5121 limit__ =
5122 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5123 ;
5124 }
5125 GeneratedField::Offset => {
5126 if offset__.is_some() {
5127 return Err(serde::de::Error::duplicate_field("offset"));
5128 }
5129 offset__ =
5130 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5131 ;
5132 }
5133 GeneratedField::GroupKey => {
5134 if group_key__.is_some() {
5135 return Err(serde::de::Error::duplicate_field("groupKey"));
5136 }
5137 group_key__ =
5138 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5139 .into_iter().map(|x| x.0).collect())
5140 ;
5141 }
5142 GeneratedField::Table => {
5143 if table__.is_some() {
5144 return Err(serde::de::Error::duplicate_field("table"));
5145 }
5146 table__ = map_.next_value()?;
5147 }
5148 GeneratedField::OrderBy => {
5149 if order_by__.is_some() {
5150 return Err(serde::de::Error::duplicate_field("orderBy"));
5151 }
5152 order_by__ = Some(map_.next_value()?);
5153 }
5154 GeneratedField::WithTies => {
5155 if with_ties__.is_some() {
5156 return Err(serde::de::Error::duplicate_field("withTies"));
5157 }
5158 with_ties__ = Some(map_.next_value()?);
5159 }
5160 }
5161 }
5162 Ok(GroupTopNNode {
5163 limit: limit__.unwrap_or_default(),
5164 offset: offset__.unwrap_or_default(),
5165 group_key: group_key__.unwrap_or_default(),
5166 table: table__,
5167 order_by: order_by__.unwrap_or_default(),
5168 with_ties: with_ties__.unwrap_or_default(),
5169 })
5170 }
5171 }
5172 deserializer.deserialize_struct("stream_plan.GroupTopNNode", FIELDS, GeneratedVisitor)
5173 }
5174}
5175impl serde::Serialize for HashAggNode {
5176 #[allow(deprecated)]
5177 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5178 where
5179 S: serde::Serializer,
5180 {
5181 use serde::ser::SerializeStruct;
5182 let mut len = 0;
5183 if !self.group_key.is_empty() {
5184 len += 1;
5185 }
5186 if !self.agg_calls.is_empty() {
5187 len += 1;
5188 }
5189 if !self.agg_call_states.is_empty() {
5190 len += 1;
5191 }
5192 if self.intermediate_state_table.is_some() {
5193 len += 1;
5194 }
5195 if self.is_append_only {
5196 len += 1;
5197 }
5198 if !self.distinct_dedup_tables.is_empty() {
5199 len += 1;
5200 }
5201 if self.row_count_index != 0 {
5202 len += 1;
5203 }
5204 if self.emit_on_window_close {
5205 len += 1;
5206 }
5207 if self.version != 0 {
5208 len += 1;
5209 }
5210 let mut struct_ser = serializer.serialize_struct("stream_plan.HashAggNode", len)?;
5211 if !self.group_key.is_empty() {
5212 struct_ser.serialize_field("groupKey", &self.group_key)?;
5213 }
5214 if !self.agg_calls.is_empty() {
5215 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
5216 }
5217 if !self.agg_call_states.is_empty() {
5218 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
5219 }
5220 if let Some(v) = self.intermediate_state_table.as_ref() {
5221 struct_ser.serialize_field("intermediateStateTable", v)?;
5222 }
5223 if self.is_append_only {
5224 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5225 }
5226 if !self.distinct_dedup_tables.is_empty() {
5227 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
5228 }
5229 if self.row_count_index != 0 {
5230 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
5231 }
5232 if self.emit_on_window_close {
5233 struct_ser.serialize_field("emitOnWindowClose", &self.emit_on_window_close)?;
5234 }
5235 if self.version != 0 {
5236 let v = AggNodeVersion::try_from(self.version)
5237 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
5238 struct_ser.serialize_field("version", &v)?;
5239 }
5240 struct_ser.end()
5241 }
5242}
5243impl<'de> serde::Deserialize<'de> for HashAggNode {
5244 #[allow(deprecated)]
5245 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5246 where
5247 D: serde::Deserializer<'de>,
5248 {
5249 const FIELDS: &[&str] = &[
5250 "group_key",
5251 "groupKey",
5252 "agg_calls",
5253 "aggCalls",
5254 "agg_call_states",
5255 "aggCallStates",
5256 "intermediate_state_table",
5257 "intermediateStateTable",
5258 "is_append_only",
5259 "isAppendOnly",
5260 "distinct_dedup_tables",
5261 "distinctDedupTables",
5262 "row_count_index",
5263 "rowCountIndex",
5264 "emit_on_window_close",
5265 "emitOnWindowClose",
5266 "version",
5267 ];
5268
5269 #[allow(clippy::enum_variant_names)]
5270 enum GeneratedField {
5271 GroupKey,
5272 AggCalls,
5273 AggCallStates,
5274 IntermediateStateTable,
5275 IsAppendOnly,
5276 DistinctDedupTables,
5277 RowCountIndex,
5278 EmitOnWindowClose,
5279 Version,
5280 }
5281 impl<'de> serde::Deserialize<'de> for GeneratedField {
5282 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5283 where
5284 D: serde::Deserializer<'de>,
5285 {
5286 struct GeneratedVisitor;
5287
5288 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5289 type Value = GeneratedField;
5290
5291 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5292 write!(formatter, "expected one of: {:?}", &FIELDS)
5293 }
5294
5295 #[allow(unused_variables)]
5296 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5297 where
5298 E: serde::de::Error,
5299 {
5300 match value {
5301 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5302 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
5303 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
5304 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
5305 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5306 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
5307 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
5308 "emitOnWindowClose" | "emit_on_window_close" => Ok(GeneratedField::EmitOnWindowClose),
5309 "version" => Ok(GeneratedField::Version),
5310 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5311 }
5312 }
5313 }
5314 deserializer.deserialize_identifier(GeneratedVisitor)
5315 }
5316 }
5317 struct GeneratedVisitor;
5318 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5319 type Value = HashAggNode;
5320
5321 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5322 formatter.write_str("struct stream_plan.HashAggNode")
5323 }
5324
5325 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashAggNode, V::Error>
5326 where
5327 V: serde::de::MapAccess<'de>,
5328 {
5329 let mut group_key__ = None;
5330 let mut agg_calls__ = None;
5331 let mut agg_call_states__ = None;
5332 let mut intermediate_state_table__ = None;
5333 let mut is_append_only__ = None;
5334 let mut distinct_dedup_tables__ = None;
5335 let mut row_count_index__ = None;
5336 let mut emit_on_window_close__ = None;
5337 let mut version__ = None;
5338 while let Some(k) = map_.next_key()? {
5339 match k {
5340 GeneratedField::GroupKey => {
5341 if group_key__.is_some() {
5342 return Err(serde::de::Error::duplicate_field("groupKey"));
5343 }
5344 group_key__ =
5345 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5346 .into_iter().map(|x| x.0).collect())
5347 ;
5348 }
5349 GeneratedField::AggCalls => {
5350 if agg_calls__.is_some() {
5351 return Err(serde::de::Error::duplicate_field("aggCalls"));
5352 }
5353 agg_calls__ = Some(map_.next_value()?);
5354 }
5355 GeneratedField::AggCallStates => {
5356 if agg_call_states__.is_some() {
5357 return Err(serde::de::Error::duplicate_field("aggCallStates"));
5358 }
5359 agg_call_states__ = Some(map_.next_value()?);
5360 }
5361 GeneratedField::IntermediateStateTable => {
5362 if intermediate_state_table__.is_some() {
5363 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
5364 }
5365 intermediate_state_table__ = map_.next_value()?;
5366 }
5367 GeneratedField::IsAppendOnly => {
5368 if is_append_only__.is_some() {
5369 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
5370 }
5371 is_append_only__ = Some(map_.next_value()?);
5372 }
5373 GeneratedField::DistinctDedupTables => {
5374 if distinct_dedup_tables__.is_some() {
5375 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
5376 }
5377 distinct_dedup_tables__ = Some(
5378 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5379 .into_iter().map(|(k,v)| (k.0, v)).collect()
5380 );
5381 }
5382 GeneratedField::RowCountIndex => {
5383 if row_count_index__.is_some() {
5384 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
5385 }
5386 row_count_index__ =
5387 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5388 ;
5389 }
5390 GeneratedField::EmitOnWindowClose => {
5391 if emit_on_window_close__.is_some() {
5392 return Err(serde::de::Error::duplicate_field("emitOnWindowClose"));
5393 }
5394 emit_on_window_close__ = Some(map_.next_value()?);
5395 }
5396 GeneratedField::Version => {
5397 if version__.is_some() {
5398 return Err(serde::de::Error::duplicate_field("version"));
5399 }
5400 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
5401 }
5402 }
5403 }
5404 Ok(HashAggNode {
5405 group_key: group_key__.unwrap_or_default(),
5406 agg_calls: agg_calls__.unwrap_or_default(),
5407 agg_call_states: agg_call_states__.unwrap_or_default(),
5408 intermediate_state_table: intermediate_state_table__,
5409 is_append_only: is_append_only__.unwrap_or_default(),
5410 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
5411 row_count_index: row_count_index__.unwrap_or_default(),
5412 emit_on_window_close: emit_on_window_close__.unwrap_or_default(),
5413 version: version__.unwrap_or_default(),
5414 })
5415 }
5416 }
5417 deserializer.deserialize_struct("stream_plan.HashAggNode", FIELDS, GeneratedVisitor)
5418 }
5419}
5420impl serde::Serialize for HashJoinNode {
5421 #[allow(deprecated)]
5422 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5423 where
5424 S: serde::Serializer,
5425 {
5426 use serde::ser::SerializeStruct;
5427 let mut len = 0;
5428 if self.join_type != 0 {
5429 len += 1;
5430 }
5431 if !self.left_key.is_empty() {
5432 len += 1;
5433 }
5434 if !self.right_key.is_empty() {
5435 len += 1;
5436 }
5437 if self.condition.is_some() {
5438 len += 1;
5439 }
5440 if !self.inequality_pairs.is_empty() {
5441 len += 1;
5442 }
5443 if self.left_table.is_some() {
5444 len += 1;
5445 }
5446 if self.right_table.is_some() {
5447 len += 1;
5448 }
5449 if self.left_degree_table.is_some() {
5450 len += 1;
5451 }
5452 if self.right_degree_table.is_some() {
5453 len += 1;
5454 }
5455 if !self.output_indices.is_empty() {
5456 len += 1;
5457 }
5458 if !self.left_deduped_input_pk_indices.is_empty() {
5459 len += 1;
5460 }
5461 if !self.right_deduped_input_pk_indices.is_empty() {
5462 len += 1;
5463 }
5464 if !self.null_safe.is_empty() {
5465 len += 1;
5466 }
5467 if self.is_append_only {
5468 len += 1;
5469 }
5470 if self.join_encoding_type != 0 {
5471 len += 1;
5472 }
5473 let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinNode", len)?;
5474 if self.join_type != 0 {
5475 let v = super::plan_common::JoinType::try_from(self.join_type)
5476 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
5477 struct_ser.serialize_field("joinType", &v)?;
5478 }
5479 if !self.left_key.is_empty() {
5480 struct_ser.serialize_field("leftKey", &self.left_key)?;
5481 }
5482 if !self.right_key.is_empty() {
5483 struct_ser.serialize_field("rightKey", &self.right_key)?;
5484 }
5485 if let Some(v) = self.condition.as_ref() {
5486 struct_ser.serialize_field("condition", v)?;
5487 }
5488 if !self.inequality_pairs.is_empty() {
5489 struct_ser.serialize_field("inequalityPairs", &self.inequality_pairs)?;
5490 }
5491 if let Some(v) = self.left_table.as_ref() {
5492 struct_ser.serialize_field("leftTable", v)?;
5493 }
5494 if let Some(v) = self.right_table.as_ref() {
5495 struct_ser.serialize_field("rightTable", v)?;
5496 }
5497 if let Some(v) = self.left_degree_table.as_ref() {
5498 struct_ser.serialize_field("leftDegreeTable", v)?;
5499 }
5500 if let Some(v) = self.right_degree_table.as_ref() {
5501 struct_ser.serialize_field("rightDegreeTable", v)?;
5502 }
5503 if !self.output_indices.is_empty() {
5504 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
5505 }
5506 if !self.left_deduped_input_pk_indices.is_empty() {
5507 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
5508 }
5509 if !self.right_deduped_input_pk_indices.is_empty() {
5510 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
5511 }
5512 if !self.null_safe.is_empty() {
5513 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
5514 }
5515 if self.is_append_only {
5516 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5517 }
5518 if self.join_encoding_type != 0 {
5519 let v = JoinEncodingType::try_from(self.join_encoding_type)
5520 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
5521 struct_ser.serialize_field("joinEncodingType", &v)?;
5522 }
5523 struct_ser.end()
5524 }
5525}
5526impl<'de> serde::Deserialize<'de> for HashJoinNode {
5527 #[allow(deprecated)]
5528 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5529 where
5530 D: serde::Deserializer<'de>,
5531 {
5532 const FIELDS: &[&str] = &[
5533 "join_type",
5534 "joinType",
5535 "left_key",
5536 "leftKey",
5537 "right_key",
5538 "rightKey",
5539 "condition",
5540 "inequality_pairs",
5541 "inequalityPairs",
5542 "left_table",
5543 "leftTable",
5544 "right_table",
5545 "rightTable",
5546 "left_degree_table",
5547 "leftDegreeTable",
5548 "right_degree_table",
5549 "rightDegreeTable",
5550 "output_indices",
5551 "outputIndices",
5552 "left_deduped_input_pk_indices",
5553 "leftDedupedInputPkIndices",
5554 "right_deduped_input_pk_indices",
5555 "rightDedupedInputPkIndices",
5556 "null_safe",
5557 "nullSafe",
5558 "is_append_only",
5559 "isAppendOnly",
5560 "join_encoding_type",
5561 "joinEncodingType",
5562 ];
5563
5564 #[allow(clippy::enum_variant_names)]
5565 enum GeneratedField {
5566 JoinType,
5567 LeftKey,
5568 RightKey,
5569 Condition,
5570 InequalityPairs,
5571 LeftTable,
5572 RightTable,
5573 LeftDegreeTable,
5574 RightDegreeTable,
5575 OutputIndices,
5576 LeftDedupedInputPkIndices,
5577 RightDedupedInputPkIndices,
5578 NullSafe,
5579 IsAppendOnly,
5580 JoinEncodingType,
5581 }
5582 impl<'de> serde::Deserialize<'de> for GeneratedField {
5583 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5584 where
5585 D: serde::Deserializer<'de>,
5586 {
5587 struct GeneratedVisitor;
5588
5589 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5590 type Value = GeneratedField;
5591
5592 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5593 write!(formatter, "expected one of: {:?}", &FIELDS)
5594 }
5595
5596 #[allow(unused_variables)]
5597 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5598 where
5599 E: serde::de::Error,
5600 {
5601 match value {
5602 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
5603 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
5604 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
5605 "condition" => Ok(GeneratedField::Condition),
5606 "inequalityPairs" | "inequality_pairs" => Ok(GeneratedField::InequalityPairs),
5607 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
5608 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
5609 "leftDegreeTable" | "left_degree_table" => Ok(GeneratedField::LeftDegreeTable),
5610 "rightDegreeTable" | "right_degree_table" => Ok(GeneratedField::RightDegreeTable),
5611 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
5612 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
5613 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
5614 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
5615 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5616 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
5617 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5618 }
5619 }
5620 }
5621 deserializer.deserialize_identifier(GeneratedVisitor)
5622 }
5623 }
5624 struct GeneratedVisitor;
5625 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5626 type Value = HashJoinNode;
5627
5628 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5629 formatter.write_str("struct stream_plan.HashJoinNode")
5630 }
5631
5632 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinNode, V::Error>
5633 where
5634 V: serde::de::MapAccess<'de>,
5635 {
5636 let mut join_type__ = None;
5637 let mut left_key__ = None;
5638 let mut right_key__ = None;
5639 let mut condition__ = None;
5640 let mut inequality_pairs__ = None;
5641 let mut left_table__ = None;
5642 let mut right_table__ = None;
5643 let mut left_degree_table__ = None;
5644 let mut right_degree_table__ = None;
5645 let mut output_indices__ = None;
5646 let mut left_deduped_input_pk_indices__ = None;
5647 let mut right_deduped_input_pk_indices__ = None;
5648 let mut null_safe__ = None;
5649 let mut is_append_only__ = None;
5650 let mut join_encoding_type__ = None;
5651 while let Some(k) = map_.next_key()? {
5652 match k {
5653 GeneratedField::JoinType => {
5654 if join_type__.is_some() {
5655 return Err(serde::de::Error::duplicate_field("joinType"));
5656 }
5657 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
5658 }
5659 GeneratedField::LeftKey => {
5660 if left_key__.is_some() {
5661 return Err(serde::de::Error::duplicate_field("leftKey"));
5662 }
5663 left_key__ =
5664 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5665 .into_iter().map(|x| x.0).collect())
5666 ;
5667 }
5668 GeneratedField::RightKey => {
5669 if right_key__.is_some() {
5670 return Err(serde::de::Error::duplicate_field("rightKey"));
5671 }
5672 right_key__ =
5673 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5674 .into_iter().map(|x| x.0).collect())
5675 ;
5676 }
5677 GeneratedField::Condition => {
5678 if condition__.is_some() {
5679 return Err(serde::de::Error::duplicate_field("condition"));
5680 }
5681 condition__ = map_.next_value()?;
5682 }
5683 GeneratedField::InequalityPairs => {
5684 if inequality_pairs__.is_some() {
5685 return Err(serde::de::Error::duplicate_field("inequalityPairs"));
5686 }
5687 inequality_pairs__ = Some(map_.next_value()?);
5688 }
5689 GeneratedField::LeftTable => {
5690 if left_table__.is_some() {
5691 return Err(serde::de::Error::duplicate_field("leftTable"));
5692 }
5693 left_table__ = map_.next_value()?;
5694 }
5695 GeneratedField::RightTable => {
5696 if right_table__.is_some() {
5697 return Err(serde::de::Error::duplicate_field("rightTable"));
5698 }
5699 right_table__ = map_.next_value()?;
5700 }
5701 GeneratedField::LeftDegreeTable => {
5702 if left_degree_table__.is_some() {
5703 return Err(serde::de::Error::duplicate_field("leftDegreeTable"));
5704 }
5705 left_degree_table__ = map_.next_value()?;
5706 }
5707 GeneratedField::RightDegreeTable => {
5708 if right_degree_table__.is_some() {
5709 return Err(serde::de::Error::duplicate_field("rightDegreeTable"));
5710 }
5711 right_degree_table__ = map_.next_value()?;
5712 }
5713 GeneratedField::OutputIndices => {
5714 if output_indices__.is_some() {
5715 return Err(serde::de::Error::duplicate_field("outputIndices"));
5716 }
5717 output_indices__ =
5718 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5719 .into_iter().map(|x| x.0).collect())
5720 ;
5721 }
5722 GeneratedField::LeftDedupedInputPkIndices => {
5723 if left_deduped_input_pk_indices__.is_some() {
5724 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
5725 }
5726 left_deduped_input_pk_indices__ =
5727 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5728 .into_iter().map(|x| x.0).collect())
5729 ;
5730 }
5731 GeneratedField::RightDedupedInputPkIndices => {
5732 if right_deduped_input_pk_indices__.is_some() {
5733 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
5734 }
5735 right_deduped_input_pk_indices__ =
5736 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5737 .into_iter().map(|x| x.0).collect())
5738 ;
5739 }
5740 GeneratedField::NullSafe => {
5741 if null_safe__.is_some() {
5742 return Err(serde::de::Error::duplicate_field("nullSafe"));
5743 }
5744 null_safe__ = Some(map_.next_value()?);
5745 }
5746 GeneratedField::IsAppendOnly => {
5747 if is_append_only__.is_some() {
5748 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
5749 }
5750 is_append_only__ = Some(map_.next_value()?);
5751 }
5752 GeneratedField::JoinEncodingType => {
5753 if join_encoding_type__.is_some() {
5754 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
5755 }
5756 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
5757 }
5758 }
5759 }
5760 Ok(HashJoinNode {
5761 join_type: join_type__.unwrap_or_default(),
5762 left_key: left_key__.unwrap_or_default(),
5763 right_key: right_key__.unwrap_or_default(),
5764 condition: condition__,
5765 inequality_pairs: inequality_pairs__.unwrap_or_default(),
5766 left_table: left_table__,
5767 right_table: right_table__,
5768 left_degree_table: left_degree_table__,
5769 right_degree_table: right_degree_table__,
5770 output_indices: output_indices__.unwrap_or_default(),
5771 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
5772 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
5773 null_safe: null_safe__.unwrap_or_default(),
5774 is_append_only: is_append_only__.unwrap_or_default(),
5775 join_encoding_type: join_encoding_type__.unwrap_or_default(),
5776 })
5777 }
5778 }
5779 deserializer.deserialize_struct("stream_plan.HashJoinNode", FIELDS, GeneratedVisitor)
5780 }
5781}
5782impl serde::Serialize for HopWindowNode {
5783 #[allow(deprecated)]
5784 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5785 where
5786 S: serde::Serializer,
5787 {
5788 use serde::ser::SerializeStruct;
5789 let mut len = 0;
5790 if self.time_col != 0 {
5791 len += 1;
5792 }
5793 if self.window_slide.is_some() {
5794 len += 1;
5795 }
5796 if self.window_size.is_some() {
5797 len += 1;
5798 }
5799 if !self.output_indices.is_empty() {
5800 len += 1;
5801 }
5802 if !self.window_start_exprs.is_empty() {
5803 len += 1;
5804 }
5805 if !self.window_end_exprs.is_empty() {
5806 len += 1;
5807 }
5808 let mut struct_ser = serializer.serialize_struct("stream_plan.HopWindowNode", len)?;
5809 if self.time_col != 0 {
5810 struct_ser.serialize_field("timeCol", &self.time_col)?;
5811 }
5812 if let Some(v) = self.window_slide.as_ref() {
5813 struct_ser.serialize_field("windowSlide", v)?;
5814 }
5815 if let Some(v) = self.window_size.as_ref() {
5816 struct_ser.serialize_field("windowSize", v)?;
5817 }
5818 if !self.output_indices.is_empty() {
5819 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
5820 }
5821 if !self.window_start_exprs.is_empty() {
5822 struct_ser.serialize_field("windowStartExprs", &self.window_start_exprs)?;
5823 }
5824 if !self.window_end_exprs.is_empty() {
5825 struct_ser.serialize_field("windowEndExprs", &self.window_end_exprs)?;
5826 }
5827 struct_ser.end()
5828 }
5829}
5830impl<'de> serde::Deserialize<'de> for HopWindowNode {
5831 #[allow(deprecated)]
5832 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5833 where
5834 D: serde::Deserializer<'de>,
5835 {
5836 const FIELDS: &[&str] = &[
5837 "time_col",
5838 "timeCol",
5839 "window_slide",
5840 "windowSlide",
5841 "window_size",
5842 "windowSize",
5843 "output_indices",
5844 "outputIndices",
5845 "window_start_exprs",
5846 "windowStartExprs",
5847 "window_end_exprs",
5848 "windowEndExprs",
5849 ];
5850
5851 #[allow(clippy::enum_variant_names)]
5852 enum GeneratedField {
5853 TimeCol,
5854 WindowSlide,
5855 WindowSize,
5856 OutputIndices,
5857 WindowStartExprs,
5858 WindowEndExprs,
5859 }
5860 impl<'de> serde::Deserialize<'de> for GeneratedField {
5861 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5862 where
5863 D: serde::Deserializer<'de>,
5864 {
5865 struct GeneratedVisitor;
5866
5867 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5868 type Value = GeneratedField;
5869
5870 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5871 write!(formatter, "expected one of: {:?}", &FIELDS)
5872 }
5873
5874 #[allow(unused_variables)]
5875 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5876 where
5877 E: serde::de::Error,
5878 {
5879 match value {
5880 "timeCol" | "time_col" => Ok(GeneratedField::TimeCol),
5881 "windowSlide" | "window_slide" => Ok(GeneratedField::WindowSlide),
5882 "windowSize" | "window_size" => Ok(GeneratedField::WindowSize),
5883 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
5884 "windowStartExprs" | "window_start_exprs" => Ok(GeneratedField::WindowStartExprs),
5885 "windowEndExprs" | "window_end_exprs" => Ok(GeneratedField::WindowEndExprs),
5886 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5887 }
5888 }
5889 }
5890 deserializer.deserialize_identifier(GeneratedVisitor)
5891 }
5892 }
5893 struct GeneratedVisitor;
5894 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5895 type Value = HopWindowNode;
5896
5897 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5898 formatter.write_str("struct stream_plan.HopWindowNode")
5899 }
5900
5901 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HopWindowNode, V::Error>
5902 where
5903 V: serde::de::MapAccess<'de>,
5904 {
5905 let mut time_col__ = None;
5906 let mut window_slide__ = None;
5907 let mut window_size__ = None;
5908 let mut output_indices__ = None;
5909 let mut window_start_exprs__ = None;
5910 let mut window_end_exprs__ = None;
5911 while let Some(k) = map_.next_key()? {
5912 match k {
5913 GeneratedField::TimeCol => {
5914 if time_col__.is_some() {
5915 return Err(serde::de::Error::duplicate_field("timeCol"));
5916 }
5917 time_col__ =
5918 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5919 ;
5920 }
5921 GeneratedField::WindowSlide => {
5922 if window_slide__.is_some() {
5923 return Err(serde::de::Error::duplicate_field("windowSlide"));
5924 }
5925 window_slide__ = map_.next_value()?;
5926 }
5927 GeneratedField::WindowSize => {
5928 if window_size__.is_some() {
5929 return Err(serde::de::Error::duplicate_field("windowSize"));
5930 }
5931 window_size__ = map_.next_value()?;
5932 }
5933 GeneratedField::OutputIndices => {
5934 if output_indices__.is_some() {
5935 return Err(serde::de::Error::duplicate_field("outputIndices"));
5936 }
5937 output_indices__ =
5938 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5939 .into_iter().map(|x| x.0).collect())
5940 ;
5941 }
5942 GeneratedField::WindowStartExprs => {
5943 if window_start_exprs__.is_some() {
5944 return Err(serde::de::Error::duplicate_field("windowStartExprs"));
5945 }
5946 window_start_exprs__ = Some(map_.next_value()?);
5947 }
5948 GeneratedField::WindowEndExprs => {
5949 if window_end_exprs__.is_some() {
5950 return Err(serde::de::Error::duplicate_field("windowEndExprs"));
5951 }
5952 window_end_exprs__ = Some(map_.next_value()?);
5953 }
5954 }
5955 }
5956 Ok(HopWindowNode {
5957 time_col: time_col__.unwrap_or_default(),
5958 window_slide: window_slide__,
5959 window_size: window_size__,
5960 output_indices: output_indices__.unwrap_or_default(),
5961 window_start_exprs: window_start_exprs__.unwrap_or_default(),
5962 window_end_exprs: window_end_exprs__.unwrap_or_default(),
5963 })
5964 }
5965 }
5966 deserializer.deserialize_struct("stream_plan.HopWindowNode", FIELDS, GeneratedVisitor)
5967 }
5968}
5969impl serde::Serialize for InequalityPair {
5970 #[allow(deprecated)]
5971 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5972 where
5973 S: serde::Serializer,
5974 {
5975 use serde::ser::SerializeStruct;
5976 let mut len = 0;
5977 if self.key_required_larger != 0 {
5978 len += 1;
5979 }
5980 if self.key_required_smaller != 0 {
5981 len += 1;
5982 }
5983 if self.clean_state {
5984 len += 1;
5985 }
5986 if self.delta_expression.is_some() {
5987 len += 1;
5988 }
5989 let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPair", len)?;
5990 if self.key_required_larger != 0 {
5991 struct_ser.serialize_field("keyRequiredLarger", &self.key_required_larger)?;
5992 }
5993 if self.key_required_smaller != 0 {
5994 struct_ser.serialize_field("keyRequiredSmaller", &self.key_required_smaller)?;
5995 }
5996 if self.clean_state {
5997 struct_ser.serialize_field("cleanState", &self.clean_state)?;
5998 }
5999 if let Some(v) = self.delta_expression.as_ref() {
6000 struct_ser.serialize_field("deltaExpression", v)?;
6001 }
6002 struct_ser.end()
6003 }
6004}
6005impl<'de> serde::Deserialize<'de> for InequalityPair {
6006 #[allow(deprecated)]
6007 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6008 where
6009 D: serde::Deserializer<'de>,
6010 {
6011 const FIELDS: &[&str] = &[
6012 "key_required_larger",
6013 "keyRequiredLarger",
6014 "key_required_smaller",
6015 "keyRequiredSmaller",
6016 "clean_state",
6017 "cleanState",
6018 "delta_expression",
6019 "deltaExpression",
6020 ];
6021
6022 #[allow(clippy::enum_variant_names)]
6023 enum GeneratedField {
6024 KeyRequiredLarger,
6025 KeyRequiredSmaller,
6026 CleanState,
6027 DeltaExpression,
6028 }
6029 impl<'de> serde::Deserialize<'de> for GeneratedField {
6030 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6031 where
6032 D: serde::Deserializer<'de>,
6033 {
6034 struct GeneratedVisitor;
6035
6036 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6037 type Value = GeneratedField;
6038
6039 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6040 write!(formatter, "expected one of: {:?}", &FIELDS)
6041 }
6042
6043 #[allow(unused_variables)]
6044 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6045 where
6046 E: serde::de::Error,
6047 {
6048 match value {
6049 "keyRequiredLarger" | "key_required_larger" => Ok(GeneratedField::KeyRequiredLarger),
6050 "keyRequiredSmaller" | "key_required_smaller" => Ok(GeneratedField::KeyRequiredSmaller),
6051 "cleanState" | "clean_state" => Ok(GeneratedField::CleanState),
6052 "deltaExpression" | "delta_expression" => Ok(GeneratedField::DeltaExpression),
6053 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6054 }
6055 }
6056 }
6057 deserializer.deserialize_identifier(GeneratedVisitor)
6058 }
6059 }
6060 struct GeneratedVisitor;
6061 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6062 type Value = InequalityPair;
6063
6064 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6065 formatter.write_str("struct stream_plan.InequalityPair")
6066 }
6067
6068 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPair, V::Error>
6069 where
6070 V: serde::de::MapAccess<'de>,
6071 {
6072 let mut key_required_larger__ = None;
6073 let mut key_required_smaller__ = None;
6074 let mut clean_state__ = None;
6075 let mut delta_expression__ = None;
6076 while let Some(k) = map_.next_key()? {
6077 match k {
6078 GeneratedField::KeyRequiredLarger => {
6079 if key_required_larger__.is_some() {
6080 return Err(serde::de::Error::duplicate_field("keyRequiredLarger"));
6081 }
6082 key_required_larger__ =
6083 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6084 ;
6085 }
6086 GeneratedField::KeyRequiredSmaller => {
6087 if key_required_smaller__.is_some() {
6088 return Err(serde::de::Error::duplicate_field("keyRequiredSmaller"));
6089 }
6090 key_required_smaller__ =
6091 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6092 ;
6093 }
6094 GeneratedField::CleanState => {
6095 if clean_state__.is_some() {
6096 return Err(serde::de::Error::duplicate_field("cleanState"));
6097 }
6098 clean_state__ = Some(map_.next_value()?);
6099 }
6100 GeneratedField::DeltaExpression => {
6101 if delta_expression__.is_some() {
6102 return Err(serde::de::Error::duplicate_field("deltaExpression"));
6103 }
6104 delta_expression__ = map_.next_value()?;
6105 }
6106 }
6107 }
6108 Ok(InequalityPair {
6109 key_required_larger: key_required_larger__.unwrap_or_default(),
6110 key_required_smaller: key_required_smaller__.unwrap_or_default(),
6111 clean_state: clean_state__.unwrap_or_default(),
6112 delta_expression: delta_expression__,
6113 })
6114 }
6115 }
6116 deserializer.deserialize_struct("stream_plan.InequalityPair", FIELDS, GeneratedVisitor)
6117 }
6118}
6119impl serde::Serialize for JoinEncodingType {
6120 #[allow(deprecated)]
6121 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6122 where
6123 S: serde::Serializer,
6124 {
6125 let variant = match self {
6126 Self::Unspecified => "UNSPECIFIED",
6127 Self::MemoryOptimized => "MEMORY_OPTIMIZED",
6128 Self::CpuOptimized => "CPU_OPTIMIZED",
6129 };
6130 serializer.serialize_str(variant)
6131 }
6132}
6133impl<'de> serde::Deserialize<'de> for JoinEncodingType {
6134 #[allow(deprecated)]
6135 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6136 where
6137 D: serde::Deserializer<'de>,
6138 {
6139 const FIELDS: &[&str] = &[
6140 "UNSPECIFIED",
6141 "MEMORY_OPTIMIZED",
6142 "CPU_OPTIMIZED",
6143 ];
6144
6145 struct GeneratedVisitor;
6146
6147 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6148 type Value = JoinEncodingType;
6149
6150 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6151 write!(formatter, "expected one of: {:?}", &FIELDS)
6152 }
6153
6154 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6155 where
6156 E: serde::de::Error,
6157 {
6158 i32::try_from(v)
6159 .ok()
6160 .and_then(|x| x.try_into().ok())
6161 .ok_or_else(|| {
6162 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6163 })
6164 }
6165
6166 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6167 where
6168 E: serde::de::Error,
6169 {
6170 i32::try_from(v)
6171 .ok()
6172 .and_then(|x| x.try_into().ok())
6173 .ok_or_else(|| {
6174 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6175 })
6176 }
6177
6178 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6179 where
6180 E: serde::de::Error,
6181 {
6182 match value {
6183 "UNSPECIFIED" => Ok(JoinEncodingType::Unspecified),
6184 "MEMORY_OPTIMIZED" => Ok(JoinEncodingType::MemoryOptimized),
6185 "CPU_OPTIMIZED" => Ok(JoinEncodingType::CpuOptimized),
6186 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6187 }
6188 }
6189 }
6190 deserializer.deserialize_any(GeneratedVisitor)
6191 }
6192}
6193impl serde::Serialize for LoadFinishMutation {
6194 #[allow(deprecated)]
6195 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6196 where
6197 S: serde::Serializer,
6198 {
6199 use serde::ser::SerializeStruct;
6200 let mut len = 0;
6201 if self.associated_source_id != 0 {
6202 len += 1;
6203 }
6204 let mut struct_ser = serializer.serialize_struct("stream_plan.LoadFinishMutation", len)?;
6205 if self.associated_source_id != 0 {
6206 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
6207 }
6208 struct_ser.end()
6209 }
6210}
6211impl<'de> serde::Deserialize<'de> for LoadFinishMutation {
6212 #[allow(deprecated)]
6213 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6214 where
6215 D: serde::Deserializer<'de>,
6216 {
6217 const FIELDS: &[&str] = &[
6218 "associated_source_id",
6219 "associatedSourceId",
6220 ];
6221
6222 #[allow(clippy::enum_variant_names)]
6223 enum GeneratedField {
6224 AssociatedSourceId,
6225 }
6226 impl<'de> serde::Deserialize<'de> for GeneratedField {
6227 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6228 where
6229 D: serde::Deserializer<'de>,
6230 {
6231 struct GeneratedVisitor;
6232
6233 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6234 type Value = GeneratedField;
6235
6236 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6237 write!(formatter, "expected one of: {:?}", &FIELDS)
6238 }
6239
6240 #[allow(unused_variables)]
6241 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6242 where
6243 E: serde::de::Error,
6244 {
6245 match value {
6246 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
6247 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6248 }
6249 }
6250 }
6251 deserializer.deserialize_identifier(GeneratedVisitor)
6252 }
6253 }
6254 struct GeneratedVisitor;
6255 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6256 type Value = LoadFinishMutation;
6257
6258 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6259 formatter.write_str("struct stream_plan.LoadFinishMutation")
6260 }
6261
6262 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LoadFinishMutation, V::Error>
6263 where
6264 V: serde::de::MapAccess<'de>,
6265 {
6266 let mut associated_source_id__ = None;
6267 while let Some(k) = map_.next_key()? {
6268 match k {
6269 GeneratedField::AssociatedSourceId => {
6270 if associated_source_id__.is_some() {
6271 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
6272 }
6273 associated_source_id__ =
6274 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6275 ;
6276 }
6277 }
6278 }
6279 Ok(LoadFinishMutation {
6280 associated_source_id: associated_source_id__.unwrap_or_default(),
6281 })
6282 }
6283 }
6284 deserializer.deserialize_struct("stream_plan.LoadFinishMutation", FIELDS, GeneratedVisitor)
6285 }
6286}
6287impl serde::Serialize for LocalApproxPercentileNode {
6288 #[allow(deprecated)]
6289 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6290 where
6291 S: serde::Serializer,
6292 {
6293 use serde::ser::SerializeStruct;
6294 let mut len = 0;
6295 if self.base != 0. {
6296 len += 1;
6297 }
6298 if self.percentile_index != 0 {
6299 len += 1;
6300 }
6301 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalApproxPercentileNode", len)?;
6302 if self.base != 0. {
6303 struct_ser.serialize_field("base", &self.base)?;
6304 }
6305 if self.percentile_index != 0 {
6306 struct_ser.serialize_field("percentileIndex", &self.percentile_index)?;
6307 }
6308 struct_ser.end()
6309 }
6310}
6311impl<'de> serde::Deserialize<'de> for LocalApproxPercentileNode {
6312 #[allow(deprecated)]
6313 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6314 where
6315 D: serde::Deserializer<'de>,
6316 {
6317 const FIELDS: &[&str] = &[
6318 "base",
6319 "percentile_index",
6320 "percentileIndex",
6321 ];
6322
6323 #[allow(clippy::enum_variant_names)]
6324 enum GeneratedField {
6325 Base,
6326 PercentileIndex,
6327 }
6328 impl<'de> serde::Deserialize<'de> for GeneratedField {
6329 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6330 where
6331 D: serde::Deserializer<'de>,
6332 {
6333 struct GeneratedVisitor;
6334
6335 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6336 type Value = GeneratedField;
6337
6338 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6339 write!(formatter, "expected one of: {:?}", &FIELDS)
6340 }
6341
6342 #[allow(unused_variables)]
6343 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6344 where
6345 E: serde::de::Error,
6346 {
6347 match value {
6348 "base" => Ok(GeneratedField::Base),
6349 "percentileIndex" | "percentile_index" => Ok(GeneratedField::PercentileIndex),
6350 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6351 }
6352 }
6353 }
6354 deserializer.deserialize_identifier(GeneratedVisitor)
6355 }
6356 }
6357 struct GeneratedVisitor;
6358 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6359 type Value = LocalApproxPercentileNode;
6360
6361 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6362 formatter.write_str("struct stream_plan.LocalApproxPercentileNode")
6363 }
6364
6365 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalApproxPercentileNode, V::Error>
6366 where
6367 V: serde::de::MapAccess<'de>,
6368 {
6369 let mut base__ = None;
6370 let mut percentile_index__ = None;
6371 while let Some(k) = map_.next_key()? {
6372 match k {
6373 GeneratedField::Base => {
6374 if base__.is_some() {
6375 return Err(serde::de::Error::duplicate_field("base"));
6376 }
6377 base__ =
6378 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6379 ;
6380 }
6381 GeneratedField::PercentileIndex => {
6382 if percentile_index__.is_some() {
6383 return Err(serde::de::Error::duplicate_field("percentileIndex"));
6384 }
6385 percentile_index__ =
6386 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6387 ;
6388 }
6389 }
6390 }
6391 Ok(LocalApproxPercentileNode {
6392 base: base__.unwrap_or_default(),
6393 percentile_index: percentile_index__.unwrap_or_default(),
6394 })
6395 }
6396 }
6397 deserializer.deserialize_struct("stream_plan.LocalApproxPercentileNode", FIELDS, GeneratedVisitor)
6398 }
6399}
6400impl serde::Serialize for LookupNode {
6401 #[allow(deprecated)]
6402 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6403 where
6404 S: serde::Serializer,
6405 {
6406 use serde::ser::SerializeStruct;
6407 let mut len = 0;
6408 if !self.arrange_key.is_empty() {
6409 len += 1;
6410 }
6411 if !self.stream_key.is_empty() {
6412 len += 1;
6413 }
6414 if self.use_current_epoch {
6415 len += 1;
6416 }
6417 if !self.column_mapping.is_empty() {
6418 len += 1;
6419 }
6420 if self.arrangement_table_info.is_some() {
6421 len += 1;
6422 }
6423 if self.arrangement_table_id.is_some() {
6424 len += 1;
6425 }
6426 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupNode", len)?;
6427 if !self.arrange_key.is_empty() {
6428 struct_ser.serialize_field("arrangeKey", &self.arrange_key)?;
6429 }
6430 if !self.stream_key.is_empty() {
6431 struct_ser.serialize_field("streamKey", &self.stream_key)?;
6432 }
6433 if self.use_current_epoch {
6434 struct_ser.serialize_field("useCurrentEpoch", &self.use_current_epoch)?;
6435 }
6436 if !self.column_mapping.is_empty() {
6437 struct_ser.serialize_field("columnMapping", &self.column_mapping)?;
6438 }
6439 if let Some(v) = self.arrangement_table_info.as_ref() {
6440 struct_ser.serialize_field("arrangementTableInfo", v)?;
6441 }
6442 if let Some(v) = self.arrangement_table_id.as_ref() {
6443 match v {
6444 lookup_node::ArrangementTableId::TableId(v) => {
6445 struct_ser.serialize_field("tableId", v)?;
6446 }
6447 lookup_node::ArrangementTableId::IndexId(v) => {
6448 struct_ser.serialize_field("indexId", v)?;
6449 }
6450 }
6451 }
6452 struct_ser.end()
6453 }
6454}
6455impl<'de> serde::Deserialize<'de> for LookupNode {
6456 #[allow(deprecated)]
6457 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6458 where
6459 D: serde::Deserializer<'de>,
6460 {
6461 const FIELDS: &[&str] = &[
6462 "arrange_key",
6463 "arrangeKey",
6464 "stream_key",
6465 "streamKey",
6466 "use_current_epoch",
6467 "useCurrentEpoch",
6468 "column_mapping",
6469 "columnMapping",
6470 "arrangement_table_info",
6471 "arrangementTableInfo",
6472 "table_id",
6473 "tableId",
6474 "index_id",
6475 "indexId",
6476 ];
6477
6478 #[allow(clippy::enum_variant_names)]
6479 enum GeneratedField {
6480 ArrangeKey,
6481 StreamKey,
6482 UseCurrentEpoch,
6483 ColumnMapping,
6484 ArrangementTableInfo,
6485 TableId,
6486 IndexId,
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 "arrangeKey" | "arrange_key" => Ok(GeneratedField::ArrangeKey),
6509 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
6510 "useCurrentEpoch" | "use_current_epoch" => Ok(GeneratedField::UseCurrentEpoch),
6511 "columnMapping" | "column_mapping" => Ok(GeneratedField::ColumnMapping),
6512 "arrangementTableInfo" | "arrangement_table_info" => Ok(GeneratedField::ArrangementTableInfo),
6513 "tableId" | "table_id" => Ok(GeneratedField::TableId),
6514 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
6515 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6516 }
6517 }
6518 }
6519 deserializer.deserialize_identifier(GeneratedVisitor)
6520 }
6521 }
6522 struct GeneratedVisitor;
6523 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6524 type Value = LookupNode;
6525
6526 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6527 formatter.write_str("struct stream_plan.LookupNode")
6528 }
6529
6530 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupNode, V::Error>
6531 where
6532 V: serde::de::MapAccess<'de>,
6533 {
6534 let mut arrange_key__ = None;
6535 let mut stream_key__ = None;
6536 let mut use_current_epoch__ = None;
6537 let mut column_mapping__ = None;
6538 let mut arrangement_table_info__ = None;
6539 let mut arrangement_table_id__ = None;
6540 while let Some(k) = map_.next_key()? {
6541 match k {
6542 GeneratedField::ArrangeKey => {
6543 if arrange_key__.is_some() {
6544 return Err(serde::de::Error::duplicate_field("arrangeKey"));
6545 }
6546 arrange_key__ =
6547 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6548 .into_iter().map(|x| x.0).collect())
6549 ;
6550 }
6551 GeneratedField::StreamKey => {
6552 if stream_key__.is_some() {
6553 return Err(serde::de::Error::duplicate_field("streamKey"));
6554 }
6555 stream_key__ =
6556 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6557 .into_iter().map(|x| x.0).collect())
6558 ;
6559 }
6560 GeneratedField::UseCurrentEpoch => {
6561 if use_current_epoch__.is_some() {
6562 return Err(serde::de::Error::duplicate_field("useCurrentEpoch"));
6563 }
6564 use_current_epoch__ = Some(map_.next_value()?);
6565 }
6566 GeneratedField::ColumnMapping => {
6567 if column_mapping__.is_some() {
6568 return Err(serde::de::Error::duplicate_field("columnMapping"));
6569 }
6570 column_mapping__ =
6571 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6572 .into_iter().map(|x| x.0).collect())
6573 ;
6574 }
6575 GeneratedField::ArrangementTableInfo => {
6576 if arrangement_table_info__.is_some() {
6577 return Err(serde::de::Error::duplicate_field("arrangementTableInfo"));
6578 }
6579 arrangement_table_info__ = map_.next_value()?;
6580 }
6581 GeneratedField::TableId => {
6582 if arrangement_table_id__.is_some() {
6583 return Err(serde::de::Error::duplicate_field("tableId"));
6584 }
6585 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::TableId(x.0));
6586 }
6587 GeneratedField::IndexId => {
6588 if arrangement_table_id__.is_some() {
6589 return Err(serde::de::Error::duplicate_field("indexId"));
6590 }
6591 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::IndexId(x.0));
6592 }
6593 }
6594 }
6595 Ok(LookupNode {
6596 arrange_key: arrange_key__.unwrap_or_default(),
6597 stream_key: stream_key__.unwrap_or_default(),
6598 use_current_epoch: use_current_epoch__.unwrap_or_default(),
6599 column_mapping: column_mapping__.unwrap_or_default(),
6600 arrangement_table_info: arrangement_table_info__,
6601 arrangement_table_id: arrangement_table_id__,
6602 })
6603 }
6604 }
6605 deserializer.deserialize_struct("stream_plan.LookupNode", FIELDS, GeneratedVisitor)
6606 }
6607}
6608impl serde::Serialize for LookupUnionNode {
6609 #[allow(deprecated)]
6610 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6611 where
6612 S: serde::Serializer,
6613 {
6614 use serde::ser::SerializeStruct;
6615 let mut len = 0;
6616 if !self.order.is_empty() {
6617 len += 1;
6618 }
6619 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupUnionNode", len)?;
6620 if !self.order.is_empty() {
6621 struct_ser.serialize_field("order", &self.order)?;
6622 }
6623 struct_ser.end()
6624 }
6625}
6626impl<'de> serde::Deserialize<'de> for LookupUnionNode {
6627 #[allow(deprecated)]
6628 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6629 where
6630 D: serde::Deserializer<'de>,
6631 {
6632 const FIELDS: &[&str] = &[
6633 "order",
6634 ];
6635
6636 #[allow(clippy::enum_variant_names)]
6637 enum GeneratedField {
6638 Order,
6639 }
6640 impl<'de> serde::Deserialize<'de> for GeneratedField {
6641 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6642 where
6643 D: serde::Deserializer<'de>,
6644 {
6645 struct GeneratedVisitor;
6646
6647 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6648 type Value = GeneratedField;
6649
6650 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6651 write!(formatter, "expected one of: {:?}", &FIELDS)
6652 }
6653
6654 #[allow(unused_variables)]
6655 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6656 where
6657 E: serde::de::Error,
6658 {
6659 match value {
6660 "order" => Ok(GeneratedField::Order),
6661 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6662 }
6663 }
6664 }
6665 deserializer.deserialize_identifier(GeneratedVisitor)
6666 }
6667 }
6668 struct GeneratedVisitor;
6669 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6670 type Value = LookupUnionNode;
6671
6672 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6673 formatter.write_str("struct stream_plan.LookupUnionNode")
6674 }
6675
6676 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupUnionNode, V::Error>
6677 where
6678 V: serde::de::MapAccess<'de>,
6679 {
6680 let mut order__ = None;
6681 while let Some(k) = map_.next_key()? {
6682 match k {
6683 GeneratedField::Order => {
6684 if order__.is_some() {
6685 return Err(serde::de::Error::duplicate_field("order"));
6686 }
6687 order__ =
6688 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6689 .into_iter().map(|x| x.0).collect())
6690 ;
6691 }
6692 }
6693 }
6694 Ok(LookupUnionNode {
6695 order: order__.unwrap_or_default(),
6696 })
6697 }
6698 }
6699 deserializer.deserialize_struct("stream_plan.LookupUnionNode", FIELDS, GeneratedVisitor)
6700 }
6701}
6702impl serde::Serialize for MaterializeNode {
6703 #[allow(deprecated)]
6704 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6705 where
6706 S: serde::Serializer,
6707 {
6708 use serde::ser::SerializeStruct;
6709 let mut len = 0;
6710 if self.table_id != 0 {
6711 len += 1;
6712 }
6713 if !self.column_orders.is_empty() {
6714 len += 1;
6715 }
6716 if self.table.is_some() {
6717 len += 1;
6718 }
6719 if self.staging_table.is_some() {
6720 len += 1;
6721 }
6722 if self.refresh_progress_table.is_some() {
6723 len += 1;
6724 }
6725 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializeNode", len)?;
6726 if self.table_id != 0 {
6727 struct_ser.serialize_field("tableId", &self.table_id)?;
6728 }
6729 if !self.column_orders.is_empty() {
6730 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
6731 }
6732 if let Some(v) = self.table.as_ref() {
6733 struct_ser.serialize_field("table", v)?;
6734 }
6735 if let Some(v) = self.staging_table.as_ref() {
6736 struct_ser.serialize_field("stagingTable", v)?;
6737 }
6738 if let Some(v) = self.refresh_progress_table.as_ref() {
6739 struct_ser.serialize_field("refreshProgressTable", v)?;
6740 }
6741 struct_ser.end()
6742 }
6743}
6744impl<'de> serde::Deserialize<'de> for MaterializeNode {
6745 #[allow(deprecated)]
6746 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6747 where
6748 D: serde::Deserializer<'de>,
6749 {
6750 const FIELDS: &[&str] = &[
6751 "table_id",
6752 "tableId",
6753 "column_orders",
6754 "columnOrders",
6755 "table",
6756 "staging_table",
6757 "stagingTable",
6758 "refresh_progress_table",
6759 "refreshProgressTable",
6760 ];
6761
6762 #[allow(clippy::enum_variant_names)]
6763 enum GeneratedField {
6764 TableId,
6765 ColumnOrders,
6766 Table,
6767 StagingTable,
6768 RefreshProgressTable,
6769 }
6770 impl<'de> serde::Deserialize<'de> for GeneratedField {
6771 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6772 where
6773 D: serde::Deserializer<'de>,
6774 {
6775 struct GeneratedVisitor;
6776
6777 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6778 type Value = GeneratedField;
6779
6780 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6781 write!(formatter, "expected one of: {:?}", &FIELDS)
6782 }
6783
6784 #[allow(unused_variables)]
6785 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6786 where
6787 E: serde::de::Error,
6788 {
6789 match value {
6790 "tableId" | "table_id" => Ok(GeneratedField::TableId),
6791 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
6792 "table" => Ok(GeneratedField::Table),
6793 "stagingTable" | "staging_table" => Ok(GeneratedField::StagingTable),
6794 "refreshProgressTable" | "refresh_progress_table" => Ok(GeneratedField::RefreshProgressTable),
6795 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6796 }
6797 }
6798 }
6799 deserializer.deserialize_identifier(GeneratedVisitor)
6800 }
6801 }
6802 struct GeneratedVisitor;
6803 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6804 type Value = MaterializeNode;
6805
6806 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6807 formatter.write_str("struct stream_plan.MaterializeNode")
6808 }
6809
6810 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializeNode, V::Error>
6811 where
6812 V: serde::de::MapAccess<'de>,
6813 {
6814 let mut table_id__ = None;
6815 let mut column_orders__ = None;
6816 let mut table__ = None;
6817 let mut staging_table__ = None;
6818 let mut refresh_progress_table__ = None;
6819 while let Some(k) = map_.next_key()? {
6820 match k {
6821 GeneratedField::TableId => {
6822 if table_id__.is_some() {
6823 return Err(serde::de::Error::duplicate_field("tableId"));
6824 }
6825 table_id__ =
6826 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6827 ;
6828 }
6829 GeneratedField::ColumnOrders => {
6830 if column_orders__.is_some() {
6831 return Err(serde::de::Error::duplicate_field("columnOrders"));
6832 }
6833 column_orders__ = Some(map_.next_value()?);
6834 }
6835 GeneratedField::Table => {
6836 if table__.is_some() {
6837 return Err(serde::de::Error::duplicate_field("table"));
6838 }
6839 table__ = map_.next_value()?;
6840 }
6841 GeneratedField::StagingTable => {
6842 if staging_table__.is_some() {
6843 return Err(serde::de::Error::duplicate_field("stagingTable"));
6844 }
6845 staging_table__ = map_.next_value()?;
6846 }
6847 GeneratedField::RefreshProgressTable => {
6848 if refresh_progress_table__.is_some() {
6849 return Err(serde::de::Error::duplicate_field("refreshProgressTable"));
6850 }
6851 refresh_progress_table__ = map_.next_value()?;
6852 }
6853 }
6854 }
6855 Ok(MaterializeNode {
6856 table_id: table_id__.unwrap_or_default(),
6857 column_orders: column_orders__.unwrap_or_default(),
6858 table: table__,
6859 staging_table: staging_table__,
6860 refresh_progress_table: refresh_progress_table__,
6861 })
6862 }
6863 }
6864 deserializer.deserialize_struct("stream_plan.MaterializeNode", FIELDS, GeneratedVisitor)
6865 }
6866}
6867impl serde::Serialize for MaterializedExprsNode {
6868 #[allow(deprecated)]
6869 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6870 where
6871 S: serde::Serializer,
6872 {
6873 use serde::ser::SerializeStruct;
6874 let mut len = 0;
6875 if !self.exprs.is_empty() {
6876 len += 1;
6877 }
6878 if self.state_table.is_some() {
6879 len += 1;
6880 }
6881 if self.state_clean_col_idx.is_some() {
6882 len += 1;
6883 }
6884 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializedExprsNode", len)?;
6885 if !self.exprs.is_empty() {
6886 struct_ser.serialize_field("exprs", &self.exprs)?;
6887 }
6888 if let Some(v) = self.state_table.as_ref() {
6889 struct_ser.serialize_field("stateTable", v)?;
6890 }
6891 if let Some(v) = self.state_clean_col_idx.as_ref() {
6892 struct_ser.serialize_field("stateCleanColIdx", v)?;
6893 }
6894 struct_ser.end()
6895 }
6896}
6897impl<'de> serde::Deserialize<'de> for MaterializedExprsNode {
6898 #[allow(deprecated)]
6899 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6900 where
6901 D: serde::Deserializer<'de>,
6902 {
6903 const FIELDS: &[&str] = &[
6904 "exprs",
6905 "state_table",
6906 "stateTable",
6907 "state_clean_col_idx",
6908 "stateCleanColIdx",
6909 ];
6910
6911 #[allow(clippy::enum_variant_names)]
6912 enum GeneratedField {
6913 Exprs,
6914 StateTable,
6915 StateCleanColIdx,
6916 }
6917 impl<'de> serde::Deserialize<'de> for GeneratedField {
6918 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6919 where
6920 D: serde::Deserializer<'de>,
6921 {
6922 struct GeneratedVisitor;
6923
6924 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6925 type Value = GeneratedField;
6926
6927 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6928 write!(formatter, "expected one of: {:?}", &FIELDS)
6929 }
6930
6931 #[allow(unused_variables)]
6932 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6933 where
6934 E: serde::de::Error,
6935 {
6936 match value {
6937 "exprs" => Ok(GeneratedField::Exprs),
6938 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
6939 "stateCleanColIdx" | "state_clean_col_idx" => Ok(GeneratedField::StateCleanColIdx),
6940 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6941 }
6942 }
6943 }
6944 deserializer.deserialize_identifier(GeneratedVisitor)
6945 }
6946 }
6947 struct GeneratedVisitor;
6948 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6949 type Value = MaterializedExprsNode;
6950
6951 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6952 formatter.write_str("struct stream_plan.MaterializedExprsNode")
6953 }
6954
6955 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializedExprsNode, V::Error>
6956 where
6957 V: serde::de::MapAccess<'de>,
6958 {
6959 let mut exprs__ = None;
6960 let mut state_table__ = None;
6961 let mut state_clean_col_idx__ = None;
6962 while let Some(k) = map_.next_key()? {
6963 match k {
6964 GeneratedField::Exprs => {
6965 if exprs__.is_some() {
6966 return Err(serde::de::Error::duplicate_field("exprs"));
6967 }
6968 exprs__ = Some(map_.next_value()?);
6969 }
6970 GeneratedField::StateTable => {
6971 if state_table__.is_some() {
6972 return Err(serde::de::Error::duplicate_field("stateTable"));
6973 }
6974 state_table__ = map_.next_value()?;
6975 }
6976 GeneratedField::StateCleanColIdx => {
6977 if state_clean_col_idx__.is_some() {
6978 return Err(serde::de::Error::duplicate_field("stateCleanColIdx"));
6979 }
6980 state_clean_col_idx__ =
6981 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6982 ;
6983 }
6984 }
6985 }
6986 Ok(MaterializedExprsNode {
6987 exprs: exprs__.unwrap_or_default(),
6988 state_table: state_table__,
6989 state_clean_col_idx: state_clean_col_idx__,
6990 })
6991 }
6992 }
6993 deserializer.deserialize_struct("stream_plan.MaterializedExprsNode", FIELDS, GeneratedVisitor)
6994 }
6995}
6996impl serde::Serialize for MergeNode {
6997 #[allow(deprecated)]
6998 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6999 where
7000 S: serde::Serializer,
7001 {
7002 use serde::ser::SerializeStruct;
7003 let mut len = 0;
7004 if !self.upstream_actor_id.is_empty() {
7005 len += 1;
7006 }
7007 if self.upstream_fragment_id != 0 {
7008 len += 1;
7009 }
7010 if self.upstream_dispatcher_type != 0 {
7011 len += 1;
7012 }
7013 if !self.fields.is_empty() {
7014 len += 1;
7015 }
7016 let mut struct_ser = serializer.serialize_struct("stream_plan.MergeNode", len)?;
7017 if !self.upstream_actor_id.is_empty() {
7018 struct_ser.serialize_field("upstreamActorId", &self.upstream_actor_id)?;
7019 }
7020 if self.upstream_fragment_id != 0 {
7021 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
7022 }
7023 if self.upstream_dispatcher_type != 0 {
7024 let v = DispatcherType::try_from(self.upstream_dispatcher_type)
7025 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.upstream_dispatcher_type)))?;
7026 struct_ser.serialize_field("upstreamDispatcherType", &v)?;
7027 }
7028 if !self.fields.is_empty() {
7029 struct_ser.serialize_field("fields", &self.fields)?;
7030 }
7031 struct_ser.end()
7032 }
7033}
7034impl<'de> serde::Deserialize<'de> for MergeNode {
7035 #[allow(deprecated)]
7036 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7037 where
7038 D: serde::Deserializer<'de>,
7039 {
7040 const FIELDS: &[&str] = &[
7041 "upstream_actor_id",
7042 "upstreamActorId",
7043 "upstream_fragment_id",
7044 "upstreamFragmentId",
7045 "upstream_dispatcher_type",
7046 "upstreamDispatcherType",
7047 "fields",
7048 ];
7049
7050 #[allow(clippy::enum_variant_names)]
7051 enum GeneratedField {
7052 UpstreamActorId,
7053 UpstreamFragmentId,
7054 UpstreamDispatcherType,
7055 Fields,
7056 }
7057 impl<'de> serde::Deserialize<'de> for GeneratedField {
7058 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7059 where
7060 D: serde::Deserializer<'de>,
7061 {
7062 struct GeneratedVisitor;
7063
7064 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7065 type Value = GeneratedField;
7066
7067 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7068 write!(formatter, "expected one of: {:?}", &FIELDS)
7069 }
7070
7071 #[allow(unused_variables)]
7072 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7073 where
7074 E: serde::de::Error,
7075 {
7076 match value {
7077 "upstreamActorId" | "upstream_actor_id" => Ok(GeneratedField::UpstreamActorId),
7078 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
7079 "upstreamDispatcherType" | "upstream_dispatcher_type" => Ok(GeneratedField::UpstreamDispatcherType),
7080 "fields" => Ok(GeneratedField::Fields),
7081 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7082 }
7083 }
7084 }
7085 deserializer.deserialize_identifier(GeneratedVisitor)
7086 }
7087 }
7088 struct GeneratedVisitor;
7089 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7090 type Value = MergeNode;
7091
7092 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7093 formatter.write_str("struct stream_plan.MergeNode")
7094 }
7095
7096 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeNode, V::Error>
7097 where
7098 V: serde::de::MapAccess<'de>,
7099 {
7100 let mut upstream_actor_id__ = None;
7101 let mut upstream_fragment_id__ = None;
7102 let mut upstream_dispatcher_type__ = None;
7103 let mut fields__ = None;
7104 while let Some(k) = map_.next_key()? {
7105 match k {
7106 GeneratedField::UpstreamActorId => {
7107 if upstream_actor_id__.is_some() {
7108 return Err(serde::de::Error::duplicate_field("upstreamActorId"));
7109 }
7110 upstream_actor_id__ =
7111 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7112 .into_iter().map(|x| x.0).collect())
7113 ;
7114 }
7115 GeneratedField::UpstreamFragmentId => {
7116 if upstream_fragment_id__.is_some() {
7117 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
7118 }
7119 upstream_fragment_id__ =
7120 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7121 ;
7122 }
7123 GeneratedField::UpstreamDispatcherType => {
7124 if upstream_dispatcher_type__.is_some() {
7125 return Err(serde::de::Error::duplicate_field("upstreamDispatcherType"));
7126 }
7127 upstream_dispatcher_type__ = Some(map_.next_value::<DispatcherType>()? as i32);
7128 }
7129 GeneratedField::Fields => {
7130 if fields__.is_some() {
7131 return Err(serde::de::Error::duplicate_field("fields"));
7132 }
7133 fields__ = Some(map_.next_value()?);
7134 }
7135 }
7136 }
7137 Ok(MergeNode {
7138 upstream_actor_id: upstream_actor_id__.unwrap_or_default(),
7139 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
7140 upstream_dispatcher_type: upstream_dispatcher_type__.unwrap_or_default(),
7141 fields: fields__.unwrap_or_default(),
7142 })
7143 }
7144 }
7145 deserializer.deserialize_struct("stream_plan.MergeNode", FIELDS, GeneratedVisitor)
7146 }
7147}
7148impl serde::Serialize for NoOpNode {
7149 #[allow(deprecated)]
7150 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7151 where
7152 S: serde::Serializer,
7153 {
7154 use serde::ser::SerializeStruct;
7155 let len = 0;
7156 let struct_ser = serializer.serialize_struct("stream_plan.NoOpNode", len)?;
7157 struct_ser.end()
7158 }
7159}
7160impl<'de> serde::Deserialize<'de> for NoOpNode {
7161 #[allow(deprecated)]
7162 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7163 where
7164 D: serde::Deserializer<'de>,
7165 {
7166 const FIELDS: &[&str] = &[
7167 ];
7168
7169 #[allow(clippy::enum_variant_names)]
7170 enum GeneratedField {
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 Err(serde::de::Error::unknown_field(value, FIELDS))
7192 }
7193 }
7194 deserializer.deserialize_identifier(GeneratedVisitor)
7195 }
7196 }
7197 struct GeneratedVisitor;
7198 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7199 type Value = NoOpNode;
7200
7201 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7202 formatter.write_str("struct stream_plan.NoOpNode")
7203 }
7204
7205 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NoOpNode, V::Error>
7206 where
7207 V: serde::de::MapAccess<'de>,
7208 {
7209 while map_.next_key::<GeneratedField>()?.is_some() {
7210 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7211 }
7212 Ok(NoOpNode {
7213 })
7214 }
7215 }
7216 deserializer.deserialize_struct("stream_plan.NoOpNode", FIELDS, GeneratedVisitor)
7217 }
7218}
7219impl serde::Serialize for NowModeGenerateSeries {
7220 #[allow(deprecated)]
7221 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7222 where
7223 S: serde::Serializer,
7224 {
7225 use serde::ser::SerializeStruct;
7226 let mut len = 0;
7227 if self.start_timestamp.is_some() {
7228 len += 1;
7229 }
7230 if self.interval.is_some() {
7231 len += 1;
7232 }
7233 let mut struct_ser = serializer.serialize_struct("stream_plan.NowModeGenerateSeries", len)?;
7234 if let Some(v) = self.start_timestamp.as_ref() {
7235 struct_ser.serialize_field("startTimestamp", v)?;
7236 }
7237 if let Some(v) = self.interval.as_ref() {
7238 struct_ser.serialize_field("interval", v)?;
7239 }
7240 struct_ser.end()
7241 }
7242}
7243impl<'de> serde::Deserialize<'de> for NowModeGenerateSeries {
7244 #[allow(deprecated)]
7245 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7246 where
7247 D: serde::Deserializer<'de>,
7248 {
7249 const FIELDS: &[&str] = &[
7250 "start_timestamp",
7251 "startTimestamp",
7252 "interval",
7253 ];
7254
7255 #[allow(clippy::enum_variant_names)]
7256 enum GeneratedField {
7257 StartTimestamp,
7258 Interval,
7259 }
7260 impl<'de> serde::Deserialize<'de> for GeneratedField {
7261 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7262 where
7263 D: serde::Deserializer<'de>,
7264 {
7265 struct GeneratedVisitor;
7266
7267 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7268 type Value = GeneratedField;
7269
7270 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7271 write!(formatter, "expected one of: {:?}", &FIELDS)
7272 }
7273
7274 #[allow(unused_variables)]
7275 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7276 where
7277 E: serde::de::Error,
7278 {
7279 match value {
7280 "startTimestamp" | "start_timestamp" => Ok(GeneratedField::StartTimestamp),
7281 "interval" => Ok(GeneratedField::Interval),
7282 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7283 }
7284 }
7285 }
7286 deserializer.deserialize_identifier(GeneratedVisitor)
7287 }
7288 }
7289 struct GeneratedVisitor;
7290 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7291 type Value = NowModeGenerateSeries;
7292
7293 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7294 formatter.write_str("struct stream_plan.NowModeGenerateSeries")
7295 }
7296
7297 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeGenerateSeries, V::Error>
7298 where
7299 V: serde::de::MapAccess<'de>,
7300 {
7301 let mut start_timestamp__ = None;
7302 let mut interval__ = None;
7303 while let Some(k) = map_.next_key()? {
7304 match k {
7305 GeneratedField::StartTimestamp => {
7306 if start_timestamp__.is_some() {
7307 return Err(serde::de::Error::duplicate_field("startTimestamp"));
7308 }
7309 start_timestamp__ = map_.next_value()?;
7310 }
7311 GeneratedField::Interval => {
7312 if interval__.is_some() {
7313 return Err(serde::de::Error::duplicate_field("interval"));
7314 }
7315 interval__ = map_.next_value()?;
7316 }
7317 }
7318 }
7319 Ok(NowModeGenerateSeries {
7320 start_timestamp: start_timestamp__,
7321 interval: interval__,
7322 })
7323 }
7324 }
7325 deserializer.deserialize_struct("stream_plan.NowModeGenerateSeries", FIELDS, GeneratedVisitor)
7326 }
7327}
7328impl serde::Serialize for NowModeUpdateCurrent {
7329 #[allow(deprecated)]
7330 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7331 where
7332 S: serde::Serializer,
7333 {
7334 use serde::ser::SerializeStruct;
7335 let len = 0;
7336 let struct_ser = serializer.serialize_struct("stream_plan.NowModeUpdateCurrent", len)?;
7337 struct_ser.end()
7338 }
7339}
7340impl<'de> serde::Deserialize<'de> for NowModeUpdateCurrent {
7341 #[allow(deprecated)]
7342 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7343 where
7344 D: serde::Deserializer<'de>,
7345 {
7346 const FIELDS: &[&str] = &[
7347 ];
7348
7349 #[allow(clippy::enum_variant_names)]
7350 enum GeneratedField {
7351 }
7352 impl<'de> serde::Deserialize<'de> for GeneratedField {
7353 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7354 where
7355 D: serde::Deserializer<'de>,
7356 {
7357 struct GeneratedVisitor;
7358
7359 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7360 type Value = GeneratedField;
7361
7362 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7363 write!(formatter, "expected one of: {:?}", &FIELDS)
7364 }
7365
7366 #[allow(unused_variables)]
7367 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7368 where
7369 E: serde::de::Error,
7370 {
7371 Err(serde::de::Error::unknown_field(value, FIELDS))
7372 }
7373 }
7374 deserializer.deserialize_identifier(GeneratedVisitor)
7375 }
7376 }
7377 struct GeneratedVisitor;
7378 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7379 type Value = NowModeUpdateCurrent;
7380
7381 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7382 formatter.write_str("struct stream_plan.NowModeUpdateCurrent")
7383 }
7384
7385 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeUpdateCurrent, V::Error>
7386 where
7387 V: serde::de::MapAccess<'de>,
7388 {
7389 while map_.next_key::<GeneratedField>()?.is_some() {
7390 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7391 }
7392 Ok(NowModeUpdateCurrent {
7393 })
7394 }
7395 }
7396 deserializer.deserialize_struct("stream_plan.NowModeUpdateCurrent", FIELDS, GeneratedVisitor)
7397 }
7398}
7399impl serde::Serialize for NowNode {
7400 #[allow(deprecated)]
7401 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7402 where
7403 S: serde::Serializer,
7404 {
7405 use serde::ser::SerializeStruct;
7406 let mut len = 0;
7407 if self.state_table.is_some() {
7408 len += 1;
7409 }
7410 if self.mode.is_some() {
7411 len += 1;
7412 }
7413 let mut struct_ser = serializer.serialize_struct("stream_plan.NowNode", len)?;
7414 if let Some(v) = self.state_table.as_ref() {
7415 struct_ser.serialize_field("stateTable", v)?;
7416 }
7417 if let Some(v) = self.mode.as_ref() {
7418 match v {
7419 now_node::Mode::UpdateCurrent(v) => {
7420 struct_ser.serialize_field("updateCurrent", v)?;
7421 }
7422 now_node::Mode::GenerateSeries(v) => {
7423 struct_ser.serialize_field("generateSeries", v)?;
7424 }
7425 }
7426 }
7427 struct_ser.end()
7428 }
7429}
7430impl<'de> serde::Deserialize<'de> for NowNode {
7431 #[allow(deprecated)]
7432 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7433 where
7434 D: serde::Deserializer<'de>,
7435 {
7436 const FIELDS: &[&str] = &[
7437 "state_table",
7438 "stateTable",
7439 "update_current",
7440 "updateCurrent",
7441 "generate_series",
7442 "generateSeries",
7443 ];
7444
7445 #[allow(clippy::enum_variant_names)]
7446 enum GeneratedField {
7447 StateTable,
7448 UpdateCurrent,
7449 GenerateSeries,
7450 }
7451 impl<'de> serde::Deserialize<'de> for GeneratedField {
7452 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7453 where
7454 D: serde::Deserializer<'de>,
7455 {
7456 struct GeneratedVisitor;
7457
7458 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7459 type Value = GeneratedField;
7460
7461 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7462 write!(formatter, "expected one of: {:?}", &FIELDS)
7463 }
7464
7465 #[allow(unused_variables)]
7466 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7467 where
7468 E: serde::de::Error,
7469 {
7470 match value {
7471 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7472 "updateCurrent" | "update_current" => Ok(GeneratedField::UpdateCurrent),
7473 "generateSeries" | "generate_series" => Ok(GeneratedField::GenerateSeries),
7474 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7475 }
7476 }
7477 }
7478 deserializer.deserialize_identifier(GeneratedVisitor)
7479 }
7480 }
7481 struct GeneratedVisitor;
7482 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7483 type Value = NowNode;
7484
7485 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7486 formatter.write_str("struct stream_plan.NowNode")
7487 }
7488
7489 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowNode, V::Error>
7490 where
7491 V: serde::de::MapAccess<'de>,
7492 {
7493 let mut state_table__ = None;
7494 let mut mode__ = None;
7495 while let Some(k) = map_.next_key()? {
7496 match k {
7497 GeneratedField::StateTable => {
7498 if state_table__.is_some() {
7499 return Err(serde::de::Error::duplicate_field("stateTable"));
7500 }
7501 state_table__ = map_.next_value()?;
7502 }
7503 GeneratedField::UpdateCurrent => {
7504 if mode__.is_some() {
7505 return Err(serde::de::Error::duplicate_field("updateCurrent"));
7506 }
7507 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::UpdateCurrent)
7508;
7509 }
7510 GeneratedField::GenerateSeries => {
7511 if mode__.is_some() {
7512 return Err(serde::de::Error::duplicate_field("generateSeries"));
7513 }
7514 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::GenerateSeries)
7515;
7516 }
7517 }
7518 }
7519 Ok(NowNode {
7520 state_table: state_table__,
7521 mode: mode__,
7522 })
7523 }
7524 }
7525 deserializer.deserialize_struct("stream_plan.NowNode", FIELDS, GeneratedVisitor)
7526 }
7527}
7528impl serde::Serialize for OverWindowCachePolicy {
7529 #[allow(deprecated)]
7530 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7531 where
7532 S: serde::Serializer,
7533 {
7534 let variant = match self {
7535 Self::Unspecified => "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
7536 Self::Full => "OVER_WINDOW_CACHE_POLICY_FULL",
7537 Self::Recent => "OVER_WINDOW_CACHE_POLICY_RECENT",
7538 Self::RecentFirstN => "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
7539 Self::RecentLastN => "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
7540 };
7541 serializer.serialize_str(variant)
7542 }
7543}
7544impl<'de> serde::Deserialize<'de> for OverWindowCachePolicy {
7545 #[allow(deprecated)]
7546 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7547 where
7548 D: serde::Deserializer<'de>,
7549 {
7550 const FIELDS: &[&str] = &[
7551 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
7552 "OVER_WINDOW_CACHE_POLICY_FULL",
7553 "OVER_WINDOW_CACHE_POLICY_RECENT",
7554 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
7555 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
7556 ];
7557
7558 struct GeneratedVisitor;
7559
7560 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7561 type Value = OverWindowCachePolicy;
7562
7563 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7564 write!(formatter, "expected one of: {:?}", &FIELDS)
7565 }
7566
7567 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
7568 where
7569 E: serde::de::Error,
7570 {
7571 i32::try_from(v)
7572 .ok()
7573 .and_then(|x| x.try_into().ok())
7574 .ok_or_else(|| {
7575 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
7576 })
7577 }
7578
7579 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
7580 where
7581 E: serde::de::Error,
7582 {
7583 i32::try_from(v)
7584 .ok()
7585 .and_then(|x| x.try_into().ok())
7586 .ok_or_else(|| {
7587 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
7588 })
7589 }
7590
7591 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
7592 where
7593 E: serde::de::Error,
7594 {
7595 match value {
7596 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED" => Ok(OverWindowCachePolicy::Unspecified),
7597 "OVER_WINDOW_CACHE_POLICY_FULL" => Ok(OverWindowCachePolicy::Full),
7598 "OVER_WINDOW_CACHE_POLICY_RECENT" => Ok(OverWindowCachePolicy::Recent),
7599 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N" => Ok(OverWindowCachePolicy::RecentFirstN),
7600 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N" => Ok(OverWindowCachePolicy::RecentLastN),
7601 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
7602 }
7603 }
7604 }
7605 deserializer.deserialize_any(GeneratedVisitor)
7606 }
7607}
7608impl serde::Serialize for OverWindowNode {
7609 #[allow(deprecated)]
7610 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7611 where
7612 S: serde::Serializer,
7613 {
7614 use serde::ser::SerializeStruct;
7615 let mut len = 0;
7616 if !self.calls.is_empty() {
7617 len += 1;
7618 }
7619 if !self.partition_by.is_empty() {
7620 len += 1;
7621 }
7622 if !self.order_by.is_empty() {
7623 len += 1;
7624 }
7625 if self.state_table.is_some() {
7626 len += 1;
7627 }
7628 if self.cache_policy != 0 {
7629 len += 1;
7630 }
7631 let mut struct_ser = serializer.serialize_struct("stream_plan.OverWindowNode", len)?;
7632 if !self.calls.is_empty() {
7633 struct_ser.serialize_field("calls", &self.calls)?;
7634 }
7635 if !self.partition_by.is_empty() {
7636 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
7637 }
7638 if !self.order_by.is_empty() {
7639 struct_ser.serialize_field("orderBy", &self.order_by)?;
7640 }
7641 if let Some(v) = self.state_table.as_ref() {
7642 struct_ser.serialize_field("stateTable", v)?;
7643 }
7644 if self.cache_policy != 0 {
7645 let v = OverWindowCachePolicy::try_from(self.cache_policy)
7646 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cache_policy)))?;
7647 struct_ser.serialize_field("cachePolicy", &v)?;
7648 }
7649 struct_ser.end()
7650 }
7651}
7652impl<'de> serde::Deserialize<'de> for OverWindowNode {
7653 #[allow(deprecated)]
7654 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7655 where
7656 D: serde::Deserializer<'de>,
7657 {
7658 const FIELDS: &[&str] = &[
7659 "calls",
7660 "partition_by",
7661 "partitionBy",
7662 "order_by",
7663 "orderBy",
7664 "state_table",
7665 "stateTable",
7666 "cache_policy",
7667 "cachePolicy",
7668 ];
7669
7670 #[allow(clippy::enum_variant_names)]
7671 enum GeneratedField {
7672 Calls,
7673 PartitionBy,
7674 OrderBy,
7675 StateTable,
7676 CachePolicy,
7677 }
7678 impl<'de> serde::Deserialize<'de> for GeneratedField {
7679 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7680 where
7681 D: serde::Deserializer<'de>,
7682 {
7683 struct GeneratedVisitor;
7684
7685 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7686 type Value = GeneratedField;
7687
7688 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7689 write!(formatter, "expected one of: {:?}", &FIELDS)
7690 }
7691
7692 #[allow(unused_variables)]
7693 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7694 where
7695 E: serde::de::Error,
7696 {
7697 match value {
7698 "calls" => Ok(GeneratedField::Calls),
7699 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
7700 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
7701 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7702 "cachePolicy" | "cache_policy" => Ok(GeneratedField::CachePolicy),
7703 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7704 }
7705 }
7706 }
7707 deserializer.deserialize_identifier(GeneratedVisitor)
7708 }
7709 }
7710 struct GeneratedVisitor;
7711 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7712 type Value = OverWindowNode;
7713
7714 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7715 formatter.write_str("struct stream_plan.OverWindowNode")
7716 }
7717
7718 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverWindowNode, V::Error>
7719 where
7720 V: serde::de::MapAccess<'de>,
7721 {
7722 let mut calls__ = None;
7723 let mut partition_by__ = None;
7724 let mut order_by__ = None;
7725 let mut state_table__ = None;
7726 let mut cache_policy__ = None;
7727 while let Some(k) = map_.next_key()? {
7728 match k {
7729 GeneratedField::Calls => {
7730 if calls__.is_some() {
7731 return Err(serde::de::Error::duplicate_field("calls"));
7732 }
7733 calls__ = Some(map_.next_value()?);
7734 }
7735 GeneratedField::PartitionBy => {
7736 if partition_by__.is_some() {
7737 return Err(serde::de::Error::duplicate_field("partitionBy"));
7738 }
7739 partition_by__ =
7740 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7741 .into_iter().map(|x| x.0).collect())
7742 ;
7743 }
7744 GeneratedField::OrderBy => {
7745 if order_by__.is_some() {
7746 return Err(serde::de::Error::duplicate_field("orderBy"));
7747 }
7748 order_by__ = Some(map_.next_value()?);
7749 }
7750 GeneratedField::StateTable => {
7751 if state_table__.is_some() {
7752 return Err(serde::de::Error::duplicate_field("stateTable"));
7753 }
7754 state_table__ = map_.next_value()?;
7755 }
7756 GeneratedField::CachePolicy => {
7757 if cache_policy__.is_some() {
7758 return Err(serde::de::Error::duplicate_field("cachePolicy"));
7759 }
7760 cache_policy__ = Some(map_.next_value::<OverWindowCachePolicy>()? as i32);
7761 }
7762 }
7763 }
7764 Ok(OverWindowNode {
7765 calls: calls__.unwrap_or_default(),
7766 partition_by: partition_by__.unwrap_or_default(),
7767 order_by: order_by__.unwrap_or_default(),
7768 state_table: state_table__,
7769 cache_policy: cache_policy__.unwrap_or_default(),
7770 })
7771 }
7772 }
7773 deserializer.deserialize_struct("stream_plan.OverWindowNode", FIELDS, GeneratedVisitor)
7774 }
7775}
7776impl serde::Serialize for PauseMutation {
7777 #[allow(deprecated)]
7778 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7779 where
7780 S: serde::Serializer,
7781 {
7782 use serde::ser::SerializeStruct;
7783 let len = 0;
7784 let struct_ser = serializer.serialize_struct("stream_plan.PauseMutation", len)?;
7785 struct_ser.end()
7786 }
7787}
7788impl<'de> serde::Deserialize<'de> for PauseMutation {
7789 #[allow(deprecated)]
7790 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7791 where
7792 D: serde::Deserializer<'de>,
7793 {
7794 const FIELDS: &[&str] = &[
7795 ];
7796
7797 #[allow(clippy::enum_variant_names)]
7798 enum GeneratedField {
7799 }
7800 impl<'de> serde::Deserialize<'de> for GeneratedField {
7801 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7802 where
7803 D: serde::Deserializer<'de>,
7804 {
7805 struct GeneratedVisitor;
7806
7807 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7808 type Value = GeneratedField;
7809
7810 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7811 write!(formatter, "expected one of: {:?}", &FIELDS)
7812 }
7813
7814 #[allow(unused_variables)]
7815 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7816 where
7817 E: serde::de::Error,
7818 {
7819 Err(serde::de::Error::unknown_field(value, FIELDS))
7820 }
7821 }
7822 deserializer.deserialize_identifier(GeneratedVisitor)
7823 }
7824 }
7825 struct GeneratedVisitor;
7826 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7827 type Value = PauseMutation;
7828
7829 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7830 formatter.write_str("struct stream_plan.PauseMutation")
7831 }
7832
7833 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseMutation, V::Error>
7834 where
7835 V: serde::de::MapAccess<'de>,
7836 {
7837 while map_.next_key::<GeneratedField>()?.is_some() {
7838 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7839 }
7840 Ok(PauseMutation {
7841 })
7842 }
7843 }
7844 deserializer.deserialize_struct("stream_plan.PauseMutation", FIELDS, GeneratedVisitor)
7845 }
7846}
7847impl serde::Serialize for ProjectNode {
7848 #[allow(deprecated)]
7849 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7850 where
7851 S: serde::Serializer,
7852 {
7853 use serde::ser::SerializeStruct;
7854 let mut len = 0;
7855 if !self.select_list.is_empty() {
7856 len += 1;
7857 }
7858 if !self.watermark_input_cols.is_empty() {
7859 len += 1;
7860 }
7861 if !self.watermark_output_cols.is_empty() {
7862 len += 1;
7863 }
7864 if !self.nondecreasing_exprs.is_empty() {
7865 len += 1;
7866 }
7867 if self.noop_update_hint {
7868 len += 1;
7869 }
7870 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectNode", len)?;
7871 if !self.select_list.is_empty() {
7872 struct_ser.serialize_field("selectList", &self.select_list)?;
7873 }
7874 if !self.watermark_input_cols.is_empty() {
7875 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
7876 }
7877 if !self.watermark_output_cols.is_empty() {
7878 struct_ser.serialize_field("watermarkOutputCols", &self.watermark_output_cols)?;
7879 }
7880 if !self.nondecreasing_exprs.is_empty() {
7881 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
7882 }
7883 if self.noop_update_hint {
7884 struct_ser.serialize_field("noopUpdateHint", &self.noop_update_hint)?;
7885 }
7886 struct_ser.end()
7887 }
7888}
7889impl<'de> serde::Deserialize<'de> for ProjectNode {
7890 #[allow(deprecated)]
7891 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7892 where
7893 D: serde::Deserializer<'de>,
7894 {
7895 const FIELDS: &[&str] = &[
7896 "select_list",
7897 "selectList",
7898 "watermark_input_cols",
7899 "watermarkInputCols",
7900 "watermark_output_cols",
7901 "watermarkOutputCols",
7902 "nondecreasing_exprs",
7903 "nondecreasingExprs",
7904 "noop_update_hint",
7905 "noopUpdateHint",
7906 ];
7907
7908 #[allow(clippy::enum_variant_names)]
7909 enum GeneratedField {
7910 SelectList,
7911 WatermarkInputCols,
7912 WatermarkOutputCols,
7913 NondecreasingExprs,
7914 NoopUpdateHint,
7915 }
7916 impl<'de> serde::Deserialize<'de> for GeneratedField {
7917 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7918 where
7919 D: serde::Deserializer<'de>,
7920 {
7921 struct GeneratedVisitor;
7922
7923 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7924 type Value = GeneratedField;
7925
7926 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7927 write!(formatter, "expected one of: {:?}", &FIELDS)
7928 }
7929
7930 #[allow(unused_variables)]
7931 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7932 where
7933 E: serde::de::Error,
7934 {
7935 match value {
7936 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
7937 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
7938 "watermarkOutputCols" | "watermark_output_cols" => Ok(GeneratedField::WatermarkOutputCols),
7939 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
7940 "noopUpdateHint" | "noop_update_hint" => Ok(GeneratedField::NoopUpdateHint),
7941 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7942 }
7943 }
7944 }
7945 deserializer.deserialize_identifier(GeneratedVisitor)
7946 }
7947 }
7948 struct GeneratedVisitor;
7949 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7950 type Value = ProjectNode;
7951
7952 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7953 formatter.write_str("struct stream_plan.ProjectNode")
7954 }
7955
7956 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
7957 where
7958 V: serde::de::MapAccess<'de>,
7959 {
7960 let mut select_list__ = None;
7961 let mut watermark_input_cols__ = None;
7962 let mut watermark_output_cols__ = None;
7963 let mut nondecreasing_exprs__ = None;
7964 let mut noop_update_hint__ = None;
7965 while let Some(k) = map_.next_key()? {
7966 match k {
7967 GeneratedField::SelectList => {
7968 if select_list__.is_some() {
7969 return Err(serde::de::Error::duplicate_field("selectList"));
7970 }
7971 select_list__ = Some(map_.next_value()?);
7972 }
7973 GeneratedField::WatermarkInputCols => {
7974 if watermark_input_cols__.is_some() {
7975 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
7976 }
7977 watermark_input_cols__ =
7978 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7979 .into_iter().map(|x| x.0).collect())
7980 ;
7981 }
7982 GeneratedField::WatermarkOutputCols => {
7983 if watermark_output_cols__.is_some() {
7984 return Err(serde::de::Error::duplicate_field("watermarkOutputCols"));
7985 }
7986 watermark_output_cols__ =
7987 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7988 .into_iter().map(|x| x.0).collect())
7989 ;
7990 }
7991 GeneratedField::NondecreasingExprs => {
7992 if nondecreasing_exprs__.is_some() {
7993 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
7994 }
7995 nondecreasing_exprs__ =
7996 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7997 .into_iter().map(|x| x.0).collect())
7998 ;
7999 }
8000 GeneratedField::NoopUpdateHint => {
8001 if noop_update_hint__.is_some() {
8002 return Err(serde::de::Error::duplicate_field("noopUpdateHint"));
8003 }
8004 noop_update_hint__ = Some(map_.next_value()?);
8005 }
8006 }
8007 }
8008 Ok(ProjectNode {
8009 select_list: select_list__.unwrap_or_default(),
8010 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
8011 watermark_output_cols: watermark_output_cols__.unwrap_or_default(),
8012 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
8013 noop_update_hint: noop_update_hint__.unwrap_or_default(),
8014 })
8015 }
8016 }
8017 deserializer.deserialize_struct("stream_plan.ProjectNode", FIELDS, GeneratedVisitor)
8018 }
8019}
8020impl serde::Serialize for ProjectSetNode {
8021 #[allow(deprecated)]
8022 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8023 where
8024 S: serde::Serializer,
8025 {
8026 use serde::ser::SerializeStruct;
8027 let mut len = 0;
8028 if !self.select_list.is_empty() {
8029 len += 1;
8030 }
8031 if !self.watermark_input_cols.is_empty() {
8032 len += 1;
8033 }
8034 if !self.watermark_expr_indices.is_empty() {
8035 len += 1;
8036 }
8037 if !self.nondecreasing_exprs.is_empty() {
8038 len += 1;
8039 }
8040 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectSetNode", len)?;
8041 if !self.select_list.is_empty() {
8042 struct_ser.serialize_field("selectList", &self.select_list)?;
8043 }
8044 if !self.watermark_input_cols.is_empty() {
8045 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
8046 }
8047 if !self.watermark_expr_indices.is_empty() {
8048 struct_ser.serialize_field("watermarkExprIndices", &self.watermark_expr_indices)?;
8049 }
8050 if !self.nondecreasing_exprs.is_empty() {
8051 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
8052 }
8053 struct_ser.end()
8054 }
8055}
8056impl<'de> serde::Deserialize<'de> for ProjectSetNode {
8057 #[allow(deprecated)]
8058 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8059 where
8060 D: serde::Deserializer<'de>,
8061 {
8062 const FIELDS: &[&str] = &[
8063 "select_list",
8064 "selectList",
8065 "watermark_input_cols",
8066 "watermarkInputCols",
8067 "watermark_expr_indices",
8068 "watermarkExprIndices",
8069 "nondecreasing_exprs",
8070 "nondecreasingExprs",
8071 ];
8072
8073 #[allow(clippy::enum_variant_names)]
8074 enum GeneratedField {
8075 SelectList,
8076 WatermarkInputCols,
8077 WatermarkExprIndices,
8078 NondecreasingExprs,
8079 }
8080 impl<'de> serde::Deserialize<'de> for GeneratedField {
8081 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8082 where
8083 D: serde::Deserializer<'de>,
8084 {
8085 struct GeneratedVisitor;
8086
8087 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8088 type Value = GeneratedField;
8089
8090 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8091 write!(formatter, "expected one of: {:?}", &FIELDS)
8092 }
8093
8094 #[allow(unused_variables)]
8095 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8096 where
8097 E: serde::de::Error,
8098 {
8099 match value {
8100 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
8101 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
8102 "watermarkExprIndices" | "watermark_expr_indices" => Ok(GeneratedField::WatermarkExprIndices),
8103 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
8104 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8105 }
8106 }
8107 }
8108 deserializer.deserialize_identifier(GeneratedVisitor)
8109 }
8110 }
8111 struct GeneratedVisitor;
8112 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8113 type Value = ProjectSetNode;
8114
8115 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8116 formatter.write_str("struct stream_plan.ProjectSetNode")
8117 }
8118
8119 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
8120 where
8121 V: serde::de::MapAccess<'de>,
8122 {
8123 let mut select_list__ = None;
8124 let mut watermark_input_cols__ = None;
8125 let mut watermark_expr_indices__ = None;
8126 let mut nondecreasing_exprs__ = None;
8127 while let Some(k) = map_.next_key()? {
8128 match k {
8129 GeneratedField::SelectList => {
8130 if select_list__.is_some() {
8131 return Err(serde::de::Error::duplicate_field("selectList"));
8132 }
8133 select_list__ = Some(map_.next_value()?);
8134 }
8135 GeneratedField::WatermarkInputCols => {
8136 if watermark_input_cols__.is_some() {
8137 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
8138 }
8139 watermark_input_cols__ =
8140 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8141 .into_iter().map(|x| x.0).collect())
8142 ;
8143 }
8144 GeneratedField::WatermarkExprIndices => {
8145 if watermark_expr_indices__.is_some() {
8146 return Err(serde::de::Error::duplicate_field("watermarkExprIndices"));
8147 }
8148 watermark_expr_indices__ =
8149 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8150 .into_iter().map(|x| x.0).collect())
8151 ;
8152 }
8153 GeneratedField::NondecreasingExprs => {
8154 if nondecreasing_exprs__.is_some() {
8155 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
8156 }
8157 nondecreasing_exprs__ =
8158 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8159 .into_iter().map(|x| x.0).collect())
8160 ;
8161 }
8162 }
8163 }
8164 Ok(ProjectSetNode {
8165 select_list: select_list__.unwrap_or_default(),
8166 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
8167 watermark_expr_indices: watermark_expr_indices__.unwrap_or_default(),
8168 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
8169 })
8170 }
8171 }
8172 deserializer.deserialize_struct("stream_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
8173 }
8174}
8175impl serde::Serialize for RefreshStartMutation {
8176 #[allow(deprecated)]
8177 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8178 where
8179 S: serde::Serializer,
8180 {
8181 use serde::ser::SerializeStruct;
8182 let mut len = 0;
8183 if self.table_id != 0 {
8184 len += 1;
8185 }
8186 if self.associated_source_id != 0 {
8187 len += 1;
8188 }
8189 let mut struct_ser = serializer.serialize_struct("stream_plan.RefreshStartMutation", len)?;
8190 if self.table_id != 0 {
8191 struct_ser.serialize_field("tableId", &self.table_id)?;
8192 }
8193 if self.associated_source_id != 0 {
8194 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
8195 }
8196 struct_ser.end()
8197 }
8198}
8199impl<'de> serde::Deserialize<'de> for RefreshStartMutation {
8200 #[allow(deprecated)]
8201 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8202 where
8203 D: serde::Deserializer<'de>,
8204 {
8205 const FIELDS: &[&str] = &[
8206 "table_id",
8207 "tableId",
8208 "associated_source_id",
8209 "associatedSourceId",
8210 ];
8211
8212 #[allow(clippy::enum_variant_names)]
8213 enum GeneratedField {
8214 TableId,
8215 AssociatedSourceId,
8216 }
8217 impl<'de> serde::Deserialize<'de> for GeneratedField {
8218 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8219 where
8220 D: serde::Deserializer<'de>,
8221 {
8222 struct GeneratedVisitor;
8223
8224 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8225 type Value = GeneratedField;
8226
8227 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8228 write!(formatter, "expected one of: {:?}", &FIELDS)
8229 }
8230
8231 #[allow(unused_variables)]
8232 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8233 where
8234 E: serde::de::Error,
8235 {
8236 match value {
8237 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8238 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
8239 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8240 }
8241 }
8242 }
8243 deserializer.deserialize_identifier(GeneratedVisitor)
8244 }
8245 }
8246 struct GeneratedVisitor;
8247 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8248 type Value = RefreshStartMutation;
8249
8250 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8251 formatter.write_str("struct stream_plan.RefreshStartMutation")
8252 }
8253
8254 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshStartMutation, V::Error>
8255 where
8256 V: serde::de::MapAccess<'de>,
8257 {
8258 let mut table_id__ = None;
8259 let mut associated_source_id__ = None;
8260 while let Some(k) = map_.next_key()? {
8261 match k {
8262 GeneratedField::TableId => {
8263 if table_id__.is_some() {
8264 return Err(serde::de::Error::duplicate_field("tableId"));
8265 }
8266 table_id__ =
8267 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8268 ;
8269 }
8270 GeneratedField::AssociatedSourceId => {
8271 if associated_source_id__.is_some() {
8272 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
8273 }
8274 associated_source_id__ =
8275 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8276 ;
8277 }
8278 }
8279 }
8280 Ok(RefreshStartMutation {
8281 table_id: table_id__.unwrap_or_default(),
8282 associated_source_id: associated_source_id__.unwrap_or_default(),
8283 })
8284 }
8285 }
8286 deserializer.deserialize_struct("stream_plan.RefreshStartMutation", FIELDS, GeneratedVisitor)
8287 }
8288}
8289impl serde::Serialize for ResumeMutation {
8290 #[allow(deprecated)]
8291 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8292 where
8293 S: serde::Serializer,
8294 {
8295 use serde::ser::SerializeStruct;
8296 let len = 0;
8297 let struct_ser = serializer.serialize_struct("stream_plan.ResumeMutation", len)?;
8298 struct_ser.end()
8299 }
8300}
8301impl<'de> serde::Deserialize<'de> for ResumeMutation {
8302 #[allow(deprecated)]
8303 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8304 where
8305 D: serde::Deserializer<'de>,
8306 {
8307 const FIELDS: &[&str] = &[
8308 ];
8309
8310 #[allow(clippy::enum_variant_names)]
8311 enum GeneratedField {
8312 }
8313 impl<'de> serde::Deserialize<'de> for GeneratedField {
8314 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8315 where
8316 D: serde::Deserializer<'de>,
8317 {
8318 struct GeneratedVisitor;
8319
8320 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8321 type Value = GeneratedField;
8322
8323 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8324 write!(formatter, "expected one of: {:?}", &FIELDS)
8325 }
8326
8327 #[allow(unused_variables)]
8328 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8329 where
8330 E: serde::de::Error,
8331 {
8332 Err(serde::de::Error::unknown_field(value, FIELDS))
8333 }
8334 }
8335 deserializer.deserialize_identifier(GeneratedVisitor)
8336 }
8337 }
8338 struct GeneratedVisitor;
8339 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8340 type Value = ResumeMutation;
8341
8342 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8343 formatter.write_str("struct stream_plan.ResumeMutation")
8344 }
8345
8346 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeMutation, V::Error>
8347 where
8348 V: serde::de::MapAccess<'de>,
8349 {
8350 while map_.next_key::<GeneratedField>()?.is_some() {
8351 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8352 }
8353 Ok(ResumeMutation {
8354 })
8355 }
8356 }
8357 deserializer.deserialize_struct("stream_plan.ResumeMutation", FIELDS, GeneratedVisitor)
8358 }
8359}
8360impl serde::Serialize for RowIdGenNode {
8361 #[allow(deprecated)]
8362 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8363 where
8364 S: serde::Serializer,
8365 {
8366 use serde::ser::SerializeStruct;
8367 let mut len = 0;
8368 if self.row_id_index != 0 {
8369 len += 1;
8370 }
8371 let mut struct_ser = serializer.serialize_struct("stream_plan.RowIdGenNode", len)?;
8372 if self.row_id_index != 0 {
8373 #[allow(clippy::needless_borrow)]
8374 #[allow(clippy::needless_borrows_for_generic_args)]
8375 struct_ser.serialize_field("rowIdIndex", ToString::to_string(&self.row_id_index).as_str())?;
8376 }
8377 struct_ser.end()
8378 }
8379}
8380impl<'de> serde::Deserialize<'de> for RowIdGenNode {
8381 #[allow(deprecated)]
8382 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8383 where
8384 D: serde::Deserializer<'de>,
8385 {
8386 const FIELDS: &[&str] = &[
8387 "row_id_index",
8388 "rowIdIndex",
8389 ];
8390
8391 #[allow(clippy::enum_variant_names)]
8392 enum GeneratedField {
8393 RowIdIndex,
8394 }
8395 impl<'de> serde::Deserialize<'de> for GeneratedField {
8396 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8397 where
8398 D: serde::Deserializer<'de>,
8399 {
8400 struct GeneratedVisitor;
8401
8402 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8403 type Value = GeneratedField;
8404
8405 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8406 write!(formatter, "expected one of: {:?}", &FIELDS)
8407 }
8408
8409 #[allow(unused_variables)]
8410 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8411 where
8412 E: serde::de::Error,
8413 {
8414 match value {
8415 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
8416 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8417 }
8418 }
8419 }
8420 deserializer.deserialize_identifier(GeneratedVisitor)
8421 }
8422 }
8423 struct GeneratedVisitor;
8424 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8425 type Value = RowIdGenNode;
8426
8427 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8428 formatter.write_str("struct stream_plan.RowIdGenNode")
8429 }
8430
8431 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowIdGenNode, V::Error>
8432 where
8433 V: serde::de::MapAccess<'de>,
8434 {
8435 let mut row_id_index__ = None;
8436 while let Some(k) = map_.next_key()? {
8437 match k {
8438 GeneratedField::RowIdIndex => {
8439 if row_id_index__.is_some() {
8440 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
8441 }
8442 row_id_index__ =
8443 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8444 ;
8445 }
8446 }
8447 }
8448 Ok(RowIdGenNode {
8449 row_id_index: row_id_index__.unwrap_or_default(),
8450 })
8451 }
8452 }
8453 deserializer.deserialize_struct("stream_plan.RowIdGenNode", FIELDS, GeneratedVisitor)
8454 }
8455}
8456impl serde::Serialize for RowMergeNode {
8457 #[allow(deprecated)]
8458 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8459 where
8460 S: serde::Serializer,
8461 {
8462 use serde::ser::SerializeStruct;
8463 let mut len = 0;
8464 if self.lhs_mapping.is_some() {
8465 len += 1;
8466 }
8467 if self.rhs_mapping.is_some() {
8468 len += 1;
8469 }
8470 let mut struct_ser = serializer.serialize_struct("stream_plan.RowMergeNode", len)?;
8471 if let Some(v) = self.lhs_mapping.as_ref() {
8472 struct_ser.serialize_field("lhsMapping", v)?;
8473 }
8474 if let Some(v) = self.rhs_mapping.as_ref() {
8475 struct_ser.serialize_field("rhsMapping", v)?;
8476 }
8477 struct_ser.end()
8478 }
8479}
8480impl<'de> serde::Deserialize<'de> for RowMergeNode {
8481 #[allow(deprecated)]
8482 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8483 where
8484 D: serde::Deserializer<'de>,
8485 {
8486 const FIELDS: &[&str] = &[
8487 "lhs_mapping",
8488 "lhsMapping",
8489 "rhs_mapping",
8490 "rhsMapping",
8491 ];
8492
8493 #[allow(clippy::enum_variant_names)]
8494 enum GeneratedField {
8495 LhsMapping,
8496 RhsMapping,
8497 }
8498 impl<'de> serde::Deserialize<'de> for GeneratedField {
8499 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8500 where
8501 D: serde::Deserializer<'de>,
8502 {
8503 struct GeneratedVisitor;
8504
8505 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8506 type Value = GeneratedField;
8507
8508 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8509 write!(formatter, "expected one of: {:?}", &FIELDS)
8510 }
8511
8512 #[allow(unused_variables)]
8513 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8514 where
8515 E: serde::de::Error,
8516 {
8517 match value {
8518 "lhsMapping" | "lhs_mapping" => Ok(GeneratedField::LhsMapping),
8519 "rhsMapping" | "rhs_mapping" => Ok(GeneratedField::RhsMapping),
8520 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8521 }
8522 }
8523 }
8524 deserializer.deserialize_identifier(GeneratedVisitor)
8525 }
8526 }
8527 struct GeneratedVisitor;
8528 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8529 type Value = RowMergeNode;
8530
8531 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8532 formatter.write_str("struct stream_plan.RowMergeNode")
8533 }
8534
8535 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowMergeNode, V::Error>
8536 where
8537 V: serde::de::MapAccess<'de>,
8538 {
8539 let mut lhs_mapping__ = None;
8540 let mut rhs_mapping__ = None;
8541 while let Some(k) = map_.next_key()? {
8542 match k {
8543 GeneratedField::LhsMapping => {
8544 if lhs_mapping__.is_some() {
8545 return Err(serde::de::Error::duplicate_field("lhsMapping"));
8546 }
8547 lhs_mapping__ = map_.next_value()?;
8548 }
8549 GeneratedField::RhsMapping => {
8550 if rhs_mapping__.is_some() {
8551 return Err(serde::de::Error::duplicate_field("rhsMapping"));
8552 }
8553 rhs_mapping__ = map_.next_value()?;
8554 }
8555 }
8556 }
8557 Ok(RowMergeNode {
8558 lhs_mapping: lhs_mapping__,
8559 rhs_mapping: rhs_mapping__,
8560 })
8561 }
8562 }
8563 deserializer.deserialize_struct("stream_plan.RowMergeNode", FIELDS, GeneratedVisitor)
8564 }
8565}
8566impl serde::Serialize for SimpleAggNode {
8567 #[allow(deprecated)]
8568 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8569 where
8570 S: serde::Serializer,
8571 {
8572 use serde::ser::SerializeStruct;
8573 let mut len = 0;
8574 if !self.agg_calls.is_empty() {
8575 len += 1;
8576 }
8577 if !self.agg_call_states.is_empty() {
8578 len += 1;
8579 }
8580 if self.intermediate_state_table.is_some() {
8581 len += 1;
8582 }
8583 if self.is_append_only {
8584 len += 1;
8585 }
8586 if !self.distinct_dedup_tables.is_empty() {
8587 len += 1;
8588 }
8589 if self.row_count_index != 0 {
8590 len += 1;
8591 }
8592 if self.version != 0 {
8593 len += 1;
8594 }
8595 if self.must_output_per_barrier {
8596 len += 1;
8597 }
8598 let mut struct_ser = serializer.serialize_struct("stream_plan.SimpleAggNode", len)?;
8599 if !self.agg_calls.is_empty() {
8600 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
8601 }
8602 if !self.agg_call_states.is_empty() {
8603 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
8604 }
8605 if let Some(v) = self.intermediate_state_table.as_ref() {
8606 struct_ser.serialize_field("intermediateStateTable", v)?;
8607 }
8608 if self.is_append_only {
8609 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
8610 }
8611 if !self.distinct_dedup_tables.is_empty() {
8612 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
8613 }
8614 if self.row_count_index != 0 {
8615 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
8616 }
8617 if self.version != 0 {
8618 let v = AggNodeVersion::try_from(self.version)
8619 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
8620 struct_ser.serialize_field("version", &v)?;
8621 }
8622 if self.must_output_per_barrier {
8623 struct_ser.serialize_field("mustOutputPerBarrier", &self.must_output_per_barrier)?;
8624 }
8625 struct_ser.end()
8626 }
8627}
8628impl<'de> serde::Deserialize<'de> for SimpleAggNode {
8629 #[allow(deprecated)]
8630 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8631 where
8632 D: serde::Deserializer<'de>,
8633 {
8634 const FIELDS: &[&str] = &[
8635 "agg_calls",
8636 "aggCalls",
8637 "agg_call_states",
8638 "aggCallStates",
8639 "intermediate_state_table",
8640 "intermediateStateTable",
8641 "is_append_only",
8642 "isAppendOnly",
8643 "distinct_dedup_tables",
8644 "distinctDedupTables",
8645 "row_count_index",
8646 "rowCountIndex",
8647 "version",
8648 "must_output_per_barrier",
8649 "mustOutputPerBarrier",
8650 ];
8651
8652 #[allow(clippy::enum_variant_names)]
8653 enum GeneratedField {
8654 AggCalls,
8655 AggCallStates,
8656 IntermediateStateTable,
8657 IsAppendOnly,
8658 DistinctDedupTables,
8659 RowCountIndex,
8660 Version,
8661 MustOutputPerBarrier,
8662 }
8663 impl<'de> serde::Deserialize<'de> for GeneratedField {
8664 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8665 where
8666 D: serde::Deserializer<'de>,
8667 {
8668 struct GeneratedVisitor;
8669
8670 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8671 type Value = GeneratedField;
8672
8673 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8674 write!(formatter, "expected one of: {:?}", &FIELDS)
8675 }
8676
8677 #[allow(unused_variables)]
8678 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8679 where
8680 E: serde::de::Error,
8681 {
8682 match value {
8683 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
8684 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
8685 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
8686 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
8687 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
8688 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
8689 "version" => Ok(GeneratedField::Version),
8690 "mustOutputPerBarrier" | "must_output_per_barrier" => Ok(GeneratedField::MustOutputPerBarrier),
8691 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8692 }
8693 }
8694 }
8695 deserializer.deserialize_identifier(GeneratedVisitor)
8696 }
8697 }
8698 struct GeneratedVisitor;
8699 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8700 type Value = SimpleAggNode;
8701
8702 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8703 formatter.write_str("struct stream_plan.SimpleAggNode")
8704 }
8705
8706 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SimpleAggNode, V::Error>
8707 where
8708 V: serde::de::MapAccess<'de>,
8709 {
8710 let mut agg_calls__ = None;
8711 let mut agg_call_states__ = None;
8712 let mut intermediate_state_table__ = None;
8713 let mut is_append_only__ = None;
8714 let mut distinct_dedup_tables__ = None;
8715 let mut row_count_index__ = None;
8716 let mut version__ = None;
8717 let mut must_output_per_barrier__ = None;
8718 while let Some(k) = map_.next_key()? {
8719 match k {
8720 GeneratedField::AggCalls => {
8721 if agg_calls__.is_some() {
8722 return Err(serde::de::Error::duplicate_field("aggCalls"));
8723 }
8724 agg_calls__ = Some(map_.next_value()?);
8725 }
8726 GeneratedField::AggCallStates => {
8727 if agg_call_states__.is_some() {
8728 return Err(serde::de::Error::duplicate_field("aggCallStates"));
8729 }
8730 agg_call_states__ = Some(map_.next_value()?);
8731 }
8732 GeneratedField::IntermediateStateTable => {
8733 if intermediate_state_table__.is_some() {
8734 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
8735 }
8736 intermediate_state_table__ = map_.next_value()?;
8737 }
8738 GeneratedField::IsAppendOnly => {
8739 if is_append_only__.is_some() {
8740 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
8741 }
8742 is_append_only__ = Some(map_.next_value()?);
8743 }
8744 GeneratedField::DistinctDedupTables => {
8745 if distinct_dedup_tables__.is_some() {
8746 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
8747 }
8748 distinct_dedup_tables__ = Some(
8749 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8750 .into_iter().map(|(k,v)| (k.0, v)).collect()
8751 );
8752 }
8753 GeneratedField::RowCountIndex => {
8754 if row_count_index__.is_some() {
8755 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
8756 }
8757 row_count_index__ =
8758 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8759 ;
8760 }
8761 GeneratedField::Version => {
8762 if version__.is_some() {
8763 return Err(serde::de::Error::duplicate_field("version"));
8764 }
8765 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
8766 }
8767 GeneratedField::MustOutputPerBarrier => {
8768 if must_output_per_barrier__.is_some() {
8769 return Err(serde::de::Error::duplicate_field("mustOutputPerBarrier"));
8770 }
8771 must_output_per_barrier__ = Some(map_.next_value()?);
8772 }
8773 }
8774 }
8775 Ok(SimpleAggNode {
8776 agg_calls: agg_calls__.unwrap_or_default(),
8777 agg_call_states: agg_call_states__.unwrap_or_default(),
8778 intermediate_state_table: intermediate_state_table__,
8779 is_append_only: is_append_only__.unwrap_or_default(),
8780 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
8781 row_count_index: row_count_index__.unwrap_or_default(),
8782 version: version__.unwrap_or_default(),
8783 must_output_per_barrier: must_output_per_barrier__.unwrap_or_default(),
8784 })
8785 }
8786 }
8787 deserializer.deserialize_struct("stream_plan.SimpleAggNode", FIELDS, GeneratedVisitor)
8788 }
8789}
8790impl serde::Serialize for SinkAddColumns {
8791 #[allow(deprecated)]
8792 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8793 where
8794 S: serde::Serializer,
8795 {
8796 use serde::ser::SerializeStruct;
8797 let mut len = 0;
8798 if !self.fields.is_empty() {
8799 len += 1;
8800 }
8801 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkAddColumns", len)?;
8802 if !self.fields.is_empty() {
8803 struct_ser.serialize_field("fields", &self.fields)?;
8804 }
8805 struct_ser.end()
8806 }
8807}
8808impl<'de> serde::Deserialize<'de> for SinkAddColumns {
8809 #[allow(deprecated)]
8810 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8811 where
8812 D: serde::Deserializer<'de>,
8813 {
8814 const FIELDS: &[&str] = &[
8815 "fields",
8816 ];
8817
8818 #[allow(clippy::enum_variant_names)]
8819 enum GeneratedField {
8820 Fields,
8821 }
8822 impl<'de> serde::Deserialize<'de> for GeneratedField {
8823 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8824 where
8825 D: serde::Deserializer<'de>,
8826 {
8827 struct GeneratedVisitor;
8828
8829 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8830 type Value = GeneratedField;
8831
8832 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8833 write!(formatter, "expected one of: {:?}", &FIELDS)
8834 }
8835
8836 #[allow(unused_variables)]
8837 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8838 where
8839 E: serde::de::Error,
8840 {
8841 match value {
8842 "fields" => Ok(GeneratedField::Fields),
8843 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8844 }
8845 }
8846 }
8847 deserializer.deserialize_identifier(GeneratedVisitor)
8848 }
8849 }
8850 struct GeneratedVisitor;
8851 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8852 type Value = SinkAddColumns;
8853
8854 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8855 formatter.write_str("struct stream_plan.SinkAddColumns")
8856 }
8857
8858 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkAddColumns, V::Error>
8859 where
8860 V: serde::de::MapAccess<'de>,
8861 {
8862 let mut fields__ = None;
8863 while let Some(k) = map_.next_key()? {
8864 match k {
8865 GeneratedField::Fields => {
8866 if fields__.is_some() {
8867 return Err(serde::de::Error::duplicate_field("fields"));
8868 }
8869 fields__ = Some(map_.next_value()?);
8870 }
8871 }
8872 }
8873 Ok(SinkAddColumns {
8874 fields: fields__.unwrap_or_default(),
8875 })
8876 }
8877 }
8878 deserializer.deserialize_struct("stream_plan.SinkAddColumns", FIELDS, GeneratedVisitor)
8879 }
8880}
8881impl serde::Serialize for SinkDesc {
8882 #[allow(deprecated)]
8883 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8884 where
8885 S: serde::Serializer,
8886 {
8887 use serde::ser::SerializeStruct;
8888 let mut len = 0;
8889 if self.id != 0 {
8890 len += 1;
8891 }
8892 if !self.name.is_empty() {
8893 len += 1;
8894 }
8895 if !self.definition.is_empty() {
8896 len += 1;
8897 }
8898 if !self.plan_pk.is_empty() {
8899 len += 1;
8900 }
8901 if !self.downstream_pk.is_empty() {
8902 len += 1;
8903 }
8904 if !self.distribution_key.is_empty() {
8905 len += 1;
8906 }
8907 if !self.properties.is_empty() {
8908 len += 1;
8909 }
8910 if self.sink_type != 0 {
8911 len += 1;
8912 }
8913 if !self.column_catalogs.is_empty() {
8914 len += 1;
8915 }
8916 if !self.db_name.is_empty() {
8917 len += 1;
8918 }
8919 if !self.sink_from_name.is_empty() {
8920 len += 1;
8921 }
8922 if self.format_desc.is_some() {
8923 len += 1;
8924 }
8925 if self.target_table.is_some() {
8926 len += 1;
8927 }
8928 if self.extra_partition_col_idx.is_some() {
8929 len += 1;
8930 }
8931 if !self.secret_refs.is_empty() {
8932 len += 1;
8933 }
8934 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDesc", len)?;
8935 if self.id != 0 {
8936 struct_ser.serialize_field("id", &self.id)?;
8937 }
8938 if !self.name.is_empty() {
8939 struct_ser.serialize_field("name", &self.name)?;
8940 }
8941 if !self.definition.is_empty() {
8942 struct_ser.serialize_field("definition", &self.definition)?;
8943 }
8944 if !self.plan_pk.is_empty() {
8945 struct_ser.serialize_field("planPk", &self.plan_pk)?;
8946 }
8947 if !self.downstream_pk.is_empty() {
8948 struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
8949 }
8950 if !self.distribution_key.is_empty() {
8951 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
8952 }
8953 if !self.properties.is_empty() {
8954 struct_ser.serialize_field("properties", &self.properties)?;
8955 }
8956 if self.sink_type != 0 {
8957 let v = super::catalog::SinkType::try_from(self.sink_type)
8958 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
8959 struct_ser.serialize_field("sinkType", &v)?;
8960 }
8961 if !self.column_catalogs.is_empty() {
8962 struct_ser.serialize_field("columnCatalogs", &self.column_catalogs)?;
8963 }
8964 if !self.db_name.is_empty() {
8965 struct_ser.serialize_field("dbName", &self.db_name)?;
8966 }
8967 if !self.sink_from_name.is_empty() {
8968 struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
8969 }
8970 if let Some(v) = self.format_desc.as_ref() {
8971 struct_ser.serialize_field("formatDesc", v)?;
8972 }
8973 if let Some(v) = self.target_table.as_ref() {
8974 struct_ser.serialize_field("targetTable", v)?;
8975 }
8976 if let Some(v) = self.extra_partition_col_idx.as_ref() {
8977 #[allow(clippy::needless_borrow)]
8978 #[allow(clippy::needless_borrows_for_generic_args)]
8979 struct_ser.serialize_field("extraPartitionColIdx", ToString::to_string(&v).as_str())?;
8980 }
8981 if !self.secret_refs.is_empty() {
8982 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
8983 }
8984 struct_ser.end()
8985 }
8986}
8987impl<'de> serde::Deserialize<'de> for SinkDesc {
8988 #[allow(deprecated)]
8989 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8990 where
8991 D: serde::Deserializer<'de>,
8992 {
8993 const FIELDS: &[&str] = &[
8994 "id",
8995 "name",
8996 "definition",
8997 "plan_pk",
8998 "planPk",
8999 "downstream_pk",
9000 "downstreamPk",
9001 "distribution_key",
9002 "distributionKey",
9003 "properties",
9004 "sink_type",
9005 "sinkType",
9006 "column_catalogs",
9007 "columnCatalogs",
9008 "db_name",
9009 "dbName",
9010 "sink_from_name",
9011 "sinkFromName",
9012 "format_desc",
9013 "formatDesc",
9014 "target_table",
9015 "targetTable",
9016 "extra_partition_col_idx",
9017 "extraPartitionColIdx",
9018 "secret_refs",
9019 "secretRefs",
9020 ];
9021
9022 #[allow(clippy::enum_variant_names)]
9023 enum GeneratedField {
9024 Id,
9025 Name,
9026 Definition,
9027 PlanPk,
9028 DownstreamPk,
9029 DistributionKey,
9030 Properties,
9031 SinkType,
9032 ColumnCatalogs,
9033 DbName,
9034 SinkFromName,
9035 FormatDesc,
9036 TargetTable,
9037 ExtraPartitionColIdx,
9038 SecretRefs,
9039 }
9040 impl<'de> serde::Deserialize<'de> for GeneratedField {
9041 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9042 where
9043 D: serde::Deserializer<'de>,
9044 {
9045 struct GeneratedVisitor;
9046
9047 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9048 type Value = GeneratedField;
9049
9050 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9051 write!(formatter, "expected one of: {:?}", &FIELDS)
9052 }
9053
9054 #[allow(unused_variables)]
9055 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9056 where
9057 E: serde::de::Error,
9058 {
9059 match value {
9060 "id" => Ok(GeneratedField::Id),
9061 "name" => Ok(GeneratedField::Name),
9062 "definition" => Ok(GeneratedField::Definition),
9063 "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
9064 "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
9065 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
9066 "properties" => Ok(GeneratedField::Properties),
9067 "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
9068 "columnCatalogs" | "column_catalogs" => Ok(GeneratedField::ColumnCatalogs),
9069 "dbName" | "db_name" => Ok(GeneratedField::DbName),
9070 "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
9071 "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
9072 "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
9073 "extraPartitionColIdx" | "extra_partition_col_idx" => Ok(GeneratedField::ExtraPartitionColIdx),
9074 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
9075 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9076 }
9077 }
9078 }
9079 deserializer.deserialize_identifier(GeneratedVisitor)
9080 }
9081 }
9082 struct GeneratedVisitor;
9083 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9084 type Value = SinkDesc;
9085
9086 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9087 formatter.write_str("struct stream_plan.SinkDesc")
9088 }
9089
9090 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDesc, V::Error>
9091 where
9092 V: serde::de::MapAccess<'de>,
9093 {
9094 let mut id__ = None;
9095 let mut name__ = None;
9096 let mut definition__ = None;
9097 let mut plan_pk__ = None;
9098 let mut downstream_pk__ = None;
9099 let mut distribution_key__ = None;
9100 let mut properties__ = None;
9101 let mut sink_type__ = None;
9102 let mut column_catalogs__ = None;
9103 let mut db_name__ = None;
9104 let mut sink_from_name__ = None;
9105 let mut format_desc__ = None;
9106 let mut target_table__ = None;
9107 let mut extra_partition_col_idx__ = None;
9108 let mut secret_refs__ = None;
9109 while let Some(k) = map_.next_key()? {
9110 match k {
9111 GeneratedField::Id => {
9112 if id__.is_some() {
9113 return Err(serde::de::Error::duplicate_field("id"));
9114 }
9115 id__ =
9116 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9117 ;
9118 }
9119 GeneratedField::Name => {
9120 if name__.is_some() {
9121 return Err(serde::de::Error::duplicate_field("name"));
9122 }
9123 name__ = Some(map_.next_value()?);
9124 }
9125 GeneratedField::Definition => {
9126 if definition__.is_some() {
9127 return Err(serde::de::Error::duplicate_field("definition"));
9128 }
9129 definition__ = Some(map_.next_value()?);
9130 }
9131 GeneratedField::PlanPk => {
9132 if plan_pk__.is_some() {
9133 return Err(serde::de::Error::duplicate_field("planPk"));
9134 }
9135 plan_pk__ = Some(map_.next_value()?);
9136 }
9137 GeneratedField::DownstreamPk => {
9138 if downstream_pk__.is_some() {
9139 return Err(serde::de::Error::duplicate_field("downstreamPk"));
9140 }
9141 downstream_pk__ =
9142 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9143 .into_iter().map(|x| x.0).collect())
9144 ;
9145 }
9146 GeneratedField::DistributionKey => {
9147 if distribution_key__.is_some() {
9148 return Err(serde::de::Error::duplicate_field("distributionKey"));
9149 }
9150 distribution_key__ =
9151 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9152 .into_iter().map(|x| x.0).collect())
9153 ;
9154 }
9155 GeneratedField::Properties => {
9156 if properties__.is_some() {
9157 return Err(serde::de::Error::duplicate_field("properties"));
9158 }
9159 properties__ = Some(
9160 map_.next_value::<std::collections::BTreeMap<_, _>>()?
9161 );
9162 }
9163 GeneratedField::SinkType => {
9164 if sink_type__.is_some() {
9165 return Err(serde::de::Error::duplicate_field("sinkType"));
9166 }
9167 sink_type__ = Some(map_.next_value::<super::catalog::SinkType>()? as i32);
9168 }
9169 GeneratedField::ColumnCatalogs => {
9170 if column_catalogs__.is_some() {
9171 return Err(serde::de::Error::duplicate_field("columnCatalogs"));
9172 }
9173 column_catalogs__ = Some(map_.next_value()?);
9174 }
9175 GeneratedField::DbName => {
9176 if db_name__.is_some() {
9177 return Err(serde::de::Error::duplicate_field("dbName"));
9178 }
9179 db_name__ = Some(map_.next_value()?);
9180 }
9181 GeneratedField::SinkFromName => {
9182 if sink_from_name__.is_some() {
9183 return Err(serde::de::Error::duplicate_field("sinkFromName"));
9184 }
9185 sink_from_name__ = Some(map_.next_value()?);
9186 }
9187 GeneratedField::FormatDesc => {
9188 if format_desc__.is_some() {
9189 return Err(serde::de::Error::duplicate_field("formatDesc"));
9190 }
9191 format_desc__ = map_.next_value()?;
9192 }
9193 GeneratedField::TargetTable => {
9194 if target_table__.is_some() {
9195 return Err(serde::de::Error::duplicate_field("targetTable"));
9196 }
9197 target_table__ =
9198 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9199 ;
9200 }
9201 GeneratedField::ExtraPartitionColIdx => {
9202 if extra_partition_col_idx__.is_some() {
9203 return Err(serde::de::Error::duplicate_field("extraPartitionColIdx"));
9204 }
9205 extra_partition_col_idx__ =
9206 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9207 ;
9208 }
9209 GeneratedField::SecretRefs => {
9210 if secret_refs__.is_some() {
9211 return Err(serde::de::Error::duplicate_field("secretRefs"));
9212 }
9213 secret_refs__ = Some(
9214 map_.next_value::<std::collections::BTreeMap<_, _>>()?
9215 );
9216 }
9217 }
9218 }
9219 Ok(SinkDesc {
9220 id: id__.unwrap_or_default(),
9221 name: name__.unwrap_or_default(),
9222 definition: definition__.unwrap_or_default(),
9223 plan_pk: plan_pk__.unwrap_or_default(),
9224 downstream_pk: downstream_pk__.unwrap_or_default(),
9225 distribution_key: distribution_key__.unwrap_or_default(),
9226 properties: properties__.unwrap_or_default(),
9227 sink_type: sink_type__.unwrap_or_default(),
9228 column_catalogs: column_catalogs__.unwrap_or_default(),
9229 db_name: db_name__.unwrap_or_default(),
9230 sink_from_name: sink_from_name__.unwrap_or_default(),
9231 format_desc: format_desc__,
9232 target_table: target_table__,
9233 extra_partition_col_idx: extra_partition_col_idx__,
9234 secret_refs: secret_refs__.unwrap_or_default(),
9235 })
9236 }
9237 }
9238 deserializer.deserialize_struct("stream_plan.SinkDesc", FIELDS, GeneratedVisitor)
9239 }
9240}
9241impl serde::Serialize for SinkLogStoreType {
9242 #[allow(deprecated)]
9243 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9244 where
9245 S: serde::Serializer,
9246 {
9247 let variant = match self {
9248 Self::Unspecified => "SINK_LOG_STORE_TYPE_UNSPECIFIED",
9249 Self::KvLogStore => "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
9250 Self::InMemoryLogStore => "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
9251 };
9252 serializer.serialize_str(variant)
9253 }
9254}
9255impl<'de> serde::Deserialize<'de> for SinkLogStoreType {
9256 #[allow(deprecated)]
9257 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9258 where
9259 D: serde::Deserializer<'de>,
9260 {
9261 const FIELDS: &[&str] = &[
9262 "SINK_LOG_STORE_TYPE_UNSPECIFIED",
9263 "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
9264 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
9265 ];
9266
9267 struct GeneratedVisitor;
9268
9269 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9270 type Value = SinkLogStoreType;
9271
9272 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9273 write!(formatter, "expected one of: {:?}", &FIELDS)
9274 }
9275
9276 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9277 where
9278 E: serde::de::Error,
9279 {
9280 i32::try_from(v)
9281 .ok()
9282 .and_then(|x| x.try_into().ok())
9283 .ok_or_else(|| {
9284 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9285 })
9286 }
9287
9288 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9289 where
9290 E: serde::de::Error,
9291 {
9292 i32::try_from(v)
9293 .ok()
9294 .and_then(|x| x.try_into().ok())
9295 .ok_or_else(|| {
9296 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9297 })
9298 }
9299
9300 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9301 where
9302 E: serde::de::Error,
9303 {
9304 match value {
9305 "SINK_LOG_STORE_TYPE_UNSPECIFIED" => Ok(SinkLogStoreType::Unspecified),
9306 "SINK_LOG_STORE_TYPE_KV_LOG_STORE" => Ok(SinkLogStoreType::KvLogStore),
9307 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE" => Ok(SinkLogStoreType::InMemoryLogStore),
9308 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9309 }
9310 }
9311 }
9312 deserializer.deserialize_any(GeneratedVisitor)
9313 }
9314}
9315impl serde::Serialize for SinkNode {
9316 #[allow(deprecated)]
9317 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9318 where
9319 S: serde::Serializer,
9320 {
9321 use serde::ser::SerializeStruct;
9322 let mut len = 0;
9323 if self.sink_desc.is_some() {
9324 len += 1;
9325 }
9326 if self.table.is_some() {
9327 len += 1;
9328 }
9329 if self.log_store_type != 0 {
9330 len += 1;
9331 }
9332 if self.rate_limit.is_some() {
9333 len += 1;
9334 }
9335 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkNode", len)?;
9336 if let Some(v) = self.sink_desc.as_ref() {
9337 struct_ser.serialize_field("sinkDesc", v)?;
9338 }
9339 if let Some(v) = self.table.as_ref() {
9340 struct_ser.serialize_field("table", v)?;
9341 }
9342 if self.log_store_type != 0 {
9343 let v = SinkLogStoreType::try_from(self.log_store_type)
9344 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.log_store_type)))?;
9345 struct_ser.serialize_field("logStoreType", &v)?;
9346 }
9347 if let Some(v) = self.rate_limit.as_ref() {
9348 struct_ser.serialize_field("rateLimit", v)?;
9349 }
9350 struct_ser.end()
9351 }
9352}
9353impl<'de> serde::Deserialize<'de> for SinkNode {
9354 #[allow(deprecated)]
9355 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9356 where
9357 D: serde::Deserializer<'de>,
9358 {
9359 const FIELDS: &[&str] = &[
9360 "sink_desc",
9361 "sinkDesc",
9362 "table",
9363 "log_store_type",
9364 "logStoreType",
9365 "rate_limit",
9366 "rateLimit",
9367 ];
9368
9369 #[allow(clippy::enum_variant_names)]
9370 enum GeneratedField {
9371 SinkDesc,
9372 Table,
9373 LogStoreType,
9374 RateLimit,
9375 }
9376 impl<'de> serde::Deserialize<'de> for GeneratedField {
9377 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9378 where
9379 D: serde::Deserializer<'de>,
9380 {
9381 struct GeneratedVisitor;
9382
9383 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9384 type Value = GeneratedField;
9385
9386 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9387 write!(formatter, "expected one of: {:?}", &FIELDS)
9388 }
9389
9390 #[allow(unused_variables)]
9391 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9392 where
9393 E: serde::de::Error,
9394 {
9395 match value {
9396 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
9397 "table" => Ok(GeneratedField::Table),
9398 "logStoreType" | "log_store_type" => Ok(GeneratedField::LogStoreType),
9399 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
9400 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9401 }
9402 }
9403 }
9404 deserializer.deserialize_identifier(GeneratedVisitor)
9405 }
9406 }
9407 struct GeneratedVisitor;
9408 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9409 type Value = SinkNode;
9410
9411 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9412 formatter.write_str("struct stream_plan.SinkNode")
9413 }
9414
9415 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkNode, V::Error>
9416 where
9417 V: serde::de::MapAccess<'de>,
9418 {
9419 let mut sink_desc__ = None;
9420 let mut table__ = None;
9421 let mut log_store_type__ = None;
9422 let mut rate_limit__ = None;
9423 while let Some(k) = map_.next_key()? {
9424 match k {
9425 GeneratedField::SinkDesc => {
9426 if sink_desc__.is_some() {
9427 return Err(serde::de::Error::duplicate_field("sinkDesc"));
9428 }
9429 sink_desc__ = map_.next_value()?;
9430 }
9431 GeneratedField::Table => {
9432 if table__.is_some() {
9433 return Err(serde::de::Error::duplicate_field("table"));
9434 }
9435 table__ = map_.next_value()?;
9436 }
9437 GeneratedField::LogStoreType => {
9438 if log_store_type__.is_some() {
9439 return Err(serde::de::Error::duplicate_field("logStoreType"));
9440 }
9441 log_store_type__ = Some(map_.next_value::<SinkLogStoreType>()? as i32);
9442 }
9443 GeneratedField::RateLimit => {
9444 if rate_limit__.is_some() {
9445 return Err(serde::de::Error::duplicate_field("rateLimit"));
9446 }
9447 rate_limit__ =
9448 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9449 ;
9450 }
9451 }
9452 }
9453 Ok(SinkNode {
9454 sink_desc: sink_desc__,
9455 table: table__,
9456 log_store_type: log_store_type__.unwrap_or_default(),
9457 rate_limit: rate_limit__,
9458 })
9459 }
9460 }
9461 deserializer.deserialize_struct("stream_plan.SinkNode", FIELDS, GeneratedVisitor)
9462 }
9463}
9464impl serde::Serialize for SortNode {
9465 #[allow(deprecated)]
9466 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9467 where
9468 S: serde::Serializer,
9469 {
9470 use serde::ser::SerializeStruct;
9471 let mut len = 0;
9472 if self.state_table.is_some() {
9473 len += 1;
9474 }
9475 if self.sort_column_index != 0 {
9476 len += 1;
9477 }
9478 let mut struct_ser = serializer.serialize_struct("stream_plan.SortNode", len)?;
9479 if let Some(v) = self.state_table.as_ref() {
9480 struct_ser.serialize_field("stateTable", v)?;
9481 }
9482 if self.sort_column_index != 0 {
9483 struct_ser.serialize_field("sortColumnIndex", &self.sort_column_index)?;
9484 }
9485 struct_ser.end()
9486 }
9487}
9488impl<'de> serde::Deserialize<'de> for SortNode {
9489 #[allow(deprecated)]
9490 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9491 where
9492 D: serde::Deserializer<'de>,
9493 {
9494 const FIELDS: &[&str] = &[
9495 "state_table",
9496 "stateTable",
9497 "sort_column_index",
9498 "sortColumnIndex",
9499 ];
9500
9501 #[allow(clippy::enum_variant_names)]
9502 enum GeneratedField {
9503 StateTable,
9504 SortColumnIndex,
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 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9527 "sortColumnIndex" | "sort_column_index" => Ok(GeneratedField::SortColumnIndex),
9528 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9529 }
9530 }
9531 }
9532 deserializer.deserialize_identifier(GeneratedVisitor)
9533 }
9534 }
9535 struct GeneratedVisitor;
9536 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9537 type Value = SortNode;
9538
9539 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9540 formatter.write_str("struct stream_plan.SortNode")
9541 }
9542
9543 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
9544 where
9545 V: serde::de::MapAccess<'de>,
9546 {
9547 let mut state_table__ = None;
9548 let mut sort_column_index__ = None;
9549 while let Some(k) = map_.next_key()? {
9550 match k {
9551 GeneratedField::StateTable => {
9552 if state_table__.is_some() {
9553 return Err(serde::de::Error::duplicate_field("stateTable"));
9554 }
9555 state_table__ = map_.next_value()?;
9556 }
9557 GeneratedField::SortColumnIndex => {
9558 if sort_column_index__.is_some() {
9559 return Err(serde::de::Error::duplicate_field("sortColumnIndex"));
9560 }
9561 sort_column_index__ =
9562 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9563 ;
9564 }
9565 }
9566 }
9567 Ok(SortNode {
9568 state_table: state_table__,
9569 sort_column_index: sort_column_index__.unwrap_or_default(),
9570 })
9571 }
9572 }
9573 deserializer.deserialize_struct("stream_plan.SortNode", FIELDS, GeneratedVisitor)
9574 }
9575}
9576impl serde::Serialize for SourceBackfillNode {
9577 #[allow(deprecated)]
9578 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9579 where
9580 S: serde::Serializer,
9581 {
9582 use serde::ser::SerializeStruct;
9583 let mut len = 0;
9584 if self.upstream_source_id != 0 {
9585 len += 1;
9586 }
9587 if self.row_id_index.is_some() {
9588 len += 1;
9589 }
9590 if !self.columns.is_empty() {
9591 len += 1;
9592 }
9593 if self.info.is_some() {
9594 len += 1;
9595 }
9596 if !self.source_name.is_empty() {
9597 len += 1;
9598 }
9599 if !self.with_properties.is_empty() {
9600 len += 1;
9601 }
9602 if self.rate_limit.is_some() {
9603 len += 1;
9604 }
9605 if self.state_table.is_some() {
9606 len += 1;
9607 }
9608 if !self.secret_refs.is_empty() {
9609 len += 1;
9610 }
9611 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceBackfillNode", len)?;
9612 if self.upstream_source_id != 0 {
9613 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
9614 }
9615 if let Some(v) = self.row_id_index.as_ref() {
9616 struct_ser.serialize_field("rowIdIndex", v)?;
9617 }
9618 if !self.columns.is_empty() {
9619 struct_ser.serialize_field("columns", &self.columns)?;
9620 }
9621 if let Some(v) = self.info.as_ref() {
9622 struct_ser.serialize_field("info", v)?;
9623 }
9624 if !self.source_name.is_empty() {
9625 struct_ser.serialize_field("sourceName", &self.source_name)?;
9626 }
9627 if !self.with_properties.is_empty() {
9628 struct_ser.serialize_field("withProperties", &self.with_properties)?;
9629 }
9630 if let Some(v) = self.rate_limit.as_ref() {
9631 struct_ser.serialize_field("rateLimit", v)?;
9632 }
9633 if let Some(v) = self.state_table.as_ref() {
9634 struct_ser.serialize_field("stateTable", v)?;
9635 }
9636 if !self.secret_refs.is_empty() {
9637 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
9638 }
9639 struct_ser.end()
9640 }
9641}
9642impl<'de> serde::Deserialize<'de> for SourceBackfillNode {
9643 #[allow(deprecated)]
9644 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9645 where
9646 D: serde::Deserializer<'de>,
9647 {
9648 const FIELDS: &[&str] = &[
9649 "upstream_source_id",
9650 "upstreamSourceId",
9651 "row_id_index",
9652 "rowIdIndex",
9653 "columns",
9654 "info",
9655 "source_name",
9656 "sourceName",
9657 "with_properties",
9658 "withProperties",
9659 "rate_limit",
9660 "rateLimit",
9661 "state_table",
9662 "stateTable",
9663 "secret_refs",
9664 "secretRefs",
9665 ];
9666
9667 #[allow(clippy::enum_variant_names)]
9668 enum GeneratedField {
9669 UpstreamSourceId,
9670 RowIdIndex,
9671 Columns,
9672 Info,
9673 SourceName,
9674 WithProperties,
9675 RateLimit,
9676 StateTable,
9677 SecretRefs,
9678 }
9679 impl<'de> serde::Deserialize<'de> for GeneratedField {
9680 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9681 where
9682 D: serde::Deserializer<'de>,
9683 {
9684 struct GeneratedVisitor;
9685
9686 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9687 type Value = GeneratedField;
9688
9689 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9690 write!(formatter, "expected one of: {:?}", &FIELDS)
9691 }
9692
9693 #[allow(unused_variables)]
9694 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9695 where
9696 E: serde::de::Error,
9697 {
9698 match value {
9699 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
9700 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
9701 "columns" => Ok(GeneratedField::Columns),
9702 "info" => Ok(GeneratedField::Info),
9703 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
9704 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
9705 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
9706 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9707 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
9708 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9709 }
9710 }
9711 }
9712 deserializer.deserialize_identifier(GeneratedVisitor)
9713 }
9714 }
9715 struct GeneratedVisitor;
9716 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9717 type Value = SourceBackfillNode;
9718
9719 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9720 formatter.write_str("struct stream_plan.SourceBackfillNode")
9721 }
9722
9723 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceBackfillNode, V::Error>
9724 where
9725 V: serde::de::MapAccess<'de>,
9726 {
9727 let mut upstream_source_id__ = None;
9728 let mut row_id_index__ = None;
9729 let mut columns__ = None;
9730 let mut info__ = None;
9731 let mut source_name__ = None;
9732 let mut with_properties__ = None;
9733 let mut rate_limit__ = None;
9734 let mut state_table__ = None;
9735 let mut secret_refs__ = None;
9736 while let Some(k) = map_.next_key()? {
9737 match k {
9738 GeneratedField::UpstreamSourceId => {
9739 if upstream_source_id__.is_some() {
9740 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
9741 }
9742 upstream_source_id__ =
9743 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9744 ;
9745 }
9746 GeneratedField::RowIdIndex => {
9747 if row_id_index__.is_some() {
9748 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
9749 }
9750 row_id_index__ =
9751 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9752 ;
9753 }
9754 GeneratedField::Columns => {
9755 if columns__.is_some() {
9756 return Err(serde::de::Error::duplicate_field("columns"));
9757 }
9758 columns__ = Some(map_.next_value()?);
9759 }
9760 GeneratedField::Info => {
9761 if info__.is_some() {
9762 return Err(serde::de::Error::duplicate_field("info"));
9763 }
9764 info__ = map_.next_value()?;
9765 }
9766 GeneratedField::SourceName => {
9767 if source_name__.is_some() {
9768 return Err(serde::de::Error::duplicate_field("sourceName"));
9769 }
9770 source_name__ = Some(map_.next_value()?);
9771 }
9772 GeneratedField::WithProperties => {
9773 if with_properties__.is_some() {
9774 return Err(serde::de::Error::duplicate_field("withProperties"));
9775 }
9776 with_properties__ = Some(
9777 map_.next_value::<std::collections::BTreeMap<_, _>>()?
9778 );
9779 }
9780 GeneratedField::RateLimit => {
9781 if rate_limit__.is_some() {
9782 return Err(serde::de::Error::duplicate_field("rateLimit"));
9783 }
9784 rate_limit__ =
9785 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9786 ;
9787 }
9788 GeneratedField::StateTable => {
9789 if state_table__.is_some() {
9790 return Err(serde::de::Error::duplicate_field("stateTable"));
9791 }
9792 state_table__ = map_.next_value()?;
9793 }
9794 GeneratedField::SecretRefs => {
9795 if secret_refs__.is_some() {
9796 return Err(serde::de::Error::duplicate_field("secretRefs"));
9797 }
9798 secret_refs__ = Some(
9799 map_.next_value::<std::collections::BTreeMap<_, _>>()?
9800 );
9801 }
9802 }
9803 }
9804 Ok(SourceBackfillNode {
9805 upstream_source_id: upstream_source_id__.unwrap_or_default(),
9806 row_id_index: row_id_index__,
9807 columns: columns__.unwrap_or_default(),
9808 info: info__,
9809 source_name: source_name__.unwrap_or_default(),
9810 with_properties: with_properties__.unwrap_or_default(),
9811 rate_limit: rate_limit__,
9812 state_table: state_table__,
9813 secret_refs: secret_refs__.unwrap_or_default(),
9814 })
9815 }
9816 }
9817 deserializer.deserialize_struct("stream_plan.SourceBackfillNode", FIELDS, GeneratedVisitor)
9818 }
9819}
9820impl serde::Serialize for SourceChangeSplitMutation {
9821 #[allow(deprecated)]
9822 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9823 where
9824 S: serde::Serializer,
9825 {
9826 use serde::ser::SerializeStruct;
9827 let mut len = 0;
9828 if !self.actor_splits.is_empty() {
9829 len += 1;
9830 }
9831 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceChangeSplitMutation", len)?;
9832 if !self.actor_splits.is_empty() {
9833 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
9834 }
9835 struct_ser.end()
9836 }
9837}
9838impl<'de> serde::Deserialize<'de> for SourceChangeSplitMutation {
9839 #[allow(deprecated)]
9840 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9841 where
9842 D: serde::Deserializer<'de>,
9843 {
9844 const FIELDS: &[&str] = &[
9845 "actor_splits",
9846 "actorSplits",
9847 ];
9848
9849 #[allow(clippy::enum_variant_names)]
9850 enum GeneratedField {
9851 ActorSplits,
9852 }
9853 impl<'de> serde::Deserialize<'de> for GeneratedField {
9854 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9855 where
9856 D: serde::Deserializer<'de>,
9857 {
9858 struct GeneratedVisitor;
9859
9860 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9861 type Value = GeneratedField;
9862
9863 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9864 write!(formatter, "expected one of: {:?}", &FIELDS)
9865 }
9866
9867 #[allow(unused_variables)]
9868 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9869 where
9870 E: serde::de::Error,
9871 {
9872 match value {
9873 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
9874 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9875 }
9876 }
9877 }
9878 deserializer.deserialize_identifier(GeneratedVisitor)
9879 }
9880 }
9881 struct GeneratedVisitor;
9882 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9883 type Value = SourceChangeSplitMutation;
9884
9885 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9886 formatter.write_str("struct stream_plan.SourceChangeSplitMutation")
9887 }
9888
9889 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceChangeSplitMutation, V::Error>
9890 where
9891 V: serde::de::MapAccess<'de>,
9892 {
9893 let mut actor_splits__ = None;
9894 while let Some(k) = map_.next_key()? {
9895 match k {
9896 GeneratedField::ActorSplits => {
9897 if actor_splits__.is_some() {
9898 return Err(serde::de::Error::duplicate_field("actorSplits"));
9899 }
9900 actor_splits__ = Some(
9901 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
9902 .into_iter().map(|(k,v)| (k.0, v)).collect()
9903 );
9904 }
9905 }
9906 }
9907 Ok(SourceChangeSplitMutation {
9908 actor_splits: actor_splits__.unwrap_or_default(),
9909 })
9910 }
9911 }
9912 deserializer.deserialize_struct("stream_plan.SourceChangeSplitMutation", FIELDS, GeneratedVisitor)
9913 }
9914}
9915impl serde::Serialize for SourceNode {
9916 #[allow(deprecated)]
9917 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9918 where
9919 S: serde::Serializer,
9920 {
9921 use serde::ser::SerializeStruct;
9922 let mut len = 0;
9923 if self.source_inner.is_some() {
9924 len += 1;
9925 }
9926 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceNode", len)?;
9927 if let Some(v) = self.source_inner.as_ref() {
9928 struct_ser.serialize_field("sourceInner", v)?;
9929 }
9930 struct_ser.end()
9931 }
9932}
9933impl<'de> serde::Deserialize<'de> for SourceNode {
9934 #[allow(deprecated)]
9935 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9936 where
9937 D: serde::Deserializer<'de>,
9938 {
9939 const FIELDS: &[&str] = &[
9940 "source_inner",
9941 "sourceInner",
9942 ];
9943
9944 #[allow(clippy::enum_variant_names)]
9945 enum GeneratedField {
9946 SourceInner,
9947 }
9948 impl<'de> serde::Deserialize<'de> for GeneratedField {
9949 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9950 where
9951 D: serde::Deserializer<'de>,
9952 {
9953 struct GeneratedVisitor;
9954
9955 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9956 type Value = GeneratedField;
9957
9958 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9959 write!(formatter, "expected one of: {:?}", &FIELDS)
9960 }
9961
9962 #[allow(unused_variables)]
9963 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9964 where
9965 E: serde::de::Error,
9966 {
9967 match value {
9968 "sourceInner" | "source_inner" => Ok(GeneratedField::SourceInner),
9969 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9970 }
9971 }
9972 }
9973 deserializer.deserialize_identifier(GeneratedVisitor)
9974 }
9975 }
9976 struct GeneratedVisitor;
9977 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9978 type Value = SourceNode;
9979
9980 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9981 formatter.write_str("struct stream_plan.SourceNode")
9982 }
9983
9984 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
9985 where
9986 V: serde::de::MapAccess<'de>,
9987 {
9988 let mut source_inner__ = None;
9989 while let Some(k) = map_.next_key()? {
9990 match k {
9991 GeneratedField::SourceInner => {
9992 if source_inner__.is_some() {
9993 return Err(serde::de::Error::duplicate_field("sourceInner"));
9994 }
9995 source_inner__ = map_.next_value()?;
9996 }
9997 }
9998 }
9999 Ok(SourceNode {
10000 source_inner: source_inner__,
10001 })
10002 }
10003 }
10004 deserializer.deserialize_struct("stream_plan.SourceNode", FIELDS, GeneratedVisitor)
10005 }
10006}
10007impl serde::Serialize for StartFragmentBackfillMutation {
10008 #[allow(deprecated)]
10009 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10010 where
10011 S: serde::Serializer,
10012 {
10013 use serde::ser::SerializeStruct;
10014 let mut len = 0;
10015 if !self.fragment_ids.is_empty() {
10016 len += 1;
10017 }
10018 let mut struct_ser = serializer.serialize_struct("stream_plan.StartFragmentBackfillMutation", len)?;
10019 if !self.fragment_ids.is_empty() {
10020 struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
10021 }
10022 struct_ser.end()
10023 }
10024}
10025impl<'de> serde::Deserialize<'de> for StartFragmentBackfillMutation {
10026 #[allow(deprecated)]
10027 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10028 where
10029 D: serde::Deserializer<'de>,
10030 {
10031 const FIELDS: &[&str] = &[
10032 "fragment_ids",
10033 "fragmentIds",
10034 ];
10035
10036 #[allow(clippy::enum_variant_names)]
10037 enum GeneratedField {
10038 FragmentIds,
10039 }
10040 impl<'de> serde::Deserialize<'de> for GeneratedField {
10041 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10042 where
10043 D: serde::Deserializer<'de>,
10044 {
10045 struct GeneratedVisitor;
10046
10047 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10048 type Value = GeneratedField;
10049
10050 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10051 write!(formatter, "expected one of: {:?}", &FIELDS)
10052 }
10053
10054 #[allow(unused_variables)]
10055 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10056 where
10057 E: serde::de::Error,
10058 {
10059 match value {
10060 "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
10061 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10062 }
10063 }
10064 }
10065 deserializer.deserialize_identifier(GeneratedVisitor)
10066 }
10067 }
10068 struct GeneratedVisitor;
10069 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10070 type Value = StartFragmentBackfillMutation;
10071
10072 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10073 formatter.write_str("struct stream_plan.StartFragmentBackfillMutation")
10074 }
10075
10076 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StartFragmentBackfillMutation, V::Error>
10077 where
10078 V: serde::de::MapAccess<'de>,
10079 {
10080 let mut fragment_ids__ = None;
10081 while let Some(k) = map_.next_key()? {
10082 match k {
10083 GeneratedField::FragmentIds => {
10084 if fragment_ids__.is_some() {
10085 return Err(serde::de::Error::duplicate_field("fragmentIds"));
10086 }
10087 fragment_ids__ =
10088 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10089 .into_iter().map(|x| x.0).collect())
10090 ;
10091 }
10092 }
10093 }
10094 Ok(StartFragmentBackfillMutation {
10095 fragment_ids: fragment_ids__.unwrap_or_default(),
10096 })
10097 }
10098 }
10099 deserializer.deserialize_struct("stream_plan.StartFragmentBackfillMutation", FIELDS, GeneratedVisitor)
10100 }
10101}
10102impl serde::Serialize for StopMutation {
10103 #[allow(deprecated)]
10104 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10105 where
10106 S: serde::Serializer,
10107 {
10108 use serde::ser::SerializeStruct;
10109 let mut len = 0;
10110 if !self.actors.is_empty() {
10111 len += 1;
10112 }
10113 if !self.dropped_sink_fragments.is_empty() {
10114 len += 1;
10115 }
10116 let mut struct_ser = serializer.serialize_struct("stream_plan.StopMutation", len)?;
10117 if !self.actors.is_empty() {
10118 struct_ser.serialize_field("actors", &self.actors)?;
10119 }
10120 if !self.dropped_sink_fragments.is_empty() {
10121 struct_ser.serialize_field("droppedSinkFragments", &self.dropped_sink_fragments)?;
10122 }
10123 struct_ser.end()
10124 }
10125}
10126impl<'de> serde::Deserialize<'de> for StopMutation {
10127 #[allow(deprecated)]
10128 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10129 where
10130 D: serde::Deserializer<'de>,
10131 {
10132 const FIELDS: &[&str] = &[
10133 "actors",
10134 "dropped_sink_fragments",
10135 "droppedSinkFragments",
10136 ];
10137
10138 #[allow(clippy::enum_variant_names)]
10139 enum GeneratedField {
10140 Actors,
10141 DroppedSinkFragments,
10142 }
10143 impl<'de> serde::Deserialize<'de> for GeneratedField {
10144 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10145 where
10146 D: serde::Deserializer<'de>,
10147 {
10148 struct GeneratedVisitor;
10149
10150 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10151 type Value = GeneratedField;
10152
10153 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10154 write!(formatter, "expected one of: {:?}", &FIELDS)
10155 }
10156
10157 #[allow(unused_variables)]
10158 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10159 where
10160 E: serde::de::Error,
10161 {
10162 match value {
10163 "actors" => Ok(GeneratedField::Actors),
10164 "droppedSinkFragments" | "dropped_sink_fragments" => Ok(GeneratedField::DroppedSinkFragments),
10165 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10166 }
10167 }
10168 }
10169 deserializer.deserialize_identifier(GeneratedVisitor)
10170 }
10171 }
10172 struct GeneratedVisitor;
10173 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10174 type Value = StopMutation;
10175
10176 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10177 formatter.write_str("struct stream_plan.StopMutation")
10178 }
10179
10180 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopMutation, V::Error>
10181 where
10182 V: serde::de::MapAccess<'de>,
10183 {
10184 let mut actors__ = None;
10185 let mut dropped_sink_fragments__ = None;
10186 while let Some(k) = map_.next_key()? {
10187 match k {
10188 GeneratedField::Actors => {
10189 if actors__.is_some() {
10190 return Err(serde::de::Error::duplicate_field("actors"));
10191 }
10192 actors__ =
10193 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10194 .into_iter().map(|x| x.0).collect())
10195 ;
10196 }
10197 GeneratedField::DroppedSinkFragments => {
10198 if dropped_sink_fragments__.is_some() {
10199 return Err(serde::de::Error::duplicate_field("droppedSinkFragments"));
10200 }
10201 dropped_sink_fragments__ =
10202 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10203 .into_iter().map(|x| x.0).collect())
10204 ;
10205 }
10206 }
10207 }
10208 Ok(StopMutation {
10209 actors: actors__.unwrap_or_default(),
10210 dropped_sink_fragments: dropped_sink_fragments__.unwrap_or_default(),
10211 })
10212 }
10213 }
10214 deserializer.deserialize_struct("stream_plan.StopMutation", FIELDS, GeneratedVisitor)
10215 }
10216}
10217impl serde::Serialize for StreamActor {
10218 #[allow(deprecated)]
10219 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10220 where
10221 S: serde::Serializer,
10222 {
10223 use serde::ser::SerializeStruct;
10224 let mut len = 0;
10225 if self.actor_id != 0 {
10226 len += 1;
10227 }
10228 if self.fragment_id != 0 {
10229 len += 1;
10230 }
10231 if !self.dispatcher.is_empty() {
10232 len += 1;
10233 }
10234 if self.vnode_bitmap.is_some() {
10235 len += 1;
10236 }
10237 if !self.mview_definition.is_empty() {
10238 len += 1;
10239 }
10240 if self.expr_context.is_some() {
10241 len += 1;
10242 }
10243 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamActor", len)?;
10244 if self.actor_id != 0 {
10245 struct_ser.serialize_field("actorId", &self.actor_id)?;
10246 }
10247 if self.fragment_id != 0 {
10248 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
10249 }
10250 if !self.dispatcher.is_empty() {
10251 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
10252 }
10253 if let Some(v) = self.vnode_bitmap.as_ref() {
10254 struct_ser.serialize_field("vnodeBitmap", v)?;
10255 }
10256 if !self.mview_definition.is_empty() {
10257 struct_ser.serialize_field("mviewDefinition", &self.mview_definition)?;
10258 }
10259 if let Some(v) = self.expr_context.as_ref() {
10260 struct_ser.serialize_field("exprContext", v)?;
10261 }
10262 struct_ser.end()
10263 }
10264}
10265impl<'de> serde::Deserialize<'de> for StreamActor {
10266 #[allow(deprecated)]
10267 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10268 where
10269 D: serde::Deserializer<'de>,
10270 {
10271 const FIELDS: &[&str] = &[
10272 "actor_id",
10273 "actorId",
10274 "fragment_id",
10275 "fragmentId",
10276 "dispatcher",
10277 "vnode_bitmap",
10278 "vnodeBitmap",
10279 "mview_definition",
10280 "mviewDefinition",
10281 "expr_context",
10282 "exprContext",
10283 ];
10284
10285 #[allow(clippy::enum_variant_names)]
10286 enum GeneratedField {
10287 ActorId,
10288 FragmentId,
10289 Dispatcher,
10290 VnodeBitmap,
10291 MviewDefinition,
10292 ExprContext,
10293 }
10294 impl<'de> serde::Deserialize<'de> for GeneratedField {
10295 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10296 where
10297 D: serde::Deserializer<'de>,
10298 {
10299 struct GeneratedVisitor;
10300
10301 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10302 type Value = GeneratedField;
10303
10304 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10305 write!(formatter, "expected one of: {:?}", &FIELDS)
10306 }
10307
10308 #[allow(unused_variables)]
10309 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10310 where
10311 E: serde::de::Error,
10312 {
10313 match value {
10314 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
10315 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
10316 "dispatcher" => Ok(GeneratedField::Dispatcher),
10317 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
10318 "mviewDefinition" | "mview_definition" => Ok(GeneratedField::MviewDefinition),
10319 "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
10320 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10321 }
10322 }
10323 }
10324 deserializer.deserialize_identifier(GeneratedVisitor)
10325 }
10326 }
10327 struct GeneratedVisitor;
10328 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10329 type Value = StreamActor;
10330
10331 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10332 formatter.write_str("struct stream_plan.StreamActor")
10333 }
10334
10335 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamActor, V::Error>
10336 where
10337 V: serde::de::MapAccess<'de>,
10338 {
10339 let mut actor_id__ = None;
10340 let mut fragment_id__ = None;
10341 let mut dispatcher__ = None;
10342 let mut vnode_bitmap__ = None;
10343 let mut mview_definition__ = None;
10344 let mut expr_context__ = None;
10345 while let Some(k) = map_.next_key()? {
10346 match k {
10347 GeneratedField::ActorId => {
10348 if actor_id__.is_some() {
10349 return Err(serde::de::Error::duplicate_field("actorId"));
10350 }
10351 actor_id__ =
10352 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10353 ;
10354 }
10355 GeneratedField::FragmentId => {
10356 if fragment_id__.is_some() {
10357 return Err(serde::de::Error::duplicate_field("fragmentId"));
10358 }
10359 fragment_id__ =
10360 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10361 ;
10362 }
10363 GeneratedField::Dispatcher => {
10364 if dispatcher__.is_some() {
10365 return Err(serde::de::Error::duplicate_field("dispatcher"));
10366 }
10367 dispatcher__ = Some(map_.next_value()?);
10368 }
10369 GeneratedField::VnodeBitmap => {
10370 if vnode_bitmap__.is_some() {
10371 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
10372 }
10373 vnode_bitmap__ = map_.next_value()?;
10374 }
10375 GeneratedField::MviewDefinition => {
10376 if mview_definition__.is_some() {
10377 return Err(serde::de::Error::duplicate_field("mviewDefinition"));
10378 }
10379 mview_definition__ = Some(map_.next_value()?);
10380 }
10381 GeneratedField::ExprContext => {
10382 if expr_context__.is_some() {
10383 return Err(serde::de::Error::duplicate_field("exprContext"));
10384 }
10385 expr_context__ = map_.next_value()?;
10386 }
10387 }
10388 }
10389 Ok(StreamActor {
10390 actor_id: actor_id__.unwrap_or_default(),
10391 fragment_id: fragment_id__.unwrap_or_default(),
10392 dispatcher: dispatcher__.unwrap_or_default(),
10393 vnode_bitmap: vnode_bitmap__,
10394 mview_definition: mview_definition__.unwrap_or_default(),
10395 expr_context: expr_context__,
10396 })
10397 }
10398 }
10399 deserializer.deserialize_struct("stream_plan.StreamActor", FIELDS, GeneratedVisitor)
10400 }
10401}
10402impl serde::Serialize for StreamCdcScanNode {
10403 #[allow(deprecated)]
10404 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10405 where
10406 S: serde::Serializer,
10407 {
10408 use serde::ser::SerializeStruct;
10409 let mut len = 0;
10410 if self.table_id != 0 {
10411 len += 1;
10412 }
10413 if !self.upstream_column_ids.is_empty() {
10414 len += 1;
10415 }
10416 if !self.output_indices.is_empty() {
10417 len += 1;
10418 }
10419 if self.state_table.is_some() {
10420 len += 1;
10421 }
10422 if self.cdc_table_desc.is_some() {
10423 len += 1;
10424 }
10425 if self.rate_limit.is_some() {
10426 len += 1;
10427 }
10428 if self.disable_backfill {
10429 len += 1;
10430 }
10431 if self.options.is_some() {
10432 len += 1;
10433 }
10434 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanNode", len)?;
10435 if self.table_id != 0 {
10436 struct_ser.serialize_field("tableId", &self.table_id)?;
10437 }
10438 if !self.upstream_column_ids.is_empty() {
10439 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
10440 }
10441 if !self.output_indices.is_empty() {
10442 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
10443 }
10444 if let Some(v) = self.state_table.as_ref() {
10445 struct_ser.serialize_field("stateTable", v)?;
10446 }
10447 if let Some(v) = self.cdc_table_desc.as_ref() {
10448 struct_ser.serialize_field("cdcTableDesc", v)?;
10449 }
10450 if let Some(v) = self.rate_limit.as_ref() {
10451 struct_ser.serialize_field("rateLimit", v)?;
10452 }
10453 if self.disable_backfill {
10454 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
10455 }
10456 if let Some(v) = self.options.as_ref() {
10457 struct_ser.serialize_field("options", v)?;
10458 }
10459 struct_ser.end()
10460 }
10461}
10462impl<'de> serde::Deserialize<'de> for StreamCdcScanNode {
10463 #[allow(deprecated)]
10464 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10465 where
10466 D: serde::Deserializer<'de>,
10467 {
10468 const FIELDS: &[&str] = &[
10469 "table_id",
10470 "tableId",
10471 "upstream_column_ids",
10472 "upstreamColumnIds",
10473 "output_indices",
10474 "outputIndices",
10475 "state_table",
10476 "stateTable",
10477 "cdc_table_desc",
10478 "cdcTableDesc",
10479 "rate_limit",
10480 "rateLimit",
10481 "disable_backfill",
10482 "disableBackfill",
10483 "options",
10484 ];
10485
10486 #[allow(clippy::enum_variant_names)]
10487 enum GeneratedField {
10488 TableId,
10489 UpstreamColumnIds,
10490 OutputIndices,
10491 StateTable,
10492 CdcTableDesc,
10493 RateLimit,
10494 DisableBackfill,
10495 Options,
10496 }
10497 impl<'de> serde::Deserialize<'de> for GeneratedField {
10498 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10499 where
10500 D: serde::Deserializer<'de>,
10501 {
10502 struct GeneratedVisitor;
10503
10504 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10505 type Value = GeneratedField;
10506
10507 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10508 write!(formatter, "expected one of: {:?}", &FIELDS)
10509 }
10510
10511 #[allow(unused_variables)]
10512 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10513 where
10514 E: serde::de::Error,
10515 {
10516 match value {
10517 "tableId" | "table_id" => Ok(GeneratedField::TableId),
10518 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
10519 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
10520 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
10521 "cdcTableDesc" | "cdc_table_desc" => Ok(GeneratedField::CdcTableDesc),
10522 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
10523 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
10524 "options" => Ok(GeneratedField::Options),
10525 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10526 }
10527 }
10528 }
10529 deserializer.deserialize_identifier(GeneratedVisitor)
10530 }
10531 }
10532 struct GeneratedVisitor;
10533 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10534 type Value = StreamCdcScanNode;
10535
10536 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10537 formatter.write_str("struct stream_plan.StreamCdcScanNode")
10538 }
10539
10540 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanNode, V::Error>
10541 where
10542 V: serde::de::MapAccess<'de>,
10543 {
10544 let mut table_id__ = None;
10545 let mut upstream_column_ids__ = None;
10546 let mut output_indices__ = None;
10547 let mut state_table__ = None;
10548 let mut cdc_table_desc__ = None;
10549 let mut rate_limit__ = None;
10550 let mut disable_backfill__ = None;
10551 let mut options__ = None;
10552 while let Some(k) = map_.next_key()? {
10553 match k {
10554 GeneratedField::TableId => {
10555 if table_id__.is_some() {
10556 return Err(serde::de::Error::duplicate_field("tableId"));
10557 }
10558 table_id__ =
10559 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10560 ;
10561 }
10562 GeneratedField::UpstreamColumnIds => {
10563 if upstream_column_ids__.is_some() {
10564 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
10565 }
10566 upstream_column_ids__ =
10567 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10568 .into_iter().map(|x| x.0).collect())
10569 ;
10570 }
10571 GeneratedField::OutputIndices => {
10572 if output_indices__.is_some() {
10573 return Err(serde::de::Error::duplicate_field("outputIndices"));
10574 }
10575 output_indices__ =
10576 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10577 .into_iter().map(|x| x.0).collect())
10578 ;
10579 }
10580 GeneratedField::StateTable => {
10581 if state_table__.is_some() {
10582 return Err(serde::de::Error::duplicate_field("stateTable"));
10583 }
10584 state_table__ = map_.next_value()?;
10585 }
10586 GeneratedField::CdcTableDesc => {
10587 if cdc_table_desc__.is_some() {
10588 return Err(serde::de::Error::duplicate_field("cdcTableDesc"));
10589 }
10590 cdc_table_desc__ = map_.next_value()?;
10591 }
10592 GeneratedField::RateLimit => {
10593 if rate_limit__.is_some() {
10594 return Err(serde::de::Error::duplicate_field("rateLimit"));
10595 }
10596 rate_limit__ =
10597 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10598 ;
10599 }
10600 GeneratedField::DisableBackfill => {
10601 if disable_backfill__.is_some() {
10602 return Err(serde::de::Error::duplicate_field("disableBackfill"));
10603 }
10604 disable_backfill__ = Some(map_.next_value()?);
10605 }
10606 GeneratedField::Options => {
10607 if options__.is_some() {
10608 return Err(serde::de::Error::duplicate_field("options"));
10609 }
10610 options__ = map_.next_value()?;
10611 }
10612 }
10613 }
10614 Ok(StreamCdcScanNode {
10615 table_id: table_id__.unwrap_or_default(),
10616 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
10617 output_indices: output_indices__.unwrap_or_default(),
10618 state_table: state_table__,
10619 cdc_table_desc: cdc_table_desc__,
10620 rate_limit: rate_limit__,
10621 disable_backfill: disable_backfill__.unwrap_or_default(),
10622 options: options__,
10623 })
10624 }
10625 }
10626 deserializer.deserialize_struct("stream_plan.StreamCdcScanNode", FIELDS, GeneratedVisitor)
10627 }
10628}
10629impl serde::Serialize for StreamCdcScanOptions {
10630 #[allow(deprecated)]
10631 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10632 where
10633 S: serde::Serializer,
10634 {
10635 use serde::ser::SerializeStruct;
10636 let mut len = 0;
10637 if self.disable_backfill {
10638 len += 1;
10639 }
10640 if self.snapshot_barrier_interval != 0 {
10641 len += 1;
10642 }
10643 if self.snapshot_batch_size != 0 {
10644 len += 1;
10645 }
10646 if self.backfill_parallelism != 0 {
10647 len += 1;
10648 }
10649 if self.backfill_num_rows_per_split != 0 {
10650 len += 1;
10651 }
10652 if self.backfill_as_even_splits {
10653 len += 1;
10654 }
10655 if self.backfill_split_pk_column_index != 0 {
10656 len += 1;
10657 }
10658 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanOptions", len)?;
10659 if self.disable_backfill {
10660 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
10661 }
10662 if self.snapshot_barrier_interval != 0 {
10663 struct_ser.serialize_field("snapshotBarrierInterval", &self.snapshot_barrier_interval)?;
10664 }
10665 if self.snapshot_batch_size != 0 {
10666 struct_ser.serialize_field("snapshotBatchSize", &self.snapshot_batch_size)?;
10667 }
10668 if self.backfill_parallelism != 0 {
10669 struct_ser.serialize_field("backfillParallelism", &self.backfill_parallelism)?;
10670 }
10671 if self.backfill_num_rows_per_split != 0 {
10672 #[allow(clippy::needless_borrow)]
10673 #[allow(clippy::needless_borrows_for_generic_args)]
10674 struct_ser.serialize_field("backfillNumRowsPerSplit", ToString::to_string(&self.backfill_num_rows_per_split).as_str())?;
10675 }
10676 if self.backfill_as_even_splits {
10677 struct_ser.serialize_field("backfillAsEvenSplits", &self.backfill_as_even_splits)?;
10678 }
10679 if self.backfill_split_pk_column_index != 0 {
10680 struct_ser.serialize_field("backfillSplitPkColumnIndex", &self.backfill_split_pk_column_index)?;
10681 }
10682 struct_ser.end()
10683 }
10684}
10685impl<'de> serde::Deserialize<'de> for StreamCdcScanOptions {
10686 #[allow(deprecated)]
10687 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10688 where
10689 D: serde::Deserializer<'de>,
10690 {
10691 const FIELDS: &[&str] = &[
10692 "disable_backfill",
10693 "disableBackfill",
10694 "snapshot_barrier_interval",
10695 "snapshotBarrierInterval",
10696 "snapshot_batch_size",
10697 "snapshotBatchSize",
10698 "backfill_parallelism",
10699 "backfillParallelism",
10700 "backfill_num_rows_per_split",
10701 "backfillNumRowsPerSplit",
10702 "backfill_as_even_splits",
10703 "backfillAsEvenSplits",
10704 "backfill_split_pk_column_index",
10705 "backfillSplitPkColumnIndex",
10706 ];
10707
10708 #[allow(clippy::enum_variant_names)]
10709 enum GeneratedField {
10710 DisableBackfill,
10711 SnapshotBarrierInterval,
10712 SnapshotBatchSize,
10713 BackfillParallelism,
10714 BackfillNumRowsPerSplit,
10715 BackfillAsEvenSplits,
10716 BackfillSplitPkColumnIndex,
10717 }
10718 impl<'de> serde::Deserialize<'de> for GeneratedField {
10719 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10720 where
10721 D: serde::Deserializer<'de>,
10722 {
10723 struct GeneratedVisitor;
10724
10725 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10726 type Value = GeneratedField;
10727
10728 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10729 write!(formatter, "expected one of: {:?}", &FIELDS)
10730 }
10731
10732 #[allow(unused_variables)]
10733 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10734 where
10735 E: serde::de::Error,
10736 {
10737 match value {
10738 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
10739 "snapshotBarrierInterval" | "snapshot_barrier_interval" => Ok(GeneratedField::SnapshotBarrierInterval),
10740 "snapshotBatchSize" | "snapshot_batch_size" => Ok(GeneratedField::SnapshotBatchSize),
10741 "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
10742 "backfillNumRowsPerSplit" | "backfill_num_rows_per_split" => Ok(GeneratedField::BackfillNumRowsPerSplit),
10743 "backfillAsEvenSplits" | "backfill_as_even_splits" => Ok(GeneratedField::BackfillAsEvenSplits),
10744 "backfillSplitPkColumnIndex" | "backfill_split_pk_column_index" => Ok(GeneratedField::BackfillSplitPkColumnIndex),
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 = StreamCdcScanOptions;
10755
10756 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10757 formatter.write_str("struct stream_plan.StreamCdcScanOptions")
10758 }
10759
10760 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanOptions, V::Error>
10761 where
10762 V: serde::de::MapAccess<'de>,
10763 {
10764 let mut disable_backfill__ = None;
10765 let mut snapshot_barrier_interval__ = None;
10766 let mut snapshot_batch_size__ = None;
10767 let mut backfill_parallelism__ = None;
10768 let mut backfill_num_rows_per_split__ = None;
10769 let mut backfill_as_even_splits__ = None;
10770 let mut backfill_split_pk_column_index__ = None;
10771 while let Some(k) = map_.next_key()? {
10772 match k {
10773 GeneratedField::DisableBackfill => {
10774 if disable_backfill__.is_some() {
10775 return Err(serde::de::Error::duplicate_field("disableBackfill"));
10776 }
10777 disable_backfill__ = Some(map_.next_value()?);
10778 }
10779 GeneratedField::SnapshotBarrierInterval => {
10780 if snapshot_barrier_interval__.is_some() {
10781 return Err(serde::de::Error::duplicate_field("snapshotBarrierInterval"));
10782 }
10783 snapshot_barrier_interval__ =
10784 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10785 ;
10786 }
10787 GeneratedField::SnapshotBatchSize => {
10788 if snapshot_batch_size__.is_some() {
10789 return Err(serde::de::Error::duplicate_field("snapshotBatchSize"));
10790 }
10791 snapshot_batch_size__ =
10792 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10793 ;
10794 }
10795 GeneratedField::BackfillParallelism => {
10796 if backfill_parallelism__.is_some() {
10797 return Err(serde::de::Error::duplicate_field("backfillParallelism"));
10798 }
10799 backfill_parallelism__ =
10800 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10801 ;
10802 }
10803 GeneratedField::BackfillNumRowsPerSplit => {
10804 if backfill_num_rows_per_split__.is_some() {
10805 return Err(serde::de::Error::duplicate_field("backfillNumRowsPerSplit"));
10806 }
10807 backfill_num_rows_per_split__ =
10808 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10809 ;
10810 }
10811 GeneratedField::BackfillAsEvenSplits => {
10812 if backfill_as_even_splits__.is_some() {
10813 return Err(serde::de::Error::duplicate_field("backfillAsEvenSplits"));
10814 }
10815 backfill_as_even_splits__ = Some(map_.next_value()?);
10816 }
10817 GeneratedField::BackfillSplitPkColumnIndex => {
10818 if backfill_split_pk_column_index__.is_some() {
10819 return Err(serde::de::Error::duplicate_field("backfillSplitPkColumnIndex"));
10820 }
10821 backfill_split_pk_column_index__ =
10822 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10823 ;
10824 }
10825 }
10826 }
10827 Ok(StreamCdcScanOptions {
10828 disable_backfill: disable_backfill__.unwrap_or_default(),
10829 snapshot_barrier_interval: snapshot_barrier_interval__.unwrap_or_default(),
10830 snapshot_batch_size: snapshot_batch_size__.unwrap_or_default(),
10831 backfill_parallelism: backfill_parallelism__.unwrap_or_default(),
10832 backfill_num_rows_per_split: backfill_num_rows_per_split__.unwrap_or_default(),
10833 backfill_as_even_splits: backfill_as_even_splits__.unwrap_or_default(),
10834 backfill_split_pk_column_index: backfill_split_pk_column_index__.unwrap_or_default(),
10835 })
10836 }
10837 }
10838 deserializer.deserialize_struct("stream_plan.StreamCdcScanOptions", FIELDS, GeneratedVisitor)
10839 }
10840}
10841impl serde::Serialize for StreamContext {
10842 #[allow(deprecated)]
10843 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10844 where
10845 S: serde::Serializer,
10846 {
10847 use serde::ser::SerializeStruct;
10848 let mut len = 0;
10849 if !self.timezone.is_empty() {
10850 len += 1;
10851 }
10852 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamContext", len)?;
10853 if !self.timezone.is_empty() {
10854 struct_ser.serialize_field("timezone", &self.timezone)?;
10855 }
10856 struct_ser.end()
10857 }
10858}
10859impl<'de> serde::Deserialize<'de> for StreamContext {
10860 #[allow(deprecated)]
10861 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10862 where
10863 D: serde::Deserializer<'de>,
10864 {
10865 const FIELDS: &[&str] = &[
10866 "timezone",
10867 ];
10868
10869 #[allow(clippy::enum_variant_names)]
10870 enum GeneratedField {
10871 Timezone,
10872 }
10873 impl<'de> serde::Deserialize<'de> for GeneratedField {
10874 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10875 where
10876 D: serde::Deserializer<'de>,
10877 {
10878 struct GeneratedVisitor;
10879
10880 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10881 type Value = GeneratedField;
10882
10883 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10884 write!(formatter, "expected one of: {:?}", &FIELDS)
10885 }
10886
10887 #[allow(unused_variables)]
10888 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10889 where
10890 E: serde::de::Error,
10891 {
10892 match value {
10893 "timezone" => Ok(GeneratedField::Timezone),
10894 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10895 }
10896 }
10897 }
10898 deserializer.deserialize_identifier(GeneratedVisitor)
10899 }
10900 }
10901 struct GeneratedVisitor;
10902 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10903 type Value = StreamContext;
10904
10905 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10906 formatter.write_str("struct stream_plan.StreamContext")
10907 }
10908
10909 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamContext, V::Error>
10910 where
10911 V: serde::de::MapAccess<'de>,
10912 {
10913 let mut timezone__ = None;
10914 while let Some(k) = map_.next_key()? {
10915 match k {
10916 GeneratedField::Timezone => {
10917 if timezone__.is_some() {
10918 return Err(serde::de::Error::duplicate_field("timezone"));
10919 }
10920 timezone__ = Some(map_.next_value()?);
10921 }
10922 }
10923 }
10924 Ok(StreamContext {
10925 timezone: timezone__.unwrap_or_default(),
10926 })
10927 }
10928 }
10929 deserializer.deserialize_struct("stream_plan.StreamContext", FIELDS, GeneratedVisitor)
10930 }
10931}
10932impl serde::Serialize for StreamFragmentGraph {
10933 #[allow(deprecated)]
10934 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10935 where
10936 S: serde::Serializer,
10937 {
10938 use serde::ser::SerializeStruct;
10939 let mut len = 0;
10940 if !self.fragments.is_empty() {
10941 len += 1;
10942 }
10943 if !self.edges.is_empty() {
10944 len += 1;
10945 }
10946 if !self.dependent_table_ids.is_empty() {
10947 len += 1;
10948 }
10949 if self.table_ids_cnt != 0 {
10950 len += 1;
10951 }
10952 if self.ctx.is_some() {
10953 len += 1;
10954 }
10955 if self.parallelism.is_some() {
10956 len += 1;
10957 }
10958 if self.max_parallelism != 0 {
10959 len += 1;
10960 }
10961 if self.backfill_order.is_some() {
10962 len += 1;
10963 }
10964 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph", len)?;
10965 if !self.fragments.is_empty() {
10966 struct_ser.serialize_field("fragments", &self.fragments)?;
10967 }
10968 if !self.edges.is_empty() {
10969 struct_ser.serialize_field("edges", &self.edges)?;
10970 }
10971 if !self.dependent_table_ids.is_empty() {
10972 struct_ser.serialize_field("dependentTableIds", &self.dependent_table_ids)?;
10973 }
10974 if self.table_ids_cnt != 0 {
10975 struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
10976 }
10977 if let Some(v) = self.ctx.as_ref() {
10978 struct_ser.serialize_field("ctx", v)?;
10979 }
10980 if let Some(v) = self.parallelism.as_ref() {
10981 struct_ser.serialize_field("parallelism", v)?;
10982 }
10983 if self.max_parallelism != 0 {
10984 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
10985 }
10986 if let Some(v) = self.backfill_order.as_ref() {
10987 struct_ser.serialize_field("backfillOrder", v)?;
10988 }
10989 struct_ser.end()
10990 }
10991}
10992impl<'de> serde::Deserialize<'de> for StreamFragmentGraph {
10993 #[allow(deprecated)]
10994 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10995 where
10996 D: serde::Deserializer<'de>,
10997 {
10998 const FIELDS: &[&str] = &[
10999 "fragments",
11000 "edges",
11001 "dependent_table_ids",
11002 "dependentTableIds",
11003 "table_ids_cnt",
11004 "tableIdsCnt",
11005 "ctx",
11006 "parallelism",
11007 "max_parallelism",
11008 "maxParallelism",
11009 "backfill_order",
11010 "backfillOrder",
11011 ];
11012
11013 #[allow(clippy::enum_variant_names)]
11014 enum GeneratedField {
11015 Fragments,
11016 Edges,
11017 DependentTableIds,
11018 TableIdsCnt,
11019 Ctx,
11020 Parallelism,
11021 MaxParallelism,
11022 BackfillOrder,
11023 }
11024 impl<'de> serde::Deserialize<'de> for GeneratedField {
11025 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11026 where
11027 D: serde::Deserializer<'de>,
11028 {
11029 struct GeneratedVisitor;
11030
11031 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11032 type Value = GeneratedField;
11033
11034 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11035 write!(formatter, "expected one of: {:?}", &FIELDS)
11036 }
11037
11038 #[allow(unused_variables)]
11039 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11040 where
11041 E: serde::de::Error,
11042 {
11043 match value {
11044 "fragments" => Ok(GeneratedField::Fragments),
11045 "edges" => Ok(GeneratedField::Edges),
11046 "dependentTableIds" | "dependent_table_ids" => Ok(GeneratedField::DependentTableIds),
11047 "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
11048 "ctx" => Ok(GeneratedField::Ctx),
11049 "parallelism" => Ok(GeneratedField::Parallelism),
11050 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
11051 "backfillOrder" | "backfill_order" => Ok(GeneratedField::BackfillOrder),
11052 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11053 }
11054 }
11055 }
11056 deserializer.deserialize_identifier(GeneratedVisitor)
11057 }
11058 }
11059 struct GeneratedVisitor;
11060 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11061 type Value = StreamFragmentGraph;
11062
11063 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11064 formatter.write_str("struct stream_plan.StreamFragmentGraph")
11065 }
11066
11067 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFragmentGraph, V::Error>
11068 where
11069 V: serde::de::MapAccess<'de>,
11070 {
11071 let mut fragments__ = None;
11072 let mut edges__ = None;
11073 let mut dependent_table_ids__ = None;
11074 let mut table_ids_cnt__ = None;
11075 let mut ctx__ = None;
11076 let mut parallelism__ = None;
11077 let mut max_parallelism__ = None;
11078 let mut backfill_order__ = None;
11079 while let Some(k) = map_.next_key()? {
11080 match k {
11081 GeneratedField::Fragments => {
11082 if fragments__.is_some() {
11083 return Err(serde::de::Error::duplicate_field("fragments"));
11084 }
11085 fragments__ = Some(
11086 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11087 .into_iter().map(|(k,v)| (k.0, v)).collect()
11088 );
11089 }
11090 GeneratedField::Edges => {
11091 if edges__.is_some() {
11092 return Err(serde::de::Error::duplicate_field("edges"));
11093 }
11094 edges__ = Some(map_.next_value()?);
11095 }
11096 GeneratedField::DependentTableIds => {
11097 if dependent_table_ids__.is_some() {
11098 return Err(serde::de::Error::duplicate_field("dependentTableIds"));
11099 }
11100 dependent_table_ids__ =
11101 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11102 .into_iter().map(|x| x.0).collect())
11103 ;
11104 }
11105 GeneratedField::TableIdsCnt => {
11106 if table_ids_cnt__.is_some() {
11107 return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
11108 }
11109 table_ids_cnt__ =
11110 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11111 ;
11112 }
11113 GeneratedField::Ctx => {
11114 if ctx__.is_some() {
11115 return Err(serde::de::Error::duplicate_field("ctx"));
11116 }
11117 ctx__ = map_.next_value()?;
11118 }
11119 GeneratedField::Parallelism => {
11120 if parallelism__.is_some() {
11121 return Err(serde::de::Error::duplicate_field("parallelism"));
11122 }
11123 parallelism__ = map_.next_value()?;
11124 }
11125 GeneratedField::MaxParallelism => {
11126 if max_parallelism__.is_some() {
11127 return Err(serde::de::Error::duplicate_field("maxParallelism"));
11128 }
11129 max_parallelism__ =
11130 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11131 ;
11132 }
11133 GeneratedField::BackfillOrder => {
11134 if backfill_order__.is_some() {
11135 return Err(serde::de::Error::duplicate_field("backfillOrder"));
11136 }
11137 backfill_order__ = map_.next_value()?;
11138 }
11139 }
11140 }
11141 Ok(StreamFragmentGraph {
11142 fragments: fragments__.unwrap_or_default(),
11143 edges: edges__.unwrap_or_default(),
11144 dependent_table_ids: dependent_table_ids__.unwrap_or_default(),
11145 table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
11146 ctx: ctx__,
11147 parallelism: parallelism__,
11148 max_parallelism: max_parallelism__.unwrap_or_default(),
11149 backfill_order: backfill_order__,
11150 })
11151 }
11152 }
11153 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph", FIELDS, GeneratedVisitor)
11154 }
11155}
11156impl serde::Serialize for stream_fragment_graph::Parallelism {
11157 #[allow(deprecated)]
11158 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11159 where
11160 S: serde::Serializer,
11161 {
11162 use serde::ser::SerializeStruct;
11163 let mut len = 0;
11164 if self.parallelism != 0 {
11165 len += 1;
11166 }
11167 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.Parallelism", len)?;
11168 if self.parallelism != 0 {
11169 #[allow(clippy::needless_borrow)]
11170 #[allow(clippy::needless_borrows_for_generic_args)]
11171 struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
11172 }
11173 struct_ser.end()
11174 }
11175}
11176impl<'de> serde::Deserialize<'de> for stream_fragment_graph::Parallelism {
11177 #[allow(deprecated)]
11178 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11179 where
11180 D: serde::Deserializer<'de>,
11181 {
11182 const FIELDS: &[&str] = &[
11183 "parallelism",
11184 ];
11185
11186 #[allow(clippy::enum_variant_names)]
11187 enum GeneratedField {
11188 Parallelism,
11189 }
11190 impl<'de> serde::Deserialize<'de> for GeneratedField {
11191 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11192 where
11193 D: serde::Deserializer<'de>,
11194 {
11195 struct GeneratedVisitor;
11196
11197 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11198 type Value = GeneratedField;
11199
11200 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11201 write!(formatter, "expected one of: {:?}", &FIELDS)
11202 }
11203
11204 #[allow(unused_variables)]
11205 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11206 where
11207 E: serde::de::Error,
11208 {
11209 match value {
11210 "parallelism" => Ok(GeneratedField::Parallelism),
11211 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11212 }
11213 }
11214 }
11215 deserializer.deserialize_identifier(GeneratedVisitor)
11216 }
11217 }
11218 struct GeneratedVisitor;
11219 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11220 type Value = stream_fragment_graph::Parallelism;
11221
11222 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11223 formatter.write_str("struct stream_plan.StreamFragmentGraph.Parallelism")
11224 }
11225
11226 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::Parallelism, V::Error>
11227 where
11228 V: serde::de::MapAccess<'de>,
11229 {
11230 let mut parallelism__ = None;
11231 while let Some(k) = map_.next_key()? {
11232 match k {
11233 GeneratedField::Parallelism => {
11234 if parallelism__.is_some() {
11235 return Err(serde::de::Error::duplicate_field("parallelism"));
11236 }
11237 parallelism__ =
11238 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11239 ;
11240 }
11241 }
11242 }
11243 Ok(stream_fragment_graph::Parallelism {
11244 parallelism: parallelism__.unwrap_or_default(),
11245 })
11246 }
11247 }
11248 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.Parallelism", FIELDS, GeneratedVisitor)
11249 }
11250}
11251impl serde::Serialize for stream_fragment_graph::StreamFragment {
11252 #[allow(deprecated)]
11253 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11254 where
11255 S: serde::Serializer,
11256 {
11257 use serde::ser::SerializeStruct;
11258 let mut len = 0;
11259 if self.fragment_id != 0 {
11260 len += 1;
11261 }
11262 if self.node.is_some() {
11263 len += 1;
11264 }
11265 if self.fragment_type_mask != 0 {
11266 len += 1;
11267 }
11268 if self.requires_singleton {
11269 len += 1;
11270 }
11271 if self.table_ids_cnt != 0 {
11272 len += 1;
11273 }
11274 if !self.upstream_table_ids.is_empty() {
11275 len += 1;
11276 }
11277 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", len)?;
11278 if self.fragment_id != 0 {
11279 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
11280 }
11281 if let Some(v) = self.node.as_ref() {
11282 struct_ser.serialize_field("node", v)?;
11283 }
11284 if self.fragment_type_mask != 0 {
11285 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
11286 }
11287 if self.requires_singleton {
11288 struct_ser.serialize_field("requiresSingleton", &self.requires_singleton)?;
11289 }
11290 if self.table_ids_cnt != 0 {
11291 struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
11292 }
11293 if !self.upstream_table_ids.is_empty() {
11294 struct_ser.serialize_field("upstreamTableIds", &self.upstream_table_ids)?;
11295 }
11296 struct_ser.end()
11297 }
11298}
11299impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragment {
11300 #[allow(deprecated)]
11301 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11302 where
11303 D: serde::Deserializer<'de>,
11304 {
11305 const FIELDS: &[&str] = &[
11306 "fragment_id",
11307 "fragmentId",
11308 "node",
11309 "fragment_type_mask",
11310 "fragmentTypeMask",
11311 "requires_singleton",
11312 "requiresSingleton",
11313 "table_ids_cnt",
11314 "tableIdsCnt",
11315 "upstream_table_ids",
11316 "upstreamTableIds",
11317 ];
11318
11319 #[allow(clippy::enum_variant_names)]
11320 enum GeneratedField {
11321 FragmentId,
11322 Node,
11323 FragmentTypeMask,
11324 RequiresSingleton,
11325 TableIdsCnt,
11326 UpstreamTableIds,
11327 }
11328 impl<'de> serde::Deserialize<'de> for GeneratedField {
11329 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11330 where
11331 D: serde::Deserializer<'de>,
11332 {
11333 struct GeneratedVisitor;
11334
11335 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11336 type Value = GeneratedField;
11337
11338 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11339 write!(formatter, "expected one of: {:?}", &FIELDS)
11340 }
11341
11342 #[allow(unused_variables)]
11343 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11344 where
11345 E: serde::de::Error,
11346 {
11347 match value {
11348 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
11349 "node" => Ok(GeneratedField::Node),
11350 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
11351 "requiresSingleton" | "requires_singleton" => Ok(GeneratedField::RequiresSingleton),
11352 "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
11353 "upstreamTableIds" | "upstream_table_ids" => Ok(GeneratedField::UpstreamTableIds),
11354 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11355 }
11356 }
11357 }
11358 deserializer.deserialize_identifier(GeneratedVisitor)
11359 }
11360 }
11361 struct GeneratedVisitor;
11362 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11363 type Value = stream_fragment_graph::StreamFragment;
11364
11365 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11366 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragment")
11367 }
11368
11369 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragment, V::Error>
11370 where
11371 V: serde::de::MapAccess<'de>,
11372 {
11373 let mut fragment_id__ = None;
11374 let mut node__ = None;
11375 let mut fragment_type_mask__ = None;
11376 let mut requires_singleton__ = None;
11377 let mut table_ids_cnt__ = None;
11378 let mut upstream_table_ids__ = None;
11379 while let Some(k) = map_.next_key()? {
11380 match k {
11381 GeneratedField::FragmentId => {
11382 if fragment_id__.is_some() {
11383 return Err(serde::de::Error::duplicate_field("fragmentId"));
11384 }
11385 fragment_id__ =
11386 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11387 ;
11388 }
11389 GeneratedField::Node => {
11390 if node__.is_some() {
11391 return Err(serde::de::Error::duplicate_field("node"));
11392 }
11393 node__ = map_.next_value()?;
11394 }
11395 GeneratedField::FragmentTypeMask => {
11396 if fragment_type_mask__.is_some() {
11397 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
11398 }
11399 fragment_type_mask__ =
11400 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11401 ;
11402 }
11403 GeneratedField::RequiresSingleton => {
11404 if requires_singleton__.is_some() {
11405 return Err(serde::de::Error::duplicate_field("requiresSingleton"));
11406 }
11407 requires_singleton__ = Some(map_.next_value()?);
11408 }
11409 GeneratedField::TableIdsCnt => {
11410 if table_ids_cnt__.is_some() {
11411 return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
11412 }
11413 table_ids_cnt__ =
11414 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11415 ;
11416 }
11417 GeneratedField::UpstreamTableIds => {
11418 if upstream_table_ids__.is_some() {
11419 return Err(serde::de::Error::duplicate_field("upstreamTableIds"));
11420 }
11421 upstream_table_ids__ =
11422 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11423 .into_iter().map(|x| x.0).collect())
11424 ;
11425 }
11426 }
11427 }
11428 Ok(stream_fragment_graph::StreamFragment {
11429 fragment_id: fragment_id__.unwrap_or_default(),
11430 node: node__,
11431 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
11432 requires_singleton: requires_singleton__.unwrap_or_default(),
11433 table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
11434 upstream_table_ids: upstream_table_ids__.unwrap_or_default(),
11435 })
11436 }
11437 }
11438 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", FIELDS, GeneratedVisitor)
11439 }
11440}
11441impl serde::Serialize for stream_fragment_graph::StreamFragmentEdge {
11442 #[allow(deprecated)]
11443 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11444 where
11445 S: serde::Serializer,
11446 {
11447 use serde::ser::SerializeStruct;
11448 let mut len = 0;
11449 if self.dispatch_strategy.is_some() {
11450 len += 1;
11451 }
11452 if self.link_id != 0 {
11453 len += 1;
11454 }
11455 if self.upstream_id != 0 {
11456 len += 1;
11457 }
11458 if self.downstream_id != 0 {
11459 len += 1;
11460 }
11461 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", len)?;
11462 if let Some(v) = self.dispatch_strategy.as_ref() {
11463 struct_ser.serialize_field("dispatchStrategy", v)?;
11464 }
11465 if self.link_id != 0 {
11466 #[allow(clippy::needless_borrow)]
11467 #[allow(clippy::needless_borrows_for_generic_args)]
11468 struct_ser.serialize_field("linkId", ToString::to_string(&self.link_id).as_str())?;
11469 }
11470 if self.upstream_id != 0 {
11471 struct_ser.serialize_field("upstreamId", &self.upstream_id)?;
11472 }
11473 if self.downstream_id != 0 {
11474 struct_ser.serialize_field("downstreamId", &self.downstream_id)?;
11475 }
11476 struct_ser.end()
11477 }
11478}
11479impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragmentEdge {
11480 #[allow(deprecated)]
11481 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11482 where
11483 D: serde::Deserializer<'de>,
11484 {
11485 const FIELDS: &[&str] = &[
11486 "dispatch_strategy",
11487 "dispatchStrategy",
11488 "link_id",
11489 "linkId",
11490 "upstream_id",
11491 "upstreamId",
11492 "downstream_id",
11493 "downstreamId",
11494 ];
11495
11496 #[allow(clippy::enum_variant_names)]
11497 enum GeneratedField {
11498 DispatchStrategy,
11499 LinkId,
11500 UpstreamId,
11501 DownstreamId,
11502 }
11503 impl<'de> serde::Deserialize<'de> for GeneratedField {
11504 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11505 where
11506 D: serde::Deserializer<'de>,
11507 {
11508 struct GeneratedVisitor;
11509
11510 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11511 type Value = GeneratedField;
11512
11513 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11514 write!(formatter, "expected one of: {:?}", &FIELDS)
11515 }
11516
11517 #[allow(unused_variables)]
11518 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11519 where
11520 E: serde::de::Error,
11521 {
11522 match value {
11523 "dispatchStrategy" | "dispatch_strategy" => Ok(GeneratedField::DispatchStrategy),
11524 "linkId" | "link_id" => Ok(GeneratedField::LinkId),
11525 "upstreamId" | "upstream_id" => Ok(GeneratedField::UpstreamId),
11526 "downstreamId" | "downstream_id" => Ok(GeneratedField::DownstreamId),
11527 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11528 }
11529 }
11530 }
11531 deserializer.deserialize_identifier(GeneratedVisitor)
11532 }
11533 }
11534 struct GeneratedVisitor;
11535 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11536 type Value = stream_fragment_graph::StreamFragmentEdge;
11537
11538 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11539 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragmentEdge")
11540 }
11541
11542 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragmentEdge, V::Error>
11543 where
11544 V: serde::de::MapAccess<'de>,
11545 {
11546 let mut dispatch_strategy__ = None;
11547 let mut link_id__ = None;
11548 let mut upstream_id__ = None;
11549 let mut downstream_id__ = None;
11550 while let Some(k) = map_.next_key()? {
11551 match k {
11552 GeneratedField::DispatchStrategy => {
11553 if dispatch_strategy__.is_some() {
11554 return Err(serde::de::Error::duplicate_field("dispatchStrategy"));
11555 }
11556 dispatch_strategy__ = map_.next_value()?;
11557 }
11558 GeneratedField::LinkId => {
11559 if link_id__.is_some() {
11560 return Err(serde::de::Error::duplicate_field("linkId"));
11561 }
11562 link_id__ =
11563 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11564 ;
11565 }
11566 GeneratedField::UpstreamId => {
11567 if upstream_id__.is_some() {
11568 return Err(serde::de::Error::duplicate_field("upstreamId"));
11569 }
11570 upstream_id__ =
11571 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11572 ;
11573 }
11574 GeneratedField::DownstreamId => {
11575 if downstream_id__.is_some() {
11576 return Err(serde::de::Error::duplicate_field("downstreamId"));
11577 }
11578 downstream_id__ =
11579 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11580 ;
11581 }
11582 }
11583 }
11584 Ok(stream_fragment_graph::StreamFragmentEdge {
11585 dispatch_strategy: dispatch_strategy__,
11586 link_id: link_id__.unwrap_or_default(),
11587 upstream_id: upstream_id__.unwrap_or_default(),
11588 downstream_id: downstream_id__.unwrap_or_default(),
11589 })
11590 }
11591 }
11592 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", FIELDS, GeneratedVisitor)
11593 }
11594}
11595impl serde::Serialize for StreamFsFetch {
11596 #[allow(deprecated)]
11597 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11598 where
11599 S: serde::Serializer,
11600 {
11601 use serde::ser::SerializeStruct;
11602 let mut len = 0;
11603 if self.source_id != 0 {
11604 len += 1;
11605 }
11606 if self.state_table.is_some() {
11607 len += 1;
11608 }
11609 if self.row_id_index.is_some() {
11610 len += 1;
11611 }
11612 if !self.columns.is_empty() {
11613 len += 1;
11614 }
11615 if !self.with_properties.is_empty() {
11616 len += 1;
11617 }
11618 if self.info.is_some() {
11619 len += 1;
11620 }
11621 if !self.source_name.is_empty() {
11622 len += 1;
11623 }
11624 if self.rate_limit.is_some() {
11625 len += 1;
11626 }
11627 if !self.secret_refs.is_empty() {
11628 len += 1;
11629 }
11630 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetch", len)?;
11631 if self.source_id != 0 {
11632 struct_ser.serialize_field("sourceId", &self.source_id)?;
11633 }
11634 if let Some(v) = self.state_table.as_ref() {
11635 struct_ser.serialize_field("stateTable", v)?;
11636 }
11637 if let Some(v) = self.row_id_index.as_ref() {
11638 struct_ser.serialize_field("rowIdIndex", v)?;
11639 }
11640 if !self.columns.is_empty() {
11641 struct_ser.serialize_field("columns", &self.columns)?;
11642 }
11643 if !self.with_properties.is_empty() {
11644 struct_ser.serialize_field("withProperties", &self.with_properties)?;
11645 }
11646 if let Some(v) = self.info.as_ref() {
11647 struct_ser.serialize_field("info", v)?;
11648 }
11649 if !self.source_name.is_empty() {
11650 struct_ser.serialize_field("sourceName", &self.source_name)?;
11651 }
11652 if let Some(v) = self.rate_limit.as_ref() {
11653 struct_ser.serialize_field("rateLimit", v)?;
11654 }
11655 if !self.secret_refs.is_empty() {
11656 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
11657 }
11658 struct_ser.end()
11659 }
11660}
11661impl<'de> serde::Deserialize<'de> for StreamFsFetch {
11662 #[allow(deprecated)]
11663 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11664 where
11665 D: serde::Deserializer<'de>,
11666 {
11667 const FIELDS: &[&str] = &[
11668 "source_id",
11669 "sourceId",
11670 "state_table",
11671 "stateTable",
11672 "row_id_index",
11673 "rowIdIndex",
11674 "columns",
11675 "with_properties",
11676 "withProperties",
11677 "info",
11678 "source_name",
11679 "sourceName",
11680 "rate_limit",
11681 "rateLimit",
11682 "secret_refs",
11683 "secretRefs",
11684 ];
11685
11686 #[allow(clippy::enum_variant_names)]
11687 enum GeneratedField {
11688 SourceId,
11689 StateTable,
11690 RowIdIndex,
11691 Columns,
11692 WithProperties,
11693 Info,
11694 SourceName,
11695 RateLimit,
11696 SecretRefs,
11697 }
11698 impl<'de> serde::Deserialize<'de> for GeneratedField {
11699 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11700 where
11701 D: serde::Deserializer<'de>,
11702 {
11703 struct GeneratedVisitor;
11704
11705 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11706 type Value = GeneratedField;
11707
11708 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11709 write!(formatter, "expected one of: {:?}", &FIELDS)
11710 }
11711
11712 #[allow(unused_variables)]
11713 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11714 where
11715 E: serde::de::Error,
11716 {
11717 match value {
11718 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
11719 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11720 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
11721 "columns" => Ok(GeneratedField::Columns),
11722 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
11723 "info" => Ok(GeneratedField::Info),
11724 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
11725 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11726 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
11727 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11728 }
11729 }
11730 }
11731 deserializer.deserialize_identifier(GeneratedVisitor)
11732 }
11733 }
11734 struct GeneratedVisitor;
11735 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11736 type Value = StreamFsFetch;
11737
11738 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11739 formatter.write_str("struct stream_plan.StreamFsFetch")
11740 }
11741
11742 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetch, V::Error>
11743 where
11744 V: serde::de::MapAccess<'de>,
11745 {
11746 let mut source_id__ = None;
11747 let mut state_table__ = None;
11748 let mut row_id_index__ = None;
11749 let mut columns__ = None;
11750 let mut with_properties__ = None;
11751 let mut info__ = None;
11752 let mut source_name__ = None;
11753 let mut rate_limit__ = None;
11754 let mut secret_refs__ = None;
11755 while let Some(k) = map_.next_key()? {
11756 match k {
11757 GeneratedField::SourceId => {
11758 if source_id__.is_some() {
11759 return Err(serde::de::Error::duplicate_field("sourceId"));
11760 }
11761 source_id__ =
11762 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11763 ;
11764 }
11765 GeneratedField::StateTable => {
11766 if state_table__.is_some() {
11767 return Err(serde::de::Error::duplicate_field("stateTable"));
11768 }
11769 state_table__ = map_.next_value()?;
11770 }
11771 GeneratedField::RowIdIndex => {
11772 if row_id_index__.is_some() {
11773 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
11774 }
11775 row_id_index__ =
11776 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11777 ;
11778 }
11779 GeneratedField::Columns => {
11780 if columns__.is_some() {
11781 return Err(serde::de::Error::duplicate_field("columns"));
11782 }
11783 columns__ = Some(map_.next_value()?);
11784 }
11785 GeneratedField::WithProperties => {
11786 if with_properties__.is_some() {
11787 return Err(serde::de::Error::duplicate_field("withProperties"));
11788 }
11789 with_properties__ = Some(
11790 map_.next_value::<std::collections::BTreeMap<_, _>>()?
11791 );
11792 }
11793 GeneratedField::Info => {
11794 if info__.is_some() {
11795 return Err(serde::de::Error::duplicate_field("info"));
11796 }
11797 info__ = map_.next_value()?;
11798 }
11799 GeneratedField::SourceName => {
11800 if source_name__.is_some() {
11801 return Err(serde::de::Error::duplicate_field("sourceName"));
11802 }
11803 source_name__ = Some(map_.next_value()?);
11804 }
11805 GeneratedField::RateLimit => {
11806 if rate_limit__.is_some() {
11807 return Err(serde::de::Error::duplicate_field("rateLimit"));
11808 }
11809 rate_limit__ =
11810 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11811 ;
11812 }
11813 GeneratedField::SecretRefs => {
11814 if secret_refs__.is_some() {
11815 return Err(serde::de::Error::duplicate_field("secretRefs"));
11816 }
11817 secret_refs__ = Some(
11818 map_.next_value::<std::collections::BTreeMap<_, _>>()?
11819 );
11820 }
11821 }
11822 }
11823 Ok(StreamFsFetch {
11824 source_id: source_id__.unwrap_or_default(),
11825 state_table: state_table__,
11826 row_id_index: row_id_index__,
11827 columns: columns__.unwrap_or_default(),
11828 with_properties: with_properties__.unwrap_or_default(),
11829 info: info__,
11830 source_name: source_name__.unwrap_or_default(),
11831 rate_limit: rate_limit__,
11832 secret_refs: secret_refs__.unwrap_or_default(),
11833 })
11834 }
11835 }
11836 deserializer.deserialize_struct("stream_plan.StreamFsFetch", FIELDS, GeneratedVisitor)
11837 }
11838}
11839impl serde::Serialize for StreamFsFetchNode {
11840 #[allow(deprecated)]
11841 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11842 where
11843 S: serde::Serializer,
11844 {
11845 use serde::ser::SerializeStruct;
11846 let mut len = 0;
11847 if self.node_inner.is_some() {
11848 len += 1;
11849 }
11850 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetchNode", len)?;
11851 if let Some(v) = self.node_inner.as_ref() {
11852 struct_ser.serialize_field("nodeInner", v)?;
11853 }
11854 struct_ser.end()
11855 }
11856}
11857impl<'de> serde::Deserialize<'de> for StreamFsFetchNode {
11858 #[allow(deprecated)]
11859 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11860 where
11861 D: serde::Deserializer<'de>,
11862 {
11863 const FIELDS: &[&str] = &[
11864 "node_inner",
11865 "nodeInner",
11866 ];
11867
11868 #[allow(clippy::enum_variant_names)]
11869 enum GeneratedField {
11870 NodeInner,
11871 }
11872 impl<'de> serde::Deserialize<'de> for GeneratedField {
11873 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11874 where
11875 D: serde::Deserializer<'de>,
11876 {
11877 struct GeneratedVisitor;
11878
11879 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11880 type Value = GeneratedField;
11881
11882 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11883 write!(formatter, "expected one of: {:?}", &FIELDS)
11884 }
11885
11886 #[allow(unused_variables)]
11887 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11888 where
11889 E: serde::de::Error,
11890 {
11891 match value {
11892 "nodeInner" | "node_inner" => Ok(GeneratedField::NodeInner),
11893 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11894 }
11895 }
11896 }
11897 deserializer.deserialize_identifier(GeneratedVisitor)
11898 }
11899 }
11900 struct GeneratedVisitor;
11901 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11902 type Value = StreamFsFetchNode;
11903
11904 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11905 formatter.write_str("struct stream_plan.StreamFsFetchNode")
11906 }
11907
11908 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetchNode, V::Error>
11909 where
11910 V: serde::de::MapAccess<'de>,
11911 {
11912 let mut node_inner__ = None;
11913 while let Some(k) = map_.next_key()? {
11914 match k {
11915 GeneratedField::NodeInner => {
11916 if node_inner__.is_some() {
11917 return Err(serde::de::Error::duplicate_field("nodeInner"));
11918 }
11919 node_inner__ = map_.next_value()?;
11920 }
11921 }
11922 }
11923 Ok(StreamFsFetchNode {
11924 node_inner: node_inner__,
11925 })
11926 }
11927 }
11928 deserializer.deserialize_struct("stream_plan.StreamFsFetchNode", FIELDS, GeneratedVisitor)
11929 }
11930}
11931impl serde::Serialize for StreamMessage {
11932 #[allow(deprecated)]
11933 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11934 where
11935 S: serde::Serializer,
11936 {
11937 use serde::ser::SerializeStruct;
11938 let mut len = 0;
11939 if self.stream_message.is_some() {
11940 len += 1;
11941 }
11942 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessage", len)?;
11943 if let Some(v) = self.stream_message.as_ref() {
11944 match v {
11945 stream_message::StreamMessage::StreamChunk(v) => {
11946 struct_ser.serialize_field("streamChunk", v)?;
11947 }
11948 stream_message::StreamMessage::Barrier(v) => {
11949 struct_ser.serialize_field("barrier", v)?;
11950 }
11951 stream_message::StreamMessage::Watermark(v) => {
11952 struct_ser.serialize_field("watermark", v)?;
11953 }
11954 }
11955 }
11956 struct_ser.end()
11957 }
11958}
11959impl<'de> serde::Deserialize<'de> for StreamMessage {
11960 #[allow(deprecated)]
11961 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11962 where
11963 D: serde::Deserializer<'de>,
11964 {
11965 const FIELDS: &[&str] = &[
11966 "stream_chunk",
11967 "streamChunk",
11968 "barrier",
11969 "watermark",
11970 ];
11971
11972 #[allow(clippy::enum_variant_names)]
11973 enum GeneratedField {
11974 StreamChunk,
11975 Barrier,
11976 Watermark,
11977 }
11978 impl<'de> serde::Deserialize<'de> for GeneratedField {
11979 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11980 where
11981 D: serde::Deserializer<'de>,
11982 {
11983 struct GeneratedVisitor;
11984
11985 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11986 type Value = GeneratedField;
11987
11988 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11989 write!(formatter, "expected one of: {:?}", &FIELDS)
11990 }
11991
11992 #[allow(unused_variables)]
11993 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11994 where
11995 E: serde::de::Error,
11996 {
11997 match value {
11998 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
11999 "barrier" => Ok(GeneratedField::Barrier),
12000 "watermark" => Ok(GeneratedField::Watermark),
12001 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12002 }
12003 }
12004 }
12005 deserializer.deserialize_identifier(GeneratedVisitor)
12006 }
12007 }
12008 struct GeneratedVisitor;
12009 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12010 type Value = StreamMessage;
12011
12012 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12013 formatter.write_str("struct stream_plan.StreamMessage")
12014 }
12015
12016 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessage, V::Error>
12017 where
12018 V: serde::de::MapAccess<'de>,
12019 {
12020 let mut stream_message__ = None;
12021 while let Some(k) = map_.next_key()? {
12022 match k {
12023 GeneratedField::StreamChunk => {
12024 if stream_message__.is_some() {
12025 return Err(serde::de::Error::duplicate_field("streamChunk"));
12026 }
12027 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::StreamChunk)
12028;
12029 }
12030 GeneratedField::Barrier => {
12031 if stream_message__.is_some() {
12032 return Err(serde::de::Error::duplicate_field("barrier"));
12033 }
12034 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Barrier)
12035;
12036 }
12037 GeneratedField::Watermark => {
12038 if stream_message__.is_some() {
12039 return Err(serde::de::Error::duplicate_field("watermark"));
12040 }
12041 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Watermark)
12042;
12043 }
12044 }
12045 }
12046 Ok(StreamMessage {
12047 stream_message: stream_message__,
12048 })
12049 }
12050 }
12051 deserializer.deserialize_struct("stream_plan.StreamMessage", FIELDS, GeneratedVisitor)
12052 }
12053}
12054impl serde::Serialize for StreamMessageBatch {
12055 #[allow(deprecated)]
12056 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12057 where
12058 S: serde::Serializer,
12059 {
12060 use serde::ser::SerializeStruct;
12061 let mut len = 0;
12062 if self.stream_message_batch.is_some() {
12063 len += 1;
12064 }
12065 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch", len)?;
12066 if let Some(v) = self.stream_message_batch.as_ref() {
12067 match v {
12068 stream_message_batch::StreamMessageBatch::StreamChunk(v) => {
12069 struct_ser.serialize_field("streamChunk", v)?;
12070 }
12071 stream_message_batch::StreamMessageBatch::BarrierBatch(v) => {
12072 struct_ser.serialize_field("barrierBatch", v)?;
12073 }
12074 stream_message_batch::StreamMessageBatch::Watermark(v) => {
12075 struct_ser.serialize_field("watermark", v)?;
12076 }
12077 }
12078 }
12079 struct_ser.end()
12080 }
12081}
12082impl<'de> serde::Deserialize<'de> for StreamMessageBatch {
12083 #[allow(deprecated)]
12084 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12085 where
12086 D: serde::Deserializer<'de>,
12087 {
12088 const FIELDS: &[&str] = &[
12089 "stream_chunk",
12090 "streamChunk",
12091 "barrier_batch",
12092 "barrierBatch",
12093 "watermark",
12094 ];
12095
12096 #[allow(clippy::enum_variant_names)]
12097 enum GeneratedField {
12098 StreamChunk,
12099 BarrierBatch,
12100 Watermark,
12101 }
12102 impl<'de> serde::Deserialize<'de> for GeneratedField {
12103 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12104 where
12105 D: serde::Deserializer<'de>,
12106 {
12107 struct GeneratedVisitor;
12108
12109 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12110 type Value = GeneratedField;
12111
12112 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12113 write!(formatter, "expected one of: {:?}", &FIELDS)
12114 }
12115
12116 #[allow(unused_variables)]
12117 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12118 where
12119 E: serde::de::Error,
12120 {
12121 match value {
12122 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
12123 "barrierBatch" | "barrier_batch" => Ok(GeneratedField::BarrierBatch),
12124 "watermark" => Ok(GeneratedField::Watermark),
12125 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12126 }
12127 }
12128 }
12129 deserializer.deserialize_identifier(GeneratedVisitor)
12130 }
12131 }
12132 struct GeneratedVisitor;
12133 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12134 type Value = StreamMessageBatch;
12135
12136 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12137 formatter.write_str("struct stream_plan.StreamMessageBatch")
12138 }
12139
12140 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessageBatch, V::Error>
12141 where
12142 V: serde::de::MapAccess<'de>,
12143 {
12144 let mut stream_message_batch__ = None;
12145 while let Some(k) = map_.next_key()? {
12146 match k {
12147 GeneratedField::StreamChunk => {
12148 if stream_message_batch__.is_some() {
12149 return Err(serde::de::Error::duplicate_field("streamChunk"));
12150 }
12151 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::StreamChunk)
12152;
12153 }
12154 GeneratedField::BarrierBatch => {
12155 if stream_message_batch__.is_some() {
12156 return Err(serde::de::Error::duplicate_field("barrierBatch"));
12157 }
12158 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::BarrierBatch)
12159;
12160 }
12161 GeneratedField::Watermark => {
12162 if stream_message_batch__.is_some() {
12163 return Err(serde::de::Error::duplicate_field("watermark"));
12164 }
12165 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::Watermark)
12166;
12167 }
12168 }
12169 }
12170 Ok(StreamMessageBatch {
12171 stream_message_batch: stream_message_batch__,
12172 })
12173 }
12174 }
12175 deserializer.deserialize_struct("stream_plan.StreamMessageBatch", FIELDS, GeneratedVisitor)
12176 }
12177}
12178impl serde::Serialize for stream_message_batch::BarrierBatch {
12179 #[allow(deprecated)]
12180 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12181 where
12182 S: serde::Serializer,
12183 {
12184 use serde::ser::SerializeStruct;
12185 let mut len = 0;
12186 if !self.barriers.is_empty() {
12187 len += 1;
12188 }
12189 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", len)?;
12190 if !self.barriers.is_empty() {
12191 struct_ser.serialize_field("barriers", &self.barriers)?;
12192 }
12193 struct_ser.end()
12194 }
12195}
12196impl<'de> serde::Deserialize<'de> for stream_message_batch::BarrierBatch {
12197 #[allow(deprecated)]
12198 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12199 where
12200 D: serde::Deserializer<'de>,
12201 {
12202 const FIELDS: &[&str] = &[
12203 "barriers",
12204 ];
12205
12206 #[allow(clippy::enum_variant_names)]
12207 enum GeneratedField {
12208 Barriers,
12209 }
12210 impl<'de> serde::Deserialize<'de> for GeneratedField {
12211 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12212 where
12213 D: serde::Deserializer<'de>,
12214 {
12215 struct GeneratedVisitor;
12216
12217 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12218 type Value = GeneratedField;
12219
12220 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12221 write!(formatter, "expected one of: {:?}", &FIELDS)
12222 }
12223
12224 #[allow(unused_variables)]
12225 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12226 where
12227 E: serde::de::Error,
12228 {
12229 match value {
12230 "barriers" => Ok(GeneratedField::Barriers),
12231 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12232 }
12233 }
12234 }
12235 deserializer.deserialize_identifier(GeneratedVisitor)
12236 }
12237 }
12238 struct GeneratedVisitor;
12239 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12240 type Value = stream_message_batch::BarrierBatch;
12241
12242 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12243 formatter.write_str("struct stream_plan.StreamMessageBatch.BarrierBatch")
12244 }
12245
12246 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_message_batch::BarrierBatch, V::Error>
12247 where
12248 V: serde::de::MapAccess<'de>,
12249 {
12250 let mut barriers__ = None;
12251 while let Some(k) = map_.next_key()? {
12252 match k {
12253 GeneratedField::Barriers => {
12254 if barriers__.is_some() {
12255 return Err(serde::de::Error::duplicate_field("barriers"));
12256 }
12257 barriers__ = Some(map_.next_value()?);
12258 }
12259 }
12260 }
12261 Ok(stream_message_batch::BarrierBatch {
12262 barriers: barriers__.unwrap_or_default(),
12263 })
12264 }
12265 }
12266 deserializer.deserialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", FIELDS, GeneratedVisitor)
12267 }
12268}
12269impl serde::Serialize for StreamNode {
12270 #[allow(deprecated)]
12271 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12272 where
12273 S: serde::Serializer,
12274 {
12275 use serde::ser::SerializeStruct;
12276 let mut len = 0;
12277 if self.operator_id != 0 {
12278 len += 1;
12279 }
12280 if !self.input.is_empty() {
12281 len += 1;
12282 }
12283 if !self.stream_key.is_empty() {
12284 len += 1;
12285 }
12286 if self.stream_kind != 0 {
12287 len += 1;
12288 }
12289 if !self.identity.is_empty() {
12290 len += 1;
12291 }
12292 if !self.fields.is_empty() {
12293 len += 1;
12294 }
12295 if self.node_body.is_some() {
12296 len += 1;
12297 }
12298 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamNode", len)?;
12299 if self.operator_id != 0 {
12300 #[allow(clippy::needless_borrow)]
12301 #[allow(clippy::needless_borrows_for_generic_args)]
12302 struct_ser.serialize_field("operatorId", ToString::to_string(&self.operator_id).as_str())?;
12303 }
12304 if !self.input.is_empty() {
12305 struct_ser.serialize_field("input", &self.input)?;
12306 }
12307 if !self.stream_key.is_empty() {
12308 struct_ser.serialize_field("streamKey", &self.stream_key)?;
12309 }
12310 if self.stream_kind != 0 {
12311 let v = stream_node::StreamKind::try_from(self.stream_kind)
12312 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_kind)))?;
12313 struct_ser.serialize_field("streamKind", &v)?;
12314 }
12315 if !self.identity.is_empty() {
12316 struct_ser.serialize_field("identity", &self.identity)?;
12317 }
12318 if !self.fields.is_empty() {
12319 struct_ser.serialize_field("fields", &self.fields)?;
12320 }
12321 if let Some(v) = self.node_body.as_ref() {
12322 match v {
12323 stream_node::NodeBody::Source(v) => {
12324 struct_ser.serialize_field("source", v)?;
12325 }
12326 stream_node::NodeBody::Project(v) => {
12327 struct_ser.serialize_field("project", v)?;
12328 }
12329 stream_node::NodeBody::Filter(v) => {
12330 struct_ser.serialize_field("filter", v)?;
12331 }
12332 stream_node::NodeBody::Materialize(v) => {
12333 struct_ser.serialize_field("materialize", v)?;
12334 }
12335 stream_node::NodeBody::StatelessSimpleAgg(v) => {
12336 struct_ser.serialize_field("statelessSimpleAgg", v)?;
12337 }
12338 stream_node::NodeBody::SimpleAgg(v) => {
12339 struct_ser.serialize_field("simpleAgg", v)?;
12340 }
12341 stream_node::NodeBody::HashAgg(v) => {
12342 struct_ser.serialize_field("hashAgg", v)?;
12343 }
12344 stream_node::NodeBody::AppendOnlyTopN(v) => {
12345 struct_ser.serialize_field("appendOnlyTopN", v)?;
12346 }
12347 stream_node::NodeBody::HashJoin(v) => {
12348 struct_ser.serialize_field("hashJoin", v)?;
12349 }
12350 stream_node::NodeBody::TopN(v) => {
12351 struct_ser.serialize_field("topN", v)?;
12352 }
12353 stream_node::NodeBody::HopWindow(v) => {
12354 struct_ser.serialize_field("hopWindow", v)?;
12355 }
12356 stream_node::NodeBody::Merge(v) => {
12357 struct_ser.serialize_field("merge", v)?;
12358 }
12359 stream_node::NodeBody::Exchange(v) => {
12360 struct_ser.serialize_field("exchange", v)?;
12361 }
12362 stream_node::NodeBody::StreamScan(v) => {
12363 struct_ser.serialize_field("streamScan", v)?;
12364 }
12365 stream_node::NodeBody::BatchPlan(v) => {
12366 struct_ser.serialize_field("batchPlan", v)?;
12367 }
12368 stream_node::NodeBody::Lookup(v) => {
12369 struct_ser.serialize_field("lookup", v)?;
12370 }
12371 stream_node::NodeBody::Arrange(v) => {
12372 struct_ser.serialize_field("arrange", v)?;
12373 }
12374 stream_node::NodeBody::LookupUnion(v) => {
12375 struct_ser.serialize_field("lookupUnion", v)?;
12376 }
12377 stream_node::NodeBody::Union(v) => {
12378 struct_ser.serialize_field("union", v)?;
12379 }
12380 stream_node::NodeBody::DeltaIndexJoin(v) => {
12381 struct_ser.serialize_field("deltaIndexJoin", v)?;
12382 }
12383 stream_node::NodeBody::Sink(v) => {
12384 struct_ser.serialize_field("sink", v)?;
12385 }
12386 stream_node::NodeBody::Expand(v) => {
12387 struct_ser.serialize_field("expand", v)?;
12388 }
12389 stream_node::NodeBody::DynamicFilter(v) => {
12390 struct_ser.serialize_field("dynamicFilter", v)?;
12391 }
12392 stream_node::NodeBody::ProjectSet(v) => {
12393 struct_ser.serialize_field("projectSet", v)?;
12394 }
12395 stream_node::NodeBody::GroupTopN(v) => {
12396 struct_ser.serialize_field("groupTopN", v)?;
12397 }
12398 stream_node::NodeBody::Sort(v) => {
12399 struct_ser.serialize_field("sort", v)?;
12400 }
12401 stream_node::NodeBody::WatermarkFilter(v) => {
12402 struct_ser.serialize_field("watermarkFilter", v)?;
12403 }
12404 stream_node::NodeBody::Dml(v) => {
12405 struct_ser.serialize_field("dml", v)?;
12406 }
12407 stream_node::NodeBody::RowIdGen(v) => {
12408 struct_ser.serialize_field("rowIdGen", v)?;
12409 }
12410 stream_node::NodeBody::Now(v) => {
12411 struct_ser.serialize_field("now", v)?;
12412 }
12413 stream_node::NodeBody::AppendOnlyGroupTopN(v) => {
12414 struct_ser.serialize_field("appendOnlyGroupTopN", v)?;
12415 }
12416 stream_node::NodeBody::TemporalJoin(v) => {
12417 struct_ser.serialize_field("temporalJoin", v)?;
12418 }
12419 stream_node::NodeBody::BarrierRecv(v) => {
12420 struct_ser.serialize_field("barrierRecv", v)?;
12421 }
12422 stream_node::NodeBody::Values(v) => {
12423 struct_ser.serialize_field("values", v)?;
12424 }
12425 stream_node::NodeBody::AppendOnlyDedup(v) => {
12426 struct_ser.serialize_field("appendOnlyDedup", v)?;
12427 }
12428 stream_node::NodeBody::NoOp(v) => {
12429 struct_ser.serialize_field("noOp", v)?;
12430 }
12431 stream_node::NodeBody::EowcOverWindow(v) => {
12432 struct_ser.serialize_field("eowcOverWindow", v)?;
12433 }
12434 stream_node::NodeBody::OverWindow(v) => {
12435 struct_ser.serialize_field("overWindow", v)?;
12436 }
12437 stream_node::NodeBody::StreamFsFetch(v) => {
12438 struct_ser.serialize_field("streamFsFetch", v)?;
12439 }
12440 stream_node::NodeBody::StreamCdcScan(v) => {
12441 struct_ser.serialize_field("streamCdcScan", v)?;
12442 }
12443 stream_node::NodeBody::CdcFilter(v) => {
12444 struct_ser.serialize_field("cdcFilter", v)?;
12445 }
12446 stream_node::NodeBody::SourceBackfill(v) => {
12447 struct_ser.serialize_field("sourceBackfill", v)?;
12448 }
12449 stream_node::NodeBody::Changelog(v) => {
12450 struct_ser.serialize_field("changelog", v)?;
12451 }
12452 stream_node::NodeBody::LocalApproxPercentile(v) => {
12453 struct_ser.serialize_field("localApproxPercentile", v)?;
12454 }
12455 stream_node::NodeBody::GlobalApproxPercentile(v) => {
12456 struct_ser.serialize_field("globalApproxPercentile", v)?;
12457 }
12458 stream_node::NodeBody::RowMerge(v) => {
12459 struct_ser.serialize_field("rowMerge", v)?;
12460 }
12461 stream_node::NodeBody::AsOfJoin(v) => {
12462 struct_ser.serialize_field("asOfJoin", v)?;
12463 }
12464 stream_node::NodeBody::SyncLogStore(v) => {
12465 struct_ser.serialize_field("syncLogStore", v)?;
12466 }
12467 stream_node::NodeBody::MaterializedExprs(v) => {
12468 struct_ser.serialize_field("materializedExprs", v)?;
12469 }
12470 stream_node::NodeBody::VectorIndexWrite(v) => {
12471 struct_ser.serialize_field("vectorIndexWrite", v)?;
12472 }
12473 stream_node::NodeBody::UpstreamSinkUnion(v) => {
12474 struct_ser.serialize_field("upstreamSinkUnion", v)?;
12475 }
12476 }
12477 }
12478 struct_ser.end()
12479 }
12480}
12481impl<'de> serde::Deserialize<'de> for StreamNode {
12482 #[allow(deprecated)]
12483 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12484 where
12485 D: serde::Deserializer<'de>,
12486 {
12487 const FIELDS: &[&str] = &[
12488 "operator_id",
12489 "operatorId",
12490 "input",
12491 "stream_key",
12492 "streamKey",
12493 "stream_kind",
12494 "streamKind",
12495 "identity",
12496 "fields",
12497 "source",
12498 "project",
12499 "filter",
12500 "materialize",
12501 "stateless_simple_agg",
12502 "statelessSimpleAgg",
12503 "simple_agg",
12504 "simpleAgg",
12505 "hash_agg",
12506 "hashAgg",
12507 "append_only_top_n",
12508 "appendOnlyTopN",
12509 "hash_join",
12510 "hashJoin",
12511 "top_n",
12512 "topN",
12513 "hop_window",
12514 "hopWindow",
12515 "merge",
12516 "exchange",
12517 "stream_scan",
12518 "streamScan",
12519 "batch_plan",
12520 "batchPlan",
12521 "lookup",
12522 "arrange",
12523 "lookup_union",
12524 "lookupUnion",
12525 "union",
12526 "delta_index_join",
12527 "deltaIndexJoin",
12528 "sink",
12529 "expand",
12530 "dynamic_filter",
12531 "dynamicFilter",
12532 "project_set",
12533 "projectSet",
12534 "group_top_n",
12535 "groupTopN",
12536 "sort",
12537 "watermark_filter",
12538 "watermarkFilter",
12539 "dml",
12540 "row_id_gen",
12541 "rowIdGen",
12542 "now",
12543 "append_only_group_top_n",
12544 "appendOnlyGroupTopN",
12545 "temporal_join",
12546 "temporalJoin",
12547 "barrier_recv",
12548 "barrierRecv",
12549 "values",
12550 "append_only_dedup",
12551 "appendOnlyDedup",
12552 "no_op",
12553 "noOp",
12554 "eowc_over_window",
12555 "eowcOverWindow",
12556 "over_window",
12557 "overWindow",
12558 "stream_fs_fetch",
12559 "streamFsFetch",
12560 "stream_cdc_scan",
12561 "streamCdcScan",
12562 "cdc_filter",
12563 "cdcFilter",
12564 "source_backfill",
12565 "sourceBackfill",
12566 "changelog",
12567 "local_approx_percentile",
12568 "localApproxPercentile",
12569 "global_approx_percentile",
12570 "globalApproxPercentile",
12571 "row_merge",
12572 "rowMerge",
12573 "as_of_join",
12574 "asOfJoin",
12575 "sync_log_store",
12576 "syncLogStore",
12577 "materialized_exprs",
12578 "materializedExprs",
12579 "vector_index_write",
12580 "vectorIndexWrite",
12581 "upstream_sink_union",
12582 "upstreamSinkUnion",
12583 ];
12584
12585 #[allow(clippy::enum_variant_names)]
12586 enum GeneratedField {
12587 OperatorId,
12588 Input,
12589 StreamKey,
12590 StreamKind,
12591 Identity,
12592 Fields,
12593 Source,
12594 Project,
12595 Filter,
12596 Materialize,
12597 StatelessSimpleAgg,
12598 SimpleAgg,
12599 HashAgg,
12600 AppendOnlyTopN,
12601 HashJoin,
12602 TopN,
12603 HopWindow,
12604 Merge,
12605 Exchange,
12606 StreamScan,
12607 BatchPlan,
12608 Lookup,
12609 Arrange,
12610 LookupUnion,
12611 Union,
12612 DeltaIndexJoin,
12613 Sink,
12614 Expand,
12615 DynamicFilter,
12616 ProjectSet,
12617 GroupTopN,
12618 Sort,
12619 WatermarkFilter,
12620 Dml,
12621 RowIdGen,
12622 Now,
12623 AppendOnlyGroupTopN,
12624 TemporalJoin,
12625 BarrierRecv,
12626 Values,
12627 AppendOnlyDedup,
12628 NoOp,
12629 EowcOverWindow,
12630 OverWindow,
12631 StreamFsFetch,
12632 StreamCdcScan,
12633 CdcFilter,
12634 SourceBackfill,
12635 Changelog,
12636 LocalApproxPercentile,
12637 GlobalApproxPercentile,
12638 RowMerge,
12639 AsOfJoin,
12640 SyncLogStore,
12641 MaterializedExprs,
12642 VectorIndexWrite,
12643 UpstreamSinkUnion,
12644 }
12645 impl<'de> serde::Deserialize<'de> for GeneratedField {
12646 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12647 where
12648 D: serde::Deserializer<'de>,
12649 {
12650 struct GeneratedVisitor;
12651
12652 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12653 type Value = GeneratedField;
12654
12655 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12656 write!(formatter, "expected one of: {:?}", &FIELDS)
12657 }
12658
12659 #[allow(unused_variables)]
12660 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12661 where
12662 E: serde::de::Error,
12663 {
12664 match value {
12665 "operatorId" | "operator_id" => Ok(GeneratedField::OperatorId),
12666 "input" => Ok(GeneratedField::Input),
12667 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
12668 "streamKind" | "stream_kind" => Ok(GeneratedField::StreamKind),
12669 "identity" => Ok(GeneratedField::Identity),
12670 "fields" => Ok(GeneratedField::Fields),
12671 "source" => Ok(GeneratedField::Source),
12672 "project" => Ok(GeneratedField::Project),
12673 "filter" => Ok(GeneratedField::Filter),
12674 "materialize" => Ok(GeneratedField::Materialize),
12675 "statelessSimpleAgg" | "stateless_simple_agg" => Ok(GeneratedField::StatelessSimpleAgg),
12676 "simpleAgg" | "simple_agg" => Ok(GeneratedField::SimpleAgg),
12677 "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
12678 "appendOnlyTopN" | "append_only_top_n" => Ok(GeneratedField::AppendOnlyTopN),
12679 "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
12680 "topN" | "top_n" => Ok(GeneratedField::TopN),
12681 "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
12682 "merge" => Ok(GeneratedField::Merge),
12683 "exchange" => Ok(GeneratedField::Exchange),
12684 "streamScan" | "stream_scan" => Ok(GeneratedField::StreamScan),
12685 "batchPlan" | "batch_plan" => Ok(GeneratedField::BatchPlan),
12686 "lookup" => Ok(GeneratedField::Lookup),
12687 "arrange" => Ok(GeneratedField::Arrange),
12688 "lookupUnion" | "lookup_union" => Ok(GeneratedField::LookupUnion),
12689 "union" => Ok(GeneratedField::Union),
12690 "deltaIndexJoin" | "delta_index_join" => Ok(GeneratedField::DeltaIndexJoin),
12691 "sink" => Ok(GeneratedField::Sink),
12692 "expand" => Ok(GeneratedField::Expand),
12693 "dynamicFilter" | "dynamic_filter" => Ok(GeneratedField::DynamicFilter),
12694 "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
12695 "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
12696 "sort" => Ok(GeneratedField::Sort),
12697 "watermarkFilter" | "watermark_filter" => Ok(GeneratedField::WatermarkFilter),
12698 "dml" => Ok(GeneratedField::Dml),
12699 "rowIdGen" | "row_id_gen" => Ok(GeneratedField::RowIdGen),
12700 "now" => Ok(GeneratedField::Now),
12701 "appendOnlyGroupTopN" | "append_only_group_top_n" => Ok(GeneratedField::AppendOnlyGroupTopN),
12702 "temporalJoin" | "temporal_join" => Ok(GeneratedField::TemporalJoin),
12703 "barrierRecv" | "barrier_recv" => Ok(GeneratedField::BarrierRecv),
12704 "values" => Ok(GeneratedField::Values),
12705 "appendOnlyDedup" | "append_only_dedup" => Ok(GeneratedField::AppendOnlyDedup),
12706 "noOp" | "no_op" => Ok(GeneratedField::NoOp),
12707 "eowcOverWindow" | "eowc_over_window" => Ok(GeneratedField::EowcOverWindow),
12708 "overWindow" | "over_window" => Ok(GeneratedField::OverWindow),
12709 "streamFsFetch" | "stream_fs_fetch" => Ok(GeneratedField::StreamFsFetch),
12710 "streamCdcScan" | "stream_cdc_scan" => Ok(GeneratedField::StreamCdcScan),
12711 "cdcFilter" | "cdc_filter" => Ok(GeneratedField::CdcFilter),
12712 "sourceBackfill" | "source_backfill" => Ok(GeneratedField::SourceBackfill),
12713 "changelog" => Ok(GeneratedField::Changelog),
12714 "localApproxPercentile" | "local_approx_percentile" => Ok(GeneratedField::LocalApproxPercentile),
12715 "globalApproxPercentile" | "global_approx_percentile" => Ok(GeneratedField::GlobalApproxPercentile),
12716 "rowMerge" | "row_merge" => Ok(GeneratedField::RowMerge),
12717 "asOfJoin" | "as_of_join" => Ok(GeneratedField::AsOfJoin),
12718 "syncLogStore" | "sync_log_store" => Ok(GeneratedField::SyncLogStore),
12719 "materializedExprs" | "materialized_exprs" => Ok(GeneratedField::MaterializedExprs),
12720 "vectorIndexWrite" | "vector_index_write" => Ok(GeneratedField::VectorIndexWrite),
12721 "upstreamSinkUnion" | "upstream_sink_union" => Ok(GeneratedField::UpstreamSinkUnion),
12722 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12723 }
12724 }
12725 }
12726 deserializer.deserialize_identifier(GeneratedVisitor)
12727 }
12728 }
12729 struct GeneratedVisitor;
12730 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12731 type Value = StreamNode;
12732
12733 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12734 formatter.write_str("struct stream_plan.StreamNode")
12735 }
12736
12737 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamNode, V::Error>
12738 where
12739 V: serde::de::MapAccess<'de>,
12740 {
12741 let mut operator_id__ = None;
12742 let mut input__ = None;
12743 let mut stream_key__ = None;
12744 let mut stream_kind__ = None;
12745 let mut identity__ = None;
12746 let mut fields__ = None;
12747 let mut node_body__ = None;
12748 while let Some(k) = map_.next_key()? {
12749 match k {
12750 GeneratedField::OperatorId => {
12751 if operator_id__.is_some() {
12752 return Err(serde::de::Error::duplicate_field("operatorId"));
12753 }
12754 operator_id__ =
12755 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12756 ;
12757 }
12758 GeneratedField::Input => {
12759 if input__.is_some() {
12760 return Err(serde::de::Error::duplicate_field("input"));
12761 }
12762 input__ = Some(map_.next_value()?);
12763 }
12764 GeneratedField::StreamKey => {
12765 if stream_key__.is_some() {
12766 return Err(serde::de::Error::duplicate_field("streamKey"));
12767 }
12768 stream_key__ =
12769 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12770 .into_iter().map(|x| x.0).collect())
12771 ;
12772 }
12773 GeneratedField::StreamKind => {
12774 if stream_kind__.is_some() {
12775 return Err(serde::de::Error::duplicate_field("streamKind"));
12776 }
12777 stream_kind__ = Some(map_.next_value::<stream_node::StreamKind>()? as i32);
12778 }
12779 GeneratedField::Identity => {
12780 if identity__.is_some() {
12781 return Err(serde::de::Error::duplicate_field("identity"));
12782 }
12783 identity__ = Some(map_.next_value()?);
12784 }
12785 GeneratedField::Fields => {
12786 if fields__.is_some() {
12787 return Err(serde::de::Error::duplicate_field("fields"));
12788 }
12789 fields__ = Some(map_.next_value()?);
12790 }
12791 GeneratedField::Source => {
12792 if node_body__.is_some() {
12793 return Err(serde::de::Error::duplicate_field("source"));
12794 }
12795 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Source)
12796;
12797 }
12798 GeneratedField::Project => {
12799 if node_body__.is_some() {
12800 return Err(serde::de::Error::duplicate_field("project"));
12801 }
12802 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Project)
12803;
12804 }
12805 GeneratedField::Filter => {
12806 if node_body__.is_some() {
12807 return Err(serde::de::Error::duplicate_field("filter"));
12808 }
12809 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Filter)
12810;
12811 }
12812 GeneratedField::Materialize => {
12813 if node_body__.is_some() {
12814 return Err(serde::de::Error::duplicate_field("materialize"));
12815 }
12816 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Materialize)
12817;
12818 }
12819 GeneratedField::StatelessSimpleAgg => {
12820 if node_body__.is_some() {
12821 return Err(serde::de::Error::duplicate_field("statelessSimpleAgg"));
12822 }
12823 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StatelessSimpleAgg)
12824;
12825 }
12826 GeneratedField::SimpleAgg => {
12827 if node_body__.is_some() {
12828 return Err(serde::de::Error::duplicate_field("simpleAgg"));
12829 }
12830 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SimpleAgg)
12831;
12832 }
12833 GeneratedField::HashAgg => {
12834 if node_body__.is_some() {
12835 return Err(serde::de::Error::duplicate_field("hashAgg"));
12836 }
12837 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashAgg)
12838;
12839 }
12840 GeneratedField::AppendOnlyTopN => {
12841 if node_body__.is_some() {
12842 return Err(serde::de::Error::duplicate_field("appendOnlyTopN"));
12843 }
12844 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyTopN)
12845;
12846 }
12847 GeneratedField::HashJoin => {
12848 if node_body__.is_some() {
12849 return Err(serde::de::Error::duplicate_field("hashJoin"));
12850 }
12851 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashJoin)
12852;
12853 }
12854 GeneratedField::TopN => {
12855 if node_body__.is_some() {
12856 return Err(serde::de::Error::duplicate_field("topN"));
12857 }
12858 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TopN)
12859;
12860 }
12861 GeneratedField::HopWindow => {
12862 if node_body__.is_some() {
12863 return Err(serde::de::Error::duplicate_field("hopWindow"));
12864 }
12865 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HopWindow)
12866;
12867 }
12868 GeneratedField::Merge => {
12869 if node_body__.is_some() {
12870 return Err(serde::de::Error::duplicate_field("merge"));
12871 }
12872 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Merge)
12873;
12874 }
12875 GeneratedField::Exchange => {
12876 if node_body__.is_some() {
12877 return Err(serde::de::Error::duplicate_field("exchange"));
12878 }
12879 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Exchange)
12880;
12881 }
12882 GeneratedField::StreamScan => {
12883 if node_body__.is_some() {
12884 return Err(serde::de::Error::duplicate_field("streamScan"));
12885 }
12886 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamScan)
12887;
12888 }
12889 GeneratedField::BatchPlan => {
12890 if node_body__.is_some() {
12891 return Err(serde::de::Error::duplicate_field("batchPlan"));
12892 }
12893 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BatchPlan)
12894;
12895 }
12896 GeneratedField::Lookup => {
12897 if node_body__.is_some() {
12898 return Err(serde::de::Error::duplicate_field("lookup"));
12899 }
12900 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Lookup)
12901;
12902 }
12903 GeneratedField::Arrange => {
12904 if node_body__.is_some() {
12905 return Err(serde::de::Error::duplicate_field("arrange"));
12906 }
12907 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Arrange)
12908;
12909 }
12910 GeneratedField::LookupUnion => {
12911 if node_body__.is_some() {
12912 return Err(serde::de::Error::duplicate_field("lookupUnion"));
12913 }
12914 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LookupUnion)
12915;
12916 }
12917 GeneratedField::Union => {
12918 if node_body__.is_some() {
12919 return Err(serde::de::Error::duplicate_field("union"));
12920 }
12921 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Union)
12922;
12923 }
12924 GeneratedField::DeltaIndexJoin => {
12925 if node_body__.is_some() {
12926 return Err(serde::de::Error::duplicate_field("deltaIndexJoin"));
12927 }
12928 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DeltaIndexJoin)
12929;
12930 }
12931 GeneratedField::Sink => {
12932 if node_body__.is_some() {
12933 return Err(serde::de::Error::duplicate_field("sink"));
12934 }
12935 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sink)
12936;
12937 }
12938 GeneratedField::Expand => {
12939 if node_body__.is_some() {
12940 return Err(serde::de::Error::duplicate_field("expand"));
12941 }
12942 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Expand)
12943;
12944 }
12945 GeneratedField::DynamicFilter => {
12946 if node_body__.is_some() {
12947 return Err(serde::de::Error::duplicate_field("dynamicFilter"));
12948 }
12949 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DynamicFilter)
12950;
12951 }
12952 GeneratedField::ProjectSet => {
12953 if node_body__.is_some() {
12954 return Err(serde::de::Error::duplicate_field("projectSet"));
12955 }
12956 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::ProjectSet)
12957;
12958 }
12959 GeneratedField::GroupTopN => {
12960 if node_body__.is_some() {
12961 return Err(serde::de::Error::duplicate_field("groupTopN"));
12962 }
12963 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GroupTopN)
12964;
12965 }
12966 GeneratedField::Sort => {
12967 if node_body__.is_some() {
12968 return Err(serde::de::Error::duplicate_field("sort"));
12969 }
12970 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sort)
12971;
12972 }
12973 GeneratedField::WatermarkFilter => {
12974 if node_body__.is_some() {
12975 return Err(serde::de::Error::duplicate_field("watermarkFilter"));
12976 }
12977 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::WatermarkFilter)
12978;
12979 }
12980 GeneratedField::Dml => {
12981 if node_body__.is_some() {
12982 return Err(serde::de::Error::duplicate_field("dml"));
12983 }
12984 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Dml)
12985;
12986 }
12987 GeneratedField::RowIdGen => {
12988 if node_body__.is_some() {
12989 return Err(serde::de::Error::duplicate_field("rowIdGen"));
12990 }
12991 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowIdGen)
12992;
12993 }
12994 GeneratedField::Now => {
12995 if node_body__.is_some() {
12996 return Err(serde::de::Error::duplicate_field("now"));
12997 }
12998 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Now)
12999;
13000 }
13001 GeneratedField::AppendOnlyGroupTopN => {
13002 if node_body__.is_some() {
13003 return Err(serde::de::Error::duplicate_field("appendOnlyGroupTopN"));
13004 }
13005 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyGroupTopN)
13006;
13007 }
13008 GeneratedField::TemporalJoin => {
13009 if node_body__.is_some() {
13010 return Err(serde::de::Error::duplicate_field("temporalJoin"));
13011 }
13012 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TemporalJoin)
13013;
13014 }
13015 GeneratedField::BarrierRecv => {
13016 if node_body__.is_some() {
13017 return Err(serde::de::Error::duplicate_field("barrierRecv"));
13018 }
13019 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BarrierRecv)
13020;
13021 }
13022 GeneratedField::Values => {
13023 if node_body__.is_some() {
13024 return Err(serde::de::Error::duplicate_field("values"));
13025 }
13026 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Values)
13027;
13028 }
13029 GeneratedField::AppendOnlyDedup => {
13030 if node_body__.is_some() {
13031 return Err(serde::de::Error::duplicate_field("appendOnlyDedup"));
13032 }
13033 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyDedup)
13034;
13035 }
13036 GeneratedField::NoOp => {
13037 if node_body__.is_some() {
13038 return Err(serde::de::Error::duplicate_field("noOp"));
13039 }
13040 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::NoOp)
13041;
13042 }
13043 GeneratedField::EowcOverWindow => {
13044 if node_body__.is_some() {
13045 return Err(serde::de::Error::duplicate_field("eowcOverWindow"));
13046 }
13047 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcOverWindow)
13048;
13049 }
13050 GeneratedField::OverWindow => {
13051 if node_body__.is_some() {
13052 return Err(serde::de::Error::duplicate_field("overWindow"));
13053 }
13054 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::OverWindow)
13055;
13056 }
13057 GeneratedField::StreamFsFetch => {
13058 if node_body__.is_some() {
13059 return Err(serde::de::Error::duplicate_field("streamFsFetch"));
13060 }
13061 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamFsFetch)
13062;
13063 }
13064 GeneratedField::StreamCdcScan => {
13065 if node_body__.is_some() {
13066 return Err(serde::de::Error::duplicate_field("streamCdcScan"));
13067 }
13068 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamCdcScan)
13069;
13070 }
13071 GeneratedField::CdcFilter => {
13072 if node_body__.is_some() {
13073 return Err(serde::de::Error::duplicate_field("cdcFilter"));
13074 }
13075 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CdcFilter)
13076;
13077 }
13078 GeneratedField::SourceBackfill => {
13079 if node_body__.is_some() {
13080 return Err(serde::de::Error::duplicate_field("sourceBackfill"));
13081 }
13082 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SourceBackfill)
13083;
13084 }
13085 GeneratedField::Changelog => {
13086 if node_body__.is_some() {
13087 return Err(serde::de::Error::duplicate_field("changelog"));
13088 }
13089 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Changelog)
13090;
13091 }
13092 GeneratedField::LocalApproxPercentile => {
13093 if node_body__.is_some() {
13094 return Err(serde::de::Error::duplicate_field("localApproxPercentile"));
13095 }
13096 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalApproxPercentile)
13097;
13098 }
13099 GeneratedField::GlobalApproxPercentile => {
13100 if node_body__.is_some() {
13101 return Err(serde::de::Error::duplicate_field("globalApproxPercentile"));
13102 }
13103 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GlobalApproxPercentile)
13104;
13105 }
13106 GeneratedField::RowMerge => {
13107 if node_body__.is_some() {
13108 return Err(serde::de::Error::duplicate_field("rowMerge"));
13109 }
13110 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowMerge)
13111;
13112 }
13113 GeneratedField::AsOfJoin => {
13114 if node_body__.is_some() {
13115 return Err(serde::de::Error::duplicate_field("asOfJoin"));
13116 }
13117 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AsOfJoin)
13118;
13119 }
13120 GeneratedField::SyncLogStore => {
13121 if node_body__.is_some() {
13122 return Err(serde::de::Error::duplicate_field("syncLogStore"));
13123 }
13124 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SyncLogStore)
13125;
13126 }
13127 GeneratedField::MaterializedExprs => {
13128 if node_body__.is_some() {
13129 return Err(serde::de::Error::duplicate_field("materializedExprs"));
13130 }
13131 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MaterializedExprs)
13132;
13133 }
13134 GeneratedField::VectorIndexWrite => {
13135 if node_body__.is_some() {
13136 return Err(serde::de::Error::duplicate_field("vectorIndexWrite"));
13137 }
13138 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexWrite)
13139;
13140 }
13141 GeneratedField::UpstreamSinkUnion => {
13142 if node_body__.is_some() {
13143 return Err(serde::de::Error::duplicate_field("upstreamSinkUnion"));
13144 }
13145 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::UpstreamSinkUnion)
13146;
13147 }
13148 }
13149 }
13150 Ok(StreamNode {
13151 operator_id: operator_id__.unwrap_or_default(),
13152 input: input__.unwrap_or_default(),
13153 stream_key: stream_key__.unwrap_or_default(),
13154 stream_kind: stream_kind__.unwrap_or_default(),
13155 identity: identity__.unwrap_or_default(),
13156 fields: fields__.unwrap_or_default(),
13157 node_body: node_body__,
13158 })
13159 }
13160 }
13161 deserializer.deserialize_struct("stream_plan.StreamNode", FIELDS, GeneratedVisitor)
13162 }
13163}
13164impl serde::Serialize for stream_node::StreamKind {
13165 #[allow(deprecated)]
13166 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13167 where
13168 S: serde::Serializer,
13169 {
13170 let variant = match self {
13171 Self::Retract => "STREAM_KIND_RETRACT",
13172 Self::AppendOnly => "STREAM_KIND_APPEND_ONLY",
13173 Self::Upsert => "STREAM_KIND_UPSERT",
13174 };
13175 serializer.serialize_str(variant)
13176 }
13177}
13178impl<'de> serde::Deserialize<'de> for stream_node::StreamKind {
13179 #[allow(deprecated)]
13180 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13181 where
13182 D: serde::Deserializer<'de>,
13183 {
13184 const FIELDS: &[&str] = &[
13185 "STREAM_KIND_RETRACT",
13186 "STREAM_KIND_APPEND_ONLY",
13187 "STREAM_KIND_UPSERT",
13188 ];
13189
13190 struct GeneratedVisitor;
13191
13192 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13193 type Value = stream_node::StreamKind;
13194
13195 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13196 write!(formatter, "expected one of: {:?}", &FIELDS)
13197 }
13198
13199 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13200 where
13201 E: serde::de::Error,
13202 {
13203 i32::try_from(v)
13204 .ok()
13205 .and_then(|x| x.try_into().ok())
13206 .ok_or_else(|| {
13207 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13208 })
13209 }
13210
13211 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13212 where
13213 E: serde::de::Error,
13214 {
13215 i32::try_from(v)
13216 .ok()
13217 .and_then(|x| x.try_into().ok())
13218 .ok_or_else(|| {
13219 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13220 })
13221 }
13222
13223 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13224 where
13225 E: serde::de::Error,
13226 {
13227 match value {
13228 "STREAM_KIND_RETRACT" => Ok(stream_node::StreamKind::Retract),
13229 "STREAM_KIND_APPEND_ONLY" => Ok(stream_node::StreamKind::AppendOnly),
13230 "STREAM_KIND_UPSERT" => Ok(stream_node::StreamKind::Upsert),
13231 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13232 }
13233 }
13234 }
13235 deserializer.deserialize_any(GeneratedVisitor)
13236 }
13237}
13238impl serde::Serialize for StreamScanNode {
13239 #[allow(deprecated)]
13240 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13241 where
13242 S: serde::Serializer,
13243 {
13244 use serde::ser::SerializeStruct;
13245 let mut len = 0;
13246 if self.table_id != 0 {
13247 len += 1;
13248 }
13249 if !self.upstream_column_ids.is_empty() {
13250 len += 1;
13251 }
13252 if !self.output_indices.is_empty() {
13253 len += 1;
13254 }
13255 if self.stream_scan_type != 0 {
13256 len += 1;
13257 }
13258 if self.state_table.is_some() {
13259 len += 1;
13260 }
13261 if self.table_desc.is_some() {
13262 len += 1;
13263 }
13264 if self.rate_limit.is_some() {
13265 len += 1;
13266 }
13267 if self.snapshot_read_barrier_interval != 0 {
13268 len += 1;
13269 }
13270 if self.arrangement_table.is_some() {
13271 len += 1;
13272 }
13273 if self.snapshot_backfill_epoch.is_some() {
13274 len += 1;
13275 }
13276 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamScanNode", len)?;
13277 if self.table_id != 0 {
13278 struct_ser.serialize_field("tableId", &self.table_id)?;
13279 }
13280 if !self.upstream_column_ids.is_empty() {
13281 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
13282 }
13283 if !self.output_indices.is_empty() {
13284 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
13285 }
13286 if self.stream_scan_type != 0 {
13287 let v = StreamScanType::try_from(self.stream_scan_type)
13288 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_scan_type)))?;
13289 struct_ser.serialize_field("streamScanType", &v)?;
13290 }
13291 if let Some(v) = self.state_table.as_ref() {
13292 struct_ser.serialize_field("stateTable", v)?;
13293 }
13294 if let Some(v) = self.table_desc.as_ref() {
13295 struct_ser.serialize_field("tableDesc", v)?;
13296 }
13297 if let Some(v) = self.rate_limit.as_ref() {
13298 struct_ser.serialize_field("rateLimit", v)?;
13299 }
13300 if self.snapshot_read_barrier_interval != 0 {
13301 struct_ser.serialize_field("snapshotReadBarrierInterval", &self.snapshot_read_barrier_interval)?;
13302 }
13303 if let Some(v) = self.arrangement_table.as_ref() {
13304 struct_ser.serialize_field("arrangementTable", v)?;
13305 }
13306 if let Some(v) = self.snapshot_backfill_epoch.as_ref() {
13307 #[allow(clippy::needless_borrow)]
13308 #[allow(clippy::needless_borrows_for_generic_args)]
13309 struct_ser.serialize_field("snapshotBackfillEpoch", ToString::to_string(&v).as_str())?;
13310 }
13311 struct_ser.end()
13312 }
13313}
13314impl<'de> serde::Deserialize<'de> for StreamScanNode {
13315 #[allow(deprecated)]
13316 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13317 where
13318 D: serde::Deserializer<'de>,
13319 {
13320 const FIELDS: &[&str] = &[
13321 "table_id",
13322 "tableId",
13323 "upstream_column_ids",
13324 "upstreamColumnIds",
13325 "output_indices",
13326 "outputIndices",
13327 "stream_scan_type",
13328 "streamScanType",
13329 "state_table",
13330 "stateTable",
13331 "table_desc",
13332 "tableDesc",
13333 "rate_limit",
13334 "rateLimit",
13335 "snapshot_read_barrier_interval",
13336 "snapshotReadBarrierInterval",
13337 "arrangement_table",
13338 "arrangementTable",
13339 "snapshot_backfill_epoch",
13340 "snapshotBackfillEpoch",
13341 ];
13342
13343 #[allow(clippy::enum_variant_names)]
13344 enum GeneratedField {
13345 TableId,
13346 UpstreamColumnIds,
13347 OutputIndices,
13348 StreamScanType,
13349 StateTable,
13350 TableDesc,
13351 RateLimit,
13352 SnapshotReadBarrierInterval,
13353 ArrangementTable,
13354 SnapshotBackfillEpoch,
13355 }
13356 impl<'de> serde::Deserialize<'de> for GeneratedField {
13357 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13358 where
13359 D: serde::Deserializer<'de>,
13360 {
13361 struct GeneratedVisitor;
13362
13363 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13364 type Value = GeneratedField;
13365
13366 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13367 write!(formatter, "expected one of: {:?}", &FIELDS)
13368 }
13369
13370 #[allow(unused_variables)]
13371 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13372 where
13373 E: serde::de::Error,
13374 {
13375 match value {
13376 "tableId" | "table_id" => Ok(GeneratedField::TableId),
13377 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
13378 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
13379 "streamScanType" | "stream_scan_type" => Ok(GeneratedField::StreamScanType),
13380 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
13381 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
13382 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
13383 "snapshotReadBarrierInterval" | "snapshot_read_barrier_interval" => Ok(GeneratedField::SnapshotReadBarrierInterval),
13384 "arrangementTable" | "arrangement_table" => Ok(GeneratedField::ArrangementTable),
13385 "snapshotBackfillEpoch" | "snapshot_backfill_epoch" => Ok(GeneratedField::SnapshotBackfillEpoch),
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 = StreamScanNode;
13396
13397 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13398 formatter.write_str("struct stream_plan.StreamScanNode")
13399 }
13400
13401 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamScanNode, V::Error>
13402 where
13403 V: serde::de::MapAccess<'de>,
13404 {
13405 let mut table_id__ = None;
13406 let mut upstream_column_ids__ = None;
13407 let mut output_indices__ = None;
13408 let mut stream_scan_type__ = None;
13409 let mut state_table__ = None;
13410 let mut table_desc__ = None;
13411 let mut rate_limit__ = None;
13412 let mut snapshot_read_barrier_interval__ = None;
13413 let mut arrangement_table__ = None;
13414 let mut snapshot_backfill_epoch__ = None;
13415 while let Some(k) = map_.next_key()? {
13416 match k {
13417 GeneratedField::TableId => {
13418 if table_id__.is_some() {
13419 return Err(serde::de::Error::duplicate_field("tableId"));
13420 }
13421 table_id__ =
13422 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13423 ;
13424 }
13425 GeneratedField::UpstreamColumnIds => {
13426 if upstream_column_ids__.is_some() {
13427 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
13428 }
13429 upstream_column_ids__ =
13430 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13431 .into_iter().map(|x| x.0).collect())
13432 ;
13433 }
13434 GeneratedField::OutputIndices => {
13435 if output_indices__.is_some() {
13436 return Err(serde::de::Error::duplicate_field("outputIndices"));
13437 }
13438 output_indices__ =
13439 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13440 .into_iter().map(|x| x.0).collect())
13441 ;
13442 }
13443 GeneratedField::StreamScanType => {
13444 if stream_scan_type__.is_some() {
13445 return Err(serde::de::Error::duplicate_field("streamScanType"));
13446 }
13447 stream_scan_type__ = Some(map_.next_value::<StreamScanType>()? as i32);
13448 }
13449 GeneratedField::StateTable => {
13450 if state_table__.is_some() {
13451 return Err(serde::de::Error::duplicate_field("stateTable"));
13452 }
13453 state_table__ = map_.next_value()?;
13454 }
13455 GeneratedField::TableDesc => {
13456 if table_desc__.is_some() {
13457 return Err(serde::de::Error::duplicate_field("tableDesc"));
13458 }
13459 table_desc__ = map_.next_value()?;
13460 }
13461 GeneratedField::RateLimit => {
13462 if rate_limit__.is_some() {
13463 return Err(serde::de::Error::duplicate_field("rateLimit"));
13464 }
13465 rate_limit__ =
13466 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13467 ;
13468 }
13469 GeneratedField::SnapshotReadBarrierInterval => {
13470 if snapshot_read_barrier_interval__.is_some() {
13471 return Err(serde::de::Error::duplicate_field("snapshotReadBarrierInterval"));
13472 }
13473 snapshot_read_barrier_interval__ =
13474 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13475 ;
13476 }
13477 GeneratedField::ArrangementTable => {
13478 if arrangement_table__.is_some() {
13479 return Err(serde::de::Error::duplicate_field("arrangementTable"));
13480 }
13481 arrangement_table__ = map_.next_value()?;
13482 }
13483 GeneratedField::SnapshotBackfillEpoch => {
13484 if snapshot_backfill_epoch__.is_some() {
13485 return Err(serde::de::Error::duplicate_field("snapshotBackfillEpoch"));
13486 }
13487 snapshot_backfill_epoch__ =
13488 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13489 ;
13490 }
13491 }
13492 }
13493 Ok(StreamScanNode {
13494 table_id: table_id__.unwrap_or_default(),
13495 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
13496 output_indices: output_indices__.unwrap_or_default(),
13497 stream_scan_type: stream_scan_type__.unwrap_or_default(),
13498 state_table: state_table__,
13499 table_desc: table_desc__,
13500 rate_limit: rate_limit__,
13501 snapshot_read_barrier_interval: snapshot_read_barrier_interval__.unwrap_or_default(),
13502 arrangement_table: arrangement_table__,
13503 snapshot_backfill_epoch: snapshot_backfill_epoch__,
13504 })
13505 }
13506 }
13507 deserializer.deserialize_struct("stream_plan.StreamScanNode", FIELDS, GeneratedVisitor)
13508 }
13509}
13510impl serde::Serialize for StreamScanType {
13511 #[allow(deprecated)]
13512 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13513 where
13514 S: serde::Serializer,
13515 {
13516 let variant = match self {
13517 Self::Unspecified => "STREAM_SCAN_TYPE_UNSPECIFIED",
13518 Self::Chain => "STREAM_SCAN_TYPE_CHAIN",
13519 Self::Rearrange => "STREAM_SCAN_TYPE_REARRANGE",
13520 Self::Backfill => "STREAM_SCAN_TYPE_BACKFILL",
13521 Self::UpstreamOnly => "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
13522 Self::ArrangementBackfill => "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
13523 Self::SnapshotBackfill => "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
13524 Self::CrossDbSnapshotBackfill => "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
13525 };
13526 serializer.serialize_str(variant)
13527 }
13528}
13529impl<'de> serde::Deserialize<'de> for StreamScanType {
13530 #[allow(deprecated)]
13531 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13532 where
13533 D: serde::Deserializer<'de>,
13534 {
13535 const FIELDS: &[&str] = &[
13536 "STREAM_SCAN_TYPE_UNSPECIFIED",
13537 "STREAM_SCAN_TYPE_CHAIN",
13538 "STREAM_SCAN_TYPE_REARRANGE",
13539 "STREAM_SCAN_TYPE_BACKFILL",
13540 "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
13541 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
13542 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
13543 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
13544 ];
13545
13546 struct GeneratedVisitor;
13547
13548 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13549 type Value = StreamScanType;
13550
13551 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13552 write!(formatter, "expected one of: {:?}", &FIELDS)
13553 }
13554
13555 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13556 where
13557 E: serde::de::Error,
13558 {
13559 i32::try_from(v)
13560 .ok()
13561 .and_then(|x| x.try_into().ok())
13562 .ok_or_else(|| {
13563 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13564 })
13565 }
13566
13567 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13568 where
13569 E: serde::de::Error,
13570 {
13571 i32::try_from(v)
13572 .ok()
13573 .and_then(|x| x.try_into().ok())
13574 .ok_or_else(|| {
13575 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13576 })
13577 }
13578
13579 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13580 where
13581 E: serde::de::Error,
13582 {
13583 match value {
13584 "STREAM_SCAN_TYPE_UNSPECIFIED" => Ok(StreamScanType::Unspecified),
13585 "STREAM_SCAN_TYPE_CHAIN" => Ok(StreamScanType::Chain),
13586 "STREAM_SCAN_TYPE_REARRANGE" => Ok(StreamScanType::Rearrange),
13587 "STREAM_SCAN_TYPE_BACKFILL" => Ok(StreamScanType::Backfill),
13588 "STREAM_SCAN_TYPE_UPSTREAM_ONLY" => Ok(StreamScanType::UpstreamOnly),
13589 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL" => Ok(StreamScanType::ArrangementBackfill),
13590 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL" => Ok(StreamScanType::SnapshotBackfill),
13591 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL" => Ok(StreamScanType::CrossDbSnapshotBackfill),
13592 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13593 }
13594 }
13595 }
13596 deserializer.deserialize_any(GeneratedVisitor)
13597 }
13598}
13599impl serde::Serialize for StreamSource {
13600 #[allow(deprecated)]
13601 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13602 where
13603 S: serde::Serializer,
13604 {
13605 use serde::ser::SerializeStruct;
13606 let mut len = 0;
13607 if self.source_id != 0 {
13608 len += 1;
13609 }
13610 if self.state_table.is_some() {
13611 len += 1;
13612 }
13613 if self.row_id_index.is_some() {
13614 len += 1;
13615 }
13616 if !self.columns.is_empty() {
13617 len += 1;
13618 }
13619 if !self.with_properties.is_empty() {
13620 len += 1;
13621 }
13622 if self.info.is_some() {
13623 len += 1;
13624 }
13625 if !self.source_name.is_empty() {
13626 len += 1;
13627 }
13628 if self.rate_limit.is_some() {
13629 len += 1;
13630 }
13631 if !self.secret_refs.is_empty() {
13632 len += 1;
13633 }
13634 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamSource", len)?;
13635 if self.source_id != 0 {
13636 struct_ser.serialize_field("sourceId", &self.source_id)?;
13637 }
13638 if let Some(v) = self.state_table.as_ref() {
13639 struct_ser.serialize_field("stateTable", v)?;
13640 }
13641 if let Some(v) = self.row_id_index.as_ref() {
13642 struct_ser.serialize_field("rowIdIndex", v)?;
13643 }
13644 if !self.columns.is_empty() {
13645 struct_ser.serialize_field("columns", &self.columns)?;
13646 }
13647 if !self.with_properties.is_empty() {
13648 struct_ser.serialize_field("withProperties", &self.with_properties)?;
13649 }
13650 if let Some(v) = self.info.as_ref() {
13651 struct_ser.serialize_field("info", v)?;
13652 }
13653 if !self.source_name.is_empty() {
13654 struct_ser.serialize_field("sourceName", &self.source_name)?;
13655 }
13656 if let Some(v) = self.rate_limit.as_ref() {
13657 struct_ser.serialize_field("rateLimit", v)?;
13658 }
13659 if !self.secret_refs.is_empty() {
13660 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
13661 }
13662 struct_ser.end()
13663 }
13664}
13665impl<'de> serde::Deserialize<'de> for StreamSource {
13666 #[allow(deprecated)]
13667 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13668 where
13669 D: serde::Deserializer<'de>,
13670 {
13671 const FIELDS: &[&str] = &[
13672 "source_id",
13673 "sourceId",
13674 "state_table",
13675 "stateTable",
13676 "row_id_index",
13677 "rowIdIndex",
13678 "columns",
13679 "with_properties",
13680 "withProperties",
13681 "info",
13682 "source_name",
13683 "sourceName",
13684 "rate_limit",
13685 "rateLimit",
13686 "secret_refs",
13687 "secretRefs",
13688 ];
13689
13690 #[allow(clippy::enum_variant_names)]
13691 enum GeneratedField {
13692 SourceId,
13693 StateTable,
13694 RowIdIndex,
13695 Columns,
13696 WithProperties,
13697 Info,
13698 SourceName,
13699 RateLimit,
13700 SecretRefs,
13701 }
13702 impl<'de> serde::Deserialize<'de> for GeneratedField {
13703 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13704 where
13705 D: serde::Deserializer<'de>,
13706 {
13707 struct GeneratedVisitor;
13708
13709 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13710 type Value = GeneratedField;
13711
13712 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13713 write!(formatter, "expected one of: {:?}", &FIELDS)
13714 }
13715
13716 #[allow(unused_variables)]
13717 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13718 where
13719 E: serde::de::Error,
13720 {
13721 match value {
13722 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
13723 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
13724 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
13725 "columns" => Ok(GeneratedField::Columns),
13726 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
13727 "info" => Ok(GeneratedField::Info),
13728 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
13729 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
13730 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
13731 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13732 }
13733 }
13734 }
13735 deserializer.deserialize_identifier(GeneratedVisitor)
13736 }
13737 }
13738 struct GeneratedVisitor;
13739 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13740 type Value = StreamSource;
13741
13742 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13743 formatter.write_str("struct stream_plan.StreamSource")
13744 }
13745
13746 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSource, V::Error>
13747 where
13748 V: serde::de::MapAccess<'de>,
13749 {
13750 let mut source_id__ = None;
13751 let mut state_table__ = None;
13752 let mut row_id_index__ = None;
13753 let mut columns__ = None;
13754 let mut with_properties__ = None;
13755 let mut info__ = None;
13756 let mut source_name__ = None;
13757 let mut rate_limit__ = None;
13758 let mut secret_refs__ = None;
13759 while let Some(k) = map_.next_key()? {
13760 match k {
13761 GeneratedField::SourceId => {
13762 if source_id__.is_some() {
13763 return Err(serde::de::Error::duplicate_field("sourceId"));
13764 }
13765 source_id__ =
13766 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13767 ;
13768 }
13769 GeneratedField::StateTable => {
13770 if state_table__.is_some() {
13771 return Err(serde::de::Error::duplicate_field("stateTable"));
13772 }
13773 state_table__ = map_.next_value()?;
13774 }
13775 GeneratedField::RowIdIndex => {
13776 if row_id_index__.is_some() {
13777 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
13778 }
13779 row_id_index__ =
13780 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13781 ;
13782 }
13783 GeneratedField::Columns => {
13784 if columns__.is_some() {
13785 return Err(serde::de::Error::duplicate_field("columns"));
13786 }
13787 columns__ = Some(map_.next_value()?);
13788 }
13789 GeneratedField::WithProperties => {
13790 if with_properties__.is_some() {
13791 return Err(serde::de::Error::duplicate_field("withProperties"));
13792 }
13793 with_properties__ = Some(
13794 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13795 );
13796 }
13797 GeneratedField::Info => {
13798 if info__.is_some() {
13799 return Err(serde::de::Error::duplicate_field("info"));
13800 }
13801 info__ = map_.next_value()?;
13802 }
13803 GeneratedField::SourceName => {
13804 if source_name__.is_some() {
13805 return Err(serde::de::Error::duplicate_field("sourceName"));
13806 }
13807 source_name__ = Some(map_.next_value()?);
13808 }
13809 GeneratedField::RateLimit => {
13810 if rate_limit__.is_some() {
13811 return Err(serde::de::Error::duplicate_field("rateLimit"));
13812 }
13813 rate_limit__ =
13814 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13815 ;
13816 }
13817 GeneratedField::SecretRefs => {
13818 if secret_refs__.is_some() {
13819 return Err(serde::de::Error::duplicate_field("secretRefs"));
13820 }
13821 secret_refs__ = Some(
13822 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13823 );
13824 }
13825 }
13826 }
13827 Ok(StreamSource {
13828 source_id: source_id__.unwrap_or_default(),
13829 state_table: state_table__,
13830 row_id_index: row_id_index__,
13831 columns: columns__.unwrap_or_default(),
13832 with_properties: with_properties__.unwrap_or_default(),
13833 info: info__,
13834 source_name: source_name__.unwrap_or_default(),
13835 rate_limit: rate_limit__,
13836 secret_refs: secret_refs__.unwrap_or_default(),
13837 })
13838 }
13839 }
13840 deserializer.deserialize_struct("stream_plan.StreamSource", FIELDS, GeneratedVisitor)
13841 }
13842}
13843impl serde::Serialize for SubscriptionUpstreamInfo {
13844 #[allow(deprecated)]
13845 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13846 where
13847 S: serde::Serializer,
13848 {
13849 use serde::ser::SerializeStruct;
13850 let mut len = 0;
13851 if self.subscriber_id != 0 {
13852 len += 1;
13853 }
13854 if self.upstream_mv_table_id != 0 {
13855 len += 1;
13856 }
13857 let mut struct_ser = serializer.serialize_struct("stream_plan.SubscriptionUpstreamInfo", len)?;
13858 if self.subscriber_id != 0 {
13859 struct_ser.serialize_field("subscriberId", &self.subscriber_id)?;
13860 }
13861 if self.upstream_mv_table_id != 0 {
13862 struct_ser.serialize_field("upstreamMvTableId", &self.upstream_mv_table_id)?;
13863 }
13864 struct_ser.end()
13865 }
13866}
13867impl<'de> serde::Deserialize<'de> for SubscriptionUpstreamInfo {
13868 #[allow(deprecated)]
13869 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13870 where
13871 D: serde::Deserializer<'de>,
13872 {
13873 const FIELDS: &[&str] = &[
13874 "subscriber_id",
13875 "subscriberId",
13876 "upstream_mv_table_id",
13877 "upstreamMvTableId",
13878 ];
13879
13880 #[allow(clippy::enum_variant_names)]
13881 enum GeneratedField {
13882 SubscriberId,
13883 UpstreamMvTableId,
13884 }
13885 impl<'de> serde::Deserialize<'de> for GeneratedField {
13886 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13887 where
13888 D: serde::Deserializer<'de>,
13889 {
13890 struct GeneratedVisitor;
13891
13892 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13893 type Value = GeneratedField;
13894
13895 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13896 write!(formatter, "expected one of: {:?}", &FIELDS)
13897 }
13898
13899 #[allow(unused_variables)]
13900 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13901 where
13902 E: serde::de::Error,
13903 {
13904 match value {
13905 "subscriberId" | "subscriber_id" => Ok(GeneratedField::SubscriberId),
13906 "upstreamMvTableId" | "upstream_mv_table_id" => Ok(GeneratedField::UpstreamMvTableId),
13907 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13908 }
13909 }
13910 }
13911 deserializer.deserialize_identifier(GeneratedVisitor)
13912 }
13913 }
13914 struct GeneratedVisitor;
13915 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13916 type Value = SubscriptionUpstreamInfo;
13917
13918 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13919 formatter.write_str("struct stream_plan.SubscriptionUpstreamInfo")
13920 }
13921
13922 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscriptionUpstreamInfo, V::Error>
13923 where
13924 V: serde::de::MapAccess<'de>,
13925 {
13926 let mut subscriber_id__ = None;
13927 let mut upstream_mv_table_id__ = None;
13928 while let Some(k) = map_.next_key()? {
13929 match k {
13930 GeneratedField::SubscriberId => {
13931 if subscriber_id__.is_some() {
13932 return Err(serde::de::Error::duplicate_field("subscriberId"));
13933 }
13934 subscriber_id__ =
13935 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13936 ;
13937 }
13938 GeneratedField::UpstreamMvTableId => {
13939 if upstream_mv_table_id__.is_some() {
13940 return Err(serde::de::Error::duplicate_field("upstreamMvTableId"));
13941 }
13942 upstream_mv_table_id__ =
13943 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13944 ;
13945 }
13946 }
13947 }
13948 Ok(SubscriptionUpstreamInfo {
13949 subscriber_id: subscriber_id__.unwrap_or_default(),
13950 upstream_mv_table_id: upstream_mv_table_id__.unwrap_or_default(),
13951 })
13952 }
13953 }
13954 deserializer.deserialize_struct("stream_plan.SubscriptionUpstreamInfo", FIELDS, GeneratedVisitor)
13955 }
13956}
13957impl serde::Serialize for SyncLogStoreNode {
13958 #[allow(deprecated)]
13959 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13960 where
13961 S: serde::Serializer,
13962 {
13963 use serde::ser::SerializeStruct;
13964 let mut len = 0;
13965 if self.log_store_table.is_some() {
13966 len += 1;
13967 }
13968 if self.pause_duration_ms != 0 {
13969 len += 1;
13970 }
13971 if self.buffer_size != 0 {
13972 len += 1;
13973 }
13974 if self.aligned {
13975 len += 1;
13976 }
13977 let mut struct_ser = serializer.serialize_struct("stream_plan.SyncLogStoreNode", len)?;
13978 if let Some(v) = self.log_store_table.as_ref() {
13979 struct_ser.serialize_field("logStoreTable", v)?;
13980 }
13981 if self.pause_duration_ms != 0 {
13982 struct_ser.serialize_field("pauseDurationMs", &self.pause_duration_ms)?;
13983 }
13984 if self.buffer_size != 0 {
13985 struct_ser.serialize_field("bufferSize", &self.buffer_size)?;
13986 }
13987 if self.aligned {
13988 struct_ser.serialize_field("aligned", &self.aligned)?;
13989 }
13990 struct_ser.end()
13991 }
13992}
13993impl<'de> serde::Deserialize<'de> for SyncLogStoreNode {
13994 #[allow(deprecated)]
13995 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13996 where
13997 D: serde::Deserializer<'de>,
13998 {
13999 const FIELDS: &[&str] = &[
14000 "log_store_table",
14001 "logStoreTable",
14002 "pause_duration_ms",
14003 "pauseDurationMs",
14004 "buffer_size",
14005 "bufferSize",
14006 "aligned",
14007 ];
14008
14009 #[allow(clippy::enum_variant_names)]
14010 enum GeneratedField {
14011 LogStoreTable,
14012 PauseDurationMs,
14013 BufferSize,
14014 Aligned,
14015 }
14016 impl<'de> serde::Deserialize<'de> for GeneratedField {
14017 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14018 where
14019 D: serde::Deserializer<'de>,
14020 {
14021 struct GeneratedVisitor;
14022
14023 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14024 type Value = GeneratedField;
14025
14026 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14027 write!(formatter, "expected one of: {:?}", &FIELDS)
14028 }
14029
14030 #[allow(unused_variables)]
14031 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14032 where
14033 E: serde::de::Error,
14034 {
14035 match value {
14036 "logStoreTable" | "log_store_table" => Ok(GeneratedField::LogStoreTable),
14037 "pauseDurationMs" | "pause_duration_ms" => Ok(GeneratedField::PauseDurationMs),
14038 "bufferSize" | "buffer_size" => Ok(GeneratedField::BufferSize),
14039 "aligned" => Ok(GeneratedField::Aligned),
14040 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14041 }
14042 }
14043 }
14044 deserializer.deserialize_identifier(GeneratedVisitor)
14045 }
14046 }
14047 struct GeneratedVisitor;
14048 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14049 type Value = SyncLogStoreNode;
14050
14051 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14052 formatter.write_str("struct stream_plan.SyncLogStoreNode")
14053 }
14054
14055 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SyncLogStoreNode, V::Error>
14056 where
14057 V: serde::de::MapAccess<'de>,
14058 {
14059 let mut log_store_table__ = None;
14060 let mut pause_duration_ms__ = None;
14061 let mut buffer_size__ = None;
14062 let mut aligned__ = None;
14063 while let Some(k) = map_.next_key()? {
14064 match k {
14065 GeneratedField::LogStoreTable => {
14066 if log_store_table__.is_some() {
14067 return Err(serde::de::Error::duplicate_field("logStoreTable"));
14068 }
14069 log_store_table__ = map_.next_value()?;
14070 }
14071 GeneratedField::PauseDurationMs => {
14072 if pause_duration_ms__.is_some() {
14073 return Err(serde::de::Error::duplicate_field("pauseDurationMs"));
14074 }
14075 pause_duration_ms__ =
14076 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14077 ;
14078 }
14079 GeneratedField::BufferSize => {
14080 if buffer_size__.is_some() {
14081 return Err(serde::de::Error::duplicate_field("bufferSize"));
14082 }
14083 buffer_size__ =
14084 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14085 ;
14086 }
14087 GeneratedField::Aligned => {
14088 if aligned__.is_some() {
14089 return Err(serde::de::Error::duplicate_field("aligned"));
14090 }
14091 aligned__ = Some(map_.next_value()?);
14092 }
14093 }
14094 }
14095 Ok(SyncLogStoreNode {
14096 log_store_table: log_store_table__,
14097 pause_duration_ms: pause_duration_ms__.unwrap_or_default(),
14098 buffer_size: buffer_size__.unwrap_or_default(),
14099 aligned: aligned__.unwrap_or_default(),
14100 })
14101 }
14102 }
14103 deserializer.deserialize_struct("stream_plan.SyncLogStoreNode", FIELDS, GeneratedVisitor)
14104 }
14105}
14106impl serde::Serialize for TemporalJoinNode {
14107 #[allow(deprecated)]
14108 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14109 where
14110 S: serde::Serializer,
14111 {
14112 use serde::ser::SerializeStruct;
14113 let mut len = 0;
14114 if self.join_type != 0 {
14115 len += 1;
14116 }
14117 if !self.left_key.is_empty() {
14118 len += 1;
14119 }
14120 if !self.right_key.is_empty() {
14121 len += 1;
14122 }
14123 if !self.null_safe.is_empty() {
14124 len += 1;
14125 }
14126 if self.condition.is_some() {
14127 len += 1;
14128 }
14129 if !self.output_indices.is_empty() {
14130 len += 1;
14131 }
14132 if self.table_desc.is_some() {
14133 len += 1;
14134 }
14135 if !self.table_output_indices.is_empty() {
14136 len += 1;
14137 }
14138 if self.memo_table.is_some() {
14139 len += 1;
14140 }
14141 if self.is_nested_loop {
14142 len += 1;
14143 }
14144 let mut struct_ser = serializer.serialize_struct("stream_plan.TemporalJoinNode", len)?;
14145 if self.join_type != 0 {
14146 let v = super::plan_common::JoinType::try_from(self.join_type)
14147 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
14148 struct_ser.serialize_field("joinType", &v)?;
14149 }
14150 if !self.left_key.is_empty() {
14151 struct_ser.serialize_field("leftKey", &self.left_key)?;
14152 }
14153 if !self.right_key.is_empty() {
14154 struct_ser.serialize_field("rightKey", &self.right_key)?;
14155 }
14156 if !self.null_safe.is_empty() {
14157 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
14158 }
14159 if let Some(v) = self.condition.as_ref() {
14160 struct_ser.serialize_field("condition", v)?;
14161 }
14162 if !self.output_indices.is_empty() {
14163 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
14164 }
14165 if let Some(v) = self.table_desc.as_ref() {
14166 struct_ser.serialize_field("tableDesc", v)?;
14167 }
14168 if !self.table_output_indices.is_empty() {
14169 struct_ser.serialize_field("tableOutputIndices", &self.table_output_indices)?;
14170 }
14171 if let Some(v) = self.memo_table.as_ref() {
14172 struct_ser.serialize_field("memoTable", v)?;
14173 }
14174 if self.is_nested_loop {
14175 struct_ser.serialize_field("isNestedLoop", &self.is_nested_loop)?;
14176 }
14177 struct_ser.end()
14178 }
14179}
14180impl<'de> serde::Deserialize<'de> for TemporalJoinNode {
14181 #[allow(deprecated)]
14182 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14183 where
14184 D: serde::Deserializer<'de>,
14185 {
14186 const FIELDS: &[&str] = &[
14187 "join_type",
14188 "joinType",
14189 "left_key",
14190 "leftKey",
14191 "right_key",
14192 "rightKey",
14193 "null_safe",
14194 "nullSafe",
14195 "condition",
14196 "output_indices",
14197 "outputIndices",
14198 "table_desc",
14199 "tableDesc",
14200 "table_output_indices",
14201 "tableOutputIndices",
14202 "memo_table",
14203 "memoTable",
14204 "is_nested_loop",
14205 "isNestedLoop",
14206 ];
14207
14208 #[allow(clippy::enum_variant_names)]
14209 enum GeneratedField {
14210 JoinType,
14211 LeftKey,
14212 RightKey,
14213 NullSafe,
14214 Condition,
14215 OutputIndices,
14216 TableDesc,
14217 TableOutputIndices,
14218 MemoTable,
14219 IsNestedLoop,
14220 }
14221 impl<'de> serde::Deserialize<'de> for GeneratedField {
14222 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14223 where
14224 D: serde::Deserializer<'de>,
14225 {
14226 struct GeneratedVisitor;
14227
14228 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14229 type Value = GeneratedField;
14230
14231 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14232 write!(formatter, "expected one of: {:?}", &FIELDS)
14233 }
14234
14235 #[allow(unused_variables)]
14236 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14237 where
14238 E: serde::de::Error,
14239 {
14240 match value {
14241 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
14242 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
14243 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
14244 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
14245 "condition" => Ok(GeneratedField::Condition),
14246 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
14247 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
14248 "tableOutputIndices" | "table_output_indices" => Ok(GeneratedField::TableOutputIndices),
14249 "memoTable" | "memo_table" => Ok(GeneratedField::MemoTable),
14250 "isNestedLoop" | "is_nested_loop" => Ok(GeneratedField::IsNestedLoop),
14251 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14252 }
14253 }
14254 }
14255 deserializer.deserialize_identifier(GeneratedVisitor)
14256 }
14257 }
14258 struct GeneratedVisitor;
14259 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14260 type Value = TemporalJoinNode;
14261
14262 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14263 formatter.write_str("struct stream_plan.TemporalJoinNode")
14264 }
14265
14266 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TemporalJoinNode, V::Error>
14267 where
14268 V: serde::de::MapAccess<'de>,
14269 {
14270 let mut join_type__ = None;
14271 let mut left_key__ = None;
14272 let mut right_key__ = None;
14273 let mut null_safe__ = None;
14274 let mut condition__ = None;
14275 let mut output_indices__ = None;
14276 let mut table_desc__ = None;
14277 let mut table_output_indices__ = None;
14278 let mut memo_table__ = None;
14279 let mut is_nested_loop__ = None;
14280 while let Some(k) = map_.next_key()? {
14281 match k {
14282 GeneratedField::JoinType => {
14283 if join_type__.is_some() {
14284 return Err(serde::de::Error::duplicate_field("joinType"));
14285 }
14286 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
14287 }
14288 GeneratedField::LeftKey => {
14289 if left_key__.is_some() {
14290 return Err(serde::de::Error::duplicate_field("leftKey"));
14291 }
14292 left_key__ =
14293 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14294 .into_iter().map(|x| x.0).collect())
14295 ;
14296 }
14297 GeneratedField::RightKey => {
14298 if right_key__.is_some() {
14299 return Err(serde::de::Error::duplicate_field("rightKey"));
14300 }
14301 right_key__ =
14302 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14303 .into_iter().map(|x| x.0).collect())
14304 ;
14305 }
14306 GeneratedField::NullSafe => {
14307 if null_safe__.is_some() {
14308 return Err(serde::de::Error::duplicate_field("nullSafe"));
14309 }
14310 null_safe__ = Some(map_.next_value()?);
14311 }
14312 GeneratedField::Condition => {
14313 if condition__.is_some() {
14314 return Err(serde::de::Error::duplicate_field("condition"));
14315 }
14316 condition__ = map_.next_value()?;
14317 }
14318 GeneratedField::OutputIndices => {
14319 if output_indices__.is_some() {
14320 return Err(serde::de::Error::duplicate_field("outputIndices"));
14321 }
14322 output_indices__ =
14323 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14324 .into_iter().map(|x| x.0).collect())
14325 ;
14326 }
14327 GeneratedField::TableDesc => {
14328 if table_desc__.is_some() {
14329 return Err(serde::de::Error::duplicate_field("tableDesc"));
14330 }
14331 table_desc__ = map_.next_value()?;
14332 }
14333 GeneratedField::TableOutputIndices => {
14334 if table_output_indices__.is_some() {
14335 return Err(serde::de::Error::duplicate_field("tableOutputIndices"));
14336 }
14337 table_output_indices__ =
14338 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14339 .into_iter().map(|x| x.0).collect())
14340 ;
14341 }
14342 GeneratedField::MemoTable => {
14343 if memo_table__.is_some() {
14344 return Err(serde::de::Error::duplicate_field("memoTable"));
14345 }
14346 memo_table__ = map_.next_value()?;
14347 }
14348 GeneratedField::IsNestedLoop => {
14349 if is_nested_loop__.is_some() {
14350 return Err(serde::de::Error::duplicate_field("isNestedLoop"));
14351 }
14352 is_nested_loop__ = Some(map_.next_value()?);
14353 }
14354 }
14355 }
14356 Ok(TemporalJoinNode {
14357 join_type: join_type__.unwrap_or_default(),
14358 left_key: left_key__.unwrap_or_default(),
14359 right_key: right_key__.unwrap_or_default(),
14360 null_safe: null_safe__.unwrap_or_default(),
14361 condition: condition__,
14362 output_indices: output_indices__.unwrap_or_default(),
14363 table_desc: table_desc__,
14364 table_output_indices: table_output_indices__.unwrap_or_default(),
14365 memo_table: memo_table__,
14366 is_nested_loop: is_nested_loop__.unwrap_or_default(),
14367 })
14368 }
14369 }
14370 deserializer.deserialize_struct("stream_plan.TemporalJoinNode", FIELDS, GeneratedVisitor)
14371 }
14372}
14373impl serde::Serialize for ThrottleMutation {
14374 #[allow(deprecated)]
14375 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14376 where
14377 S: serde::Serializer,
14378 {
14379 use serde::ser::SerializeStruct;
14380 let mut len = 0;
14381 if !self.actor_throttle.is_empty() {
14382 len += 1;
14383 }
14384 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation", len)?;
14385 if !self.actor_throttle.is_empty() {
14386 struct_ser.serialize_field("actorThrottle", &self.actor_throttle)?;
14387 }
14388 struct_ser.end()
14389 }
14390}
14391impl<'de> serde::Deserialize<'de> for ThrottleMutation {
14392 #[allow(deprecated)]
14393 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14394 where
14395 D: serde::Deserializer<'de>,
14396 {
14397 const FIELDS: &[&str] = &[
14398 "actor_throttle",
14399 "actorThrottle",
14400 ];
14401
14402 #[allow(clippy::enum_variant_names)]
14403 enum GeneratedField {
14404 ActorThrottle,
14405 }
14406 impl<'de> serde::Deserialize<'de> for GeneratedField {
14407 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14408 where
14409 D: serde::Deserializer<'de>,
14410 {
14411 struct GeneratedVisitor;
14412
14413 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14414 type Value = GeneratedField;
14415
14416 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14417 write!(formatter, "expected one of: {:?}", &FIELDS)
14418 }
14419
14420 #[allow(unused_variables)]
14421 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14422 where
14423 E: serde::de::Error,
14424 {
14425 match value {
14426 "actorThrottle" | "actor_throttle" => Ok(GeneratedField::ActorThrottle),
14427 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14428 }
14429 }
14430 }
14431 deserializer.deserialize_identifier(GeneratedVisitor)
14432 }
14433 }
14434 struct GeneratedVisitor;
14435 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14436 type Value = ThrottleMutation;
14437
14438 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14439 formatter.write_str("struct stream_plan.ThrottleMutation")
14440 }
14441
14442 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ThrottleMutation, V::Error>
14443 where
14444 V: serde::de::MapAccess<'de>,
14445 {
14446 let mut actor_throttle__ = None;
14447 while let Some(k) = map_.next_key()? {
14448 match k {
14449 GeneratedField::ActorThrottle => {
14450 if actor_throttle__.is_some() {
14451 return Err(serde::de::Error::duplicate_field("actorThrottle"));
14452 }
14453 actor_throttle__ = Some(
14454 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14455 .into_iter().map(|(k,v)| (k.0, v)).collect()
14456 );
14457 }
14458 }
14459 }
14460 Ok(ThrottleMutation {
14461 actor_throttle: actor_throttle__.unwrap_or_default(),
14462 })
14463 }
14464 }
14465 deserializer.deserialize_struct("stream_plan.ThrottleMutation", FIELDS, GeneratedVisitor)
14466 }
14467}
14468impl serde::Serialize for throttle_mutation::RateLimit {
14469 #[allow(deprecated)]
14470 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14471 where
14472 S: serde::Serializer,
14473 {
14474 use serde::ser::SerializeStruct;
14475 let mut len = 0;
14476 if self.rate_limit.is_some() {
14477 len += 1;
14478 }
14479 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation.RateLimit", len)?;
14480 if let Some(v) = self.rate_limit.as_ref() {
14481 struct_ser.serialize_field("rateLimit", v)?;
14482 }
14483 struct_ser.end()
14484 }
14485}
14486impl<'de> serde::Deserialize<'de> for throttle_mutation::RateLimit {
14487 #[allow(deprecated)]
14488 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14489 where
14490 D: serde::Deserializer<'de>,
14491 {
14492 const FIELDS: &[&str] = &[
14493 "rate_limit",
14494 "rateLimit",
14495 ];
14496
14497 #[allow(clippy::enum_variant_names)]
14498 enum GeneratedField {
14499 RateLimit,
14500 }
14501 impl<'de> serde::Deserialize<'de> for GeneratedField {
14502 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14503 where
14504 D: serde::Deserializer<'de>,
14505 {
14506 struct GeneratedVisitor;
14507
14508 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14509 type Value = GeneratedField;
14510
14511 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14512 write!(formatter, "expected one of: {:?}", &FIELDS)
14513 }
14514
14515 #[allow(unused_variables)]
14516 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14517 where
14518 E: serde::de::Error,
14519 {
14520 match value {
14521 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
14522 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14523 }
14524 }
14525 }
14526 deserializer.deserialize_identifier(GeneratedVisitor)
14527 }
14528 }
14529 struct GeneratedVisitor;
14530 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14531 type Value = throttle_mutation::RateLimit;
14532
14533 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14534 formatter.write_str("struct stream_plan.ThrottleMutation.RateLimit")
14535 }
14536
14537 fn visit_map<V>(self, mut map_: V) -> std::result::Result<throttle_mutation::RateLimit, V::Error>
14538 where
14539 V: serde::de::MapAccess<'de>,
14540 {
14541 let mut rate_limit__ = None;
14542 while let Some(k) = map_.next_key()? {
14543 match k {
14544 GeneratedField::RateLimit => {
14545 if rate_limit__.is_some() {
14546 return Err(serde::de::Error::duplicate_field("rateLimit"));
14547 }
14548 rate_limit__ =
14549 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14550 ;
14551 }
14552 }
14553 }
14554 Ok(throttle_mutation::RateLimit {
14555 rate_limit: rate_limit__,
14556 })
14557 }
14558 }
14559 deserializer.deserialize_struct("stream_plan.ThrottleMutation.RateLimit", FIELDS, GeneratedVisitor)
14560 }
14561}
14562impl serde::Serialize for TopNNode {
14563 #[allow(deprecated)]
14564 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14565 where
14566 S: serde::Serializer,
14567 {
14568 use serde::ser::SerializeStruct;
14569 let mut len = 0;
14570 if self.limit != 0 {
14571 len += 1;
14572 }
14573 if self.offset != 0 {
14574 len += 1;
14575 }
14576 if self.table.is_some() {
14577 len += 1;
14578 }
14579 if !self.order_by.is_empty() {
14580 len += 1;
14581 }
14582 if self.with_ties {
14583 len += 1;
14584 }
14585 let mut struct_ser = serializer.serialize_struct("stream_plan.TopNNode", len)?;
14586 if self.limit != 0 {
14587 #[allow(clippy::needless_borrow)]
14588 #[allow(clippy::needless_borrows_for_generic_args)]
14589 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
14590 }
14591 if self.offset != 0 {
14592 #[allow(clippy::needless_borrow)]
14593 #[allow(clippy::needless_borrows_for_generic_args)]
14594 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
14595 }
14596 if let Some(v) = self.table.as_ref() {
14597 struct_ser.serialize_field("table", v)?;
14598 }
14599 if !self.order_by.is_empty() {
14600 struct_ser.serialize_field("orderBy", &self.order_by)?;
14601 }
14602 if self.with_ties {
14603 struct_ser.serialize_field("withTies", &self.with_ties)?;
14604 }
14605 struct_ser.end()
14606 }
14607}
14608impl<'de> serde::Deserialize<'de> for TopNNode {
14609 #[allow(deprecated)]
14610 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14611 where
14612 D: serde::Deserializer<'de>,
14613 {
14614 const FIELDS: &[&str] = &[
14615 "limit",
14616 "offset",
14617 "table",
14618 "order_by",
14619 "orderBy",
14620 "with_ties",
14621 "withTies",
14622 ];
14623
14624 #[allow(clippy::enum_variant_names)]
14625 enum GeneratedField {
14626 Limit,
14627 Offset,
14628 Table,
14629 OrderBy,
14630 WithTies,
14631 }
14632 impl<'de> serde::Deserialize<'de> for GeneratedField {
14633 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14634 where
14635 D: serde::Deserializer<'de>,
14636 {
14637 struct GeneratedVisitor;
14638
14639 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14640 type Value = GeneratedField;
14641
14642 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14643 write!(formatter, "expected one of: {:?}", &FIELDS)
14644 }
14645
14646 #[allow(unused_variables)]
14647 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14648 where
14649 E: serde::de::Error,
14650 {
14651 match value {
14652 "limit" => Ok(GeneratedField::Limit),
14653 "offset" => Ok(GeneratedField::Offset),
14654 "table" => Ok(GeneratedField::Table),
14655 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
14656 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
14657 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14658 }
14659 }
14660 }
14661 deserializer.deserialize_identifier(GeneratedVisitor)
14662 }
14663 }
14664 struct GeneratedVisitor;
14665 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14666 type Value = TopNNode;
14667
14668 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14669 formatter.write_str("struct stream_plan.TopNNode")
14670 }
14671
14672 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
14673 where
14674 V: serde::de::MapAccess<'de>,
14675 {
14676 let mut limit__ = None;
14677 let mut offset__ = None;
14678 let mut table__ = None;
14679 let mut order_by__ = None;
14680 let mut with_ties__ = None;
14681 while let Some(k) = map_.next_key()? {
14682 match k {
14683 GeneratedField::Limit => {
14684 if limit__.is_some() {
14685 return Err(serde::de::Error::duplicate_field("limit"));
14686 }
14687 limit__ =
14688 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14689 ;
14690 }
14691 GeneratedField::Offset => {
14692 if offset__.is_some() {
14693 return Err(serde::de::Error::duplicate_field("offset"));
14694 }
14695 offset__ =
14696 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14697 ;
14698 }
14699 GeneratedField::Table => {
14700 if table__.is_some() {
14701 return Err(serde::de::Error::duplicate_field("table"));
14702 }
14703 table__ = map_.next_value()?;
14704 }
14705 GeneratedField::OrderBy => {
14706 if order_by__.is_some() {
14707 return Err(serde::de::Error::duplicate_field("orderBy"));
14708 }
14709 order_by__ = Some(map_.next_value()?);
14710 }
14711 GeneratedField::WithTies => {
14712 if with_ties__.is_some() {
14713 return Err(serde::de::Error::duplicate_field("withTies"));
14714 }
14715 with_ties__ = Some(map_.next_value()?);
14716 }
14717 }
14718 }
14719 Ok(TopNNode {
14720 limit: limit__.unwrap_or_default(),
14721 offset: offset__.unwrap_or_default(),
14722 table: table__,
14723 order_by: order_by__.unwrap_or_default(),
14724 with_ties: with_ties__.unwrap_or_default(),
14725 })
14726 }
14727 }
14728 deserializer.deserialize_struct("stream_plan.TopNNode", FIELDS, GeneratedVisitor)
14729 }
14730}
14731impl serde::Serialize for UnionNode {
14732 #[allow(deprecated)]
14733 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14734 where
14735 S: serde::Serializer,
14736 {
14737 use serde::ser::SerializeStruct;
14738 let len = 0;
14739 let struct_ser = serializer.serialize_struct("stream_plan.UnionNode", len)?;
14740 struct_ser.end()
14741 }
14742}
14743impl<'de> serde::Deserialize<'de> for UnionNode {
14744 #[allow(deprecated)]
14745 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14746 where
14747 D: serde::Deserializer<'de>,
14748 {
14749 const FIELDS: &[&str] = &[
14750 ];
14751
14752 #[allow(clippy::enum_variant_names)]
14753 enum GeneratedField {
14754 }
14755 impl<'de> serde::Deserialize<'de> for GeneratedField {
14756 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14757 where
14758 D: serde::Deserializer<'de>,
14759 {
14760 struct GeneratedVisitor;
14761
14762 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14763 type Value = GeneratedField;
14764
14765 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14766 write!(formatter, "expected one of: {:?}", &FIELDS)
14767 }
14768
14769 #[allow(unused_variables)]
14770 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14771 where
14772 E: serde::de::Error,
14773 {
14774 Err(serde::de::Error::unknown_field(value, FIELDS))
14775 }
14776 }
14777 deserializer.deserialize_identifier(GeneratedVisitor)
14778 }
14779 }
14780 struct GeneratedVisitor;
14781 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14782 type Value = UnionNode;
14783
14784 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14785 formatter.write_str("struct stream_plan.UnionNode")
14786 }
14787
14788 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
14789 where
14790 V: serde::de::MapAccess<'de>,
14791 {
14792 while map_.next_key::<GeneratedField>()?.is_some() {
14793 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14794 }
14795 Ok(UnionNode {
14796 })
14797 }
14798 }
14799 deserializer.deserialize_struct("stream_plan.UnionNode", FIELDS, GeneratedVisitor)
14800 }
14801}
14802impl serde::Serialize for UpdateMutation {
14803 #[allow(deprecated)]
14804 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14805 where
14806 S: serde::Serializer,
14807 {
14808 use serde::ser::SerializeStruct;
14809 let mut len = 0;
14810 if !self.dispatcher_update.is_empty() {
14811 len += 1;
14812 }
14813 if !self.merge_update.is_empty() {
14814 len += 1;
14815 }
14816 if !self.actor_vnode_bitmap_update.is_empty() {
14817 len += 1;
14818 }
14819 if !self.dropped_actors.is_empty() {
14820 len += 1;
14821 }
14822 if !self.actor_splits.is_empty() {
14823 len += 1;
14824 }
14825 if !self.actor_new_dispatchers.is_empty() {
14826 len += 1;
14827 }
14828 if self.actor_cdc_table_snapshot_splits.is_some() {
14829 len += 1;
14830 }
14831 if !self.sink_add_columns.is_empty() {
14832 len += 1;
14833 }
14834 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation", len)?;
14835 if !self.dispatcher_update.is_empty() {
14836 struct_ser.serialize_field("dispatcherUpdate", &self.dispatcher_update)?;
14837 }
14838 if !self.merge_update.is_empty() {
14839 struct_ser.serialize_field("mergeUpdate", &self.merge_update)?;
14840 }
14841 if !self.actor_vnode_bitmap_update.is_empty() {
14842 struct_ser.serialize_field("actorVnodeBitmapUpdate", &self.actor_vnode_bitmap_update)?;
14843 }
14844 if !self.dropped_actors.is_empty() {
14845 struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
14846 }
14847 if !self.actor_splits.is_empty() {
14848 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
14849 }
14850 if !self.actor_new_dispatchers.is_empty() {
14851 struct_ser.serialize_field("actorNewDispatchers", &self.actor_new_dispatchers)?;
14852 }
14853 if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
14854 struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
14855 }
14856 if !self.sink_add_columns.is_empty() {
14857 struct_ser.serialize_field("sinkAddColumns", &self.sink_add_columns)?;
14858 }
14859 struct_ser.end()
14860 }
14861}
14862impl<'de> serde::Deserialize<'de> for UpdateMutation {
14863 #[allow(deprecated)]
14864 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14865 where
14866 D: serde::Deserializer<'de>,
14867 {
14868 const FIELDS: &[&str] = &[
14869 "dispatcher_update",
14870 "dispatcherUpdate",
14871 "merge_update",
14872 "mergeUpdate",
14873 "actor_vnode_bitmap_update",
14874 "actorVnodeBitmapUpdate",
14875 "dropped_actors",
14876 "droppedActors",
14877 "actor_splits",
14878 "actorSplits",
14879 "actor_new_dispatchers",
14880 "actorNewDispatchers",
14881 "actor_cdc_table_snapshot_splits",
14882 "actorCdcTableSnapshotSplits",
14883 "sink_add_columns",
14884 "sinkAddColumns",
14885 ];
14886
14887 #[allow(clippy::enum_variant_names)]
14888 enum GeneratedField {
14889 DispatcherUpdate,
14890 MergeUpdate,
14891 ActorVnodeBitmapUpdate,
14892 DroppedActors,
14893 ActorSplits,
14894 ActorNewDispatchers,
14895 ActorCdcTableSnapshotSplits,
14896 SinkAddColumns,
14897 }
14898 impl<'de> serde::Deserialize<'de> for GeneratedField {
14899 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14900 where
14901 D: serde::Deserializer<'de>,
14902 {
14903 struct GeneratedVisitor;
14904
14905 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14906 type Value = GeneratedField;
14907
14908 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14909 write!(formatter, "expected one of: {:?}", &FIELDS)
14910 }
14911
14912 #[allow(unused_variables)]
14913 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14914 where
14915 E: serde::de::Error,
14916 {
14917 match value {
14918 "dispatcherUpdate" | "dispatcher_update" => Ok(GeneratedField::DispatcherUpdate),
14919 "mergeUpdate" | "merge_update" => Ok(GeneratedField::MergeUpdate),
14920 "actorVnodeBitmapUpdate" | "actor_vnode_bitmap_update" => Ok(GeneratedField::ActorVnodeBitmapUpdate),
14921 "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
14922 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
14923 "actorNewDispatchers" | "actor_new_dispatchers" => Ok(GeneratedField::ActorNewDispatchers),
14924 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
14925 "sinkAddColumns" | "sink_add_columns" => Ok(GeneratedField::SinkAddColumns),
14926 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14927 }
14928 }
14929 }
14930 deserializer.deserialize_identifier(GeneratedVisitor)
14931 }
14932 }
14933 struct GeneratedVisitor;
14934 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14935 type Value = UpdateMutation;
14936
14937 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14938 formatter.write_str("struct stream_plan.UpdateMutation")
14939 }
14940
14941 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateMutation, V::Error>
14942 where
14943 V: serde::de::MapAccess<'de>,
14944 {
14945 let mut dispatcher_update__ = None;
14946 let mut merge_update__ = None;
14947 let mut actor_vnode_bitmap_update__ = None;
14948 let mut dropped_actors__ = None;
14949 let mut actor_splits__ = None;
14950 let mut actor_new_dispatchers__ = None;
14951 let mut actor_cdc_table_snapshot_splits__ = None;
14952 let mut sink_add_columns__ = None;
14953 while let Some(k) = map_.next_key()? {
14954 match k {
14955 GeneratedField::DispatcherUpdate => {
14956 if dispatcher_update__.is_some() {
14957 return Err(serde::de::Error::duplicate_field("dispatcherUpdate"));
14958 }
14959 dispatcher_update__ = Some(map_.next_value()?);
14960 }
14961 GeneratedField::MergeUpdate => {
14962 if merge_update__.is_some() {
14963 return Err(serde::de::Error::duplicate_field("mergeUpdate"));
14964 }
14965 merge_update__ = Some(map_.next_value()?);
14966 }
14967 GeneratedField::ActorVnodeBitmapUpdate => {
14968 if actor_vnode_bitmap_update__.is_some() {
14969 return Err(serde::de::Error::duplicate_field("actorVnodeBitmapUpdate"));
14970 }
14971 actor_vnode_bitmap_update__ = Some(
14972 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14973 .into_iter().map(|(k,v)| (k.0, v)).collect()
14974 );
14975 }
14976 GeneratedField::DroppedActors => {
14977 if dropped_actors__.is_some() {
14978 return Err(serde::de::Error::duplicate_field("droppedActors"));
14979 }
14980 dropped_actors__ =
14981 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14982 .into_iter().map(|x| x.0).collect())
14983 ;
14984 }
14985 GeneratedField::ActorSplits => {
14986 if actor_splits__.is_some() {
14987 return Err(serde::de::Error::duplicate_field("actorSplits"));
14988 }
14989 actor_splits__ = Some(
14990 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14991 .into_iter().map(|(k,v)| (k.0, v)).collect()
14992 );
14993 }
14994 GeneratedField::ActorNewDispatchers => {
14995 if actor_new_dispatchers__.is_some() {
14996 return Err(serde::de::Error::duplicate_field("actorNewDispatchers"));
14997 }
14998 actor_new_dispatchers__ = Some(
14999 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15000 .into_iter().map(|(k,v)| (k.0, v)).collect()
15001 );
15002 }
15003 GeneratedField::ActorCdcTableSnapshotSplits => {
15004 if actor_cdc_table_snapshot_splits__.is_some() {
15005 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
15006 }
15007 actor_cdc_table_snapshot_splits__ = map_.next_value()?;
15008 }
15009 GeneratedField::SinkAddColumns => {
15010 if sink_add_columns__.is_some() {
15011 return Err(serde::de::Error::duplicate_field("sinkAddColumns"));
15012 }
15013 sink_add_columns__ = Some(
15014 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15015 .into_iter().map(|(k,v)| (k.0, v)).collect()
15016 );
15017 }
15018 }
15019 }
15020 Ok(UpdateMutation {
15021 dispatcher_update: dispatcher_update__.unwrap_or_default(),
15022 merge_update: merge_update__.unwrap_or_default(),
15023 actor_vnode_bitmap_update: actor_vnode_bitmap_update__.unwrap_or_default(),
15024 dropped_actors: dropped_actors__.unwrap_or_default(),
15025 actor_splits: actor_splits__.unwrap_or_default(),
15026 actor_new_dispatchers: actor_new_dispatchers__.unwrap_or_default(),
15027 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
15028 sink_add_columns: sink_add_columns__.unwrap_or_default(),
15029 })
15030 }
15031 }
15032 deserializer.deserialize_struct("stream_plan.UpdateMutation", FIELDS, GeneratedVisitor)
15033 }
15034}
15035impl serde::Serialize for update_mutation::DispatcherUpdate {
15036 #[allow(deprecated)]
15037 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15038 where
15039 S: serde::Serializer,
15040 {
15041 use serde::ser::SerializeStruct;
15042 let mut len = 0;
15043 if self.actor_id != 0 {
15044 len += 1;
15045 }
15046 if self.dispatcher_id != 0 {
15047 len += 1;
15048 }
15049 if self.hash_mapping.is_some() {
15050 len += 1;
15051 }
15052 if !self.added_downstream_actor_id.is_empty() {
15053 len += 1;
15054 }
15055 if !self.removed_downstream_actor_id.is_empty() {
15056 len += 1;
15057 }
15058 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", len)?;
15059 if self.actor_id != 0 {
15060 struct_ser.serialize_field("actorId", &self.actor_id)?;
15061 }
15062 if self.dispatcher_id != 0 {
15063 #[allow(clippy::needless_borrow)]
15064 #[allow(clippy::needless_borrows_for_generic_args)]
15065 struct_ser.serialize_field("dispatcherId", ToString::to_string(&self.dispatcher_id).as_str())?;
15066 }
15067 if let Some(v) = self.hash_mapping.as_ref() {
15068 struct_ser.serialize_field("hashMapping", v)?;
15069 }
15070 if !self.added_downstream_actor_id.is_empty() {
15071 struct_ser.serialize_field("addedDownstreamActorId", &self.added_downstream_actor_id)?;
15072 }
15073 if !self.removed_downstream_actor_id.is_empty() {
15074 struct_ser.serialize_field("removedDownstreamActorId", &self.removed_downstream_actor_id)?;
15075 }
15076 struct_ser.end()
15077 }
15078}
15079impl<'de> serde::Deserialize<'de> for update_mutation::DispatcherUpdate {
15080 #[allow(deprecated)]
15081 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15082 where
15083 D: serde::Deserializer<'de>,
15084 {
15085 const FIELDS: &[&str] = &[
15086 "actor_id",
15087 "actorId",
15088 "dispatcher_id",
15089 "dispatcherId",
15090 "hash_mapping",
15091 "hashMapping",
15092 "added_downstream_actor_id",
15093 "addedDownstreamActorId",
15094 "removed_downstream_actor_id",
15095 "removedDownstreamActorId",
15096 ];
15097
15098 #[allow(clippy::enum_variant_names)]
15099 enum GeneratedField {
15100 ActorId,
15101 DispatcherId,
15102 HashMapping,
15103 AddedDownstreamActorId,
15104 RemovedDownstreamActorId,
15105 }
15106 impl<'de> serde::Deserialize<'de> for GeneratedField {
15107 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15108 where
15109 D: serde::Deserializer<'de>,
15110 {
15111 struct GeneratedVisitor;
15112
15113 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15114 type Value = GeneratedField;
15115
15116 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15117 write!(formatter, "expected one of: {:?}", &FIELDS)
15118 }
15119
15120 #[allow(unused_variables)]
15121 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15122 where
15123 E: serde::de::Error,
15124 {
15125 match value {
15126 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
15127 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
15128 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
15129 "addedDownstreamActorId" | "added_downstream_actor_id" => Ok(GeneratedField::AddedDownstreamActorId),
15130 "removedDownstreamActorId" | "removed_downstream_actor_id" => Ok(GeneratedField::RemovedDownstreamActorId),
15131 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15132 }
15133 }
15134 }
15135 deserializer.deserialize_identifier(GeneratedVisitor)
15136 }
15137 }
15138 struct GeneratedVisitor;
15139 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15140 type Value = update_mutation::DispatcherUpdate;
15141
15142 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15143 formatter.write_str("struct stream_plan.UpdateMutation.DispatcherUpdate")
15144 }
15145
15146 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::DispatcherUpdate, V::Error>
15147 where
15148 V: serde::de::MapAccess<'de>,
15149 {
15150 let mut actor_id__ = None;
15151 let mut dispatcher_id__ = None;
15152 let mut hash_mapping__ = None;
15153 let mut added_downstream_actor_id__ = None;
15154 let mut removed_downstream_actor_id__ = None;
15155 while let Some(k) = map_.next_key()? {
15156 match k {
15157 GeneratedField::ActorId => {
15158 if actor_id__.is_some() {
15159 return Err(serde::de::Error::duplicate_field("actorId"));
15160 }
15161 actor_id__ =
15162 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15163 ;
15164 }
15165 GeneratedField::DispatcherId => {
15166 if dispatcher_id__.is_some() {
15167 return Err(serde::de::Error::duplicate_field("dispatcherId"));
15168 }
15169 dispatcher_id__ =
15170 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15171 ;
15172 }
15173 GeneratedField::HashMapping => {
15174 if hash_mapping__.is_some() {
15175 return Err(serde::de::Error::duplicate_field("hashMapping"));
15176 }
15177 hash_mapping__ = map_.next_value()?;
15178 }
15179 GeneratedField::AddedDownstreamActorId => {
15180 if added_downstream_actor_id__.is_some() {
15181 return Err(serde::de::Error::duplicate_field("addedDownstreamActorId"));
15182 }
15183 added_downstream_actor_id__ =
15184 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15185 .into_iter().map(|x| x.0).collect())
15186 ;
15187 }
15188 GeneratedField::RemovedDownstreamActorId => {
15189 if removed_downstream_actor_id__.is_some() {
15190 return Err(serde::de::Error::duplicate_field("removedDownstreamActorId"));
15191 }
15192 removed_downstream_actor_id__ =
15193 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15194 .into_iter().map(|x| x.0).collect())
15195 ;
15196 }
15197 }
15198 }
15199 Ok(update_mutation::DispatcherUpdate {
15200 actor_id: actor_id__.unwrap_or_default(),
15201 dispatcher_id: dispatcher_id__.unwrap_or_default(),
15202 hash_mapping: hash_mapping__,
15203 added_downstream_actor_id: added_downstream_actor_id__.unwrap_or_default(),
15204 removed_downstream_actor_id: removed_downstream_actor_id__.unwrap_or_default(),
15205 })
15206 }
15207 }
15208 deserializer.deserialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", FIELDS, GeneratedVisitor)
15209 }
15210}
15211impl serde::Serialize for update_mutation::MergeUpdate {
15212 #[allow(deprecated)]
15213 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15214 where
15215 S: serde::Serializer,
15216 {
15217 use serde::ser::SerializeStruct;
15218 let mut len = 0;
15219 if self.actor_id != 0 {
15220 len += 1;
15221 }
15222 if self.upstream_fragment_id != 0 {
15223 len += 1;
15224 }
15225 if self.new_upstream_fragment_id.is_some() {
15226 len += 1;
15227 }
15228 if !self.added_upstream_actors.is_empty() {
15229 len += 1;
15230 }
15231 if !self.removed_upstream_actor_id.is_empty() {
15232 len += 1;
15233 }
15234 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.MergeUpdate", len)?;
15235 if self.actor_id != 0 {
15236 struct_ser.serialize_field("actorId", &self.actor_id)?;
15237 }
15238 if self.upstream_fragment_id != 0 {
15239 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
15240 }
15241 if let Some(v) = self.new_upstream_fragment_id.as_ref() {
15242 struct_ser.serialize_field("newUpstreamFragmentId", v)?;
15243 }
15244 if !self.added_upstream_actors.is_empty() {
15245 struct_ser.serialize_field("addedUpstreamActors", &self.added_upstream_actors)?;
15246 }
15247 if !self.removed_upstream_actor_id.is_empty() {
15248 struct_ser.serialize_field("removedUpstreamActorId", &self.removed_upstream_actor_id)?;
15249 }
15250 struct_ser.end()
15251 }
15252}
15253impl<'de> serde::Deserialize<'de> for update_mutation::MergeUpdate {
15254 #[allow(deprecated)]
15255 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15256 where
15257 D: serde::Deserializer<'de>,
15258 {
15259 const FIELDS: &[&str] = &[
15260 "actor_id",
15261 "actorId",
15262 "upstream_fragment_id",
15263 "upstreamFragmentId",
15264 "new_upstream_fragment_id",
15265 "newUpstreamFragmentId",
15266 "added_upstream_actors",
15267 "addedUpstreamActors",
15268 "removed_upstream_actor_id",
15269 "removedUpstreamActorId",
15270 ];
15271
15272 #[allow(clippy::enum_variant_names)]
15273 enum GeneratedField {
15274 ActorId,
15275 UpstreamFragmentId,
15276 NewUpstreamFragmentId,
15277 AddedUpstreamActors,
15278 RemovedUpstreamActorId,
15279 }
15280 impl<'de> serde::Deserialize<'de> for GeneratedField {
15281 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15282 where
15283 D: serde::Deserializer<'de>,
15284 {
15285 struct GeneratedVisitor;
15286
15287 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15288 type Value = GeneratedField;
15289
15290 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15291 write!(formatter, "expected one of: {:?}", &FIELDS)
15292 }
15293
15294 #[allow(unused_variables)]
15295 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15296 where
15297 E: serde::de::Error,
15298 {
15299 match value {
15300 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
15301 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
15302 "newUpstreamFragmentId" | "new_upstream_fragment_id" => Ok(GeneratedField::NewUpstreamFragmentId),
15303 "addedUpstreamActors" | "added_upstream_actors" => Ok(GeneratedField::AddedUpstreamActors),
15304 "removedUpstreamActorId" | "removed_upstream_actor_id" => Ok(GeneratedField::RemovedUpstreamActorId),
15305 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15306 }
15307 }
15308 }
15309 deserializer.deserialize_identifier(GeneratedVisitor)
15310 }
15311 }
15312 struct GeneratedVisitor;
15313 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15314 type Value = update_mutation::MergeUpdate;
15315
15316 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15317 formatter.write_str("struct stream_plan.UpdateMutation.MergeUpdate")
15318 }
15319
15320 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::MergeUpdate, V::Error>
15321 where
15322 V: serde::de::MapAccess<'de>,
15323 {
15324 let mut actor_id__ = None;
15325 let mut upstream_fragment_id__ = None;
15326 let mut new_upstream_fragment_id__ = None;
15327 let mut added_upstream_actors__ = None;
15328 let mut removed_upstream_actor_id__ = None;
15329 while let Some(k) = map_.next_key()? {
15330 match k {
15331 GeneratedField::ActorId => {
15332 if actor_id__.is_some() {
15333 return Err(serde::de::Error::duplicate_field("actorId"));
15334 }
15335 actor_id__ =
15336 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15337 ;
15338 }
15339 GeneratedField::UpstreamFragmentId => {
15340 if upstream_fragment_id__.is_some() {
15341 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
15342 }
15343 upstream_fragment_id__ =
15344 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15345 ;
15346 }
15347 GeneratedField::NewUpstreamFragmentId => {
15348 if new_upstream_fragment_id__.is_some() {
15349 return Err(serde::de::Error::duplicate_field("newUpstreamFragmentId"));
15350 }
15351 new_upstream_fragment_id__ =
15352 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15353 ;
15354 }
15355 GeneratedField::AddedUpstreamActors => {
15356 if added_upstream_actors__.is_some() {
15357 return Err(serde::de::Error::duplicate_field("addedUpstreamActors"));
15358 }
15359 added_upstream_actors__ = Some(map_.next_value()?);
15360 }
15361 GeneratedField::RemovedUpstreamActorId => {
15362 if removed_upstream_actor_id__.is_some() {
15363 return Err(serde::de::Error::duplicate_field("removedUpstreamActorId"));
15364 }
15365 removed_upstream_actor_id__ =
15366 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15367 .into_iter().map(|x| x.0).collect())
15368 ;
15369 }
15370 }
15371 }
15372 Ok(update_mutation::MergeUpdate {
15373 actor_id: actor_id__.unwrap_or_default(),
15374 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
15375 new_upstream_fragment_id: new_upstream_fragment_id__,
15376 added_upstream_actors: added_upstream_actors__.unwrap_or_default(),
15377 removed_upstream_actor_id: removed_upstream_actor_id__.unwrap_or_default(),
15378 })
15379 }
15380 }
15381 deserializer.deserialize_struct("stream_plan.UpdateMutation.MergeUpdate", FIELDS, GeneratedVisitor)
15382 }
15383}
15384impl serde::Serialize for UpstreamSinkInfo {
15385 #[allow(deprecated)]
15386 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15387 where
15388 S: serde::Serializer,
15389 {
15390 use serde::ser::SerializeStruct;
15391 let mut len = 0;
15392 if self.upstream_fragment_id != 0 {
15393 len += 1;
15394 }
15395 if !self.sink_output_schema.is_empty() {
15396 len += 1;
15397 }
15398 if !self.project_exprs.is_empty() {
15399 len += 1;
15400 }
15401 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkInfo", len)?;
15402 if self.upstream_fragment_id != 0 {
15403 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
15404 }
15405 if !self.sink_output_schema.is_empty() {
15406 struct_ser.serialize_field("sinkOutputSchema", &self.sink_output_schema)?;
15407 }
15408 if !self.project_exprs.is_empty() {
15409 struct_ser.serialize_field("projectExprs", &self.project_exprs)?;
15410 }
15411 struct_ser.end()
15412 }
15413}
15414impl<'de> serde::Deserialize<'de> for UpstreamSinkInfo {
15415 #[allow(deprecated)]
15416 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15417 where
15418 D: serde::Deserializer<'de>,
15419 {
15420 const FIELDS: &[&str] = &[
15421 "upstream_fragment_id",
15422 "upstreamFragmentId",
15423 "sink_output_schema",
15424 "sinkOutputSchema",
15425 "project_exprs",
15426 "projectExprs",
15427 ];
15428
15429 #[allow(clippy::enum_variant_names)]
15430 enum GeneratedField {
15431 UpstreamFragmentId,
15432 SinkOutputSchema,
15433 ProjectExprs,
15434 }
15435 impl<'de> serde::Deserialize<'de> for GeneratedField {
15436 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15437 where
15438 D: serde::Deserializer<'de>,
15439 {
15440 struct GeneratedVisitor;
15441
15442 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15443 type Value = GeneratedField;
15444
15445 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15446 write!(formatter, "expected one of: {:?}", &FIELDS)
15447 }
15448
15449 #[allow(unused_variables)]
15450 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15451 where
15452 E: serde::de::Error,
15453 {
15454 match value {
15455 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
15456 "sinkOutputSchema" | "sink_output_schema" => Ok(GeneratedField::SinkOutputSchema),
15457 "projectExprs" | "project_exprs" => Ok(GeneratedField::ProjectExprs),
15458 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15459 }
15460 }
15461 }
15462 deserializer.deserialize_identifier(GeneratedVisitor)
15463 }
15464 }
15465 struct GeneratedVisitor;
15466 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15467 type Value = UpstreamSinkInfo;
15468
15469 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15470 formatter.write_str("struct stream_plan.UpstreamSinkInfo")
15471 }
15472
15473 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkInfo, V::Error>
15474 where
15475 V: serde::de::MapAccess<'de>,
15476 {
15477 let mut upstream_fragment_id__ = None;
15478 let mut sink_output_schema__ = None;
15479 let mut project_exprs__ = None;
15480 while let Some(k) = map_.next_key()? {
15481 match k {
15482 GeneratedField::UpstreamFragmentId => {
15483 if upstream_fragment_id__.is_some() {
15484 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
15485 }
15486 upstream_fragment_id__ =
15487 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15488 ;
15489 }
15490 GeneratedField::SinkOutputSchema => {
15491 if sink_output_schema__.is_some() {
15492 return Err(serde::de::Error::duplicate_field("sinkOutputSchema"));
15493 }
15494 sink_output_schema__ = Some(map_.next_value()?);
15495 }
15496 GeneratedField::ProjectExprs => {
15497 if project_exprs__.is_some() {
15498 return Err(serde::de::Error::duplicate_field("projectExprs"));
15499 }
15500 project_exprs__ = Some(map_.next_value()?);
15501 }
15502 }
15503 }
15504 Ok(UpstreamSinkInfo {
15505 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
15506 sink_output_schema: sink_output_schema__.unwrap_or_default(),
15507 project_exprs: project_exprs__.unwrap_or_default(),
15508 })
15509 }
15510 }
15511 deserializer.deserialize_struct("stream_plan.UpstreamSinkInfo", FIELDS, GeneratedVisitor)
15512 }
15513}
15514impl serde::Serialize for UpstreamSinkUnionNode {
15515 #[allow(deprecated)]
15516 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15517 where
15518 S: serde::Serializer,
15519 {
15520 use serde::ser::SerializeStruct;
15521 let mut len = 0;
15522 if !self.init_upstreams.is_empty() {
15523 len += 1;
15524 }
15525 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkUnionNode", len)?;
15526 if !self.init_upstreams.is_empty() {
15527 struct_ser.serialize_field("initUpstreams", &self.init_upstreams)?;
15528 }
15529 struct_ser.end()
15530 }
15531}
15532impl<'de> serde::Deserialize<'de> for UpstreamSinkUnionNode {
15533 #[allow(deprecated)]
15534 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15535 where
15536 D: serde::Deserializer<'de>,
15537 {
15538 const FIELDS: &[&str] = &[
15539 "init_upstreams",
15540 "initUpstreams",
15541 ];
15542
15543 #[allow(clippy::enum_variant_names)]
15544 enum GeneratedField {
15545 InitUpstreams,
15546 }
15547 impl<'de> serde::Deserialize<'de> for GeneratedField {
15548 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15549 where
15550 D: serde::Deserializer<'de>,
15551 {
15552 struct GeneratedVisitor;
15553
15554 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15555 type Value = GeneratedField;
15556
15557 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15558 write!(formatter, "expected one of: {:?}", &FIELDS)
15559 }
15560
15561 #[allow(unused_variables)]
15562 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15563 where
15564 E: serde::de::Error,
15565 {
15566 match value {
15567 "initUpstreams" | "init_upstreams" => Ok(GeneratedField::InitUpstreams),
15568 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15569 }
15570 }
15571 }
15572 deserializer.deserialize_identifier(GeneratedVisitor)
15573 }
15574 }
15575 struct GeneratedVisitor;
15576 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15577 type Value = UpstreamSinkUnionNode;
15578
15579 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15580 formatter.write_str("struct stream_plan.UpstreamSinkUnionNode")
15581 }
15582
15583 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkUnionNode, V::Error>
15584 where
15585 V: serde::de::MapAccess<'de>,
15586 {
15587 let mut init_upstreams__ = None;
15588 while let Some(k) = map_.next_key()? {
15589 match k {
15590 GeneratedField::InitUpstreams => {
15591 if init_upstreams__.is_some() {
15592 return Err(serde::de::Error::duplicate_field("initUpstreams"));
15593 }
15594 init_upstreams__ = Some(map_.next_value()?);
15595 }
15596 }
15597 }
15598 Ok(UpstreamSinkUnionNode {
15599 init_upstreams: init_upstreams__.unwrap_or_default(),
15600 })
15601 }
15602 }
15603 deserializer.deserialize_struct("stream_plan.UpstreamSinkUnionNode", FIELDS, GeneratedVisitor)
15604 }
15605}
15606impl serde::Serialize for ValuesNode {
15607 #[allow(deprecated)]
15608 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15609 where
15610 S: serde::Serializer,
15611 {
15612 use serde::ser::SerializeStruct;
15613 let mut len = 0;
15614 if !self.tuples.is_empty() {
15615 len += 1;
15616 }
15617 if !self.fields.is_empty() {
15618 len += 1;
15619 }
15620 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode", len)?;
15621 if !self.tuples.is_empty() {
15622 struct_ser.serialize_field("tuples", &self.tuples)?;
15623 }
15624 if !self.fields.is_empty() {
15625 struct_ser.serialize_field("fields", &self.fields)?;
15626 }
15627 struct_ser.end()
15628 }
15629}
15630impl<'de> serde::Deserialize<'de> for ValuesNode {
15631 #[allow(deprecated)]
15632 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15633 where
15634 D: serde::Deserializer<'de>,
15635 {
15636 const FIELDS: &[&str] = &[
15637 "tuples",
15638 "fields",
15639 ];
15640
15641 #[allow(clippy::enum_variant_names)]
15642 enum GeneratedField {
15643 Tuples,
15644 Fields,
15645 }
15646 impl<'de> serde::Deserialize<'de> for GeneratedField {
15647 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15648 where
15649 D: serde::Deserializer<'de>,
15650 {
15651 struct GeneratedVisitor;
15652
15653 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15654 type Value = GeneratedField;
15655
15656 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15657 write!(formatter, "expected one of: {:?}", &FIELDS)
15658 }
15659
15660 #[allow(unused_variables)]
15661 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15662 where
15663 E: serde::de::Error,
15664 {
15665 match value {
15666 "tuples" => Ok(GeneratedField::Tuples),
15667 "fields" => Ok(GeneratedField::Fields),
15668 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15669 }
15670 }
15671 }
15672 deserializer.deserialize_identifier(GeneratedVisitor)
15673 }
15674 }
15675 struct GeneratedVisitor;
15676 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15677 type Value = ValuesNode;
15678
15679 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15680 formatter.write_str("struct stream_plan.ValuesNode")
15681 }
15682
15683 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
15684 where
15685 V: serde::de::MapAccess<'de>,
15686 {
15687 let mut tuples__ = None;
15688 let mut fields__ = None;
15689 while let Some(k) = map_.next_key()? {
15690 match k {
15691 GeneratedField::Tuples => {
15692 if tuples__.is_some() {
15693 return Err(serde::de::Error::duplicate_field("tuples"));
15694 }
15695 tuples__ = Some(map_.next_value()?);
15696 }
15697 GeneratedField::Fields => {
15698 if fields__.is_some() {
15699 return Err(serde::de::Error::duplicate_field("fields"));
15700 }
15701 fields__ = Some(map_.next_value()?);
15702 }
15703 }
15704 }
15705 Ok(ValuesNode {
15706 tuples: tuples__.unwrap_or_default(),
15707 fields: fields__.unwrap_or_default(),
15708 })
15709 }
15710 }
15711 deserializer.deserialize_struct("stream_plan.ValuesNode", FIELDS, GeneratedVisitor)
15712 }
15713}
15714impl serde::Serialize for values_node::ExprTuple {
15715 #[allow(deprecated)]
15716 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15717 where
15718 S: serde::Serializer,
15719 {
15720 use serde::ser::SerializeStruct;
15721 let mut len = 0;
15722 if !self.cells.is_empty() {
15723 len += 1;
15724 }
15725 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode.ExprTuple", len)?;
15726 if !self.cells.is_empty() {
15727 struct_ser.serialize_field("cells", &self.cells)?;
15728 }
15729 struct_ser.end()
15730 }
15731}
15732impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
15733 #[allow(deprecated)]
15734 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15735 where
15736 D: serde::Deserializer<'de>,
15737 {
15738 const FIELDS: &[&str] = &[
15739 "cells",
15740 ];
15741
15742 #[allow(clippy::enum_variant_names)]
15743 enum GeneratedField {
15744 Cells,
15745 }
15746 impl<'de> serde::Deserialize<'de> for GeneratedField {
15747 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15748 where
15749 D: serde::Deserializer<'de>,
15750 {
15751 struct GeneratedVisitor;
15752
15753 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15754 type Value = GeneratedField;
15755
15756 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15757 write!(formatter, "expected one of: {:?}", &FIELDS)
15758 }
15759
15760 #[allow(unused_variables)]
15761 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15762 where
15763 E: serde::de::Error,
15764 {
15765 match value {
15766 "cells" => Ok(GeneratedField::Cells),
15767 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15768 }
15769 }
15770 }
15771 deserializer.deserialize_identifier(GeneratedVisitor)
15772 }
15773 }
15774 struct GeneratedVisitor;
15775 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15776 type Value = values_node::ExprTuple;
15777
15778 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15779 formatter.write_str("struct stream_plan.ValuesNode.ExprTuple")
15780 }
15781
15782 fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
15783 where
15784 V: serde::de::MapAccess<'de>,
15785 {
15786 let mut cells__ = None;
15787 while let Some(k) = map_.next_key()? {
15788 match k {
15789 GeneratedField::Cells => {
15790 if cells__.is_some() {
15791 return Err(serde::de::Error::duplicate_field("cells"));
15792 }
15793 cells__ = Some(map_.next_value()?);
15794 }
15795 }
15796 }
15797 Ok(values_node::ExprTuple {
15798 cells: cells__.unwrap_or_default(),
15799 })
15800 }
15801 }
15802 deserializer.deserialize_struct("stream_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
15803 }
15804}
15805impl serde::Serialize for VectorIndexWriteNode {
15806 #[allow(deprecated)]
15807 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15808 where
15809 S: serde::Serializer,
15810 {
15811 use serde::ser::SerializeStruct;
15812 let mut len = 0;
15813 if self.table.is_some() {
15814 len += 1;
15815 }
15816 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexWriteNode", len)?;
15817 if let Some(v) = self.table.as_ref() {
15818 struct_ser.serialize_field("table", v)?;
15819 }
15820 struct_ser.end()
15821 }
15822}
15823impl<'de> serde::Deserialize<'de> for VectorIndexWriteNode {
15824 #[allow(deprecated)]
15825 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15826 where
15827 D: serde::Deserializer<'de>,
15828 {
15829 const FIELDS: &[&str] = &[
15830 "table",
15831 ];
15832
15833 #[allow(clippy::enum_variant_names)]
15834 enum GeneratedField {
15835 Table,
15836 }
15837 impl<'de> serde::Deserialize<'de> for GeneratedField {
15838 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15839 where
15840 D: serde::Deserializer<'de>,
15841 {
15842 struct GeneratedVisitor;
15843
15844 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15845 type Value = GeneratedField;
15846
15847 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15848 write!(formatter, "expected one of: {:?}", &FIELDS)
15849 }
15850
15851 #[allow(unused_variables)]
15852 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15853 where
15854 E: serde::de::Error,
15855 {
15856 match value {
15857 "table" => Ok(GeneratedField::Table),
15858 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15859 }
15860 }
15861 }
15862 deserializer.deserialize_identifier(GeneratedVisitor)
15863 }
15864 }
15865 struct GeneratedVisitor;
15866 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15867 type Value = VectorIndexWriteNode;
15868
15869 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15870 formatter.write_str("struct stream_plan.VectorIndexWriteNode")
15871 }
15872
15873 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexWriteNode, V::Error>
15874 where
15875 V: serde::de::MapAccess<'de>,
15876 {
15877 let mut table__ = None;
15878 while let Some(k) = map_.next_key()? {
15879 match k {
15880 GeneratedField::Table => {
15881 if table__.is_some() {
15882 return Err(serde::de::Error::duplicate_field("table"));
15883 }
15884 table__ = map_.next_value()?;
15885 }
15886 }
15887 }
15888 Ok(VectorIndexWriteNode {
15889 table: table__,
15890 })
15891 }
15892 }
15893 deserializer.deserialize_struct("stream_plan.VectorIndexWriteNode", FIELDS, GeneratedVisitor)
15894 }
15895}
15896impl serde::Serialize for Watermark {
15897 #[allow(deprecated)]
15898 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15899 where
15900 S: serde::Serializer,
15901 {
15902 use serde::ser::SerializeStruct;
15903 let mut len = 0;
15904 if self.column.is_some() {
15905 len += 1;
15906 }
15907 if self.val.is_some() {
15908 len += 1;
15909 }
15910 let mut struct_ser = serializer.serialize_struct("stream_plan.Watermark", len)?;
15911 if let Some(v) = self.column.as_ref() {
15912 struct_ser.serialize_field("column", v)?;
15913 }
15914 if let Some(v) = self.val.as_ref() {
15915 struct_ser.serialize_field("val", v)?;
15916 }
15917 struct_ser.end()
15918 }
15919}
15920impl<'de> serde::Deserialize<'de> for Watermark {
15921 #[allow(deprecated)]
15922 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15923 where
15924 D: serde::Deserializer<'de>,
15925 {
15926 const FIELDS: &[&str] = &[
15927 "column",
15928 "val",
15929 ];
15930
15931 #[allow(clippy::enum_variant_names)]
15932 enum GeneratedField {
15933 Column,
15934 Val,
15935 }
15936 impl<'de> serde::Deserialize<'de> for GeneratedField {
15937 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15938 where
15939 D: serde::Deserializer<'de>,
15940 {
15941 struct GeneratedVisitor;
15942
15943 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15944 type Value = GeneratedField;
15945
15946 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15947 write!(formatter, "expected one of: {:?}", &FIELDS)
15948 }
15949
15950 #[allow(unused_variables)]
15951 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15952 where
15953 E: serde::de::Error,
15954 {
15955 match value {
15956 "column" => Ok(GeneratedField::Column),
15957 "val" => Ok(GeneratedField::Val),
15958 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15959 }
15960 }
15961 }
15962 deserializer.deserialize_identifier(GeneratedVisitor)
15963 }
15964 }
15965 struct GeneratedVisitor;
15966 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15967 type Value = Watermark;
15968
15969 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15970 formatter.write_str("struct stream_plan.Watermark")
15971 }
15972
15973 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Watermark, V::Error>
15974 where
15975 V: serde::de::MapAccess<'de>,
15976 {
15977 let mut column__ = None;
15978 let mut val__ = None;
15979 while let Some(k) = map_.next_key()? {
15980 match k {
15981 GeneratedField::Column => {
15982 if column__.is_some() {
15983 return Err(serde::de::Error::duplicate_field("column"));
15984 }
15985 column__ = map_.next_value()?;
15986 }
15987 GeneratedField::Val => {
15988 if val__.is_some() {
15989 return Err(serde::de::Error::duplicate_field("val"));
15990 }
15991 val__ = map_.next_value()?;
15992 }
15993 }
15994 }
15995 Ok(Watermark {
15996 column: column__,
15997 val: val__,
15998 })
15999 }
16000 }
16001 deserializer.deserialize_struct("stream_plan.Watermark", FIELDS, GeneratedVisitor)
16002 }
16003}
16004impl serde::Serialize for WatermarkFilterNode {
16005 #[allow(deprecated)]
16006 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16007 where
16008 S: serde::Serializer,
16009 {
16010 use serde::ser::SerializeStruct;
16011 let mut len = 0;
16012 if !self.watermark_descs.is_empty() {
16013 len += 1;
16014 }
16015 if !self.tables.is_empty() {
16016 len += 1;
16017 }
16018 let mut struct_ser = serializer.serialize_struct("stream_plan.WatermarkFilterNode", len)?;
16019 if !self.watermark_descs.is_empty() {
16020 struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
16021 }
16022 if !self.tables.is_empty() {
16023 struct_ser.serialize_field("tables", &self.tables)?;
16024 }
16025 struct_ser.end()
16026 }
16027}
16028impl<'de> serde::Deserialize<'de> for WatermarkFilterNode {
16029 #[allow(deprecated)]
16030 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16031 where
16032 D: serde::Deserializer<'de>,
16033 {
16034 const FIELDS: &[&str] = &[
16035 "watermark_descs",
16036 "watermarkDescs",
16037 "tables",
16038 ];
16039
16040 #[allow(clippy::enum_variant_names)]
16041 enum GeneratedField {
16042 WatermarkDescs,
16043 Tables,
16044 }
16045 impl<'de> serde::Deserialize<'de> for GeneratedField {
16046 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16047 where
16048 D: serde::Deserializer<'de>,
16049 {
16050 struct GeneratedVisitor;
16051
16052 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16053 type Value = GeneratedField;
16054
16055 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16056 write!(formatter, "expected one of: {:?}", &FIELDS)
16057 }
16058
16059 #[allow(unused_variables)]
16060 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16061 where
16062 E: serde::de::Error,
16063 {
16064 match value {
16065 "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
16066 "tables" => Ok(GeneratedField::Tables),
16067 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16068 }
16069 }
16070 }
16071 deserializer.deserialize_identifier(GeneratedVisitor)
16072 }
16073 }
16074 struct GeneratedVisitor;
16075 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16076 type Value = WatermarkFilterNode;
16077
16078 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16079 formatter.write_str("struct stream_plan.WatermarkFilterNode")
16080 }
16081
16082 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkFilterNode, V::Error>
16083 where
16084 V: serde::de::MapAccess<'de>,
16085 {
16086 let mut watermark_descs__ = None;
16087 let mut tables__ = None;
16088 while let Some(k) = map_.next_key()? {
16089 match k {
16090 GeneratedField::WatermarkDescs => {
16091 if watermark_descs__.is_some() {
16092 return Err(serde::de::Error::duplicate_field("watermarkDescs"));
16093 }
16094 watermark_descs__ = Some(map_.next_value()?);
16095 }
16096 GeneratedField::Tables => {
16097 if tables__.is_some() {
16098 return Err(serde::de::Error::duplicate_field("tables"));
16099 }
16100 tables__ = Some(map_.next_value()?);
16101 }
16102 }
16103 }
16104 Ok(WatermarkFilterNode {
16105 watermark_descs: watermark_descs__.unwrap_or_default(),
16106 tables: tables__.unwrap_or_default(),
16107 })
16108 }
16109 }
16110 deserializer.deserialize_struct("stream_plan.WatermarkFilterNode", FIELDS, GeneratedVisitor)
16111 }
16112}