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 LocalityProviderNode {
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.locality_columns.is_empty() {
6409 len += 1;
6410 }
6411 if self.state_table.is_some() {
6412 len += 1;
6413 }
6414 if self.progress_table.is_some() {
6415 len += 1;
6416 }
6417 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalityProviderNode", len)?;
6418 if !self.locality_columns.is_empty() {
6419 struct_ser.serialize_field("localityColumns", &self.locality_columns)?;
6420 }
6421 if let Some(v) = self.state_table.as_ref() {
6422 struct_ser.serialize_field("stateTable", v)?;
6423 }
6424 if let Some(v) = self.progress_table.as_ref() {
6425 struct_ser.serialize_field("progressTable", v)?;
6426 }
6427 struct_ser.end()
6428 }
6429}
6430impl<'de> serde::Deserialize<'de> for LocalityProviderNode {
6431 #[allow(deprecated)]
6432 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6433 where
6434 D: serde::Deserializer<'de>,
6435 {
6436 const FIELDS: &[&str] = &[
6437 "locality_columns",
6438 "localityColumns",
6439 "state_table",
6440 "stateTable",
6441 "progress_table",
6442 "progressTable",
6443 ];
6444
6445 #[allow(clippy::enum_variant_names)]
6446 enum GeneratedField {
6447 LocalityColumns,
6448 StateTable,
6449 ProgressTable,
6450 }
6451 impl<'de> serde::Deserialize<'de> for GeneratedField {
6452 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6453 where
6454 D: serde::Deserializer<'de>,
6455 {
6456 struct GeneratedVisitor;
6457
6458 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6459 type Value = GeneratedField;
6460
6461 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6462 write!(formatter, "expected one of: {:?}", &FIELDS)
6463 }
6464
6465 #[allow(unused_variables)]
6466 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6467 where
6468 E: serde::de::Error,
6469 {
6470 match value {
6471 "localityColumns" | "locality_columns" => Ok(GeneratedField::LocalityColumns),
6472 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
6473 "progressTable" | "progress_table" => Ok(GeneratedField::ProgressTable),
6474 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6475 }
6476 }
6477 }
6478 deserializer.deserialize_identifier(GeneratedVisitor)
6479 }
6480 }
6481 struct GeneratedVisitor;
6482 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6483 type Value = LocalityProviderNode;
6484
6485 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6486 formatter.write_str("struct stream_plan.LocalityProviderNode")
6487 }
6488
6489 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalityProviderNode, V::Error>
6490 where
6491 V: serde::de::MapAccess<'de>,
6492 {
6493 let mut locality_columns__ = None;
6494 let mut state_table__ = None;
6495 let mut progress_table__ = None;
6496 while let Some(k) = map_.next_key()? {
6497 match k {
6498 GeneratedField::LocalityColumns => {
6499 if locality_columns__.is_some() {
6500 return Err(serde::de::Error::duplicate_field("localityColumns"));
6501 }
6502 locality_columns__ =
6503 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6504 .into_iter().map(|x| x.0).collect())
6505 ;
6506 }
6507 GeneratedField::StateTable => {
6508 if state_table__.is_some() {
6509 return Err(serde::de::Error::duplicate_field("stateTable"));
6510 }
6511 state_table__ = map_.next_value()?;
6512 }
6513 GeneratedField::ProgressTable => {
6514 if progress_table__.is_some() {
6515 return Err(serde::de::Error::duplicate_field("progressTable"));
6516 }
6517 progress_table__ = map_.next_value()?;
6518 }
6519 }
6520 }
6521 Ok(LocalityProviderNode {
6522 locality_columns: locality_columns__.unwrap_or_default(),
6523 state_table: state_table__,
6524 progress_table: progress_table__,
6525 })
6526 }
6527 }
6528 deserializer.deserialize_struct("stream_plan.LocalityProviderNode", FIELDS, GeneratedVisitor)
6529 }
6530}
6531impl serde::Serialize for LookupNode {
6532 #[allow(deprecated)]
6533 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6534 where
6535 S: serde::Serializer,
6536 {
6537 use serde::ser::SerializeStruct;
6538 let mut len = 0;
6539 if !self.arrange_key.is_empty() {
6540 len += 1;
6541 }
6542 if !self.stream_key.is_empty() {
6543 len += 1;
6544 }
6545 if self.use_current_epoch {
6546 len += 1;
6547 }
6548 if !self.column_mapping.is_empty() {
6549 len += 1;
6550 }
6551 if self.arrangement_table_info.is_some() {
6552 len += 1;
6553 }
6554 if self.arrangement_table_id.is_some() {
6555 len += 1;
6556 }
6557 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupNode", len)?;
6558 if !self.arrange_key.is_empty() {
6559 struct_ser.serialize_field("arrangeKey", &self.arrange_key)?;
6560 }
6561 if !self.stream_key.is_empty() {
6562 struct_ser.serialize_field("streamKey", &self.stream_key)?;
6563 }
6564 if self.use_current_epoch {
6565 struct_ser.serialize_field("useCurrentEpoch", &self.use_current_epoch)?;
6566 }
6567 if !self.column_mapping.is_empty() {
6568 struct_ser.serialize_field("columnMapping", &self.column_mapping)?;
6569 }
6570 if let Some(v) = self.arrangement_table_info.as_ref() {
6571 struct_ser.serialize_field("arrangementTableInfo", v)?;
6572 }
6573 if let Some(v) = self.arrangement_table_id.as_ref() {
6574 match v {
6575 lookup_node::ArrangementTableId::TableId(v) => {
6576 struct_ser.serialize_field("tableId", v)?;
6577 }
6578 lookup_node::ArrangementTableId::IndexId(v) => {
6579 struct_ser.serialize_field("indexId", v)?;
6580 }
6581 }
6582 }
6583 struct_ser.end()
6584 }
6585}
6586impl<'de> serde::Deserialize<'de> for LookupNode {
6587 #[allow(deprecated)]
6588 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6589 where
6590 D: serde::Deserializer<'de>,
6591 {
6592 const FIELDS: &[&str] = &[
6593 "arrange_key",
6594 "arrangeKey",
6595 "stream_key",
6596 "streamKey",
6597 "use_current_epoch",
6598 "useCurrentEpoch",
6599 "column_mapping",
6600 "columnMapping",
6601 "arrangement_table_info",
6602 "arrangementTableInfo",
6603 "table_id",
6604 "tableId",
6605 "index_id",
6606 "indexId",
6607 ];
6608
6609 #[allow(clippy::enum_variant_names)]
6610 enum GeneratedField {
6611 ArrangeKey,
6612 StreamKey,
6613 UseCurrentEpoch,
6614 ColumnMapping,
6615 ArrangementTableInfo,
6616 TableId,
6617 IndexId,
6618 }
6619 impl<'de> serde::Deserialize<'de> for GeneratedField {
6620 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6621 where
6622 D: serde::Deserializer<'de>,
6623 {
6624 struct GeneratedVisitor;
6625
6626 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6627 type Value = GeneratedField;
6628
6629 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6630 write!(formatter, "expected one of: {:?}", &FIELDS)
6631 }
6632
6633 #[allow(unused_variables)]
6634 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6635 where
6636 E: serde::de::Error,
6637 {
6638 match value {
6639 "arrangeKey" | "arrange_key" => Ok(GeneratedField::ArrangeKey),
6640 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
6641 "useCurrentEpoch" | "use_current_epoch" => Ok(GeneratedField::UseCurrentEpoch),
6642 "columnMapping" | "column_mapping" => Ok(GeneratedField::ColumnMapping),
6643 "arrangementTableInfo" | "arrangement_table_info" => Ok(GeneratedField::ArrangementTableInfo),
6644 "tableId" | "table_id" => Ok(GeneratedField::TableId),
6645 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
6646 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6647 }
6648 }
6649 }
6650 deserializer.deserialize_identifier(GeneratedVisitor)
6651 }
6652 }
6653 struct GeneratedVisitor;
6654 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6655 type Value = LookupNode;
6656
6657 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6658 formatter.write_str("struct stream_plan.LookupNode")
6659 }
6660
6661 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupNode, V::Error>
6662 where
6663 V: serde::de::MapAccess<'de>,
6664 {
6665 let mut arrange_key__ = None;
6666 let mut stream_key__ = None;
6667 let mut use_current_epoch__ = None;
6668 let mut column_mapping__ = None;
6669 let mut arrangement_table_info__ = None;
6670 let mut arrangement_table_id__ = None;
6671 while let Some(k) = map_.next_key()? {
6672 match k {
6673 GeneratedField::ArrangeKey => {
6674 if arrange_key__.is_some() {
6675 return Err(serde::de::Error::duplicate_field("arrangeKey"));
6676 }
6677 arrange_key__ =
6678 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6679 .into_iter().map(|x| x.0).collect())
6680 ;
6681 }
6682 GeneratedField::StreamKey => {
6683 if stream_key__.is_some() {
6684 return Err(serde::de::Error::duplicate_field("streamKey"));
6685 }
6686 stream_key__ =
6687 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6688 .into_iter().map(|x| x.0).collect())
6689 ;
6690 }
6691 GeneratedField::UseCurrentEpoch => {
6692 if use_current_epoch__.is_some() {
6693 return Err(serde::de::Error::duplicate_field("useCurrentEpoch"));
6694 }
6695 use_current_epoch__ = Some(map_.next_value()?);
6696 }
6697 GeneratedField::ColumnMapping => {
6698 if column_mapping__.is_some() {
6699 return Err(serde::de::Error::duplicate_field("columnMapping"));
6700 }
6701 column_mapping__ =
6702 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6703 .into_iter().map(|x| x.0).collect())
6704 ;
6705 }
6706 GeneratedField::ArrangementTableInfo => {
6707 if arrangement_table_info__.is_some() {
6708 return Err(serde::de::Error::duplicate_field("arrangementTableInfo"));
6709 }
6710 arrangement_table_info__ = map_.next_value()?;
6711 }
6712 GeneratedField::TableId => {
6713 if arrangement_table_id__.is_some() {
6714 return Err(serde::de::Error::duplicate_field("tableId"));
6715 }
6716 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::TableId(x.0));
6717 }
6718 GeneratedField::IndexId => {
6719 if arrangement_table_id__.is_some() {
6720 return Err(serde::de::Error::duplicate_field("indexId"));
6721 }
6722 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::IndexId(x.0));
6723 }
6724 }
6725 }
6726 Ok(LookupNode {
6727 arrange_key: arrange_key__.unwrap_or_default(),
6728 stream_key: stream_key__.unwrap_or_default(),
6729 use_current_epoch: use_current_epoch__.unwrap_or_default(),
6730 column_mapping: column_mapping__.unwrap_or_default(),
6731 arrangement_table_info: arrangement_table_info__,
6732 arrangement_table_id: arrangement_table_id__,
6733 })
6734 }
6735 }
6736 deserializer.deserialize_struct("stream_plan.LookupNode", FIELDS, GeneratedVisitor)
6737 }
6738}
6739impl serde::Serialize for LookupUnionNode {
6740 #[allow(deprecated)]
6741 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6742 where
6743 S: serde::Serializer,
6744 {
6745 use serde::ser::SerializeStruct;
6746 let mut len = 0;
6747 if !self.order.is_empty() {
6748 len += 1;
6749 }
6750 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupUnionNode", len)?;
6751 if !self.order.is_empty() {
6752 struct_ser.serialize_field("order", &self.order)?;
6753 }
6754 struct_ser.end()
6755 }
6756}
6757impl<'de> serde::Deserialize<'de> for LookupUnionNode {
6758 #[allow(deprecated)]
6759 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6760 where
6761 D: serde::Deserializer<'de>,
6762 {
6763 const FIELDS: &[&str] = &[
6764 "order",
6765 ];
6766
6767 #[allow(clippy::enum_variant_names)]
6768 enum GeneratedField {
6769 Order,
6770 }
6771 impl<'de> serde::Deserialize<'de> for GeneratedField {
6772 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6773 where
6774 D: serde::Deserializer<'de>,
6775 {
6776 struct GeneratedVisitor;
6777
6778 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6779 type Value = GeneratedField;
6780
6781 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6782 write!(formatter, "expected one of: {:?}", &FIELDS)
6783 }
6784
6785 #[allow(unused_variables)]
6786 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6787 where
6788 E: serde::de::Error,
6789 {
6790 match value {
6791 "order" => Ok(GeneratedField::Order),
6792 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6793 }
6794 }
6795 }
6796 deserializer.deserialize_identifier(GeneratedVisitor)
6797 }
6798 }
6799 struct GeneratedVisitor;
6800 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6801 type Value = LookupUnionNode;
6802
6803 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6804 formatter.write_str("struct stream_plan.LookupUnionNode")
6805 }
6806
6807 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupUnionNode, V::Error>
6808 where
6809 V: serde::de::MapAccess<'de>,
6810 {
6811 let mut order__ = None;
6812 while let Some(k) = map_.next_key()? {
6813 match k {
6814 GeneratedField::Order => {
6815 if order__.is_some() {
6816 return Err(serde::de::Error::duplicate_field("order"));
6817 }
6818 order__ =
6819 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6820 .into_iter().map(|x| x.0).collect())
6821 ;
6822 }
6823 }
6824 }
6825 Ok(LookupUnionNode {
6826 order: order__.unwrap_or_default(),
6827 })
6828 }
6829 }
6830 deserializer.deserialize_struct("stream_plan.LookupUnionNode", FIELDS, GeneratedVisitor)
6831 }
6832}
6833impl serde::Serialize for MaterializeNode {
6834 #[allow(deprecated)]
6835 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6836 where
6837 S: serde::Serializer,
6838 {
6839 use serde::ser::SerializeStruct;
6840 let mut len = 0;
6841 if self.table_id != 0 {
6842 len += 1;
6843 }
6844 if !self.column_orders.is_empty() {
6845 len += 1;
6846 }
6847 if self.table.is_some() {
6848 len += 1;
6849 }
6850 if self.staging_table.is_some() {
6851 len += 1;
6852 }
6853 if self.refresh_progress_table.is_some() {
6854 len += 1;
6855 }
6856 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializeNode", len)?;
6857 if self.table_id != 0 {
6858 struct_ser.serialize_field("tableId", &self.table_id)?;
6859 }
6860 if !self.column_orders.is_empty() {
6861 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
6862 }
6863 if let Some(v) = self.table.as_ref() {
6864 struct_ser.serialize_field("table", v)?;
6865 }
6866 if let Some(v) = self.staging_table.as_ref() {
6867 struct_ser.serialize_field("stagingTable", v)?;
6868 }
6869 if let Some(v) = self.refresh_progress_table.as_ref() {
6870 struct_ser.serialize_field("refreshProgressTable", v)?;
6871 }
6872 struct_ser.end()
6873 }
6874}
6875impl<'de> serde::Deserialize<'de> for MaterializeNode {
6876 #[allow(deprecated)]
6877 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6878 where
6879 D: serde::Deserializer<'de>,
6880 {
6881 const FIELDS: &[&str] = &[
6882 "table_id",
6883 "tableId",
6884 "column_orders",
6885 "columnOrders",
6886 "table",
6887 "staging_table",
6888 "stagingTable",
6889 "refresh_progress_table",
6890 "refreshProgressTable",
6891 ];
6892
6893 #[allow(clippy::enum_variant_names)]
6894 enum GeneratedField {
6895 TableId,
6896 ColumnOrders,
6897 Table,
6898 StagingTable,
6899 RefreshProgressTable,
6900 }
6901 impl<'de> serde::Deserialize<'de> for GeneratedField {
6902 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6903 where
6904 D: serde::Deserializer<'de>,
6905 {
6906 struct GeneratedVisitor;
6907
6908 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6909 type Value = GeneratedField;
6910
6911 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6912 write!(formatter, "expected one of: {:?}", &FIELDS)
6913 }
6914
6915 #[allow(unused_variables)]
6916 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6917 where
6918 E: serde::de::Error,
6919 {
6920 match value {
6921 "tableId" | "table_id" => Ok(GeneratedField::TableId),
6922 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
6923 "table" => Ok(GeneratedField::Table),
6924 "stagingTable" | "staging_table" => Ok(GeneratedField::StagingTable),
6925 "refreshProgressTable" | "refresh_progress_table" => Ok(GeneratedField::RefreshProgressTable),
6926 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6927 }
6928 }
6929 }
6930 deserializer.deserialize_identifier(GeneratedVisitor)
6931 }
6932 }
6933 struct GeneratedVisitor;
6934 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6935 type Value = MaterializeNode;
6936
6937 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6938 formatter.write_str("struct stream_plan.MaterializeNode")
6939 }
6940
6941 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializeNode, V::Error>
6942 where
6943 V: serde::de::MapAccess<'de>,
6944 {
6945 let mut table_id__ = None;
6946 let mut column_orders__ = None;
6947 let mut table__ = None;
6948 let mut staging_table__ = None;
6949 let mut refresh_progress_table__ = None;
6950 while let Some(k) = map_.next_key()? {
6951 match k {
6952 GeneratedField::TableId => {
6953 if table_id__.is_some() {
6954 return Err(serde::de::Error::duplicate_field("tableId"));
6955 }
6956 table_id__ =
6957 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6958 ;
6959 }
6960 GeneratedField::ColumnOrders => {
6961 if column_orders__.is_some() {
6962 return Err(serde::de::Error::duplicate_field("columnOrders"));
6963 }
6964 column_orders__ = Some(map_.next_value()?);
6965 }
6966 GeneratedField::Table => {
6967 if table__.is_some() {
6968 return Err(serde::de::Error::duplicate_field("table"));
6969 }
6970 table__ = map_.next_value()?;
6971 }
6972 GeneratedField::StagingTable => {
6973 if staging_table__.is_some() {
6974 return Err(serde::de::Error::duplicate_field("stagingTable"));
6975 }
6976 staging_table__ = map_.next_value()?;
6977 }
6978 GeneratedField::RefreshProgressTable => {
6979 if refresh_progress_table__.is_some() {
6980 return Err(serde::de::Error::duplicate_field("refreshProgressTable"));
6981 }
6982 refresh_progress_table__ = map_.next_value()?;
6983 }
6984 }
6985 }
6986 Ok(MaterializeNode {
6987 table_id: table_id__.unwrap_or_default(),
6988 column_orders: column_orders__.unwrap_or_default(),
6989 table: table__,
6990 staging_table: staging_table__,
6991 refresh_progress_table: refresh_progress_table__,
6992 })
6993 }
6994 }
6995 deserializer.deserialize_struct("stream_plan.MaterializeNode", FIELDS, GeneratedVisitor)
6996 }
6997}
6998impl serde::Serialize for MaterializedExprsNode {
6999 #[allow(deprecated)]
7000 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7001 where
7002 S: serde::Serializer,
7003 {
7004 use serde::ser::SerializeStruct;
7005 let mut len = 0;
7006 if !self.exprs.is_empty() {
7007 len += 1;
7008 }
7009 if self.state_table.is_some() {
7010 len += 1;
7011 }
7012 if self.state_clean_col_idx.is_some() {
7013 len += 1;
7014 }
7015 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializedExprsNode", len)?;
7016 if !self.exprs.is_empty() {
7017 struct_ser.serialize_field("exprs", &self.exprs)?;
7018 }
7019 if let Some(v) = self.state_table.as_ref() {
7020 struct_ser.serialize_field("stateTable", v)?;
7021 }
7022 if let Some(v) = self.state_clean_col_idx.as_ref() {
7023 struct_ser.serialize_field("stateCleanColIdx", v)?;
7024 }
7025 struct_ser.end()
7026 }
7027}
7028impl<'de> serde::Deserialize<'de> for MaterializedExprsNode {
7029 #[allow(deprecated)]
7030 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7031 where
7032 D: serde::Deserializer<'de>,
7033 {
7034 const FIELDS: &[&str] = &[
7035 "exprs",
7036 "state_table",
7037 "stateTable",
7038 "state_clean_col_idx",
7039 "stateCleanColIdx",
7040 ];
7041
7042 #[allow(clippy::enum_variant_names)]
7043 enum GeneratedField {
7044 Exprs,
7045 StateTable,
7046 StateCleanColIdx,
7047 }
7048 impl<'de> serde::Deserialize<'de> for GeneratedField {
7049 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7050 where
7051 D: serde::Deserializer<'de>,
7052 {
7053 struct GeneratedVisitor;
7054
7055 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7056 type Value = GeneratedField;
7057
7058 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7059 write!(formatter, "expected one of: {:?}", &FIELDS)
7060 }
7061
7062 #[allow(unused_variables)]
7063 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7064 where
7065 E: serde::de::Error,
7066 {
7067 match value {
7068 "exprs" => Ok(GeneratedField::Exprs),
7069 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7070 "stateCleanColIdx" | "state_clean_col_idx" => Ok(GeneratedField::StateCleanColIdx),
7071 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7072 }
7073 }
7074 }
7075 deserializer.deserialize_identifier(GeneratedVisitor)
7076 }
7077 }
7078 struct GeneratedVisitor;
7079 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7080 type Value = MaterializedExprsNode;
7081
7082 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7083 formatter.write_str("struct stream_plan.MaterializedExprsNode")
7084 }
7085
7086 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializedExprsNode, V::Error>
7087 where
7088 V: serde::de::MapAccess<'de>,
7089 {
7090 let mut exprs__ = None;
7091 let mut state_table__ = None;
7092 let mut state_clean_col_idx__ = None;
7093 while let Some(k) = map_.next_key()? {
7094 match k {
7095 GeneratedField::Exprs => {
7096 if exprs__.is_some() {
7097 return Err(serde::de::Error::duplicate_field("exprs"));
7098 }
7099 exprs__ = Some(map_.next_value()?);
7100 }
7101 GeneratedField::StateTable => {
7102 if state_table__.is_some() {
7103 return Err(serde::de::Error::duplicate_field("stateTable"));
7104 }
7105 state_table__ = map_.next_value()?;
7106 }
7107 GeneratedField::StateCleanColIdx => {
7108 if state_clean_col_idx__.is_some() {
7109 return Err(serde::de::Error::duplicate_field("stateCleanColIdx"));
7110 }
7111 state_clean_col_idx__ =
7112 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
7113 ;
7114 }
7115 }
7116 }
7117 Ok(MaterializedExprsNode {
7118 exprs: exprs__.unwrap_or_default(),
7119 state_table: state_table__,
7120 state_clean_col_idx: state_clean_col_idx__,
7121 })
7122 }
7123 }
7124 deserializer.deserialize_struct("stream_plan.MaterializedExprsNode", FIELDS, GeneratedVisitor)
7125 }
7126}
7127impl serde::Serialize for MergeNode {
7128 #[allow(deprecated)]
7129 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7130 where
7131 S: serde::Serializer,
7132 {
7133 use serde::ser::SerializeStruct;
7134 let mut len = 0;
7135 if !self.upstream_actor_id.is_empty() {
7136 len += 1;
7137 }
7138 if self.upstream_fragment_id != 0 {
7139 len += 1;
7140 }
7141 if self.upstream_dispatcher_type != 0 {
7142 len += 1;
7143 }
7144 if !self.fields.is_empty() {
7145 len += 1;
7146 }
7147 let mut struct_ser = serializer.serialize_struct("stream_plan.MergeNode", len)?;
7148 if !self.upstream_actor_id.is_empty() {
7149 struct_ser.serialize_field("upstreamActorId", &self.upstream_actor_id)?;
7150 }
7151 if self.upstream_fragment_id != 0 {
7152 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
7153 }
7154 if self.upstream_dispatcher_type != 0 {
7155 let v = DispatcherType::try_from(self.upstream_dispatcher_type)
7156 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.upstream_dispatcher_type)))?;
7157 struct_ser.serialize_field("upstreamDispatcherType", &v)?;
7158 }
7159 if !self.fields.is_empty() {
7160 struct_ser.serialize_field("fields", &self.fields)?;
7161 }
7162 struct_ser.end()
7163 }
7164}
7165impl<'de> serde::Deserialize<'de> for MergeNode {
7166 #[allow(deprecated)]
7167 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7168 where
7169 D: serde::Deserializer<'de>,
7170 {
7171 const FIELDS: &[&str] = &[
7172 "upstream_actor_id",
7173 "upstreamActorId",
7174 "upstream_fragment_id",
7175 "upstreamFragmentId",
7176 "upstream_dispatcher_type",
7177 "upstreamDispatcherType",
7178 "fields",
7179 ];
7180
7181 #[allow(clippy::enum_variant_names)]
7182 enum GeneratedField {
7183 UpstreamActorId,
7184 UpstreamFragmentId,
7185 UpstreamDispatcherType,
7186 Fields,
7187 }
7188 impl<'de> serde::Deserialize<'de> for GeneratedField {
7189 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7190 where
7191 D: serde::Deserializer<'de>,
7192 {
7193 struct GeneratedVisitor;
7194
7195 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7196 type Value = GeneratedField;
7197
7198 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7199 write!(formatter, "expected one of: {:?}", &FIELDS)
7200 }
7201
7202 #[allow(unused_variables)]
7203 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7204 where
7205 E: serde::de::Error,
7206 {
7207 match value {
7208 "upstreamActorId" | "upstream_actor_id" => Ok(GeneratedField::UpstreamActorId),
7209 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
7210 "upstreamDispatcherType" | "upstream_dispatcher_type" => Ok(GeneratedField::UpstreamDispatcherType),
7211 "fields" => Ok(GeneratedField::Fields),
7212 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7213 }
7214 }
7215 }
7216 deserializer.deserialize_identifier(GeneratedVisitor)
7217 }
7218 }
7219 struct GeneratedVisitor;
7220 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7221 type Value = MergeNode;
7222
7223 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7224 formatter.write_str("struct stream_plan.MergeNode")
7225 }
7226
7227 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeNode, V::Error>
7228 where
7229 V: serde::de::MapAccess<'de>,
7230 {
7231 let mut upstream_actor_id__ = None;
7232 let mut upstream_fragment_id__ = None;
7233 let mut upstream_dispatcher_type__ = None;
7234 let mut fields__ = None;
7235 while let Some(k) = map_.next_key()? {
7236 match k {
7237 GeneratedField::UpstreamActorId => {
7238 if upstream_actor_id__.is_some() {
7239 return Err(serde::de::Error::duplicate_field("upstreamActorId"));
7240 }
7241 upstream_actor_id__ =
7242 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7243 .into_iter().map(|x| x.0).collect())
7244 ;
7245 }
7246 GeneratedField::UpstreamFragmentId => {
7247 if upstream_fragment_id__.is_some() {
7248 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
7249 }
7250 upstream_fragment_id__ =
7251 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7252 ;
7253 }
7254 GeneratedField::UpstreamDispatcherType => {
7255 if upstream_dispatcher_type__.is_some() {
7256 return Err(serde::de::Error::duplicate_field("upstreamDispatcherType"));
7257 }
7258 upstream_dispatcher_type__ = Some(map_.next_value::<DispatcherType>()? as i32);
7259 }
7260 GeneratedField::Fields => {
7261 if fields__.is_some() {
7262 return Err(serde::de::Error::duplicate_field("fields"));
7263 }
7264 fields__ = Some(map_.next_value()?);
7265 }
7266 }
7267 }
7268 Ok(MergeNode {
7269 upstream_actor_id: upstream_actor_id__.unwrap_or_default(),
7270 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
7271 upstream_dispatcher_type: upstream_dispatcher_type__.unwrap_or_default(),
7272 fields: fields__.unwrap_or_default(),
7273 })
7274 }
7275 }
7276 deserializer.deserialize_struct("stream_plan.MergeNode", FIELDS, GeneratedVisitor)
7277 }
7278}
7279impl serde::Serialize for NoOpNode {
7280 #[allow(deprecated)]
7281 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7282 where
7283 S: serde::Serializer,
7284 {
7285 use serde::ser::SerializeStruct;
7286 let len = 0;
7287 let struct_ser = serializer.serialize_struct("stream_plan.NoOpNode", len)?;
7288 struct_ser.end()
7289 }
7290}
7291impl<'de> serde::Deserialize<'de> for NoOpNode {
7292 #[allow(deprecated)]
7293 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7294 where
7295 D: serde::Deserializer<'de>,
7296 {
7297 const FIELDS: &[&str] = &[
7298 ];
7299
7300 #[allow(clippy::enum_variant_names)]
7301 enum GeneratedField {
7302 }
7303 impl<'de> serde::Deserialize<'de> for GeneratedField {
7304 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7305 where
7306 D: serde::Deserializer<'de>,
7307 {
7308 struct GeneratedVisitor;
7309
7310 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7311 type Value = GeneratedField;
7312
7313 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7314 write!(formatter, "expected one of: {:?}", &FIELDS)
7315 }
7316
7317 #[allow(unused_variables)]
7318 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7319 where
7320 E: serde::de::Error,
7321 {
7322 Err(serde::de::Error::unknown_field(value, FIELDS))
7323 }
7324 }
7325 deserializer.deserialize_identifier(GeneratedVisitor)
7326 }
7327 }
7328 struct GeneratedVisitor;
7329 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7330 type Value = NoOpNode;
7331
7332 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7333 formatter.write_str("struct stream_plan.NoOpNode")
7334 }
7335
7336 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NoOpNode, V::Error>
7337 where
7338 V: serde::de::MapAccess<'de>,
7339 {
7340 while map_.next_key::<GeneratedField>()?.is_some() {
7341 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7342 }
7343 Ok(NoOpNode {
7344 })
7345 }
7346 }
7347 deserializer.deserialize_struct("stream_plan.NoOpNode", FIELDS, GeneratedVisitor)
7348 }
7349}
7350impl serde::Serialize for NowModeGenerateSeries {
7351 #[allow(deprecated)]
7352 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7353 where
7354 S: serde::Serializer,
7355 {
7356 use serde::ser::SerializeStruct;
7357 let mut len = 0;
7358 if self.start_timestamp.is_some() {
7359 len += 1;
7360 }
7361 if self.interval.is_some() {
7362 len += 1;
7363 }
7364 let mut struct_ser = serializer.serialize_struct("stream_plan.NowModeGenerateSeries", len)?;
7365 if let Some(v) = self.start_timestamp.as_ref() {
7366 struct_ser.serialize_field("startTimestamp", v)?;
7367 }
7368 if let Some(v) = self.interval.as_ref() {
7369 struct_ser.serialize_field("interval", v)?;
7370 }
7371 struct_ser.end()
7372 }
7373}
7374impl<'de> serde::Deserialize<'de> for NowModeGenerateSeries {
7375 #[allow(deprecated)]
7376 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7377 where
7378 D: serde::Deserializer<'de>,
7379 {
7380 const FIELDS: &[&str] = &[
7381 "start_timestamp",
7382 "startTimestamp",
7383 "interval",
7384 ];
7385
7386 #[allow(clippy::enum_variant_names)]
7387 enum GeneratedField {
7388 StartTimestamp,
7389 Interval,
7390 }
7391 impl<'de> serde::Deserialize<'de> for GeneratedField {
7392 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7393 where
7394 D: serde::Deserializer<'de>,
7395 {
7396 struct GeneratedVisitor;
7397
7398 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7399 type Value = GeneratedField;
7400
7401 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7402 write!(formatter, "expected one of: {:?}", &FIELDS)
7403 }
7404
7405 #[allow(unused_variables)]
7406 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7407 where
7408 E: serde::de::Error,
7409 {
7410 match value {
7411 "startTimestamp" | "start_timestamp" => Ok(GeneratedField::StartTimestamp),
7412 "interval" => Ok(GeneratedField::Interval),
7413 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7414 }
7415 }
7416 }
7417 deserializer.deserialize_identifier(GeneratedVisitor)
7418 }
7419 }
7420 struct GeneratedVisitor;
7421 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7422 type Value = NowModeGenerateSeries;
7423
7424 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7425 formatter.write_str("struct stream_plan.NowModeGenerateSeries")
7426 }
7427
7428 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeGenerateSeries, V::Error>
7429 where
7430 V: serde::de::MapAccess<'de>,
7431 {
7432 let mut start_timestamp__ = None;
7433 let mut interval__ = None;
7434 while let Some(k) = map_.next_key()? {
7435 match k {
7436 GeneratedField::StartTimestamp => {
7437 if start_timestamp__.is_some() {
7438 return Err(serde::de::Error::duplicate_field("startTimestamp"));
7439 }
7440 start_timestamp__ = map_.next_value()?;
7441 }
7442 GeneratedField::Interval => {
7443 if interval__.is_some() {
7444 return Err(serde::de::Error::duplicate_field("interval"));
7445 }
7446 interval__ = map_.next_value()?;
7447 }
7448 }
7449 }
7450 Ok(NowModeGenerateSeries {
7451 start_timestamp: start_timestamp__,
7452 interval: interval__,
7453 })
7454 }
7455 }
7456 deserializer.deserialize_struct("stream_plan.NowModeGenerateSeries", FIELDS, GeneratedVisitor)
7457 }
7458}
7459impl serde::Serialize for NowModeUpdateCurrent {
7460 #[allow(deprecated)]
7461 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7462 where
7463 S: serde::Serializer,
7464 {
7465 use serde::ser::SerializeStruct;
7466 let len = 0;
7467 let struct_ser = serializer.serialize_struct("stream_plan.NowModeUpdateCurrent", len)?;
7468 struct_ser.end()
7469 }
7470}
7471impl<'de> serde::Deserialize<'de> for NowModeUpdateCurrent {
7472 #[allow(deprecated)]
7473 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7474 where
7475 D: serde::Deserializer<'de>,
7476 {
7477 const FIELDS: &[&str] = &[
7478 ];
7479
7480 #[allow(clippy::enum_variant_names)]
7481 enum GeneratedField {
7482 }
7483 impl<'de> serde::Deserialize<'de> for GeneratedField {
7484 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7485 where
7486 D: serde::Deserializer<'de>,
7487 {
7488 struct GeneratedVisitor;
7489
7490 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7491 type Value = GeneratedField;
7492
7493 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7494 write!(formatter, "expected one of: {:?}", &FIELDS)
7495 }
7496
7497 #[allow(unused_variables)]
7498 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7499 where
7500 E: serde::de::Error,
7501 {
7502 Err(serde::de::Error::unknown_field(value, FIELDS))
7503 }
7504 }
7505 deserializer.deserialize_identifier(GeneratedVisitor)
7506 }
7507 }
7508 struct GeneratedVisitor;
7509 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7510 type Value = NowModeUpdateCurrent;
7511
7512 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7513 formatter.write_str("struct stream_plan.NowModeUpdateCurrent")
7514 }
7515
7516 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeUpdateCurrent, V::Error>
7517 where
7518 V: serde::de::MapAccess<'de>,
7519 {
7520 while map_.next_key::<GeneratedField>()?.is_some() {
7521 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7522 }
7523 Ok(NowModeUpdateCurrent {
7524 })
7525 }
7526 }
7527 deserializer.deserialize_struct("stream_plan.NowModeUpdateCurrent", FIELDS, GeneratedVisitor)
7528 }
7529}
7530impl serde::Serialize for NowNode {
7531 #[allow(deprecated)]
7532 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7533 where
7534 S: serde::Serializer,
7535 {
7536 use serde::ser::SerializeStruct;
7537 let mut len = 0;
7538 if self.state_table.is_some() {
7539 len += 1;
7540 }
7541 if self.mode.is_some() {
7542 len += 1;
7543 }
7544 let mut struct_ser = serializer.serialize_struct("stream_plan.NowNode", len)?;
7545 if let Some(v) = self.state_table.as_ref() {
7546 struct_ser.serialize_field("stateTable", v)?;
7547 }
7548 if let Some(v) = self.mode.as_ref() {
7549 match v {
7550 now_node::Mode::UpdateCurrent(v) => {
7551 struct_ser.serialize_field("updateCurrent", v)?;
7552 }
7553 now_node::Mode::GenerateSeries(v) => {
7554 struct_ser.serialize_field("generateSeries", v)?;
7555 }
7556 }
7557 }
7558 struct_ser.end()
7559 }
7560}
7561impl<'de> serde::Deserialize<'de> for NowNode {
7562 #[allow(deprecated)]
7563 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7564 where
7565 D: serde::Deserializer<'de>,
7566 {
7567 const FIELDS: &[&str] = &[
7568 "state_table",
7569 "stateTable",
7570 "update_current",
7571 "updateCurrent",
7572 "generate_series",
7573 "generateSeries",
7574 ];
7575
7576 #[allow(clippy::enum_variant_names)]
7577 enum GeneratedField {
7578 StateTable,
7579 UpdateCurrent,
7580 GenerateSeries,
7581 }
7582 impl<'de> serde::Deserialize<'de> for GeneratedField {
7583 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7584 where
7585 D: serde::Deserializer<'de>,
7586 {
7587 struct GeneratedVisitor;
7588
7589 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7590 type Value = GeneratedField;
7591
7592 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7593 write!(formatter, "expected one of: {:?}", &FIELDS)
7594 }
7595
7596 #[allow(unused_variables)]
7597 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7598 where
7599 E: serde::de::Error,
7600 {
7601 match value {
7602 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7603 "updateCurrent" | "update_current" => Ok(GeneratedField::UpdateCurrent),
7604 "generateSeries" | "generate_series" => Ok(GeneratedField::GenerateSeries),
7605 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7606 }
7607 }
7608 }
7609 deserializer.deserialize_identifier(GeneratedVisitor)
7610 }
7611 }
7612 struct GeneratedVisitor;
7613 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7614 type Value = NowNode;
7615
7616 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7617 formatter.write_str("struct stream_plan.NowNode")
7618 }
7619
7620 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowNode, V::Error>
7621 where
7622 V: serde::de::MapAccess<'de>,
7623 {
7624 let mut state_table__ = None;
7625 let mut mode__ = None;
7626 while let Some(k) = map_.next_key()? {
7627 match k {
7628 GeneratedField::StateTable => {
7629 if state_table__.is_some() {
7630 return Err(serde::de::Error::duplicate_field("stateTable"));
7631 }
7632 state_table__ = map_.next_value()?;
7633 }
7634 GeneratedField::UpdateCurrent => {
7635 if mode__.is_some() {
7636 return Err(serde::de::Error::duplicate_field("updateCurrent"));
7637 }
7638 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::UpdateCurrent)
7639;
7640 }
7641 GeneratedField::GenerateSeries => {
7642 if mode__.is_some() {
7643 return Err(serde::de::Error::duplicate_field("generateSeries"));
7644 }
7645 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::GenerateSeries)
7646;
7647 }
7648 }
7649 }
7650 Ok(NowNode {
7651 state_table: state_table__,
7652 mode: mode__,
7653 })
7654 }
7655 }
7656 deserializer.deserialize_struct("stream_plan.NowNode", FIELDS, GeneratedVisitor)
7657 }
7658}
7659impl serde::Serialize for OverWindowCachePolicy {
7660 #[allow(deprecated)]
7661 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7662 where
7663 S: serde::Serializer,
7664 {
7665 let variant = match self {
7666 Self::Unspecified => "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
7667 Self::Full => "OVER_WINDOW_CACHE_POLICY_FULL",
7668 Self::Recent => "OVER_WINDOW_CACHE_POLICY_RECENT",
7669 Self::RecentFirstN => "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
7670 Self::RecentLastN => "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
7671 };
7672 serializer.serialize_str(variant)
7673 }
7674}
7675impl<'de> serde::Deserialize<'de> for OverWindowCachePolicy {
7676 #[allow(deprecated)]
7677 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7678 where
7679 D: serde::Deserializer<'de>,
7680 {
7681 const FIELDS: &[&str] = &[
7682 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
7683 "OVER_WINDOW_CACHE_POLICY_FULL",
7684 "OVER_WINDOW_CACHE_POLICY_RECENT",
7685 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
7686 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
7687 ];
7688
7689 struct GeneratedVisitor;
7690
7691 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7692 type Value = OverWindowCachePolicy;
7693
7694 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7695 write!(formatter, "expected one of: {:?}", &FIELDS)
7696 }
7697
7698 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
7699 where
7700 E: serde::de::Error,
7701 {
7702 i32::try_from(v)
7703 .ok()
7704 .and_then(|x| x.try_into().ok())
7705 .ok_or_else(|| {
7706 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
7707 })
7708 }
7709
7710 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
7711 where
7712 E: serde::de::Error,
7713 {
7714 i32::try_from(v)
7715 .ok()
7716 .and_then(|x| x.try_into().ok())
7717 .ok_or_else(|| {
7718 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
7719 })
7720 }
7721
7722 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
7723 where
7724 E: serde::de::Error,
7725 {
7726 match value {
7727 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED" => Ok(OverWindowCachePolicy::Unspecified),
7728 "OVER_WINDOW_CACHE_POLICY_FULL" => Ok(OverWindowCachePolicy::Full),
7729 "OVER_WINDOW_CACHE_POLICY_RECENT" => Ok(OverWindowCachePolicy::Recent),
7730 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N" => Ok(OverWindowCachePolicy::RecentFirstN),
7731 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N" => Ok(OverWindowCachePolicy::RecentLastN),
7732 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
7733 }
7734 }
7735 }
7736 deserializer.deserialize_any(GeneratedVisitor)
7737 }
7738}
7739impl serde::Serialize for OverWindowNode {
7740 #[allow(deprecated)]
7741 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7742 where
7743 S: serde::Serializer,
7744 {
7745 use serde::ser::SerializeStruct;
7746 let mut len = 0;
7747 if !self.calls.is_empty() {
7748 len += 1;
7749 }
7750 if !self.partition_by.is_empty() {
7751 len += 1;
7752 }
7753 if !self.order_by.is_empty() {
7754 len += 1;
7755 }
7756 if self.state_table.is_some() {
7757 len += 1;
7758 }
7759 if self.cache_policy != 0 {
7760 len += 1;
7761 }
7762 let mut struct_ser = serializer.serialize_struct("stream_plan.OverWindowNode", len)?;
7763 if !self.calls.is_empty() {
7764 struct_ser.serialize_field("calls", &self.calls)?;
7765 }
7766 if !self.partition_by.is_empty() {
7767 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
7768 }
7769 if !self.order_by.is_empty() {
7770 struct_ser.serialize_field("orderBy", &self.order_by)?;
7771 }
7772 if let Some(v) = self.state_table.as_ref() {
7773 struct_ser.serialize_field("stateTable", v)?;
7774 }
7775 if self.cache_policy != 0 {
7776 let v = OverWindowCachePolicy::try_from(self.cache_policy)
7777 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cache_policy)))?;
7778 struct_ser.serialize_field("cachePolicy", &v)?;
7779 }
7780 struct_ser.end()
7781 }
7782}
7783impl<'de> serde::Deserialize<'de> for OverWindowNode {
7784 #[allow(deprecated)]
7785 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7786 where
7787 D: serde::Deserializer<'de>,
7788 {
7789 const FIELDS: &[&str] = &[
7790 "calls",
7791 "partition_by",
7792 "partitionBy",
7793 "order_by",
7794 "orderBy",
7795 "state_table",
7796 "stateTable",
7797 "cache_policy",
7798 "cachePolicy",
7799 ];
7800
7801 #[allow(clippy::enum_variant_names)]
7802 enum GeneratedField {
7803 Calls,
7804 PartitionBy,
7805 OrderBy,
7806 StateTable,
7807 CachePolicy,
7808 }
7809 impl<'de> serde::Deserialize<'de> for GeneratedField {
7810 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7811 where
7812 D: serde::Deserializer<'de>,
7813 {
7814 struct GeneratedVisitor;
7815
7816 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7817 type Value = GeneratedField;
7818
7819 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7820 write!(formatter, "expected one of: {:?}", &FIELDS)
7821 }
7822
7823 #[allow(unused_variables)]
7824 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7825 where
7826 E: serde::de::Error,
7827 {
7828 match value {
7829 "calls" => Ok(GeneratedField::Calls),
7830 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
7831 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
7832 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7833 "cachePolicy" | "cache_policy" => Ok(GeneratedField::CachePolicy),
7834 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7835 }
7836 }
7837 }
7838 deserializer.deserialize_identifier(GeneratedVisitor)
7839 }
7840 }
7841 struct GeneratedVisitor;
7842 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7843 type Value = OverWindowNode;
7844
7845 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7846 formatter.write_str("struct stream_plan.OverWindowNode")
7847 }
7848
7849 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverWindowNode, V::Error>
7850 where
7851 V: serde::de::MapAccess<'de>,
7852 {
7853 let mut calls__ = None;
7854 let mut partition_by__ = None;
7855 let mut order_by__ = None;
7856 let mut state_table__ = None;
7857 let mut cache_policy__ = None;
7858 while let Some(k) = map_.next_key()? {
7859 match k {
7860 GeneratedField::Calls => {
7861 if calls__.is_some() {
7862 return Err(serde::de::Error::duplicate_field("calls"));
7863 }
7864 calls__ = Some(map_.next_value()?);
7865 }
7866 GeneratedField::PartitionBy => {
7867 if partition_by__.is_some() {
7868 return Err(serde::de::Error::duplicate_field("partitionBy"));
7869 }
7870 partition_by__ =
7871 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7872 .into_iter().map(|x| x.0).collect())
7873 ;
7874 }
7875 GeneratedField::OrderBy => {
7876 if order_by__.is_some() {
7877 return Err(serde::de::Error::duplicate_field("orderBy"));
7878 }
7879 order_by__ = Some(map_.next_value()?);
7880 }
7881 GeneratedField::StateTable => {
7882 if state_table__.is_some() {
7883 return Err(serde::de::Error::duplicate_field("stateTable"));
7884 }
7885 state_table__ = map_.next_value()?;
7886 }
7887 GeneratedField::CachePolicy => {
7888 if cache_policy__.is_some() {
7889 return Err(serde::de::Error::duplicate_field("cachePolicy"));
7890 }
7891 cache_policy__ = Some(map_.next_value::<OverWindowCachePolicy>()? as i32);
7892 }
7893 }
7894 }
7895 Ok(OverWindowNode {
7896 calls: calls__.unwrap_or_default(),
7897 partition_by: partition_by__.unwrap_or_default(),
7898 order_by: order_by__.unwrap_or_default(),
7899 state_table: state_table__,
7900 cache_policy: cache_policy__.unwrap_or_default(),
7901 })
7902 }
7903 }
7904 deserializer.deserialize_struct("stream_plan.OverWindowNode", FIELDS, GeneratedVisitor)
7905 }
7906}
7907impl serde::Serialize for PauseMutation {
7908 #[allow(deprecated)]
7909 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7910 where
7911 S: serde::Serializer,
7912 {
7913 use serde::ser::SerializeStruct;
7914 let len = 0;
7915 let struct_ser = serializer.serialize_struct("stream_plan.PauseMutation", len)?;
7916 struct_ser.end()
7917 }
7918}
7919impl<'de> serde::Deserialize<'de> for PauseMutation {
7920 #[allow(deprecated)]
7921 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7922 where
7923 D: serde::Deserializer<'de>,
7924 {
7925 const FIELDS: &[&str] = &[
7926 ];
7927
7928 #[allow(clippy::enum_variant_names)]
7929 enum GeneratedField {
7930 }
7931 impl<'de> serde::Deserialize<'de> for GeneratedField {
7932 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7933 where
7934 D: serde::Deserializer<'de>,
7935 {
7936 struct GeneratedVisitor;
7937
7938 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7939 type Value = GeneratedField;
7940
7941 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7942 write!(formatter, "expected one of: {:?}", &FIELDS)
7943 }
7944
7945 #[allow(unused_variables)]
7946 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7947 where
7948 E: serde::de::Error,
7949 {
7950 Err(serde::de::Error::unknown_field(value, FIELDS))
7951 }
7952 }
7953 deserializer.deserialize_identifier(GeneratedVisitor)
7954 }
7955 }
7956 struct GeneratedVisitor;
7957 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7958 type Value = PauseMutation;
7959
7960 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7961 formatter.write_str("struct stream_plan.PauseMutation")
7962 }
7963
7964 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseMutation, V::Error>
7965 where
7966 V: serde::de::MapAccess<'de>,
7967 {
7968 while map_.next_key::<GeneratedField>()?.is_some() {
7969 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7970 }
7971 Ok(PauseMutation {
7972 })
7973 }
7974 }
7975 deserializer.deserialize_struct("stream_plan.PauseMutation", FIELDS, GeneratedVisitor)
7976 }
7977}
7978impl serde::Serialize for ProjectNode {
7979 #[allow(deprecated)]
7980 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7981 where
7982 S: serde::Serializer,
7983 {
7984 use serde::ser::SerializeStruct;
7985 let mut len = 0;
7986 if !self.select_list.is_empty() {
7987 len += 1;
7988 }
7989 if !self.watermark_input_cols.is_empty() {
7990 len += 1;
7991 }
7992 if !self.watermark_output_cols.is_empty() {
7993 len += 1;
7994 }
7995 if !self.nondecreasing_exprs.is_empty() {
7996 len += 1;
7997 }
7998 if self.noop_update_hint {
7999 len += 1;
8000 }
8001 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectNode", len)?;
8002 if !self.select_list.is_empty() {
8003 struct_ser.serialize_field("selectList", &self.select_list)?;
8004 }
8005 if !self.watermark_input_cols.is_empty() {
8006 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
8007 }
8008 if !self.watermark_output_cols.is_empty() {
8009 struct_ser.serialize_field("watermarkOutputCols", &self.watermark_output_cols)?;
8010 }
8011 if !self.nondecreasing_exprs.is_empty() {
8012 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
8013 }
8014 if self.noop_update_hint {
8015 struct_ser.serialize_field("noopUpdateHint", &self.noop_update_hint)?;
8016 }
8017 struct_ser.end()
8018 }
8019}
8020impl<'de> serde::Deserialize<'de> for ProjectNode {
8021 #[allow(deprecated)]
8022 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8023 where
8024 D: serde::Deserializer<'de>,
8025 {
8026 const FIELDS: &[&str] = &[
8027 "select_list",
8028 "selectList",
8029 "watermark_input_cols",
8030 "watermarkInputCols",
8031 "watermark_output_cols",
8032 "watermarkOutputCols",
8033 "nondecreasing_exprs",
8034 "nondecreasingExprs",
8035 "noop_update_hint",
8036 "noopUpdateHint",
8037 ];
8038
8039 #[allow(clippy::enum_variant_names)]
8040 enum GeneratedField {
8041 SelectList,
8042 WatermarkInputCols,
8043 WatermarkOutputCols,
8044 NondecreasingExprs,
8045 NoopUpdateHint,
8046 }
8047 impl<'de> serde::Deserialize<'de> for GeneratedField {
8048 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8049 where
8050 D: serde::Deserializer<'de>,
8051 {
8052 struct GeneratedVisitor;
8053
8054 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8055 type Value = GeneratedField;
8056
8057 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8058 write!(formatter, "expected one of: {:?}", &FIELDS)
8059 }
8060
8061 #[allow(unused_variables)]
8062 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8063 where
8064 E: serde::de::Error,
8065 {
8066 match value {
8067 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
8068 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
8069 "watermarkOutputCols" | "watermark_output_cols" => Ok(GeneratedField::WatermarkOutputCols),
8070 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
8071 "noopUpdateHint" | "noop_update_hint" => Ok(GeneratedField::NoopUpdateHint),
8072 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8073 }
8074 }
8075 }
8076 deserializer.deserialize_identifier(GeneratedVisitor)
8077 }
8078 }
8079 struct GeneratedVisitor;
8080 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8081 type Value = ProjectNode;
8082
8083 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8084 formatter.write_str("struct stream_plan.ProjectNode")
8085 }
8086
8087 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
8088 where
8089 V: serde::de::MapAccess<'de>,
8090 {
8091 let mut select_list__ = None;
8092 let mut watermark_input_cols__ = None;
8093 let mut watermark_output_cols__ = None;
8094 let mut nondecreasing_exprs__ = None;
8095 let mut noop_update_hint__ = None;
8096 while let Some(k) = map_.next_key()? {
8097 match k {
8098 GeneratedField::SelectList => {
8099 if select_list__.is_some() {
8100 return Err(serde::de::Error::duplicate_field("selectList"));
8101 }
8102 select_list__ = Some(map_.next_value()?);
8103 }
8104 GeneratedField::WatermarkInputCols => {
8105 if watermark_input_cols__.is_some() {
8106 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
8107 }
8108 watermark_input_cols__ =
8109 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8110 .into_iter().map(|x| x.0).collect())
8111 ;
8112 }
8113 GeneratedField::WatermarkOutputCols => {
8114 if watermark_output_cols__.is_some() {
8115 return Err(serde::de::Error::duplicate_field("watermarkOutputCols"));
8116 }
8117 watermark_output_cols__ =
8118 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8119 .into_iter().map(|x| x.0).collect())
8120 ;
8121 }
8122 GeneratedField::NondecreasingExprs => {
8123 if nondecreasing_exprs__.is_some() {
8124 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
8125 }
8126 nondecreasing_exprs__ =
8127 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8128 .into_iter().map(|x| x.0).collect())
8129 ;
8130 }
8131 GeneratedField::NoopUpdateHint => {
8132 if noop_update_hint__.is_some() {
8133 return Err(serde::de::Error::duplicate_field("noopUpdateHint"));
8134 }
8135 noop_update_hint__ = Some(map_.next_value()?);
8136 }
8137 }
8138 }
8139 Ok(ProjectNode {
8140 select_list: select_list__.unwrap_or_default(),
8141 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
8142 watermark_output_cols: watermark_output_cols__.unwrap_or_default(),
8143 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
8144 noop_update_hint: noop_update_hint__.unwrap_or_default(),
8145 })
8146 }
8147 }
8148 deserializer.deserialize_struct("stream_plan.ProjectNode", FIELDS, GeneratedVisitor)
8149 }
8150}
8151impl serde::Serialize for ProjectSetNode {
8152 #[allow(deprecated)]
8153 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8154 where
8155 S: serde::Serializer,
8156 {
8157 use serde::ser::SerializeStruct;
8158 let mut len = 0;
8159 if !self.select_list.is_empty() {
8160 len += 1;
8161 }
8162 if !self.watermark_input_cols.is_empty() {
8163 len += 1;
8164 }
8165 if !self.watermark_expr_indices.is_empty() {
8166 len += 1;
8167 }
8168 if !self.nondecreasing_exprs.is_empty() {
8169 len += 1;
8170 }
8171 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectSetNode", len)?;
8172 if !self.select_list.is_empty() {
8173 struct_ser.serialize_field("selectList", &self.select_list)?;
8174 }
8175 if !self.watermark_input_cols.is_empty() {
8176 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
8177 }
8178 if !self.watermark_expr_indices.is_empty() {
8179 struct_ser.serialize_field("watermarkExprIndices", &self.watermark_expr_indices)?;
8180 }
8181 if !self.nondecreasing_exprs.is_empty() {
8182 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
8183 }
8184 struct_ser.end()
8185 }
8186}
8187impl<'de> serde::Deserialize<'de> for ProjectSetNode {
8188 #[allow(deprecated)]
8189 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8190 where
8191 D: serde::Deserializer<'de>,
8192 {
8193 const FIELDS: &[&str] = &[
8194 "select_list",
8195 "selectList",
8196 "watermark_input_cols",
8197 "watermarkInputCols",
8198 "watermark_expr_indices",
8199 "watermarkExprIndices",
8200 "nondecreasing_exprs",
8201 "nondecreasingExprs",
8202 ];
8203
8204 #[allow(clippy::enum_variant_names)]
8205 enum GeneratedField {
8206 SelectList,
8207 WatermarkInputCols,
8208 WatermarkExprIndices,
8209 NondecreasingExprs,
8210 }
8211 impl<'de> serde::Deserialize<'de> for GeneratedField {
8212 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8213 where
8214 D: serde::Deserializer<'de>,
8215 {
8216 struct GeneratedVisitor;
8217
8218 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8219 type Value = GeneratedField;
8220
8221 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8222 write!(formatter, "expected one of: {:?}", &FIELDS)
8223 }
8224
8225 #[allow(unused_variables)]
8226 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8227 where
8228 E: serde::de::Error,
8229 {
8230 match value {
8231 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
8232 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
8233 "watermarkExprIndices" | "watermark_expr_indices" => Ok(GeneratedField::WatermarkExprIndices),
8234 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
8235 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8236 }
8237 }
8238 }
8239 deserializer.deserialize_identifier(GeneratedVisitor)
8240 }
8241 }
8242 struct GeneratedVisitor;
8243 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8244 type Value = ProjectSetNode;
8245
8246 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8247 formatter.write_str("struct stream_plan.ProjectSetNode")
8248 }
8249
8250 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
8251 where
8252 V: serde::de::MapAccess<'de>,
8253 {
8254 let mut select_list__ = None;
8255 let mut watermark_input_cols__ = None;
8256 let mut watermark_expr_indices__ = None;
8257 let mut nondecreasing_exprs__ = None;
8258 while let Some(k) = map_.next_key()? {
8259 match k {
8260 GeneratedField::SelectList => {
8261 if select_list__.is_some() {
8262 return Err(serde::de::Error::duplicate_field("selectList"));
8263 }
8264 select_list__ = Some(map_.next_value()?);
8265 }
8266 GeneratedField::WatermarkInputCols => {
8267 if watermark_input_cols__.is_some() {
8268 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
8269 }
8270 watermark_input_cols__ =
8271 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8272 .into_iter().map(|x| x.0).collect())
8273 ;
8274 }
8275 GeneratedField::WatermarkExprIndices => {
8276 if watermark_expr_indices__.is_some() {
8277 return Err(serde::de::Error::duplicate_field("watermarkExprIndices"));
8278 }
8279 watermark_expr_indices__ =
8280 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8281 .into_iter().map(|x| x.0).collect())
8282 ;
8283 }
8284 GeneratedField::NondecreasingExprs => {
8285 if nondecreasing_exprs__.is_some() {
8286 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
8287 }
8288 nondecreasing_exprs__ =
8289 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8290 .into_iter().map(|x| x.0).collect())
8291 ;
8292 }
8293 }
8294 }
8295 Ok(ProjectSetNode {
8296 select_list: select_list__.unwrap_or_default(),
8297 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
8298 watermark_expr_indices: watermark_expr_indices__.unwrap_or_default(),
8299 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
8300 })
8301 }
8302 }
8303 deserializer.deserialize_struct("stream_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
8304 }
8305}
8306impl serde::Serialize for RefreshStartMutation {
8307 #[allow(deprecated)]
8308 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8309 where
8310 S: serde::Serializer,
8311 {
8312 use serde::ser::SerializeStruct;
8313 let mut len = 0;
8314 if self.table_id != 0 {
8315 len += 1;
8316 }
8317 if self.associated_source_id != 0 {
8318 len += 1;
8319 }
8320 let mut struct_ser = serializer.serialize_struct("stream_plan.RefreshStartMutation", len)?;
8321 if self.table_id != 0 {
8322 struct_ser.serialize_field("tableId", &self.table_id)?;
8323 }
8324 if self.associated_source_id != 0 {
8325 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
8326 }
8327 struct_ser.end()
8328 }
8329}
8330impl<'de> serde::Deserialize<'de> for RefreshStartMutation {
8331 #[allow(deprecated)]
8332 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8333 where
8334 D: serde::Deserializer<'de>,
8335 {
8336 const FIELDS: &[&str] = &[
8337 "table_id",
8338 "tableId",
8339 "associated_source_id",
8340 "associatedSourceId",
8341 ];
8342
8343 #[allow(clippy::enum_variant_names)]
8344 enum GeneratedField {
8345 TableId,
8346 AssociatedSourceId,
8347 }
8348 impl<'de> serde::Deserialize<'de> for GeneratedField {
8349 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8350 where
8351 D: serde::Deserializer<'de>,
8352 {
8353 struct GeneratedVisitor;
8354
8355 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8356 type Value = GeneratedField;
8357
8358 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8359 write!(formatter, "expected one of: {:?}", &FIELDS)
8360 }
8361
8362 #[allow(unused_variables)]
8363 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8364 where
8365 E: serde::de::Error,
8366 {
8367 match value {
8368 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8369 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
8370 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8371 }
8372 }
8373 }
8374 deserializer.deserialize_identifier(GeneratedVisitor)
8375 }
8376 }
8377 struct GeneratedVisitor;
8378 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8379 type Value = RefreshStartMutation;
8380
8381 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8382 formatter.write_str("struct stream_plan.RefreshStartMutation")
8383 }
8384
8385 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshStartMutation, V::Error>
8386 where
8387 V: serde::de::MapAccess<'de>,
8388 {
8389 let mut table_id__ = None;
8390 let mut associated_source_id__ = None;
8391 while let Some(k) = map_.next_key()? {
8392 match k {
8393 GeneratedField::TableId => {
8394 if table_id__.is_some() {
8395 return Err(serde::de::Error::duplicate_field("tableId"));
8396 }
8397 table_id__ =
8398 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8399 ;
8400 }
8401 GeneratedField::AssociatedSourceId => {
8402 if associated_source_id__.is_some() {
8403 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
8404 }
8405 associated_source_id__ =
8406 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8407 ;
8408 }
8409 }
8410 }
8411 Ok(RefreshStartMutation {
8412 table_id: table_id__.unwrap_or_default(),
8413 associated_source_id: associated_source_id__.unwrap_or_default(),
8414 })
8415 }
8416 }
8417 deserializer.deserialize_struct("stream_plan.RefreshStartMutation", FIELDS, GeneratedVisitor)
8418 }
8419}
8420impl serde::Serialize for ResumeMutation {
8421 #[allow(deprecated)]
8422 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8423 where
8424 S: serde::Serializer,
8425 {
8426 use serde::ser::SerializeStruct;
8427 let len = 0;
8428 let struct_ser = serializer.serialize_struct("stream_plan.ResumeMutation", len)?;
8429 struct_ser.end()
8430 }
8431}
8432impl<'de> serde::Deserialize<'de> for ResumeMutation {
8433 #[allow(deprecated)]
8434 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8435 where
8436 D: serde::Deserializer<'de>,
8437 {
8438 const FIELDS: &[&str] = &[
8439 ];
8440
8441 #[allow(clippy::enum_variant_names)]
8442 enum GeneratedField {
8443 }
8444 impl<'de> serde::Deserialize<'de> for GeneratedField {
8445 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8446 where
8447 D: serde::Deserializer<'de>,
8448 {
8449 struct GeneratedVisitor;
8450
8451 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8452 type Value = GeneratedField;
8453
8454 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8455 write!(formatter, "expected one of: {:?}", &FIELDS)
8456 }
8457
8458 #[allow(unused_variables)]
8459 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8460 where
8461 E: serde::de::Error,
8462 {
8463 Err(serde::de::Error::unknown_field(value, FIELDS))
8464 }
8465 }
8466 deserializer.deserialize_identifier(GeneratedVisitor)
8467 }
8468 }
8469 struct GeneratedVisitor;
8470 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8471 type Value = ResumeMutation;
8472
8473 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8474 formatter.write_str("struct stream_plan.ResumeMutation")
8475 }
8476
8477 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeMutation, V::Error>
8478 where
8479 V: serde::de::MapAccess<'de>,
8480 {
8481 while map_.next_key::<GeneratedField>()?.is_some() {
8482 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8483 }
8484 Ok(ResumeMutation {
8485 })
8486 }
8487 }
8488 deserializer.deserialize_struct("stream_plan.ResumeMutation", FIELDS, GeneratedVisitor)
8489 }
8490}
8491impl serde::Serialize for RowIdGenNode {
8492 #[allow(deprecated)]
8493 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8494 where
8495 S: serde::Serializer,
8496 {
8497 use serde::ser::SerializeStruct;
8498 let mut len = 0;
8499 if self.row_id_index != 0 {
8500 len += 1;
8501 }
8502 let mut struct_ser = serializer.serialize_struct("stream_plan.RowIdGenNode", len)?;
8503 if self.row_id_index != 0 {
8504 #[allow(clippy::needless_borrow)]
8505 #[allow(clippy::needless_borrows_for_generic_args)]
8506 struct_ser.serialize_field("rowIdIndex", ToString::to_string(&self.row_id_index).as_str())?;
8507 }
8508 struct_ser.end()
8509 }
8510}
8511impl<'de> serde::Deserialize<'de> for RowIdGenNode {
8512 #[allow(deprecated)]
8513 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8514 where
8515 D: serde::Deserializer<'de>,
8516 {
8517 const FIELDS: &[&str] = &[
8518 "row_id_index",
8519 "rowIdIndex",
8520 ];
8521
8522 #[allow(clippy::enum_variant_names)]
8523 enum GeneratedField {
8524 RowIdIndex,
8525 }
8526 impl<'de> serde::Deserialize<'de> for GeneratedField {
8527 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8528 where
8529 D: serde::Deserializer<'de>,
8530 {
8531 struct GeneratedVisitor;
8532
8533 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8534 type Value = GeneratedField;
8535
8536 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8537 write!(formatter, "expected one of: {:?}", &FIELDS)
8538 }
8539
8540 #[allow(unused_variables)]
8541 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8542 where
8543 E: serde::de::Error,
8544 {
8545 match value {
8546 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
8547 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8548 }
8549 }
8550 }
8551 deserializer.deserialize_identifier(GeneratedVisitor)
8552 }
8553 }
8554 struct GeneratedVisitor;
8555 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8556 type Value = RowIdGenNode;
8557
8558 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8559 formatter.write_str("struct stream_plan.RowIdGenNode")
8560 }
8561
8562 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowIdGenNode, V::Error>
8563 where
8564 V: serde::de::MapAccess<'de>,
8565 {
8566 let mut row_id_index__ = None;
8567 while let Some(k) = map_.next_key()? {
8568 match k {
8569 GeneratedField::RowIdIndex => {
8570 if row_id_index__.is_some() {
8571 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
8572 }
8573 row_id_index__ =
8574 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8575 ;
8576 }
8577 }
8578 }
8579 Ok(RowIdGenNode {
8580 row_id_index: row_id_index__.unwrap_or_default(),
8581 })
8582 }
8583 }
8584 deserializer.deserialize_struct("stream_plan.RowIdGenNode", FIELDS, GeneratedVisitor)
8585 }
8586}
8587impl serde::Serialize for RowMergeNode {
8588 #[allow(deprecated)]
8589 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8590 where
8591 S: serde::Serializer,
8592 {
8593 use serde::ser::SerializeStruct;
8594 let mut len = 0;
8595 if self.lhs_mapping.is_some() {
8596 len += 1;
8597 }
8598 if self.rhs_mapping.is_some() {
8599 len += 1;
8600 }
8601 let mut struct_ser = serializer.serialize_struct("stream_plan.RowMergeNode", len)?;
8602 if let Some(v) = self.lhs_mapping.as_ref() {
8603 struct_ser.serialize_field("lhsMapping", v)?;
8604 }
8605 if let Some(v) = self.rhs_mapping.as_ref() {
8606 struct_ser.serialize_field("rhsMapping", v)?;
8607 }
8608 struct_ser.end()
8609 }
8610}
8611impl<'de> serde::Deserialize<'de> for RowMergeNode {
8612 #[allow(deprecated)]
8613 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8614 where
8615 D: serde::Deserializer<'de>,
8616 {
8617 const FIELDS: &[&str] = &[
8618 "lhs_mapping",
8619 "lhsMapping",
8620 "rhs_mapping",
8621 "rhsMapping",
8622 ];
8623
8624 #[allow(clippy::enum_variant_names)]
8625 enum GeneratedField {
8626 LhsMapping,
8627 RhsMapping,
8628 }
8629 impl<'de> serde::Deserialize<'de> for GeneratedField {
8630 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8631 where
8632 D: serde::Deserializer<'de>,
8633 {
8634 struct GeneratedVisitor;
8635
8636 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8637 type Value = GeneratedField;
8638
8639 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8640 write!(formatter, "expected one of: {:?}", &FIELDS)
8641 }
8642
8643 #[allow(unused_variables)]
8644 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8645 where
8646 E: serde::de::Error,
8647 {
8648 match value {
8649 "lhsMapping" | "lhs_mapping" => Ok(GeneratedField::LhsMapping),
8650 "rhsMapping" | "rhs_mapping" => Ok(GeneratedField::RhsMapping),
8651 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8652 }
8653 }
8654 }
8655 deserializer.deserialize_identifier(GeneratedVisitor)
8656 }
8657 }
8658 struct GeneratedVisitor;
8659 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8660 type Value = RowMergeNode;
8661
8662 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8663 formatter.write_str("struct stream_plan.RowMergeNode")
8664 }
8665
8666 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowMergeNode, V::Error>
8667 where
8668 V: serde::de::MapAccess<'de>,
8669 {
8670 let mut lhs_mapping__ = None;
8671 let mut rhs_mapping__ = None;
8672 while let Some(k) = map_.next_key()? {
8673 match k {
8674 GeneratedField::LhsMapping => {
8675 if lhs_mapping__.is_some() {
8676 return Err(serde::de::Error::duplicate_field("lhsMapping"));
8677 }
8678 lhs_mapping__ = map_.next_value()?;
8679 }
8680 GeneratedField::RhsMapping => {
8681 if rhs_mapping__.is_some() {
8682 return Err(serde::de::Error::duplicate_field("rhsMapping"));
8683 }
8684 rhs_mapping__ = map_.next_value()?;
8685 }
8686 }
8687 }
8688 Ok(RowMergeNode {
8689 lhs_mapping: lhs_mapping__,
8690 rhs_mapping: rhs_mapping__,
8691 })
8692 }
8693 }
8694 deserializer.deserialize_struct("stream_plan.RowMergeNode", FIELDS, GeneratedVisitor)
8695 }
8696}
8697impl serde::Serialize for SimpleAggNode {
8698 #[allow(deprecated)]
8699 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8700 where
8701 S: serde::Serializer,
8702 {
8703 use serde::ser::SerializeStruct;
8704 let mut len = 0;
8705 if !self.agg_calls.is_empty() {
8706 len += 1;
8707 }
8708 if !self.agg_call_states.is_empty() {
8709 len += 1;
8710 }
8711 if self.intermediate_state_table.is_some() {
8712 len += 1;
8713 }
8714 if self.is_append_only {
8715 len += 1;
8716 }
8717 if !self.distinct_dedup_tables.is_empty() {
8718 len += 1;
8719 }
8720 if self.row_count_index != 0 {
8721 len += 1;
8722 }
8723 if self.version != 0 {
8724 len += 1;
8725 }
8726 if self.must_output_per_barrier {
8727 len += 1;
8728 }
8729 let mut struct_ser = serializer.serialize_struct("stream_plan.SimpleAggNode", len)?;
8730 if !self.agg_calls.is_empty() {
8731 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
8732 }
8733 if !self.agg_call_states.is_empty() {
8734 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
8735 }
8736 if let Some(v) = self.intermediate_state_table.as_ref() {
8737 struct_ser.serialize_field("intermediateStateTable", v)?;
8738 }
8739 if self.is_append_only {
8740 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
8741 }
8742 if !self.distinct_dedup_tables.is_empty() {
8743 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
8744 }
8745 if self.row_count_index != 0 {
8746 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
8747 }
8748 if self.version != 0 {
8749 let v = AggNodeVersion::try_from(self.version)
8750 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
8751 struct_ser.serialize_field("version", &v)?;
8752 }
8753 if self.must_output_per_barrier {
8754 struct_ser.serialize_field("mustOutputPerBarrier", &self.must_output_per_barrier)?;
8755 }
8756 struct_ser.end()
8757 }
8758}
8759impl<'de> serde::Deserialize<'de> for SimpleAggNode {
8760 #[allow(deprecated)]
8761 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8762 where
8763 D: serde::Deserializer<'de>,
8764 {
8765 const FIELDS: &[&str] = &[
8766 "agg_calls",
8767 "aggCalls",
8768 "agg_call_states",
8769 "aggCallStates",
8770 "intermediate_state_table",
8771 "intermediateStateTable",
8772 "is_append_only",
8773 "isAppendOnly",
8774 "distinct_dedup_tables",
8775 "distinctDedupTables",
8776 "row_count_index",
8777 "rowCountIndex",
8778 "version",
8779 "must_output_per_barrier",
8780 "mustOutputPerBarrier",
8781 ];
8782
8783 #[allow(clippy::enum_variant_names)]
8784 enum GeneratedField {
8785 AggCalls,
8786 AggCallStates,
8787 IntermediateStateTable,
8788 IsAppendOnly,
8789 DistinctDedupTables,
8790 RowCountIndex,
8791 Version,
8792 MustOutputPerBarrier,
8793 }
8794 impl<'de> serde::Deserialize<'de> for GeneratedField {
8795 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8796 where
8797 D: serde::Deserializer<'de>,
8798 {
8799 struct GeneratedVisitor;
8800
8801 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8802 type Value = GeneratedField;
8803
8804 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8805 write!(formatter, "expected one of: {:?}", &FIELDS)
8806 }
8807
8808 #[allow(unused_variables)]
8809 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8810 where
8811 E: serde::de::Error,
8812 {
8813 match value {
8814 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
8815 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
8816 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
8817 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
8818 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
8819 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
8820 "version" => Ok(GeneratedField::Version),
8821 "mustOutputPerBarrier" | "must_output_per_barrier" => Ok(GeneratedField::MustOutputPerBarrier),
8822 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8823 }
8824 }
8825 }
8826 deserializer.deserialize_identifier(GeneratedVisitor)
8827 }
8828 }
8829 struct GeneratedVisitor;
8830 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8831 type Value = SimpleAggNode;
8832
8833 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8834 formatter.write_str("struct stream_plan.SimpleAggNode")
8835 }
8836
8837 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SimpleAggNode, V::Error>
8838 where
8839 V: serde::de::MapAccess<'de>,
8840 {
8841 let mut agg_calls__ = None;
8842 let mut agg_call_states__ = None;
8843 let mut intermediate_state_table__ = None;
8844 let mut is_append_only__ = None;
8845 let mut distinct_dedup_tables__ = None;
8846 let mut row_count_index__ = None;
8847 let mut version__ = None;
8848 let mut must_output_per_barrier__ = None;
8849 while let Some(k) = map_.next_key()? {
8850 match k {
8851 GeneratedField::AggCalls => {
8852 if agg_calls__.is_some() {
8853 return Err(serde::de::Error::duplicate_field("aggCalls"));
8854 }
8855 agg_calls__ = Some(map_.next_value()?);
8856 }
8857 GeneratedField::AggCallStates => {
8858 if agg_call_states__.is_some() {
8859 return Err(serde::de::Error::duplicate_field("aggCallStates"));
8860 }
8861 agg_call_states__ = Some(map_.next_value()?);
8862 }
8863 GeneratedField::IntermediateStateTable => {
8864 if intermediate_state_table__.is_some() {
8865 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
8866 }
8867 intermediate_state_table__ = map_.next_value()?;
8868 }
8869 GeneratedField::IsAppendOnly => {
8870 if is_append_only__.is_some() {
8871 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
8872 }
8873 is_append_only__ = Some(map_.next_value()?);
8874 }
8875 GeneratedField::DistinctDedupTables => {
8876 if distinct_dedup_tables__.is_some() {
8877 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
8878 }
8879 distinct_dedup_tables__ = Some(
8880 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8881 .into_iter().map(|(k,v)| (k.0, v)).collect()
8882 );
8883 }
8884 GeneratedField::RowCountIndex => {
8885 if row_count_index__.is_some() {
8886 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
8887 }
8888 row_count_index__ =
8889 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8890 ;
8891 }
8892 GeneratedField::Version => {
8893 if version__.is_some() {
8894 return Err(serde::de::Error::duplicate_field("version"));
8895 }
8896 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
8897 }
8898 GeneratedField::MustOutputPerBarrier => {
8899 if must_output_per_barrier__.is_some() {
8900 return Err(serde::de::Error::duplicate_field("mustOutputPerBarrier"));
8901 }
8902 must_output_per_barrier__ = Some(map_.next_value()?);
8903 }
8904 }
8905 }
8906 Ok(SimpleAggNode {
8907 agg_calls: agg_calls__.unwrap_or_default(),
8908 agg_call_states: agg_call_states__.unwrap_or_default(),
8909 intermediate_state_table: intermediate_state_table__,
8910 is_append_only: is_append_only__.unwrap_or_default(),
8911 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
8912 row_count_index: row_count_index__.unwrap_or_default(),
8913 version: version__.unwrap_or_default(),
8914 must_output_per_barrier: must_output_per_barrier__.unwrap_or_default(),
8915 })
8916 }
8917 }
8918 deserializer.deserialize_struct("stream_plan.SimpleAggNode", FIELDS, GeneratedVisitor)
8919 }
8920}
8921impl serde::Serialize for SinkAddColumns {
8922 #[allow(deprecated)]
8923 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8924 where
8925 S: serde::Serializer,
8926 {
8927 use serde::ser::SerializeStruct;
8928 let mut len = 0;
8929 if !self.fields.is_empty() {
8930 len += 1;
8931 }
8932 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkAddColumns", len)?;
8933 if !self.fields.is_empty() {
8934 struct_ser.serialize_field("fields", &self.fields)?;
8935 }
8936 struct_ser.end()
8937 }
8938}
8939impl<'de> serde::Deserialize<'de> for SinkAddColumns {
8940 #[allow(deprecated)]
8941 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8942 where
8943 D: serde::Deserializer<'de>,
8944 {
8945 const FIELDS: &[&str] = &[
8946 "fields",
8947 ];
8948
8949 #[allow(clippy::enum_variant_names)]
8950 enum GeneratedField {
8951 Fields,
8952 }
8953 impl<'de> serde::Deserialize<'de> for GeneratedField {
8954 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8955 where
8956 D: serde::Deserializer<'de>,
8957 {
8958 struct GeneratedVisitor;
8959
8960 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8961 type Value = GeneratedField;
8962
8963 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8964 write!(formatter, "expected one of: {:?}", &FIELDS)
8965 }
8966
8967 #[allow(unused_variables)]
8968 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8969 where
8970 E: serde::de::Error,
8971 {
8972 match value {
8973 "fields" => Ok(GeneratedField::Fields),
8974 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8975 }
8976 }
8977 }
8978 deserializer.deserialize_identifier(GeneratedVisitor)
8979 }
8980 }
8981 struct GeneratedVisitor;
8982 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8983 type Value = SinkAddColumns;
8984
8985 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8986 formatter.write_str("struct stream_plan.SinkAddColumns")
8987 }
8988
8989 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkAddColumns, V::Error>
8990 where
8991 V: serde::de::MapAccess<'de>,
8992 {
8993 let mut fields__ = None;
8994 while let Some(k) = map_.next_key()? {
8995 match k {
8996 GeneratedField::Fields => {
8997 if fields__.is_some() {
8998 return Err(serde::de::Error::duplicate_field("fields"));
8999 }
9000 fields__ = Some(map_.next_value()?);
9001 }
9002 }
9003 }
9004 Ok(SinkAddColumns {
9005 fields: fields__.unwrap_or_default(),
9006 })
9007 }
9008 }
9009 deserializer.deserialize_struct("stream_plan.SinkAddColumns", FIELDS, GeneratedVisitor)
9010 }
9011}
9012impl serde::Serialize for SinkDesc {
9013 #[allow(deprecated)]
9014 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9015 where
9016 S: serde::Serializer,
9017 {
9018 use serde::ser::SerializeStruct;
9019 let mut len = 0;
9020 if self.id != 0 {
9021 len += 1;
9022 }
9023 if !self.name.is_empty() {
9024 len += 1;
9025 }
9026 if !self.definition.is_empty() {
9027 len += 1;
9028 }
9029 if !self.plan_pk.is_empty() {
9030 len += 1;
9031 }
9032 if !self.downstream_pk.is_empty() {
9033 len += 1;
9034 }
9035 if !self.distribution_key.is_empty() {
9036 len += 1;
9037 }
9038 if !self.properties.is_empty() {
9039 len += 1;
9040 }
9041 if self.sink_type != 0 {
9042 len += 1;
9043 }
9044 if !self.column_catalogs.is_empty() {
9045 len += 1;
9046 }
9047 if !self.db_name.is_empty() {
9048 len += 1;
9049 }
9050 if !self.sink_from_name.is_empty() {
9051 len += 1;
9052 }
9053 if self.format_desc.is_some() {
9054 len += 1;
9055 }
9056 if self.target_table.is_some() {
9057 len += 1;
9058 }
9059 if self.extra_partition_col_idx.is_some() {
9060 len += 1;
9061 }
9062 if !self.secret_refs.is_empty() {
9063 len += 1;
9064 }
9065 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDesc", len)?;
9066 if self.id != 0 {
9067 struct_ser.serialize_field("id", &self.id)?;
9068 }
9069 if !self.name.is_empty() {
9070 struct_ser.serialize_field("name", &self.name)?;
9071 }
9072 if !self.definition.is_empty() {
9073 struct_ser.serialize_field("definition", &self.definition)?;
9074 }
9075 if !self.plan_pk.is_empty() {
9076 struct_ser.serialize_field("planPk", &self.plan_pk)?;
9077 }
9078 if !self.downstream_pk.is_empty() {
9079 struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
9080 }
9081 if !self.distribution_key.is_empty() {
9082 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
9083 }
9084 if !self.properties.is_empty() {
9085 struct_ser.serialize_field("properties", &self.properties)?;
9086 }
9087 if self.sink_type != 0 {
9088 let v = super::catalog::SinkType::try_from(self.sink_type)
9089 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
9090 struct_ser.serialize_field("sinkType", &v)?;
9091 }
9092 if !self.column_catalogs.is_empty() {
9093 struct_ser.serialize_field("columnCatalogs", &self.column_catalogs)?;
9094 }
9095 if !self.db_name.is_empty() {
9096 struct_ser.serialize_field("dbName", &self.db_name)?;
9097 }
9098 if !self.sink_from_name.is_empty() {
9099 struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
9100 }
9101 if let Some(v) = self.format_desc.as_ref() {
9102 struct_ser.serialize_field("formatDesc", v)?;
9103 }
9104 if let Some(v) = self.target_table.as_ref() {
9105 struct_ser.serialize_field("targetTable", v)?;
9106 }
9107 if let Some(v) = self.extra_partition_col_idx.as_ref() {
9108 #[allow(clippy::needless_borrow)]
9109 #[allow(clippy::needless_borrows_for_generic_args)]
9110 struct_ser.serialize_field("extraPartitionColIdx", ToString::to_string(&v).as_str())?;
9111 }
9112 if !self.secret_refs.is_empty() {
9113 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
9114 }
9115 struct_ser.end()
9116 }
9117}
9118impl<'de> serde::Deserialize<'de> for SinkDesc {
9119 #[allow(deprecated)]
9120 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9121 where
9122 D: serde::Deserializer<'de>,
9123 {
9124 const FIELDS: &[&str] = &[
9125 "id",
9126 "name",
9127 "definition",
9128 "plan_pk",
9129 "planPk",
9130 "downstream_pk",
9131 "downstreamPk",
9132 "distribution_key",
9133 "distributionKey",
9134 "properties",
9135 "sink_type",
9136 "sinkType",
9137 "column_catalogs",
9138 "columnCatalogs",
9139 "db_name",
9140 "dbName",
9141 "sink_from_name",
9142 "sinkFromName",
9143 "format_desc",
9144 "formatDesc",
9145 "target_table",
9146 "targetTable",
9147 "extra_partition_col_idx",
9148 "extraPartitionColIdx",
9149 "secret_refs",
9150 "secretRefs",
9151 ];
9152
9153 #[allow(clippy::enum_variant_names)]
9154 enum GeneratedField {
9155 Id,
9156 Name,
9157 Definition,
9158 PlanPk,
9159 DownstreamPk,
9160 DistributionKey,
9161 Properties,
9162 SinkType,
9163 ColumnCatalogs,
9164 DbName,
9165 SinkFromName,
9166 FormatDesc,
9167 TargetTable,
9168 ExtraPartitionColIdx,
9169 SecretRefs,
9170 }
9171 impl<'de> serde::Deserialize<'de> for GeneratedField {
9172 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9173 where
9174 D: serde::Deserializer<'de>,
9175 {
9176 struct GeneratedVisitor;
9177
9178 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9179 type Value = GeneratedField;
9180
9181 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9182 write!(formatter, "expected one of: {:?}", &FIELDS)
9183 }
9184
9185 #[allow(unused_variables)]
9186 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9187 where
9188 E: serde::de::Error,
9189 {
9190 match value {
9191 "id" => Ok(GeneratedField::Id),
9192 "name" => Ok(GeneratedField::Name),
9193 "definition" => Ok(GeneratedField::Definition),
9194 "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
9195 "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
9196 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
9197 "properties" => Ok(GeneratedField::Properties),
9198 "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
9199 "columnCatalogs" | "column_catalogs" => Ok(GeneratedField::ColumnCatalogs),
9200 "dbName" | "db_name" => Ok(GeneratedField::DbName),
9201 "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
9202 "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
9203 "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
9204 "extraPartitionColIdx" | "extra_partition_col_idx" => Ok(GeneratedField::ExtraPartitionColIdx),
9205 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
9206 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9207 }
9208 }
9209 }
9210 deserializer.deserialize_identifier(GeneratedVisitor)
9211 }
9212 }
9213 struct GeneratedVisitor;
9214 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9215 type Value = SinkDesc;
9216
9217 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9218 formatter.write_str("struct stream_plan.SinkDesc")
9219 }
9220
9221 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDesc, V::Error>
9222 where
9223 V: serde::de::MapAccess<'de>,
9224 {
9225 let mut id__ = None;
9226 let mut name__ = None;
9227 let mut definition__ = None;
9228 let mut plan_pk__ = None;
9229 let mut downstream_pk__ = None;
9230 let mut distribution_key__ = None;
9231 let mut properties__ = None;
9232 let mut sink_type__ = None;
9233 let mut column_catalogs__ = None;
9234 let mut db_name__ = None;
9235 let mut sink_from_name__ = None;
9236 let mut format_desc__ = None;
9237 let mut target_table__ = None;
9238 let mut extra_partition_col_idx__ = None;
9239 let mut secret_refs__ = None;
9240 while let Some(k) = map_.next_key()? {
9241 match k {
9242 GeneratedField::Id => {
9243 if id__.is_some() {
9244 return Err(serde::de::Error::duplicate_field("id"));
9245 }
9246 id__ =
9247 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9248 ;
9249 }
9250 GeneratedField::Name => {
9251 if name__.is_some() {
9252 return Err(serde::de::Error::duplicate_field("name"));
9253 }
9254 name__ = Some(map_.next_value()?);
9255 }
9256 GeneratedField::Definition => {
9257 if definition__.is_some() {
9258 return Err(serde::de::Error::duplicate_field("definition"));
9259 }
9260 definition__ = Some(map_.next_value()?);
9261 }
9262 GeneratedField::PlanPk => {
9263 if plan_pk__.is_some() {
9264 return Err(serde::de::Error::duplicate_field("planPk"));
9265 }
9266 plan_pk__ = Some(map_.next_value()?);
9267 }
9268 GeneratedField::DownstreamPk => {
9269 if downstream_pk__.is_some() {
9270 return Err(serde::de::Error::duplicate_field("downstreamPk"));
9271 }
9272 downstream_pk__ =
9273 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9274 .into_iter().map(|x| x.0).collect())
9275 ;
9276 }
9277 GeneratedField::DistributionKey => {
9278 if distribution_key__.is_some() {
9279 return Err(serde::de::Error::duplicate_field("distributionKey"));
9280 }
9281 distribution_key__ =
9282 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9283 .into_iter().map(|x| x.0).collect())
9284 ;
9285 }
9286 GeneratedField::Properties => {
9287 if properties__.is_some() {
9288 return Err(serde::de::Error::duplicate_field("properties"));
9289 }
9290 properties__ = Some(
9291 map_.next_value::<std::collections::BTreeMap<_, _>>()?
9292 );
9293 }
9294 GeneratedField::SinkType => {
9295 if sink_type__.is_some() {
9296 return Err(serde::de::Error::duplicate_field("sinkType"));
9297 }
9298 sink_type__ = Some(map_.next_value::<super::catalog::SinkType>()? as i32);
9299 }
9300 GeneratedField::ColumnCatalogs => {
9301 if column_catalogs__.is_some() {
9302 return Err(serde::de::Error::duplicate_field("columnCatalogs"));
9303 }
9304 column_catalogs__ = Some(map_.next_value()?);
9305 }
9306 GeneratedField::DbName => {
9307 if db_name__.is_some() {
9308 return Err(serde::de::Error::duplicate_field("dbName"));
9309 }
9310 db_name__ = Some(map_.next_value()?);
9311 }
9312 GeneratedField::SinkFromName => {
9313 if sink_from_name__.is_some() {
9314 return Err(serde::de::Error::duplicate_field("sinkFromName"));
9315 }
9316 sink_from_name__ = Some(map_.next_value()?);
9317 }
9318 GeneratedField::FormatDesc => {
9319 if format_desc__.is_some() {
9320 return Err(serde::de::Error::duplicate_field("formatDesc"));
9321 }
9322 format_desc__ = map_.next_value()?;
9323 }
9324 GeneratedField::TargetTable => {
9325 if target_table__.is_some() {
9326 return Err(serde::de::Error::duplicate_field("targetTable"));
9327 }
9328 target_table__ =
9329 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9330 ;
9331 }
9332 GeneratedField::ExtraPartitionColIdx => {
9333 if extra_partition_col_idx__.is_some() {
9334 return Err(serde::de::Error::duplicate_field("extraPartitionColIdx"));
9335 }
9336 extra_partition_col_idx__ =
9337 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9338 ;
9339 }
9340 GeneratedField::SecretRefs => {
9341 if secret_refs__.is_some() {
9342 return Err(serde::de::Error::duplicate_field("secretRefs"));
9343 }
9344 secret_refs__ = Some(
9345 map_.next_value::<std::collections::BTreeMap<_, _>>()?
9346 );
9347 }
9348 }
9349 }
9350 Ok(SinkDesc {
9351 id: id__.unwrap_or_default(),
9352 name: name__.unwrap_or_default(),
9353 definition: definition__.unwrap_or_default(),
9354 plan_pk: plan_pk__.unwrap_or_default(),
9355 downstream_pk: downstream_pk__.unwrap_or_default(),
9356 distribution_key: distribution_key__.unwrap_or_default(),
9357 properties: properties__.unwrap_or_default(),
9358 sink_type: sink_type__.unwrap_or_default(),
9359 column_catalogs: column_catalogs__.unwrap_or_default(),
9360 db_name: db_name__.unwrap_or_default(),
9361 sink_from_name: sink_from_name__.unwrap_or_default(),
9362 format_desc: format_desc__,
9363 target_table: target_table__,
9364 extra_partition_col_idx: extra_partition_col_idx__,
9365 secret_refs: secret_refs__.unwrap_or_default(),
9366 })
9367 }
9368 }
9369 deserializer.deserialize_struct("stream_plan.SinkDesc", FIELDS, GeneratedVisitor)
9370 }
9371}
9372impl serde::Serialize for SinkLogStoreType {
9373 #[allow(deprecated)]
9374 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9375 where
9376 S: serde::Serializer,
9377 {
9378 let variant = match self {
9379 Self::Unspecified => "SINK_LOG_STORE_TYPE_UNSPECIFIED",
9380 Self::KvLogStore => "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
9381 Self::InMemoryLogStore => "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
9382 };
9383 serializer.serialize_str(variant)
9384 }
9385}
9386impl<'de> serde::Deserialize<'de> for SinkLogStoreType {
9387 #[allow(deprecated)]
9388 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9389 where
9390 D: serde::Deserializer<'de>,
9391 {
9392 const FIELDS: &[&str] = &[
9393 "SINK_LOG_STORE_TYPE_UNSPECIFIED",
9394 "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
9395 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
9396 ];
9397
9398 struct GeneratedVisitor;
9399
9400 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9401 type Value = SinkLogStoreType;
9402
9403 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9404 write!(formatter, "expected one of: {:?}", &FIELDS)
9405 }
9406
9407 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9408 where
9409 E: serde::de::Error,
9410 {
9411 i32::try_from(v)
9412 .ok()
9413 .and_then(|x| x.try_into().ok())
9414 .ok_or_else(|| {
9415 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9416 })
9417 }
9418
9419 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9420 where
9421 E: serde::de::Error,
9422 {
9423 i32::try_from(v)
9424 .ok()
9425 .and_then(|x| x.try_into().ok())
9426 .ok_or_else(|| {
9427 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9428 })
9429 }
9430
9431 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9432 where
9433 E: serde::de::Error,
9434 {
9435 match value {
9436 "SINK_LOG_STORE_TYPE_UNSPECIFIED" => Ok(SinkLogStoreType::Unspecified),
9437 "SINK_LOG_STORE_TYPE_KV_LOG_STORE" => Ok(SinkLogStoreType::KvLogStore),
9438 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE" => Ok(SinkLogStoreType::InMemoryLogStore),
9439 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9440 }
9441 }
9442 }
9443 deserializer.deserialize_any(GeneratedVisitor)
9444 }
9445}
9446impl serde::Serialize for SinkNode {
9447 #[allow(deprecated)]
9448 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9449 where
9450 S: serde::Serializer,
9451 {
9452 use serde::ser::SerializeStruct;
9453 let mut len = 0;
9454 if self.sink_desc.is_some() {
9455 len += 1;
9456 }
9457 if self.table.is_some() {
9458 len += 1;
9459 }
9460 if self.log_store_type != 0 {
9461 len += 1;
9462 }
9463 if self.rate_limit.is_some() {
9464 len += 1;
9465 }
9466 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkNode", len)?;
9467 if let Some(v) = self.sink_desc.as_ref() {
9468 struct_ser.serialize_field("sinkDesc", v)?;
9469 }
9470 if let Some(v) = self.table.as_ref() {
9471 struct_ser.serialize_field("table", v)?;
9472 }
9473 if self.log_store_type != 0 {
9474 let v = SinkLogStoreType::try_from(self.log_store_type)
9475 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.log_store_type)))?;
9476 struct_ser.serialize_field("logStoreType", &v)?;
9477 }
9478 if let Some(v) = self.rate_limit.as_ref() {
9479 struct_ser.serialize_field("rateLimit", v)?;
9480 }
9481 struct_ser.end()
9482 }
9483}
9484impl<'de> serde::Deserialize<'de> for SinkNode {
9485 #[allow(deprecated)]
9486 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9487 where
9488 D: serde::Deserializer<'de>,
9489 {
9490 const FIELDS: &[&str] = &[
9491 "sink_desc",
9492 "sinkDesc",
9493 "table",
9494 "log_store_type",
9495 "logStoreType",
9496 "rate_limit",
9497 "rateLimit",
9498 ];
9499
9500 #[allow(clippy::enum_variant_names)]
9501 enum GeneratedField {
9502 SinkDesc,
9503 Table,
9504 LogStoreType,
9505 RateLimit,
9506 }
9507 impl<'de> serde::Deserialize<'de> for GeneratedField {
9508 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9509 where
9510 D: serde::Deserializer<'de>,
9511 {
9512 struct GeneratedVisitor;
9513
9514 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9515 type Value = GeneratedField;
9516
9517 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9518 write!(formatter, "expected one of: {:?}", &FIELDS)
9519 }
9520
9521 #[allow(unused_variables)]
9522 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9523 where
9524 E: serde::de::Error,
9525 {
9526 match value {
9527 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
9528 "table" => Ok(GeneratedField::Table),
9529 "logStoreType" | "log_store_type" => Ok(GeneratedField::LogStoreType),
9530 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
9531 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9532 }
9533 }
9534 }
9535 deserializer.deserialize_identifier(GeneratedVisitor)
9536 }
9537 }
9538 struct GeneratedVisitor;
9539 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9540 type Value = SinkNode;
9541
9542 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9543 formatter.write_str("struct stream_plan.SinkNode")
9544 }
9545
9546 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkNode, V::Error>
9547 where
9548 V: serde::de::MapAccess<'de>,
9549 {
9550 let mut sink_desc__ = None;
9551 let mut table__ = None;
9552 let mut log_store_type__ = None;
9553 let mut rate_limit__ = None;
9554 while let Some(k) = map_.next_key()? {
9555 match k {
9556 GeneratedField::SinkDesc => {
9557 if sink_desc__.is_some() {
9558 return Err(serde::de::Error::duplicate_field("sinkDesc"));
9559 }
9560 sink_desc__ = map_.next_value()?;
9561 }
9562 GeneratedField::Table => {
9563 if table__.is_some() {
9564 return Err(serde::de::Error::duplicate_field("table"));
9565 }
9566 table__ = map_.next_value()?;
9567 }
9568 GeneratedField::LogStoreType => {
9569 if log_store_type__.is_some() {
9570 return Err(serde::de::Error::duplicate_field("logStoreType"));
9571 }
9572 log_store_type__ = Some(map_.next_value::<SinkLogStoreType>()? as i32);
9573 }
9574 GeneratedField::RateLimit => {
9575 if rate_limit__.is_some() {
9576 return Err(serde::de::Error::duplicate_field("rateLimit"));
9577 }
9578 rate_limit__ =
9579 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9580 ;
9581 }
9582 }
9583 }
9584 Ok(SinkNode {
9585 sink_desc: sink_desc__,
9586 table: table__,
9587 log_store_type: log_store_type__.unwrap_or_default(),
9588 rate_limit: rate_limit__,
9589 })
9590 }
9591 }
9592 deserializer.deserialize_struct("stream_plan.SinkNode", FIELDS, GeneratedVisitor)
9593 }
9594}
9595impl serde::Serialize for SortNode {
9596 #[allow(deprecated)]
9597 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9598 where
9599 S: serde::Serializer,
9600 {
9601 use serde::ser::SerializeStruct;
9602 let mut len = 0;
9603 if self.state_table.is_some() {
9604 len += 1;
9605 }
9606 if self.sort_column_index != 0 {
9607 len += 1;
9608 }
9609 let mut struct_ser = serializer.serialize_struct("stream_plan.SortNode", len)?;
9610 if let Some(v) = self.state_table.as_ref() {
9611 struct_ser.serialize_field("stateTable", v)?;
9612 }
9613 if self.sort_column_index != 0 {
9614 struct_ser.serialize_field("sortColumnIndex", &self.sort_column_index)?;
9615 }
9616 struct_ser.end()
9617 }
9618}
9619impl<'de> serde::Deserialize<'de> for SortNode {
9620 #[allow(deprecated)]
9621 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9622 where
9623 D: serde::Deserializer<'de>,
9624 {
9625 const FIELDS: &[&str] = &[
9626 "state_table",
9627 "stateTable",
9628 "sort_column_index",
9629 "sortColumnIndex",
9630 ];
9631
9632 #[allow(clippy::enum_variant_names)]
9633 enum GeneratedField {
9634 StateTable,
9635 SortColumnIndex,
9636 }
9637 impl<'de> serde::Deserialize<'de> for GeneratedField {
9638 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9639 where
9640 D: serde::Deserializer<'de>,
9641 {
9642 struct GeneratedVisitor;
9643
9644 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9645 type Value = GeneratedField;
9646
9647 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9648 write!(formatter, "expected one of: {:?}", &FIELDS)
9649 }
9650
9651 #[allow(unused_variables)]
9652 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9653 where
9654 E: serde::de::Error,
9655 {
9656 match value {
9657 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9658 "sortColumnIndex" | "sort_column_index" => Ok(GeneratedField::SortColumnIndex),
9659 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9660 }
9661 }
9662 }
9663 deserializer.deserialize_identifier(GeneratedVisitor)
9664 }
9665 }
9666 struct GeneratedVisitor;
9667 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9668 type Value = SortNode;
9669
9670 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9671 formatter.write_str("struct stream_plan.SortNode")
9672 }
9673
9674 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
9675 where
9676 V: serde::de::MapAccess<'de>,
9677 {
9678 let mut state_table__ = None;
9679 let mut sort_column_index__ = None;
9680 while let Some(k) = map_.next_key()? {
9681 match k {
9682 GeneratedField::StateTable => {
9683 if state_table__.is_some() {
9684 return Err(serde::de::Error::duplicate_field("stateTable"));
9685 }
9686 state_table__ = map_.next_value()?;
9687 }
9688 GeneratedField::SortColumnIndex => {
9689 if sort_column_index__.is_some() {
9690 return Err(serde::de::Error::duplicate_field("sortColumnIndex"));
9691 }
9692 sort_column_index__ =
9693 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9694 ;
9695 }
9696 }
9697 }
9698 Ok(SortNode {
9699 state_table: state_table__,
9700 sort_column_index: sort_column_index__.unwrap_or_default(),
9701 })
9702 }
9703 }
9704 deserializer.deserialize_struct("stream_plan.SortNode", FIELDS, GeneratedVisitor)
9705 }
9706}
9707impl serde::Serialize for SourceBackfillNode {
9708 #[allow(deprecated)]
9709 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9710 where
9711 S: serde::Serializer,
9712 {
9713 use serde::ser::SerializeStruct;
9714 let mut len = 0;
9715 if self.upstream_source_id != 0 {
9716 len += 1;
9717 }
9718 if self.row_id_index.is_some() {
9719 len += 1;
9720 }
9721 if !self.columns.is_empty() {
9722 len += 1;
9723 }
9724 if self.info.is_some() {
9725 len += 1;
9726 }
9727 if !self.source_name.is_empty() {
9728 len += 1;
9729 }
9730 if !self.with_properties.is_empty() {
9731 len += 1;
9732 }
9733 if self.rate_limit.is_some() {
9734 len += 1;
9735 }
9736 if self.state_table.is_some() {
9737 len += 1;
9738 }
9739 if !self.secret_refs.is_empty() {
9740 len += 1;
9741 }
9742 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceBackfillNode", len)?;
9743 if self.upstream_source_id != 0 {
9744 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
9745 }
9746 if let Some(v) = self.row_id_index.as_ref() {
9747 struct_ser.serialize_field("rowIdIndex", v)?;
9748 }
9749 if !self.columns.is_empty() {
9750 struct_ser.serialize_field("columns", &self.columns)?;
9751 }
9752 if let Some(v) = self.info.as_ref() {
9753 struct_ser.serialize_field("info", v)?;
9754 }
9755 if !self.source_name.is_empty() {
9756 struct_ser.serialize_field("sourceName", &self.source_name)?;
9757 }
9758 if !self.with_properties.is_empty() {
9759 struct_ser.serialize_field("withProperties", &self.with_properties)?;
9760 }
9761 if let Some(v) = self.rate_limit.as_ref() {
9762 struct_ser.serialize_field("rateLimit", v)?;
9763 }
9764 if let Some(v) = self.state_table.as_ref() {
9765 struct_ser.serialize_field("stateTable", v)?;
9766 }
9767 if !self.secret_refs.is_empty() {
9768 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
9769 }
9770 struct_ser.end()
9771 }
9772}
9773impl<'de> serde::Deserialize<'de> for SourceBackfillNode {
9774 #[allow(deprecated)]
9775 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9776 where
9777 D: serde::Deserializer<'de>,
9778 {
9779 const FIELDS: &[&str] = &[
9780 "upstream_source_id",
9781 "upstreamSourceId",
9782 "row_id_index",
9783 "rowIdIndex",
9784 "columns",
9785 "info",
9786 "source_name",
9787 "sourceName",
9788 "with_properties",
9789 "withProperties",
9790 "rate_limit",
9791 "rateLimit",
9792 "state_table",
9793 "stateTable",
9794 "secret_refs",
9795 "secretRefs",
9796 ];
9797
9798 #[allow(clippy::enum_variant_names)]
9799 enum GeneratedField {
9800 UpstreamSourceId,
9801 RowIdIndex,
9802 Columns,
9803 Info,
9804 SourceName,
9805 WithProperties,
9806 RateLimit,
9807 StateTable,
9808 SecretRefs,
9809 }
9810 impl<'de> serde::Deserialize<'de> for GeneratedField {
9811 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9812 where
9813 D: serde::Deserializer<'de>,
9814 {
9815 struct GeneratedVisitor;
9816
9817 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9818 type Value = GeneratedField;
9819
9820 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9821 write!(formatter, "expected one of: {:?}", &FIELDS)
9822 }
9823
9824 #[allow(unused_variables)]
9825 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9826 where
9827 E: serde::de::Error,
9828 {
9829 match value {
9830 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
9831 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
9832 "columns" => Ok(GeneratedField::Columns),
9833 "info" => Ok(GeneratedField::Info),
9834 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
9835 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
9836 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
9837 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9838 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
9839 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9840 }
9841 }
9842 }
9843 deserializer.deserialize_identifier(GeneratedVisitor)
9844 }
9845 }
9846 struct GeneratedVisitor;
9847 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9848 type Value = SourceBackfillNode;
9849
9850 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9851 formatter.write_str("struct stream_plan.SourceBackfillNode")
9852 }
9853
9854 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceBackfillNode, V::Error>
9855 where
9856 V: serde::de::MapAccess<'de>,
9857 {
9858 let mut upstream_source_id__ = None;
9859 let mut row_id_index__ = None;
9860 let mut columns__ = None;
9861 let mut info__ = None;
9862 let mut source_name__ = None;
9863 let mut with_properties__ = None;
9864 let mut rate_limit__ = None;
9865 let mut state_table__ = None;
9866 let mut secret_refs__ = None;
9867 while let Some(k) = map_.next_key()? {
9868 match k {
9869 GeneratedField::UpstreamSourceId => {
9870 if upstream_source_id__.is_some() {
9871 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
9872 }
9873 upstream_source_id__ =
9874 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9875 ;
9876 }
9877 GeneratedField::RowIdIndex => {
9878 if row_id_index__.is_some() {
9879 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
9880 }
9881 row_id_index__ =
9882 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9883 ;
9884 }
9885 GeneratedField::Columns => {
9886 if columns__.is_some() {
9887 return Err(serde::de::Error::duplicate_field("columns"));
9888 }
9889 columns__ = Some(map_.next_value()?);
9890 }
9891 GeneratedField::Info => {
9892 if info__.is_some() {
9893 return Err(serde::de::Error::duplicate_field("info"));
9894 }
9895 info__ = map_.next_value()?;
9896 }
9897 GeneratedField::SourceName => {
9898 if source_name__.is_some() {
9899 return Err(serde::de::Error::duplicate_field("sourceName"));
9900 }
9901 source_name__ = Some(map_.next_value()?);
9902 }
9903 GeneratedField::WithProperties => {
9904 if with_properties__.is_some() {
9905 return Err(serde::de::Error::duplicate_field("withProperties"));
9906 }
9907 with_properties__ = Some(
9908 map_.next_value::<std::collections::BTreeMap<_, _>>()?
9909 );
9910 }
9911 GeneratedField::RateLimit => {
9912 if rate_limit__.is_some() {
9913 return Err(serde::de::Error::duplicate_field("rateLimit"));
9914 }
9915 rate_limit__ =
9916 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9917 ;
9918 }
9919 GeneratedField::StateTable => {
9920 if state_table__.is_some() {
9921 return Err(serde::de::Error::duplicate_field("stateTable"));
9922 }
9923 state_table__ = map_.next_value()?;
9924 }
9925 GeneratedField::SecretRefs => {
9926 if secret_refs__.is_some() {
9927 return Err(serde::de::Error::duplicate_field("secretRefs"));
9928 }
9929 secret_refs__ = Some(
9930 map_.next_value::<std::collections::BTreeMap<_, _>>()?
9931 );
9932 }
9933 }
9934 }
9935 Ok(SourceBackfillNode {
9936 upstream_source_id: upstream_source_id__.unwrap_or_default(),
9937 row_id_index: row_id_index__,
9938 columns: columns__.unwrap_or_default(),
9939 info: info__,
9940 source_name: source_name__.unwrap_or_default(),
9941 with_properties: with_properties__.unwrap_or_default(),
9942 rate_limit: rate_limit__,
9943 state_table: state_table__,
9944 secret_refs: secret_refs__.unwrap_or_default(),
9945 })
9946 }
9947 }
9948 deserializer.deserialize_struct("stream_plan.SourceBackfillNode", FIELDS, GeneratedVisitor)
9949 }
9950}
9951impl serde::Serialize for SourceChangeSplitMutation {
9952 #[allow(deprecated)]
9953 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9954 where
9955 S: serde::Serializer,
9956 {
9957 use serde::ser::SerializeStruct;
9958 let mut len = 0;
9959 if !self.actor_splits.is_empty() {
9960 len += 1;
9961 }
9962 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceChangeSplitMutation", len)?;
9963 if !self.actor_splits.is_empty() {
9964 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
9965 }
9966 struct_ser.end()
9967 }
9968}
9969impl<'de> serde::Deserialize<'de> for SourceChangeSplitMutation {
9970 #[allow(deprecated)]
9971 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9972 where
9973 D: serde::Deserializer<'de>,
9974 {
9975 const FIELDS: &[&str] = &[
9976 "actor_splits",
9977 "actorSplits",
9978 ];
9979
9980 #[allow(clippy::enum_variant_names)]
9981 enum GeneratedField {
9982 ActorSplits,
9983 }
9984 impl<'de> serde::Deserialize<'de> for GeneratedField {
9985 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9986 where
9987 D: serde::Deserializer<'de>,
9988 {
9989 struct GeneratedVisitor;
9990
9991 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9992 type Value = GeneratedField;
9993
9994 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9995 write!(formatter, "expected one of: {:?}", &FIELDS)
9996 }
9997
9998 #[allow(unused_variables)]
9999 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10000 where
10001 E: serde::de::Error,
10002 {
10003 match value {
10004 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
10005 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10006 }
10007 }
10008 }
10009 deserializer.deserialize_identifier(GeneratedVisitor)
10010 }
10011 }
10012 struct GeneratedVisitor;
10013 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10014 type Value = SourceChangeSplitMutation;
10015
10016 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10017 formatter.write_str("struct stream_plan.SourceChangeSplitMutation")
10018 }
10019
10020 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceChangeSplitMutation, V::Error>
10021 where
10022 V: serde::de::MapAccess<'de>,
10023 {
10024 let mut actor_splits__ = None;
10025 while let Some(k) = map_.next_key()? {
10026 match k {
10027 GeneratedField::ActorSplits => {
10028 if actor_splits__.is_some() {
10029 return Err(serde::de::Error::duplicate_field("actorSplits"));
10030 }
10031 actor_splits__ = Some(
10032 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10033 .into_iter().map(|(k,v)| (k.0, v)).collect()
10034 );
10035 }
10036 }
10037 }
10038 Ok(SourceChangeSplitMutation {
10039 actor_splits: actor_splits__.unwrap_or_default(),
10040 })
10041 }
10042 }
10043 deserializer.deserialize_struct("stream_plan.SourceChangeSplitMutation", FIELDS, GeneratedVisitor)
10044 }
10045}
10046impl serde::Serialize for SourceNode {
10047 #[allow(deprecated)]
10048 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10049 where
10050 S: serde::Serializer,
10051 {
10052 use serde::ser::SerializeStruct;
10053 let mut len = 0;
10054 if self.source_inner.is_some() {
10055 len += 1;
10056 }
10057 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceNode", len)?;
10058 if let Some(v) = self.source_inner.as_ref() {
10059 struct_ser.serialize_field("sourceInner", v)?;
10060 }
10061 struct_ser.end()
10062 }
10063}
10064impl<'de> serde::Deserialize<'de> for SourceNode {
10065 #[allow(deprecated)]
10066 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10067 where
10068 D: serde::Deserializer<'de>,
10069 {
10070 const FIELDS: &[&str] = &[
10071 "source_inner",
10072 "sourceInner",
10073 ];
10074
10075 #[allow(clippy::enum_variant_names)]
10076 enum GeneratedField {
10077 SourceInner,
10078 }
10079 impl<'de> serde::Deserialize<'de> for GeneratedField {
10080 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10081 where
10082 D: serde::Deserializer<'de>,
10083 {
10084 struct GeneratedVisitor;
10085
10086 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10087 type Value = GeneratedField;
10088
10089 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10090 write!(formatter, "expected one of: {:?}", &FIELDS)
10091 }
10092
10093 #[allow(unused_variables)]
10094 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10095 where
10096 E: serde::de::Error,
10097 {
10098 match value {
10099 "sourceInner" | "source_inner" => Ok(GeneratedField::SourceInner),
10100 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10101 }
10102 }
10103 }
10104 deserializer.deserialize_identifier(GeneratedVisitor)
10105 }
10106 }
10107 struct GeneratedVisitor;
10108 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10109 type Value = SourceNode;
10110
10111 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10112 formatter.write_str("struct stream_plan.SourceNode")
10113 }
10114
10115 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
10116 where
10117 V: serde::de::MapAccess<'de>,
10118 {
10119 let mut source_inner__ = None;
10120 while let Some(k) = map_.next_key()? {
10121 match k {
10122 GeneratedField::SourceInner => {
10123 if source_inner__.is_some() {
10124 return Err(serde::de::Error::duplicate_field("sourceInner"));
10125 }
10126 source_inner__ = map_.next_value()?;
10127 }
10128 }
10129 }
10130 Ok(SourceNode {
10131 source_inner: source_inner__,
10132 })
10133 }
10134 }
10135 deserializer.deserialize_struct("stream_plan.SourceNode", FIELDS, GeneratedVisitor)
10136 }
10137}
10138impl serde::Serialize for StartFragmentBackfillMutation {
10139 #[allow(deprecated)]
10140 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10141 where
10142 S: serde::Serializer,
10143 {
10144 use serde::ser::SerializeStruct;
10145 let mut len = 0;
10146 if !self.fragment_ids.is_empty() {
10147 len += 1;
10148 }
10149 let mut struct_ser = serializer.serialize_struct("stream_plan.StartFragmentBackfillMutation", len)?;
10150 if !self.fragment_ids.is_empty() {
10151 struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
10152 }
10153 struct_ser.end()
10154 }
10155}
10156impl<'de> serde::Deserialize<'de> for StartFragmentBackfillMutation {
10157 #[allow(deprecated)]
10158 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10159 where
10160 D: serde::Deserializer<'de>,
10161 {
10162 const FIELDS: &[&str] = &[
10163 "fragment_ids",
10164 "fragmentIds",
10165 ];
10166
10167 #[allow(clippy::enum_variant_names)]
10168 enum GeneratedField {
10169 FragmentIds,
10170 }
10171 impl<'de> serde::Deserialize<'de> for GeneratedField {
10172 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10173 where
10174 D: serde::Deserializer<'de>,
10175 {
10176 struct GeneratedVisitor;
10177
10178 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10179 type Value = GeneratedField;
10180
10181 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10182 write!(formatter, "expected one of: {:?}", &FIELDS)
10183 }
10184
10185 #[allow(unused_variables)]
10186 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10187 where
10188 E: serde::de::Error,
10189 {
10190 match value {
10191 "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
10192 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10193 }
10194 }
10195 }
10196 deserializer.deserialize_identifier(GeneratedVisitor)
10197 }
10198 }
10199 struct GeneratedVisitor;
10200 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10201 type Value = StartFragmentBackfillMutation;
10202
10203 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10204 formatter.write_str("struct stream_plan.StartFragmentBackfillMutation")
10205 }
10206
10207 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StartFragmentBackfillMutation, V::Error>
10208 where
10209 V: serde::de::MapAccess<'de>,
10210 {
10211 let mut fragment_ids__ = None;
10212 while let Some(k) = map_.next_key()? {
10213 match k {
10214 GeneratedField::FragmentIds => {
10215 if fragment_ids__.is_some() {
10216 return Err(serde::de::Error::duplicate_field("fragmentIds"));
10217 }
10218 fragment_ids__ =
10219 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10220 .into_iter().map(|x| x.0).collect())
10221 ;
10222 }
10223 }
10224 }
10225 Ok(StartFragmentBackfillMutation {
10226 fragment_ids: fragment_ids__.unwrap_or_default(),
10227 })
10228 }
10229 }
10230 deserializer.deserialize_struct("stream_plan.StartFragmentBackfillMutation", FIELDS, GeneratedVisitor)
10231 }
10232}
10233impl serde::Serialize for StopMutation {
10234 #[allow(deprecated)]
10235 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10236 where
10237 S: serde::Serializer,
10238 {
10239 use serde::ser::SerializeStruct;
10240 let mut len = 0;
10241 if !self.actors.is_empty() {
10242 len += 1;
10243 }
10244 if !self.dropped_sink_fragments.is_empty() {
10245 len += 1;
10246 }
10247 let mut struct_ser = serializer.serialize_struct("stream_plan.StopMutation", len)?;
10248 if !self.actors.is_empty() {
10249 struct_ser.serialize_field("actors", &self.actors)?;
10250 }
10251 if !self.dropped_sink_fragments.is_empty() {
10252 struct_ser.serialize_field("droppedSinkFragments", &self.dropped_sink_fragments)?;
10253 }
10254 struct_ser.end()
10255 }
10256}
10257impl<'de> serde::Deserialize<'de> for StopMutation {
10258 #[allow(deprecated)]
10259 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10260 where
10261 D: serde::Deserializer<'de>,
10262 {
10263 const FIELDS: &[&str] = &[
10264 "actors",
10265 "dropped_sink_fragments",
10266 "droppedSinkFragments",
10267 ];
10268
10269 #[allow(clippy::enum_variant_names)]
10270 enum GeneratedField {
10271 Actors,
10272 DroppedSinkFragments,
10273 }
10274 impl<'de> serde::Deserialize<'de> for GeneratedField {
10275 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10276 where
10277 D: serde::Deserializer<'de>,
10278 {
10279 struct GeneratedVisitor;
10280
10281 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10282 type Value = GeneratedField;
10283
10284 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10285 write!(formatter, "expected one of: {:?}", &FIELDS)
10286 }
10287
10288 #[allow(unused_variables)]
10289 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10290 where
10291 E: serde::de::Error,
10292 {
10293 match value {
10294 "actors" => Ok(GeneratedField::Actors),
10295 "droppedSinkFragments" | "dropped_sink_fragments" => Ok(GeneratedField::DroppedSinkFragments),
10296 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10297 }
10298 }
10299 }
10300 deserializer.deserialize_identifier(GeneratedVisitor)
10301 }
10302 }
10303 struct GeneratedVisitor;
10304 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10305 type Value = StopMutation;
10306
10307 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10308 formatter.write_str("struct stream_plan.StopMutation")
10309 }
10310
10311 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopMutation, V::Error>
10312 where
10313 V: serde::de::MapAccess<'de>,
10314 {
10315 let mut actors__ = None;
10316 let mut dropped_sink_fragments__ = None;
10317 while let Some(k) = map_.next_key()? {
10318 match k {
10319 GeneratedField::Actors => {
10320 if actors__.is_some() {
10321 return Err(serde::de::Error::duplicate_field("actors"));
10322 }
10323 actors__ =
10324 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10325 .into_iter().map(|x| x.0).collect())
10326 ;
10327 }
10328 GeneratedField::DroppedSinkFragments => {
10329 if dropped_sink_fragments__.is_some() {
10330 return Err(serde::de::Error::duplicate_field("droppedSinkFragments"));
10331 }
10332 dropped_sink_fragments__ =
10333 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10334 .into_iter().map(|x| x.0).collect())
10335 ;
10336 }
10337 }
10338 }
10339 Ok(StopMutation {
10340 actors: actors__.unwrap_or_default(),
10341 dropped_sink_fragments: dropped_sink_fragments__.unwrap_or_default(),
10342 })
10343 }
10344 }
10345 deserializer.deserialize_struct("stream_plan.StopMutation", FIELDS, GeneratedVisitor)
10346 }
10347}
10348impl serde::Serialize for StreamActor {
10349 #[allow(deprecated)]
10350 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10351 where
10352 S: serde::Serializer,
10353 {
10354 use serde::ser::SerializeStruct;
10355 let mut len = 0;
10356 if self.actor_id != 0 {
10357 len += 1;
10358 }
10359 if self.fragment_id != 0 {
10360 len += 1;
10361 }
10362 if !self.dispatcher.is_empty() {
10363 len += 1;
10364 }
10365 if self.vnode_bitmap.is_some() {
10366 len += 1;
10367 }
10368 if !self.mview_definition.is_empty() {
10369 len += 1;
10370 }
10371 if self.expr_context.is_some() {
10372 len += 1;
10373 }
10374 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamActor", len)?;
10375 if self.actor_id != 0 {
10376 struct_ser.serialize_field("actorId", &self.actor_id)?;
10377 }
10378 if self.fragment_id != 0 {
10379 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
10380 }
10381 if !self.dispatcher.is_empty() {
10382 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
10383 }
10384 if let Some(v) = self.vnode_bitmap.as_ref() {
10385 struct_ser.serialize_field("vnodeBitmap", v)?;
10386 }
10387 if !self.mview_definition.is_empty() {
10388 struct_ser.serialize_field("mviewDefinition", &self.mview_definition)?;
10389 }
10390 if let Some(v) = self.expr_context.as_ref() {
10391 struct_ser.serialize_field("exprContext", v)?;
10392 }
10393 struct_ser.end()
10394 }
10395}
10396impl<'de> serde::Deserialize<'de> for StreamActor {
10397 #[allow(deprecated)]
10398 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10399 where
10400 D: serde::Deserializer<'de>,
10401 {
10402 const FIELDS: &[&str] = &[
10403 "actor_id",
10404 "actorId",
10405 "fragment_id",
10406 "fragmentId",
10407 "dispatcher",
10408 "vnode_bitmap",
10409 "vnodeBitmap",
10410 "mview_definition",
10411 "mviewDefinition",
10412 "expr_context",
10413 "exprContext",
10414 ];
10415
10416 #[allow(clippy::enum_variant_names)]
10417 enum GeneratedField {
10418 ActorId,
10419 FragmentId,
10420 Dispatcher,
10421 VnodeBitmap,
10422 MviewDefinition,
10423 ExprContext,
10424 }
10425 impl<'de> serde::Deserialize<'de> for GeneratedField {
10426 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10427 where
10428 D: serde::Deserializer<'de>,
10429 {
10430 struct GeneratedVisitor;
10431
10432 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10433 type Value = GeneratedField;
10434
10435 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10436 write!(formatter, "expected one of: {:?}", &FIELDS)
10437 }
10438
10439 #[allow(unused_variables)]
10440 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10441 where
10442 E: serde::de::Error,
10443 {
10444 match value {
10445 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
10446 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
10447 "dispatcher" => Ok(GeneratedField::Dispatcher),
10448 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
10449 "mviewDefinition" | "mview_definition" => Ok(GeneratedField::MviewDefinition),
10450 "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
10451 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10452 }
10453 }
10454 }
10455 deserializer.deserialize_identifier(GeneratedVisitor)
10456 }
10457 }
10458 struct GeneratedVisitor;
10459 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10460 type Value = StreamActor;
10461
10462 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10463 formatter.write_str("struct stream_plan.StreamActor")
10464 }
10465
10466 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamActor, V::Error>
10467 where
10468 V: serde::de::MapAccess<'de>,
10469 {
10470 let mut actor_id__ = None;
10471 let mut fragment_id__ = None;
10472 let mut dispatcher__ = None;
10473 let mut vnode_bitmap__ = None;
10474 let mut mview_definition__ = None;
10475 let mut expr_context__ = None;
10476 while let Some(k) = map_.next_key()? {
10477 match k {
10478 GeneratedField::ActorId => {
10479 if actor_id__.is_some() {
10480 return Err(serde::de::Error::duplicate_field("actorId"));
10481 }
10482 actor_id__ =
10483 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10484 ;
10485 }
10486 GeneratedField::FragmentId => {
10487 if fragment_id__.is_some() {
10488 return Err(serde::de::Error::duplicate_field("fragmentId"));
10489 }
10490 fragment_id__ =
10491 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10492 ;
10493 }
10494 GeneratedField::Dispatcher => {
10495 if dispatcher__.is_some() {
10496 return Err(serde::de::Error::duplicate_field("dispatcher"));
10497 }
10498 dispatcher__ = Some(map_.next_value()?);
10499 }
10500 GeneratedField::VnodeBitmap => {
10501 if vnode_bitmap__.is_some() {
10502 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
10503 }
10504 vnode_bitmap__ = map_.next_value()?;
10505 }
10506 GeneratedField::MviewDefinition => {
10507 if mview_definition__.is_some() {
10508 return Err(serde::de::Error::duplicate_field("mviewDefinition"));
10509 }
10510 mview_definition__ = Some(map_.next_value()?);
10511 }
10512 GeneratedField::ExprContext => {
10513 if expr_context__.is_some() {
10514 return Err(serde::de::Error::duplicate_field("exprContext"));
10515 }
10516 expr_context__ = map_.next_value()?;
10517 }
10518 }
10519 }
10520 Ok(StreamActor {
10521 actor_id: actor_id__.unwrap_or_default(),
10522 fragment_id: fragment_id__.unwrap_or_default(),
10523 dispatcher: dispatcher__.unwrap_or_default(),
10524 vnode_bitmap: vnode_bitmap__,
10525 mview_definition: mview_definition__.unwrap_or_default(),
10526 expr_context: expr_context__,
10527 })
10528 }
10529 }
10530 deserializer.deserialize_struct("stream_plan.StreamActor", FIELDS, GeneratedVisitor)
10531 }
10532}
10533impl serde::Serialize for StreamCdcScanNode {
10534 #[allow(deprecated)]
10535 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10536 where
10537 S: serde::Serializer,
10538 {
10539 use serde::ser::SerializeStruct;
10540 let mut len = 0;
10541 if self.table_id != 0 {
10542 len += 1;
10543 }
10544 if !self.upstream_column_ids.is_empty() {
10545 len += 1;
10546 }
10547 if !self.output_indices.is_empty() {
10548 len += 1;
10549 }
10550 if self.state_table.is_some() {
10551 len += 1;
10552 }
10553 if self.cdc_table_desc.is_some() {
10554 len += 1;
10555 }
10556 if self.rate_limit.is_some() {
10557 len += 1;
10558 }
10559 if self.disable_backfill {
10560 len += 1;
10561 }
10562 if self.options.is_some() {
10563 len += 1;
10564 }
10565 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanNode", len)?;
10566 if self.table_id != 0 {
10567 struct_ser.serialize_field("tableId", &self.table_id)?;
10568 }
10569 if !self.upstream_column_ids.is_empty() {
10570 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
10571 }
10572 if !self.output_indices.is_empty() {
10573 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
10574 }
10575 if let Some(v) = self.state_table.as_ref() {
10576 struct_ser.serialize_field("stateTable", v)?;
10577 }
10578 if let Some(v) = self.cdc_table_desc.as_ref() {
10579 struct_ser.serialize_field("cdcTableDesc", v)?;
10580 }
10581 if let Some(v) = self.rate_limit.as_ref() {
10582 struct_ser.serialize_field("rateLimit", v)?;
10583 }
10584 if self.disable_backfill {
10585 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
10586 }
10587 if let Some(v) = self.options.as_ref() {
10588 struct_ser.serialize_field("options", v)?;
10589 }
10590 struct_ser.end()
10591 }
10592}
10593impl<'de> serde::Deserialize<'de> for StreamCdcScanNode {
10594 #[allow(deprecated)]
10595 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10596 where
10597 D: serde::Deserializer<'de>,
10598 {
10599 const FIELDS: &[&str] = &[
10600 "table_id",
10601 "tableId",
10602 "upstream_column_ids",
10603 "upstreamColumnIds",
10604 "output_indices",
10605 "outputIndices",
10606 "state_table",
10607 "stateTable",
10608 "cdc_table_desc",
10609 "cdcTableDesc",
10610 "rate_limit",
10611 "rateLimit",
10612 "disable_backfill",
10613 "disableBackfill",
10614 "options",
10615 ];
10616
10617 #[allow(clippy::enum_variant_names)]
10618 enum GeneratedField {
10619 TableId,
10620 UpstreamColumnIds,
10621 OutputIndices,
10622 StateTable,
10623 CdcTableDesc,
10624 RateLimit,
10625 DisableBackfill,
10626 Options,
10627 }
10628 impl<'de> serde::Deserialize<'de> for GeneratedField {
10629 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10630 where
10631 D: serde::Deserializer<'de>,
10632 {
10633 struct GeneratedVisitor;
10634
10635 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10636 type Value = GeneratedField;
10637
10638 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10639 write!(formatter, "expected one of: {:?}", &FIELDS)
10640 }
10641
10642 #[allow(unused_variables)]
10643 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10644 where
10645 E: serde::de::Error,
10646 {
10647 match value {
10648 "tableId" | "table_id" => Ok(GeneratedField::TableId),
10649 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
10650 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
10651 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
10652 "cdcTableDesc" | "cdc_table_desc" => Ok(GeneratedField::CdcTableDesc),
10653 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
10654 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
10655 "options" => Ok(GeneratedField::Options),
10656 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10657 }
10658 }
10659 }
10660 deserializer.deserialize_identifier(GeneratedVisitor)
10661 }
10662 }
10663 struct GeneratedVisitor;
10664 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10665 type Value = StreamCdcScanNode;
10666
10667 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10668 formatter.write_str("struct stream_plan.StreamCdcScanNode")
10669 }
10670
10671 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanNode, V::Error>
10672 where
10673 V: serde::de::MapAccess<'de>,
10674 {
10675 let mut table_id__ = None;
10676 let mut upstream_column_ids__ = None;
10677 let mut output_indices__ = None;
10678 let mut state_table__ = None;
10679 let mut cdc_table_desc__ = None;
10680 let mut rate_limit__ = None;
10681 let mut disable_backfill__ = None;
10682 let mut options__ = None;
10683 while let Some(k) = map_.next_key()? {
10684 match k {
10685 GeneratedField::TableId => {
10686 if table_id__.is_some() {
10687 return Err(serde::de::Error::duplicate_field("tableId"));
10688 }
10689 table_id__ =
10690 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10691 ;
10692 }
10693 GeneratedField::UpstreamColumnIds => {
10694 if upstream_column_ids__.is_some() {
10695 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
10696 }
10697 upstream_column_ids__ =
10698 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10699 .into_iter().map(|x| x.0).collect())
10700 ;
10701 }
10702 GeneratedField::OutputIndices => {
10703 if output_indices__.is_some() {
10704 return Err(serde::de::Error::duplicate_field("outputIndices"));
10705 }
10706 output_indices__ =
10707 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10708 .into_iter().map(|x| x.0).collect())
10709 ;
10710 }
10711 GeneratedField::StateTable => {
10712 if state_table__.is_some() {
10713 return Err(serde::de::Error::duplicate_field("stateTable"));
10714 }
10715 state_table__ = map_.next_value()?;
10716 }
10717 GeneratedField::CdcTableDesc => {
10718 if cdc_table_desc__.is_some() {
10719 return Err(serde::de::Error::duplicate_field("cdcTableDesc"));
10720 }
10721 cdc_table_desc__ = map_.next_value()?;
10722 }
10723 GeneratedField::RateLimit => {
10724 if rate_limit__.is_some() {
10725 return Err(serde::de::Error::duplicate_field("rateLimit"));
10726 }
10727 rate_limit__ =
10728 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10729 ;
10730 }
10731 GeneratedField::DisableBackfill => {
10732 if disable_backfill__.is_some() {
10733 return Err(serde::de::Error::duplicate_field("disableBackfill"));
10734 }
10735 disable_backfill__ = Some(map_.next_value()?);
10736 }
10737 GeneratedField::Options => {
10738 if options__.is_some() {
10739 return Err(serde::de::Error::duplicate_field("options"));
10740 }
10741 options__ = map_.next_value()?;
10742 }
10743 }
10744 }
10745 Ok(StreamCdcScanNode {
10746 table_id: table_id__.unwrap_or_default(),
10747 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
10748 output_indices: output_indices__.unwrap_or_default(),
10749 state_table: state_table__,
10750 cdc_table_desc: cdc_table_desc__,
10751 rate_limit: rate_limit__,
10752 disable_backfill: disable_backfill__.unwrap_or_default(),
10753 options: options__,
10754 })
10755 }
10756 }
10757 deserializer.deserialize_struct("stream_plan.StreamCdcScanNode", FIELDS, GeneratedVisitor)
10758 }
10759}
10760impl serde::Serialize for StreamCdcScanOptions {
10761 #[allow(deprecated)]
10762 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10763 where
10764 S: serde::Serializer,
10765 {
10766 use serde::ser::SerializeStruct;
10767 let mut len = 0;
10768 if self.disable_backfill {
10769 len += 1;
10770 }
10771 if self.snapshot_barrier_interval != 0 {
10772 len += 1;
10773 }
10774 if self.snapshot_batch_size != 0 {
10775 len += 1;
10776 }
10777 if self.backfill_parallelism != 0 {
10778 len += 1;
10779 }
10780 if self.backfill_num_rows_per_split != 0 {
10781 len += 1;
10782 }
10783 if self.backfill_as_even_splits {
10784 len += 1;
10785 }
10786 if self.backfill_split_pk_column_index != 0 {
10787 len += 1;
10788 }
10789 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanOptions", len)?;
10790 if self.disable_backfill {
10791 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
10792 }
10793 if self.snapshot_barrier_interval != 0 {
10794 struct_ser.serialize_field("snapshotBarrierInterval", &self.snapshot_barrier_interval)?;
10795 }
10796 if self.snapshot_batch_size != 0 {
10797 struct_ser.serialize_field("snapshotBatchSize", &self.snapshot_batch_size)?;
10798 }
10799 if self.backfill_parallelism != 0 {
10800 struct_ser.serialize_field("backfillParallelism", &self.backfill_parallelism)?;
10801 }
10802 if self.backfill_num_rows_per_split != 0 {
10803 #[allow(clippy::needless_borrow)]
10804 #[allow(clippy::needless_borrows_for_generic_args)]
10805 struct_ser.serialize_field("backfillNumRowsPerSplit", ToString::to_string(&self.backfill_num_rows_per_split).as_str())?;
10806 }
10807 if self.backfill_as_even_splits {
10808 struct_ser.serialize_field("backfillAsEvenSplits", &self.backfill_as_even_splits)?;
10809 }
10810 if self.backfill_split_pk_column_index != 0 {
10811 struct_ser.serialize_field("backfillSplitPkColumnIndex", &self.backfill_split_pk_column_index)?;
10812 }
10813 struct_ser.end()
10814 }
10815}
10816impl<'de> serde::Deserialize<'de> for StreamCdcScanOptions {
10817 #[allow(deprecated)]
10818 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10819 where
10820 D: serde::Deserializer<'de>,
10821 {
10822 const FIELDS: &[&str] = &[
10823 "disable_backfill",
10824 "disableBackfill",
10825 "snapshot_barrier_interval",
10826 "snapshotBarrierInterval",
10827 "snapshot_batch_size",
10828 "snapshotBatchSize",
10829 "backfill_parallelism",
10830 "backfillParallelism",
10831 "backfill_num_rows_per_split",
10832 "backfillNumRowsPerSplit",
10833 "backfill_as_even_splits",
10834 "backfillAsEvenSplits",
10835 "backfill_split_pk_column_index",
10836 "backfillSplitPkColumnIndex",
10837 ];
10838
10839 #[allow(clippy::enum_variant_names)]
10840 enum GeneratedField {
10841 DisableBackfill,
10842 SnapshotBarrierInterval,
10843 SnapshotBatchSize,
10844 BackfillParallelism,
10845 BackfillNumRowsPerSplit,
10846 BackfillAsEvenSplits,
10847 BackfillSplitPkColumnIndex,
10848 }
10849 impl<'de> serde::Deserialize<'de> for GeneratedField {
10850 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10851 where
10852 D: serde::Deserializer<'de>,
10853 {
10854 struct GeneratedVisitor;
10855
10856 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10857 type Value = GeneratedField;
10858
10859 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10860 write!(formatter, "expected one of: {:?}", &FIELDS)
10861 }
10862
10863 #[allow(unused_variables)]
10864 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10865 where
10866 E: serde::de::Error,
10867 {
10868 match value {
10869 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
10870 "snapshotBarrierInterval" | "snapshot_barrier_interval" => Ok(GeneratedField::SnapshotBarrierInterval),
10871 "snapshotBatchSize" | "snapshot_batch_size" => Ok(GeneratedField::SnapshotBatchSize),
10872 "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
10873 "backfillNumRowsPerSplit" | "backfill_num_rows_per_split" => Ok(GeneratedField::BackfillNumRowsPerSplit),
10874 "backfillAsEvenSplits" | "backfill_as_even_splits" => Ok(GeneratedField::BackfillAsEvenSplits),
10875 "backfillSplitPkColumnIndex" | "backfill_split_pk_column_index" => Ok(GeneratedField::BackfillSplitPkColumnIndex),
10876 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10877 }
10878 }
10879 }
10880 deserializer.deserialize_identifier(GeneratedVisitor)
10881 }
10882 }
10883 struct GeneratedVisitor;
10884 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10885 type Value = StreamCdcScanOptions;
10886
10887 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10888 formatter.write_str("struct stream_plan.StreamCdcScanOptions")
10889 }
10890
10891 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanOptions, V::Error>
10892 where
10893 V: serde::de::MapAccess<'de>,
10894 {
10895 let mut disable_backfill__ = None;
10896 let mut snapshot_barrier_interval__ = None;
10897 let mut snapshot_batch_size__ = None;
10898 let mut backfill_parallelism__ = None;
10899 let mut backfill_num_rows_per_split__ = None;
10900 let mut backfill_as_even_splits__ = None;
10901 let mut backfill_split_pk_column_index__ = None;
10902 while let Some(k) = map_.next_key()? {
10903 match k {
10904 GeneratedField::DisableBackfill => {
10905 if disable_backfill__.is_some() {
10906 return Err(serde::de::Error::duplicate_field("disableBackfill"));
10907 }
10908 disable_backfill__ = Some(map_.next_value()?);
10909 }
10910 GeneratedField::SnapshotBarrierInterval => {
10911 if snapshot_barrier_interval__.is_some() {
10912 return Err(serde::de::Error::duplicate_field("snapshotBarrierInterval"));
10913 }
10914 snapshot_barrier_interval__ =
10915 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10916 ;
10917 }
10918 GeneratedField::SnapshotBatchSize => {
10919 if snapshot_batch_size__.is_some() {
10920 return Err(serde::de::Error::duplicate_field("snapshotBatchSize"));
10921 }
10922 snapshot_batch_size__ =
10923 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10924 ;
10925 }
10926 GeneratedField::BackfillParallelism => {
10927 if backfill_parallelism__.is_some() {
10928 return Err(serde::de::Error::duplicate_field("backfillParallelism"));
10929 }
10930 backfill_parallelism__ =
10931 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10932 ;
10933 }
10934 GeneratedField::BackfillNumRowsPerSplit => {
10935 if backfill_num_rows_per_split__.is_some() {
10936 return Err(serde::de::Error::duplicate_field("backfillNumRowsPerSplit"));
10937 }
10938 backfill_num_rows_per_split__ =
10939 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10940 ;
10941 }
10942 GeneratedField::BackfillAsEvenSplits => {
10943 if backfill_as_even_splits__.is_some() {
10944 return Err(serde::de::Error::duplicate_field("backfillAsEvenSplits"));
10945 }
10946 backfill_as_even_splits__ = Some(map_.next_value()?);
10947 }
10948 GeneratedField::BackfillSplitPkColumnIndex => {
10949 if backfill_split_pk_column_index__.is_some() {
10950 return Err(serde::de::Error::duplicate_field("backfillSplitPkColumnIndex"));
10951 }
10952 backfill_split_pk_column_index__ =
10953 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10954 ;
10955 }
10956 }
10957 }
10958 Ok(StreamCdcScanOptions {
10959 disable_backfill: disable_backfill__.unwrap_or_default(),
10960 snapshot_barrier_interval: snapshot_barrier_interval__.unwrap_or_default(),
10961 snapshot_batch_size: snapshot_batch_size__.unwrap_or_default(),
10962 backfill_parallelism: backfill_parallelism__.unwrap_or_default(),
10963 backfill_num_rows_per_split: backfill_num_rows_per_split__.unwrap_or_default(),
10964 backfill_as_even_splits: backfill_as_even_splits__.unwrap_or_default(),
10965 backfill_split_pk_column_index: backfill_split_pk_column_index__.unwrap_or_default(),
10966 })
10967 }
10968 }
10969 deserializer.deserialize_struct("stream_plan.StreamCdcScanOptions", FIELDS, GeneratedVisitor)
10970 }
10971}
10972impl serde::Serialize for StreamContext {
10973 #[allow(deprecated)]
10974 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10975 where
10976 S: serde::Serializer,
10977 {
10978 use serde::ser::SerializeStruct;
10979 let mut len = 0;
10980 if !self.timezone.is_empty() {
10981 len += 1;
10982 }
10983 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamContext", len)?;
10984 if !self.timezone.is_empty() {
10985 struct_ser.serialize_field("timezone", &self.timezone)?;
10986 }
10987 struct_ser.end()
10988 }
10989}
10990impl<'de> serde::Deserialize<'de> for StreamContext {
10991 #[allow(deprecated)]
10992 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10993 where
10994 D: serde::Deserializer<'de>,
10995 {
10996 const FIELDS: &[&str] = &[
10997 "timezone",
10998 ];
10999
11000 #[allow(clippy::enum_variant_names)]
11001 enum GeneratedField {
11002 Timezone,
11003 }
11004 impl<'de> serde::Deserialize<'de> for GeneratedField {
11005 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11006 where
11007 D: serde::Deserializer<'de>,
11008 {
11009 struct GeneratedVisitor;
11010
11011 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11012 type Value = GeneratedField;
11013
11014 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11015 write!(formatter, "expected one of: {:?}", &FIELDS)
11016 }
11017
11018 #[allow(unused_variables)]
11019 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11020 where
11021 E: serde::de::Error,
11022 {
11023 match value {
11024 "timezone" => Ok(GeneratedField::Timezone),
11025 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11026 }
11027 }
11028 }
11029 deserializer.deserialize_identifier(GeneratedVisitor)
11030 }
11031 }
11032 struct GeneratedVisitor;
11033 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11034 type Value = StreamContext;
11035
11036 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11037 formatter.write_str("struct stream_plan.StreamContext")
11038 }
11039
11040 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamContext, V::Error>
11041 where
11042 V: serde::de::MapAccess<'de>,
11043 {
11044 let mut timezone__ = None;
11045 while let Some(k) = map_.next_key()? {
11046 match k {
11047 GeneratedField::Timezone => {
11048 if timezone__.is_some() {
11049 return Err(serde::de::Error::duplicate_field("timezone"));
11050 }
11051 timezone__ = Some(map_.next_value()?);
11052 }
11053 }
11054 }
11055 Ok(StreamContext {
11056 timezone: timezone__.unwrap_or_default(),
11057 })
11058 }
11059 }
11060 deserializer.deserialize_struct("stream_plan.StreamContext", FIELDS, GeneratedVisitor)
11061 }
11062}
11063impl serde::Serialize for StreamFragmentGraph {
11064 #[allow(deprecated)]
11065 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11066 where
11067 S: serde::Serializer,
11068 {
11069 use serde::ser::SerializeStruct;
11070 let mut len = 0;
11071 if !self.fragments.is_empty() {
11072 len += 1;
11073 }
11074 if !self.edges.is_empty() {
11075 len += 1;
11076 }
11077 if !self.dependent_table_ids.is_empty() {
11078 len += 1;
11079 }
11080 if self.table_ids_cnt != 0 {
11081 len += 1;
11082 }
11083 if self.ctx.is_some() {
11084 len += 1;
11085 }
11086 if self.parallelism.is_some() {
11087 len += 1;
11088 }
11089 if self.max_parallelism != 0 {
11090 len += 1;
11091 }
11092 if self.backfill_order.is_some() {
11093 len += 1;
11094 }
11095 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph", len)?;
11096 if !self.fragments.is_empty() {
11097 struct_ser.serialize_field("fragments", &self.fragments)?;
11098 }
11099 if !self.edges.is_empty() {
11100 struct_ser.serialize_field("edges", &self.edges)?;
11101 }
11102 if !self.dependent_table_ids.is_empty() {
11103 struct_ser.serialize_field("dependentTableIds", &self.dependent_table_ids)?;
11104 }
11105 if self.table_ids_cnt != 0 {
11106 struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
11107 }
11108 if let Some(v) = self.ctx.as_ref() {
11109 struct_ser.serialize_field("ctx", v)?;
11110 }
11111 if let Some(v) = self.parallelism.as_ref() {
11112 struct_ser.serialize_field("parallelism", v)?;
11113 }
11114 if self.max_parallelism != 0 {
11115 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
11116 }
11117 if let Some(v) = self.backfill_order.as_ref() {
11118 struct_ser.serialize_field("backfillOrder", v)?;
11119 }
11120 struct_ser.end()
11121 }
11122}
11123impl<'de> serde::Deserialize<'de> for StreamFragmentGraph {
11124 #[allow(deprecated)]
11125 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11126 where
11127 D: serde::Deserializer<'de>,
11128 {
11129 const FIELDS: &[&str] = &[
11130 "fragments",
11131 "edges",
11132 "dependent_table_ids",
11133 "dependentTableIds",
11134 "table_ids_cnt",
11135 "tableIdsCnt",
11136 "ctx",
11137 "parallelism",
11138 "max_parallelism",
11139 "maxParallelism",
11140 "backfill_order",
11141 "backfillOrder",
11142 ];
11143
11144 #[allow(clippy::enum_variant_names)]
11145 enum GeneratedField {
11146 Fragments,
11147 Edges,
11148 DependentTableIds,
11149 TableIdsCnt,
11150 Ctx,
11151 Parallelism,
11152 MaxParallelism,
11153 BackfillOrder,
11154 }
11155 impl<'de> serde::Deserialize<'de> for GeneratedField {
11156 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11157 where
11158 D: serde::Deserializer<'de>,
11159 {
11160 struct GeneratedVisitor;
11161
11162 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11163 type Value = GeneratedField;
11164
11165 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11166 write!(formatter, "expected one of: {:?}", &FIELDS)
11167 }
11168
11169 #[allow(unused_variables)]
11170 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11171 where
11172 E: serde::de::Error,
11173 {
11174 match value {
11175 "fragments" => Ok(GeneratedField::Fragments),
11176 "edges" => Ok(GeneratedField::Edges),
11177 "dependentTableIds" | "dependent_table_ids" => Ok(GeneratedField::DependentTableIds),
11178 "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
11179 "ctx" => Ok(GeneratedField::Ctx),
11180 "parallelism" => Ok(GeneratedField::Parallelism),
11181 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
11182 "backfillOrder" | "backfill_order" => Ok(GeneratedField::BackfillOrder),
11183 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11184 }
11185 }
11186 }
11187 deserializer.deserialize_identifier(GeneratedVisitor)
11188 }
11189 }
11190 struct GeneratedVisitor;
11191 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11192 type Value = StreamFragmentGraph;
11193
11194 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11195 formatter.write_str("struct stream_plan.StreamFragmentGraph")
11196 }
11197
11198 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFragmentGraph, V::Error>
11199 where
11200 V: serde::de::MapAccess<'de>,
11201 {
11202 let mut fragments__ = None;
11203 let mut edges__ = None;
11204 let mut dependent_table_ids__ = None;
11205 let mut table_ids_cnt__ = None;
11206 let mut ctx__ = None;
11207 let mut parallelism__ = None;
11208 let mut max_parallelism__ = None;
11209 let mut backfill_order__ = None;
11210 while let Some(k) = map_.next_key()? {
11211 match k {
11212 GeneratedField::Fragments => {
11213 if fragments__.is_some() {
11214 return Err(serde::de::Error::duplicate_field("fragments"));
11215 }
11216 fragments__ = Some(
11217 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11218 .into_iter().map(|(k,v)| (k.0, v)).collect()
11219 );
11220 }
11221 GeneratedField::Edges => {
11222 if edges__.is_some() {
11223 return Err(serde::de::Error::duplicate_field("edges"));
11224 }
11225 edges__ = Some(map_.next_value()?);
11226 }
11227 GeneratedField::DependentTableIds => {
11228 if dependent_table_ids__.is_some() {
11229 return Err(serde::de::Error::duplicate_field("dependentTableIds"));
11230 }
11231 dependent_table_ids__ =
11232 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11233 .into_iter().map(|x| x.0).collect())
11234 ;
11235 }
11236 GeneratedField::TableIdsCnt => {
11237 if table_ids_cnt__.is_some() {
11238 return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
11239 }
11240 table_ids_cnt__ =
11241 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11242 ;
11243 }
11244 GeneratedField::Ctx => {
11245 if ctx__.is_some() {
11246 return Err(serde::de::Error::duplicate_field("ctx"));
11247 }
11248 ctx__ = map_.next_value()?;
11249 }
11250 GeneratedField::Parallelism => {
11251 if parallelism__.is_some() {
11252 return Err(serde::de::Error::duplicate_field("parallelism"));
11253 }
11254 parallelism__ = map_.next_value()?;
11255 }
11256 GeneratedField::MaxParallelism => {
11257 if max_parallelism__.is_some() {
11258 return Err(serde::de::Error::duplicate_field("maxParallelism"));
11259 }
11260 max_parallelism__ =
11261 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11262 ;
11263 }
11264 GeneratedField::BackfillOrder => {
11265 if backfill_order__.is_some() {
11266 return Err(serde::de::Error::duplicate_field("backfillOrder"));
11267 }
11268 backfill_order__ = map_.next_value()?;
11269 }
11270 }
11271 }
11272 Ok(StreamFragmentGraph {
11273 fragments: fragments__.unwrap_or_default(),
11274 edges: edges__.unwrap_or_default(),
11275 dependent_table_ids: dependent_table_ids__.unwrap_or_default(),
11276 table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
11277 ctx: ctx__,
11278 parallelism: parallelism__,
11279 max_parallelism: max_parallelism__.unwrap_or_default(),
11280 backfill_order: backfill_order__,
11281 })
11282 }
11283 }
11284 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph", FIELDS, GeneratedVisitor)
11285 }
11286}
11287impl serde::Serialize for stream_fragment_graph::Parallelism {
11288 #[allow(deprecated)]
11289 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11290 where
11291 S: serde::Serializer,
11292 {
11293 use serde::ser::SerializeStruct;
11294 let mut len = 0;
11295 if self.parallelism != 0 {
11296 len += 1;
11297 }
11298 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.Parallelism", len)?;
11299 if self.parallelism != 0 {
11300 #[allow(clippy::needless_borrow)]
11301 #[allow(clippy::needless_borrows_for_generic_args)]
11302 struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
11303 }
11304 struct_ser.end()
11305 }
11306}
11307impl<'de> serde::Deserialize<'de> for stream_fragment_graph::Parallelism {
11308 #[allow(deprecated)]
11309 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11310 where
11311 D: serde::Deserializer<'de>,
11312 {
11313 const FIELDS: &[&str] = &[
11314 "parallelism",
11315 ];
11316
11317 #[allow(clippy::enum_variant_names)]
11318 enum GeneratedField {
11319 Parallelism,
11320 }
11321 impl<'de> serde::Deserialize<'de> for GeneratedField {
11322 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11323 where
11324 D: serde::Deserializer<'de>,
11325 {
11326 struct GeneratedVisitor;
11327
11328 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11329 type Value = GeneratedField;
11330
11331 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11332 write!(formatter, "expected one of: {:?}", &FIELDS)
11333 }
11334
11335 #[allow(unused_variables)]
11336 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11337 where
11338 E: serde::de::Error,
11339 {
11340 match value {
11341 "parallelism" => Ok(GeneratedField::Parallelism),
11342 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11343 }
11344 }
11345 }
11346 deserializer.deserialize_identifier(GeneratedVisitor)
11347 }
11348 }
11349 struct GeneratedVisitor;
11350 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11351 type Value = stream_fragment_graph::Parallelism;
11352
11353 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11354 formatter.write_str("struct stream_plan.StreamFragmentGraph.Parallelism")
11355 }
11356
11357 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::Parallelism, V::Error>
11358 where
11359 V: serde::de::MapAccess<'de>,
11360 {
11361 let mut parallelism__ = None;
11362 while let Some(k) = map_.next_key()? {
11363 match k {
11364 GeneratedField::Parallelism => {
11365 if parallelism__.is_some() {
11366 return Err(serde::de::Error::duplicate_field("parallelism"));
11367 }
11368 parallelism__ =
11369 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11370 ;
11371 }
11372 }
11373 }
11374 Ok(stream_fragment_graph::Parallelism {
11375 parallelism: parallelism__.unwrap_or_default(),
11376 })
11377 }
11378 }
11379 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.Parallelism", FIELDS, GeneratedVisitor)
11380 }
11381}
11382impl serde::Serialize for stream_fragment_graph::StreamFragment {
11383 #[allow(deprecated)]
11384 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11385 where
11386 S: serde::Serializer,
11387 {
11388 use serde::ser::SerializeStruct;
11389 let mut len = 0;
11390 if self.fragment_id != 0 {
11391 len += 1;
11392 }
11393 if self.node.is_some() {
11394 len += 1;
11395 }
11396 if self.fragment_type_mask != 0 {
11397 len += 1;
11398 }
11399 if self.requires_singleton {
11400 len += 1;
11401 }
11402 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", len)?;
11403 if self.fragment_id != 0 {
11404 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
11405 }
11406 if let Some(v) = self.node.as_ref() {
11407 struct_ser.serialize_field("node", v)?;
11408 }
11409 if self.fragment_type_mask != 0 {
11410 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
11411 }
11412 if self.requires_singleton {
11413 struct_ser.serialize_field("requiresSingleton", &self.requires_singleton)?;
11414 }
11415 struct_ser.end()
11416 }
11417}
11418impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragment {
11419 #[allow(deprecated)]
11420 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11421 where
11422 D: serde::Deserializer<'de>,
11423 {
11424 const FIELDS: &[&str] = &[
11425 "fragment_id",
11426 "fragmentId",
11427 "node",
11428 "fragment_type_mask",
11429 "fragmentTypeMask",
11430 "requires_singleton",
11431 "requiresSingleton",
11432 ];
11433
11434 #[allow(clippy::enum_variant_names)]
11435 enum GeneratedField {
11436 FragmentId,
11437 Node,
11438 FragmentTypeMask,
11439 RequiresSingleton,
11440 }
11441 impl<'de> serde::Deserialize<'de> for GeneratedField {
11442 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11443 where
11444 D: serde::Deserializer<'de>,
11445 {
11446 struct GeneratedVisitor;
11447
11448 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11449 type Value = GeneratedField;
11450
11451 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11452 write!(formatter, "expected one of: {:?}", &FIELDS)
11453 }
11454
11455 #[allow(unused_variables)]
11456 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11457 where
11458 E: serde::de::Error,
11459 {
11460 match value {
11461 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
11462 "node" => Ok(GeneratedField::Node),
11463 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
11464 "requiresSingleton" | "requires_singleton" => Ok(GeneratedField::RequiresSingleton),
11465 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11466 }
11467 }
11468 }
11469 deserializer.deserialize_identifier(GeneratedVisitor)
11470 }
11471 }
11472 struct GeneratedVisitor;
11473 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11474 type Value = stream_fragment_graph::StreamFragment;
11475
11476 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11477 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragment")
11478 }
11479
11480 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragment, V::Error>
11481 where
11482 V: serde::de::MapAccess<'de>,
11483 {
11484 let mut fragment_id__ = None;
11485 let mut node__ = None;
11486 let mut fragment_type_mask__ = None;
11487 let mut requires_singleton__ = None;
11488 while let Some(k) = map_.next_key()? {
11489 match k {
11490 GeneratedField::FragmentId => {
11491 if fragment_id__.is_some() {
11492 return Err(serde::de::Error::duplicate_field("fragmentId"));
11493 }
11494 fragment_id__ =
11495 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11496 ;
11497 }
11498 GeneratedField::Node => {
11499 if node__.is_some() {
11500 return Err(serde::de::Error::duplicate_field("node"));
11501 }
11502 node__ = map_.next_value()?;
11503 }
11504 GeneratedField::FragmentTypeMask => {
11505 if fragment_type_mask__.is_some() {
11506 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
11507 }
11508 fragment_type_mask__ =
11509 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11510 ;
11511 }
11512 GeneratedField::RequiresSingleton => {
11513 if requires_singleton__.is_some() {
11514 return Err(serde::de::Error::duplicate_field("requiresSingleton"));
11515 }
11516 requires_singleton__ = Some(map_.next_value()?);
11517 }
11518 }
11519 }
11520 Ok(stream_fragment_graph::StreamFragment {
11521 fragment_id: fragment_id__.unwrap_or_default(),
11522 node: node__,
11523 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
11524 requires_singleton: requires_singleton__.unwrap_or_default(),
11525 })
11526 }
11527 }
11528 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", FIELDS, GeneratedVisitor)
11529 }
11530}
11531impl serde::Serialize for stream_fragment_graph::StreamFragmentEdge {
11532 #[allow(deprecated)]
11533 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11534 where
11535 S: serde::Serializer,
11536 {
11537 use serde::ser::SerializeStruct;
11538 let mut len = 0;
11539 if self.dispatch_strategy.is_some() {
11540 len += 1;
11541 }
11542 if self.link_id != 0 {
11543 len += 1;
11544 }
11545 if self.upstream_id != 0 {
11546 len += 1;
11547 }
11548 if self.downstream_id != 0 {
11549 len += 1;
11550 }
11551 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", len)?;
11552 if let Some(v) = self.dispatch_strategy.as_ref() {
11553 struct_ser.serialize_field("dispatchStrategy", v)?;
11554 }
11555 if self.link_id != 0 {
11556 #[allow(clippy::needless_borrow)]
11557 #[allow(clippy::needless_borrows_for_generic_args)]
11558 struct_ser.serialize_field("linkId", ToString::to_string(&self.link_id).as_str())?;
11559 }
11560 if self.upstream_id != 0 {
11561 struct_ser.serialize_field("upstreamId", &self.upstream_id)?;
11562 }
11563 if self.downstream_id != 0 {
11564 struct_ser.serialize_field("downstreamId", &self.downstream_id)?;
11565 }
11566 struct_ser.end()
11567 }
11568}
11569impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragmentEdge {
11570 #[allow(deprecated)]
11571 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11572 where
11573 D: serde::Deserializer<'de>,
11574 {
11575 const FIELDS: &[&str] = &[
11576 "dispatch_strategy",
11577 "dispatchStrategy",
11578 "link_id",
11579 "linkId",
11580 "upstream_id",
11581 "upstreamId",
11582 "downstream_id",
11583 "downstreamId",
11584 ];
11585
11586 #[allow(clippy::enum_variant_names)]
11587 enum GeneratedField {
11588 DispatchStrategy,
11589 LinkId,
11590 UpstreamId,
11591 DownstreamId,
11592 }
11593 impl<'de> serde::Deserialize<'de> for GeneratedField {
11594 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11595 where
11596 D: serde::Deserializer<'de>,
11597 {
11598 struct GeneratedVisitor;
11599
11600 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11601 type Value = GeneratedField;
11602
11603 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11604 write!(formatter, "expected one of: {:?}", &FIELDS)
11605 }
11606
11607 #[allow(unused_variables)]
11608 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11609 where
11610 E: serde::de::Error,
11611 {
11612 match value {
11613 "dispatchStrategy" | "dispatch_strategy" => Ok(GeneratedField::DispatchStrategy),
11614 "linkId" | "link_id" => Ok(GeneratedField::LinkId),
11615 "upstreamId" | "upstream_id" => Ok(GeneratedField::UpstreamId),
11616 "downstreamId" | "downstream_id" => Ok(GeneratedField::DownstreamId),
11617 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11618 }
11619 }
11620 }
11621 deserializer.deserialize_identifier(GeneratedVisitor)
11622 }
11623 }
11624 struct GeneratedVisitor;
11625 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11626 type Value = stream_fragment_graph::StreamFragmentEdge;
11627
11628 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11629 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragmentEdge")
11630 }
11631
11632 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragmentEdge, V::Error>
11633 where
11634 V: serde::de::MapAccess<'de>,
11635 {
11636 let mut dispatch_strategy__ = None;
11637 let mut link_id__ = None;
11638 let mut upstream_id__ = None;
11639 let mut downstream_id__ = None;
11640 while let Some(k) = map_.next_key()? {
11641 match k {
11642 GeneratedField::DispatchStrategy => {
11643 if dispatch_strategy__.is_some() {
11644 return Err(serde::de::Error::duplicate_field("dispatchStrategy"));
11645 }
11646 dispatch_strategy__ = map_.next_value()?;
11647 }
11648 GeneratedField::LinkId => {
11649 if link_id__.is_some() {
11650 return Err(serde::de::Error::duplicate_field("linkId"));
11651 }
11652 link_id__ =
11653 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11654 ;
11655 }
11656 GeneratedField::UpstreamId => {
11657 if upstream_id__.is_some() {
11658 return Err(serde::de::Error::duplicate_field("upstreamId"));
11659 }
11660 upstream_id__ =
11661 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11662 ;
11663 }
11664 GeneratedField::DownstreamId => {
11665 if downstream_id__.is_some() {
11666 return Err(serde::de::Error::duplicate_field("downstreamId"));
11667 }
11668 downstream_id__ =
11669 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11670 ;
11671 }
11672 }
11673 }
11674 Ok(stream_fragment_graph::StreamFragmentEdge {
11675 dispatch_strategy: dispatch_strategy__,
11676 link_id: link_id__.unwrap_or_default(),
11677 upstream_id: upstream_id__.unwrap_or_default(),
11678 downstream_id: downstream_id__.unwrap_or_default(),
11679 })
11680 }
11681 }
11682 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", FIELDS, GeneratedVisitor)
11683 }
11684}
11685impl serde::Serialize for StreamFsFetch {
11686 #[allow(deprecated)]
11687 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11688 where
11689 S: serde::Serializer,
11690 {
11691 use serde::ser::SerializeStruct;
11692 let mut len = 0;
11693 if self.source_id != 0 {
11694 len += 1;
11695 }
11696 if self.state_table.is_some() {
11697 len += 1;
11698 }
11699 if self.row_id_index.is_some() {
11700 len += 1;
11701 }
11702 if !self.columns.is_empty() {
11703 len += 1;
11704 }
11705 if !self.with_properties.is_empty() {
11706 len += 1;
11707 }
11708 if self.info.is_some() {
11709 len += 1;
11710 }
11711 if !self.source_name.is_empty() {
11712 len += 1;
11713 }
11714 if self.rate_limit.is_some() {
11715 len += 1;
11716 }
11717 if !self.secret_refs.is_empty() {
11718 len += 1;
11719 }
11720 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetch", len)?;
11721 if self.source_id != 0 {
11722 struct_ser.serialize_field("sourceId", &self.source_id)?;
11723 }
11724 if let Some(v) = self.state_table.as_ref() {
11725 struct_ser.serialize_field("stateTable", v)?;
11726 }
11727 if let Some(v) = self.row_id_index.as_ref() {
11728 struct_ser.serialize_field("rowIdIndex", v)?;
11729 }
11730 if !self.columns.is_empty() {
11731 struct_ser.serialize_field("columns", &self.columns)?;
11732 }
11733 if !self.with_properties.is_empty() {
11734 struct_ser.serialize_field("withProperties", &self.with_properties)?;
11735 }
11736 if let Some(v) = self.info.as_ref() {
11737 struct_ser.serialize_field("info", v)?;
11738 }
11739 if !self.source_name.is_empty() {
11740 struct_ser.serialize_field("sourceName", &self.source_name)?;
11741 }
11742 if let Some(v) = self.rate_limit.as_ref() {
11743 struct_ser.serialize_field("rateLimit", v)?;
11744 }
11745 if !self.secret_refs.is_empty() {
11746 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
11747 }
11748 struct_ser.end()
11749 }
11750}
11751impl<'de> serde::Deserialize<'de> for StreamFsFetch {
11752 #[allow(deprecated)]
11753 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11754 where
11755 D: serde::Deserializer<'de>,
11756 {
11757 const FIELDS: &[&str] = &[
11758 "source_id",
11759 "sourceId",
11760 "state_table",
11761 "stateTable",
11762 "row_id_index",
11763 "rowIdIndex",
11764 "columns",
11765 "with_properties",
11766 "withProperties",
11767 "info",
11768 "source_name",
11769 "sourceName",
11770 "rate_limit",
11771 "rateLimit",
11772 "secret_refs",
11773 "secretRefs",
11774 ];
11775
11776 #[allow(clippy::enum_variant_names)]
11777 enum GeneratedField {
11778 SourceId,
11779 StateTable,
11780 RowIdIndex,
11781 Columns,
11782 WithProperties,
11783 Info,
11784 SourceName,
11785 RateLimit,
11786 SecretRefs,
11787 }
11788 impl<'de> serde::Deserialize<'de> for GeneratedField {
11789 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11790 where
11791 D: serde::Deserializer<'de>,
11792 {
11793 struct GeneratedVisitor;
11794
11795 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11796 type Value = GeneratedField;
11797
11798 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11799 write!(formatter, "expected one of: {:?}", &FIELDS)
11800 }
11801
11802 #[allow(unused_variables)]
11803 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11804 where
11805 E: serde::de::Error,
11806 {
11807 match value {
11808 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
11809 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11810 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
11811 "columns" => Ok(GeneratedField::Columns),
11812 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
11813 "info" => Ok(GeneratedField::Info),
11814 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
11815 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11816 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
11817 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11818 }
11819 }
11820 }
11821 deserializer.deserialize_identifier(GeneratedVisitor)
11822 }
11823 }
11824 struct GeneratedVisitor;
11825 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11826 type Value = StreamFsFetch;
11827
11828 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11829 formatter.write_str("struct stream_plan.StreamFsFetch")
11830 }
11831
11832 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetch, V::Error>
11833 where
11834 V: serde::de::MapAccess<'de>,
11835 {
11836 let mut source_id__ = None;
11837 let mut state_table__ = None;
11838 let mut row_id_index__ = None;
11839 let mut columns__ = None;
11840 let mut with_properties__ = None;
11841 let mut info__ = None;
11842 let mut source_name__ = None;
11843 let mut rate_limit__ = None;
11844 let mut secret_refs__ = None;
11845 while let Some(k) = map_.next_key()? {
11846 match k {
11847 GeneratedField::SourceId => {
11848 if source_id__.is_some() {
11849 return Err(serde::de::Error::duplicate_field("sourceId"));
11850 }
11851 source_id__ =
11852 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11853 ;
11854 }
11855 GeneratedField::StateTable => {
11856 if state_table__.is_some() {
11857 return Err(serde::de::Error::duplicate_field("stateTable"));
11858 }
11859 state_table__ = map_.next_value()?;
11860 }
11861 GeneratedField::RowIdIndex => {
11862 if row_id_index__.is_some() {
11863 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
11864 }
11865 row_id_index__ =
11866 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11867 ;
11868 }
11869 GeneratedField::Columns => {
11870 if columns__.is_some() {
11871 return Err(serde::de::Error::duplicate_field("columns"));
11872 }
11873 columns__ = Some(map_.next_value()?);
11874 }
11875 GeneratedField::WithProperties => {
11876 if with_properties__.is_some() {
11877 return Err(serde::de::Error::duplicate_field("withProperties"));
11878 }
11879 with_properties__ = Some(
11880 map_.next_value::<std::collections::BTreeMap<_, _>>()?
11881 );
11882 }
11883 GeneratedField::Info => {
11884 if info__.is_some() {
11885 return Err(serde::de::Error::duplicate_field("info"));
11886 }
11887 info__ = map_.next_value()?;
11888 }
11889 GeneratedField::SourceName => {
11890 if source_name__.is_some() {
11891 return Err(serde::de::Error::duplicate_field("sourceName"));
11892 }
11893 source_name__ = Some(map_.next_value()?);
11894 }
11895 GeneratedField::RateLimit => {
11896 if rate_limit__.is_some() {
11897 return Err(serde::de::Error::duplicate_field("rateLimit"));
11898 }
11899 rate_limit__ =
11900 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11901 ;
11902 }
11903 GeneratedField::SecretRefs => {
11904 if secret_refs__.is_some() {
11905 return Err(serde::de::Error::duplicate_field("secretRefs"));
11906 }
11907 secret_refs__ = Some(
11908 map_.next_value::<std::collections::BTreeMap<_, _>>()?
11909 );
11910 }
11911 }
11912 }
11913 Ok(StreamFsFetch {
11914 source_id: source_id__.unwrap_or_default(),
11915 state_table: state_table__,
11916 row_id_index: row_id_index__,
11917 columns: columns__.unwrap_or_default(),
11918 with_properties: with_properties__.unwrap_or_default(),
11919 info: info__,
11920 source_name: source_name__.unwrap_or_default(),
11921 rate_limit: rate_limit__,
11922 secret_refs: secret_refs__.unwrap_or_default(),
11923 })
11924 }
11925 }
11926 deserializer.deserialize_struct("stream_plan.StreamFsFetch", FIELDS, GeneratedVisitor)
11927 }
11928}
11929impl serde::Serialize for StreamFsFetchNode {
11930 #[allow(deprecated)]
11931 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11932 where
11933 S: serde::Serializer,
11934 {
11935 use serde::ser::SerializeStruct;
11936 let mut len = 0;
11937 if self.node_inner.is_some() {
11938 len += 1;
11939 }
11940 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetchNode", len)?;
11941 if let Some(v) = self.node_inner.as_ref() {
11942 struct_ser.serialize_field("nodeInner", v)?;
11943 }
11944 struct_ser.end()
11945 }
11946}
11947impl<'de> serde::Deserialize<'de> for StreamFsFetchNode {
11948 #[allow(deprecated)]
11949 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11950 where
11951 D: serde::Deserializer<'de>,
11952 {
11953 const FIELDS: &[&str] = &[
11954 "node_inner",
11955 "nodeInner",
11956 ];
11957
11958 #[allow(clippy::enum_variant_names)]
11959 enum GeneratedField {
11960 NodeInner,
11961 }
11962 impl<'de> serde::Deserialize<'de> for GeneratedField {
11963 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11964 where
11965 D: serde::Deserializer<'de>,
11966 {
11967 struct GeneratedVisitor;
11968
11969 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11970 type Value = GeneratedField;
11971
11972 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11973 write!(formatter, "expected one of: {:?}", &FIELDS)
11974 }
11975
11976 #[allow(unused_variables)]
11977 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11978 where
11979 E: serde::de::Error,
11980 {
11981 match value {
11982 "nodeInner" | "node_inner" => Ok(GeneratedField::NodeInner),
11983 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11984 }
11985 }
11986 }
11987 deserializer.deserialize_identifier(GeneratedVisitor)
11988 }
11989 }
11990 struct GeneratedVisitor;
11991 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11992 type Value = StreamFsFetchNode;
11993
11994 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11995 formatter.write_str("struct stream_plan.StreamFsFetchNode")
11996 }
11997
11998 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetchNode, V::Error>
11999 where
12000 V: serde::de::MapAccess<'de>,
12001 {
12002 let mut node_inner__ = None;
12003 while let Some(k) = map_.next_key()? {
12004 match k {
12005 GeneratedField::NodeInner => {
12006 if node_inner__.is_some() {
12007 return Err(serde::de::Error::duplicate_field("nodeInner"));
12008 }
12009 node_inner__ = map_.next_value()?;
12010 }
12011 }
12012 }
12013 Ok(StreamFsFetchNode {
12014 node_inner: node_inner__,
12015 })
12016 }
12017 }
12018 deserializer.deserialize_struct("stream_plan.StreamFsFetchNode", FIELDS, GeneratedVisitor)
12019 }
12020}
12021impl serde::Serialize for StreamMessage {
12022 #[allow(deprecated)]
12023 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12024 where
12025 S: serde::Serializer,
12026 {
12027 use serde::ser::SerializeStruct;
12028 let mut len = 0;
12029 if self.stream_message.is_some() {
12030 len += 1;
12031 }
12032 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessage", len)?;
12033 if let Some(v) = self.stream_message.as_ref() {
12034 match v {
12035 stream_message::StreamMessage::StreamChunk(v) => {
12036 struct_ser.serialize_field("streamChunk", v)?;
12037 }
12038 stream_message::StreamMessage::Barrier(v) => {
12039 struct_ser.serialize_field("barrier", v)?;
12040 }
12041 stream_message::StreamMessage::Watermark(v) => {
12042 struct_ser.serialize_field("watermark", v)?;
12043 }
12044 }
12045 }
12046 struct_ser.end()
12047 }
12048}
12049impl<'de> serde::Deserialize<'de> for StreamMessage {
12050 #[allow(deprecated)]
12051 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12052 where
12053 D: serde::Deserializer<'de>,
12054 {
12055 const FIELDS: &[&str] = &[
12056 "stream_chunk",
12057 "streamChunk",
12058 "barrier",
12059 "watermark",
12060 ];
12061
12062 #[allow(clippy::enum_variant_names)]
12063 enum GeneratedField {
12064 StreamChunk,
12065 Barrier,
12066 Watermark,
12067 }
12068 impl<'de> serde::Deserialize<'de> for GeneratedField {
12069 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12070 where
12071 D: serde::Deserializer<'de>,
12072 {
12073 struct GeneratedVisitor;
12074
12075 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12076 type Value = GeneratedField;
12077
12078 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12079 write!(formatter, "expected one of: {:?}", &FIELDS)
12080 }
12081
12082 #[allow(unused_variables)]
12083 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12084 where
12085 E: serde::de::Error,
12086 {
12087 match value {
12088 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
12089 "barrier" => Ok(GeneratedField::Barrier),
12090 "watermark" => Ok(GeneratedField::Watermark),
12091 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12092 }
12093 }
12094 }
12095 deserializer.deserialize_identifier(GeneratedVisitor)
12096 }
12097 }
12098 struct GeneratedVisitor;
12099 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12100 type Value = StreamMessage;
12101
12102 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12103 formatter.write_str("struct stream_plan.StreamMessage")
12104 }
12105
12106 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessage, V::Error>
12107 where
12108 V: serde::de::MapAccess<'de>,
12109 {
12110 let mut stream_message__ = None;
12111 while let Some(k) = map_.next_key()? {
12112 match k {
12113 GeneratedField::StreamChunk => {
12114 if stream_message__.is_some() {
12115 return Err(serde::de::Error::duplicate_field("streamChunk"));
12116 }
12117 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::StreamChunk)
12118;
12119 }
12120 GeneratedField::Barrier => {
12121 if stream_message__.is_some() {
12122 return Err(serde::de::Error::duplicate_field("barrier"));
12123 }
12124 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Barrier)
12125;
12126 }
12127 GeneratedField::Watermark => {
12128 if stream_message__.is_some() {
12129 return Err(serde::de::Error::duplicate_field("watermark"));
12130 }
12131 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Watermark)
12132;
12133 }
12134 }
12135 }
12136 Ok(StreamMessage {
12137 stream_message: stream_message__,
12138 })
12139 }
12140 }
12141 deserializer.deserialize_struct("stream_plan.StreamMessage", FIELDS, GeneratedVisitor)
12142 }
12143}
12144impl serde::Serialize for StreamMessageBatch {
12145 #[allow(deprecated)]
12146 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12147 where
12148 S: serde::Serializer,
12149 {
12150 use serde::ser::SerializeStruct;
12151 let mut len = 0;
12152 if self.stream_message_batch.is_some() {
12153 len += 1;
12154 }
12155 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch", len)?;
12156 if let Some(v) = self.stream_message_batch.as_ref() {
12157 match v {
12158 stream_message_batch::StreamMessageBatch::StreamChunk(v) => {
12159 struct_ser.serialize_field("streamChunk", v)?;
12160 }
12161 stream_message_batch::StreamMessageBatch::BarrierBatch(v) => {
12162 struct_ser.serialize_field("barrierBatch", v)?;
12163 }
12164 stream_message_batch::StreamMessageBatch::Watermark(v) => {
12165 struct_ser.serialize_field("watermark", v)?;
12166 }
12167 }
12168 }
12169 struct_ser.end()
12170 }
12171}
12172impl<'de> serde::Deserialize<'de> for StreamMessageBatch {
12173 #[allow(deprecated)]
12174 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12175 where
12176 D: serde::Deserializer<'de>,
12177 {
12178 const FIELDS: &[&str] = &[
12179 "stream_chunk",
12180 "streamChunk",
12181 "barrier_batch",
12182 "barrierBatch",
12183 "watermark",
12184 ];
12185
12186 #[allow(clippy::enum_variant_names)]
12187 enum GeneratedField {
12188 StreamChunk,
12189 BarrierBatch,
12190 Watermark,
12191 }
12192 impl<'de> serde::Deserialize<'de> for GeneratedField {
12193 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12194 where
12195 D: serde::Deserializer<'de>,
12196 {
12197 struct GeneratedVisitor;
12198
12199 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12200 type Value = GeneratedField;
12201
12202 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12203 write!(formatter, "expected one of: {:?}", &FIELDS)
12204 }
12205
12206 #[allow(unused_variables)]
12207 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12208 where
12209 E: serde::de::Error,
12210 {
12211 match value {
12212 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
12213 "barrierBatch" | "barrier_batch" => Ok(GeneratedField::BarrierBatch),
12214 "watermark" => Ok(GeneratedField::Watermark),
12215 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12216 }
12217 }
12218 }
12219 deserializer.deserialize_identifier(GeneratedVisitor)
12220 }
12221 }
12222 struct GeneratedVisitor;
12223 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12224 type Value = StreamMessageBatch;
12225
12226 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12227 formatter.write_str("struct stream_plan.StreamMessageBatch")
12228 }
12229
12230 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessageBatch, V::Error>
12231 where
12232 V: serde::de::MapAccess<'de>,
12233 {
12234 let mut stream_message_batch__ = None;
12235 while let Some(k) = map_.next_key()? {
12236 match k {
12237 GeneratedField::StreamChunk => {
12238 if stream_message_batch__.is_some() {
12239 return Err(serde::de::Error::duplicate_field("streamChunk"));
12240 }
12241 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::StreamChunk)
12242;
12243 }
12244 GeneratedField::BarrierBatch => {
12245 if stream_message_batch__.is_some() {
12246 return Err(serde::de::Error::duplicate_field("barrierBatch"));
12247 }
12248 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::BarrierBatch)
12249;
12250 }
12251 GeneratedField::Watermark => {
12252 if stream_message_batch__.is_some() {
12253 return Err(serde::de::Error::duplicate_field("watermark"));
12254 }
12255 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::Watermark)
12256;
12257 }
12258 }
12259 }
12260 Ok(StreamMessageBatch {
12261 stream_message_batch: stream_message_batch__,
12262 })
12263 }
12264 }
12265 deserializer.deserialize_struct("stream_plan.StreamMessageBatch", FIELDS, GeneratedVisitor)
12266 }
12267}
12268impl serde::Serialize for stream_message_batch::BarrierBatch {
12269 #[allow(deprecated)]
12270 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12271 where
12272 S: serde::Serializer,
12273 {
12274 use serde::ser::SerializeStruct;
12275 let mut len = 0;
12276 if !self.barriers.is_empty() {
12277 len += 1;
12278 }
12279 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", len)?;
12280 if !self.barriers.is_empty() {
12281 struct_ser.serialize_field("barriers", &self.barriers)?;
12282 }
12283 struct_ser.end()
12284 }
12285}
12286impl<'de> serde::Deserialize<'de> for stream_message_batch::BarrierBatch {
12287 #[allow(deprecated)]
12288 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12289 where
12290 D: serde::Deserializer<'de>,
12291 {
12292 const FIELDS: &[&str] = &[
12293 "barriers",
12294 ];
12295
12296 #[allow(clippy::enum_variant_names)]
12297 enum GeneratedField {
12298 Barriers,
12299 }
12300 impl<'de> serde::Deserialize<'de> for GeneratedField {
12301 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12302 where
12303 D: serde::Deserializer<'de>,
12304 {
12305 struct GeneratedVisitor;
12306
12307 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12308 type Value = GeneratedField;
12309
12310 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12311 write!(formatter, "expected one of: {:?}", &FIELDS)
12312 }
12313
12314 #[allow(unused_variables)]
12315 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12316 where
12317 E: serde::de::Error,
12318 {
12319 match value {
12320 "barriers" => Ok(GeneratedField::Barriers),
12321 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12322 }
12323 }
12324 }
12325 deserializer.deserialize_identifier(GeneratedVisitor)
12326 }
12327 }
12328 struct GeneratedVisitor;
12329 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12330 type Value = stream_message_batch::BarrierBatch;
12331
12332 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12333 formatter.write_str("struct stream_plan.StreamMessageBatch.BarrierBatch")
12334 }
12335
12336 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_message_batch::BarrierBatch, V::Error>
12337 where
12338 V: serde::de::MapAccess<'de>,
12339 {
12340 let mut barriers__ = None;
12341 while let Some(k) = map_.next_key()? {
12342 match k {
12343 GeneratedField::Barriers => {
12344 if barriers__.is_some() {
12345 return Err(serde::de::Error::duplicate_field("barriers"));
12346 }
12347 barriers__ = Some(map_.next_value()?);
12348 }
12349 }
12350 }
12351 Ok(stream_message_batch::BarrierBatch {
12352 barriers: barriers__.unwrap_or_default(),
12353 })
12354 }
12355 }
12356 deserializer.deserialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", FIELDS, GeneratedVisitor)
12357 }
12358}
12359impl serde::Serialize for StreamNode {
12360 #[allow(deprecated)]
12361 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12362 where
12363 S: serde::Serializer,
12364 {
12365 use serde::ser::SerializeStruct;
12366 let mut len = 0;
12367 if self.operator_id != 0 {
12368 len += 1;
12369 }
12370 if !self.input.is_empty() {
12371 len += 1;
12372 }
12373 if !self.stream_key.is_empty() {
12374 len += 1;
12375 }
12376 if self.stream_kind != 0 {
12377 len += 1;
12378 }
12379 if !self.identity.is_empty() {
12380 len += 1;
12381 }
12382 if !self.fields.is_empty() {
12383 len += 1;
12384 }
12385 if self.node_body.is_some() {
12386 len += 1;
12387 }
12388 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamNode", len)?;
12389 if self.operator_id != 0 {
12390 #[allow(clippy::needless_borrow)]
12391 #[allow(clippy::needless_borrows_for_generic_args)]
12392 struct_ser.serialize_field("operatorId", ToString::to_string(&self.operator_id).as_str())?;
12393 }
12394 if !self.input.is_empty() {
12395 struct_ser.serialize_field("input", &self.input)?;
12396 }
12397 if !self.stream_key.is_empty() {
12398 struct_ser.serialize_field("streamKey", &self.stream_key)?;
12399 }
12400 if self.stream_kind != 0 {
12401 let v = stream_node::StreamKind::try_from(self.stream_kind)
12402 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_kind)))?;
12403 struct_ser.serialize_field("streamKind", &v)?;
12404 }
12405 if !self.identity.is_empty() {
12406 struct_ser.serialize_field("identity", &self.identity)?;
12407 }
12408 if !self.fields.is_empty() {
12409 struct_ser.serialize_field("fields", &self.fields)?;
12410 }
12411 if let Some(v) = self.node_body.as_ref() {
12412 match v {
12413 stream_node::NodeBody::Source(v) => {
12414 struct_ser.serialize_field("source", v)?;
12415 }
12416 stream_node::NodeBody::Project(v) => {
12417 struct_ser.serialize_field("project", v)?;
12418 }
12419 stream_node::NodeBody::Filter(v) => {
12420 struct_ser.serialize_field("filter", v)?;
12421 }
12422 stream_node::NodeBody::Materialize(v) => {
12423 struct_ser.serialize_field("materialize", v)?;
12424 }
12425 stream_node::NodeBody::StatelessSimpleAgg(v) => {
12426 struct_ser.serialize_field("statelessSimpleAgg", v)?;
12427 }
12428 stream_node::NodeBody::SimpleAgg(v) => {
12429 struct_ser.serialize_field("simpleAgg", v)?;
12430 }
12431 stream_node::NodeBody::HashAgg(v) => {
12432 struct_ser.serialize_field("hashAgg", v)?;
12433 }
12434 stream_node::NodeBody::AppendOnlyTopN(v) => {
12435 struct_ser.serialize_field("appendOnlyTopN", v)?;
12436 }
12437 stream_node::NodeBody::HashJoin(v) => {
12438 struct_ser.serialize_field("hashJoin", v)?;
12439 }
12440 stream_node::NodeBody::TopN(v) => {
12441 struct_ser.serialize_field("topN", v)?;
12442 }
12443 stream_node::NodeBody::HopWindow(v) => {
12444 struct_ser.serialize_field("hopWindow", v)?;
12445 }
12446 stream_node::NodeBody::Merge(v) => {
12447 struct_ser.serialize_field("merge", v)?;
12448 }
12449 stream_node::NodeBody::Exchange(v) => {
12450 struct_ser.serialize_field("exchange", v)?;
12451 }
12452 stream_node::NodeBody::StreamScan(v) => {
12453 struct_ser.serialize_field("streamScan", v)?;
12454 }
12455 stream_node::NodeBody::BatchPlan(v) => {
12456 struct_ser.serialize_field("batchPlan", v)?;
12457 }
12458 stream_node::NodeBody::Lookup(v) => {
12459 struct_ser.serialize_field("lookup", v)?;
12460 }
12461 stream_node::NodeBody::Arrange(v) => {
12462 struct_ser.serialize_field("arrange", v)?;
12463 }
12464 stream_node::NodeBody::LookupUnion(v) => {
12465 struct_ser.serialize_field("lookupUnion", v)?;
12466 }
12467 stream_node::NodeBody::Union(v) => {
12468 struct_ser.serialize_field("union", v)?;
12469 }
12470 stream_node::NodeBody::DeltaIndexJoin(v) => {
12471 struct_ser.serialize_field("deltaIndexJoin", v)?;
12472 }
12473 stream_node::NodeBody::Sink(v) => {
12474 struct_ser.serialize_field("sink", v)?;
12475 }
12476 stream_node::NodeBody::Expand(v) => {
12477 struct_ser.serialize_field("expand", v)?;
12478 }
12479 stream_node::NodeBody::DynamicFilter(v) => {
12480 struct_ser.serialize_field("dynamicFilter", v)?;
12481 }
12482 stream_node::NodeBody::ProjectSet(v) => {
12483 struct_ser.serialize_field("projectSet", v)?;
12484 }
12485 stream_node::NodeBody::GroupTopN(v) => {
12486 struct_ser.serialize_field("groupTopN", v)?;
12487 }
12488 stream_node::NodeBody::Sort(v) => {
12489 struct_ser.serialize_field("sort", v)?;
12490 }
12491 stream_node::NodeBody::WatermarkFilter(v) => {
12492 struct_ser.serialize_field("watermarkFilter", v)?;
12493 }
12494 stream_node::NodeBody::Dml(v) => {
12495 struct_ser.serialize_field("dml", v)?;
12496 }
12497 stream_node::NodeBody::RowIdGen(v) => {
12498 struct_ser.serialize_field("rowIdGen", v)?;
12499 }
12500 stream_node::NodeBody::Now(v) => {
12501 struct_ser.serialize_field("now", v)?;
12502 }
12503 stream_node::NodeBody::AppendOnlyGroupTopN(v) => {
12504 struct_ser.serialize_field("appendOnlyGroupTopN", v)?;
12505 }
12506 stream_node::NodeBody::TemporalJoin(v) => {
12507 struct_ser.serialize_field("temporalJoin", v)?;
12508 }
12509 stream_node::NodeBody::BarrierRecv(v) => {
12510 struct_ser.serialize_field("barrierRecv", v)?;
12511 }
12512 stream_node::NodeBody::Values(v) => {
12513 struct_ser.serialize_field("values", v)?;
12514 }
12515 stream_node::NodeBody::AppendOnlyDedup(v) => {
12516 struct_ser.serialize_field("appendOnlyDedup", v)?;
12517 }
12518 stream_node::NodeBody::NoOp(v) => {
12519 struct_ser.serialize_field("noOp", v)?;
12520 }
12521 stream_node::NodeBody::EowcOverWindow(v) => {
12522 struct_ser.serialize_field("eowcOverWindow", v)?;
12523 }
12524 stream_node::NodeBody::OverWindow(v) => {
12525 struct_ser.serialize_field("overWindow", v)?;
12526 }
12527 stream_node::NodeBody::StreamFsFetch(v) => {
12528 struct_ser.serialize_field("streamFsFetch", v)?;
12529 }
12530 stream_node::NodeBody::StreamCdcScan(v) => {
12531 struct_ser.serialize_field("streamCdcScan", v)?;
12532 }
12533 stream_node::NodeBody::CdcFilter(v) => {
12534 struct_ser.serialize_field("cdcFilter", v)?;
12535 }
12536 stream_node::NodeBody::SourceBackfill(v) => {
12537 struct_ser.serialize_field("sourceBackfill", v)?;
12538 }
12539 stream_node::NodeBody::Changelog(v) => {
12540 struct_ser.serialize_field("changelog", v)?;
12541 }
12542 stream_node::NodeBody::LocalApproxPercentile(v) => {
12543 struct_ser.serialize_field("localApproxPercentile", v)?;
12544 }
12545 stream_node::NodeBody::GlobalApproxPercentile(v) => {
12546 struct_ser.serialize_field("globalApproxPercentile", v)?;
12547 }
12548 stream_node::NodeBody::RowMerge(v) => {
12549 struct_ser.serialize_field("rowMerge", v)?;
12550 }
12551 stream_node::NodeBody::AsOfJoin(v) => {
12552 struct_ser.serialize_field("asOfJoin", v)?;
12553 }
12554 stream_node::NodeBody::SyncLogStore(v) => {
12555 struct_ser.serialize_field("syncLogStore", v)?;
12556 }
12557 stream_node::NodeBody::MaterializedExprs(v) => {
12558 struct_ser.serialize_field("materializedExprs", v)?;
12559 }
12560 stream_node::NodeBody::VectorIndexWrite(v) => {
12561 struct_ser.serialize_field("vectorIndexWrite", v)?;
12562 }
12563 stream_node::NodeBody::UpstreamSinkUnion(v) => {
12564 struct_ser.serialize_field("upstreamSinkUnion", v)?;
12565 }
12566 stream_node::NodeBody::LocalityProvider(v) => {
12567 struct_ser.serialize_field("localityProvider", v)?;
12568 }
12569 }
12570 }
12571 struct_ser.end()
12572 }
12573}
12574impl<'de> serde::Deserialize<'de> for StreamNode {
12575 #[allow(deprecated)]
12576 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12577 where
12578 D: serde::Deserializer<'de>,
12579 {
12580 const FIELDS: &[&str] = &[
12581 "operator_id",
12582 "operatorId",
12583 "input",
12584 "stream_key",
12585 "streamKey",
12586 "stream_kind",
12587 "streamKind",
12588 "identity",
12589 "fields",
12590 "source",
12591 "project",
12592 "filter",
12593 "materialize",
12594 "stateless_simple_agg",
12595 "statelessSimpleAgg",
12596 "simple_agg",
12597 "simpleAgg",
12598 "hash_agg",
12599 "hashAgg",
12600 "append_only_top_n",
12601 "appendOnlyTopN",
12602 "hash_join",
12603 "hashJoin",
12604 "top_n",
12605 "topN",
12606 "hop_window",
12607 "hopWindow",
12608 "merge",
12609 "exchange",
12610 "stream_scan",
12611 "streamScan",
12612 "batch_plan",
12613 "batchPlan",
12614 "lookup",
12615 "arrange",
12616 "lookup_union",
12617 "lookupUnion",
12618 "union",
12619 "delta_index_join",
12620 "deltaIndexJoin",
12621 "sink",
12622 "expand",
12623 "dynamic_filter",
12624 "dynamicFilter",
12625 "project_set",
12626 "projectSet",
12627 "group_top_n",
12628 "groupTopN",
12629 "sort",
12630 "watermark_filter",
12631 "watermarkFilter",
12632 "dml",
12633 "row_id_gen",
12634 "rowIdGen",
12635 "now",
12636 "append_only_group_top_n",
12637 "appendOnlyGroupTopN",
12638 "temporal_join",
12639 "temporalJoin",
12640 "barrier_recv",
12641 "barrierRecv",
12642 "values",
12643 "append_only_dedup",
12644 "appendOnlyDedup",
12645 "no_op",
12646 "noOp",
12647 "eowc_over_window",
12648 "eowcOverWindow",
12649 "over_window",
12650 "overWindow",
12651 "stream_fs_fetch",
12652 "streamFsFetch",
12653 "stream_cdc_scan",
12654 "streamCdcScan",
12655 "cdc_filter",
12656 "cdcFilter",
12657 "source_backfill",
12658 "sourceBackfill",
12659 "changelog",
12660 "local_approx_percentile",
12661 "localApproxPercentile",
12662 "global_approx_percentile",
12663 "globalApproxPercentile",
12664 "row_merge",
12665 "rowMerge",
12666 "as_of_join",
12667 "asOfJoin",
12668 "sync_log_store",
12669 "syncLogStore",
12670 "materialized_exprs",
12671 "materializedExprs",
12672 "vector_index_write",
12673 "vectorIndexWrite",
12674 "upstream_sink_union",
12675 "upstreamSinkUnion",
12676 "locality_provider",
12677 "localityProvider",
12678 ];
12679
12680 #[allow(clippy::enum_variant_names)]
12681 enum GeneratedField {
12682 OperatorId,
12683 Input,
12684 StreamKey,
12685 StreamKind,
12686 Identity,
12687 Fields,
12688 Source,
12689 Project,
12690 Filter,
12691 Materialize,
12692 StatelessSimpleAgg,
12693 SimpleAgg,
12694 HashAgg,
12695 AppendOnlyTopN,
12696 HashJoin,
12697 TopN,
12698 HopWindow,
12699 Merge,
12700 Exchange,
12701 StreamScan,
12702 BatchPlan,
12703 Lookup,
12704 Arrange,
12705 LookupUnion,
12706 Union,
12707 DeltaIndexJoin,
12708 Sink,
12709 Expand,
12710 DynamicFilter,
12711 ProjectSet,
12712 GroupTopN,
12713 Sort,
12714 WatermarkFilter,
12715 Dml,
12716 RowIdGen,
12717 Now,
12718 AppendOnlyGroupTopN,
12719 TemporalJoin,
12720 BarrierRecv,
12721 Values,
12722 AppendOnlyDedup,
12723 NoOp,
12724 EowcOverWindow,
12725 OverWindow,
12726 StreamFsFetch,
12727 StreamCdcScan,
12728 CdcFilter,
12729 SourceBackfill,
12730 Changelog,
12731 LocalApproxPercentile,
12732 GlobalApproxPercentile,
12733 RowMerge,
12734 AsOfJoin,
12735 SyncLogStore,
12736 MaterializedExprs,
12737 VectorIndexWrite,
12738 UpstreamSinkUnion,
12739 LocalityProvider,
12740 }
12741 impl<'de> serde::Deserialize<'de> for GeneratedField {
12742 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12743 where
12744 D: serde::Deserializer<'de>,
12745 {
12746 struct GeneratedVisitor;
12747
12748 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12749 type Value = GeneratedField;
12750
12751 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12752 write!(formatter, "expected one of: {:?}", &FIELDS)
12753 }
12754
12755 #[allow(unused_variables)]
12756 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12757 where
12758 E: serde::de::Error,
12759 {
12760 match value {
12761 "operatorId" | "operator_id" => Ok(GeneratedField::OperatorId),
12762 "input" => Ok(GeneratedField::Input),
12763 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
12764 "streamKind" | "stream_kind" => Ok(GeneratedField::StreamKind),
12765 "identity" => Ok(GeneratedField::Identity),
12766 "fields" => Ok(GeneratedField::Fields),
12767 "source" => Ok(GeneratedField::Source),
12768 "project" => Ok(GeneratedField::Project),
12769 "filter" => Ok(GeneratedField::Filter),
12770 "materialize" => Ok(GeneratedField::Materialize),
12771 "statelessSimpleAgg" | "stateless_simple_agg" => Ok(GeneratedField::StatelessSimpleAgg),
12772 "simpleAgg" | "simple_agg" => Ok(GeneratedField::SimpleAgg),
12773 "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
12774 "appendOnlyTopN" | "append_only_top_n" => Ok(GeneratedField::AppendOnlyTopN),
12775 "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
12776 "topN" | "top_n" => Ok(GeneratedField::TopN),
12777 "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
12778 "merge" => Ok(GeneratedField::Merge),
12779 "exchange" => Ok(GeneratedField::Exchange),
12780 "streamScan" | "stream_scan" => Ok(GeneratedField::StreamScan),
12781 "batchPlan" | "batch_plan" => Ok(GeneratedField::BatchPlan),
12782 "lookup" => Ok(GeneratedField::Lookup),
12783 "arrange" => Ok(GeneratedField::Arrange),
12784 "lookupUnion" | "lookup_union" => Ok(GeneratedField::LookupUnion),
12785 "union" => Ok(GeneratedField::Union),
12786 "deltaIndexJoin" | "delta_index_join" => Ok(GeneratedField::DeltaIndexJoin),
12787 "sink" => Ok(GeneratedField::Sink),
12788 "expand" => Ok(GeneratedField::Expand),
12789 "dynamicFilter" | "dynamic_filter" => Ok(GeneratedField::DynamicFilter),
12790 "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
12791 "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
12792 "sort" => Ok(GeneratedField::Sort),
12793 "watermarkFilter" | "watermark_filter" => Ok(GeneratedField::WatermarkFilter),
12794 "dml" => Ok(GeneratedField::Dml),
12795 "rowIdGen" | "row_id_gen" => Ok(GeneratedField::RowIdGen),
12796 "now" => Ok(GeneratedField::Now),
12797 "appendOnlyGroupTopN" | "append_only_group_top_n" => Ok(GeneratedField::AppendOnlyGroupTopN),
12798 "temporalJoin" | "temporal_join" => Ok(GeneratedField::TemporalJoin),
12799 "barrierRecv" | "barrier_recv" => Ok(GeneratedField::BarrierRecv),
12800 "values" => Ok(GeneratedField::Values),
12801 "appendOnlyDedup" | "append_only_dedup" => Ok(GeneratedField::AppendOnlyDedup),
12802 "noOp" | "no_op" => Ok(GeneratedField::NoOp),
12803 "eowcOverWindow" | "eowc_over_window" => Ok(GeneratedField::EowcOverWindow),
12804 "overWindow" | "over_window" => Ok(GeneratedField::OverWindow),
12805 "streamFsFetch" | "stream_fs_fetch" => Ok(GeneratedField::StreamFsFetch),
12806 "streamCdcScan" | "stream_cdc_scan" => Ok(GeneratedField::StreamCdcScan),
12807 "cdcFilter" | "cdc_filter" => Ok(GeneratedField::CdcFilter),
12808 "sourceBackfill" | "source_backfill" => Ok(GeneratedField::SourceBackfill),
12809 "changelog" => Ok(GeneratedField::Changelog),
12810 "localApproxPercentile" | "local_approx_percentile" => Ok(GeneratedField::LocalApproxPercentile),
12811 "globalApproxPercentile" | "global_approx_percentile" => Ok(GeneratedField::GlobalApproxPercentile),
12812 "rowMerge" | "row_merge" => Ok(GeneratedField::RowMerge),
12813 "asOfJoin" | "as_of_join" => Ok(GeneratedField::AsOfJoin),
12814 "syncLogStore" | "sync_log_store" => Ok(GeneratedField::SyncLogStore),
12815 "materializedExprs" | "materialized_exprs" => Ok(GeneratedField::MaterializedExprs),
12816 "vectorIndexWrite" | "vector_index_write" => Ok(GeneratedField::VectorIndexWrite),
12817 "upstreamSinkUnion" | "upstream_sink_union" => Ok(GeneratedField::UpstreamSinkUnion),
12818 "localityProvider" | "locality_provider" => Ok(GeneratedField::LocalityProvider),
12819 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12820 }
12821 }
12822 }
12823 deserializer.deserialize_identifier(GeneratedVisitor)
12824 }
12825 }
12826 struct GeneratedVisitor;
12827 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12828 type Value = StreamNode;
12829
12830 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12831 formatter.write_str("struct stream_plan.StreamNode")
12832 }
12833
12834 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamNode, V::Error>
12835 where
12836 V: serde::de::MapAccess<'de>,
12837 {
12838 let mut operator_id__ = None;
12839 let mut input__ = None;
12840 let mut stream_key__ = None;
12841 let mut stream_kind__ = None;
12842 let mut identity__ = None;
12843 let mut fields__ = None;
12844 let mut node_body__ = None;
12845 while let Some(k) = map_.next_key()? {
12846 match k {
12847 GeneratedField::OperatorId => {
12848 if operator_id__.is_some() {
12849 return Err(serde::de::Error::duplicate_field("operatorId"));
12850 }
12851 operator_id__ =
12852 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12853 ;
12854 }
12855 GeneratedField::Input => {
12856 if input__.is_some() {
12857 return Err(serde::de::Error::duplicate_field("input"));
12858 }
12859 input__ = Some(map_.next_value()?);
12860 }
12861 GeneratedField::StreamKey => {
12862 if stream_key__.is_some() {
12863 return Err(serde::de::Error::duplicate_field("streamKey"));
12864 }
12865 stream_key__ =
12866 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12867 .into_iter().map(|x| x.0).collect())
12868 ;
12869 }
12870 GeneratedField::StreamKind => {
12871 if stream_kind__.is_some() {
12872 return Err(serde::de::Error::duplicate_field("streamKind"));
12873 }
12874 stream_kind__ = Some(map_.next_value::<stream_node::StreamKind>()? as i32);
12875 }
12876 GeneratedField::Identity => {
12877 if identity__.is_some() {
12878 return Err(serde::de::Error::duplicate_field("identity"));
12879 }
12880 identity__ = Some(map_.next_value()?);
12881 }
12882 GeneratedField::Fields => {
12883 if fields__.is_some() {
12884 return Err(serde::de::Error::duplicate_field("fields"));
12885 }
12886 fields__ = Some(map_.next_value()?);
12887 }
12888 GeneratedField::Source => {
12889 if node_body__.is_some() {
12890 return Err(serde::de::Error::duplicate_field("source"));
12891 }
12892 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Source)
12893;
12894 }
12895 GeneratedField::Project => {
12896 if node_body__.is_some() {
12897 return Err(serde::de::Error::duplicate_field("project"));
12898 }
12899 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Project)
12900;
12901 }
12902 GeneratedField::Filter => {
12903 if node_body__.is_some() {
12904 return Err(serde::de::Error::duplicate_field("filter"));
12905 }
12906 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Filter)
12907;
12908 }
12909 GeneratedField::Materialize => {
12910 if node_body__.is_some() {
12911 return Err(serde::de::Error::duplicate_field("materialize"));
12912 }
12913 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Materialize)
12914;
12915 }
12916 GeneratedField::StatelessSimpleAgg => {
12917 if node_body__.is_some() {
12918 return Err(serde::de::Error::duplicate_field("statelessSimpleAgg"));
12919 }
12920 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StatelessSimpleAgg)
12921;
12922 }
12923 GeneratedField::SimpleAgg => {
12924 if node_body__.is_some() {
12925 return Err(serde::de::Error::duplicate_field("simpleAgg"));
12926 }
12927 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SimpleAgg)
12928;
12929 }
12930 GeneratedField::HashAgg => {
12931 if node_body__.is_some() {
12932 return Err(serde::de::Error::duplicate_field("hashAgg"));
12933 }
12934 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashAgg)
12935;
12936 }
12937 GeneratedField::AppendOnlyTopN => {
12938 if node_body__.is_some() {
12939 return Err(serde::de::Error::duplicate_field("appendOnlyTopN"));
12940 }
12941 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyTopN)
12942;
12943 }
12944 GeneratedField::HashJoin => {
12945 if node_body__.is_some() {
12946 return Err(serde::de::Error::duplicate_field("hashJoin"));
12947 }
12948 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashJoin)
12949;
12950 }
12951 GeneratedField::TopN => {
12952 if node_body__.is_some() {
12953 return Err(serde::de::Error::duplicate_field("topN"));
12954 }
12955 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TopN)
12956;
12957 }
12958 GeneratedField::HopWindow => {
12959 if node_body__.is_some() {
12960 return Err(serde::de::Error::duplicate_field("hopWindow"));
12961 }
12962 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HopWindow)
12963;
12964 }
12965 GeneratedField::Merge => {
12966 if node_body__.is_some() {
12967 return Err(serde::de::Error::duplicate_field("merge"));
12968 }
12969 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Merge)
12970;
12971 }
12972 GeneratedField::Exchange => {
12973 if node_body__.is_some() {
12974 return Err(serde::de::Error::duplicate_field("exchange"));
12975 }
12976 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Exchange)
12977;
12978 }
12979 GeneratedField::StreamScan => {
12980 if node_body__.is_some() {
12981 return Err(serde::de::Error::duplicate_field("streamScan"));
12982 }
12983 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamScan)
12984;
12985 }
12986 GeneratedField::BatchPlan => {
12987 if node_body__.is_some() {
12988 return Err(serde::de::Error::duplicate_field("batchPlan"));
12989 }
12990 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BatchPlan)
12991;
12992 }
12993 GeneratedField::Lookup => {
12994 if node_body__.is_some() {
12995 return Err(serde::de::Error::duplicate_field("lookup"));
12996 }
12997 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Lookup)
12998;
12999 }
13000 GeneratedField::Arrange => {
13001 if node_body__.is_some() {
13002 return Err(serde::de::Error::duplicate_field("arrange"));
13003 }
13004 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Arrange)
13005;
13006 }
13007 GeneratedField::LookupUnion => {
13008 if node_body__.is_some() {
13009 return Err(serde::de::Error::duplicate_field("lookupUnion"));
13010 }
13011 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LookupUnion)
13012;
13013 }
13014 GeneratedField::Union => {
13015 if node_body__.is_some() {
13016 return Err(serde::de::Error::duplicate_field("union"));
13017 }
13018 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Union)
13019;
13020 }
13021 GeneratedField::DeltaIndexJoin => {
13022 if node_body__.is_some() {
13023 return Err(serde::de::Error::duplicate_field("deltaIndexJoin"));
13024 }
13025 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DeltaIndexJoin)
13026;
13027 }
13028 GeneratedField::Sink => {
13029 if node_body__.is_some() {
13030 return Err(serde::de::Error::duplicate_field("sink"));
13031 }
13032 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sink)
13033;
13034 }
13035 GeneratedField::Expand => {
13036 if node_body__.is_some() {
13037 return Err(serde::de::Error::duplicate_field("expand"));
13038 }
13039 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Expand)
13040;
13041 }
13042 GeneratedField::DynamicFilter => {
13043 if node_body__.is_some() {
13044 return Err(serde::de::Error::duplicate_field("dynamicFilter"));
13045 }
13046 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DynamicFilter)
13047;
13048 }
13049 GeneratedField::ProjectSet => {
13050 if node_body__.is_some() {
13051 return Err(serde::de::Error::duplicate_field("projectSet"));
13052 }
13053 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::ProjectSet)
13054;
13055 }
13056 GeneratedField::GroupTopN => {
13057 if node_body__.is_some() {
13058 return Err(serde::de::Error::duplicate_field("groupTopN"));
13059 }
13060 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GroupTopN)
13061;
13062 }
13063 GeneratedField::Sort => {
13064 if node_body__.is_some() {
13065 return Err(serde::de::Error::duplicate_field("sort"));
13066 }
13067 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sort)
13068;
13069 }
13070 GeneratedField::WatermarkFilter => {
13071 if node_body__.is_some() {
13072 return Err(serde::de::Error::duplicate_field("watermarkFilter"));
13073 }
13074 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::WatermarkFilter)
13075;
13076 }
13077 GeneratedField::Dml => {
13078 if node_body__.is_some() {
13079 return Err(serde::de::Error::duplicate_field("dml"));
13080 }
13081 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Dml)
13082;
13083 }
13084 GeneratedField::RowIdGen => {
13085 if node_body__.is_some() {
13086 return Err(serde::de::Error::duplicate_field("rowIdGen"));
13087 }
13088 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowIdGen)
13089;
13090 }
13091 GeneratedField::Now => {
13092 if node_body__.is_some() {
13093 return Err(serde::de::Error::duplicate_field("now"));
13094 }
13095 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Now)
13096;
13097 }
13098 GeneratedField::AppendOnlyGroupTopN => {
13099 if node_body__.is_some() {
13100 return Err(serde::de::Error::duplicate_field("appendOnlyGroupTopN"));
13101 }
13102 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyGroupTopN)
13103;
13104 }
13105 GeneratedField::TemporalJoin => {
13106 if node_body__.is_some() {
13107 return Err(serde::de::Error::duplicate_field("temporalJoin"));
13108 }
13109 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TemporalJoin)
13110;
13111 }
13112 GeneratedField::BarrierRecv => {
13113 if node_body__.is_some() {
13114 return Err(serde::de::Error::duplicate_field("barrierRecv"));
13115 }
13116 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BarrierRecv)
13117;
13118 }
13119 GeneratedField::Values => {
13120 if node_body__.is_some() {
13121 return Err(serde::de::Error::duplicate_field("values"));
13122 }
13123 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Values)
13124;
13125 }
13126 GeneratedField::AppendOnlyDedup => {
13127 if node_body__.is_some() {
13128 return Err(serde::de::Error::duplicate_field("appendOnlyDedup"));
13129 }
13130 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyDedup)
13131;
13132 }
13133 GeneratedField::NoOp => {
13134 if node_body__.is_some() {
13135 return Err(serde::de::Error::duplicate_field("noOp"));
13136 }
13137 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::NoOp)
13138;
13139 }
13140 GeneratedField::EowcOverWindow => {
13141 if node_body__.is_some() {
13142 return Err(serde::de::Error::duplicate_field("eowcOverWindow"));
13143 }
13144 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcOverWindow)
13145;
13146 }
13147 GeneratedField::OverWindow => {
13148 if node_body__.is_some() {
13149 return Err(serde::de::Error::duplicate_field("overWindow"));
13150 }
13151 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::OverWindow)
13152;
13153 }
13154 GeneratedField::StreamFsFetch => {
13155 if node_body__.is_some() {
13156 return Err(serde::de::Error::duplicate_field("streamFsFetch"));
13157 }
13158 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamFsFetch)
13159;
13160 }
13161 GeneratedField::StreamCdcScan => {
13162 if node_body__.is_some() {
13163 return Err(serde::de::Error::duplicate_field("streamCdcScan"));
13164 }
13165 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamCdcScan)
13166;
13167 }
13168 GeneratedField::CdcFilter => {
13169 if node_body__.is_some() {
13170 return Err(serde::de::Error::duplicate_field("cdcFilter"));
13171 }
13172 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CdcFilter)
13173;
13174 }
13175 GeneratedField::SourceBackfill => {
13176 if node_body__.is_some() {
13177 return Err(serde::de::Error::duplicate_field("sourceBackfill"));
13178 }
13179 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SourceBackfill)
13180;
13181 }
13182 GeneratedField::Changelog => {
13183 if node_body__.is_some() {
13184 return Err(serde::de::Error::duplicate_field("changelog"));
13185 }
13186 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Changelog)
13187;
13188 }
13189 GeneratedField::LocalApproxPercentile => {
13190 if node_body__.is_some() {
13191 return Err(serde::de::Error::duplicate_field("localApproxPercentile"));
13192 }
13193 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalApproxPercentile)
13194;
13195 }
13196 GeneratedField::GlobalApproxPercentile => {
13197 if node_body__.is_some() {
13198 return Err(serde::de::Error::duplicate_field("globalApproxPercentile"));
13199 }
13200 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GlobalApproxPercentile)
13201;
13202 }
13203 GeneratedField::RowMerge => {
13204 if node_body__.is_some() {
13205 return Err(serde::de::Error::duplicate_field("rowMerge"));
13206 }
13207 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowMerge)
13208;
13209 }
13210 GeneratedField::AsOfJoin => {
13211 if node_body__.is_some() {
13212 return Err(serde::de::Error::duplicate_field("asOfJoin"));
13213 }
13214 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AsOfJoin)
13215;
13216 }
13217 GeneratedField::SyncLogStore => {
13218 if node_body__.is_some() {
13219 return Err(serde::de::Error::duplicate_field("syncLogStore"));
13220 }
13221 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SyncLogStore)
13222;
13223 }
13224 GeneratedField::MaterializedExprs => {
13225 if node_body__.is_some() {
13226 return Err(serde::de::Error::duplicate_field("materializedExprs"));
13227 }
13228 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MaterializedExprs)
13229;
13230 }
13231 GeneratedField::VectorIndexWrite => {
13232 if node_body__.is_some() {
13233 return Err(serde::de::Error::duplicate_field("vectorIndexWrite"));
13234 }
13235 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexWrite)
13236;
13237 }
13238 GeneratedField::UpstreamSinkUnion => {
13239 if node_body__.is_some() {
13240 return Err(serde::de::Error::duplicate_field("upstreamSinkUnion"));
13241 }
13242 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::UpstreamSinkUnion)
13243;
13244 }
13245 GeneratedField::LocalityProvider => {
13246 if node_body__.is_some() {
13247 return Err(serde::de::Error::duplicate_field("localityProvider"));
13248 }
13249 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalityProvider)
13250;
13251 }
13252 }
13253 }
13254 Ok(StreamNode {
13255 operator_id: operator_id__.unwrap_or_default(),
13256 input: input__.unwrap_or_default(),
13257 stream_key: stream_key__.unwrap_or_default(),
13258 stream_kind: stream_kind__.unwrap_or_default(),
13259 identity: identity__.unwrap_or_default(),
13260 fields: fields__.unwrap_or_default(),
13261 node_body: node_body__,
13262 })
13263 }
13264 }
13265 deserializer.deserialize_struct("stream_plan.StreamNode", FIELDS, GeneratedVisitor)
13266 }
13267}
13268impl serde::Serialize for stream_node::StreamKind {
13269 #[allow(deprecated)]
13270 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13271 where
13272 S: serde::Serializer,
13273 {
13274 let variant = match self {
13275 Self::Retract => "STREAM_KIND_RETRACT",
13276 Self::AppendOnly => "STREAM_KIND_APPEND_ONLY",
13277 Self::Upsert => "STREAM_KIND_UPSERT",
13278 };
13279 serializer.serialize_str(variant)
13280 }
13281}
13282impl<'de> serde::Deserialize<'de> for stream_node::StreamKind {
13283 #[allow(deprecated)]
13284 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13285 where
13286 D: serde::Deserializer<'de>,
13287 {
13288 const FIELDS: &[&str] = &[
13289 "STREAM_KIND_RETRACT",
13290 "STREAM_KIND_APPEND_ONLY",
13291 "STREAM_KIND_UPSERT",
13292 ];
13293
13294 struct GeneratedVisitor;
13295
13296 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13297 type Value = stream_node::StreamKind;
13298
13299 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13300 write!(formatter, "expected one of: {:?}", &FIELDS)
13301 }
13302
13303 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13304 where
13305 E: serde::de::Error,
13306 {
13307 i32::try_from(v)
13308 .ok()
13309 .and_then(|x| x.try_into().ok())
13310 .ok_or_else(|| {
13311 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13312 })
13313 }
13314
13315 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13316 where
13317 E: serde::de::Error,
13318 {
13319 i32::try_from(v)
13320 .ok()
13321 .and_then(|x| x.try_into().ok())
13322 .ok_or_else(|| {
13323 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13324 })
13325 }
13326
13327 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13328 where
13329 E: serde::de::Error,
13330 {
13331 match value {
13332 "STREAM_KIND_RETRACT" => Ok(stream_node::StreamKind::Retract),
13333 "STREAM_KIND_APPEND_ONLY" => Ok(stream_node::StreamKind::AppendOnly),
13334 "STREAM_KIND_UPSERT" => Ok(stream_node::StreamKind::Upsert),
13335 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13336 }
13337 }
13338 }
13339 deserializer.deserialize_any(GeneratedVisitor)
13340 }
13341}
13342impl serde::Serialize for StreamScanNode {
13343 #[allow(deprecated)]
13344 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13345 where
13346 S: serde::Serializer,
13347 {
13348 use serde::ser::SerializeStruct;
13349 let mut len = 0;
13350 if self.table_id != 0 {
13351 len += 1;
13352 }
13353 if !self.upstream_column_ids.is_empty() {
13354 len += 1;
13355 }
13356 if !self.output_indices.is_empty() {
13357 len += 1;
13358 }
13359 if self.stream_scan_type != 0 {
13360 len += 1;
13361 }
13362 if self.state_table.is_some() {
13363 len += 1;
13364 }
13365 if self.table_desc.is_some() {
13366 len += 1;
13367 }
13368 if self.rate_limit.is_some() {
13369 len += 1;
13370 }
13371 if self.snapshot_read_barrier_interval != 0 {
13372 len += 1;
13373 }
13374 if self.arrangement_table.is_some() {
13375 len += 1;
13376 }
13377 if self.snapshot_backfill_epoch.is_some() {
13378 len += 1;
13379 }
13380 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamScanNode", len)?;
13381 if self.table_id != 0 {
13382 struct_ser.serialize_field("tableId", &self.table_id)?;
13383 }
13384 if !self.upstream_column_ids.is_empty() {
13385 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
13386 }
13387 if !self.output_indices.is_empty() {
13388 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
13389 }
13390 if self.stream_scan_type != 0 {
13391 let v = StreamScanType::try_from(self.stream_scan_type)
13392 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_scan_type)))?;
13393 struct_ser.serialize_field("streamScanType", &v)?;
13394 }
13395 if let Some(v) = self.state_table.as_ref() {
13396 struct_ser.serialize_field("stateTable", v)?;
13397 }
13398 if let Some(v) = self.table_desc.as_ref() {
13399 struct_ser.serialize_field("tableDesc", v)?;
13400 }
13401 if let Some(v) = self.rate_limit.as_ref() {
13402 struct_ser.serialize_field("rateLimit", v)?;
13403 }
13404 if self.snapshot_read_barrier_interval != 0 {
13405 struct_ser.serialize_field("snapshotReadBarrierInterval", &self.snapshot_read_barrier_interval)?;
13406 }
13407 if let Some(v) = self.arrangement_table.as_ref() {
13408 struct_ser.serialize_field("arrangementTable", v)?;
13409 }
13410 if let Some(v) = self.snapshot_backfill_epoch.as_ref() {
13411 #[allow(clippy::needless_borrow)]
13412 #[allow(clippy::needless_borrows_for_generic_args)]
13413 struct_ser.serialize_field("snapshotBackfillEpoch", ToString::to_string(&v).as_str())?;
13414 }
13415 struct_ser.end()
13416 }
13417}
13418impl<'de> serde::Deserialize<'de> for StreamScanNode {
13419 #[allow(deprecated)]
13420 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13421 where
13422 D: serde::Deserializer<'de>,
13423 {
13424 const FIELDS: &[&str] = &[
13425 "table_id",
13426 "tableId",
13427 "upstream_column_ids",
13428 "upstreamColumnIds",
13429 "output_indices",
13430 "outputIndices",
13431 "stream_scan_type",
13432 "streamScanType",
13433 "state_table",
13434 "stateTable",
13435 "table_desc",
13436 "tableDesc",
13437 "rate_limit",
13438 "rateLimit",
13439 "snapshot_read_barrier_interval",
13440 "snapshotReadBarrierInterval",
13441 "arrangement_table",
13442 "arrangementTable",
13443 "snapshot_backfill_epoch",
13444 "snapshotBackfillEpoch",
13445 ];
13446
13447 #[allow(clippy::enum_variant_names)]
13448 enum GeneratedField {
13449 TableId,
13450 UpstreamColumnIds,
13451 OutputIndices,
13452 StreamScanType,
13453 StateTable,
13454 TableDesc,
13455 RateLimit,
13456 SnapshotReadBarrierInterval,
13457 ArrangementTable,
13458 SnapshotBackfillEpoch,
13459 }
13460 impl<'de> serde::Deserialize<'de> for GeneratedField {
13461 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13462 where
13463 D: serde::Deserializer<'de>,
13464 {
13465 struct GeneratedVisitor;
13466
13467 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13468 type Value = GeneratedField;
13469
13470 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13471 write!(formatter, "expected one of: {:?}", &FIELDS)
13472 }
13473
13474 #[allow(unused_variables)]
13475 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13476 where
13477 E: serde::de::Error,
13478 {
13479 match value {
13480 "tableId" | "table_id" => Ok(GeneratedField::TableId),
13481 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
13482 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
13483 "streamScanType" | "stream_scan_type" => Ok(GeneratedField::StreamScanType),
13484 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
13485 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
13486 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
13487 "snapshotReadBarrierInterval" | "snapshot_read_barrier_interval" => Ok(GeneratedField::SnapshotReadBarrierInterval),
13488 "arrangementTable" | "arrangement_table" => Ok(GeneratedField::ArrangementTable),
13489 "snapshotBackfillEpoch" | "snapshot_backfill_epoch" => Ok(GeneratedField::SnapshotBackfillEpoch),
13490 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13491 }
13492 }
13493 }
13494 deserializer.deserialize_identifier(GeneratedVisitor)
13495 }
13496 }
13497 struct GeneratedVisitor;
13498 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13499 type Value = StreamScanNode;
13500
13501 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13502 formatter.write_str("struct stream_plan.StreamScanNode")
13503 }
13504
13505 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamScanNode, V::Error>
13506 where
13507 V: serde::de::MapAccess<'de>,
13508 {
13509 let mut table_id__ = None;
13510 let mut upstream_column_ids__ = None;
13511 let mut output_indices__ = None;
13512 let mut stream_scan_type__ = None;
13513 let mut state_table__ = None;
13514 let mut table_desc__ = None;
13515 let mut rate_limit__ = None;
13516 let mut snapshot_read_barrier_interval__ = None;
13517 let mut arrangement_table__ = None;
13518 let mut snapshot_backfill_epoch__ = None;
13519 while let Some(k) = map_.next_key()? {
13520 match k {
13521 GeneratedField::TableId => {
13522 if table_id__.is_some() {
13523 return Err(serde::de::Error::duplicate_field("tableId"));
13524 }
13525 table_id__ =
13526 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13527 ;
13528 }
13529 GeneratedField::UpstreamColumnIds => {
13530 if upstream_column_ids__.is_some() {
13531 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
13532 }
13533 upstream_column_ids__ =
13534 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13535 .into_iter().map(|x| x.0).collect())
13536 ;
13537 }
13538 GeneratedField::OutputIndices => {
13539 if output_indices__.is_some() {
13540 return Err(serde::de::Error::duplicate_field("outputIndices"));
13541 }
13542 output_indices__ =
13543 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13544 .into_iter().map(|x| x.0).collect())
13545 ;
13546 }
13547 GeneratedField::StreamScanType => {
13548 if stream_scan_type__.is_some() {
13549 return Err(serde::de::Error::duplicate_field("streamScanType"));
13550 }
13551 stream_scan_type__ = Some(map_.next_value::<StreamScanType>()? as i32);
13552 }
13553 GeneratedField::StateTable => {
13554 if state_table__.is_some() {
13555 return Err(serde::de::Error::duplicate_field("stateTable"));
13556 }
13557 state_table__ = map_.next_value()?;
13558 }
13559 GeneratedField::TableDesc => {
13560 if table_desc__.is_some() {
13561 return Err(serde::de::Error::duplicate_field("tableDesc"));
13562 }
13563 table_desc__ = map_.next_value()?;
13564 }
13565 GeneratedField::RateLimit => {
13566 if rate_limit__.is_some() {
13567 return Err(serde::de::Error::duplicate_field("rateLimit"));
13568 }
13569 rate_limit__ =
13570 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13571 ;
13572 }
13573 GeneratedField::SnapshotReadBarrierInterval => {
13574 if snapshot_read_barrier_interval__.is_some() {
13575 return Err(serde::de::Error::duplicate_field("snapshotReadBarrierInterval"));
13576 }
13577 snapshot_read_barrier_interval__ =
13578 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13579 ;
13580 }
13581 GeneratedField::ArrangementTable => {
13582 if arrangement_table__.is_some() {
13583 return Err(serde::de::Error::duplicate_field("arrangementTable"));
13584 }
13585 arrangement_table__ = map_.next_value()?;
13586 }
13587 GeneratedField::SnapshotBackfillEpoch => {
13588 if snapshot_backfill_epoch__.is_some() {
13589 return Err(serde::de::Error::duplicate_field("snapshotBackfillEpoch"));
13590 }
13591 snapshot_backfill_epoch__ =
13592 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13593 ;
13594 }
13595 }
13596 }
13597 Ok(StreamScanNode {
13598 table_id: table_id__.unwrap_or_default(),
13599 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
13600 output_indices: output_indices__.unwrap_or_default(),
13601 stream_scan_type: stream_scan_type__.unwrap_or_default(),
13602 state_table: state_table__,
13603 table_desc: table_desc__,
13604 rate_limit: rate_limit__,
13605 snapshot_read_barrier_interval: snapshot_read_barrier_interval__.unwrap_or_default(),
13606 arrangement_table: arrangement_table__,
13607 snapshot_backfill_epoch: snapshot_backfill_epoch__,
13608 })
13609 }
13610 }
13611 deserializer.deserialize_struct("stream_plan.StreamScanNode", FIELDS, GeneratedVisitor)
13612 }
13613}
13614impl serde::Serialize for StreamScanType {
13615 #[allow(deprecated)]
13616 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13617 where
13618 S: serde::Serializer,
13619 {
13620 let variant = match self {
13621 Self::Unspecified => "STREAM_SCAN_TYPE_UNSPECIFIED",
13622 Self::Chain => "STREAM_SCAN_TYPE_CHAIN",
13623 Self::Rearrange => "STREAM_SCAN_TYPE_REARRANGE",
13624 Self::Backfill => "STREAM_SCAN_TYPE_BACKFILL",
13625 Self::UpstreamOnly => "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
13626 Self::ArrangementBackfill => "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
13627 Self::SnapshotBackfill => "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
13628 Self::CrossDbSnapshotBackfill => "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
13629 };
13630 serializer.serialize_str(variant)
13631 }
13632}
13633impl<'de> serde::Deserialize<'de> for StreamScanType {
13634 #[allow(deprecated)]
13635 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13636 where
13637 D: serde::Deserializer<'de>,
13638 {
13639 const FIELDS: &[&str] = &[
13640 "STREAM_SCAN_TYPE_UNSPECIFIED",
13641 "STREAM_SCAN_TYPE_CHAIN",
13642 "STREAM_SCAN_TYPE_REARRANGE",
13643 "STREAM_SCAN_TYPE_BACKFILL",
13644 "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
13645 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
13646 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
13647 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
13648 ];
13649
13650 struct GeneratedVisitor;
13651
13652 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13653 type Value = StreamScanType;
13654
13655 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13656 write!(formatter, "expected one of: {:?}", &FIELDS)
13657 }
13658
13659 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13660 where
13661 E: serde::de::Error,
13662 {
13663 i32::try_from(v)
13664 .ok()
13665 .and_then(|x| x.try_into().ok())
13666 .ok_or_else(|| {
13667 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13668 })
13669 }
13670
13671 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13672 where
13673 E: serde::de::Error,
13674 {
13675 i32::try_from(v)
13676 .ok()
13677 .and_then(|x| x.try_into().ok())
13678 .ok_or_else(|| {
13679 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13680 })
13681 }
13682
13683 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13684 where
13685 E: serde::de::Error,
13686 {
13687 match value {
13688 "STREAM_SCAN_TYPE_UNSPECIFIED" => Ok(StreamScanType::Unspecified),
13689 "STREAM_SCAN_TYPE_CHAIN" => Ok(StreamScanType::Chain),
13690 "STREAM_SCAN_TYPE_REARRANGE" => Ok(StreamScanType::Rearrange),
13691 "STREAM_SCAN_TYPE_BACKFILL" => Ok(StreamScanType::Backfill),
13692 "STREAM_SCAN_TYPE_UPSTREAM_ONLY" => Ok(StreamScanType::UpstreamOnly),
13693 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL" => Ok(StreamScanType::ArrangementBackfill),
13694 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL" => Ok(StreamScanType::SnapshotBackfill),
13695 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL" => Ok(StreamScanType::CrossDbSnapshotBackfill),
13696 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13697 }
13698 }
13699 }
13700 deserializer.deserialize_any(GeneratedVisitor)
13701 }
13702}
13703impl serde::Serialize for StreamSource {
13704 #[allow(deprecated)]
13705 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13706 where
13707 S: serde::Serializer,
13708 {
13709 use serde::ser::SerializeStruct;
13710 let mut len = 0;
13711 if self.source_id != 0 {
13712 len += 1;
13713 }
13714 if self.state_table.is_some() {
13715 len += 1;
13716 }
13717 if self.row_id_index.is_some() {
13718 len += 1;
13719 }
13720 if !self.columns.is_empty() {
13721 len += 1;
13722 }
13723 if !self.with_properties.is_empty() {
13724 len += 1;
13725 }
13726 if self.info.is_some() {
13727 len += 1;
13728 }
13729 if !self.source_name.is_empty() {
13730 len += 1;
13731 }
13732 if self.rate_limit.is_some() {
13733 len += 1;
13734 }
13735 if !self.secret_refs.is_empty() {
13736 len += 1;
13737 }
13738 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamSource", len)?;
13739 if self.source_id != 0 {
13740 struct_ser.serialize_field("sourceId", &self.source_id)?;
13741 }
13742 if let Some(v) = self.state_table.as_ref() {
13743 struct_ser.serialize_field("stateTable", v)?;
13744 }
13745 if let Some(v) = self.row_id_index.as_ref() {
13746 struct_ser.serialize_field("rowIdIndex", v)?;
13747 }
13748 if !self.columns.is_empty() {
13749 struct_ser.serialize_field("columns", &self.columns)?;
13750 }
13751 if !self.with_properties.is_empty() {
13752 struct_ser.serialize_field("withProperties", &self.with_properties)?;
13753 }
13754 if let Some(v) = self.info.as_ref() {
13755 struct_ser.serialize_field("info", v)?;
13756 }
13757 if !self.source_name.is_empty() {
13758 struct_ser.serialize_field("sourceName", &self.source_name)?;
13759 }
13760 if let Some(v) = self.rate_limit.as_ref() {
13761 struct_ser.serialize_field("rateLimit", v)?;
13762 }
13763 if !self.secret_refs.is_empty() {
13764 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
13765 }
13766 struct_ser.end()
13767 }
13768}
13769impl<'de> serde::Deserialize<'de> for StreamSource {
13770 #[allow(deprecated)]
13771 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13772 where
13773 D: serde::Deserializer<'de>,
13774 {
13775 const FIELDS: &[&str] = &[
13776 "source_id",
13777 "sourceId",
13778 "state_table",
13779 "stateTable",
13780 "row_id_index",
13781 "rowIdIndex",
13782 "columns",
13783 "with_properties",
13784 "withProperties",
13785 "info",
13786 "source_name",
13787 "sourceName",
13788 "rate_limit",
13789 "rateLimit",
13790 "secret_refs",
13791 "secretRefs",
13792 ];
13793
13794 #[allow(clippy::enum_variant_names)]
13795 enum GeneratedField {
13796 SourceId,
13797 StateTable,
13798 RowIdIndex,
13799 Columns,
13800 WithProperties,
13801 Info,
13802 SourceName,
13803 RateLimit,
13804 SecretRefs,
13805 }
13806 impl<'de> serde::Deserialize<'de> for GeneratedField {
13807 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13808 where
13809 D: serde::Deserializer<'de>,
13810 {
13811 struct GeneratedVisitor;
13812
13813 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13814 type Value = GeneratedField;
13815
13816 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13817 write!(formatter, "expected one of: {:?}", &FIELDS)
13818 }
13819
13820 #[allow(unused_variables)]
13821 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13822 where
13823 E: serde::de::Error,
13824 {
13825 match value {
13826 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
13827 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
13828 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
13829 "columns" => Ok(GeneratedField::Columns),
13830 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
13831 "info" => Ok(GeneratedField::Info),
13832 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
13833 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
13834 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
13835 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13836 }
13837 }
13838 }
13839 deserializer.deserialize_identifier(GeneratedVisitor)
13840 }
13841 }
13842 struct GeneratedVisitor;
13843 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13844 type Value = StreamSource;
13845
13846 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13847 formatter.write_str("struct stream_plan.StreamSource")
13848 }
13849
13850 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSource, V::Error>
13851 where
13852 V: serde::de::MapAccess<'de>,
13853 {
13854 let mut source_id__ = None;
13855 let mut state_table__ = None;
13856 let mut row_id_index__ = None;
13857 let mut columns__ = None;
13858 let mut with_properties__ = None;
13859 let mut info__ = None;
13860 let mut source_name__ = None;
13861 let mut rate_limit__ = None;
13862 let mut secret_refs__ = None;
13863 while let Some(k) = map_.next_key()? {
13864 match k {
13865 GeneratedField::SourceId => {
13866 if source_id__.is_some() {
13867 return Err(serde::de::Error::duplicate_field("sourceId"));
13868 }
13869 source_id__ =
13870 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13871 ;
13872 }
13873 GeneratedField::StateTable => {
13874 if state_table__.is_some() {
13875 return Err(serde::de::Error::duplicate_field("stateTable"));
13876 }
13877 state_table__ = map_.next_value()?;
13878 }
13879 GeneratedField::RowIdIndex => {
13880 if row_id_index__.is_some() {
13881 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
13882 }
13883 row_id_index__ =
13884 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13885 ;
13886 }
13887 GeneratedField::Columns => {
13888 if columns__.is_some() {
13889 return Err(serde::de::Error::duplicate_field("columns"));
13890 }
13891 columns__ = Some(map_.next_value()?);
13892 }
13893 GeneratedField::WithProperties => {
13894 if with_properties__.is_some() {
13895 return Err(serde::de::Error::duplicate_field("withProperties"));
13896 }
13897 with_properties__ = Some(
13898 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13899 );
13900 }
13901 GeneratedField::Info => {
13902 if info__.is_some() {
13903 return Err(serde::de::Error::duplicate_field("info"));
13904 }
13905 info__ = map_.next_value()?;
13906 }
13907 GeneratedField::SourceName => {
13908 if source_name__.is_some() {
13909 return Err(serde::de::Error::duplicate_field("sourceName"));
13910 }
13911 source_name__ = Some(map_.next_value()?);
13912 }
13913 GeneratedField::RateLimit => {
13914 if rate_limit__.is_some() {
13915 return Err(serde::de::Error::duplicate_field("rateLimit"));
13916 }
13917 rate_limit__ =
13918 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13919 ;
13920 }
13921 GeneratedField::SecretRefs => {
13922 if secret_refs__.is_some() {
13923 return Err(serde::de::Error::duplicate_field("secretRefs"));
13924 }
13925 secret_refs__ = Some(
13926 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13927 );
13928 }
13929 }
13930 }
13931 Ok(StreamSource {
13932 source_id: source_id__.unwrap_or_default(),
13933 state_table: state_table__,
13934 row_id_index: row_id_index__,
13935 columns: columns__.unwrap_or_default(),
13936 with_properties: with_properties__.unwrap_or_default(),
13937 info: info__,
13938 source_name: source_name__.unwrap_or_default(),
13939 rate_limit: rate_limit__,
13940 secret_refs: secret_refs__.unwrap_or_default(),
13941 })
13942 }
13943 }
13944 deserializer.deserialize_struct("stream_plan.StreamSource", FIELDS, GeneratedVisitor)
13945 }
13946}
13947impl serde::Serialize for SubscriptionUpstreamInfo {
13948 #[allow(deprecated)]
13949 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13950 where
13951 S: serde::Serializer,
13952 {
13953 use serde::ser::SerializeStruct;
13954 let mut len = 0;
13955 if self.subscriber_id != 0 {
13956 len += 1;
13957 }
13958 if self.upstream_mv_table_id != 0 {
13959 len += 1;
13960 }
13961 let mut struct_ser = serializer.serialize_struct("stream_plan.SubscriptionUpstreamInfo", len)?;
13962 if self.subscriber_id != 0 {
13963 struct_ser.serialize_field("subscriberId", &self.subscriber_id)?;
13964 }
13965 if self.upstream_mv_table_id != 0 {
13966 struct_ser.serialize_field("upstreamMvTableId", &self.upstream_mv_table_id)?;
13967 }
13968 struct_ser.end()
13969 }
13970}
13971impl<'de> serde::Deserialize<'de> for SubscriptionUpstreamInfo {
13972 #[allow(deprecated)]
13973 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13974 where
13975 D: serde::Deserializer<'de>,
13976 {
13977 const FIELDS: &[&str] = &[
13978 "subscriber_id",
13979 "subscriberId",
13980 "upstream_mv_table_id",
13981 "upstreamMvTableId",
13982 ];
13983
13984 #[allow(clippy::enum_variant_names)]
13985 enum GeneratedField {
13986 SubscriberId,
13987 UpstreamMvTableId,
13988 }
13989 impl<'de> serde::Deserialize<'de> for GeneratedField {
13990 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13991 where
13992 D: serde::Deserializer<'de>,
13993 {
13994 struct GeneratedVisitor;
13995
13996 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13997 type Value = GeneratedField;
13998
13999 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14000 write!(formatter, "expected one of: {:?}", &FIELDS)
14001 }
14002
14003 #[allow(unused_variables)]
14004 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14005 where
14006 E: serde::de::Error,
14007 {
14008 match value {
14009 "subscriberId" | "subscriber_id" => Ok(GeneratedField::SubscriberId),
14010 "upstreamMvTableId" | "upstream_mv_table_id" => Ok(GeneratedField::UpstreamMvTableId),
14011 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14012 }
14013 }
14014 }
14015 deserializer.deserialize_identifier(GeneratedVisitor)
14016 }
14017 }
14018 struct GeneratedVisitor;
14019 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14020 type Value = SubscriptionUpstreamInfo;
14021
14022 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14023 formatter.write_str("struct stream_plan.SubscriptionUpstreamInfo")
14024 }
14025
14026 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscriptionUpstreamInfo, V::Error>
14027 where
14028 V: serde::de::MapAccess<'de>,
14029 {
14030 let mut subscriber_id__ = None;
14031 let mut upstream_mv_table_id__ = None;
14032 while let Some(k) = map_.next_key()? {
14033 match k {
14034 GeneratedField::SubscriberId => {
14035 if subscriber_id__.is_some() {
14036 return Err(serde::de::Error::duplicate_field("subscriberId"));
14037 }
14038 subscriber_id__ =
14039 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14040 ;
14041 }
14042 GeneratedField::UpstreamMvTableId => {
14043 if upstream_mv_table_id__.is_some() {
14044 return Err(serde::de::Error::duplicate_field("upstreamMvTableId"));
14045 }
14046 upstream_mv_table_id__ =
14047 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14048 ;
14049 }
14050 }
14051 }
14052 Ok(SubscriptionUpstreamInfo {
14053 subscriber_id: subscriber_id__.unwrap_or_default(),
14054 upstream_mv_table_id: upstream_mv_table_id__.unwrap_or_default(),
14055 })
14056 }
14057 }
14058 deserializer.deserialize_struct("stream_plan.SubscriptionUpstreamInfo", FIELDS, GeneratedVisitor)
14059 }
14060}
14061impl serde::Serialize for SyncLogStoreNode {
14062 #[allow(deprecated)]
14063 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14064 where
14065 S: serde::Serializer,
14066 {
14067 use serde::ser::SerializeStruct;
14068 let mut len = 0;
14069 if self.log_store_table.is_some() {
14070 len += 1;
14071 }
14072 if self.pause_duration_ms != 0 {
14073 len += 1;
14074 }
14075 if self.buffer_size != 0 {
14076 len += 1;
14077 }
14078 if self.aligned {
14079 len += 1;
14080 }
14081 let mut struct_ser = serializer.serialize_struct("stream_plan.SyncLogStoreNode", len)?;
14082 if let Some(v) = self.log_store_table.as_ref() {
14083 struct_ser.serialize_field("logStoreTable", v)?;
14084 }
14085 if self.pause_duration_ms != 0 {
14086 struct_ser.serialize_field("pauseDurationMs", &self.pause_duration_ms)?;
14087 }
14088 if self.buffer_size != 0 {
14089 struct_ser.serialize_field("bufferSize", &self.buffer_size)?;
14090 }
14091 if self.aligned {
14092 struct_ser.serialize_field("aligned", &self.aligned)?;
14093 }
14094 struct_ser.end()
14095 }
14096}
14097impl<'de> serde::Deserialize<'de> for SyncLogStoreNode {
14098 #[allow(deprecated)]
14099 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14100 where
14101 D: serde::Deserializer<'de>,
14102 {
14103 const FIELDS: &[&str] = &[
14104 "log_store_table",
14105 "logStoreTable",
14106 "pause_duration_ms",
14107 "pauseDurationMs",
14108 "buffer_size",
14109 "bufferSize",
14110 "aligned",
14111 ];
14112
14113 #[allow(clippy::enum_variant_names)]
14114 enum GeneratedField {
14115 LogStoreTable,
14116 PauseDurationMs,
14117 BufferSize,
14118 Aligned,
14119 }
14120 impl<'de> serde::Deserialize<'de> for GeneratedField {
14121 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14122 where
14123 D: serde::Deserializer<'de>,
14124 {
14125 struct GeneratedVisitor;
14126
14127 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14128 type Value = GeneratedField;
14129
14130 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14131 write!(formatter, "expected one of: {:?}", &FIELDS)
14132 }
14133
14134 #[allow(unused_variables)]
14135 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14136 where
14137 E: serde::de::Error,
14138 {
14139 match value {
14140 "logStoreTable" | "log_store_table" => Ok(GeneratedField::LogStoreTable),
14141 "pauseDurationMs" | "pause_duration_ms" => Ok(GeneratedField::PauseDurationMs),
14142 "bufferSize" | "buffer_size" => Ok(GeneratedField::BufferSize),
14143 "aligned" => Ok(GeneratedField::Aligned),
14144 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14145 }
14146 }
14147 }
14148 deserializer.deserialize_identifier(GeneratedVisitor)
14149 }
14150 }
14151 struct GeneratedVisitor;
14152 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14153 type Value = SyncLogStoreNode;
14154
14155 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14156 formatter.write_str("struct stream_plan.SyncLogStoreNode")
14157 }
14158
14159 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SyncLogStoreNode, V::Error>
14160 where
14161 V: serde::de::MapAccess<'de>,
14162 {
14163 let mut log_store_table__ = None;
14164 let mut pause_duration_ms__ = None;
14165 let mut buffer_size__ = None;
14166 let mut aligned__ = None;
14167 while let Some(k) = map_.next_key()? {
14168 match k {
14169 GeneratedField::LogStoreTable => {
14170 if log_store_table__.is_some() {
14171 return Err(serde::de::Error::duplicate_field("logStoreTable"));
14172 }
14173 log_store_table__ = map_.next_value()?;
14174 }
14175 GeneratedField::PauseDurationMs => {
14176 if pause_duration_ms__.is_some() {
14177 return Err(serde::de::Error::duplicate_field("pauseDurationMs"));
14178 }
14179 pause_duration_ms__ =
14180 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14181 ;
14182 }
14183 GeneratedField::BufferSize => {
14184 if buffer_size__.is_some() {
14185 return Err(serde::de::Error::duplicate_field("bufferSize"));
14186 }
14187 buffer_size__ =
14188 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14189 ;
14190 }
14191 GeneratedField::Aligned => {
14192 if aligned__.is_some() {
14193 return Err(serde::de::Error::duplicate_field("aligned"));
14194 }
14195 aligned__ = Some(map_.next_value()?);
14196 }
14197 }
14198 }
14199 Ok(SyncLogStoreNode {
14200 log_store_table: log_store_table__,
14201 pause_duration_ms: pause_duration_ms__.unwrap_or_default(),
14202 buffer_size: buffer_size__.unwrap_or_default(),
14203 aligned: aligned__.unwrap_or_default(),
14204 })
14205 }
14206 }
14207 deserializer.deserialize_struct("stream_plan.SyncLogStoreNode", FIELDS, GeneratedVisitor)
14208 }
14209}
14210impl serde::Serialize for TemporalJoinNode {
14211 #[allow(deprecated)]
14212 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14213 where
14214 S: serde::Serializer,
14215 {
14216 use serde::ser::SerializeStruct;
14217 let mut len = 0;
14218 if self.join_type != 0 {
14219 len += 1;
14220 }
14221 if !self.left_key.is_empty() {
14222 len += 1;
14223 }
14224 if !self.right_key.is_empty() {
14225 len += 1;
14226 }
14227 if !self.null_safe.is_empty() {
14228 len += 1;
14229 }
14230 if self.condition.is_some() {
14231 len += 1;
14232 }
14233 if !self.output_indices.is_empty() {
14234 len += 1;
14235 }
14236 if self.table_desc.is_some() {
14237 len += 1;
14238 }
14239 if !self.table_output_indices.is_empty() {
14240 len += 1;
14241 }
14242 if self.memo_table.is_some() {
14243 len += 1;
14244 }
14245 if self.is_nested_loop {
14246 len += 1;
14247 }
14248 let mut struct_ser = serializer.serialize_struct("stream_plan.TemporalJoinNode", len)?;
14249 if self.join_type != 0 {
14250 let v = super::plan_common::JoinType::try_from(self.join_type)
14251 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
14252 struct_ser.serialize_field("joinType", &v)?;
14253 }
14254 if !self.left_key.is_empty() {
14255 struct_ser.serialize_field("leftKey", &self.left_key)?;
14256 }
14257 if !self.right_key.is_empty() {
14258 struct_ser.serialize_field("rightKey", &self.right_key)?;
14259 }
14260 if !self.null_safe.is_empty() {
14261 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
14262 }
14263 if let Some(v) = self.condition.as_ref() {
14264 struct_ser.serialize_field("condition", v)?;
14265 }
14266 if !self.output_indices.is_empty() {
14267 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
14268 }
14269 if let Some(v) = self.table_desc.as_ref() {
14270 struct_ser.serialize_field("tableDesc", v)?;
14271 }
14272 if !self.table_output_indices.is_empty() {
14273 struct_ser.serialize_field("tableOutputIndices", &self.table_output_indices)?;
14274 }
14275 if let Some(v) = self.memo_table.as_ref() {
14276 struct_ser.serialize_field("memoTable", v)?;
14277 }
14278 if self.is_nested_loop {
14279 struct_ser.serialize_field("isNestedLoop", &self.is_nested_loop)?;
14280 }
14281 struct_ser.end()
14282 }
14283}
14284impl<'de> serde::Deserialize<'de> for TemporalJoinNode {
14285 #[allow(deprecated)]
14286 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14287 where
14288 D: serde::Deserializer<'de>,
14289 {
14290 const FIELDS: &[&str] = &[
14291 "join_type",
14292 "joinType",
14293 "left_key",
14294 "leftKey",
14295 "right_key",
14296 "rightKey",
14297 "null_safe",
14298 "nullSafe",
14299 "condition",
14300 "output_indices",
14301 "outputIndices",
14302 "table_desc",
14303 "tableDesc",
14304 "table_output_indices",
14305 "tableOutputIndices",
14306 "memo_table",
14307 "memoTable",
14308 "is_nested_loop",
14309 "isNestedLoop",
14310 ];
14311
14312 #[allow(clippy::enum_variant_names)]
14313 enum GeneratedField {
14314 JoinType,
14315 LeftKey,
14316 RightKey,
14317 NullSafe,
14318 Condition,
14319 OutputIndices,
14320 TableDesc,
14321 TableOutputIndices,
14322 MemoTable,
14323 IsNestedLoop,
14324 }
14325 impl<'de> serde::Deserialize<'de> for GeneratedField {
14326 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14327 where
14328 D: serde::Deserializer<'de>,
14329 {
14330 struct GeneratedVisitor;
14331
14332 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14333 type Value = GeneratedField;
14334
14335 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14336 write!(formatter, "expected one of: {:?}", &FIELDS)
14337 }
14338
14339 #[allow(unused_variables)]
14340 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14341 where
14342 E: serde::de::Error,
14343 {
14344 match value {
14345 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
14346 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
14347 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
14348 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
14349 "condition" => Ok(GeneratedField::Condition),
14350 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
14351 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
14352 "tableOutputIndices" | "table_output_indices" => Ok(GeneratedField::TableOutputIndices),
14353 "memoTable" | "memo_table" => Ok(GeneratedField::MemoTable),
14354 "isNestedLoop" | "is_nested_loop" => Ok(GeneratedField::IsNestedLoop),
14355 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14356 }
14357 }
14358 }
14359 deserializer.deserialize_identifier(GeneratedVisitor)
14360 }
14361 }
14362 struct GeneratedVisitor;
14363 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14364 type Value = TemporalJoinNode;
14365
14366 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14367 formatter.write_str("struct stream_plan.TemporalJoinNode")
14368 }
14369
14370 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TemporalJoinNode, V::Error>
14371 where
14372 V: serde::de::MapAccess<'de>,
14373 {
14374 let mut join_type__ = None;
14375 let mut left_key__ = None;
14376 let mut right_key__ = None;
14377 let mut null_safe__ = None;
14378 let mut condition__ = None;
14379 let mut output_indices__ = None;
14380 let mut table_desc__ = None;
14381 let mut table_output_indices__ = None;
14382 let mut memo_table__ = None;
14383 let mut is_nested_loop__ = None;
14384 while let Some(k) = map_.next_key()? {
14385 match k {
14386 GeneratedField::JoinType => {
14387 if join_type__.is_some() {
14388 return Err(serde::de::Error::duplicate_field("joinType"));
14389 }
14390 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
14391 }
14392 GeneratedField::LeftKey => {
14393 if left_key__.is_some() {
14394 return Err(serde::de::Error::duplicate_field("leftKey"));
14395 }
14396 left_key__ =
14397 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14398 .into_iter().map(|x| x.0).collect())
14399 ;
14400 }
14401 GeneratedField::RightKey => {
14402 if right_key__.is_some() {
14403 return Err(serde::de::Error::duplicate_field("rightKey"));
14404 }
14405 right_key__ =
14406 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14407 .into_iter().map(|x| x.0).collect())
14408 ;
14409 }
14410 GeneratedField::NullSafe => {
14411 if null_safe__.is_some() {
14412 return Err(serde::de::Error::duplicate_field("nullSafe"));
14413 }
14414 null_safe__ = Some(map_.next_value()?);
14415 }
14416 GeneratedField::Condition => {
14417 if condition__.is_some() {
14418 return Err(serde::de::Error::duplicate_field("condition"));
14419 }
14420 condition__ = map_.next_value()?;
14421 }
14422 GeneratedField::OutputIndices => {
14423 if output_indices__.is_some() {
14424 return Err(serde::de::Error::duplicate_field("outputIndices"));
14425 }
14426 output_indices__ =
14427 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14428 .into_iter().map(|x| x.0).collect())
14429 ;
14430 }
14431 GeneratedField::TableDesc => {
14432 if table_desc__.is_some() {
14433 return Err(serde::de::Error::duplicate_field("tableDesc"));
14434 }
14435 table_desc__ = map_.next_value()?;
14436 }
14437 GeneratedField::TableOutputIndices => {
14438 if table_output_indices__.is_some() {
14439 return Err(serde::de::Error::duplicate_field("tableOutputIndices"));
14440 }
14441 table_output_indices__ =
14442 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14443 .into_iter().map(|x| x.0).collect())
14444 ;
14445 }
14446 GeneratedField::MemoTable => {
14447 if memo_table__.is_some() {
14448 return Err(serde::de::Error::duplicate_field("memoTable"));
14449 }
14450 memo_table__ = map_.next_value()?;
14451 }
14452 GeneratedField::IsNestedLoop => {
14453 if is_nested_loop__.is_some() {
14454 return Err(serde::de::Error::duplicate_field("isNestedLoop"));
14455 }
14456 is_nested_loop__ = Some(map_.next_value()?);
14457 }
14458 }
14459 }
14460 Ok(TemporalJoinNode {
14461 join_type: join_type__.unwrap_or_default(),
14462 left_key: left_key__.unwrap_or_default(),
14463 right_key: right_key__.unwrap_or_default(),
14464 null_safe: null_safe__.unwrap_or_default(),
14465 condition: condition__,
14466 output_indices: output_indices__.unwrap_or_default(),
14467 table_desc: table_desc__,
14468 table_output_indices: table_output_indices__.unwrap_or_default(),
14469 memo_table: memo_table__,
14470 is_nested_loop: is_nested_loop__.unwrap_or_default(),
14471 })
14472 }
14473 }
14474 deserializer.deserialize_struct("stream_plan.TemporalJoinNode", FIELDS, GeneratedVisitor)
14475 }
14476}
14477impl serde::Serialize for ThrottleMutation {
14478 #[allow(deprecated)]
14479 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14480 where
14481 S: serde::Serializer,
14482 {
14483 use serde::ser::SerializeStruct;
14484 let mut len = 0;
14485 if !self.actor_throttle.is_empty() {
14486 len += 1;
14487 }
14488 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation", len)?;
14489 if !self.actor_throttle.is_empty() {
14490 struct_ser.serialize_field("actorThrottle", &self.actor_throttle)?;
14491 }
14492 struct_ser.end()
14493 }
14494}
14495impl<'de> serde::Deserialize<'de> for ThrottleMutation {
14496 #[allow(deprecated)]
14497 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14498 where
14499 D: serde::Deserializer<'de>,
14500 {
14501 const FIELDS: &[&str] = &[
14502 "actor_throttle",
14503 "actorThrottle",
14504 ];
14505
14506 #[allow(clippy::enum_variant_names)]
14507 enum GeneratedField {
14508 ActorThrottle,
14509 }
14510 impl<'de> serde::Deserialize<'de> for GeneratedField {
14511 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14512 where
14513 D: serde::Deserializer<'de>,
14514 {
14515 struct GeneratedVisitor;
14516
14517 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14518 type Value = GeneratedField;
14519
14520 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14521 write!(formatter, "expected one of: {:?}", &FIELDS)
14522 }
14523
14524 #[allow(unused_variables)]
14525 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14526 where
14527 E: serde::de::Error,
14528 {
14529 match value {
14530 "actorThrottle" | "actor_throttle" => Ok(GeneratedField::ActorThrottle),
14531 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14532 }
14533 }
14534 }
14535 deserializer.deserialize_identifier(GeneratedVisitor)
14536 }
14537 }
14538 struct GeneratedVisitor;
14539 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14540 type Value = ThrottleMutation;
14541
14542 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14543 formatter.write_str("struct stream_plan.ThrottleMutation")
14544 }
14545
14546 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ThrottleMutation, V::Error>
14547 where
14548 V: serde::de::MapAccess<'de>,
14549 {
14550 let mut actor_throttle__ = None;
14551 while let Some(k) = map_.next_key()? {
14552 match k {
14553 GeneratedField::ActorThrottle => {
14554 if actor_throttle__.is_some() {
14555 return Err(serde::de::Error::duplicate_field("actorThrottle"));
14556 }
14557 actor_throttle__ = Some(
14558 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14559 .into_iter().map(|(k,v)| (k.0, v)).collect()
14560 );
14561 }
14562 }
14563 }
14564 Ok(ThrottleMutation {
14565 actor_throttle: actor_throttle__.unwrap_or_default(),
14566 })
14567 }
14568 }
14569 deserializer.deserialize_struct("stream_plan.ThrottleMutation", FIELDS, GeneratedVisitor)
14570 }
14571}
14572impl serde::Serialize for throttle_mutation::RateLimit {
14573 #[allow(deprecated)]
14574 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14575 where
14576 S: serde::Serializer,
14577 {
14578 use serde::ser::SerializeStruct;
14579 let mut len = 0;
14580 if self.rate_limit.is_some() {
14581 len += 1;
14582 }
14583 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation.RateLimit", len)?;
14584 if let Some(v) = self.rate_limit.as_ref() {
14585 struct_ser.serialize_field("rateLimit", v)?;
14586 }
14587 struct_ser.end()
14588 }
14589}
14590impl<'de> serde::Deserialize<'de> for throttle_mutation::RateLimit {
14591 #[allow(deprecated)]
14592 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14593 where
14594 D: serde::Deserializer<'de>,
14595 {
14596 const FIELDS: &[&str] = &[
14597 "rate_limit",
14598 "rateLimit",
14599 ];
14600
14601 #[allow(clippy::enum_variant_names)]
14602 enum GeneratedField {
14603 RateLimit,
14604 }
14605 impl<'de> serde::Deserialize<'de> for GeneratedField {
14606 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14607 where
14608 D: serde::Deserializer<'de>,
14609 {
14610 struct GeneratedVisitor;
14611
14612 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14613 type Value = GeneratedField;
14614
14615 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14616 write!(formatter, "expected one of: {:?}", &FIELDS)
14617 }
14618
14619 #[allow(unused_variables)]
14620 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14621 where
14622 E: serde::de::Error,
14623 {
14624 match value {
14625 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
14626 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14627 }
14628 }
14629 }
14630 deserializer.deserialize_identifier(GeneratedVisitor)
14631 }
14632 }
14633 struct GeneratedVisitor;
14634 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14635 type Value = throttle_mutation::RateLimit;
14636
14637 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14638 formatter.write_str("struct stream_plan.ThrottleMutation.RateLimit")
14639 }
14640
14641 fn visit_map<V>(self, mut map_: V) -> std::result::Result<throttle_mutation::RateLimit, V::Error>
14642 where
14643 V: serde::de::MapAccess<'de>,
14644 {
14645 let mut rate_limit__ = None;
14646 while let Some(k) = map_.next_key()? {
14647 match k {
14648 GeneratedField::RateLimit => {
14649 if rate_limit__.is_some() {
14650 return Err(serde::de::Error::duplicate_field("rateLimit"));
14651 }
14652 rate_limit__ =
14653 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14654 ;
14655 }
14656 }
14657 }
14658 Ok(throttle_mutation::RateLimit {
14659 rate_limit: rate_limit__,
14660 })
14661 }
14662 }
14663 deserializer.deserialize_struct("stream_plan.ThrottleMutation.RateLimit", FIELDS, GeneratedVisitor)
14664 }
14665}
14666impl serde::Serialize for TopNNode {
14667 #[allow(deprecated)]
14668 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14669 where
14670 S: serde::Serializer,
14671 {
14672 use serde::ser::SerializeStruct;
14673 let mut len = 0;
14674 if self.limit != 0 {
14675 len += 1;
14676 }
14677 if self.offset != 0 {
14678 len += 1;
14679 }
14680 if self.table.is_some() {
14681 len += 1;
14682 }
14683 if !self.order_by.is_empty() {
14684 len += 1;
14685 }
14686 if self.with_ties {
14687 len += 1;
14688 }
14689 let mut struct_ser = serializer.serialize_struct("stream_plan.TopNNode", len)?;
14690 if self.limit != 0 {
14691 #[allow(clippy::needless_borrow)]
14692 #[allow(clippy::needless_borrows_for_generic_args)]
14693 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
14694 }
14695 if self.offset != 0 {
14696 #[allow(clippy::needless_borrow)]
14697 #[allow(clippy::needless_borrows_for_generic_args)]
14698 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
14699 }
14700 if let Some(v) = self.table.as_ref() {
14701 struct_ser.serialize_field("table", v)?;
14702 }
14703 if !self.order_by.is_empty() {
14704 struct_ser.serialize_field("orderBy", &self.order_by)?;
14705 }
14706 if self.with_ties {
14707 struct_ser.serialize_field("withTies", &self.with_ties)?;
14708 }
14709 struct_ser.end()
14710 }
14711}
14712impl<'de> serde::Deserialize<'de> for TopNNode {
14713 #[allow(deprecated)]
14714 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14715 where
14716 D: serde::Deserializer<'de>,
14717 {
14718 const FIELDS: &[&str] = &[
14719 "limit",
14720 "offset",
14721 "table",
14722 "order_by",
14723 "orderBy",
14724 "with_ties",
14725 "withTies",
14726 ];
14727
14728 #[allow(clippy::enum_variant_names)]
14729 enum GeneratedField {
14730 Limit,
14731 Offset,
14732 Table,
14733 OrderBy,
14734 WithTies,
14735 }
14736 impl<'de> serde::Deserialize<'de> for GeneratedField {
14737 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14738 where
14739 D: serde::Deserializer<'de>,
14740 {
14741 struct GeneratedVisitor;
14742
14743 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14744 type Value = GeneratedField;
14745
14746 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14747 write!(formatter, "expected one of: {:?}", &FIELDS)
14748 }
14749
14750 #[allow(unused_variables)]
14751 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14752 where
14753 E: serde::de::Error,
14754 {
14755 match value {
14756 "limit" => Ok(GeneratedField::Limit),
14757 "offset" => Ok(GeneratedField::Offset),
14758 "table" => Ok(GeneratedField::Table),
14759 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
14760 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
14761 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14762 }
14763 }
14764 }
14765 deserializer.deserialize_identifier(GeneratedVisitor)
14766 }
14767 }
14768 struct GeneratedVisitor;
14769 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14770 type Value = TopNNode;
14771
14772 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14773 formatter.write_str("struct stream_plan.TopNNode")
14774 }
14775
14776 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
14777 where
14778 V: serde::de::MapAccess<'de>,
14779 {
14780 let mut limit__ = None;
14781 let mut offset__ = None;
14782 let mut table__ = None;
14783 let mut order_by__ = None;
14784 let mut with_ties__ = None;
14785 while let Some(k) = map_.next_key()? {
14786 match k {
14787 GeneratedField::Limit => {
14788 if limit__.is_some() {
14789 return Err(serde::de::Error::duplicate_field("limit"));
14790 }
14791 limit__ =
14792 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14793 ;
14794 }
14795 GeneratedField::Offset => {
14796 if offset__.is_some() {
14797 return Err(serde::de::Error::duplicate_field("offset"));
14798 }
14799 offset__ =
14800 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14801 ;
14802 }
14803 GeneratedField::Table => {
14804 if table__.is_some() {
14805 return Err(serde::de::Error::duplicate_field("table"));
14806 }
14807 table__ = map_.next_value()?;
14808 }
14809 GeneratedField::OrderBy => {
14810 if order_by__.is_some() {
14811 return Err(serde::de::Error::duplicate_field("orderBy"));
14812 }
14813 order_by__ = Some(map_.next_value()?);
14814 }
14815 GeneratedField::WithTies => {
14816 if with_ties__.is_some() {
14817 return Err(serde::de::Error::duplicate_field("withTies"));
14818 }
14819 with_ties__ = Some(map_.next_value()?);
14820 }
14821 }
14822 }
14823 Ok(TopNNode {
14824 limit: limit__.unwrap_or_default(),
14825 offset: offset__.unwrap_or_default(),
14826 table: table__,
14827 order_by: order_by__.unwrap_or_default(),
14828 with_ties: with_ties__.unwrap_or_default(),
14829 })
14830 }
14831 }
14832 deserializer.deserialize_struct("stream_plan.TopNNode", FIELDS, GeneratedVisitor)
14833 }
14834}
14835impl serde::Serialize for UnionNode {
14836 #[allow(deprecated)]
14837 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14838 where
14839 S: serde::Serializer,
14840 {
14841 use serde::ser::SerializeStruct;
14842 let len = 0;
14843 let struct_ser = serializer.serialize_struct("stream_plan.UnionNode", len)?;
14844 struct_ser.end()
14845 }
14846}
14847impl<'de> serde::Deserialize<'de> for UnionNode {
14848 #[allow(deprecated)]
14849 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14850 where
14851 D: serde::Deserializer<'de>,
14852 {
14853 const FIELDS: &[&str] = &[
14854 ];
14855
14856 #[allow(clippy::enum_variant_names)]
14857 enum GeneratedField {
14858 }
14859 impl<'de> serde::Deserialize<'de> for GeneratedField {
14860 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14861 where
14862 D: serde::Deserializer<'de>,
14863 {
14864 struct GeneratedVisitor;
14865
14866 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14867 type Value = GeneratedField;
14868
14869 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14870 write!(formatter, "expected one of: {:?}", &FIELDS)
14871 }
14872
14873 #[allow(unused_variables)]
14874 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14875 where
14876 E: serde::de::Error,
14877 {
14878 Err(serde::de::Error::unknown_field(value, FIELDS))
14879 }
14880 }
14881 deserializer.deserialize_identifier(GeneratedVisitor)
14882 }
14883 }
14884 struct GeneratedVisitor;
14885 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14886 type Value = UnionNode;
14887
14888 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14889 formatter.write_str("struct stream_plan.UnionNode")
14890 }
14891
14892 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
14893 where
14894 V: serde::de::MapAccess<'de>,
14895 {
14896 while map_.next_key::<GeneratedField>()?.is_some() {
14897 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14898 }
14899 Ok(UnionNode {
14900 })
14901 }
14902 }
14903 deserializer.deserialize_struct("stream_plan.UnionNode", FIELDS, GeneratedVisitor)
14904 }
14905}
14906impl serde::Serialize for UpdateMutation {
14907 #[allow(deprecated)]
14908 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14909 where
14910 S: serde::Serializer,
14911 {
14912 use serde::ser::SerializeStruct;
14913 let mut len = 0;
14914 if !self.dispatcher_update.is_empty() {
14915 len += 1;
14916 }
14917 if !self.merge_update.is_empty() {
14918 len += 1;
14919 }
14920 if !self.actor_vnode_bitmap_update.is_empty() {
14921 len += 1;
14922 }
14923 if !self.dropped_actors.is_empty() {
14924 len += 1;
14925 }
14926 if !self.actor_splits.is_empty() {
14927 len += 1;
14928 }
14929 if !self.actor_new_dispatchers.is_empty() {
14930 len += 1;
14931 }
14932 if self.actor_cdc_table_snapshot_splits.is_some() {
14933 len += 1;
14934 }
14935 if !self.sink_add_columns.is_empty() {
14936 len += 1;
14937 }
14938 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation", len)?;
14939 if !self.dispatcher_update.is_empty() {
14940 struct_ser.serialize_field("dispatcherUpdate", &self.dispatcher_update)?;
14941 }
14942 if !self.merge_update.is_empty() {
14943 struct_ser.serialize_field("mergeUpdate", &self.merge_update)?;
14944 }
14945 if !self.actor_vnode_bitmap_update.is_empty() {
14946 struct_ser.serialize_field("actorVnodeBitmapUpdate", &self.actor_vnode_bitmap_update)?;
14947 }
14948 if !self.dropped_actors.is_empty() {
14949 struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
14950 }
14951 if !self.actor_splits.is_empty() {
14952 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
14953 }
14954 if !self.actor_new_dispatchers.is_empty() {
14955 struct_ser.serialize_field("actorNewDispatchers", &self.actor_new_dispatchers)?;
14956 }
14957 if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
14958 struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
14959 }
14960 if !self.sink_add_columns.is_empty() {
14961 struct_ser.serialize_field("sinkAddColumns", &self.sink_add_columns)?;
14962 }
14963 struct_ser.end()
14964 }
14965}
14966impl<'de> serde::Deserialize<'de> for UpdateMutation {
14967 #[allow(deprecated)]
14968 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14969 where
14970 D: serde::Deserializer<'de>,
14971 {
14972 const FIELDS: &[&str] = &[
14973 "dispatcher_update",
14974 "dispatcherUpdate",
14975 "merge_update",
14976 "mergeUpdate",
14977 "actor_vnode_bitmap_update",
14978 "actorVnodeBitmapUpdate",
14979 "dropped_actors",
14980 "droppedActors",
14981 "actor_splits",
14982 "actorSplits",
14983 "actor_new_dispatchers",
14984 "actorNewDispatchers",
14985 "actor_cdc_table_snapshot_splits",
14986 "actorCdcTableSnapshotSplits",
14987 "sink_add_columns",
14988 "sinkAddColumns",
14989 ];
14990
14991 #[allow(clippy::enum_variant_names)]
14992 enum GeneratedField {
14993 DispatcherUpdate,
14994 MergeUpdate,
14995 ActorVnodeBitmapUpdate,
14996 DroppedActors,
14997 ActorSplits,
14998 ActorNewDispatchers,
14999 ActorCdcTableSnapshotSplits,
15000 SinkAddColumns,
15001 }
15002 impl<'de> serde::Deserialize<'de> for GeneratedField {
15003 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15004 where
15005 D: serde::Deserializer<'de>,
15006 {
15007 struct GeneratedVisitor;
15008
15009 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15010 type Value = GeneratedField;
15011
15012 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15013 write!(formatter, "expected one of: {:?}", &FIELDS)
15014 }
15015
15016 #[allow(unused_variables)]
15017 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15018 where
15019 E: serde::de::Error,
15020 {
15021 match value {
15022 "dispatcherUpdate" | "dispatcher_update" => Ok(GeneratedField::DispatcherUpdate),
15023 "mergeUpdate" | "merge_update" => Ok(GeneratedField::MergeUpdate),
15024 "actorVnodeBitmapUpdate" | "actor_vnode_bitmap_update" => Ok(GeneratedField::ActorVnodeBitmapUpdate),
15025 "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
15026 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
15027 "actorNewDispatchers" | "actor_new_dispatchers" => Ok(GeneratedField::ActorNewDispatchers),
15028 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
15029 "sinkAddColumns" | "sink_add_columns" => Ok(GeneratedField::SinkAddColumns),
15030 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15031 }
15032 }
15033 }
15034 deserializer.deserialize_identifier(GeneratedVisitor)
15035 }
15036 }
15037 struct GeneratedVisitor;
15038 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15039 type Value = UpdateMutation;
15040
15041 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15042 formatter.write_str("struct stream_plan.UpdateMutation")
15043 }
15044
15045 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateMutation, V::Error>
15046 where
15047 V: serde::de::MapAccess<'de>,
15048 {
15049 let mut dispatcher_update__ = None;
15050 let mut merge_update__ = None;
15051 let mut actor_vnode_bitmap_update__ = None;
15052 let mut dropped_actors__ = None;
15053 let mut actor_splits__ = None;
15054 let mut actor_new_dispatchers__ = None;
15055 let mut actor_cdc_table_snapshot_splits__ = None;
15056 let mut sink_add_columns__ = None;
15057 while let Some(k) = map_.next_key()? {
15058 match k {
15059 GeneratedField::DispatcherUpdate => {
15060 if dispatcher_update__.is_some() {
15061 return Err(serde::de::Error::duplicate_field("dispatcherUpdate"));
15062 }
15063 dispatcher_update__ = Some(map_.next_value()?);
15064 }
15065 GeneratedField::MergeUpdate => {
15066 if merge_update__.is_some() {
15067 return Err(serde::de::Error::duplicate_field("mergeUpdate"));
15068 }
15069 merge_update__ = Some(map_.next_value()?);
15070 }
15071 GeneratedField::ActorVnodeBitmapUpdate => {
15072 if actor_vnode_bitmap_update__.is_some() {
15073 return Err(serde::de::Error::duplicate_field("actorVnodeBitmapUpdate"));
15074 }
15075 actor_vnode_bitmap_update__ = Some(
15076 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15077 .into_iter().map(|(k,v)| (k.0, v)).collect()
15078 );
15079 }
15080 GeneratedField::DroppedActors => {
15081 if dropped_actors__.is_some() {
15082 return Err(serde::de::Error::duplicate_field("droppedActors"));
15083 }
15084 dropped_actors__ =
15085 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15086 .into_iter().map(|x| x.0).collect())
15087 ;
15088 }
15089 GeneratedField::ActorSplits => {
15090 if actor_splits__.is_some() {
15091 return Err(serde::de::Error::duplicate_field("actorSplits"));
15092 }
15093 actor_splits__ = Some(
15094 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15095 .into_iter().map(|(k,v)| (k.0, v)).collect()
15096 );
15097 }
15098 GeneratedField::ActorNewDispatchers => {
15099 if actor_new_dispatchers__.is_some() {
15100 return Err(serde::de::Error::duplicate_field("actorNewDispatchers"));
15101 }
15102 actor_new_dispatchers__ = Some(
15103 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15104 .into_iter().map(|(k,v)| (k.0, v)).collect()
15105 );
15106 }
15107 GeneratedField::ActorCdcTableSnapshotSplits => {
15108 if actor_cdc_table_snapshot_splits__.is_some() {
15109 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
15110 }
15111 actor_cdc_table_snapshot_splits__ = map_.next_value()?;
15112 }
15113 GeneratedField::SinkAddColumns => {
15114 if sink_add_columns__.is_some() {
15115 return Err(serde::de::Error::duplicate_field("sinkAddColumns"));
15116 }
15117 sink_add_columns__ = Some(
15118 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15119 .into_iter().map(|(k,v)| (k.0, v)).collect()
15120 );
15121 }
15122 }
15123 }
15124 Ok(UpdateMutation {
15125 dispatcher_update: dispatcher_update__.unwrap_or_default(),
15126 merge_update: merge_update__.unwrap_or_default(),
15127 actor_vnode_bitmap_update: actor_vnode_bitmap_update__.unwrap_or_default(),
15128 dropped_actors: dropped_actors__.unwrap_or_default(),
15129 actor_splits: actor_splits__.unwrap_or_default(),
15130 actor_new_dispatchers: actor_new_dispatchers__.unwrap_or_default(),
15131 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
15132 sink_add_columns: sink_add_columns__.unwrap_or_default(),
15133 })
15134 }
15135 }
15136 deserializer.deserialize_struct("stream_plan.UpdateMutation", FIELDS, GeneratedVisitor)
15137 }
15138}
15139impl serde::Serialize for update_mutation::DispatcherUpdate {
15140 #[allow(deprecated)]
15141 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15142 where
15143 S: serde::Serializer,
15144 {
15145 use serde::ser::SerializeStruct;
15146 let mut len = 0;
15147 if self.actor_id != 0 {
15148 len += 1;
15149 }
15150 if self.dispatcher_id != 0 {
15151 len += 1;
15152 }
15153 if self.hash_mapping.is_some() {
15154 len += 1;
15155 }
15156 if !self.added_downstream_actor_id.is_empty() {
15157 len += 1;
15158 }
15159 if !self.removed_downstream_actor_id.is_empty() {
15160 len += 1;
15161 }
15162 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", len)?;
15163 if self.actor_id != 0 {
15164 struct_ser.serialize_field("actorId", &self.actor_id)?;
15165 }
15166 if self.dispatcher_id != 0 {
15167 #[allow(clippy::needless_borrow)]
15168 #[allow(clippy::needless_borrows_for_generic_args)]
15169 struct_ser.serialize_field("dispatcherId", ToString::to_string(&self.dispatcher_id).as_str())?;
15170 }
15171 if let Some(v) = self.hash_mapping.as_ref() {
15172 struct_ser.serialize_field("hashMapping", v)?;
15173 }
15174 if !self.added_downstream_actor_id.is_empty() {
15175 struct_ser.serialize_field("addedDownstreamActorId", &self.added_downstream_actor_id)?;
15176 }
15177 if !self.removed_downstream_actor_id.is_empty() {
15178 struct_ser.serialize_field("removedDownstreamActorId", &self.removed_downstream_actor_id)?;
15179 }
15180 struct_ser.end()
15181 }
15182}
15183impl<'de> serde::Deserialize<'de> for update_mutation::DispatcherUpdate {
15184 #[allow(deprecated)]
15185 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15186 where
15187 D: serde::Deserializer<'de>,
15188 {
15189 const FIELDS: &[&str] = &[
15190 "actor_id",
15191 "actorId",
15192 "dispatcher_id",
15193 "dispatcherId",
15194 "hash_mapping",
15195 "hashMapping",
15196 "added_downstream_actor_id",
15197 "addedDownstreamActorId",
15198 "removed_downstream_actor_id",
15199 "removedDownstreamActorId",
15200 ];
15201
15202 #[allow(clippy::enum_variant_names)]
15203 enum GeneratedField {
15204 ActorId,
15205 DispatcherId,
15206 HashMapping,
15207 AddedDownstreamActorId,
15208 RemovedDownstreamActorId,
15209 }
15210 impl<'de> serde::Deserialize<'de> for GeneratedField {
15211 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15212 where
15213 D: serde::Deserializer<'de>,
15214 {
15215 struct GeneratedVisitor;
15216
15217 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15218 type Value = GeneratedField;
15219
15220 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15221 write!(formatter, "expected one of: {:?}", &FIELDS)
15222 }
15223
15224 #[allow(unused_variables)]
15225 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15226 where
15227 E: serde::de::Error,
15228 {
15229 match value {
15230 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
15231 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
15232 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
15233 "addedDownstreamActorId" | "added_downstream_actor_id" => Ok(GeneratedField::AddedDownstreamActorId),
15234 "removedDownstreamActorId" | "removed_downstream_actor_id" => Ok(GeneratedField::RemovedDownstreamActorId),
15235 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15236 }
15237 }
15238 }
15239 deserializer.deserialize_identifier(GeneratedVisitor)
15240 }
15241 }
15242 struct GeneratedVisitor;
15243 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15244 type Value = update_mutation::DispatcherUpdate;
15245
15246 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15247 formatter.write_str("struct stream_plan.UpdateMutation.DispatcherUpdate")
15248 }
15249
15250 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::DispatcherUpdate, V::Error>
15251 where
15252 V: serde::de::MapAccess<'de>,
15253 {
15254 let mut actor_id__ = None;
15255 let mut dispatcher_id__ = None;
15256 let mut hash_mapping__ = None;
15257 let mut added_downstream_actor_id__ = None;
15258 let mut removed_downstream_actor_id__ = None;
15259 while let Some(k) = map_.next_key()? {
15260 match k {
15261 GeneratedField::ActorId => {
15262 if actor_id__.is_some() {
15263 return Err(serde::de::Error::duplicate_field("actorId"));
15264 }
15265 actor_id__ =
15266 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15267 ;
15268 }
15269 GeneratedField::DispatcherId => {
15270 if dispatcher_id__.is_some() {
15271 return Err(serde::de::Error::duplicate_field("dispatcherId"));
15272 }
15273 dispatcher_id__ =
15274 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15275 ;
15276 }
15277 GeneratedField::HashMapping => {
15278 if hash_mapping__.is_some() {
15279 return Err(serde::de::Error::duplicate_field("hashMapping"));
15280 }
15281 hash_mapping__ = map_.next_value()?;
15282 }
15283 GeneratedField::AddedDownstreamActorId => {
15284 if added_downstream_actor_id__.is_some() {
15285 return Err(serde::de::Error::duplicate_field("addedDownstreamActorId"));
15286 }
15287 added_downstream_actor_id__ =
15288 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15289 .into_iter().map(|x| x.0).collect())
15290 ;
15291 }
15292 GeneratedField::RemovedDownstreamActorId => {
15293 if removed_downstream_actor_id__.is_some() {
15294 return Err(serde::de::Error::duplicate_field("removedDownstreamActorId"));
15295 }
15296 removed_downstream_actor_id__ =
15297 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15298 .into_iter().map(|x| x.0).collect())
15299 ;
15300 }
15301 }
15302 }
15303 Ok(update_mutation::DispatcherUpdate {
15304 actor_id: actor_id__.unwrap_or_default(),
15305 dispatcher_id: dispatcher_id__.unwrap_or_default(),
15306 hash_mapping: hash_mapping__,
15307 added_downstream_actor_id: added_downstream_actor_id__.unwrap_or_default(),
15308 removed_downstream_actor_id: removed_downstream_actor_id__.unwrap_or_default(),
15309 })
15310 }
15311 }
15312 deserializer.deserialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", FIELDS, GeneratedVisitor)
15313 }
15314}
15315impl serde::Serialize for update_mutation::MergeUpdate {
15316 #[allow(deprecated)]
15317 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15318 where
15319 S: serde::Serializer,
15320 {
15321 use serde::ser::SerializeStruct;
15322 let mut len = 0;
15323 if self.actor_id != 0 {
15324 len += 1;
15325 }
15326 if self.upstream_fragment_id != 0 {
15327 len += 1;
15328 }
15329 if self.new_upstream_fragment_id.is_some() {
15330 len += 1;
15331 }
15332 if !self.added_upstream_actors.is_empty() {
15333 len += 1;
15334 }
15335 if !self.removed_upstream_actor_id.is_empty() {
15336 len += 1;
15337 }
15338 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.MergeUpdate", len)?;
15339 if self.actor_id != 0 {
15340 struct_ser.serialize_field("actorId", &self.actor_id)?;
15341 }
15342 if self.upstream_fragment_id != 0 {
15343 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
15344 }
15345 if let Some(v) = self.new_upstream_fragment_id.as_ref() {
15346 struct_ser.serialize_field("newUpstreamFragmentId", v)?;
15347 }
15348 if !self.added_upstream_actors.is_empty() {
15349 struct_ser.serialize_field("addedUpstreamActors", &self.added_upstream_actors)?;
15350 }
15351 if !self.removed_upstream_actor_id.is_empty() {
15352 struct_ser.serialize_field("removedUpstreamActorId", &self.removed_upstream_actor_id)?;
15353 }
15354 struct_ser.end()
15355 }
15356}
15357impl<'de> serde::Deserialize<'de> for update_mutation::MergeUpdate {
15358 #[allow(deprecated)]
15359 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15360 where
15361 D: serde::Deserializer<'de>,
15362 {
15363 const FIELDS: &[&str] = &[
15364 "actor_id",
15365 "actorId",
15366 "upstream_fragment_id",
15367 "upstreamFragmentId",
15368 "new_upstream_fragment_id",
15369 "newUpstreamFragmentId",
15370 "added_upstream_actors",
15371 "addedUpstreamActors",
15372 "removed_upstream_actor_id",
15373 "removedUpstreamActorId",
15374 ];
15375
15376 #[allow(clippy::enum_variant_names)]
15377 enum GeneratedField {
15378 ActorId,
15379 UpstreamFragmentId,
15380 NewUpstreamFragmentId,
15381 AddedUpstreamActors,
15382 RemovedUpstreamActorId,
15383 }
15384 impl<'de> serde::Deserialize<'de> for GeneratedField {
15385 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15386 where
15387 D: serde::Deserializer<'de>,
15388 {
15389 struct GeneratedVisitor;
15390
15391 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15392 type Value = GeneratedField;
15393
15394 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15395 write!(formatter, "expected one of: {:?}", &FIELDS)
15396 }
15397
15398 #[allow(unused_variables)]
15399 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15400 where
15401 E: serde::de::Error,
15402 {
15403 match value {
15404 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
15405 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
15406 "newUpstreamFragmentId" | "new_upstream_fragment_id" => Ok(GeneratedField::NewUpstreamFragmentId),
15407 "addedUpstreamActors" | "added_upstream_actors" => Ok(GeneratedField::AddedUpstreamActors),
15408 "removedUpstreamActorId" | "removed_upstream_actor_id" => Ok(GeneratedField::RemovedUpstreamActorId),
15409 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15410 }
15411 }
15412 }
15413 deserializer.deserialize_identifier(GeneratedVisitor)
15414 }
15415 }
15416 struct GeneratedVisitor;
15417 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15418 type Value = update_mutation::MergeUpdate;
15419
15420 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15421 formatter.write_str("struct stream_plan.UpdateMutation.MergeUpdate")
15422 }
15423
15424 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::MergeUpdate, V::Error>
15425 where
15426 V: serde::de::MapAccess<'de>,
15427 {
15428 let mut actor_id__ = None;
15429 let mut upstream_fragment_id__ = None;
15430 let mut new_upstream_fragment_id__ = None;
15431 let mut added_upstream_actors__ = None;
15432 let mut removed_upstream_actor_id__ = None;
15433 while let Some(k) = map_.next_key()? {
15434 match k {
15435 GeneratedField::ActorId => {
15436 if actor_id__.is_some() {
15437 return Err(serde::de::Error::duplicate_field("actorId"));
15438 }
15439 actor_id__ =
15440 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15441 ;
15442 }
15443 GeneratedField::UpstreamFragmentId => {
15444 if upstream_fragment_id__.is_some() {
15445 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
15446 }
15447 upstream_fragment_id__ =
15448 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15449 ;
15450 }
15451 GeneratedField::NewUpstreamFragmentId => {
15452 if new_upstream_fragment_id__.is_some() {
15453 return Err(serde::de::Error::duplicate_field("newUpstreamFragmentId"));
15454 }
15455 new_upstream_fragment_id__ =
15456 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15457 ;
15458 }
15459 GeneratedField::AddedUpstreamActors => {
15460 if added_upstream_actors__.is_some() {
15461 return Err(serde::de::Error::duplicate_field("addedUpstreamActors"));
15462 }
15463 added_upstream_actors__ = Some(map_.next_value()?);
15464 }
15465 GeneratedField::RemovedUpstreamActorId => {
15466 if removed_upstream_actor_id__.is_some() {
15467 return Err(serde::de::Error::duplicate_field("removedUpstreamActorId"));
15468 }
15469 removed_upstream_actor_id__ =
15470 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15471 .into_iter().map(|x| x.0).collect())
15472 ;
15473 }
15474 }
15475 }
15476 Ok(update_mutation::MergeUpdate {
15477 actor_id: actor_id__.unwrap_or_default(),
15478 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
15479 new_upstream_fragment_id: new_upstream_fragment_id__,
15480 added_upstream_actors: added_upstream_actors__.unwrap_or_default(),
15481 removed_upstream_actor_id: removed_upstream_actor_id__.unwrap_or_default(),
15482 })
15483 }
15484 }
15485 deserializer.deserialize_struct("stream_plan.UpdateMutation.MergeUpdate", FIELDS, GeneratedVisitor)
15486 }
15487}
15488impl serde::Serialize for UpstreamSinkInfo {
15489 #[allow(deprecated)]
15490 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15491 where
15492 S: serde::Serializer,
15493 {
15494 use serde::ser::SerializeStruct;
15495 let mut len = 0;
15496 if self.upstream_fragment_id != 0 {
15497 len += 1;
15498 }
15499 if !self.sink_output_schema.is_empty() {
15500 len += 1;
15501 }
15502 if !self.project_exprs.is_empty() {
15503 len += 1;
15504 }
15505 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkInfo", len)?;
15506 if self.upstream_fragment_id != 0 {
15507 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
15508 }
15509 if !self.sink_output_schema.is_empty() {
15510 struct_ser.serialize_field("sinkOutputSchema", &self.sink_output_schema)?;
15511 }
15512 if !self.project_exprs.is_empty() {
15513 struct_ser.serialize_field("projectExprs", &self.project_exprs)?;
15514 }
15515 struct_ser.end()
15516 }
15517}
15518impl<'de> serde::Deserialize<'de> for UpstreamSinkInfo {
15519 #[allow(deprecated)]
15520 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15521 where
15522 D: serde::Deserializer<'de>,
15523 {
15524 const FIELDS: &[&str] = &[
15525 "upstream_fragment_id",
15526 "upstreamFragmentId",
15527 "sink_output_schema",
15528 "sinkOutputSchema",
15529 "project_exprs",
15530 "projectExprs",
15531 ];
15532
15533 #[allow(clippy::enum_variant_names)]
15534 enum GeneratedField {
15535 UpstreamFragmentId,
15536 SinkOutputSchema,
15537 ProjectExprs,
15538 }
15539 impl<'de> serde::Deserialize<'de> for GeneratedField {
15540 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15541 where
15542 D: serde::Deserializer<'de>,
15543 {
15544 struct GeneratedVisitor;
15545
15546 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15547 type Value = GeneratedField;
15548
15549 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15550 write!(formatter, "expected one of: {:?}", &FIELDS)
15551 }
15552
15553 #[allow(unused_variables)]
15554 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15555 where
15556 E: serde::de::Error,
15557 {
15558 match value {
15559 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
15560 "sinkOutputSchema" | "sink_output_schema" => Ok(GeneratedField::SinkOutputSchema),
15561 "projectExprs" | "project_exprs" => Ok(GeneratedField::ProjectExprs),
15562 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15563 }
15564 }
15565 }
15566 deserializer.deserialize_identifier(GeneratedVisitor)
15567 }
15568 }
15569 struct GeneratedVisitor;
15570 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15571 type Value = UpstreamSinkInfo;
15572
15573 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15574 formatter.write_str("struct stream_plan.UpstreamSinkInfo")
15575 }
15576
15577 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkInfo, V::Error>
15578 where
15579 V: serde::de::MapAccess<'de>,
15580 {
15581 let mut upstream_fragment_id__ = None;
15582 let mut sink_output_schema__ = None;
15583 let mut project_exprs__ = None;
15584 while let Some(k) = map_.next_key()? {
15585 match k {
15586 GeneratedField::UpstreamFragmentId => {
15587 if upstream_fragment_id__.is_some() {
15588 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
15589 }
15590 upstream_fragment_id__ =
15591 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15592 ;
15593 }
15594 GeneratedField::SinkOutputSchema => {
15595 if sink_output_schema__.is_some() {
15596 return Err(serde::de::Error::duplicate_field("sinkOutputSchema"));
15597 }
15598 sink_output_schema__ = Some(map_.next_value()?);
15599 }
15600 GeneratedField::ProjectExprs => {
15601 if project_exprs__.is_some() {
15602 return Err(serde::de::Error::duplicate_field("projectExprs"));
15603 }
15604 project_exprs__ = Some(map_.next_value()?);
15605 }
15606 }
15607 }
15608 Ok(UpstreamSinkInfo {
15609 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
15610 sink_output_schema: sink_output_schema__.unwrap_or_default(),
15611 project_exprs: project_exprs__.unwrap_or_default(),
15612 })
15613 }
15614 }
15615 deserializer.deserialize_struct("stream_plan.UpstreamSinkInfo", FIELDS, GeneratedVisitor)
15616 }
15617}
15618impl serde::Serialize for UpstreamSinkUnionNode {
15619 #[allow(deprecated)]
15620 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15621 where
15622 S: serde::Serializer,
15623 {
15624 use serde::ser::SerializeStruct;
15625 let mut len = 0;
15626 if !self.init_upstreams.is_empty() {
15627 len += 1;
15628 }
15629 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkUnionNode", len)?;
15630 if !self.init_upstreams.is_empty() {
15631 struct_ser.serialize_field("initUpstreams", &self.init_upstreams)?;
15632 }
15633 struct_ser.end()
15634 }
15635}
15636impl<'de> serde::Deserialize<'de> for UpstreamSinkUnionNode {
15637 #[allow(deprecated)]
15638 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15639 where
15640 D: serde::Deserializer<'de>,
15641 {
15642 const FIELDS: &[&str] = &[
15643 "init_upstreams",
15644 "initUpstreams",
15645 ];
15646
15647 #[allow(clippy::enum_variant_names)]
15648 enum GeneratedField {
15649 InitUpstreams,
15650 }
15651 impl<'de> serde::Deserialize<'de> for GeneratedField {
15652 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15653 where
15654 D: serde::Deserializer<'de>,
15655 {
15656 struct GeneratedVisitor;
15657
15658 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15659 type Value = GeneratedField;
15660
15661 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15662 write!(formatter, "expected one of: {:?}", &FIELDS)
15663 }
15664
15665 #[allow(unused_variables)]
15666 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15667 where
15668 E: serde::de::Error,
15669 {
15670 match value {
15671 "initUpstreams" | "init_upstreams" => Ok(GeneratedField::InitUpstreams),
15672 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15673 }
15674 }
15675 }
15676 deserializer.deserialize_identifier(GeneratedVisitor)
15677 }
15678 }
15679 struct GeneratedVisitor;
15680 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15681 type Value = UpstreamSinkUnionNode;
15682
15683 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15684 formatter.write_str("struct stream_plan.UpstreamSinkUnionNode")
15685 }
15686
15687 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkUnionNode, V::Error>
15688 where
15689 V: serde::de::MapAccess<'de>,
15690 {
15691 let mut init_upstreams__ = None;
15692 while let Some(k) = map_.next_key()? {
15693 match k {
15694 GeneratedField::InitUpstreams => {
15695 if init_upstreams__.is_some() {
15696 return Err(serde::de::Error::duplicate_field("initUpstreams"));
15697 }
15698 init_upstreams__ = Some(map_.next_value()?);
15699 }
15700 }
15701 }
15702 Ok(UpstreamSinkUnionNode {
15703 init_upstreams: init_upstreams__.unwrap_or_default(),
15704 })
15705 }
15706 }
15707 deserializer.deserialize_struct("stream_plan.UpstreamSinkUnionNode", FIELDS, GeneratedVisitor)
15708 }
15709}
15710impl serde::Serialize for ValuesNode {
15711 #[allow(deprecated)]
15712 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15713 where
15714 S: serde::Serializer,
15715 {
15716 use serde::ser::SerializeStruct;
15717 let mut len = 0;
15718 if !self.tuples.is_empty() {
15719 len += 1;
15720 }
15721 if !self.fields.is_empty() {
15722 len += 1;
15723 }
15724 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode", len)?;
15725 if !self.tuples.is_empty() {
15726 struct_ser.serialize_field("tuples", &self.tuples)?;
15727 }
15728 if !self.fields.is_empty() {
15729 struct_ser.serialize_field("fields", &self.fields)?;
15730 }
15731 struct_ser.end()
15732 }
15733}
15734impl<'de> serde::Deserialize<'de> for ValuesNode {
15735 #[allow(deprecated)]
15736 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15737 where
15738 D: serde::Deserializer<'de>,
15739 {
15740 const FIELDS: &[&str] = &[
15741 "tuples",
15742 "fields",
15743 ];
15744
15745 #[allow(clippy::enum_variant_names)]
15746 enum GeneratedField {
15747 Tuples,
15748 Fields,
15749 }
15750 impl<'de> serde::Deserialize<'de> for GeneratedField {
15751 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15752 where
15753 D: serde::Deserializer<'de>,
15754 {
15755 struct GeneratedVisitor;
15756
15757 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15758 type Value = GeneratedField;
15759
15760 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15761 write!(formatter, "expected one of: {:?}", &FIELDS)
15762 }
15763
15764 #[allow(unused_variables)]
15765 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15766 where
15767 E: serde::de::Error,
15768 {
15769 match value {
15770 "tuples" => Ok(GeneratedField::Tuples),
15771 "fields" => Ok(GeneratedField::Fields),
15772 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15773 }
15774 }
15775 }
15776 deserializer.deserialize_identifier(GeneratedVisitor)
15777 }
15778 }
15779 struct GeneratedVisitor;
15780 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15781 type Value = ValuesNode;
15782
15783 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15784 formatter.write_str("struct stream_plan.ValuesNode")
15785 }
15786
15787 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
15788 where
15789 V: serde::de::MapAccess<'de>,
15790 {
15791 let mut tuples__ = None;
15792 let mut fields__ = None;
15793 while let Some(k) = map_.next_key()? {
15794 match k {
15795 GeneratedField::Tuples => {
15796 if tuples__.is_some() {
15797 return Err(serde::de::Error::duplicate_field("tuples"));
15798 }
15799 tuples__ = Some(map_.next_value()?);
15800 }
15801 GeneratedField::Fields => {
15802 if fields__.is_some() {
15803 return Err(serde::de::Error::duplicate_field("fields"));
15804 }
15805 fields__ = Some(map_.next_value()?);
15806 }
15807 }
15808 }
15809 Ok(ValuesNode {
15810 tuples: tuples__.unwrap_or_default(),
15811 fields: fields__.unwrap_or_default(),
15812 })
15813 }
15814 }
15815 deserializer.deserialize_struct("stream_plan.ValuesNode", FIELDS, GeneratedVisitor)
15816 }
15817}
15818impl serde::Serialize for values_node::ExprTuple {
15819 #[allow(deprecated)]
15820 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15821 where
15822 S: serde::Serializer,
15823 {
15824 use serde::ser::SerializeStruct;
15825 let mut len = 0;
15826 if !self.cells.is_empty() {
15827 len += 1;
15828 }
15829 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode.ExprTuple", len)?;
15830 if !self.cells.is_empty() {
15831 struct_ser.serialize_field("cells", &self.cells)?;
15832 }
15833 struct_ser.end()
15834 }
15835}
15836impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
15837 #[allow(deprecated)]
15838 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15839 where
15840 D: serde::Deserializer<'de>,
15841 {
15842 const FIELDS: &[&str] = &[
15843 "cells",
15844 ];
15845
15846 #[allow(clippy::enum_variant_names)]
15847 enum GeneratedField {
15848 Cells,
15849 }
15850 impl<'de> serde::Deserialize<'de> for GeneratedField {
15851 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15852 where
15853 D: serde::Deserializer<'de>,
15854 {
15855 struct GeneratedVisitor;
15856
15857 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15858 type Value = GeneratedField;
15859
15860 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15861 write!(formatter, "expected one of: {:?}", &FIELDS)
15862 }
15863
15864 #[allow(unused_variables)]
15865 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15866 where
15867 E: serde::de::Error,
15868 {
15869 match value {
15870 "cells" => Ok(GeneratedField::Cells),
15871 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15872 }
15873 }
15874 }
15875 deserializer.deserialize_identifier(GeneratedVisitor)
15876 }
15877 }
15878 struct GeneratedVisitor;
15879 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15880 type Value = values_node::ExprTuple;
15881
15882 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15883 formatter.write_str("struct stream_plan.ValuesNode.ExprTuple")
15884 }
15885
15886 fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
15887 where
15888 V: serde::de::MapAccess<'de>,
15889 {
15890 let mut cells__ = None;
15891 while let Some(k) = map_.next_key()? {
15892 match k {
15893 GeneratedField::Cells => {
15894 if cells__.is_some() {
15895 return Err(serde::de::Error::duplicate_field("cells"));
15896 }
15897 cells__ = Some(map_.next_value()?);
15898 }
15899 }
15900 }
15901 Ok(values_node::ExprTuple {
15902 cells: cells__.unwrap_or_default(),
15903 })
15904 }
15905 }
15906 deserializer.deserialize_struct("stream_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
15907 }
15908}
15909impl serde::Serialize for VectorIndexWriteNode {
15910 #[allow(deprecated)]
15911 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15912 where
15913 S: serde::Serializer,
15914 {
15915 use serde::ser::SerializeStruct;
15916 let mut len = 0;
15917 if self.table.is_some() {
15918 len += 1;
15919 }
15920 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexWriteNode", len)?;
15921 if let Some(v) = self.table.as_ref() {
15922 struct_ser.serialize_field("table", v)?;
15923 }
15924 struct_ser.end()
15925 }
15926}
15927impl<'de> serde::Deserialize<'de> for VectorIndexWriteNode {
15928 #[allow(deprecated)]
15929 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15930 where
15931 D: serde::Deserializer<'de>,
15932 {
15933 const FIELDS: &[&str] = &[
15934 "table",
15935 ];
15936
15937 #[allow(clippy::enum_variant_names)]
15938 enum GeneratedField {
15939 Table,
15940 }
15941 impl<'de> serde::Deserialize<'de> for GeneratedField {
15942 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15943 where
15944 D: serde::Deserializer<'de>,
15945 {
15946 struct GeneratedVisitor;
15947
15948 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15949 type Value = GeneratedField;
15950
15951 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15952 write!(formatter, "expected one of: {:?}", &FIELDS)
15953 }
15954
15955 #[allow(unused_variables)]
15956 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15957 where
15958 E: serde::de::Error,
15959 {
15960 match value {
15961 "table" => Ok(GeneratedField::Table),
15962 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15963 }
15964 }
15965 }
15966 deserializer.deserialize_identifier(GeneratedVisitor)
15967 }
15968 }
15969 struct GeneratedVisitor;
15970 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15971 type Value = VectorIndexWriteNode;
15972
15973 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15974 formatter.write_str("struct stream_plan.VectorIndexWriteNode")
15975 }
15976
15977 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexWriteNode, V::Error>
15978 where
15979 V: serde::de::MapAccess<'de>,
15980 {
15981 let mut table__ = None;
15982 while let Some(k) = map_.next_key()? {
15983 match k {
15984 GeneratedField::Table => {
15985 if table__.is_some() {
15986 return Err(serde::de::Error::duplicate_field("table"));
15987 }
15988 table__ = map_.next_value()?;
15989 }
15990 }
15991 }
15992 Ok(VectorIndexWriteNode {
15993 table: table__,
15994 })
15995 }
15996 }
15997 deserializer.deserialize_struct("stream_plan.VectorIndexWriteNode", FIELDS, GeneratedVisitor)
15998 }
15999}
16000impl serde::Serialize for Watermark {
16001 #[allow(deprecated)]
16002 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16003 where
16004 S: serde::Serializer,
16005 {
16006 use serde::ser::SerializeStruct;
16007 let mut len = 0;
16008 if self.column.is_some() {
16009 len += 1;
16010 }
16011 if self.val.is_some() {
16012 len += 1;
16013 }
16014 let mut struct_ser = serializer.serialize_struct("stream_plan.Watermark", len)?;
16015 if let Some(v) = self.column.as_ref() {
16016 struct_ser.serialize_field("column", v)?;
16017 }
16018 if let Some(v) = self.val.as_ref() {
16019 struct_ser.serialize_field("val", v)?;
16020 }
16021 struct_ser.end()
16022 }
16023}
16024impl<'de> serde::Deserialize<'de> for Watermark {
16025 #[allow(deprecated)]
16026 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16027 where
16028 D: serde::Deserializer<'de>,
16029 {
16030 const FIELDS: &[&str] = &[
16031 "column",
16032 "val",
16033 ];
16034
16035 #[allow(clippy::enum_variant_names)]
16036 enum GeneratedField {
16037 Column,
16038 Val,
16039 }
16040 impl<'de> serde::Deserialize<'de> for GeneratedField {
16041 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16042 where
16043 D: serde::Deserializer<'de>,
16044 {
16045 struct GeneratedVisitor;
16046
16047 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16048 type Value = GeneratedField;
16049
16050 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16051 write!(formatter, "expected one of: {:?}", &FIELDS)
16052 }
16053
16054 #[allow(unused_variables)]
16055 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16056 where
16057 E: serde::de::Error,
16058 {
16059 match value {
16060 "column" => Ok(GeneratedField::Column),
16061 "val" => Ok(GeneratedField::Val),
16062 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16063 }
16064 }
16065 }
16066 deserializer.deserialize_identifier(GeneratedVisitor)
16067 }
16068 }
16069 struct GeneratedVisitor;
16070 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16071 type Value = Watermark;
16072
16073 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16074 formatter.write_str("struct stream_plan.Watermark")
16075 }
16076
16077 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Watermark, V::Error>
16078 where
16079 V: serde::de::MapAccess<'de>,
16080 {
16081 let mut column__ = None;
16082 let mut val__ = None;
16083 while let Some(k) = map_.next_key()? {
16084 match k {
16085 GeneratedField::Column => {
16086 if column__.is_some() {
16087 return Err(serde::de::Error::duplicate_field("column"));
16088 }
16089 column__ = map_.next_value()?;
16090 }
16091 GeneratedField::Val => {
16092 if val__.is_some() {
16093 return Err(serde::de::Error::duplicate_field("val"));
16094 }
16095 val__ = map_.next_value()?;
16096 }
16097 }
16098 }
16099 Ok(Watermark {
16100 column: column__,
16101 val: val__,
16102 })
16103 }
16104 }
16105 deserializer.deserialize_struct("stream_plan.Watermark", FIELDS, GeneratedVisitor)
16106 }
16107}
16108impl serde::Serialize for WatermarkFilterNode {
16109 #[allow(deprecated)]
16110 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16111 where
16112 S: serde::Serializer,
16113 {
16114 use serde::ser::SerializeStruct;
16115 let mut len = 0;
16116 if !self.watermark_descs.is_empty() {
16117 len += 1;
16118 }
16119 if !self.tables.is_empty() {
16120 len += 1;
16121 }
16122 let mut struct_ser = serializer.serialize_struct("stream_plan.WatermarkFilterNode", len)?;
16123 if !self.watermark_descs.is_empty() {
16124 struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
16125 }
16126 if !self.tables.is_empty() {
16127 struct_ser.serialize_field("tables", &self.tables)?;
16128 }
16129 struct_ser.end()
16130 }
16131}
16132impl<'de> serde::Deserialize<'de> for WatermarkFilterNode {
16133 #[allow(deprecated)]
16134 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16135 where
16136 D: serde::Deserializer<'de>,
16137 {
16138 const FIELDS: &[&str] = &[
16139 "watermark_descs",
16140 "watermarkDescs",
16141 "tables",
16142 ];
16143
16144 #[allow(clippy::enum_variant_names)]
16145 enum GeneratedField {
16146 WatermarkDescs,
16147 Tables,
16148 }
16149 impl<'de> serde::Deserialize<'de> for GeneratedField {
16150 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16151 where
16152 D: serde::Deserializer<'de>,
16153 {
16154 struct GeneratedVisitor;
16155
16156 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16157 type Value = GeneratedField;
16158
16159 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16160 write!(formatter, "expected one of: {:?}", &FIELDS)
16161 }
16162
16163 #[allow(unused_variables)]
16164 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16165 where
16166 E: serde::de::Error,
16167 {
16168 match value {
16169 "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
16170 "tables" => Ok(GeneratedField::Tables),
16171 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16172 }
16173 }
16174 }
16175 deserializer.deserialize_identifier(GeneratedVisitor)
16176 }
16177 }
16178 struct GeneratedVisitor;
16179 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16180 type Value = WatermarkFilterNode;
16181
16182 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16183 formatter.write_str("struct stream_plan.WatermarkFilterNode")
16184 }
16185
16186 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkFilterNode, V::Error>
16187 where
16188 V: serde::de::MapAccess<'de>,
16189 {
16190 let mut watermark_descs__ = None;
16191 let mut tables__ = None;
16192 while let Some(k) = map_.next_key()? {
16193 match k {
16194 GeneratedField::WatermarkDescs => {
16195 if watermark_descs__.is_some() {
16196 return Err(serde::de::Error::duplicate_field("watermarkDescs"));
16197 }
16198 watermark_descs__ = Some(map_.next_value()?);
16199 }
16200 GeneratedField::Tables => {
16201 if tables__.is_some() {
16202 return Err(serde::de::Error::duplicate_field("tables"));
16203 }
16204 tables__ = Some(map_.next_value()?);
16205 }
16206 }
16207 }
16208 Ok(WatermarkFilterNode {
16209 watermark_descs: watermark_descs__.unwrap_or_default(),
16210 tables: tables__.unwrap_or_default(),
16211 })
16212 }
16213 }
16214 deserializer.deserialize_struct("stream_plan.WatermarkFilterNode", FIELDS, GeneratedVisitor)
16215 }
16216}