1#![allow(clippy::useless_conversion)]
2use crate::stream_plan::*;
3impl serde::Serialize for ActorMapping {
4 #[allow(deprecated)]
5 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6 where
7 S: serde::Serializer,
8 {
9 use serde::ser::SerializeStruct;
10 let mut len = 0;
11 if !self.original_indices.is_empty() {
12 len += 1;
13 }
14 if !self.data.is_empty() {
15 len += 1;
16 }
17 let mut struct_ser = serializer.serialize_struct("stream_plan.ActorMapping", len)?;
18 if !self.original_indices.is_empty() {
19 struct_ser.serialize_field("originalIndices", &self.original_indices)?;
20 }
21 if !self.data.is_empty() {
22 struct_ser.serialize_field("data", &self.data)?;
23 }
24 struct_ser.end()
25 }
26}
27impl<'de> serde::Deserialize<'de> for ActorMapping {
28 #[allow(deprecated)]
29 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
30 where
31 D: serde::Deserializer<'de>,
32 {
33 const FIELDS: &[&str] = &[
34 "original_indices",
35 "originalIndices",
36 "data",
37 ];
38
39 #[allow(clippy::enum_variant_names)]
40 enum GeneratedField {
41 OriginalIndices,
42 Data,
43 }
44 impl<'de> serde::Deserialize<'de> for GeneratedField {
45 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
46 where
47 D: serde::Deserializer<'de>,
48 {
49 struct GeneratedVisitor;
50
51 impl serde::de::Visitor<'_> for GeneratedVisitor {
52 type Value = GeneratedField;
53
54 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
55 write!(formatter, "expected one of: {:?}", &FIELDS)
56 }
57
58 #[allow(unused_variables)]
59 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
60 where
61 E: serde::de::Error,
62 {
63 match value {
64 "originalIndices" | "original_indices" => Ok(GeneratedField::OriginalIndices),
65 "data" => Ok(GeneratedField::Data),
66 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
67 }
68 }
69 }
70 deserializer.deserialize_identifier(GeneratedVisitor)
71 }
72 }
73 struct GeneratedVisitor;
74 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
75 type Value = ActorMapping;
76
77 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
78 formatter.write_str("struct stream_plan.ActorMapping")
79 }
80
81 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorMapping, V::Error>
82 where
83 V: serde::de::MapAccess<'de>,
84 {
85 let mut original_indices__ = None;
86 let mut data__ = None;
87 while let Some(k) = map_.next_key()? {
88 match k {
89 GeneratedField::OriginalIndices => {
90 if original_indices__.is_some() {
91 return Err(serde::de::Error::duplicate_field("originalIndices"));
92 }
93 original_indices__ =
94 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
95 .into_iter().map(|x| x.0).collect())
96 ;
97 }
98 GeneratedField::Data => {
99 if data__.is_some() {
100 return Err(serde::de::Error::duplicate_field("data"));
101 }
102 data__ =
103 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
104 .into_iter().map(|x| x.0).collect())
105 ;
106 }
107 }
108 }
109 Ok(ActorMapping {
110 original_indices: original_indices__.unwrap_or_default(),
111 data: data__.unwrap_or_default(),
112 })
113 }
114 }
115 deserializer.deserialize_struct("stream_plan.ActorMapping", FIELDS, GeneratedVisitor)
116 }
117}
118impl serde::Serialize for AddMutation {
119 #[allow(deprecated)]
120 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
121 where
122 S: serde::Serializer,
123 {
124 use serde::ser::SerializeStruct;
125 let mut len = 0;
126 if !self.actor_dispatchers.is_empty() {
127 len += 1;
128 }
129 if !self.added_actors.is_empty() {
130 len += 1;
131 }
132 if !self.actor_splits.is_empty() {
133 len += 1;
134 }
135 if self.pause {
136 len += 1;
137 }
138 if !self.subscriptions_to_add.is_empty() {
139 len += 1;
140 }
141 if !self.backfill_nodes_to_pause.is_empty() {
142 len += 1;
143 }
144 if self.actor_cdc_table_snapshot_splits.is_some() {
145 len += 1;
146 }
147 if !self.new_upstream_sinks.is_empty() {
148 len += 1;
149 }
150 let mut struct_ser = serializer.serialize_struct("stream_plan.AddMutation", len)?;
151 if !self.actor_dispatchers.is_empty() {
152 struct_ser.serialize_field("actorDispatchers", &self.actor_dispatchers)?;
153 }
154 if !self.added_actors.is_empty() {
155 struct_ser.serialize_field("addedActors", &self.added_actors)?;
156 }
157 if !self.actor_splits.is_empty() {
158 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
159 }
160 if self.pause {
161 struct_ser.serialize_field("pause", &self.pause)?;
162 }
163 if !self.subscriptions_to_add.is_empty() {
164 struct_ser.serialize_field("subscriptionsToAdd", &self.subscriptions_to_add)?;
165 }
166 if !self.backfill_nodes_to_pause.is_empty() {
167 struct_ser.serialize_field("backfillNodesToPause", &self.backfill_nodes_to_pause)?;
168 }
169 if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
170 struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
171 }
172 if !self.new_upstream_sinks.is_empty() {
173 struct_ser.serialize_field("newUpstreamSinks", &self.new_upstream_sinks)?;
174 }
175 struct_ser.end()
176 }
177}
178impl<'de> serde::Deserialize<'de> for AddMutation {
179 #[allow(deprecated)]
180 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
181 where
182 D: serde::Deserializer<'de>,
183 {
184 const FIELDS: &[&str] = &[
185 "actor_dispatchers",
186 "actorDispatchers",
187 "added_actors",
188 "addedActors",
189 "actor_splits",
190 "actorSplits",
191 "pause",
192 "subscriptions_to_add",
193 "subscriptionsToAdd",
194 "backfill_nodes_to_pause",
195 "backfillNodesToPause",
196 "actor_cdc_table_snapshot_splits",
197 "actorCdcTableSnapshotSplits",
198 "new_upstream_sinks",
199 "newUpstreamSinks",
200 ];
201
202 #[allow(clippy::enum_variant_names)]
203 enum GeneratedField {
204 ActorDispatchers,
205 AddedActors,
206 ActorSplits,
207 Pause,
208 SubscriptionsToAdd,
209 BackfillNodesToPause,
210 ActorCdcTableSnapshotSplits,
211 NewUpstreamSinks,
212 }
213 impl<'de> serde::Deserialize<'de> for GeneratedField {
214 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
215 where
216 D: serde::Deserializer<'de>,
217 {
218 struct GeneratedVisitor;
219
220 impl serde::de::Visitor<'_> for GeneratedVisitor {
221 type Value = GeneratedField;
222
223 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
224 write!(formatter, "expected one of: {:?}", &FIELDS)
225 }
226
227 #[allow(unused_variables)]
228 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
229 where
230 E: serde::de::Error,
231 {
232 match value {
233 "actorDispatchers" | "actor_dispatchers" => Ok(GeneratedField::ActorDispatchers),
234 "addedActors" | "added_actors" => Ok(GeneratedField::AddedActors),
235 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
236 "pause" => Ok(GeneratedField::Pause),
237 "subscriptionsToAdd" | "subscriptions_to_add" => Ok(GeneratedField::SubscriptionsToAdd),
238 "backfillNodesToPause" | "backfill_nodes_to_pause" => Ok(GeneratedField::BackfillNodesToPause),
239 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
240 "newUpstreamSinks" | "new_upstream_sinks" => Ok(GeneratedField::NewUpstreamSinks),
241 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
242 }
243 }
244 }
245 deserializer.deserialize_identifier(GeneratedVisitor)
246 }
247 }
248 struct GeneratedVisitor;
249 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
250 type Value = AddMutation;
251
252 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
253 formatter.write_str("struct stream_plan.AddMutation")
254 }
255
256 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddMutation, V::Error>
257 where
258 V: serde::de::MapAccess<'de>,
259 {
260 let mut actor_dispatchers__ = None;
261 let mut added_actors__ = None;
262 let mut actor_splits__ = None;
263 let mut pause__ = None;
264 let mut subscriptions_to_add__ = None;
265 let mut backfill_nodes_to_pause__ = None;
266 let mut actor_cdc_table_snapshot_splits__ = None;
267 let mut new_upstream_sinks__ = None;
268 while let Some(k) = map_.next_key()? {
269 match k {
270 GeneratedField::ActorDispatchers => {
271 if actor_dispatchers__.is_some() {
272 return Err(serde::de::Error::duplicate_field("actorDispatchers"));
273 }
274 actor_dispatchers__ = Some(
275 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
276 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
277 );
278 }
279 GeneratedField::AddedActors => {
280 if added_actors__.is_some() {
281 return Err(serde::de::Error::duplicate_field("addedActors"));
282 }
283 added_actors__ =
284 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
285 .into_iter().map(|x| x.0).collect())
286 ;
287 }
288 GeneratedField::ActorSplits => {
289 if actor_splits__.is_some() {
290 return Err(serde::de::Error::duplicate_field("actorSplits"));
291 }
292 actor_splits__ = Some(
293 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
294 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
295 );
296 }
297 GeneratedField::Pause => {
298 if pause__.is_some() {
299 return Err(serde::de::Error::duplicate_field("pause"));
300 }
301 pause__ = Some(map_.next_value()?);
302 }
303 GeneratedField::SubscriptionsToAdd => {
304 if subscriptions_to_add__.is_some() {
305 return Err(serde::de::Error::duplicate_field("subscriptionsToAdd"));
306 }
307 subscriptions_to_add__ = Some(map_.next_value()?);
308 }
309 GeneratedField::BackfillNodesToPause => {
310 if backfill_nodes_to_pause__.is_some() {
311 return Err(serde::de::Error::duplicate_field("backfillNodesToPause"));
312 }
313 backfill_nodes_to_pause__ =
314 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
315 .into_iter().map(|x| x.0).collect())
316 ;
317 }
318 GeneratedField::ActorCdcTableSnapshotSplits => {
319 if actor_cdc_table_snapshot_splits__.is_some() {
320 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
321 }
322 actor_cdc_table_snapshot_splits__ = map_.next_value()?;
323 }
324 GeneratedField::NewUpstreamSinks => {
325 if new_upstream_sinks__.is_some() {
326 return Err(serde::de::Error::duplicate_field("newUpstreamSinks"));
327 }
328 new_upstream_sinks__ = Some(
329 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
330 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
331 );
332 }
333 }
334 }
335 Ok(AddMutation {
336 actor_dispatchers: actor_dispatchers__.unwrap_or_default(),
337 added_actors: added_actors__.unwrap_or_default(),
338 actor_splits: actor_splits__.unwrap_or_default(),
339 pause: pause__.unwrap_or_default(),
340 subscriptions_to_add: subscriptions_to_add__.unwrap_or_default(),
341 backfill_nodes_to_pause: backfill_nodes_to_pause__.unwrap_or_default(),
342 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
343 new_upstream_sinks: new_upstream_sinks__.unwrap_or_default(),
344 })
345 }
346 }
347 deserializer.deserialize_struct("stream_plan.AddMutation", FIELDS, GeneratedVisitor)
348 }
349}
350impl serde::Serialize for add_mutation::NewUpstreamSink {
351 #[allow(deprecated)]
352 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
353 where
354 S: serde::Serializer,
355 {
356 use serde::ser::SerializeStruct;
357 let mut len = 0;
358 if self.info.is_some() {
359 len += 1;
360 }
361 if !self.upstream_actors.is_empty() {
362 len += 1;
363 }
364 let mut struct_ser = serializer.serialize_struct("stream_plan.AddMutation.NewUpstreamSink", len)?;
365 if let Some(v) = self.info.as_ref() {
366 struct_ser.serialize_field("info", v)?;
367 }
368 if !self.upstream_actors.is_empty() {
369 struct_ser.serialize_field("upstreamActors", &self.upstream_actors)?;
370 }
371 struct_ser.end()
372 }
373}
374impl<'de> serde::Deserialize<'de> for add_mutation::NewUpstreamSink {
375 #[allow(deprecated)]
376 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
377 where
378 D: serde::Deserializer<'de>,
379 {
380 const FIELDS: &[&str] = &[
381 "info",
382 "upstream_actors",
383 "upstreamActors",
384 ];
385
386 #[allow(clippy::enum_variant_names)]
387 enum GeneratedField {
388 Info,
389 UpstreamActors,
390 }
391 impl<'de> serde::Deserialize<'de> for GeneratedField {
392 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
393 where
394 D: serde::Deserializer<'de>,
395 {
396 struct GeneratedVisitor;
397
398 impl serde::de::Visitor<'_> for GeneratedVisitor {
399 type Value = GeneratedField;
400
401 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
402 write!(formatter, "expected one of: {:?}", &FIELDS)
403 }
404
405 #[allow(unused_variables)]
406 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
407 where
408 E: serde::de::Error,
409 {
410 match value {
411 "info" => Ok(GeneratedField::Info),
412 "upstreamActors" | "upstream_actors" => Ok(GeneratedField::UpstreamActors),
413 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
414 }
415 }
416 }
417 deserializer.deserialize_identifier(GeneratedVisitor)
418 }
419 }
420 struct GeneratedVisitor;
421 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
422 type Value = add_mutation::NewUpstreamSink;
423
424 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
425 formatter.write_str("struct stream_plan.AddMutation.NewUpstreamSink")
426 }
427
428 fn visit_map<V>(self, mut map_: V) -> std::result::Result<add_mutation::NewUpstreamSink, V::Error>
429 where
430 V: serde::de::MapAccess<'de>,
431 {
432 let mut info__ = None;
433 let mut upstream_actors__ = None;
434 while let Some(k) = map_.next_key()? {
435 match k {
436 GeneratedField::Info => {
437 if info__.is_some() {
438 return Err(serde::de::Error::duplicate_field("info"));
439 }
440 info__ = map_.next_value()?;
441 }
442 GeneratedField::UpstreamActors => {
443 if upstream_actors__.is_some() {
444 return Err(serde::de::Error::duplicate_field("upstreamActors"));
445 }
446 upstream_actors__ = Some(map_.next_value()?);
447 }
448 }
449 }
450 Ok(add_mutation::NewUpstreamSink {
451 info: info__,
452 upstream_actors: upstream_actors__.unwrap_or_default(),
453 })
454 }
455 }
456 deserializer.deserialize_struct("stream_plan.AddMutation.NewUpstreamSink", FIELDS, GeneratedVisitor)
457 }
458}
459impl serde::Serialize for AggCallState {
460 #[allow(deprecated)]
461 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
462 where
463 S: serde::Serializer,
464 {
465 use serde::ser::SerializeStruct;
466 let mut len = 0;
467 if self.inner.is_some() {
468 len += 1;
469 }
470 let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState", len)?;
471 if let Some(v) = self.inner.as_ref() {
472 match v {
473 agg_call_state::Inner::ValueState(v) => {
474 struct_ser.serialize_field("valueState", v)?;
475 }
476 agg_call_state::Inner::MaterializedInputState(v) => {
477 struct_ser.serialize_field("materializedInputState", v)?;
478 }
479 }
480 }
481 struct_ser.end()
482 }
483}
484impl<'de> serde::Deserialize<'de> for AggCallState {
485 #[allow(deprecated)]
486 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
487 where
488 D: serde::Deserializer<'de>,
489 {
490 const FIELDS: &[&str] = &[
491 "value_state",
492 "valueState",
493 "materialized_input_state",
494 "materializedInputState",
495 ];
496
497 #[allow(clippy::enum_variant_names)]
498 enum GeneratedField {
499 ValueState,
500 MaterializedInputState,
501 }
502 impl<'de> serde::Deserialize<'de> for GeneratedField {
503 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
504 where
505 D: serde::Deserializer<'de>,
506 {
507 struct GeneratedVisitor;
508
509 impl serde::de::Visitor<'_> for GeneratedVisitor {
510 type Value = GeneratedField;
511
512 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
513 write!(formatter, "expected one of: {:?}", &FIELDS)
514 }
515
516 #[allow(unused_variables)]
517 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
518 where
519 E: serde::de::Error,
520 {
521 match value {
522 "valueState" | "value_state" => Ok(GeneratedField::ValueState),
523 "materializedInputState" | "materialized_input_state" => Ok(GeneratedField::MaterializedInputState),
524 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
525 }
526 }
527 }
528 deserializer.deserialize_identifier(GeneratedVisitor)
529 }
530 }
531 struct GeneratedVisitor;
532 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
533 type Value = AggCallState;
534
535 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
536 formatter.write_str("struct stream_plan.AggCallState")
537 }
538
539 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AggCallState, V::Error>
540 where
541 V: serde::de::MapAccess<'de>,
542 {
543 let mut inner__ = None;
544 while let Some(k) = map_.next_key()? {
545 match k {
546 GeneratedField::ValueState => {
547 if inner__.is_some() {
548 return Err(serde::de::Error::duplicate_field("valueState"));
549 }
550 inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::ValueState)
551;
552 }
553 GeneratedField::MaterializedInputState => {
554 if inner__.is_some() {
555 return Err(serde::de::Error::duplicate_field("materializedInputState"));
556 }
557 inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::MaterializedInputState)
558;
559 }
560 }
561 }
562 Ok(AggCallState {
563 inner: inner__,
564 })
565 }
566 }
567 deserializer.deserialize_struct("stream_plan.AggCallState", FIELDS, GeneratedVisitor)
568 }
569}
570impl serde::Serialize for agg_call_state::MaterializedInputState {
571 #[allow(deprecated)]
572 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
573 where
574 S: serde::Serializer,
575 {
576 use serde::ser::SerializeStruct;
577 let mut len = 0;
578 if self.table.is_some() {
579 len += 1;
580 }
581 if !self.included_upstream_indices.is_empty() {
582 len += 1;
583 }
584 if !self.table_value_indices.is_empty() {
585 len += 1;
586 }
587 if !self.order_columns.is_empty() {
588 len += 1;
589 }
590 let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState.MaterializedInputState", len)?;
591 if let Some(v) = self.table.as_ref() {
592 struct_ser.serialize_field("table", v)?;
593 }
594 if !self.included_upstream_indices.is_empty() {
595 struct_ser.serialize_field("includedUpstreamIndices", &self.included_upstream_indices)?;
596 }
597 if !self.table_value_indices.is_empty() {
598 struct_ser.serialize_field("tableValueIndices", &self.table_value_indices)?;
599 }
600 if !self.order_columns.is_empty() {
601 struct_ser.serialize_field("orderColumns", &self.order_columns)?;
602 }
603 struct_ser.end()
604 }
605}
606impl<'de> serde::Deserialize<'de> for agg_call_state::MaterializedInputState {
607 #[allow(deprecated)]
608 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
609 where
610 D: serde::Deserializer<'de>,
611 {
612 const FIELDS: &[&str] = &[
613 "table",
614 "included_upstream_indices",
615 "includedUpstreamIndices",
616 "table_value_indices",
617 "tableValueIndices",
618 "order_columns",
619 "orderColumns",
620 ];
621
622 #[allow(clippy::enum_variant_names)]
623 enum GeneratedField {
624 Table,
625 IncludedUpstreamIndices,
626 TableValueIndices,
627 OrderColumns,
628 }
629 impl<'de> serde::Deserialize<'de> for GeneratedField {
630 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
631 where
632 D: serde::Deserializer<'de>,
633 {
634 struct GeneratedVisitor;
635
636 impl serde::de::Visitor<'_> for GeneratedVisitor {
637 type Value = GeneratedField;
638
639 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
640 write!(formatter, "expected one of: {:?}", &FIELDS)
641 }
642
643 #[allow(unused_variables)]
644 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
645 where
646 E: serde::de::Error,
647 {
648 match value {
649 "table" => Ok(GeneratedField::Table),
650 "includedUpstreamIndices" | "included_upstream_indices" => Ok(GeneratedField::IncludedUpstreamIndices),
651 "tableValueIndices" | "table_value_indices" => Ok(GeneratedField::TableValueIndices),
652 "orderColumns" | "order_columns" => Ok(GeneratedField::OrderColumns),
653 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
654 }
655 }
656 }
657 deserializer.deserialize_identifier(GeneratedVisitor)
658 }
659 }
660 struct GeneratedVisitor;
661 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
662 type Value = agg_call_state::MaterializedInputState;
663
664 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
665 formatter.write_str("struct stream_plan.AggCallState.MaterializedInputState")
666 }
667
668 fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::MaterializedInputState, V::Error>
669 where
670 V: serde::de::MapAccess<'de>,
671 {
672 let mut table__ = None;
673 let mut included_upstream_indices__ = None;
674 let mut table_value_indices__ = None;
675 let mut order_columns__ = None;
676 while let Some(k) = map_.next_key()? {
677 match k {
678 GeneratedField::Table => {
679 if table__.is_some() {
680 return Err(serde::de::Error::duplicate_field("table"));
681 }
682 table__ = map_.next_value()?;
683 }
684 GeneratedField::IncludedUpstreamIndices => {
685 if included_upstream_indices__.is_some() {
686 return Err(serde::de::Error::duplicate_field("includedUpstreamIndices"));
687 }
688 included_upstream_indices__ =
689 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
690 .into_iter().map(|x| x.0).collect())
691 ;
692 }
693 GeneratedField::TableValueIndices => {
694 if table_value_indices__.is_some() {
695 return Err(serde::de::Error::duplicate_field("tableValueIndices"));
696 }
697 table_value_indices__ =
698 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
699 .into_iter().map(|x| x.0).collect())
700 ;
701 }
702 GeneratedField::OrderColumns => {
703 if order_columns__.is_some() {
704 return Err(serde::de::Error::duplicate_field("orderColumns"));
705 }
706 order_columns__ = Some(map_.next_value()?);
707 }
708 }
709 }
710 Ok(agg_call_state::MaterializedInputState {
711 table: table__,
712 included_upstream_indices: included_upstream_indices__.unwrap_or_default(),
713 table_value_indices: table_value_indices__.unwrap_or_default(),
714 order_columns: order_columns__.unwrap_or_default(),
715 })
716 }
717 }
718 deserializer.deserialize_struct("stream_plan.AggCallState.MaterializedInputState", FIELDS, GeneratedVisitor)
719 }
720}
721impl serde::Serialize for agg_call_state::ValueState {
722 #[allow(deprecated)]
723 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
724 where
725 S: serde::Serializer,
726 {
727 use serde::ser::SerializeStruct;
728 let len = 0;
729 let struct_ser = serializer.serialize_struct("stream_plan.AggCallState.ValueState", len)?;
730 struct_ser.end()
731 }
732}
733impl<'de> serde::Deserialize<'de> for agg_call_state::ValueState {
734 #[allow(deprecated)]
735 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
736 where
737 D: serde::Deserializer<'de>,
738 {
739 const FIELDS: &[&str] = &[
740 ];
741
742 #[allow(clippy::enum_variant_names)]
743 enum GeneratedField {
744 }
745 impl<'de> serde::Deserialize<'de> for GeneratedField {
746 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
747 where
748 D: serde::Deserializer<'de>,
749 {
750 struct GeneratedVisitor;
751
752 impl serde::de::Visitor<'_> for GeneratedVisitor {
753 type Value = GeneratedField;
754
755 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
756 write!(formatter, "expected one of: {:?}", &FIELDS)
757 }
758
759 #[allow(unused_variables)]
760 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
761 where
762 E: serde::de::Error,
763 {
764 Err(serde::de::Error::unknown_field(value, FIELDS))
765 }
766 }
767 deserializer.deserialize_identifier(GeneratedVisitor)
768 }
769 }
770 struct GeneratedVisitor;
771 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
772 type Value = agg_call_state::ValueState;
773
774 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
775 formatter.write_str("struct stream_plan.AggCallState.ValueState")
776 }
777
778 fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::ValueState, V::Error>
779 where
780 V: serde::de::MapAccess<'de>,
781 {
782 while map_.next_key::<GeneratedField>()?.is_some() {
783 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
784 }
785 Ok(agg_call_state::ValueState {
786 })
787 }
788 }
789 deserializer.deserialize_struct("stream_plan.AggCallState.ValueState", FIELDS, GeneratedVisitor)
790 }
791}
792impl serde::Serialize for AggNodeVersion {
793 #[allow(deprecated)]
794 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
795 where
796 S: serde::Serializer,
797 {
798 let variant = match self {
799 Self::Unspecified => "AGG_NODE_VERSION_UNSPECIFIED",
800 Self::Issue12140 => "AGG_NODE_VERSION_ISSUE_12140",
801 Self::Issue13465 => "AGG_NODE_VERSION_ISSUE_13465",
802 };
803 serializer.serialize_str(variant)
804 }
805}
806impl<'de> serde::Deserialize<'de> for AggNodeVersion {
807 #[allow(deprecated)]
808 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
809 where
810 D: serde::Deserializer<'de>,
811 {
812 const FIELDS: &[&str] = &[
813 "AGG_NODE_VERSION_UNSPECIFIED",
814 "AGG_NODE_VERSION_ISSUE_12140",
815 "AGG_NODE_VERSION_ISSUE_13465",
816 ];
817
818 struct GeneratedVisitor;
819
820 impl serde::de::Visitor<'_> for GeneratedVisitor {
821 type Value = AggNodeVersion;
822
823 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
824 write!(formatter, "expected one of: {:?}", &FIELDS)
825 }
826
827 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
828 where
829 E: serde::de::Error,
830 {
831 i32::try_from(v)
832 .ok()
833 .and_then(|x| x.try_into().ok())
834 .ok_or_else(|| {
835 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
836 })
837 }
838
839 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
840 where
841 E: serde::de::Error,
842 {
843 i32::try_from(v)
844 .ok()
845 .and_then(|x| x.try_into().ok())
846 .ok_or_else(|| {
847 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
848 })
849 }
850
851 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
852 where
853 E: serde::de::Error,
854 {
855 match value {
856 "AGG_NODE_VERSION_UNSPECIFIED" => Ok(AggNodeVersion::Unspecified),
857 "AGG_NODE_VERSION_ISSUE_12140" => Ok(AggNodeVersion::Issue12140),
858 "AGG_NODE_VERSION_ISSUE_13465" => Ok(AggNodeVersion::Issue13465),
859 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
860 }
861 }
862 }
863 deserializer.deserialize_any(GeneratedVisitor)
864 }
865}
866impl serde::Serialize for ArrangeNode {
867 #[allow(deprecated)]
868 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
869 where
870 S: serde::Serializer,
871 {
872 use serde::ser::SerializeStruct;
873 let mut len = 0;
874 if self.table_info.is_some() {
875 len += 1;
876 }
877 if !self.distribution_key.is_empty() {
878 len += 1;
879 }
880 if self.table.is_some() {
881 len += 1;
882 }
883 let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangeNode", len)?;
884 if let Some(v) = self.table_info.as_ref() {
885 struct_ser.serialize_field("tableInfo", v)?;
886 }
887 if !self.distribution_key.is_empty() {
888 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
889 }
890 if let Some(v) = self.table.as_ref() {
891 struct_ser.serialize_field("table", v)?;
892 }
893 struct_ser.end()
894 }
895}
896impl<'de> serde::Deserialize<'de> for ArrangeNode {
897 #[allow(deprecated)]
898 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
899 where
900 D: serde::Deserializer<'de>,
901 {
902 const FIELDS: &[&str] = &[
903 "table_info",
904 "tableInfo",
905 "distribution_key",
906 "distributionKey",
907 "table",
908 ];
909
910 #[allow(clippy::enum_variant_names)]
911 enum GeneratedField {
912 TableInfo,
913 DistributionKey,
914 Table,
915 }
916 impl<'de> serde::Deserialize<'de> for GeneratedField {
917 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
918 where
919 D: serde::Deserializer<'de>,
920 {
921 struct GeneratedVisitor;
922
923 impl serde::de::Visitor<'_> for GeneratedVisitor {
924 type Value = GeneratedField;
925
926 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
927 write!(formatter, "expected one of: {:?}", &FIELDS)
928 }
929
930 #[allow(unused_variables)]
931 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
932 where
933 E: serde::de::Error,
934 {
935 match value {
936 "tableInfo" | "table_info" => Ok(GeneratedField::TableInfo),
937 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
938 "table" => Ok(GeneratedField::Table),
939 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
940 }
941 }
942 }
943 deserializer.deserialize_identifier(GeneratedVisitor)
944 }
945 }
946 struct GeneratedVisitor;
947 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
948 type Value = ArrangeNode;
949
950 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
951 formatter.write_str("struct stream_plan.ArrangeNode")
952 }
953
954 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangeNode, V::Error>
955 where
956 V: serde::de::MapAccess<'de>,
957 {
958 let mut table_info__ = None;
959 let mut distribution_key__ = None;
960 let mut table__ = None;
961 while let Some(k) = map_.next_key()? {
962 match k {
963 GeneratedField::TableInfo => {
964 if table_info__.is_some() {
965 return Err(serde::de::Error::duplicate_field("tableInfo"));
966 }
967 table_info__ = map_.next_value()?;
968 }
969 GeneratedField::DistributionKey => {
970 if distribution_key__.is_some() {
971 return Err(serde::de::Error::duplicate_field("distributionKey"));
972 }
973 distribution_key__ =
974 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
975 .into_iter().map(|x| x.0).collect())
976 ;
977 }
978 GeneratedField::Table => {
979 if table__.is_some() {
980 return Err(serde::de::Error::duplicate_field("table"));
981 }
982 table__ = map_.next_value()?;
983 }
984 }
985 }
986 Ok(ArrangeNode {
987 table_info: table_info__,
988 distribution_key: distribution_key__.unwrap_or_default(),
989 table: table__,
990 })
991 }
992 }
993 deserializer.deserialize_struct("stream_plan.ArrangeNode", FIELDS, GeneratedVisitor)
994 }
995}
996impl serde::Serialize for ArrangementInfo {
997 #[allow(deprecated)]
998 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
999 where
1000 S: serde::Serializer,
1001 {
1002 use serde::ser::SerializeStruct;
1003 let mut len = 0;
1004 if !self.arrange_key_orders.is_empty() {
1005 len += 1;
1006 }
1007 if !self.column_descs.is_empty() {
1008 len += 1;
1009 }
1010 if self.table_desc.is_some() {
1011 len += 1;
1012 }
1013 if !self.output_col_idx.is_empty() {
1014 len += 1;
1015 }
1016 let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangementInfo", len)?;
1017 if !self.arrange_key_orders.is_empty() {
1018 struct_ser.serialize_field("arrangeKeyOrders", &self.arrange_key_orders)?;
1019 }
1020 if !self.column_descs.is_empty() {
1021 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
1022 }
1023 if let Some(v) = self.table_desc.as_ref() {
1024 struct_ser.serialize_field("tableDesc", v)?;
1025 }
1026 if !self.output_col_idx.is_empty() {
1027 struct_ser.serialize_field("outputColIdx", &self.output_col_idx)?;
1028 }
1029 struct_ser.end()
1030 }
1031}
1032impl<'de> serde::Deserialize<'de> for ArrangementInfo {
1033 #[allow(deprecated)]
1034 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1035 where
1036 D: serde::Deserializer<'de>,
1037 {
1038 const FIELDS: &[&str] = &[
1039 "arrange_key_orders",
1040 "arrangeKeyOrders",
1041 "column_descs",
1042 "columnDescs",
1043 "table_desc",
1044 "tableDesc",
1045 "output_col_idx",
1046 "outputColIdx",
1047 ];
1048
1049 #[allow(clippy::enum_variant_names)]
1050 enum GeneratedField {
1051 ArrangeKeyOrders,
1052 ColumnDescs,
1053 TableDesc,
1054 OutputColIdx,
1055 }
1056 impl<'de> serde::Deserialize<'de> for GeneratedField {
1057 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1058 where
1059 D: serde::Deserializer<'de>,
1060 {
1061 struct GeneratedVisitor;
1062
1063 impl serde::de::Visitor<'_> for GeneratedVisitor {
1064 type Value = GeneratedField;
1065
1066 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1067 write!(formatter, "expected one of: {:?}", &FIELDS)
1068 }
1069
1070 #[allow(unused_variables)]
1071 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1072 where
1073 E: serde::de::Error,
1074 {
1075 match value {
1076 "arrangeKeyOrders" | "arrange_key_orders" => Ok(GeneratedField::ArrangeKeyOrders),
1077 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
1078 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
1079 "outputColIdx" | "output_col_idx" => Ok(GeneratedField::OutputColIdx),
1080 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1081 }
1082 }
1083 }
1084 deserializer.deserialize_identifier(GeneratedVisitor)
1085 }
1086 }
1087 struct GeneratedVisitor;
1088 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1089 type Value = ArrangementInfo;
1090
1091 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1092 formatter.write_str("struct stream_plan.ArrangementInfo")
1093 }
1094
1095 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangementInfo, V::Error>
1096 where
1097 V: serde::de::MapAccess<'de>,
1098 {
1099 let mut arrange_key_orders__ = None;
1100 let mut column_descs__ = None;
1101 let mut table_desc__ = None;
1102 let mut output_col_idx__ = None;
1103 while let Some(k) = map_.next_key()? {
1104 match k {
1105 GeneratedField::ArrangeKeyOrders => {
1106 if arrange_key_orders__.is_some() {
1107 return Err(serde::de::Error::duplicate_field("arrangeKeyOrders"));
1108 }
1109 arrange_key_orders__ = Some(map_.next_value()?);
1110 }
1111 GeneratedField::ColumnDescs => {
1112 if column_descs__.is_some() {
1113 return Err(serde::de::Error::duplicate_field("columnDescs"));
1114 }
1115 column_descs__ = Some(map_.next_value()?);
1116 }
1117 GeneratedField::TableDesc => {
1118 if table_desc__.is_some() {
1119 return Err(serde::de::Error::duplicate_field("tableDesc"));
1120 }
1121 table_desc__ = map_.next_value()?;
1122 }
1123 GeneratedField::OutputColIdx => {
1124 if output_col_idx__.is_some() {
1125 return Err(serde::de::Error::duplicate_field("outputColIdx"));
1126 }
1127 output_col_idx__ =
1128 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1129 .into_iter().map(|x| x.0).collect())
1130 ;
1131 }
1132 }
1133 }
1134 Ok(ArrangementInfo {
1135 arrange_key_orders: arrange_key_orders__.unwrap_or_default(),
1136 column_descs: column_descs__.unwrap_or_default(),
1137 table_desc: table_desc__,
1138 output_col_idx: output_col_idx__.unwrap_or_default(),
1139 })
1140 }
1141 }
1142 deserializer.deserialize_struct("stream_plan.ArrangementInfo", FIELDS, GeneratedVisitor)
1143 }
1144}
1145impl serde::Serialize for AsOfJoinNode {
1146 #[allow(deprecated)]
1147 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1148 where
1149 S: serde::Serializer,
1150 {
1151 use serde::ser::SerializeStruct;
1152 let mut len = 0;
1153 if self.join_type != 0 {
1154 len += 1;
1155 }
1156 if !self.left_key.is_empty() {
1157 len += 1;
1158 }
1159 if !self.right_key.is_empty() {
1160 len += 1;
1161 }
1162 if self.left_table.is_some() {
1163 len += 1;
1164 }
1165 if self.right_table.is_some() {
1166 len += 1;
1167 }
1168 if !self.output_indices.is_empty() {
1169 len += 1;
1170 }
1171 if !self.left_deduped_input_pk_indices.is_empty() {
1172 len += 1;
1173 }
1174 if !self.right_deduped_input_pk_indices.is_empty() {
1175 len += 1;
1176 }
1177 if !self.null_safe.is_empty() {
1178 len += 1;
1179 }
1180 if self.asof_desc.is_some() {
1181 len += 1;
1182 }
1183 if self.join_encoding_type != 0 {
1184 len += 1;
1185 }
1186 let mut struct_ser = serializer.serialize_struct("stream_plan.AsOfJoinNode", len)?;
1187 if self.join_type != 0 {
1188 let v = super::plan_common::AsOfJoinType::try_from(self.join_type)
1189 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
1190 struct_ser.serialize_field("joinType", &v)?;
1191 }
1192 if !self.left_key.is_empty() {
1193 struct_ser.serialize_field("leftKey", &self.left_key)?;
1194 }
1195 if !self.right_key.is_empty() {
1196 struct_ser.serialize_field("rightKey", &self.right_key)?;
1197 }
1198 if let Some(v) = self.left_table.as_ref() {
1199 struct_ser.serialize_field("leftTable", v)?;
1200 }
1201 if let Some(v) = self.right_table.as_ref() {
1202 struct_ser.serialize_field("rightTable", v)?;
1203 }
1204 if !self.output_indices.is_empty() {
1205 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
1206 }
1207 if !self.left_deduped_input_pk_indices.is_empty() {
1208 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
1209 }
1210 if !self.right_deduped_input_pk_indices.is_empty() {
1211 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
1212 }
1213 if !self.null_safe.is_empty() {
1214 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
1215 }
1216 if let Some(v) = self.asof_desc.as_ref() {
1217 struct_ser.serialize_field("asofDesc", v)?;
1218 }
1219 if self.join_encoding_type != 0 {
1220 let v = JoinEncodingType::try_from(self.join_encoding_type)
1221 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
1222 struct_ser.serialize_field("joinEncodingType", &v)?;
1223 }
1224 struct_ser.end()
1225 }
1226}
1227impl<'de> serde::Deserialize<'de> for AsOfJoinNode {
1228 #[allow(deprecated)]
1229 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1230 where
1231 D: serde::Deserializer<'de>,
1232 {
1233 const FIELDS: &[&str] = &[
1234 "join_type",
1235 "joinType",
1236 "left_key",
1237 "leftKey",
1238 "right_key",
1239 "rightKey",
1240 "left_table",
1241 "leftTable",
1242 "right_table",
1243 "rightTable",
1244 "output_indices",
1245 "outputIndices",
1246 "left_deduped_input_pk_indices",
1247 "leftDedupedInputPkIndices",
1248 "right_deduped_input_pk_indices",
1249 "rightDedupedInputPkIndices",
1250 "null_safe",
1251 "nullSafe",
1252 "asof_desc",
1253 "asofDesc",
1254 "join_encoding_type",
1255 "joinEncodingType",
1256 ];
1257
1258 #[allow(clippy::enum_variant_names)]
1259 enum GeneratedField {
1260 JoinType,
1261 LeftKey,
1262 RightKey,
1263 LeftTable,
1264 RightTable,
1265 OutputIndices,
1266 LeftDedupedInputPkIndices,
1267 RightDedupedInputPkIndices,
1268 NullSafe,
1269 AsofDesc,
1270 JoinEncodingType,
1271 }
1272 impl<'de> serde::Deserialize<'de> for GeneratedField {
1273 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1274 where
1275 D: serde::Deserializer<'de>,
1276 {
1277 struct GeneratedVisitor;
1278
1279 impl serde::de::Visitor<'_> for GeneratedVisitor {
1280 type Value = GeneratedField;
1281
1282 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1283 write!(formatter, "expected one of: {:?}", &FIELDS)
1284 }
1285
1286 #[allow(unused_variables)]
1287 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1288 where
1289 E: serde::de::Error,
1290 {
1291 match value {
1292 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
1293 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
1294 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
1295 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
1296 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
1297 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
1298 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
1299 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
1300 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
1301 "asofDesc" | "asof_desc" => Ok(GeneratedField::AsofDesc),
1302 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
1303 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1304 }
1305 }
1306 }
1307 deserializer.deserialize_identifier(GeneratedVisitor)
1308 }
1309 }
1310 struct GeneratedVisitor;
1311 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1312 type Value = AsOfJoinNode;
1313
1314 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1315 formatter.write_str("struct stream_plan.AsOfJoinNode")
1316 }
1317
1318 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AsOfJoinNode, V::Error>
1319 where
1320 V: serde::de::MapAccess<'de>,
1321 {
1322 let mut join_type__ = None;
1323 let mut left_key__ = None;
1324 let mut right_key__ = None;
1325 let mut left_table__ = None;
1326 let mut right_table__ = None;
1327 let mut output_indices__ = None;
1328 let mut left_deduped_input_pk_indices__ = None;
1329 let mut right_deduped_input_pk_indices__ = None;
1330 let mut null_safe__ = None;
1331 let mut asof_desc__ = None;
1332 let mut join_encoding_type__ = None;
1333 while let Some(k) = map_.next_key()? {
1334 match k {
1335 GeneratedField::JoinType => {
1336 if join_type__.is_some() {
1337 return Err(serde::de::Error::duplicate_field("joinType"));
1338 }
1339 join_type__ = Some(map_.next_value::<super::plan_common::AsOfJoinType>()? as i32);
1340 }
1341 GeneratedField::LeftKey => {
1342 if left_key__.is_some() {
1343 return Err(serde::de::Error::duplicate_field("leftKey"));
1344 }
1345 left_key__ =
1346 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1347 .into_iter().map(|x| x.0).collect())
1348 ;
1349 }
1350 GeneratedField::RightKey => {
1351 if right_key__.is_some() {
1352 return Err(serde::de::Error::duplicate_field("rightKey"));
1353 }
1354 right_key__ =
1355 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1356 .into_iter().map(|x| x.0).collect())
1357 ;
1358 }
1359 GeneratedField::LeftTable => {
1360 if left_table__.is_some() {
1361 return Err(serde::de::Error::duplicate_field("leftTable"));
1362 }
1363 left_table__ = map_.next_value()?;
1364 }
1365 GeneratedField::RightTable => {
1366 if right_table__.is_some() {
1367 return Err(serde::de::Error::duplicate_field("rightTable"));
1368 }
1369 right_table__ = map_.next_value()?;
1370 }
1371 GeneratedField::OutputIndices => {
1372 if output_indices__.is_some() {
1373 return Err(serde::de::Error::duplicate_field("outputIndices"));
1374 }
1375 output_indices__ =
1376 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1377 .into_iter().map(|x| x.0).collect())
1378 ;
1379 }
1380 GeneratedField::LeftDedupedInputPkIndices => {
1381 if left_deduped_input_pk_indices__.is_some() {
1382 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
1383 }
1384 left_deduped_input_pk_indices__ =
1385 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1386 .into_iter().map(|x| x.0).collect())
1387 ;
1388 }
1389 GeneratedField::RightDedupedInputPkIndices => {
1390 if right_deduped_input_pk_indices__.is_some() {
1391 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
1392 }
1393 right_deduped_input_pk_indices__ =
1394 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1395 .into_iter().map(|x| x.0).collect())
1396 ;
1397 }
1398 GeneratedField::NullSafe => {
1399 if null_safe__.is_some() {
1400 return Err(serde::de::Error::duplicate_field("nullSafe"));
1401 }
1402 null_safe__ = Some(map_.next_value()?);
1403 }
1404 GeneratedField::AsofDesc => {
1405 if asof_desc__.is_some() {
1406 return Err(serde::de::Error::duplicate_field("asofDesc"));
1407 }
1408 asof_desc__ = map_.next_value()?;
1409 }
1410 GeneratedField::JoinEncodingType => {
1411 if join_encoding_type__.is_some() {
1412 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
1413 }
1414 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
1415 }
1416 }
1417 }
1418 Ok(AsOfJoinNode {
1419 join_type: join_type__.unwrap_or_default(),
1420 left_key: left_key__.unwrap_or_default(),
1421 right_key: right_key__.unwrap_or_default(),
1422 left_table: left_table__,
1423 right_table: right_table__,
1424 output_indices: output_indices__.unwrap_or_default(),
1425 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
1426 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
1427 null_safe: null_safe__.unwrap_or_default(),
1428 asof_desc: asof_desc__,
1429 join_encoding_type: join_encoding_type__.unwrap_or_default(),
1430 })
1431 }
1432 }
1433 deserializer.deserialize_struct("stream_plan.AsOfJoinNode", FIELDS, GeneratedVisitor)
1434 }
1435}
1436impl serde::Serialize for BackfillOrder {
1437 #[allow(deprecated)]
1438 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1439 where
1440 S: serde::Serializer,
1441 {
1442 use serde::ser::SerializeStruct;
1443 let mut len = 0;
1444 if !self.order.is_empty() {
1445 len += 1;
1446 }
1447 let mut struct_ser = serializer.serialize_struct("stream_plan.BackfillOrder", len)?;
1448 if !self.order.is_empty() {
1449 struct_ser.serialize_field("order", &self.order)?;
1450 }
1451 struct_ser.end()
1452 }
1453}
1454impl<'de> serde::Deserialize<'de> for BackfillOrder {
1455 #[allow(deprecated)]
1456 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1457 where
1458 D: serde::Deserializer<'de>,
1459 {
1460 const FIELDS: &[&str] = &[
1461 "order",
1462 ];
1463
1464 #[allow(clippy::enum_variant_names)]
1465 enum GeneratedField {
1466 Order,
1467 }
1468 impl<'de> serde::Deserialize<'de> for GeneratedField {
1469 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1470 where
1471 D: serde::Deserializer<'de>,
1472 {
1473 struct GeneratedVisitor;
1474
1475 impl serde::de::Visitor<'_> for GeneratedVisitor {
1476 type Value = GeneratedField;
1477
1478 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1479 write!(formatter, "expected one of: {:?}", &FIELDS)
1480 }
1481
1482 #[allow(unused_variables)]
1483 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1484 where
1485 E: serde::de::Error,
1486 {
1487 match value {
1488 "order" => Ok(GeneratedField::Order),
1489 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1490 }
1491 }
1492 }
1493 deserializer.deserialize_identifier(GeneratedVisitor)
1494 }
1495 }
1496 struct GeneratedVisitor;
1497 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1498 type Value = BackfillOrder;
1499
1500 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1501 formatter.write_str("struct stream_plan.BackfillOrder")
1502 }
1503
1504 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BackfillOrder, V::Error>
1505 where
1506 V: serde::de::MapAccess<'de>,
1507 {
1508 let mut order__ = None;
1509 while let Some(k) = map_.next_key()? {
1510 match k {
1511 GeneratedField::Order => {
1512 if order__.is_some() {
1513 return Err(serde::de::Error::duplicate_field("order"));
1514 }
1515 order__ = Some(
1516 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1517 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1518 );
1519 }
1520 }
1521 }
1522 Ok(BackfillOrder {
1523 order: order__.unwrap_or_default(),
1524 })
1525 }
1526 }
1527 deserializer.deserialize_struct("stream_plan.BackfillOrder", FIELDS, GeneratedVisitor)
1528 }
1529}
1530impl serde::Serialize for Barrier {
1531 #[allow(deprecated)]
1532 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1533 where
1534 S: serde::Serializer,
1535 {
1536 use serde::ser::SerializeStruct;
1537 let mut len = 0;
1538 if self.epoch.is_some() {
1539 len += 1;
1540 }
1541 if self.mutation.is_some() {
1542 len += 1;
1543 }
1544 if !self.tracing_context.is_empty() {
1545 len += 1;
1546 }
1547 if self.kind != 0 {
1548 len += 1;
1549 }
1550 let mut struct_ser = serializer.serialize_struct("stream_plan.Barrier", len)?;
1551 if let Some(v) = self.epoch.as_ref() {
1552 struct_ser.serialize_field("epoch", v)?;
1553 }
1554 if let Some(v) = self.mutation.as_ref() {
1555 struct_ser.serialize_field("mutation", v)?;
1556 }
1557 if !self.tracing_context.is_empty() {
1558 struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
1559 }
1560 if self.kind != 0 {
1561 let v = barrier::BarrierKind::try_from(self.kind)
1562 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
1563 struct_ser.serialize_field("kind", &v)?;
1564 }
1565 struct_ser.end()
1566 }
1567}
1568impl<'de> serde::Deserialize<'de> for Barrier {
1569 #[allow(deprecated)]
1570 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1571 where
1572 D: serde::Deserializer<'de>,
1573 {
1574 const FIELDS: &[&str] = &[
1575 "epoch",
1576 "mutation",
1577 "tracing_context",
1578 "tracingContext",
1579 "kind",
1580 ];
1581
1582 #[allow(clippy::enum_variant_names)]
1583 enum GeneratedField {
1584 Epoch,
1585 Mutation,
1586 TracingContext,
1587 Kind,
1588 }
1589 impl<'de> serde::Deserialize<'de> for GeneratedField {
1590 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1591 where
1592 D: serde::Deserializer<'de>,
1593 {
1594 struct GeneratedVisitor;
1595
1596 impl serde::de::Visitor<'_> for GeneratedVisitor {
1597 type Value = GeneratedField;
1598
1599 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1600 write!(formatter, "expected one of: {:?}", &FIELDS)
1601 }
1602
1603 #[allow(unused_variables)]
1604 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1605 where
1606 E: serde::de::Error,
1607 {
1608 match value {
1609 "epoch" => Ok(GeneratedField::Epoch),
1610 "mutation" => Ok(GeneratedField::Mutation),
1611 "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
1612 "kind" => Ok(GeneratedField::Kind),
1613 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1614 }
1615 }
1616 }
1617 deserializer.deserialize_identifier(GeneratedVisitor)
1618 }
1619 }
1620 struct GeneratedVisitor;
1621 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1622 type Value = Barrier;
1623
1624 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1625 formatter.write_str("struct stream_plan.Barrier")
1626 }
1627
1628 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Barrier, V::Error>
1629 where
1630 V: serde::de::MapAccess<'de>,
1631 {
1632 let mut epoch__ = None;
1633 let mut mutation__ = None;
1634 let mut tracing_context__ = None;
1635 let mut kind__ = None;
1636 while let Some(k) = map_.next_key()? {
1637 match k {
1638 GeneratedField::Epoch => {
1639 if epoch__.is_some() {
1640 return Err(serde::de::Error::duplicate_field("epoch"));
1641 }
1642 epoch__ = map_.next_value()?;
1643 }
1644 GeneratedField::Mutation => {
1645 if mutation__.is_some() {
1646 return Err(serde::de::Error::duplicate_field("mutation"));
1647 }
1648 mutation__ = map_.next_value()?;
1649 }
1650 GeneratedField::TracingContext => {
1651 if tracing_context__.is_some() {
1652 return Err(serde::de::Error::duplicate_field("tracingContext"));
1653 }
1654 tracing_context__ = Some(
1655 map_.next_value::<std::collections::HashMap<_, _>>()?
1656 );
1657 }
1658 GeneratedField::Kind => {
1659 if kind__.is_some() {
1660 return Err(serde::de::Error::duplicate_field("kind"));
1661 }
1662 kind__ = Some(map_.next_value::<barrier::BarrierKind>()? as i32);
1663 }
1664 }
1665 }
1666 Ok(Barrier {
1667 epoch: epoch__,
1668 mutation: mutation__,
1669 tracing_context: tracing_context__.unwrap_or_default(),
1670 kind: kind__.unwrap_or_default(),
1671 })
1672 }
1673 }
1674 deserializer.deserialize_struct("stream_plan.Barrier", FIELDS, GeneratedVisitor)
1675 }
1676}
1677impl serde::Serialize for barrier::BarrierKind {
1678 #[allow(deprecated)]
1679 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1680 where
1681 S: serde::Serializer,
1682 {
1683 let variant = match self {
1684 Self::Unspecified => "BARRIER_KIND_UNSPECIFIED",
1685 Self::Initial => "BARRIER_KIND_INITIAL",
1686 Self::Barrier => "BARRIER_KIND_BARRIER",
1687 Self::Checkpoint => "BARRIER_KIND_CHECKPOINT",
1688 };
1689 serializer.serialize_str(variant)
1690 }
1691}
1692impl<'de> serde::Deserialize<'de> for barrier::BarrierKind {
1693 #[allow(deprecated)]
1694 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1695 where
1696 D: serde::Deserializer<'de>,
1697 {
1698 const FIELDS: &[&str] = &[
1699 "BARRIER_KIND_UNSPECIFIED",
1700 "BARRIER_KIND_INITIAL",
1701 "BARRIER_KIND_BARRIER",
1702 "BARRIER_KIND_CHECKPOINT",
1703 ];
1704
1705 struct GeneratedVisitor;
1706
1707 impl serde::de::Visitor<'_> for GeneratedVisitor {
1708 type Value = barrier::BarrierKind;
1709
1710 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1711 write!(formatter, "expected one of: {:?}", &FIELDS)
1712 }
1713
1714 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1715 where
1716 E: serde::de::Error,
1717 {
1718 i32::try_from(v)
1719 .ok()
1720 .and_then(|x| x.try_into().ok())
1721 .ok_or_else(|| {
1722 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1723 })
1724 }
1725
1726 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1727 where
1728 E: serde::de::Error,
1729 {
1730 i32::try_from(v)
1731 .ok()
1732 .and_then(|x| x.try_into().ok())
1733 .ok_or_else(|| {
1734 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1735 })
1736 }
1737
1738 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1739 where
1740 E: serde::de::Error,
1741 {
1742 match value {
1743 "BARRIER_KIND_UNSPECIFIED" => Ok(barrier::BarrierKind::Unspecified),
1744 "BARRIER_KIND_INITIAL" => Ok(barrier::BarrierKind::Initial),
1745 "BARRIER_KIND_BARRIER" => Ok(barrier::BarrierKind::Barrier),
1746 "BARRIER_KIND_CHECKPOINT" => Ok(barrier::BarrierKind::Checkpoint),
1747 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1748 }
1749 }
1750 }
1751 deserializer.deserialize_any(GeneratedVisitor)
1752 }
1753}
1754impl serde::Serialize for BarrierMutation {
1755 #[allow(deprecated)]
1756 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1757 where
1758 S: serde::Serializer,
1759 {
1760 use serde::ser::SerializeStruct;
1761 let mut len = 0;
1762 if self.mutation.is_some() {
1763 len += 1;
1764 }
1765 let mut struct_ser = serializer.serialize_struct("stream_plan.BarrierMutation", len)?;
1766 if let Some(v) = self.mutation.as_ref() {
1767 match v {
1768 barrier_mutation::Mutation::Add(v) => {
1769 struct_ser.serialize_field("add", v)?;
1770 }
1771 barrier_mutation::Mutation::Stop(v) => {
1772 struct_ser.serialize_field("stop", v)?;
1773 }
1774 barrier_mutation::Mutation::Update(v) => {
1775 struct_ser.serialize_field("update", v)?;
1776 }
1777 barrier_mutation::Mutation::Splits(v) => {
1778 struct_ser.serialize_field("splits", v)?;
1779 }
1780 barrier_mutation::Mutation::Pause(v) => {
1781 struct_ser.serialize_field("pause", v)?;
1782 }
1783 barrier_mutation::Mutation::Resume(v) => {
1784 struct_ser.serialize_field("resume", v)?;
1785 }
1786 barrier_mutation::Mutation::Throttle(v) => {
1787 struct_ser.serialize_field("throttle", v)?;
1788 }
1789 barrier_mutation::Mutation::DropSubscriptions(v) => {
1790 struct_ser.serialize_field("dropSubscriptions", v)?;
1791 }
1792 barrier_mutation::Mutation::ConnectorPropsChange(v) => {
1793 struct_ser.serialize_field("connectorPropsChange", v)?;
1794 }
1795 barrier_mutation::Mutation::StartFragmentBackfill(v) => {
1796 struct_ser.serialize_field("startFragmentBackfill", v)?;
1797 }
1798 barrier_mutation::Mutation::RefreshStart(v) => {
1799 struct_ser.serialize_field("refreshStart", v)?;
1800 }
1801 barrier_mutation::Mutation::LoadFinish(v) => {
1802 struct_ser.serialize_field("loadFinish", v)?;
1803 }
1804 barrier_mutation::Mutation::ListFinish(v) => {
1805 struct_ser.serialize_field("listFinish", v)?;
1806 }
1807 barrier_mutation::Mutation::ResetSource(v) => {
1808 struct_ser.serialize_field("resetSource", v)?;
1809 }
1810 barrier_mutation::Mutation::InjectSourceOffsets(v) => {
1811 struct_ser.serialize_field("injectSourceOffsets", v)?;
1812 }
1813 }
1814 }
1815 struct_ser.end()
1816 }
1817}
1818impl<'de> serde::Deserialize<'de> for BarrierMutation {
1819 #[allow(deprecated)]
1820 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1821 where
1822 D: serde::Deserializer<'de>,
1823 {
1824 const FIELDS: &[&str] = &[
1825 "add",
1826 "stop",
1827 "update",
1828 "splits",
1829 "pause",
1830 "resume",
1831 "throttle",
1832 "drop_subscriptions",
1833 "dropSubscriptions",
1834 "connector_props_change",
1835 "connectorPropsChange",
1836 "start_fragment_backfill",
1837 "startFragmentBackfill",
1838 "refresh_start",
1839 "refreshStart",
1840 "load_finish",
1841 "loadFinish",
1842 "list_finish",
1843 "listFinish",
1844 "reset_source",
1845 "resetSource",
1846 "inject_source_offsets",
1847 "injectSourceOffsets",
1848 ];
1849
1850 #[allow(clippy::enum_variant_names)]
1851 enum GeneratedField {
1852 Add,
1853 Stop,
1854 Update,
1855 Splits,
1856 Pause,
1857 Resume,
1858 Throttle,
1859 DropSubscriptions,
1860 ConnectorPropsChange,
1861 StartFragmentBackfill,
1862 RefreshStart,
1863 LoadFinish,
1864 ListFinish,
1865 ResetSource,
1866 InjectSourceOffsets,
1867 }
1868 impl<'de> serde::Deserialize<'de> for GeneratedField {
1869 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1870 where
1871 D: serde::Deserializer<'de>,
1872 {
1873 struct GeneratedVisitor;
1874
1875 impl serde::de::Visitor<'_> for GeneratedVisitor {
1876 type Value = GeneratedField;
1877
1878 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1879 write!(formatter, "expected one of: {:?}", &FIELDS)
1880 }
1881
1882 #[allow(unused_variables)]
1883 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1884 where
1885 E: serde::de::Error,
1886 {
1887 match value {
1888 "add" => Ok(GeneratedField::Add),
1889 "stop" => Ok(GeneratedField::Stop),
1890 "update" => Ok(GeneratedField::Update),
1891 "splits" => Ok(GeneratedField::Splits),
1892 "pause" => Ok(GeneratedField::Pause),
1893 "resume" => Ok(GeneratedField::Resume),
1894 "throttle" => Ok(GeneratedField::Throttle),
1895 "dropSubscriptions" | "drop_subscriptions" => Ok(GeneratedField::DropSubscriptions),
1896 "connectorPropsChange" | "connector_props_change" => Ok(GeneratedField::ConnectorPropsChange),
1897 "startFragmentBackfill" | "start_fragment_backfill" => Ok(GeneratedField::StartFragmentBackfill),
1898 "refreshStart" | "refresh_start" => Ok(GeneratedField::RefreshStart),
1899 "loadFinish" | "load_finish" => Ok(GeneratedField::LoadFinish),
1900 "listFinish" | "list_finish" => Ok(GeneratedField::ListFinish),
1901 "resetSource" | "reset_source" => Ok(GeneratedField::ResetSource),
1902 "injectSourceOffsets" | "inject_source_offsets" => Ok(GeneratedField::InjectSourceOffsets),
1903 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1904 }
1905 }
1906 }
1907 deserializer.deserialize_identifier(GeneratedVisitor)
1908 }
1909 }
1910 struct GeneratedVisitor;
1911 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1912 type Value = BarrierMutation;
1913
1914 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1915 formatter.write_str("struct stream_plan.BarrierMutation")
1916 }
1917
1918 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierMutation, V::Error>
1919 where
1920 V: serde::de::MapAccess<'de>,
1921 {
1922 let mut mutation__ = None;
1923 while let Some(k) = map_.next_key()? {
1924 match k {
1925 GeneratedField::Add => {
1926 if mutation__.is_some() {
1927 return Err(serde::de::Error::duplicate_field("add"));
1928 }
1929 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Add)
1930;
1931 }
1932 GeneratedField::Stop => {
1933 if mutation__.is_some() {
1934 return Err(serde::de::Error::duplicate_field("stop"));
1935 }
1936 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Stop)
1937;
1938 }
1939 GeneratedField::Update => {
1940 if mutation__.is_some() {
1941 return Err(serde::de::Error::duplicate_field("update"));
1942 }
1943 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Update)
1944;
1945 }
1946 GeneratedField::Splits => {
1947 if mutation__.is_some() {
1948 return Err(serde::de::Error::duplicate_field("splits"));
1949 }
1950 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Splits)
1951;
1952 }
1953 GeneratedField::Pause => {
1954 if mutation__.is_some() {
1955 return Err(serde::de::Error::duplicate_field("pause"));
1956 }
1957 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Pause)
1958;
1959 }
1960 GeneratedField::Resume => {
1961 if mutation__.is_some() {
1962 return Err(serde::de::Error::duplicate_field("resume"));
1963 }
1964 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Resume)
1965;
1966 }
1967 GeneratedField::Throttle => {
1968 if mutation__.is_some() {
1969 return Err(serde::de::Error::duplicate_field("throttle"));
1970 }
1971 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Throttle)
1972;
1973 }
1974 GeneratedField::DropSubscriptions => {
1975 if mutation__.is_some() {
1976 return Err(serde::de::Error::duplicate_field("dropSubscriptions"));
1977 }
1978 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::DropSubscriptions)
1979;
1980 }
1981 GeneratedField::ConnectorPropsChange => {
1982 if mutation__.is_some() {
1983 return Err(serde::de::Error::duplicate_field("connectorPropsChange"));
1984 }
1985 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ConnectorPropsChange)
1986;
1987 }
1988 GeneratedField::StartFragmentBackfill => {
1989 if mutation__.is_some() {
1990 return Err(serde::de::Error::duplicate_field("startFragmentBackfill"));
1991 }
1992 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::StartFragmentBackfill)
1993;
1994 }
1995 GeneratedField::RefreshStart => {
1996 if mutation__.is_some() {
1997 return Err(serde::de::Error::duplicate_field("refreshStart"));
1998 }
1999 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::RefreshStart)
2000;
2001 }
2002 GeneratedField::LoadFinish => {
2003 if mutation__.is_some() {
2004 return Err(serde::de::Error::duplicate_field("loadFinish"));
2005 }
2006 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::LoadFinish)
2007;
2008 }
2009 GeneratedField::ListFinish => {
2010 if mutation__.is_some() {
2011 return Err(serde::de::Error::duplicate_field("listFinish"));
2012 }
2013 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ListFinish)
2014;
2015 }
2016 GeneratedField::ResetSource => {
2017 if mutation__.is_some() {
2018 return Err(serde::de::Error::duplicate_field("resetSource"));
2019 }
2020 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ResetSource)
2021;
2022 }
2023 GeneratedField::InjectSourceOffsets => {
2024 if mutation__.is_some() {
2025 return Err(serde::de::Error::duplicate_field("injectSourceOffsets"));
2026 }
2027 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::InjectSourceOffsets)
2028;
2029 }
2030 }
2031 }
2032 Ok(BarrierMutation {
2033 mutation: mutation__,
2034 })
2035 }
2036 }
2037 deserializer.deserialize_struct("stream_plan.BarrierMutation", FIELDS, GeneratedVisitor)
2038 }
2039}
2040impl serde::Serialize for BarrierRecvNode {
2041 #[allow(deprecated)]
2042 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2043 where
2044 S: serde::Serializer,
2045 {
2046 use serde::ser::SerializeStruct;
2047 let len = 0;
2048 let struct_ser = serializer.serialize_struct("stream_plan.BarrierRecvNode", len)?;
2049 struct_ser.end()
2050 }
2051}
2052impl<'de> serde::Deserialize<'de> for BarrierRecvNode {
2053 #[allow(deprecated)]
2054 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2055 where
2056 D: serde::Deserializer<'de>,
2057 {
2058 const FIELDS: &[&str] = &[
2059 ];
2060
2061 #[allow(clippy::enum_variant_names)]
2062 enum GeneratedField {
2063 }
2064 impl<'de> serde::Deserialize<'de> for GeneratedField {
2065 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2066 where
2067 D: serde::Deserializer<'de>,
2068 {
2069 struct GeneratedVisitor;
2070
2071 impl serde::de::Visitor<'_> for GeneratedVisitor {
2072 type Value = GeneratedField;
2073
2074 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2075 write!(formatter, "expected one of: {:?}", &FIELDS)
2076 }
2077
2078 #[allow(unused_variables)]
2079 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2080 where
2081 E: serde::de::Error,
2082 {
2083 Err(serde::de::Error::unknown_field(value, FIELDS))
2084 }
2085 }
2086 deserializer.deserialize_identifier(GeneratedVisitor)
2087 }
2088 }
2089 struct GeneratedVisitor;
2090 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2091 type Value = BarrierRecvNode;
2092
2093 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2094 formatter.write_str("struct stream_plan.BarrierRecvNode")
2095 }
2096
2097 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierRecvNode, V::Error>
2098 where
2099 V: serde::de::MapAccess<'de>,
2100 {
2101 while map_.next_key::<GeneratedField>()?.is_some() {
2102 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2103 }
2104 Ok(BarrierRecvNode {
2105 })
2106 }
2107 }
2108 deserializer.deserialize_struct("stream_plan.BarrierRecvNode", FIELDS, GeneratedVisitor)
2109 }
2110}
2111impl serde::Serialize for BatchPlanNode {
2112 #[allow(deprecated)]
2113 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2114 where
2115 S: serde::Serializer,
2116 {
2117 use serde::ser::SerializeStruct;
2118 let mut len = 0;
2119 if self.table_desc.is_some() {
2120 len += 1;
2121 }
2122 if !self.column_ids.is_empty() {
2123 len += 1;
2124 }
2125 let mut struct_ser = serializer.serialize_struct("stream_plan.BatchPlanNode", len)?;
2126 if let Some(v) = self.table_desc.as_ref() {
2127 struct_ser.serialize_field("tableDesc", v)?;
2128 }
2129 if !self.column_ids.is_empty() {
2130 struct_ser.serialize_field("columnIds", &self.column_ids)?;
2131 }
2132 struct_ser.end()
2133 }
2134}
2135impl<'de> serde::Deserialize<'de> for BatchPlanNode {
2136 #[allow(deprecated)]
2137 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2138 where
2139 D: serde::Deserializer<'de>,
2140 {
2141 const FIELDS: &[&str] = &[
2142 "table_desc",
2143 "tableDesc",
2144 "column_ids",
2145 "columnIds",
2146 ];
2147
2148 #[allow(clippy::enum_variant_names)]
2149 enum GeneratedField {
2150 TableDesc,
2151 ColumnIds,
2152 }
2153 impl<'de> serde::Deserialize<'de> for GeneratedField {
2154 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2155 where
2156 D: serde::Deserializer<'de>,
2157 {
2158 struct GeneratedVisitor;
2159
2160 impl serde::de::Visitor<'_> for GeneratedVisitor {
2161 type Value = GeneratedField;
2162
2163 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2164 write!(formatter, "expected one of: {:?}", &FIELDS)
2165 }
2166
2167 #[allow(unused_variables)]
2168 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2169 where
2170 E: serde::de::Error,
2171 {
2172 match value {
2173 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
2174 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
2175 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2176 }
2177 }
2178 }
2179 deserializer.deserialize_identifier(GeneratedVisitor)
2180 }
2181 }
2182 struct GeneratedVisitor;
2183 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2184 type Value = BatchPlanNode;
2185
2186 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2187 formatter.write_str("struct stream_plan.BatchPlanNode")
2188 }
2189
2190 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BatchPlanNode, V::Error>
2191 where
2192 V: serde::de::MapAccess<'de>,
2193 {
2194 let mut table_desc__ = None;
2195 let mut column_ids__ = None;
2196 while let Some(k) = map_.next_key()? {
2197 match k {
2198 GeneratedField::TableDesc => {
2199 if table_desc__.is_some() {
2200 return Err(serde::de::Error::duplicate_field("tableDesc"));
2201 }
2202 table_desc__ = map_.next_value()?;
2203 }
2204 GeneratedField::ColumnIds => {
2205 if column_ids__.is_some() {
2206 return Err(serde::de::Error::duplicate_field("columnIds"));
2207 }
2208 column_ids__ =
2209 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2210 .into_iter().map(|x| x.0).collect())
2211 ;
2212 }
2213 }
2214 }
2215 Ok(BatchPlanNode {
2216 table_desc: table_desc__,
2217 column_ids: column_ids__.unwrap_or_default(),
2218 })
2219 }
2220 }
2221 deserializer.deserialize_struct("stream_plan.BatchPlanNode", FIELDS, GeneratedVisitor)
2222 }
2223}
2224impl serde::Serialize for CdcFilterNode {
2225 #[allow(deprecated)]
2226 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2227 where
2228 S: serde::Serializer,
2229 {
2230 use serde::ser::SerializeStruct;
2231 let mut len = 0;
2232 if self.search_condition.is_some() {
2233 len += 1;
2234 }
2235 if self.upstream_source_id != 0 {
2236 len += 1;
2237 }
2238 let mut struct_ser = serializer.serialize_struct("stream_plan.CdcFilterNode", len)?;
2239 if let Some(v) = self.search_condition.as_ref() {
2240 struct_ser.serialize_field("searchCondition", v)?;
2241 }
2242 if self.upstream_source_id != 0 {
2243 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
2244 }
2245 struct_ser.end()
2246 }
2247}
2248impl<'de> serde::Deserialize<'de> for CdcFilterNode {
2249 #[allow(deprecated)]
2250 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2251 where
2252 D: serde::Deserializer<'de>,
2253 {
2254 const FIELDS: &[&str] = &[
2255 "search_condition",
2256 "searchCondition",
2257 "upstream_source_id",
2258 "upstreamSourceId",
2259 ];
2260
2261 #[allow(clippy::enum_variant_names)]
2262 enum GeneratedField {
2263 SearchCondition,
2264 UpstreamSourceId,
2265 }
2266 impl<'de> serde::Deserialize<'de> for GeneratedField {
2267 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2268 where
2269 D: serde::Deserializer<'de>,
2270 {
2271 struct GeneratedVisitor;
2272
2273 impl serde::de::Visitor<'_> for GeneratedVisitor {
2274 type Value = GeneratedField;
2275
2276 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2277 write!(formatter, "expected one of: {:?}", &FIELDS)
2278 }
2279
2280 #[allow(unused_variables)]
2281 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2282 where
2283 E: serde::de::Error,
2284 {
2285 match value {
2286 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
2287 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
2288 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2289 }
2290 }
2291 }
2292 deserializer.deserialize_identifier(GeneratedVisitor)
2293 }
2294 }
2295 struct GeneratedVisitor;
2296 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2297 type Value = CdcFilterNode;
2298
2299 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2300 formatter.write_str("struct stream_plan.CdcFilterNode")
2301 }
2302
2303 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcFilterNode, V::Error>
2304 where
2305 V: serde::de::MapAccess<'de>,
2306 {
2307 let mut search_condition__ = None;
2308 let mut upstream_source_id__ = None;
2309 while let Some(k) = map_.next_key()? {
2310 match k {
2311 GeneratedField::SearchCondition => {
2312 if search_condition__.is_some() {
2313 return Err(serde::de::Error::duplicate_field("searchCondition"));
2314 }
2315 search_condition__ = map_.next_value()?;
2316 }
2317 GeneratedField::UpstreamSourceId => {
2318 if upstream_source_id__.is_some() {
2319 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
2320 }
2321 upstream_source_id__ =
2322 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2323 ;
2324 }
2325 }
2326 }
2327 Ok(CdcFilterNode {
2328 search_condition: search_condition__,
2329 upstream_source_id: upstream_source_id__.unwrap_or_default(),
2330 })
2331 }
2332 }
2333 deserializer.deserialize_struct("stream_plan.CdcFilterNode", FIELDS, GeneratedVisitor)
2334 }
2335}
2336impl serde::Serialize for ChangeLogNode {
2337 #[allow(deprecated)]
2338 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2339 where
2340 S: serde::Serializer,
2341 {
2342 use serde::ser::SerializeStruct;
2343 let mut len = 0;
2344 if self.need_op {
2345 len += 1;
2346 }
2347 if !self.distribution_keys.is_empty() {
2348 len += 1;
2349 }
2350 let mut struct_ser = serializer.serialize_struct("stream_plan.ChangeLogNode", len)?;
2351 if self.need_op {
2352 struct_ser.serialize_field("needOp", &self.need_op)?;
2353 }
2354 if !self.distribution_keys.is_empty() {
2355 struct_ser.serialize_field("distributionKeys", &self.distribution_keys)?;
2356 }
2357 struct_ser.end()
2358 }
2359}
2360impl<'de> serde::Deserialize<'de> for ChangeLogNode {
2361 #[allow(deprecated)]
2362 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2363 where
2364 D: serde::Deserializer<'de>,
2365 {
2366 const FIELDS: &[&str] = &[
2367 "need_op",
2368 "needOp",
2369 "distribution_keys",
2370 "distributionKeys",
2371 ];
2372
2373 #[allow(clippy::enum_variant_names)]
2374 enum GeneratedField {
2375 NeedOp,
2376 DistributionKeys,
2377 }
2378 impl<'de> serde::Deserialize<'de> for GeneratedField {
2379 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2380 where
2381 D: serde::Deserializer<'de>,
2382 {
2383 struct GeneratedVisitor;
2384
2385 impl serde::de::Visitor<'_> for GeneratedVisitor {
2386 type Value = GeneratedField;
2387
2388 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2389 write!(formatter, "expected one of: {:?}", &FIELDS)
2390 }
2391
2392 #[allow(unused_variables)]
2393 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2394 where
2395 E: serde::de::Error,
2396 {
2397 match value {
2398 "needOp" | "need_op" => Ok(GeneratedField::NeedOp),
2399 "distributionKeys" | "distribution_keys" => Ok(GeneratedField::DistributionKeys),
2400 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2401 }
2402 }
2403 }
2404 deserializer.deserialize_identifier(GeneratedVisitor)
2405 }
2406 }
2407 struct GeneratedVisitor;
2408 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2409 type Value = ChangeLogNode;
2410
2411 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2412 formatter.write_str("struct stream_plan.ChangeLogNode")
2413 }
2414
2415 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ChangeLogNode, V::Error>
2416 where
2417 V: serde::de::MapAccess<'de>,
2418 {
2419 let mut need_op__ = None;
2420 let mut distribution_keys__ = None;
2421 while let Some(k) = map_.next_key()? {
2422 match k {
2423 GeneratedField::NeedOp => {
2424 if need_op__.is_some() {
2425 return Err(serde::de::Error::duplicate_field("needOp"));
2426 }
2427 need_op__ = Some(map_.next_value()?);
2428 }
2429 GeneratedField::DistributionKeys => {
2430 if distribution_keys__.is_some() {
2431 return Err(serde::de::Error::duplicate_field("distributionKeys"));
2432 }
2433 distribution_keys__ =
2434 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2435 .into_iter().map(|x| x.0).collect())
2436 ;
2437 }
2438 }
2439 }
2440 Ok(ChangeLogNode {
2441 need_op: need_op__.unwrap_or_default(),
2442 distribution_keys: distribution_keys__.unwrap_or_default(),
2443 })
2444 }
2445 }
2446 deserializer.deserialize_struct("stream_plan.ChangeLogNode", FIELDS, GeneratedVisitor)
2447 }
2448}
2449impl serde::Serialize for Columns {
2450 #[allow(deprecated)]
2451 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2452 where
2453 S: serde::Serializer,
2454 {
2455 use serde::ser::SerializeStruct;
2456 let mut len = 0;
2457 if !self.columns.is_empty() {
2458 len += 1;
2459 }
2460 let mut struct_ser = serializer.serialize_struct("stream_plan.Columns", len)?;
2461 if !self.columns.is_empty() {
2462 struct_ser.serialize_field("columns", &self.columns)?;
2463 }
2464 struct_ser.end()
2465 }
2466}
2467impl<'de> serde::Deserialize<'de> for Columns {
2468 #[allow(deprecated)]
2469 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2470 where
2471 D: serde::Deserializer<'de>,
2472 {
2473 const FIELDS: &[&str] = &[
2474 "columns",
2475 ];
2476
2477 #[allow(clippy::enum_variant_names)]
2478 enum GeneratedField {
2479 Columns,
2480 }
2481 impl<'de> serde::Deserialize<'de> for GeneratedField {
2482 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2483 where
2484 D: serde::Deserializer<'de>,
2485 {
2486 struct GeneratedVisitor;
2487
2488 impl serde::de::Visitor<'_> for GeneratedVisitor {
2489 type Value = GeneratedField;
2490
2491 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2492 write!(formatter, "expected one of: {:?}", &FIELDS)
2493 }
2494
2495 #[allow(unused_variables)]
2496 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2497 where
2498 E: serde::de::Error,
2499 {
2500 match value {
2501 "columns" => Ok(GeneratedField::Columns),
2502 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2503 }
2504 }
2505 }
2506 deserializer.deserialize_identifier(GeneratedVisitor)
2507 }
2508 }
2509 struct GeneratedVisitor;
2510 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2511 type Value = Columns;
2512
2513 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2514 formatter.write_str("struct stream_plan.Columns")
2515 }
2516
2517 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Columns, V::Error>
2518 where
2519 V: serde::de::MapAccess<'de>,
2520 {
2521 let mut columns__ = None;
2522 while let Some(k) = map_.next_key()? {
2523 match k {
2524 GeneratedField::Columns => {
2525 if columns__.is_some() {
2526 return Err(serde::de::Error::duplicate_field("columns"));
2527 }
2528 columns__ = Some(map_.next_value()?);
2529 }
2530 }
2531 }
2532 Ok(Columns {
2533 columns: columns__.unwrap_or_default(),
2534 })
2535 }
2536 }
2537 deserializer.deserialize_struct("stream_plan.Columns", FIELDS, GeneratedVisitor)
2538 }
2539}
2540impl serde::Serialize for ConnectorPropsChangeMutation {
2541 #[allow(deprecated)]
2542 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2543 where
2544 S: serde::Serializer,
2545 {
2546 use serde::ser::SerializeStruct;
2547 let mut len = 0;
2548 if !self.connector_props_infos.is_empty() {
2549 len += 1;
2550 }
2551 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation", len)?;
2552 if !self.connector_props_infos.is_empty() {
2553 struct_ser.serialize_field("connectorPropsInfos", &self.connector_props_infos)?;
2554 }
2555 struct_ser.end()
2556 }
2557}
2558impl<'de> serde::Deserialize<'de> for ConnectorPropsChangeMutation {
2559 #[allow(deprecated)]
2560 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2561 where
2562 D: serde::Deserializer<'de>,
2563 {
2564 const FIELDS: &[&str] = &[
2565 "connector_props_infos",
2566 "connectorPropsInfos",
2567 ];
2568
2569 #[allow(clippy::enum_variant_names)]
2570 enum GeneratedField {
2571 ConnectorPropsInfos,
2572 }
2573 impl<'de> serde::Deserialize<'de> for GeneratedField {
2574 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2575 where
2576 D: serde::Deserializer<'de>,
2577 {
2578 struct GeneratedVisitor;
2579
2580 impl serde::de::Visitor<'_> for GeneratedVisitor {
2581 type Value = GeneratedField;
2582
2583 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2584 write!(formatter, "expected one of: {:?}", &FIELDS)
2585 }
2586
2587 #[allow(unused_variables)]
2588 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2589 where
2590 E: serde::de::Error,
2591 {
2592 match value {
2593 "connectorPropsInfos" | "connector_props_infos" => Ok(GeneratedField::ConnectorPropsInfos),
2594 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2595 }
2596 }
2597 }
2598 deserializer.deserialize_identifier(GeneratedVisitor)
2599 }
2600 }
2601 struct GeneratedVisitor;
2602 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2603 type Value = ConnectorPropsChangeMutation;
2604
2605 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2606 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation")
2607 }
2608
2609 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectorPropsChangeMutation, V::Error>
2610 where
2611 V: serde::de::MapAccess<'de>,
2612 {
2613 let mut connector_props_infos__ = None;
2614 while let Some(k) = map_.next_key()? {
2615 match k {
2616 GeneratedField::ConnectorPropsInfos => {
2617 if connector_props_infos__.is_some() {
2618 return Err(serde::de::Error::duplicate_field("connectorPropsInfos"));
2619 }
2620 connector_props_infos__ = Some(
2621 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
2622 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
2623 );
2624 }
2625 }
2626 }
2627 Ok(ConnectorPropsChangeMutation {
2628 connector_props_infos: connector_props_infos__.unwrap_or_default(),
2629 })
2630 }
2631 }
2632 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation", FIELDS, GeneratedVisitor)
2633 }
2634}
2635impl serde::Serialize for connector_props_change_mutation::ConnectorPropsInfo {
2636 #[allow(deprecated)]
2637 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2638 where
2639 S: serde::Serializer,
2640 {
2641 use serde::ser::SerializeStruct;
2642 let mut len = 0;
2643 if !self.connector_props_info.is_empty() {
2644 len += 1;
2645 }
2646 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", len)?;
2647 if !self.connector_props_info.is_empty() {
2648 struct_ser.serialize_field("connectorPropsInfo", &self.connector_props_info)?;
2649 }
2650 struct_ser.end()
2651 }
2652}
2653impl<'de> serde::Deserialize<'de> for connector_props_change_mutation::ConnectorPropsInfo {
2654 #[allow(deprecated)]
2655 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2656 where
2657 D: serde::Deserializer<'de>,
2658 {
2659 const FIELDS: &[&str] = &[
2660 "connector_props_info",
2661 "connectorPropsInfo",
2662 ];
2663
2664 #[allow(clippy::enum_variant_names)]
2665 enum GeneratedField {
2666 ConnectorPropsInfo,
2667 }
2668 impl<'de> serde::Deserialize<'de> for GeneratedField {
2669 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2670 where
2671 D: serde::Deserializer<'de>,
2672 {
2673 struct GeneratedVisitor;
2674
2675 impl serde::de::Visitor<'_> for GeneratedVisitor {
2676 type Value = GeneratedField;
2677
2678 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2679 write!(formatter, "expected one of: {:?}", &FIELDS)
2680 }
2681
2682 #[allow(unused_variables)]
2683 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2684 where
2685 E: serde::de::Error,
2686 {
2687 match value {
2688 "connectorPropsInfo" | "connector_props_info" => Ok(GeneratedField::ConnectorPropsInfo),
2689 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2690 }
2691 }
2692 }
2693 deserializer.deserialize_identifier(GeneratedVisitor)
2694 }
2695 }
2696 struct GeneratedVisitor;
2697 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2698 type Value = connector_props_change_mutation::ConnectorPropsInfo;
2699
2700 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2701 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo")
2702 }
2703
2704 fn visit_map<V>(self, mut map_: V) -> std::result::Result<connector_props_change_mutation::ConnectorPropsInfo, V::Error>
2705 where
2706 V: serde::de::MapAccess<'de>,
2707 {
2708 let mut connector_props_info__ = None;
2709 while let Some(k) = map_.next_key()? {
2710 match k {
2711 GeneratedField::ConnectorPropsInfo => {
2712 if connector_props_info__.is_some() {
2713 return Err(serde::de::Error::duplicate_field("connectorPropsInfo"));
2714 }
2715 connector_props_info__ = Some(
2716 map_.next_value::<std::collections::HashMap<_, _>>()?
2717 );
2718 }
2719 }
2720 }
2721 Ok(connector_props_change_mutation::ConnectorPropsInfo {
2722 connector_props_info: connector_props_info__.unwrap_or_default(),
2723 })
2724 }
2725 }
2726 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", FIELDS, GeneratedVisitor)
2727 }
2728}
2729impl serde::Serialize for DedupNode {
2730 #[allow(deprecated)]
2731 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2732 where
2733 S: serde::Serializer,
2734 {
2735 use serde::ser::SerializeStruct;
2736 let mut len = 0;
2737 if self.state_table.is_some() {
2738 len += 1;
2739 }
2740 if !self.dedup_column_indices.is_empty() {
2741 len += 1;
2742 }
2743 let mut struct_ser = serializer.serialize_struct("stream_plan.DedupNode", len)?;
2744 if let Some(v) = self.state_table.as_ref() {
2745 struct_ser.serialize_field("stateTable", v)?;
2746 }
2747 if !self.dedup_column_indices.is_empty() {
2748 struct_ser.serialize_field("dedupColumnIndices", &self.dedup_column_indices)?;
2749 }
2750 struct_ser.end()
2751 }
2752}
2753impl<'de> serde::Deserialize<'de> for DedupNode {
2754 #[allow(deprecated)]
2755 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2756 where
2757 D: serde::Deserializer<'de>,
2758 {
2759 const FIELDS: &[&str] = &[
2760 "state_table",
2761 "stateTable",
2762 "dedup_column_indices",
2763 "dedupColumnIndices",
2764 ];
2765
2766 #[allow(clippy::enum_variant_names)]
2767 enum GeneratedField {
2768 StateTable,
2769 DedupColumnIndices,
2770 }
2771 impl<'de> serde::Deserialize<'de> for GeneratedField {
2772 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2773 where
2774 D: serde::Deserializer<'de>,
2775 {
2776 struct GeneratedVisitor;
2777
2778 impl serde::de::Visitor<'_> for GeneratedVisitor {
2779 type Value = GeneratedField;
2780
2781 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2782 write!(formatter, "expected one of: {:?}", &FIELDS)
2783 }
2784
2785 #[allow(unused_variables)]
2786 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2787 where
2788 E: serde::de::Error,
2789 {
2790 match value {
2791 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
2792 "dedupColumnIndices" | "dedup_column_indices" => Ok(GeneratedField::DedupColumnIndices),
2793 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2794 }
2795 }
2796 }
2797 deserializer.deserialize_identifier(GeneratedVisitor)
2798 }
2799 }
2800 struct GeneratedVisitor;
2801 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2802 type Value = DedupNode;
2803
2804 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2805 formatter.write_str("struct stream_plan.DedupNode")
2806 }
2807
2808 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DedupNode, V::Error>
2809 where
2810 V: serde::de::MapAccess<'de>,
2811 {
2812 let mut state_table__ = None;
2813 let mut dedup_column_indices__ = None;
2814 while let Some(k) = map_.next_key()? {
2815 match k {
2816 GeneratedField::StateTable => {
2817 if state_table__.is_some() {
2818 return Err(serde::de::Error::duplicate_field("stateTable"));
2819 }
2820 state_table__ = map_.next_value()?;
2821 }
2822 GeneratedField::DedupColumnIndices => {
2823 if dedup_column_indices__.is_some() {
2824 return Err(serde::de::Error::duplicate_field("dedupColumnIndices"));
2825 }
2826 dedup_column_indices__ =
2827 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2828 .into_iter().map(|x| x.0).collect())
2829 ;
2830 }
2831 }
2832 }
2833 Ok(DedupNode {
2834 state_table: state_table__,
2835 dedup_column_indices: dedup_column_indices__.unwrap_or_default(),
2836 })
2837 }
2838 }
2839 deserializer.deserialize_struct("stream_plan.DedupNode", FIELDS, GeneratedVisitor)
2840 }
2841}
2842impl serde::Serialize for DeltaExpression {
2843 #[allow(deprecated)]
2844 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2845 where
2846 S: serde::Serializer,
2847 {
2848 use serde::ser::SerializeStruct;
2849 let mut len = 0;
2850 if self.delta_type != 0 {
2851 len += 1;
2852 }
2853 if self.delta.is_some() {
2854 len += 1;
2855 }
2856 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaExpression", len)?;
2857 if self.delta_type != 0 {
2858 let v = super::expr::expr_node::Type::try_from(self.delta_type)
2859 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.delta_type)))?;
2860 struct_ser.serialize_field("deltaType", &v)?;
2861 }
2862 if let Some(v) = self.delta.as_ref() {
2863 struct_ser.serialize_field("delta", v)?;
2864 }
2865 struct_ser.end()
2866 }
2867}
2868impl<'de> serde::Deserialize<'de> for DeltaExpression {
2869 #[allow(deprecated)]
2870 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2871 where
2872 D: serde::Deserializer<'de>,
2873 {
2874 const FIELDS: &[&str] = &[
2875 "delta_type",
2876 "deltaType",
2877 "delta",
2878 ];
2879
2880 #[allow(clippy::enum_variant_names)]
2881 enum GeneratedField {
2882 DeltaType,
2883 Delta,
2884 }
2885 impl<'de> serde::Deserialize<'de> for GeneratedField {
2886 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2887 where
2888 D: serde::Deserializer<'de>,
2889 {
2890 struct GeneratedVisitor;
2891
2892 impl serde::de::Visitor<'_> for GeneratedVisitor {
2893 type Value = GeneratedField;
2894
2895 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2896 write!(formatter, "expected one of: {:?}", &FIELDS)
2897 }
2898
2899 #[allow(unused_variables)]
2900 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2901 where
2902 E: serde::de::Error,
2903 {
2904 match value {
2905 "deltaType" | "delta_type" => Ok(GeneratedField::DeltaType),
2906 "delta" => Ok(GeneratedField::Delta),
2907 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2908 }
2909 }
2910 }
2911 deserializer.deserialize_identifier(GeneratedVisitor)
2912 }
2913 }
2914 struct GeneratedVisitor;
2915 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2916 type Value = DeltaExpression;
2917
2918 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2919 formatter.write_str("struct stream_plan.DeltaExpression")
2920 }
2921
2922 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaExpression, V::Error>
2923 where
2924 V: serde::de::MapAccess<'de>,
2925 {
2926 let mut delta_type__ = None;
2927 let mut delta__ = None;
2928 while let Some(k) = map_.next_key()? {
2929 match k {
2930 GeneratedField::DeltaType => {
2931 if delta_type__.is_some() {
2932 return Err(serde::de::Error::duplicate_field("deltaType"));
2933 }
2934 delta_type__ = Some(map_.next_value::<super::expr::expr_node::Type>()? as i32);
2935 }
2936 GeneratedField::Delta => {
2937 if delta__.is_some() {
2938 return Err(serde::de::Error::duplicate_field("delta"));
2939 }
2940 delta__ = map_.next_value()?;
2941 }
2942 }
2943 }
2944 Ok(DeltaExpression {
2945 delta_type: delta_type__.unwrap_or_default(),
2946 delta: delta__,
2947 })
2948 }
2949 }
2950 deserializer.deserialize_struct("stream_plan.DeltaExpression", FIELDS, GeneratedVisitor)
2951 }
2952}
2953impl serde::Serialize for DeltaIndexJoinNode {
2954 #[allow(deprecated)]
2955 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2956 where
2957 S: serde::Serializer,
2958 {
2959 use serde::ser::SerializeStruct;
2960 let mut len = 0;
2961 if self.join_type != 0 {
2962 len += 1;
2963 }
2964 if !self.left_key.is_empty() {
2965 len += 1;
2966 }
2967 if !self.right_key.is_empty() {
2968 len += 1;
2969 }
2970 if self.condition.is_some() {
2971 len += 1;
2972 }
2973 if self.left_table_id != 0 {
2974 len += 1;
2975 }
2976 if self.right_table_id != 0 {
2977 len += 1;
2978 }
2979 if self.left_info.is_some() {
2980 len += 1;
2981 }
2982 if self.right_info.is_some() {
2983 len += 1;
2984 }
2985 if !self.output_indices.is_empty() {
2986 len += 1;
2987 }
2988 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaIndexJoinNode", len)?;
2989 if self.join_type != 0 {
2990 let v = super::plan_common::JoinType::try_from(self.join_type)
2991 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
2992 struct_ser.serialize_field("joinType", &v)?;
2993 }
2994 if !self.left_key.is_empty() {
2995 struct_ser.serialize_field("leftKey", &self.left_key)?;
2996 }
2997 if !self.right_key.is_empty() {
2998 struct_ser.serialize_field("rightKey", &self.right_key)?;
2999 }
3000 if let Some(v) = self.condition.as_ref() {
3001 struct_ser.serialize_field("condition", v)?;
3002 }
3003 if self.left_table_id != 0 {
3004 struct_ser.serialize_field("leftTableId", &self.left_table_id)?;
3005 }
3006 if self.right_table_id != 0 {
3007 struct_ser.serialize_field("rightTableId", &self.right_table_id)?;
3008 }
3009 if let Some(v) = self.left_info.as_ref() {
3010 struct_ser.serialize_field("leftInfo", v)?;
3011 }
3012 if let Some(v) = self.right_info.as_ref() {
3013 struct_ser.serialize_field("rightInfo", v)?;
3014 }
3015 if !self.output_indices.is_empty() {
3016 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
3017 }
3018 struct_ser.end()
3019 }
3020}
3021impl<'de> serde::Deserialize<'de> for DeltaIndexJoinNode {
3022 #[allow(deprecated)]
3023 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3024 where
3025 D: serde::Deserializer<'de>,
3026 {
3027 const FIELDS: &[&str] = &[
3028 "join_type",
3029 "joinType",
3030 "left_key",
3031 "leftKey",
3032 "right_key",
3033 "rightKey",
3034 "condition",
3035 "left_table_id",
3036 "leftTableId",
3037 "right_table_id",
3038 "rightTableId",
3039 "left_info",
3040 "leftInfo",
3041 "right_info",
3042 "rightInfo",
3043 "output_indices",
3044 "outputIndices",
3045 ];
3046
3047 #[allow(clippy::enum_variant_names)]
3048 enum GeneratedField {
3049 JoinType,
3050 LeftKey,
3051 RightKey,
3052 Condition,
3053 LeftTableId,
3054 RightTableId,
3055 LeftInfo,
3056 RightInfo,
3057 OutputIndices,
3058 }
3059 impl<'de> serde::Deserialize<'de> for GeneratedField {
3060 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3061 where
3062 D: serde::Deserializer<'de>,
3063 {
3064 struct GeneratedVisitor;
3065
3066 impl serde::de::Visitor<'_> for GeneratedVisitor {
3067 type Value = GeneratedField;
3068
3069 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3070 write!(formatter, "expected one of: {:?}", &FIELDS)
3071 }
3072
3073 #[allow(unused_variables)]
3074 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3075 where
3076 E: serde::de::Error,
3077 {
3078 match value {
3079 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
3080 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
3081 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
3082 "condition" => Ok(GeneratedField::Condition),
3083 "leftTableId" | "left_table_id" => Ok(GeneratedField::LeftTableId),
3084 "rightTableId" | "right_table_id" => Ok(GeneratedField::RightTableId),
3085 "leftInfo" | "left_info" => Ok(GeneratedField::LeftInfo),
3086 "rightInfo" | "right_info" => Ok(GeneratedField::RightInfo),
3087 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
3088 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3089 }
3090 }
3091 }
3092 deserializer.deserialize_identifier(GeneratedVisitor)
3093 }
3094 }
3095 struct GeneratedVisitor;
3096 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3097 type Value = DeltaIndexJoinNode;
3098
3099 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3100 formatter.write_str("struct stream_plan.DeltaIndexJoinNode")
3101 }
3102
3103 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaIndexJoinNode, V::Error>
3104 where
3105 V: serde::de::MapAccess<'de>,
3106 {
3107 let mut join_type__ = None;
3108 let mut left_key__ = None;
3109 let mut right_key__ = None;
3110 let mut condition__ = None;
3111 let mut left_table_id__ = None;
3112 let mut right_table_id__ = None;
3113 let mut left_info__ = None;
3114 let mut right_info__ = None;
3115 let mut output_indices__ = None;
3116 while let Some(k) = map_.next_key()? {
3117 match k {
3118 GeneratedField::JoinType => {
3119 if join_type__.is_some() {
3120 return Err(serde::de::Error::duplicate_field("joinType"));
3121 }
3122 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
3123 }
3124 GeneratedField::LeftKey => {
3125 if left_key__.is_some() {
3126 return Err(serde::de::Error::duplicate_field("leftKey"));
3127 }
3128 left_key__ =
3129 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3130 .into_iter().map(|x| x.0).collect())
3131 ;
3132 }
3133 GeneratedField::RightKey => {
3134 if right_key__.is_some() {
3135 return Err(serde::de::Error::duplicate_field("rightKey"));
3136 }
3137 right_key__ =
3138 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3139 .into_iter().map(|x| x.0).collect())
3140 ;
3141 }
3142 GeneratedField::Condition => {
3143 if condition__.is_some() {
3144 return Err(serde::de::Error::duplicate_field("condition"));
3145 }
3146 condition__ = map_.next_value()?;
3147 }
3148 GeneratedField::LeftTableId => {
3149 if left_table_id__.is_some() {
3150 return Err(serde::de::Error::duplicate_field("leftTableId"));
3151 }
3152 left_table_id__ =
3153 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3154 ;
3155 }
3156 GeneratedField::RightTableId => {
3157 if right_table_id__.is_some() {
3158 return Err(serde::de::Error::duplicate_field("rightTableId"));
3159 }
3160 right_table_id__ =
3161 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3162 ;
3163 }
3164 GeneratedField::LeftInfo => {
3165 if left_info__.is_some() {
3166 return Err(serde::de::Error::duplicate_field("leftInfo"));
3167 }
3168 left_info__ = map_.next_value()?;
3169 }
3170 GeneratedField::RightInfo => {
3171 if right_info__.is_some() {
3172 return Err(serde::de::Error::duplicate_field("rightInfo"));
3173 }
3174 right_info__ = map_.next_value()?;
3175 }
3176 GeneratedField::OutputIndices => {
3177 if output_indices__.is_some() {
3178 return Err(serde::de::Error::duplicate_field("outputIndices"));
3179 }
3180 output_indices__ =
3181 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3182 .into_iter().map(|x| x.0).collect())
3183 ;
3184 }
3185 }
3186 }
3187 Ok(DeltaIndexJoinNode {
3188 join_type: join_type__.unwrap_or_default(),
3189 left_key: left_key__.unwrap_or_default(),
3190 right_key: right_key__.unwrap_or_default(),
3191 condition: condition__,
3192 left_table_id: left_table_id__.unwrap_or_default(),
3193 right_table_id: right_table_id__.unwrap_or_default(),
3194 left_info: left_info__,
3195 right_info: right_info__,
3196 output_indices: output_indices__.unwrap_or_default(),
3197 })
3198 }
3199 }
3200 deserializer.deserialize_struct("stream_plan.DeltaIndexJoinNode", FIELDS, GeneratedVisitor)
3201 }
3202}
3203impl serde::Serialize for DispatchOutputMapping {
3204 #[allow(deprecated)]
3205 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3206 where
3207 S: serde::Serializer,
3208 {
3209 use serde::ser::SerializeStruct;
3210 let mut len = 0;
3211 if !self.indices.is_empty() {
3212 len += 1;
3213 }
3214 if !self.types.is_empty() {
3215 len += 1;
3216 }
3217 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping", len)?;
3218 if !self.indices.is_empty() {
3219 struct_ser.serialize_field("indices", &self.indices)?;
3220 }
3221 if !self.types.is_empty() {
3222 struct_ser.serialize_field("types", &self.types)?;
3223 }
3224 struct_ser.end()
3225 }
3226}
3227impl<'de> serde::Deserialize<'de> for DispatchOutputMapping {
3228 #[allow(deprecated)]
3229 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3230 where
3231 D: serde::Deserializer<'de>,
3232 {
3233 const FIELDS: &[&str] = &[
3234 "indices",
3235 "types",
3236 ];
3237
3238 #[allow(clippy::enum_variant_names)]
3239 enum GeneratedField {
3240 Indices,
3241 Types,
3242 }
3243 impl<'de> serde::Deserialize<'de> for GeneratedField {
3244 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3245 where
3246 D: serde::Deserializer<'de>,
3247 {
3248 struct GeneratedVisitor;
3249
3250 impl serde::de::Visitor<'_> for GeneratedVisitor {
3251 type Value = GeneratedField;
3252
3253 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3254 write!(formatter, "expected one of: {:?}", &FIELDS)
3255 }
3256
3257 #[allow(unused_variables)]
3258 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3259 where
3260 E: serde::de::Error,
3261 {
3262 match value {
3263 "indices" => Ok(GeneratedField::Indices),
3264 "types" => Ok(GeneratedField::Types),
3265 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3266 }
3267 }
3268 }
3269 deserializer.deserialize_identifier(GeneratedVisitor)
3270 }
3271 }
3272 struct GeneratedVisitor;
3273 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3274 type Value = DispatchOutputMapping;
3275
3276 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3277 formatter.write_str("struct stream_plan.DispatchOutputMapping")
3278 }
3279
3280 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchOutputMapping, V::Error>
3281 where
3282 V: serde::de::MapAccess<'de>,
3283 {
3284 let mut indices__ = None;
3285 let mut types__ = None;
3286 while let Some(k) = map_.next_key()? {
3287 match k {
3288 GeneratedField::Indices => {
3289 if indices__.is_some() {
3290 return Err(serde::de::Error::duplicate_field("indices"));
3291 }
3292 indices__ =
3293 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3294 .into_iter().map(|x| x.0).collect())
3295 ;
3296 }
3297 GeneratedField::Types => {
3298 if types__.is_some() {
3299 return Err(serde::de::Error::duplicate_field("types"));
3300 }
3301 types__ = Some(map_.next_value()?);
3302 }
3303 }
3304 }
3305 Ok(DispatchOutputMapping {
3306 indices: indices__.unwrap_or_default(),
3307 types: types__.unwrap_or_default(),
3308 })
3309 }
3310 }
3311 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping", FIELDS, GeneratedVisitor)
3312 }
3313}
3314impl serde::Serialize for dispatch_output_mapping::TypePair {
3315 #[allow(deprecated)]
3316 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3317 where
3318 S: serde::Serializer,
3319 {
3320 use serde::ser::SerializeStruct;
3321 let mut len = 0;
3322 if self.upstream.is_some() {
3323 len += 1;
3324 }
3325 if self.downstream.is_some() {
3326 len += 1;
3327 }
3328 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping.TypePair", len)?;
3329 if let Some(v) = self.upstream.as_ref() {
3330 struct_ser.serialize_field("upstream", v)?;
3331 }
3332 if let Some(v) = self.downstream.as_ref() {
3333 struct_ser.serialize_field("downstream", v)?;
3334 }
3335 struct_ser.end()
3336 }
3337}
3338impl<'de> serde::Deserialize<'de> for dispatch_output_mapping::TypePair {
3339 #[allow(deprecated)]
3340 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3341 where
3342 D: serde::Deserializer<'de>,
3343 {
3344 const FIELDS: &[&str] = &[
3345 "upstream",
3346 "downstream",
3347 ];
3348
3349 #[allow(clippy::enum_variant_names)]
3350 enum GeneratedField {
3351 Upstream,
3352 Downstream,
3353 }
3354 impl<'de> serde::Deserialize<'de> for GeneratedField {
3355 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3356 where
3357 D: serde::Deserializer<'de>,
3358 {
3359 struct GeneratedVisitor;
3360
3361 impl serde::de::Visitor<'_> for GeneratedVisitor {
3362 type Value = GeneratedField;
3363
3364 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3365 write!(formatter, "expected one of: {:?}", &FIELDS)
3366 }
3367
3368 #[allow(unused_variables)]
3369 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3370 where
3371 E: serde::de::Error,
3372 {
3373 match value {
3374 "upstream" => Ok(GeneratedField::Upstream),
3375 "downstream" => Ok(GeneratedField::Downstream),
3376 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3377 }
3378 }
3379 }
3380 deserializer.deserialize_identifier(GeneratedVisitor)
3381 }
3382 }
3383 struct GeneratedVisitor;
3384 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3385 type Value = dispatch_output_mapping::TypePair;
3386
3387 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3388 formatter.write_str("struct stream_plan.DispatchOutputMapping.TypePair")
3389 }
3390
3391 fn visit_map<V>(self, mut map_: V) -> std::result::Result<dispatch_output_mapping::TypePair, V::Error>
3392 where
3393 V: serde::de::MapAccess<'de>,
3394 {
3395 let mut upstream__ = None;
3396 let mut downstream__ = None;
3397 while let Some(k) = map_.next_key()? {
3398 match k {
3399 GeneratedField::Upstream => {
3400 if upstream__.is_some() {
3401 return Err(serde::de::Error::duplicate_field("upstream"));
3402 }
3403 upstream__ = map_.next_value()?;
3404 }
3405 GeneratedField::Downstream => {
3406 if downstream__.is_some() {
3407 return Err(serde::de::Error::duplicate_field("downstream"));
3408 }
3409 downstream__ = map_.next_value()?;
3410 }
3411 }
3412 }
3413 Ok(dispatch_output_mapping::TypePair {
3414 upstream: upstream__,
3415 downstream: downstream__,
3416 })
3417 }
3418 }
3419 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping.TypePair", FIELDS, GeneratedVisitor)
3420 }
3421}
3422impl serde::Serialize for DispatchStrategy {
3423 #[allow(deprecated)]
3424 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3425 where
3426 S: serde::Serializer,
3427 {
3428 use serde::ser::SerializeStruct;
3429 let mut len = 0;
3430 if self.r#type != 0 {
3431 len += 1;
3432 }
3433 if !self.dist_key_indices.is_empty() {
3434 len += 1;
3435 }
3436 if self.output_mapping.is_some() {
3437 len += 1;
3438 }
3439 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchStrategy", len)?;
3440 if self.r#type != 0 {
3441 let v = DispatcherType::try_from(self.r#type)
3442 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3443 struct_ser.serialize_field("type", &v)?;
3444 }
3445 if !self.dist_key_indices.is_empty() {
3446 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3447 }
3448 if let Some(v) = self.output_mapping.as_ref() {
3449 struct_ser.serialize_field("outputMapping", v)?;
3450 }
3451 struct_ser.end()
3452 }
3453}
3454impl<'de> serde::Deserialize<'de> for DispatchStrategy {
3455 #[allow(deprecated)]
3456 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3457 where
3458 D: serde::Deserializer<'de>,
3459 {
3460 const FIELDS: &[&str] = &[
3461 "type",
3462 "dist_key_indices",
3463 "distKeyIndices",
3464 "output_mapping",
3465 "outputMapping",
3466 ];
3467
3468 #[allow(clippy::enum_variant_names)]
3469 enum GeneratedField {
3470 Type,
3471 DistKeyIndices,
3472 OutputMapping,
3473 }
3474 impl<'de> serde::Deserialize<'de> for GeneratedField {
3475 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3476 where
3477 D: serde::Deserializer<'de>,
3478 {
3479 struct GeneratedVisitor;
3480
3481 impl serde::de::Visitor<'_> for GeneratedVisitor {
3482 type Value = GeneratedField;
3483
3484 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3485 write!(formatter, "expected one of: {:?}", &FIELDS)
3486 }
3487
3488 #[allow(unused_variables)]
3489 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3490 where
3491 E: serde::de::Error,
3492 {
3493 match value {
3494 "type" => Ok(GeneratedField::Type),
3495 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3496 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3497 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3498 }
3499 }
3500 }
3501 deserializer.deserialize_identifier(GeneratedVisitor)
3502 }
3503 }
3504 struct GeneratedVisitor;
3505 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3506 type Value = DispatchStrategy;
3507
3508 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3509 formatter.write_str("struct stream_plan.DispatchStrategy")
3510 }
3511
3512 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchStrategy, V::Error>
3513 where
3514 V: serde::de::MapAccess<'de>,
3515 {
3516 let mut r#type__ = None;
3517 let mut dist_key_indices__ = None;
3518 let mut output_mapping__ = None;
3519 while let Some(k) = map_.next_key()? {
3520 match k {
3521 GeneratedField::Type => {
3522 if r#type__.is_some() {
3523 return Err(serde::de::Error::duplicate_field("type"));
3524 }
3525 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3526 }
3527 GeneratedField::DistKeyIndices => {
3528 if dist_key_indices__.is_some() {
3529 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3530 }
3531 dist_key_indices__ =
3532 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3533 .into_iter().map(|x| x.0).collect())
3534 ;
3535 }
3536 GeneratedField::OutputMapping => {
3537 if output_mapping__.is_some() {
3538 return Err(serde::de::Error::duplicate_field("outputMapping"));
3539 }
3540 output_mapping__ = map_.next_value()?;
3541 }
3542 }
3543 }
3544 Ok(DispatchStrategy {
3545 r#type: r#type__.unwrap_or_default(),
3546 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3547 output_mapping: output_mapping__,
3548 })
3549 }
3550 }
3551 deserializer.deserialize_struct("stream_plan.DispatchStrategy", FIELDS, GeneratedVisitor)
3552 }
3553}
3554impl serde::Serialize for Dispatcher {
3555 #[allow(deprecated)]
3556 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3557 where
3558 S: serde::Serializer,
3559 {
3560 use serde::ser::SerializeStruct;
3561 let mut len = 0;
3562 if self.r#type != 0 {
3563 len += 1;
3564 }
3565 if !self.dist_key_indices.is_empty() {
3566 len += 1;
3567 }
3568 if self.output_mapping.is_some() {
3569 len += 1;
3570 }
3571 if self.hash_mapping.is_some() {
3572 len += 1;
3573 }
3574 if self.dispatcher_id != 0 {
3575 len += 1;
3576 }
3577 if !self.downstream_actor_id.is_empty() {
3578 len += 1;
3579 }
3580 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatcher", len)?;
3581 if self.r#type != 0 {
3582 let v = DispatcherType::try_from(self.r#type)
3583 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3584 struct_ser.serialize_field("type", &v)?;
3585 }
3586 if !self.dist_key_indices.is_empty() {
3587 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3588 }
3589 if let Some(v) = self.output_mapping.as_ref() {
3590 struct_ser.serialize_field("outputMapping", v)?;
3591 }
3592 if let Some(v) = self.hash_mapping.as_ref() {
3593 struct_ser.serialize_field("hashMapping", v)?;
3594 }
3595 if self.dispatcher_id != 0 {
3596 struct_ser.serialize_field("dispatcherId", &self.dispatcher_id)?;
3597 }
3598 if !self.downstream_actor_id.is_empty() {
3599 struct_ser.serialize_field("downstreamActorId", &self.downstream_actor_id)?;
3600 }
3601 struct_ser.end()
3602 }
3603}
3604impl<'de> serde::Deserialize<'de> for Dispatcher {
3605 #[allow(deprecated)]
3606 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3607 where
3608 D: serde::Deserializer<'de>,
3609 {
3610 const FIELDS: &[&str] = &[
3611 "type",
3612 "dist_key_indices",
3613 "distKeyIndices",
3614 "output_mapping",
3615 "outputMapping",
3616 "hash_mapping",
3617 "hashMapping",
3618 "dispatcher_id",
3619 "dispatcherId",
3620 "downstream_actor_id",
3621 "downstreamActorId",
3622 ];
3623
3624 #[allow(clippy::enum_variant_names)]
3625 enum GeneratedField {
3626 Type,
3627 DistKeyIndices,
3628 OutputMapping,
3629 HashMapping,
3630 DispatcherId,
3631 DownstreamActorId,
3632 }
3633 impl<'de> serde::Deserialize<'de> for GeneratedField {
3634 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3635 where
3636 D: serde::Deserializer<'de>,
3637 {
3638 struct GeneratedVisitor;
3639
3640 impl serde::de::Visitor<'_> for GeneratedVisitor {
3641 type Value = GeneratedField;
3642
3643 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3644 write!(formatter, "expected one of: {:?}", &FIELDS)
3645 }
3646
3647 #[allow(unused_variables)]
3648 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3649 where
3650 E: serde::de::Error,
3651 {
3652 match value {
3653 "type" => Ok(GeneratedField::Type),
3654 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3655 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3656 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
3657 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
3658 "downstreamActorId" | "downstream_actor_id" => Ok(GeneratedField::DownstreamActorId),
3659 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3660 }
3661 }
3662 }
3663 deserializer.deserialize_identifier(GeneratedVisitor)
3664 }
3665 }
3666 struct GeneratedVisitor;
3667 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3668 type Value = Dispatcher;
3669
3670 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3671 formatter.write_str("struct stream_plan.Dispatcher")
3672 }
3673
3674 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatcher, V::Error>
3675 where
3676 V: serde::de::MapAccess<'de>,
3677 {
3678 let mut r#type__ = None;
3679 let mut dist_key_indices__ = None;
3680 let mut output_mapping__ = None;
3681 let mut hash_mapping__ = None;
3682 let mut dispatcher_id__ = None;
3683 let mut downstream_actor_id__ = None;
3684 while let Some(k) = map_.next_key()? {
3685 match k {
3686 GeneratedField::Type => {
3687 if r#type__.is_some() {
3688 return Err(serde::de::Error::duplicate_field("type"));
3689 }
3690 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3691 }
3692 GeneratedField::DistKeyIndices => {
3693 if dist_key_indices__.is_some() {
3694 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3695 }
3696 dist_key_indices__ =
3697 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3698 .into_iter().map(|x| x.0).collect())
3699 ;
3700 }
3701 GeneratedField::OutputMapping => {
3702 if output_mapping__.is_some() {
3703 return Err(serde::de::Error::duplicate_field("outputMapping"));
3704 }
3705 output_mapping__ = map_.next_value()?;
3706 }
3707 GeneratedField::HashMapping => {
3708 if hash_mapping__.is_some() {
3709 return Err(serde::de::Error::duplicate_field("hashMapping"));
3710 }
3711 hash_mapping__ = map_.next_value()?;
3712 }
3713 GeneratedField::DispatcherId => {
3714 if dispatcher_id__.is_some() {
3715 return Err(serde::de::Error::duplicate_field("dispatcherId"));
3716 }
3717 dispatcher_id__ =
3718 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3719 ;
3720 }
3721 GeneratedField::DownstreamActorId => {
3722 if downstream_actor_id__.is_some() {
3723 return Err(serde::de::Error::duplicate_field("downstreamActorId"));
3724 }
3725 downstream_actor_id__ =
3726 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3727 .into_iter().map(|x| x.0).collect())
3728 ;
3729 }
3730 }
3731 }
3732 Ok(Dispatcher {
3733 r#type: r#type__.unwrap_or_default(),
3734 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3735 output_mapping: output_mapping__,
3736 hash_mapping: hash_mapping__,
3737 dispatcher_id: dispatcher_id__.unwrap_or_default(),
3738 downstream_actor_id: downstream_actor_id__.unwrap_or_default(),
3739 })
3740 }
3741 }
3742 deserializer.deserialize_struct("stream_plan.Dispatcher", FIELDS, GeneratedVisitor)
3743 }
3744}
3745impl serde::Serialize for DispatcherType {
3746 #[allow(deprecated)]
3747 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3748 where
3749 S: serde::Serializer,
3750 {
3751 let variant = match self {
3752 Self::Unspecified => "DISPATCHER_TYPE_UNSPECIFIED",
3753 Self::Hash => "DISPATCHER_TYPE_HASH",
3754 Self::Broadcast => "DISPATCHER_TYPE_BROADCAST",
3755 Self::Simple => "DISPATCHER_TYPE_SIMPLE",
3756 Self::NoShuffle => "DISPATCHER_TYPE_NO_SHUFFLE",
3757 };
3758 serializer.serialize_str(variant)
3759 }
3760}
3761impl<'de> serde::Deserialize<'de> for DispatcherType {
3762 #[allow(deprecated)]
3763 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3764 where
3765 D: serde::Deserializer<'de>,
3766 {
3767 const FIELDS: &[&str] = &[
3768 "DISPATCHER_TYPE_UNSPECIFIED",
3769 "DISPATCHER_TYPE_HASH",
3770 "DISPATCHER_TYPE_BROADCAST",
3771 "DISPATCHER_TYPE_SIMPLE",
3772 "DISPATCHER_TYPE_NO_SHUFFLE",
3773 ];
3774
3775 struct GeneratedVisitor;
3776
3777 impl serde::de::Visitor<'_> for GeneratedVisitor {
3778 type Value = DispatcherType;
3779
3780 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3781 write!(formatter, "expected one of: {:?}", &FIELDS)
3782 }
3783
3784 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3785 where
3786 E: serde::de::Error,
3787 {
3788 i32::try_from(v)
3789 .ok()
3790 .and_then(|x| x.try_into().ok())
3791 .ok_or_else(|| {
3792 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3793 })
3794 }
3795
3796 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3797 where
3798 E: serde::de::Error,
3799 {
3800 i32::try_from(v)
3801 .ok()
3802 .and_then(|x| x.try_into().ok())
3803 .ok_or_else(|| {
3804 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3805 })
3806 }
3807
3808 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3809 where
3810 E: serde::de::Error,
3811 {
3812 match value {
3813 "DISPATCHER_TYPE_UNSPECIFIED" => Ok(DispatcherType::Unspecified),
3814 "DISPATCHER_TYPE_HASH" => Ok(DispatcherType::Hash),
3815 "DISPATCHER_TYPE_BROADCAST" => Ok(DispatcherType::Broadcast),
3816 "DISPATCHER_TYPE_SIMPLE" => Ok(DispatcherType::Simple),
3817 "DISPATCHER_TYPE_NO_SHUFFLE" => Ok(DispatcherType::NoShuffle),
3818 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3819 }
3820 }
3821 }
3822 deserializer.deserialize_any(GeneratedVisitor)
3823 }
3824}
3825impl serde::Serialize for Dispatchers {
3826 #[allow(deprecated)]
3827 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3828 where
3829 S: serde::Serializer,
3830 {
3831 use serde::ser::SerializeStruct;
3832 let mut len = 0;
3833 if !self.dispatchers.is_empty() {
3834 len += 1;
3835 }
3836 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatchers", len)?;
3837 if !self.dispatchers.is_empty() {
3838 struct_ser.serialize_field("dispatchers", &self.dispatchers)?;
3839 }
3840 struct_ser.end()
3841 }
3842}
3843impl<'de> serde::Deserialize<'de> for Dispatchers {
3844 #[allow(deprecated)]
3845 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3846 where
3847 D: serde::Deserializer<'de>,
3848 {
3849 const FIELDS: &[&str] = &[
3850 "dispatchers",
3851 ];
3852
3853 #[allow(clippy::enum_variant_names)]
3854 enum GeneratedField {
3855 Dispatchers,
3856 }
3857 impl<'de> serde::Deserialize<'de> for GeneratedField {
3858 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3859 where
3860 D: serde::Deserializer<'de>,
3861 {
3862 struct GeneratedVisitor;
3863
3864 impl serde::de::Visitor<'_> for GeneratedVisitor {
3865 type Value = GeneratedField;
3866
3867 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3868 write!(formatter, "expected one of: {:?}", &FIELDS)
3869 }
3870
3871 #[allow(unused_variables)]
3872 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3873 where
3874 E: serde::de::Error,
3875 {
3876 match value {
3877 "dispatchers" => Ok(GeneratedField::Dispatchers),
3878 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3879 }
3880 }
3881 }
3882 deserializer.deserialize_identifier(GeneratedVisitor)
3883 }
3884 }
3885 struct GeneratedVisitor;
3886 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3887 type Value = Dispatchers;
3888
3889 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3890 formatter.write_str("struct stream_plan.Dispatchers")
3891 }
3892
3893 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatchers, V::Error>
3894 where
3895 V: serde::de::MapAccess<'de>,
3896 {
3897 let mut dispatchers__ = None;
3898 while let Some(k) = map_.next_key()? {
3899 match k {
3900 GeneratedField::Dispatchers => {
3901 if dispatchers__.is_some() {
3902 return Err(serde::de::Error::duplicate_field("dispatchers"));
3903 }
3904 dispatchers__ = Some(map_.next_value()?);
3905 }
3906 }
3907 }
3908 Ok(Dispatchers {
3909 dispatchers: dispatchers__.unwrap_or_default(),
3910 })
3911 }
3912 }
3913 deserializer.deserialize_struct("stream_plan.Dispatchers", FIELDS, GeneratedVisitor)
3914 }
3915}
3916impl serde::Serialize for DmlNode {
3917 #[allow(deprecated)]
3918 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3919 where
3920 S: serde::Serializer,
3921 {
3922 use serde::ser::SerializeStruct;
3923 let mut len = 0;
3924 if self.table_id != 0 {
3925 len += 1;
3926 }
3927 if self.table_version_id != 0 {
3928 len += 1;
3929 }
3930 if !self.column_descs.is_empty() {
3931 len += 1;
3932 }
3933 if self.rate_limit.is_some() {
3934 len += 1;
3935 }
3936 let mut struct_ser = serializer.serialize_struct("stream_plan.DmlNode", len)?;
3937 if self.table_id != 0 {
3938 struct_ser.serialize_field("tableId", &self.table_id)?;
3939 }
3940 if self.table_version_id != 0 {
3941 #[allow(clippy::needless_borrow)]
3942 #[allow(clippy::needless_borrows_for_generic_args)]
3943 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
3944 }
3945 if !self.column_descs.is_empty() {
3946 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
3947 }
3948 if let Some(v) = self.rate_limit.as_ref() {
3949 struct_ser.serialize_field("rateLimit", v)?;
3950 }
3951 struct_ser.end()
3952 }
3953}
3954impl<'de> serde::Deserialize<'de> for DmlNode {
3955 #[allow(deprecated)]
3956 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3957 where
3958 D: serde::Deserializer<'de>,
3959 {
3960 const FIELDS: &[&str] = &[
3961 "table_id",
3962 "tableId",
3963 "table_version_id",
3964 "tableVersionId",
3965 "column_descs",
3966 "columnDescs",
3967 "rate_limit",
3968 "rateLimit",
3969 ];
3970
3971 #[allow(clippy::enum_variant_names)]
3972 enum GeneratedField {
3973 TableId,
3974 TableVersionId,
3975 ColumnDescs,
3976 RateLimit,
3977 }
3978 impl<'de> serde::Deserialize<'de> for GeneratedField {
3979 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3980 where
3981 D: serde::Deserializer<'de>,
3982 {
3983 struct GeneratedVisitor;
3984
3985 impl serde::de::Visitor<'_> for GeneratedVisitor {
3986 type Value = GeneratedField;
3987
3988 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3989 write!(formatter, "expected one of: {:?}", &FIELDS)
3990 }
3991
3992 #[allow(unused_variables)]
3993 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3994 where
3995 E: serde::de::Error,
3996 {
3997 match value {
3998 "tableId" | "table_id" => Ok(GeneratedField::TableId),
3999 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
4000 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
4001 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
4002 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4003 }
4004 }
4005 }
4006 deserializer.deserialize_identifier(GeneratedVisitor)
4007 }
4008 }
4009 struct GeneratedVisitor;
4010 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4011 type Value = DmlNode;
4012
4013 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4014 formatter.write_str("struct stream_plan.DmlNode")
4015 }
4016
4017 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DmlNode, V::Error>
4018 where
4019 V: serde::de::MapAccess<'de>,
4020 {
4021 let mut table_id__ = None;
4022 let mut table_version_id__ = None;
4023 let mut column_descs__ = None;
4024 let mut rate_limit__ = None;
4025 while let Some(k) = map_.next_key()? {
4026 match k {
4027 GeneratedField::TableId => {
4028 if table_id__.is_some() {
4029 return Err(serde::de::Error::duplicate_field("tableId"));
4030 }
4031 table_id__ =
4032 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4033 ;
4034 }
4035 GeneratedField::TableVersionId => {
4036 if table_version_id__.is_some() {
4037 return Err(serde::de::Error::duplicate_field("tableVersionId"));
4038 }
4039 table_version_id__ =
4040 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4041 ;
4042 }
4043 GeneratedField::ColumnDescs => {
4044 if column_descs__.is_some() {
4045 return Err(serde::de::Error::duplicate_field("columnDescs"));
4046 }
4047 column_descs__ = Some(map_.next_value()?);
4048 }
4049 GeneratedField::RateLimit => {
4050 if rate_limit__.is_some() {
4051 return Err(serde::de::Error::duplicate_field("rateLimit"));
4052 }
4053 rate_limit__ =
4054 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4055 ;
4056 }
4057 }
4058 }
4059 Ok(DmlNode {
4060 table_id: table_id__.unwrap_or_default(),
4061 table_version_id: table_version_id__.unwrap_or_default(),
4062 column_descs: column_descs__.unwrap_or_default(),
4063 rate_limit: rate_limit__,
4064 })
4065 }
4066 }
4067 deserializer.deserialize_struct("stream_plan.DmlNode", FIELDS, GeneratedVisitor)
4068 }
4069}
4070impl serde::Serialize for DropSubscriptionsMutation {
4071 #[allow(deprecated)]
4072 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4073 where
4074 S: serde::Serializer,
4075 {
4076 use serde::ser::SerializeStruct;
4077 let mut len = 0;
4078 if !self.info.is_empty() {
4079 len += 1;
4080 }
4081 let mut struct_ser = serializer.serialize_struct("stream_plan.DropSubscriptionsMutation", len)?;
4082 if !self.info.is_empty() {
4083 struct_ser.serialize_field("info", &self.info)?;
4084 }
4085 struct_ser.end()
4086 }
4087}
4088impl<'de> serde::Deserialize<'de> for DropSubscriptionsMutation {
4089 #[allow(deprecated)]
4090 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4091 where
4092 D: serde::Deserializer<'de>,
4093 {
4094 const FIELDS: &[&str] = &[
4095 "info",
4096 ];
4097
4098 #[allow(clippy::enum_variant_names)]
4099 enum GeneratedField {
4100 Info,
4101 }
4102 impl<'de> serde::Deserialize<'de> for GeneratedField {
4103 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4104 where
4105 D: serde::Deserializer<'de>,
4106 {
4107 struct GeneratedVisitor;
4108
4109 impl serde::de::Visitor<'_> for GeneratedVisitor {
4110 type Value = GeneratedField;
4111
4112 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4113 write!(formatter, "expected one of: {:?}", &FIELDS)
4114 }
4115
4116 #[allow(unused_variables)]
4117 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4118 where
4119 E: serde::de::Error,
4120 {
4121 match value {
4122 "info" => Ok(GeneratedField::Info),
4123 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4124 }
4125 }
4126 }
4127 deserializer.deserialize_identifier(GeneratedVisitor)
4128 }
4129 }
4130 struct GeneratedVisitor;
4131 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4132 type Value = DropSubscriptionsMutation;
4133
4134 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4135 formatter.write_str("struct stream_plan.DropSubscriptionsMutation")
4136 }
4137
4138 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionsMutation, V::Error>
4139 where
4140 V: serde::de::MapAccess<'de>,
4141 {
4142 let mut info__ = None;
4143 while let Some(k) = map_.next_key()? {
4144 match k {
4145 GeneratedField::Info => {
4146 if info__.is_some() {
4147 return Err(serde::de::Error::duplicate_field("info"));
4148 }
4149 info__ = Some(map_.next_value()?);
4150 }
4151 }
4152 }
4153 Ok(DropSubscriptionsMutation {
4154 info: info__.unwrap_or_default(),
4155 })
4156 }
4157 }
4158 deserializer.deserialize_struct("stream_plan.DropSubscriptionsMutation", FIELDS, GeneratedVisitor)
4159 }
4160}
4161impl serde::Serialize for DynamicFilterNode {
4162 #[allow(deprecated)]
4163 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4164 where
4165 S: serde::Serializer,
4166 {
4167 use serde::ser::SerializeStruct;
4168 let mut len = 0;
4169 if self.left_key != 0 {
4170 len += 1;
4171 }
4172 if self.condition.is_some() {
4173 len += 1;
4174 }
4175 if self.left_table.is_some() {
4176 len += 1;
4177 }
4178 if self.right_table.is_some() {
4179 len += 1;
4180 }
4181 if self.condition_always_relax {
4182 len += 1;
4183 }
4184 if self.cleaned_by_watermark {
4185 len += 1;
4186 }
4187 let mut struct_ser = serializer.serialize_struct("stream_plan.DynamicFilterNode", len)?;
4188 if self.left_key != 0 {
4189 struct_ser.serialize_field("leftKey", &self.left_key)?;
4190 }
4191 if let Some(v) = self.condition.as_ref() {
4192 struct_ser.serialize_field("condition", v)?;
4193 }
4194 if let Some(v) = self.left_table.as_ref() {
4195 struct_ser.serialize_field("leftTable", v)?;
4196 }
4197 if let Some(v) = self.right_table.as_ref() {
4198 struct_ser.serialize_field("rightTable", v)?;
4199 }
4200 if self.condition_always_relax {
4201 struct_ser.serialize_field("conditionAlwaysRelax", &self.condition_always_relax)?;
4202 }
4203 if self.cleaned_by_watermark {
4204 struct_ser.serialize_field("cleanedByWatermark", &self.cleaned_by_watermark)?;
4205 }
4206 struct_ser.end()
4207 }
4208}
4209impl<'de> serde::Deserialize<'de> for DynamicFilterNode {
4210 #[allow(deprecated)]
4211 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4212 where
4213 D: serde::Deserializer<'de>,
4214 {
4215 const FIELDS: &[&str] = &[
4216 "left_key",
4217 "leftKey",
4218 "condition",
4219 "left_table",
4220 "leftTable",
4221 "right_table",
4222 "rightTable",
4223 "condition_always_relax",
4224 "conditionAlwaysRelax",
4225 "cleaned_by_watermark",
4226 "cleanedByWatermark",
4227 ];
4228
4229 #[allow(clippy::enum_variant_names)]
4230 enum GeneratedField {
4231 LeftKey,
4232 Condition,
4233 LeftTable,
4234 RightTable,
4235 ConditionAlwaysRelax,
4236 CleanedByWatermark,
4237 }
4238 impl<'de> serde::Deserialize<'de> for GeneratedField {
4239 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4240 where
4241 D: serde::Deserializer<'de>,
4242 {
4243 struct GeneratedVisitor;
4244
4245 impl serde::de::Visitor<'_> for GeneratedVisitor {
4246 type Value = GeneratedField;
4247
4248 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4249 write!(formatter, "expected one of: {:?}", &FIELDS)
4250 }
4251
4252 #[allow(unused_variables)]
4253 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4254 where
4255 E: serde::de::Error,
4256 {
4257 match value {
4258 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
4259 "condition" => Ok(GeneratedField::Condition),
4260 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
4261 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
4262 "conditionAlwaysRelax" | "condition_always_relax" => Ok(GeneratedField::ConditionAlwaysRelax),
4263 "cleanedByWatermark" | "cleaned_by_watermark" => Ok(GeneratedField::CleanedByWatermark),
4264 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4265 }
4266 }
4267 }
4268 deserializer.deserialize_identifier(GeneratedVisitor)
4269 }
4270 }
4271 struct GeneratedVisitor;
4272 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4273 type Value = DynamicFilterNode;
4274
4275 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4276 formatter.write_str("struct stream_plan.DynamicFilterNode")
4277 }
4278
4279 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DynamicFilterNode, V::Error>
4280 where
4281 V: serde::de::MapAccess<'de>,
4282 {
4283 let mut left_key__ = None;
4284 let mut condition__ = None;
4285 let mut left_table__ = None;
4286 let mut right_table__ = None;
4287 let mut condition_always_relax__ = None;
4288 let mut cleaned_by_watermark__ = None;
4289 while let Some(k) = map_.next_key()? {
4290 match k {
4291 GeneratedField::LeftKey => {
4292 if left_key__.is_some() {
4293 return Err(serde::de::Error::duplicate_field("leftKey"));
4294 }
4295 left_key__ =
4296 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4297 ;
4298 }
4299 GeneratedField::Condition => {
4300 if condition__.is_some() {
4301 return Err(serde::de::Error::duplicate_field("condition"));
4302 }
4303 condition__ = map_.next_value()?;
4304 }
4305 GeneratedField::LeftTable => {
4306 if left_table__.is_some() {
4307 return Err(serde::de::Error::duplicate_field("leftTable"));
4308 }
4309 left_table__ = map_.next_value()?;
4310 }
4311 GeneratedField::RightTable => {
4312 if right_table__.is_some() {
4313 return Err(serde::de::Error::duplicate_field("rightTable"));
4314 }
4315 right_table__ = map_.next_value()?;
4316 }
4317 GeneratedField::ConditionAlwaysRelax => {
4318 if condition_always_relax__.is_some() {
4319 return Err(serde::de::Error::duplicate_field("conditionAlwaysRelax"));
4320 }
4321 condition_always_relax__ = Some(map_.next_value()?);
4322 }
4323 GeneratedField::CleanedByWatermark => {
4324 if cleaned_by_watermark__.is_some() {
4325 return Err(serde::de::Error::duplicate_field("cleanedByWatermark"));
4326 }
4327 cleaned_by_watermark__ = Some(map_.next_value()?);
4328 }
4329 }
4330 }
4331 Ok(DynamicFilterNode {
4332 left_key: left_key__.unwrap_or_default(),
4333 condition: condition__,
4334 left_table: left_table__,
4335 right_table: right_table__,
4336 condition_always_relax: condition_always_relax__.unwrap_or_default(),
4337 cleaned_by_watermark: cleaned_by_watermark__.unwrap_or_default(),
4338 })
4339 }
4340 }
4341 deserializer.deserialize_struct("stream_plan.DynamicFilterNode", FIELDS, GeneratedVisitor)
4342 }
4343}
4344impl serde::Serialize for EowcGapFillNode {
4345 #[allow(deprecated)]
4346 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4347 where
4348 S: serde::Serializer,
4349 {
4350 use serde::ser::SerializeStruct;
4351 let mut len = 0;
4352 if self.time_column_index != 0 {
4353 len += 1;
4354 }
4355 if self.interval.is_some() {
4356 len += 1;
4357 }
4358 if !self.fill_columns.is_empty() {
4359 len += 1;
4360 }
4361 if !self.fill_strategies.is_empty() {
4362 len += 1;
4363 }
4364 if self.buffer_table.is_some() {
4365 len += 1;
4366 }
4367 if self.prev_row_table.is_some() {
4368 len += 1;
4369 }
4370 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcGapFillNode", len)?;
4371 if self.time_column_index != 0 {
4372 struct_ser.serialize_field("timeColumnIndex", &self.time_column_index)?;
4373 }
4374 if let Some(v) = self.interval.as_ref() {
4375 struct_ser.serialize_field("interval", v)?;
4376 }
4377 if !self.fill_columns.is_empty() {
4378 struct_ser.serialize_field("fillColumns", &self.fill_columns)?;
4379 }
4380 if !self.fill_strategies.is_empty() {
4381 struct_ser.serialize_field("fillStrategies", &self.fill_strategies)?;
4382 }
4383 if let Some(v) = self.buffer_table.as_ref() {
4384 struct_ser.serialize_field("bufferTable", v)?;
4385 }
4386 if let Some(v) = self.prev_row_table.as_ref() {
4387 struct_ser.serialize_field("prevRowTable", v)?;
4388 }
4389 struct_ser.end()
4390 }
4391}
4392impl<'de> serde::Deserialize<'de> for EowcGapFillNode {
4393 #[allow(deprecated)]
4394 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4395 where
4396 D: serde::Deserializer<'de>,
4397 {
4398 const FIELDS: &[&str] = &[
4399 "time_column_index",
4400 "timeColumnIndex",
4401 "interval",
4402 "fill_columns",
4403 "fillColumns",
4404 "fill_strategies",
4405 "fillStrategies",
4406 "buffer_table",
4407 "bufferTable",
4408 "prev_row_table",
4409 "prevRowTable",
4410 ];
4411
4412 #[allow(clippy::enum_variant_names)]
4413 enum GeneratedField {
4414 TimeColumnIndex,
4415 Interval,
4416 FillColumns,
4417 FillStrategies,
4418 BufferTable,
4419 PrevRowTable,
4420 }
4421 impl<'de> serde::Deserialize<'de> for GeneratedField {
4422 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4423 where
4424 D: serde::Deserializer<'de>,
4425 {
4426 struct GeneratedVisitor;
4427
4428 impl serde::de::Visitor<'_> for GeneratedVisitor {
4429 type Value = GeneratedField;
4430
4431 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4432 write!(formatter, "expected one of: {:?}", &FIELDS)
4433 }
4434
4435 #[allow(unused_variables)]
4436 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4437 where
4438 E: serde::de::Error,
4439 {
4440 match value {
4441 "timeColumnIndex" | "time_column_index" => Ok(GeneratedField::TimeColumnIndex),
4442 "interval" => Ok(GeneratedField::Interval),
4443 "fillColumns" | "fill_columns" => Ok(GeneratedField::FillColumns),
4444 "fillStrategies" | "fill_strategies" => Ok(GeneratedField::FillStrategies),
4445 "bufferTable" | "buffer_table" => Ok(GeneratedField::BufferTable),
4446 "prevRowTable" | "prev_row_table" => Ok(GeneratedField::PrevRowTable),
4447 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4448 }
4449 }
4450 }
4451 deserializer.deserialize_identifier(GeneratedVisitor)
4452 }
4453 }
4454 struct GeneratedVisitor;
4455 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4456 type Value = EowcGapFillNode;
4457
4458 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4459 formatter.write_str("struct stream_plan.EowcGapFillNode")
4460 }
4461
4462 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcGapFillNode, V::Error>
4463 where
4464 V: serde::de::MapAccess<'de>,
4465 {
4466 let mut time_column_index__ = None;
4467 let mut interval__ = None;
4468 let mut fill_columns__ = None;
4469 let mut fill_strategies__ = None;
4470 let mut buffer_table__ = None;
4471 let mut prev_row_table__ = None;
4472 while let Some(k) = map_.next_key()? {
4473 match k {
4474 GeneratedField::TimeColumnIndex => {
4475 if time_column_index__.is_some() {
4476 return Err(serde::de::Error::duplicate_field("timeColumnIndex"));
4477 }
4478 time_column_index__ =
4479 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4480 ;
4481 }
4482 GeneratedField::Interval => {
4483 if interval__.is_some() {
4484 return Err(serde::de::Error::duplicate_field("interval"));
4485 }
4486 interval__ = map_.next_value()?;
4487 }
4488 GeneratedField::FillColumns => {
4489 if fill_columns__.is_some() {
4490 return Err(serde::de::Error::duplicate_field("fillColumns"));
4491 }
4492 fill_columns__ =
4493 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4494 .into_iter().map(|x| x.0).collect())
4495 ;
4496 }
4497 GeneratedField::FillStrategies => {
4498 if fill_strategies__.is_some() {
4499 return Err(serde::de::Error::duplicate_field("fillStrategies"));
4500 }
4501 fill_strategies__ = Some(map_.next_value()?);
4502 }
4503 GeneratedField::BufferTable => {
4504 if buffer_table__.is_some() {
4505 return Err(serde::de::Error::duplicate_field("bufferTable"));
4506 }
4507 buffer_table__ = map_.next_value()?;
4508 }
4509 GeneratedField::PrevRowTable => {
4510 if prev_row_table__.is_some() {
4511 return Err(serde::de::Error::duplicate_field("prevRowTable"));
4512 }
4513 prev_row_table__ = map_.next_value()?;
4514 }
4515 }
4516 }
4517 Ok(EowcGapFillNode {
4518 time_column_index: time_column_index__.unwrap_or_default(),
4519 interval: interval__,
4520 fill_columns: fill_columns__.unwrap_or_default(),
4521 fill_strategies: fill_strategies__.unwrap_or_default(),
4522 buffer_table: buffer_table__,
4523 prev_row_table: prev_row_table__,
4524 })
4525 }
4526 }
4527 deserializer.deserialize_struct("stream_plan.EowcGapFillNode", FIELDS, GeneratedVisitor)
4528 }
4529}
4530impl serde::Serialize for EowcOverWindowNode {
4531 #[allow(deprecated)]
4532 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4533 where
4534 S: serde::Serializer,
4535 {
4536 use serde::ser::SerializeStruct;
4537 let mut len = 0;
4538 if !self.calls.is_empty() {
4539 len += 1;
4540 }
4541 if !self.partition_by.is_empty() {
4542 len += 1;
4543 }
4544 if !self.order_by.is_empty() {
4545 len += 1;
4546 }
4547 if self.state_table.is_some() {
4548 len += 1;
4549 }
4550 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcOverWindowNode", len)?;
4551 if !self.calls.is_empty() {
4552 struct_ser.serialize_field("calls", &self.calls)?;
4553 }
4554 if !self.partition_by.is_empty() {
4555 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
4556 }
4557 if !self.order_by.is_empty() {
4558 struct_ser.serialize_field("orderBy", &self.order_by)?;
4559 }
4560 if let Some(v) = self.state_table.as_ref() {
4561 struct_ser.serialize_field("stateTable", v)?;
4562 }
4563 struct_ser.end()
4564 }
4565}
4566impl<'de> serde::Deserialize<'de> for EowcOverWindowNode {
4567 #[allow(deprecated)]
4568 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4569 where
4570 D: serde::Deserializer<'de>,
4571 {
4572 const FIELDS: &[&str] = &[
4573 "calls",
4574 "partition_by",
4575 "partitionBy",
4576 "order_by",
4577 "orderBy",
4578 "state_table",
4579 "stateTable",
4580 ];
4581
4582 #[allow(clippy::enum_variant_names)]
4583 enum GeneratedField {
4584 Calls,
4585 PartitionBy,
4586 OrderBy,
4587 StateTable,
4588 }
4589 impl<'de> serde::Deserialize<'de> for GeneratedField {
4590 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4591 where
4592 D: serde::Deserializer<'de>,
4593 {
4594 struct GeneratedVisitor;
4595
4596 impl serde::de::Visitor<'_> for GeneratedVisitor {
4597 type Value = GeneratedField;
4598
4599 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4600 write!(formatter, "expected one of: {:?}", &FIELDS)
4601 }
4602
4603 #[allow(unused_variables)]
4604 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4605 where
4606 E: serde::de::Error,
4607 {
4608 match value {
4609 "calls" => Ok(GeneratedField::Calls),
4610 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
4611 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
4612 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
4613 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4614 }
4615 }
4616 }
4617 deserializer.deserialize_identifier(GeneratedVisitor)
4618 }
4619 }
4620 struct GeneratedVisitor;
4621 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4622 type Value = EowcOverWindowNode;
4623
4624 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4625 formatter.write_str("struct stream_plan.EowcOverWindowNode")
4626 }
4627
4628 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcOverWindowNode, V::Error>
4629 where
4630 V: serde::de::MapAccess<'de>,
4631 {
4632 let mut calls__ = None;
4633 let mut partition_by__ = None;
4634 let mut order_by__ = None;
4635 let mut state_table__ = None;
4636 while let Some(k) = map_.next_key()? {
4637 match k {
4638 GeneratedField::Calls => {
4639 if calls__.is_some() {
4640 return Err(serde::de::Error::duplicate_field("calls"));
4641 }
4642 calls__ = Some(map_.next_value()?);
4643 }
4644 GeneratedField::PartitionBy => {
4645 if partition_by__.is_some() {
4646 return Err(serde::de::Error::duplicate_field("partitionBy"));
4647 }
4648 partition_by__ =
4649 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4650 .into_iter().map(|x| x.0).collect())
4651 ;
4652 }
4653 GeneratedField::OrderBy => {
4654 if order_by__.is_some() {
4655 return Err(serde::de::Error::duplicate_field("orderBy"));
4656 }
4657 order_by__ = Some(map_.next_value()?);
4658 }
4659 GeneratedField::StateTable => {
4660 if state_table__.is_some() {
4661 return Err(serde::de::Error::duplicate_field("stateTable"));
4662 }
4663 state_table__ = map_.next_value()?;
4664 }
4665 }
4666 }
4667 Ok(EowcOverWindowNode {
4668 calls: calls__.unwrap_or_default(),
4669 partition_by: partition_by__.unwrap_or_default(),
4670 order_by: order_by__.unwrap_or_default(),
4671 state_table: state_table__,
4672 })
4673 }
4674 }
4675 deserializer.deserialize_struct("stream_plan.EowcOverWindowNode", FIELDS, GeneratedVisitor)
4676 }
4677}
4678impl serde::Serialize for ExchangeNode {
4679 #[allow(deprecated)]
4680 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4681 where
4682 S: serde::Serializer,
4683 {
4684 use serde::ser::SerializeStruct;
4685 let mut len = 0;
4686 if self.strategy.is_some() {
4687 len += 1;
4688 }
4689 let mut struct_ser = serializer.serialize_struct("stream_plan.ExchangeNode", len)?;
4690 if let Some(v) = self.strategy.as_ref() {
4691 struct_ser.serialize_field("strategy", v)?;
4692 }
4693 struct_ser.end()
4694 }
4695}
4696impl<'de> serde::Deserialize<'de> for ExchangeNode {
4697 #[allow(deprecated)]
4698 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4699 where
4700 D: serde::Deserializer<'de>,
4701 {
4702 const FIELDS: &[&str] = &[
4703 "strategy",
4704 ];
4705
4706 #[allow(clippy::enum_variant_names)]
4707 enum GeneratedField {
4708 Strategy,
4709 }
4710 impl<'de> serde::Deserialize<'de> for GeneratedField {
4711 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4712 where
4713 D: serde::Deserializer<'de>,
4714 {
4715 struct GeneratedVisitor;
4716
4717 impl serde::de::Visitor<'_> for GeneratedVisitor {
4718 type Value = GeneratedField;
4719
4720 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4721 write!(formatter, "expected one of: {:?}", &FIELDS)
4722 }
4723
4724 #[allow(unused_variables)]
4725 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4726 where
4727 E: serde::de::Error,
4728 {
4729 match value {
4730 "strategy" => Ok(GeneratedField::Strategy),
4731 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4732 }
4733 }
4734 }
4735 deserializer.deserialize_identifier(GeneratedVisitor)
4736 }
4737 }
4738 struct GeneratedVisitor;
4739 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4740 type Value = ExchangeNode;
4741
4742 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4743 formatter.write_str("struct stream_plan.ExchangeNode")
4744 }
4745
4746 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExchangeNode, V::Error>
4747 where
4748 V: serde::de::MapAccess<'de>,
4749 {
4750 let mut strategy__ = None;
4751 while let Some(k) = map_.next_key()? {
4752 match k {
4753 GeneratedField::Strategy => {
4754 if strategy__.is_some() {
4755 return Err(serde::de::Error::duplicate_field("strategy"));
4756 }
4757 strategy__ = map_.next_value()?;
4758 }
4759 }
4760 }
4761 Ok(ExchangeNode {
4762 strategy: strategy__,
4763 })
4764 }
4765 }
4766 deserializer.deserialize_struct("stream_plan.ExchangeNode", FIELDS, GeneratedVisitor)
4767 }
4768}
4769impl serde::Serialize for ExpandNode {
4770 #[allow(deprecated)]
4771 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4772 where
4773 S: serde::Serializer,
4774 {
4775 use serde::ser::SerializeStruct;
4776 let mut len = 0;
4777 if !self.column_subsets.is_empty() {
4778 len += 1;
4779 }
4780 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode", len)?;
4781 if !self.column_subsets.is_empty() {
4782 struct_ser.serialize_field("columnSubsets", &self.column_subsets)?;
4783 }
4784 struct_ser.end()
4785 }
4786}
4787impl<'de> serde::Deserialize<'de> for ExpandNode {
4788 #[allow(deprecated)]
4789 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4790 where
4791 D: serde::Deserializer<'de>,
4792 {
4793 const FIELDS: &[&str] = &[
4794 "column_subsets",
4795 "columnSubsets",
4796 ];
4797
4798 #[allow(clippy::enum_variant_names)]
4799 enum GeneratedField {
4800 ColumnSubsets,
4801 }
4802 impl<'de> serde::Deserialize<'de> for GeneratedField {
4803 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4804 where
4805 D: serde::Deserializer<'de>,
4806 {
4807 struct GeneratedVisitor;
4808
4809 impl serde::de::Visitor<'_> for GeneratedVisitor {
4810 type Value = GeneratedField;
4811
4812 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4813 write!(formatter, "expected one of: {:?}", &FIELDS)
4814 }
4815
4816 #[allow(unused_variables)]
4817 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4818 where
4819 E: serde::de::Error,
4820 {
4821 match value {
4822 "columnSubsets" | "column_subsets" => Ok(GeneratedField::ColumnSubsets),
4823 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4824 }
4825 }
4826 }
4827 deserializer.deserialize_identifier(GeneratedVisitor)
4828 }
4829 }
4830 struct GeneratedVisitor;
4831 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4832 type Value = ExpandNode;
4833
4834 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4835 formatter.write_str("struct stream_plan.ExpandNode")
4836 }
4837
4838 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpandNode, V::Error>
4839 where
4840 V: serde::de::MapAccess<'de>,
4841 {
4842 let mut column_subsets__ = None;
4843 while let Some(k) = map_.next_key()? {
4844 match k {
4845 GeneratedField::ColumnSubsets => {
4846 if column_subsets__.is_some() {
4847 return Err(serde::de::Error::duplicate_field("columnSubsets"));
4848 }
4849 column_subsets__ = Some(map_.next_value()?);
4850 }
4851 }
4852 }
4853 Ok(ExpandNode {
4854 column_subsets: column_subsets__.unwrap_or_default(),
4855 })
4856 }
4857 }
4858 deserializer.deserialize_struct("stream_plan.ExpandNode", FIELDS, GeneratedVisitor)
4859 }
4860}
4861impl serde::Serialize for expand_node::Subset {
4862 #[allow(deprecated)]
4863 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4864 where
4865 S: serde::Serializer,
4866 {
4867 use serde::ser::SerializeStruct;
4868 let mut len = 0;
4869 if !self.column_indices.is_empty() {
4870 len += 1;
4871 }
4872 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode.Subset", len)?;
4873 if !self.column_indices.is_empty() {
4874 struct_ser.serialize_field("columnIndices", &self.column_indices)?;
4875 }
4876 struct_ser.end()
4877 }
4878}
4879impl<'de> serde::Deserialize<'de> for expand_node::Subset {
4880 #[allow(deprecated)]
4881 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4882 where
4883 D: serde::Deserializer<'de>,
4884 {
4885 const FIELDS: &[&str] = &[
4886 "column_indices",
4887 "columnIndices",
4888 ];
4889
4890 #[allow(clippy::enum_variant_names)]
4891 enum GeneratedField {
4892 ColumnIndices,
4893 }
4894 impl<'de> serde::Deserialize<'de> for GeneratedField {
4895 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4896 where
4897 D: serde::Deserializer<'de>,
4898 {
4899 struct GeneratedVisitor;
4900
4901 impl serde::de::Visitor<'_> for GeneratedVisitor {
4902 type Value = GeneratedField;
4903
4904 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4905 write!(formatter, "expected one of: {:?}", &FIELDS)
4906 }
4907
4908 #[allow(unused_variables)]
4909 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4910 where
4911 E: serde::de::Error,
4912 {
4913 match value {
4914 "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
4915 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4916 }
4917 }
4918 }
4919 deserializer.deserialize_identifier(GeneratedVisitor)
4920 }
4921 }
4922 struct GeneratedVisitor;
4923 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4924 type Value = expand_node::Subset;
4925
4926 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4927 formatter.write_str("struct stream_plan.ExpandNode.Subset")
4928 }
4929
4930 fn visit_map<V>(self, mut map_: V) -> std::result::Result<expand_node::Subset, V::Error>
4931 where
4932 V: serde::de::MapAccess<'de>,
4933 {
4934 let mut column_indices__ = None;
4935 while let Some(k) = map_.next_key()? {
4936 match k {
4937 GeneratedField::ColumnIndices => {
4938 if column_indices__.is_some() {
4939 return Err(serde::de::Error::duplicate_field("columnIndices"));
4940 }
4941 column_indices__ =
4942 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4943 .into_iter().map(|x| x.0).collect())
4944 ;
4945 }
4946 }
4947 }
4948 Ok(expand_node::Subset {
4949 column_indices: column_indices__.unwrap_or_default(),
4950 })
4951 }
4952 }
4953 deserializer.deserialize_struct("stream_plan.ExpandNode.Subset", FIELDS, GeneratedVisitor)
4954 }
4955}
4956impl serde::Serialize for FilterNode {
4957 #[allow(deprecated)]
4958 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4959 where
4960 S: serde::Serializer,
4961 {
4962 use serde::ser::SerializeStruct;
4963 let mut len = 0;
4964 if self.search_condition.is_some() {
4965 len += 1;
4966 }
4967 let mut struct_ser = serializer.serialize_struct("stream_plan.FilterNode", len)?;
4968 if let Some(v) = self.search_condition.as_ref() {
4969 struct_ser.serialize_field("searchCondition", v)?;
4970 }
4971 struct_ser.end()
4972 }
4973}
4974impl<'de> serde::Deserialize<'de> for FilterNode {
4975 #[allow(deprecated)]
4976 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4977 where
4978 D: serde::Deserializer<'de>,
4979 {
4980 const FIELDS: &[&str] = &[
4981 "search_condition",
4982 "searchCondition",
4983 ];
4984
4985 #[allow(clippy::enum_variant_names)]
4986 enum GeneratedField {
4987 SearchCondition,
4988 }
4989 impl<'de> serde::Deserialize<'de> for GeneratedField {
4990 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4991 where
4992 D: serde::Deserializer<'de>,
4993 {
4994 struct GeneratedVisitor;
4995
4996 impl serde::de::Visitor<'_> for GeneratedVisitor {
4997 type Value = GeneratedField;
4998
4999 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5000 write!(formatter, "expected one of: {:?}", &FIELDS)
5001 }
5002
5003 #[allow(unused_variables)]
5004 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5005 where
5006 E: serde::de::Error,
5007 {
5008 match value {
5009 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
5010 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5011 }
5012 }
5013 }
5014 deserializer.deserialize_identifier(GeneratedVisitor)
5015 }
5016 }
5017 struct GeneratedVisitor;
5018 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5019 type Value = FilterNode;
5020
5021 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5022 formatter.write_str("struct stream_plan.FilterNode")
5023 }
5024
5025 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FilterNode, V::Error>
5026 where
5027 V: serde::de::MapAccess<'de>,
5028 {
5029 let mut search_condition__ = None;
5030 while let Some(k) = map_.next_key()? {
5031 match k {
5032 GeneratedField::SearchCondition => {
5033 if search_condition__.is_some() {
5034 return Err(serde::de::Error::duplicate_field("searchCondition"));
5035 }
5036 search_condition__ = map_.next_value()?;
5037 }
5038 }
5039 }
5040 Ok(FilterNode {
5041 search_condition: search_condition__,
5042 })
5043 }
5044 }
5045 deserializer.deserialize_struct("stream_plan.FilterNode", FIELDS, GeneratedVisitor)
5046 }
5047}
5048impl serde::Serialize for GapFillNode {
5049 #[allow(deprecated)]
5050 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5051 where
5052 S: serde::Serializer,
5053 {
5054 use serde::ser::SerializeStruct;
5055 let mut len = 0;
5056 if self.time_column_index != 0 {
5057 len += 1;
5058 }
5059 if self.interval.is_some() {
5060 len += 1;
5061 }
5062 if !self.fill_columns.is_empty() {
5063 len += 1;
5064 }
5065 if !self.fill_strategies.is_empty() {
5066 len += 1;
5067 }
5068 if self.state_table.is_some() {
5069 len += 1;
5070 }
5071 let mut struct_ser = serializer.serialize_struct("stream_plan.GapFillNode", len)?;
5072 if self.time_column_index != 0 {
5073 struct_ser.serialize_field("timeColumnIndex", &self.time_column_index)?;
5074 }
5075 if let Some(v) = self.interval.as_ref() {
5076 struct_ser.serialize_field("interval", v)?;
5077 }
5078 if !self.fill_columns.is_empty() {
5079 struct_ser.serialize_field("fillColumns", &self.fill_columns)?;
5080 }
5081 if !self.fill_strategies.is_empty() {
5082 struct_ser.serialize_field("fillStrategies", &self.fill_strategies)?;
5083 }
5084 if let Some(v) = self.state_table.as_ref() {
5085 struct_ser.serialize_field("stateTable", v)?;
5086 }
5087 struct_ser.end()
5088 }
5089}
5090impl<'de> serde::Deserialize<'de> for GapFillNode {
5091 #[allow(deprecated)]
5092 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5093 where
5094 D: serde::Deserializer<'de>,
5095 {
5096 const FIELDS: &[&str] = &[
5097 "time_column_index",
5098 "timeColumnIndex",
5099 "interval",
5100 "fill_columns",
5101 "fillColumns",
5102 "fill_strategies",
5103 "fillStrategies",
5104 "state_table",
5105 "stateTable",
5106 ];
5107
5108 #[allow(clippy::enum_variant_names)]
5109 enum GeneratedField {
5110 TimeColumnIndex,
5111 Interval,
5112 FillColumns,
5113 FillStrategies,
5114 StateTable,
5115 }
5116 impl<'de> serde::Deserialize<'de> for GeneratedField {
5117 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5118 where
5119 D: serde::Deserializer<'de>,
5120 {
5121 struct GeneratedVisitor;
5122
5123 impl serde::de::Visitor<'_> for GeneratedVisitor {
5124 type Value = GeneratedField;
5125
5126 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5127 write!(formatter, "expected one of: {:?}", &FIELDS)
5128 }
5129
5130 #[allow(unused_variables)]
5131 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5132 where
5133 E: serde::de::Error,
5134 {
5135 match value {
5136 "timeColumnIndex" | "time_column_index" => Ok(GeneratedField::TimeColumnIndex),
5137 "interval" => Ok(GeneratedField::Interval),
5138 "fillColumns" | "fill_columns" => Ok(GeneratedField::FillColumns),
5139 "fillStrategies" | "fill_strategies" => Ok(GeneratedField::FillStrategies),
5140 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
5141 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5142 }
5143 }
5144 }
5145 deserializer.deserialize_identifier(GeneratedVisitor)
5146 }
5147 }
5148 struct GeneratedVisitor;
5149 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5150 type Value = GapFillNode;
5151
5152 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5153 formatter.write_str("struct stream_plan.GapFillNode")
5154 }
5155
5156 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GapFillNode, V::Error>
5157 where
5158 V: serde::de::MapAccess<'de>,
5159 {
5160 let mut time_column_index__ = None;
5161 let mut interval__ = None;
5162 let mut fill_columns__ = None;
5163 let mut fill_strategies__ = None;
5164 let mut state_table__ = None;
5165 while let Some(k) = map_.next_key()? {
5166 match k {
5167 GeneratedField::TimeColumnIndex => {
5168 if time_column_index__.is_some() {
5169 return Err(serde::de::Error::duplicate_field("timeColumnIndex"));
5170 }
5171 time_column_index__ =
5172 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5173 ;
5174 }
5175 GeneratedField::Interval => {
5176 if interval__.is_some() {
5177 return Err(serde::de::Error::duplicate_field("interval"));
5178 }
5179 interval__ = map_.next_value()?;
5180 }
5181 GeneratedField::FillColumns => {
5182 if fill_columns__.is_some() {
5183 return Err(serde::de::Error::duplicate_field("fillColumns"));
5184 }
5185 fill_columns__ =
5186 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5187 .into_iter().map(|x| x.0).collect())
5188 ;
5189 }
5190 GeneratedField::FillStrategies => {
5191 if fill_strategies__.is_some() {
5192 return Err(serde::de::Error::duplicate_field("fillStrategies"));
5193 }
5194 fill_strategies__ = Some(map_.next_value()?);
5195 }
5196 GeneratedField::StateTable => {
5197 if state_table__.is_some() {
5198 return Err(serde::de::Error::duplicate_field("stateTable"));
5199 }
5200 state_table__ = map_.next_value()?;
5201 }
5202 }
5203 }
5204 Ok(GapFillNode {
5205 time_column_index: time_column_index__.unwrap_or_default(),
5206 interval: interval__,
5207 fill_columns: fill_columns__.unwrap_or_default(),
5208 fill_strategies: fill_strategies__.unwrap_or_default(),
5209 state_table: state_table__,
5210 })
5211 }
5212 }
5213 deserializer.deserialize_struct("stream_plan.GapFillNode", FIELDS, GeneratedVisitor)
5214 }
5215}
5216impl serde::Serialize for GlobalApproxPercentileNode {
5217 #[allow(deprecated)]
5218 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5219 where
5220 S: serde::Serializer,
5221 {
5222 use serde::ser::SerializeStruct;
5223 let mut len = 0;
5224 if self.base != 0. {
5225 len += 1;
5226 }
5227 if self.quantile != 0. {
5228 len += 1;
5229 }
5230 if self.bucket_state_table.is_some() {
5231 len += 1;
5232 }
5233 if self.count_state_table.is_some() {
5234 len += 1;
5235 }
5236 let mut struct_ser = serializer.serialize_struct("stream_plan.GlobalApproxPercentileNode", len)?;
5237 if self.base != 0. {
5238 struct_ser.serialize_field("base", &self.base)?;
5239 }
5240 if self.quantile != 0. {
5241 struct_ser.serialize_field("quantile", &self.quantile)?;
5242 }
5243 if let Some(v) = self.bucket_state_table.as_ref() {
5244 struct_ser.serialize_field("bucketStateTable", v)?;
5245 }
5246 if let Some(v) = self.count_state_table.as_ref() {
5247 struct_ser.serialize_field("countStateTable", v)?;
5248 }
5249 struct_ser.end()
5250 }
5251}
5252impl<'de> serde::Deserialize<'de> for GlobalApproxPercentileNode {
5253 #[allow(deprecated)]
5254 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5255 where
5256 D: serde::Deserializer<'de>,
5257 {
5258 const FIELDS: &[&str] = &[
5259 "base",
5260 "quantile",
5261 "bucket_state_table",
5262 "bucketStateTable",
5263 "count_state_table",
5264 "countStateTable",
5265 ];
5266
5267 #[allow(clippy::enum_variant_names)]
5268 enum GeneratedField {
5269 Base,
5270 Quantile,
5271 BucketStateTable,
5272 CountStateTable,
5273 }
5274 impl<'de> serde::Deserialize<'de> for GeneratedField {
5275 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5276 where
5277 D: serde::Deserializer<'de>,
5278 {
5279 struct GeneratedVisitor;
5280
5281 impl serde::de::Visitor<'_> for GeneratedVisitor {
5282 type Value = GeneratedField;
5283
5284 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5285 write!(formatter, "expected one of: {:?}", &FIELDS)
5286 }
5287
5288 #[allow(unused_variables)]
5289 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5290 where
5291 E: serde::de::Error,
5292 {
5293 match value {
5294 "base" => Ok(GeneratedField::Base),
5295 "quantile" => Ok(GeneratedField::Quantile),
5296 "bucketStateTable" | "bucket_state_table" => Ok(GeneratedField::BucketStateTable),
5297 "countStateTable" | "count_state_table" => Ok(GeneratedField::CountStateTable),
5298 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5299 }
5300 }
5301 }
5302 deserializer.deserialize_identifier(GeneratedVisitor)
5303 }
5304 }
5305 struct GeneratedVisitor;
5306 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5307 type Value = GlobalApproxPercentileNode;
5308
5309 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5310 formatter.write_str("struct stream_plan.GlobalApproxPercentileNode")
5311 }
5312
5313 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GlobalApproxPercentileNode, V::Error>
5314 where
5315 V: serde::de::MapAccess<'de>,
5316 {
5317 let mut base__ = None;
5318 let mut quantile__ = None;
5319 let mut bucket_state_table__ = None;
5320 let mut count_state_table__ = None;
5321 while let Some(k) = map_.next_key()? {
5322 match k {
5323 GeneratedField::Base => {
5324 if base__.is_some() {
5325 return Err(serde::de::Error::duplicate_field("base"));
5326 }
5327 base__ =
5328 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5329 ;
5330 }
5331 GeneratedField::Quantile => {
5332 if quantile__.is_some() {
5333 return Err(serde::de::Error::duplicate_field("quantile"));
5334 }
5335 quantile__ =
5336 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5337 ;
5338 }
5339 GeneratedField::BucketStateTable => {
5340 if bucket_state_table__.is_some() {
5341 return Err(serde::de::Error::duplicate_field("bucketStateTable"));
5342 }
5343 bucket_state_table__ = map_.next_value()?;
5344 }
5345 GeneratedField::CountStateTable => {
5346 if count_state_table__.is_some() {
5347 return Err(serde::de::Error::duplicate_field("countStateTable"));
5348 }
5349 count_state_table__ = map_.next_value()?;
5350 }
5351 }
5352 }
5353 Ok(GlobalApproxPercentileNode {
5354 base: base__.unwrap_or_default(),
5355 quantile: quantile__.unwrap_or_default(),
5356 bucket_state_table: bucket_state_table__,
5357 count_state_table: count_state_table__,
5358 })
5359 }
5360 }
5361 deserializer.deserialize_struct("stream_plan.GlobalApproxPercentileNode", FIELDS, GeneratedVisitor)
5362 }
5363}
5364impl serde::Serialize for GroupTopNNode {
5365 #[allow(deprecated)]
5366 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5367 where
5368 S: serde::Serializer,
5369 {
5370 use serde::ser::SerializeStruct;
5371 let mut len = 0;
5372 if self.limit != 0 {
5373 len += 1;
5374 }
5375 if self.offset != 0 {
5376 len += 1;
5377 }
5378 if !self.group_key.is_empty() {
5379 len += 1;
5380 }
5381 if self.table.is_some() {
5382 len += 1;
5383 }
5384 if !self.order_by.is_empty() {
5385 len += 1;
5386 }
5387 if self.with_ties {
5388 len += 1;
5389 }
5390 let mut struct_ser = serializer.serialize_struct("stream_plan.GroupTopNNode", len)?;
5391 if self.limit != 0 {
5392 #[allow(clippy::needless_borrow)]
5393 #[allow(clippy::needless_borrows_for_generic_args)]
5394 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
5395 }
5396 if self.offset != 0 {
5397 #[allow(clippy::needless_borrow)]
5398 #[allow(clippy::needless_borrows_for_generic_args)]
5399 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
5400 }
5401 if !self.group_key.is_empty() {
5402 struct_ser.serialize_field("groupKey", &self.group_key)?;
5403 }
5404 if let Some(v) = self.table.as_ref() {
5405 struct_ser.serialize_field("table", v)?;
5406 }
5407 if !self.order_by.is_empty() {
5408 struct_ser.serialize_field("orderBy", &self.order_by)?;
5409 }
5410 if self.with_ties {
5411 struct_ser.serialize_field("withTies", &self.with_ties)?;
5412 }
5413 struct_ser.end()
5414 }
5415}
5416impl<'de> serde::Deserialize<'de> for GroupTopNNode {
5417 #[allow(deprecated)]
5418 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5419 where
5420 D: serde::Deserializer<'de>,
5421 {
5422 const FIELDS: &[&str] = &[
5423 "limit",
5424 "offset",
5425 "group_key",
5426 "groupKey",
5427 "table",
5428 "order_by",
5429 "orderBy",
5430 "with_ties",
5431 "withTies",
5432 ];
5433
5434 #[allow(clippy::enum_variant_names)]
5435 enum GeneratedField {
5436 Limit,
5437 Offset,
5438 GroupKey,
5439 Table,
5440 OrderBy,
5441 WithTies,
5442 }
5443 impl<'de> serde::Deserialize<'de> for GeneratedField {
5444 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5445 where
5446 D: serde::Deserializer<'de>,
5447 {
5448 struct GeneratedVisitor;
5449
5450 impl serde::de::Visitor<'_> for GeneratedVisitor {
5451 type Value = GeneratedField;
5452
5453 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5454 write!(formatter, "expected one of: {:?}", &FIELDS)
5455 }
5456
5457 #[allow(unused_variables)]
5458 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5459 where
5460 E: serde::de::Error,
5461 {
5462 match value {
5463 "limit" => Ok(GeneratedField::Limit),
5464 "offset" => Ok(GeneratedField::Offset),
5465 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5466 "table" => Ok(GeneratedField::Table),
5467 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
5468 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
5469 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5470 }
5471 }
5472 }
5473 deserializer.deserialize_identifier(GeneratedVisitor)
5474 }
5475 }
5476 struct GeneratedVisitor;
5477 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5478 type Value = GroupTopNNode;
5479
5480 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5481 formatter.write_str("struct stream_plan.GroupTopNNode")
5482 }
5483
5484 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupTopNNode, V::Error>
5485 where
5486 V: serde::de::MapAccess<'de>,
5487 {
5488 let mut limit__ = None;
5489 let mut offset__ = None;
5490 let mut group_key__ = None;
5491 let mut table__ = None;
5492 let mut order_by__ = None;
5493 let mut with_ties__ = None;
5494 while let Some(k) = map_.next_key()? {
5495 match k {
5496 GeneratedField::Limit => {
5497 if limit__.is_some() {
5498 return Err(serde::de::Error::duplicate_field("limit"));
5499 }
5500 limit__ =
5501 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5502 ;
5503 }
5504 GeneratedField::Offset => {
5505 if offset__.is_some() {
5506 return Err(serde::de::Error::duplicate_field("offset"));
5507 }
5508 offset__ =
5509 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5510 ;
5511 }
5512 GeneratedField::GroupKey => {
5513 if group_key__.is_some() {
5514 return Err(serde::de::Error::duplicate_field("groupKey"));
5515 }
5516 group_key__ =
5517 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5518 .into_iter().map(|x| x.0).collect())
5519 ;
5520 }
5521 GeneratedField::Table => {
5522 if table__.is_some() {
5523 return Err(serde::de::Error::duplicate_field("table"));
5524 }
5525 table__ = map_.next_value()?;
5526 }
5527 GeneratedField::OrderBy => {
5528 if order_by__.is_some() {
5529 return Err(serde::de::Error::duplicate_field("orderBy"));
5530 }
5531 order_by__ = Some(map_.next_value()?);
5532 }
5533 GeneratedField::WithTies => {
5534 if with_ties__.is_some() {
5535 return Err(serde::de::Error::duplicate_field("withTies"));
5536 }
5537 with_ties__ = Some(map_.next_value()?);
5538 }
5539 }
5540 }
5541 Ok(GroupTopNNode {
5542 limit: limit__.unwrap_or_default(),
5543 offset: offset__.unwrap_or_default(),
5544 group_key: group_key__.unwrap_or_default(),
5545 table: table__,
5546 order_by: order_by__.unwrap_or_default(),
5547 with_ties: with_ties__.unwrap_or_default(),
5548 })
5549 }
5550 }
5551 deserializer.deserialize_struct("stream_plan.GroupTopNNode", FIELDS, GeneratedVisitor)
5552 }
5553}
5554impl serde::Serialize for HashAggNode {
5555 #[allow(deprecated)]
5556 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5557 where
5558 S: serde::Serializer,
5559 {
5560 use serde::ser::SerializeStruct;
5561 let mut len = 0;
5562 if !self.group_key.is_empty() {
5563 len += 1;
5564 }
5565 if !self.agg_calls.is_empty() {
5566 len += 1;
5567 }
5568 if !self.agg_call_states.is_empty() {
5569 len += 1;
5570 }
5571 if self.intermediate_state_table.is_some() {
5572 len += 1;
5573 }
5574 if self.is_append_only {
5575 len += 1;
5576 }
5577 if !self.distinct_dedup_tables.is_empty() {
5578 len += 1;
5579 }
5580 if self.row_count_index != 0 {
5581 len += 1;
5582 }
5583 if self.emit_on_window_close {
5584 len += 1;
5585 }
5586 if self.version != 0 {
5587 len += 1;
5588 }
5589 let mut struct_ser = serializer.serialize_struct("stream_plan.HashAggNode", len)?;
5590 if !self.group_key.is_empty() {
5591 struct_ser.serialize_field("groupKey", &self.group_key)?;
5592 }
5593 if !self.agg_calls.is_empty() {
5594 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
5595 }
5596 if !self.agg_call_states.is_empty() {
5597 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
5598 }
5599 if let Some(v) = self.intermediate_state_table.as_ref() {
5600 struct_ser.serialize_field("intermediateStateTable", v)?;
5601 }
5602 if self.is_append_only {
5603 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5604 }
5605 if !self.distinct_dedup_tables.is_empty() {
5606 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
5607 }
5608 if self.row_count_index != 0 {
5609 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
5610 }
5611 if self.emit_on_window_close {
5612 struct_ser.serialize_field("emitOnWindowClose", &self.emit_on_window_close)?;
5613 }
5614 if self.version != 0 {
5615 let v = AggNodeVersion::try_from(self.version)
5616 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
5617 struct_ser.serialize_field("version", &v)?;
5618 }
5619 struct_ser.end()
5620 }
5621}
5622impl<'de> serde::Deserialize<'de> for HashAggNode {
5623 #[allow(deprecated)]
5624 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5625 where
5626 D: serde::Deserializer<'de>,
5627 {
5628 const FIELDS: &[&str] = &[
5629 "group_key",
5630 "groupKey",
5631 "agg_calls",
5632 "aggCalls",
5633 "agg_call_states",
5634 "aggCallStates",
5635 "intermediate_state_table",
5636 "intermediateStateTable",
5637 "is_append_only",
5638 "isAppendOnly",
5639 "distinct_dedup_tables",
5640 "distinctDedupTables",
5641 "row_count_index",
5642 "rowCountIndex",
5643 "emit_on_window_close",
5644 "emitOnWindowClose",
5645 "version",
5646 ];
5647
5648 #[allow(clippy::enum_variant_names)]
5649 enum GeneratedField {
5650 GroupKey,
5651 AggCalls,
5652 AggCallStates,
5653 IntermediateStateTable,
5654 IsAppendOnly,
5655 DistinctDedupTables,
5656 RowCountIndex,
5657 EmitOnWindowClose,
5658 Version,
5659 }
5660 impl<'de> serde::Deserialize<'de> for GeneratedField {
5661 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5662 where
5663 D: serde::Deserializer<'de>,
5664 {
5665 struct GeneratedVisitor;
5666
5667 impl serde::de::Visitor<'_> for GeneratedVisitor {
5668 type Value = GeneratedField;
5669
5670 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5671 write!(formatter, "expected one of: {:?}", &FIELDS)
5672 }
5673
5674 #[allow(unused_variables)]
5675 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5676 where
5677 E: serde::de::Error,
5678 {
5679 match value {
5680 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5681 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
5682 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
5683 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
5684 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5685 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
5686 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
5687 "emitOnWindowClose" | "emit_on_window_close" => Ok(GeneratedField::EmitOnWindowClose),
5688 "version" => Ok(GeneratedField::Version),
5689 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5690 }
5691 }
5692 }
5693 deserializer.deserialize_identifier(GeneratedVisitor)
5694 }
5695 }
5696 struct GeneratedVisitor;
5697 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5698 type Value = HashAggNode;
5699
5700 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5701 formatter.write_str("struct stream_plan.HashAggNode")
5702 }
5703
5704 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashAggNode, V::Error>
5705 where
5706 V: serde::de::MapAccess<'de>,
5707 {
5708 let mut group_key__ = None;
5709 let mut agg_calls__ = None;
5710 let mut agg_call_states__ = None;
5711 let mut intermediate_state_table__ = None;
5712 let mut is_append_only__ = None;
5713 let mut distinct_dedup_tables__ = None;
5714 let mut row_count_index__ = None;
5715 let mut emit_on_window_close__ = None;
5716 let mut version__ = None;
5717 while let Some(k) = map_.next_key()? {
5718 match k {
5719 GeneratedField::GroupKey => {
5720 if group_key__.is_some() {
5721 return Err(serde::de::Error::duplicate_field("groupKey"));
5722 }
5723 group_key__ =
5724 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5725 .into_iter().map(|x| x.0).collect())
5726 ;
5727 }
5728 GeneratedField::AggCalls => {
5729 if agg_calls__.is_some() {
5730 return Err(serde::de::Error::duplicate_field("aggCalls"));
5731 }
5732 agg_calls__ = Some(map_.next_value()?);
5733 }
5734 GeneratedField::AggCallStates => {
5735 if agg_call_states__.is_some() {
5736 return Err(serde::de::Error::duplicate_field("aggCallStates"));
5737 }
5738 agg_call_states__ = Some(map_.next_value()?);
5739 }
5740 GeneratedField::IntermediateStateTable => {
5741 if intermediate_state_table__.is_some() {
5742 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
5743 }
5744 intermediate_state_table__ = map_.next_value()?;
5745 }
5746 GeneratedField::IsAppendOnly => {
5747 if is_append_only__.is_some() {
5748 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
5749 }
5750 is_append_only__ = Some(map_.next_value()?);
5751 }
5752 GeneratedField::DistinctDedupTables => {
5753 if distinct_dedup_tables__.is_some() {
5754 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
5755 }
5756 distinct_dedup_tables__ = Some(
5757 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5758 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
5759 );
5760 }
5761 GeneratedField::RowCountIndex => {
5762 if row_count_index__.is_some() {
5763 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
5764 }
5765 row_count_index__ =
5766 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5767 ;
5768 }
5769 GeneratedField::EmitOnWindowClose => {
5770 if emit_on_window_close__.is_some() {
5771 return Err(serde::de::Error::duplicate_field("emitOnWindowClose"));
5772 }
5773 emit_on_window_close__ = Some(map_.next_value()?);
5774 }
5775 GeneratedField::Version => {
5776 if version__.is_some() {
5777 return Err(serde::de::Error::duplicate_field("version"));
5778 }
5779 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
5780 }
5781 }
5782 }
5783 Ok(HashAggNode {
5784 group_key: group_key__.unwrap_or_default(),
5785 agg_calls: agg_calls__.unwrap_or_default(),
5786 agg_call_states: agg_call_states__.unwrap_or_default(),
5787 intermediate_state_table: intermediate_state_table__,
5788 is_append_only: is_append_only__.unwrap_or_default(),
5789 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
5790 row_count_index: row_count_index__.unwrap_or_default(),
5791 emit_on_window_close: emit_on_window_close__.unwrap_or_default(),
5792 version: version__.unwrap_or_default(),
5793 })
5794 }
5795 }
5796 deserializer.deserialize_struct("stream_plan.HashAggNode", FIELDS, GeneratedVisitor)
5797 }
5798}
5799impl serde::Serialize for HashJoinNode {
5800 #[allow(deprecated)]
5801 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5802 where
5803 S: serde::Serializer,
5804 {
5805 use serde::ser::SerializeStruct;
5806 let mut len = 0;
5807 if self.join_type != 0 {
5808 len += 1;
5809 }
5810 if !self.left_key.is_empty() {
5811 len += 1;
5812 }
5813 if !self.right_key.is_empty() {
5814 len += 1;
5815 }
5816 if self.condition.is_some() {
5817 len += 1;
5818 }
5819 if !self.inequality_pairs.is_empty() {
5820 len += 1;
5821 }
5822 if self.left_table.is_some() {
5823 len += 1;
5824 }
5825 if self.right_table.is_some() {
5826 len += 1;
5827 }
5828 if self.left_degree_table.is_some() {
5829 len += 1;
5830 }
5831 if self.right_degree_table.is_some() {
5832 len += 1;
5833 }
5834 if !self.output_indices.is_empty() {
5835 len += 1;
5836 }
5837 if !self.left_deduped_input_pk_indices.is_empty() {
5838 len += 1;
5839 }
5840 if !self.right_deduped_input_pk_indices.is_empty() {
5841 len += 1;
5842 }
5843 if !self.null_safe.is_empty() {
5844 len += 1;
5845 }
5846 if self.is_append_only {
5847 len += 1;
5848 }
5849 if self.join_encoding_type != 0 {
5850 len += 1;
5851 }
5852 if !self.inequality_pairs_v2.is_empty() {
5853 len += 1;
5854 }
5855 let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinNode", len)?;
5856 if self.join_type != 0 {
5857 let v = super::plan_common::JoinType::try_from(self.join_type)
5858 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
5859 struct_ser.serialize_field("joinType", &v)?;
5860 }
5861 if !self.left_key.is_empty() {
5862 struct_ser.serialize_field("leftKey", &self.left_key)?;
5863 }
5864 if !self.right_key.is_empty() {
5865 struct_ser.serialize_field("rightKey", &self.right_key)?;
5866 }
5867 if let Some(v) = self.condition.as_ref() {
5868 struct_ser.serialize_field("condition", v)?;
5869 }
5870 if !self.inequality_pairs.is_empty() {
5871 struct_ser.serialize_field("inequalityPairs", &self.inequality_pairs)?;
5872 }
5873 if let Some(v) = self.left_table.as_ref() {
5874 struct_ser.serialize_field("leftTable", v)?;
5875 }
5876 if let Some(v) = self.right_table.as_ref() {
5877 struct_ser.serialize_field("rightTable", v)?;
5878 }
5879 if let Some(v) = self.left_degree_table.as_ref() {
5880 struct_ser.serialize_field("leftDegreeTable", v)?;
5881 }
5882 if let Some(v) = self.right_degree_table.as_ref() {
5883 struct_ser.serialize_field("rightDegreeTable", v)?;
5884 }
5885 if !self.output_indices.is_empty() {
5886 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
5887 }
5888 if !self.left_deduped_input_pk_indices.is_empty() {
5889 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
5890 }
5891 if !self.right_deduped_input_pk_indices.is_empty() {
5892 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
5893 }
5894 if !self.null_safe.is_empty() {
5895 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
5896 }
5897 if self.is_append_only {
5898 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5899 }
5900 if self.join_encoding_type != 0 {
5901 let v = JoinEncodingType::try_from(self.join_encoding_type)
5902 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
5903 struct_ser.serialize_field("joinEncodingType", &v)?;
5904 }
5905 if !self.inequality_pairs_v2.is_empty() {
5906 struct_ser.serialize_field("inequalityPairsV2", &self.inequality_pairs_v2)?;
5907 }
5908 struct_ser.end()
5909 }
5910}
5911impl<'de> serde::Deserialize<'de> for HashJoinNode {
5912 #[allow(deprecated)]
5913 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5914 where
5915 D: serde::Deserializer<'de>,
5916 {
5917 const FIELDS: &[&str] = &[
5918 "join_type",
5919 "joinType",
5920 "left_key",
5921 "leftKey",
5922 "right_key",
5923 "rightKey",
5924 "condition",
5925 "inequality_pairs",
5926 "inequalityPairs",
5927 "left_table",
5928 "leftTable",
5929 "right_table",
5930 "rightTable",
5931 "left_degree_table",
5932 "leftDegreeTable",
5933 "right_degree_table",
5934 "rightDegreeTable",
5935 "output_indices",
5936 "outputIndices",
5937 "left_deduped_input_pk_indices",
5938 "leftDedupedInputPkIndices",
5939 "right_deduped_input_pk_indices",
5940 "rightDedupedInputPkIndices",
5941 "null_safe",
5942 "nullSafe",
5943 "is_append_only",
5944 "isAppendOnly",
5945 "join_encoding_type",
5946 "joinEncodingType",
5947 "inequality_pairs_v2",
5948 "inequalityPairsV2",
5949 ];
5950
5951 #[allow(clippy::enum_variant_names)]
5952 enum GeneratedField {
5953 JoinType,
5954 LeftKey,
5955 RightKey,
5956 Condition,
5957 InequalityPairs,
5958 LeftTable,
5959 RightTable,
5960 LeftDegreeTable,
5961 RightDegreeTable,
5962 OutputIndices,
5963 LeftDedupedInputPkIndices,
5964 RightDedupedInputPkIndices,
5965 NullSafe,
5966 IsAppendOnly,
5967 JoinEncodingType,
5968 InequalityPairsV2,
5969 }
5970 impl<'de> serde::Deserialize<'de> for GeneratedField {
5971 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5972 where
5973 D: serde::Deserializer<'de>,
5974 {
5975 struct GeneratedVisitor;
5976
5977 impl serde::de::Visitor<'_> for GeneratedVisitor {
5978 type Value = GeneratedField;
5979
5980 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5981 write!(formatter, "expected one of: {:?}", &FIELDS)
5982 }
5983
5984 #[allow(unused_variables)]
5985 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5986 where
5987 E: serde::de::Error,
5988 {
5989 match value {
5990 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
5991 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
5992 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
5993 "condition" => Ok(GeneratedField::Condition),
5994 "inequalityPairs" | "inequality_pairs" => Ok(GeneratedField::InequalityPairs),
5995 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
5996 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
5997 "leftDegreeTable" | "left_degree_table" => Ok(GeneratedField::LeftDegreeTable),
5998 "rightDegreeTable" | "right_degree_table" => Ok(GeneratedField::RightDegreeTable),
5999 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
6000 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
6001 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
6002 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
6003 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
6004 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
6005 "inequalityPairsV2" | "inequality_pairs_v2" => Ok(GeneratedField::InequalityPairsV2),
6006 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6007 }
6008 }
6009 }
6010 deserializer.deserialize_identifier(GeneratedVisitor)
6011 }
6012 }
6013 struct GeneratedVisitor;
6014 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6015 type Value = HashJoinNode;
6016
6017 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6018 formatter.write_str("struct stream_plan.HashJoinNode")
6019 }
6020
6021 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinNode, V::Error>
6022 where
6023 V: serde::de::MapAccess<'de>,
6024 {
6025 let mut join_type__ = None;
6026 let mut left_key__ = None;
6027 let mut right_key__ = None;
6028 let mut condition__ = None;
6029 let mut inequality_pairs__ = None;
6030 let mut left_table__ = None;
6031 let mut right_table__ = None;
6032 let mut left_degree_table__ = None;
6033 let mut right_degree_table__ = None;
6034 let mut output_indices__ = None;
6035 let mut left_deduped_input_pk_indices__ = None;
6036 let mut right_deduped_input_pk_indices__ = None;
6037 let mut null_safe__ = None;
6038 let mut is_append_only__ = None;
6039 let mut join_encoding_type__ = None;
6040 let mut inequality_pairs_v2__ = None;
6041 while let Some(k) = map_.next_key()? {
6042 match k {
6043 GeneratedField::JoinType => {
6044 if join_type__.is_some() {
6045 return Err(serde::de::Error::duplicate_field("joinType"));
6046 }
6047 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
6048 }
6049 GeneratedField::LeftKey => {
6050 if left_key__.is_some() {
6051 return Err(serde::de::Error::duplicate_field("leftKey"));
6052 }
6053 left_key__ =
6054 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6055 .into_iter().map(|x| x.0).collect())
6056 ;
6057 }
6058 GeneratedField::RightKey => {
6059 if right_key__.is_some() {
6060 return Err(serde::de::Error::duplicate_field("rightKey"));
6061 }
6062 right_key__ =
6063 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6064 .into_iter().map(|x| x.0).collect())
6065 ;
6066 }
6067 GeneratedField::Condition => {
6068 if condition__.is_some() {
6069 return Err(serde::de::Error::duplicate_field("condition"));
6070 }
6071 condition__ = map_.next_value()?;
6072 }
6073 GeneratedField::InequalityPairs => {
6074 if inequality_pairs__.is_some() {
6075 return Err(serde::de::Error::duplicate_field("inequalityPairs"));
6076 }
6077 inequality_pairs__ = Some(map_.next_value()?);
6078 }
6079 GeneratedField::LeftTable => {
6080 if left_table__.is_some() {
6081 return Err(serde::de::Error::duplicate_field("leftTable"));
6082 }
6083 left_table__ = map_.next_value()?;
6084 }
6085 GeneratedField::RightTable => {
6086 if right_table__.is_some() {
6087 return Err(serde::de::Error::duplicate_field("rightTable"));
6088 }
6089 right_table__ = map_.next_value()?;
6090 }
6091 GeneratedField::LeftDegreeTable => {
6092 if left_degree_table__.is_some() {
6093 return Err(serde::de::Error::duplicate_field("leftDegreeTable"));
6094 }
6095 left_degree_table__ = map_.next_value()?;
6096 }
6097 GeneratedField::RightDegreeTable => {
6098 if right_degree_table__.is_some() {
6099 return Err(serde::de::Error::duplicate_field("rightDegreeTable"));
6100 }
6101 right_degree_table__ = map_.next_value()?;
6102 }
6103 GeneratedField::OutputIndices => {
6104 if output_indices__.is_some() {
6105 return Err(serde::de::Error::duplicate_field("outputIndices"));
6106 }
6107 output_indices__ =
6108 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6109 .into_iter().map(|x| x.0).collect())
6110 ;
6111 }
6112 GeneratedField::LeftDedupedInputPkIndices => {
6113 if left_deduped_input_pk_indices__.is_some() {
6114 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
6115 }
6116 left_deduped_input_pk_indices__ =
6117 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6118 .into_iter().map(|x| x.0).collect())
6119 ;
6120 }
6121 GeneratedField::RightDedupedInputPkIndices => {
6122 if right_deduped_input_pk_indices__.is_some() {
6123 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
6124 }
6125 right_deduped_input_pk_indices__ =
6126 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6127 .into_iter().map(|x| x.0).collect())
6128 ;
6129 }
6130 GeneratedField::NullSafe => {
6131 if null_safe__.is_some() {
6132 return Err(serde::de::Error::duplicate_field("nullSafe"));
6133 }
6134 null_safe__ = Some(map_.next_value()?);
6135 }
6136 GeneratedField::IsAppendOnly => {
6137 if is_append_only__.is_some() {
6138 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
6139 }
6140 is_append_only__ = Some(map_.next_value()?);
6141 }
6142 GeneratedField::JoinEncodingType => {
6143 if join_encoding_type__.is_some() {
6144 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
6145 }
6146 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
6147 }
6148 GeneratedField::InequalityPairsV2 => {
6149 if inequality_pairs_v2__.is_some() {
6150 return Err(serde::de::Error::duplicate_field("inequalityPairsV2"));
6151 }
6152 inequality_pairs_v2__ = Some(map_.next_value()?);
6153 }
6154 }
6155 }
6156 Ok(HashJoinNode {
6157 join_type: join_type__.unwrap_or_default(),
6158 left_key: left_key__.unwrap_or_default(),
6159 right_key: right_key__.unwrap_or_default(),
6160 condition: condition__,
6161 inequality_pairs: inequality_pairs__.unwrap_or_default(),
6162 left_table: left_table__,
6163 right_table: right_table__,
6164 left_degree_table: left_degree_table__,
6165 right_degree_table: right_degree_table__,
6166 output_indices: output_indices__.unwrap_or_default(),
6167 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
6168 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
6169 null_safe: null_safe__.unwrap_or_default(),
6170 is_append_only: is_append_only__.unwrap_or_default(),
6171 join_encoding_type: join_encoding_type__.unwrap_or_default(),
6172 inequality_pairs_v2: inequality_pairs_v2__.unwrap_or_default(),
6173 })
6174 }
6175 }
6176 deserializer.deserialize_struct("stream_plan.HashJoinNode", FIELDS, GeneratedVisitor)
6177 }
6178}
6179impl serde::Serialize for HopWindowNode {
6180 #[allow(deprecated)]
6181 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6182 where
6183 S: serde::Serializer,
6184 {
6185 use serde::ser::SerializeStruct;
6186 let mut len = 0;
6187 if self.time_col != 0 {
6188 len += 1;
6189 }
6190 if self.window_slide.is_some() {
6191 len += 1;
6192 }
6193 if self.window_size.is_some() {
6194 len += 1;
6195 }
6196 if !self.output_indices.is_empty() {
6197 len += 1;
6198 }
6199 if !self.window_start_exprs.is_empty() {
6200 len += 1;
6201 }
6202 if !self.window_end_exprs.is_empty() {
6203 len += 1;
6204 }
6205 let mut struct_ser = serializer.serialize_struct("stream_plan.HopWindowNode", len)?;
6206 if self.time_col != 0 {
6207 struct_ser.serialize_field("timeCol", &self.time_col)?;
6208 }
6209 if let Some(v) = self.window_slide.as_ref() {
6210 struct_ser.serialize_field("windowSlide", v)?;
6211 }
6212 if let Some(v) = self.window_size.as_ref() {
6213 struct_ser.serialize_field("windowSize", v)?;
6214 }
6215 if !self.output_indices.is_empty() {
6216 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
6217 }
6218 if !self.window_start_exprs.is_empty() {
6219 struct_ser.serialize_field("windowStartExprs", &self.window_start_exprs)?;
6220 }
6221 if !self.window_end_exprs.is_empty() {
6222 struct_ser.serialize_field("windowEndExprs", &self.window_end_exprs)?;
6223 }
6224 struct_ser.end()
6225 }
6226}
6227impl<'de> serde::Deserialize<'de> for HopWindowNode {
6228 #[allow(deprecated)]
6229 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6230 where
6231 D: serde::Deserializer<'de>,
6232 {
6233 const FIELDS: &[&str] = &[
6234 "time_col",
6235 "timeCol",
6236 "window_slide",
6237 "windowSlide",
6238 "window_size",
6239 "windowSize",
6240 "output_indices",
6241 "outputIndices",
6242 "window_start_exprs",
6243 "windowStartExprs",
6244 "window_end_exprs",
6245 "windowEndExprs",
6246 ];
6247
6248 #[allow(clippy::enum_variant_names)]
6249 enum GeneratedField {
6250 TimeCol,
6251 WindowSlide,
6252 WindowSize,
6253 OutputIndices,
6254 WindowStartExprs,
6255 WindowEndExprs,
6256 }
6257 impl<'de> serde::Deserialize<'de> for GeneratedField {
6258 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6259 where
6260 D: serde::Deserializer<'de>,
6261 {
6262 struct GeneratedVisitor;
6263
6264 impl serde::de::Visitor<'_> for GeneratedVisitor {
6265 type Value = GeneratedField;
6266
6267 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6268 write!(formatter, "expected one of: {:?}", &FIELDS)
6269 }
6270
6271 #[allow(unused_variables)]
6272 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6273 where
6274 E: serde::de::Error,
6275 {
6276 match value {
6277 "timeCol" | "time_col" => Ok(GeneratedField::TimeCol),
6278 "windowSlide" | "window_slide" => Ok(GeneratedField::WindowSlide),
6279 "windowSize" | "window_size" => Ok(GeneratedField::WindowSize),
6280 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
6281 "windowStartExprs" | "window_start_exprs" => Ok(GeneratedField::WindowStartExprs),
6282 "windowEndExprs" | "window_end_exprs" => Ok(GeneratedField::WindowEndExprs),
6283 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6284 }
6285 }
6286 }
6287 deserializer.deserialize_identifier(GeneratedVisitor)
6288 }
6289 }
6290 struct GeneratedVisitor;
6291 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6292 type Value = HopWindowNode;
6293
6294 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6295 formatter.write_str("struct stream_plan.HopWindowNode")
6296 }
6297
6298 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HopWindowNode, V::Error>
6299 where
6300 V: serde::de::MapAccess<'de>,
6301 {
6302 let mut time_col__ = None;
6303 let mut window_slide__ = None;
6304 let mut window_size__ = None;
6305 let mut output_indices__ = None;
6306 let mut window_start_exprs__ = None;
6307 let mut window_end_exprs__ = None;
6308 while let Some(k) = map_.next_key()? {
6309 match k {
6310 GeneratedField::TimeCol => {
6311 if time_col__.is_some() {
6312 return Err(serde::de::Error::duplicate_field("timeCol"));
6313 }
6314 time_col__ =
6315 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6316 ;
6317 }
6318 GeneratedField::WindowSlide => {
6319 if window_slide__.is_some() {
6320 return Err(serde::de::Error::duplicate_field("windowSlide"));
6321 }
6322 window_slide__ = map_.next_value()?;
6323 }
6324 GeneratedField::WindowSize => {
6325 if window_size__.is_some() {
6326 return Err(serde::de::Error::duplicate_field("windowSize"));
6327 }
6328 window_size__ = map_.next_value()?;
6329 }
6330 GeneratedField::OutputIndices => {
6331 if output_indices__.is_some() {
6332 return Err(serde::de::Error::duplicate_field("outputIndices"));
6333 }
6334 output_indices__ =
6335 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6336 .into_iter().map(|x| x.0).collect())
6337 ;
6338 }
6339 GeneratedField::WindowStartExprs => {
6340 if window_start_exprs__.is_some() {
6341 return Err(serde::de::Error::duplicate_field("windowStartExprs"));
6342 }
6343 window_start_exprs__ = Some(map_.next_value()?);
6344 }
6345 GeneratedField::WindowEndExprs => {
6346 if window_end_exprs__.is_some() {
6347 return Err(serde::de::Error::duplicate_field("windowEndExprs"));
6348 }
6349 window_end_exprs__ = Some(map_.next_value()?);
6350 }
6351 }
6352 }
6353 Ok(HopWindowNode {
6354 time_col: time_col__.unwrap_or_default(),
6355 window_slide: window_slide__,
6356 window_size: window_size__,
6357 output_indices: output_indices__.unwrap_or_default(),
6358 window_start_exprs: window_start_exprs__.unwrap_or_default(),
6359 window_end_exprs: window_end_exprs__.unwrap_or_default(),
6360 })
6361 }
6362 }
6363 deserializer.deserialize_struct("stream_plan.HopWindowNode", FIELDS, GeneratedVisitor)
6364 }
6365}
6366impl serde::Serialize for InequalityPair {
6367 #[allow(deprecated)]
6368 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6369 where
6370 S: serde::Serializer,
6371 {
6372 use serde::ser::SerializeStruct;
6373 let mut len = 0;
6374 if self.key_required_larger != 0 {
6375 len += 1;
6376 }
6377 if self.key_required_smaller != 0 {
6378 len += 1;
6379 }
6380 if self.clean_state {
6381 len += 1;
6382 }
6383 if self.delta_expression.is_some() {
6384 len += 1;
6385 }
6386 let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPair", len)?;
6387 if self.key_required_larger != 0 {
6388 struct_ser.serialize_field("keyRequiredLarger", &self.key_required_larger)?;
6389 }
6390 if self.key_required_smaller != 0 {
6391 struct_ser.serialize_field("keyRequiredSmaller", &self.key_required_smaller)?;
6392 }
6393 if self.clean_state {
6394 struct_ser.serialize_field("cleanState", &self.clean_state)?;
6395 }
6396 if let Some(v) = self.delta_expression.as_ref() {
6397 struct_ser.serialize_field("deltaExpression", v)?;
6398 }
6399 struct_ser.end()
6400 }
6401}
6402impl<'de> serde::Deserialize<'de> for InequalityPair {
6403 #[allow(deprecated)]
6404 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6405 where
6406 D: serde::Deserializer<'de>,
6407 {
6408 const FIELDS: &[&str] = &[
6409 "key_required_larger",
6410 "keyRequiredLarger",
6411 "key_required_smaller",
6412 "keyRequiredSmaller",
6413 "clean_state",
6414 "cleanState",
6415 "delta_expression",
6416 "deltaExpression",
6417 ];
6418
6419 #[allow(clippy::enum_variant_names)]
6420 enum GeneratedField {
6421 KeyRequiredLarger,
6422 KeyRequiredSmaller,
6423 CleanState,
6424 DeltaExpression,
6425 }
6426 impl<'de> serde::Deserialize<'de> for GeneratedField {
6427 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6428 where
6429 D: serde::Deserializer<'de>,
6430 {
6431 struct GeneratedVisitor;
6432
6433 impl serde::de::Visitor<'_> for GeneratedVisitor {
6434 type Value = GeneratedField;
6435
6436 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6437 write!(formatter, "expected one of: {:?}", &FIELDS)
6438 }
6439
6440 #[allow(unused_variables)]
6441 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6442 where
6443 E: serde::de::Error,
6444 {
6445 match value {
6446 "keyRequiredLarger" | "key_required_larger" => Ok(GeneratedField::KeyRequiredLarger),
6447 "keyRequiredSmaller" | "key_required_smaller" => Ok(GeneratedField::KeyRequiredSmaller),
6448 "cleanState" | "clean_state" => Ok(GeneratedField::CleanState),
6449 "deltaExpression" | "delta_expression" => Ok(GeneratedField::DeltaExpression),
6450 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6451 }
6452 }
6453 }
6454 deserializer.deserialize_identifier(GeneratedVisitor)
6455 }
6456 }
6457 struct GeneratedVisitor;
6458 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6459 type Value = InequalityPair;
6460
6461 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6462 formatter.write_str("struct stream_plan.InequalityPair")
6463 }
6464
6465 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPair, V::Error>
6466 where
6467 V: serde::de::MapAccess<'de>,
6468 {
6469 let mut key_required_larger__ = None;
6470 let mut key_required_smaller__ = None;
6471 let mut clean_state__ = None;
6472 let mut delta_expression__ = None;
6473 while let Some(k) = map_.next_key()? {
6474 match k {
6475 GeneratedField::KeyRequiredLarger => {
6476 if key_required_larger__.is_some() {
6477 return Err(serde::de::Error::duplicate_field("keyRequiredLarger"));
6478 }
6479 key_required_larger__ =
6480 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6481 ;
6482 }
6483 GeneratedField::KeyRequiredSmaller => {
6484 if key_required_smaller__.is_some() {
6485 return Err(serde::de::Error::duplicate_field("keyRequiredSmaller"));
6486 }
6487 key_required_smaller__ =
6488 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6489 ;
6490 }
6491 GeneratedField::CleanState => {
6492 if clean_state__.is_some() {
6493 return Err(serde::de::Error::duplicate_field("cleanState"));
6494 }
6495 clean_state__ = Some(map_.next_value()?);
6496 }
6497 GeneratedField::DeltaExpression => {
6498 if delta_expression__.is_some() {
6499 return Err(serde::de::Error::duplicate_field("deltaExpression"));
6500 }
6501 delta_expression__ = map_.next_value()?;
6502 }
6503 }
6504 }
6505 Ok(InequalityPair {
6506 key_required_larger: key_required_larger__.unwrap_or_default(),
6507 key_required_smaller: key_required_smaller__.unwrap_or_default(),
6508 clean_state: clean_state__.unwrap_or_default(),
6509 delta_expression: delta_expression__,
6510 })
6511 }
6512 }
6513 deserializer.deserialize_struct("stream_plan.InequalityPair", FIELDS, GeneratedVisitor)
6514 }
6515}
6516impl serde::Serialize for InequalityPairV2 {
6517 #[allow(deprecated)]
6518 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6519 where
6520 S: serde::Serializer,
6521 {
6522 use serde::ser::SerializeStruct;
6523 let mut len = 0;
6524 if self.left_idx != 0 {
6525 len += 1;
6526 }
6527 if self.right_idx != 0 {
6528 len += 1;
6529 }
6530 if self.clean_left_state {
6531 len += 1;
6532 }
6533 if self.clean_right_state {
6534 len += 1;
6535 }
6536 if self.op != 0 {
6537 len += 1;
6538 }
6539 let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPairV2", len)?;
6540 if self.left_idx != 0 {
6541 struct_ser.serialize_field("leftIdx", &self.left_idx)?;
6542 }
6543 if self.right_idx != 0 {
6544 struct_ser.serialize_field("rightIdx", &self.right_idx)?;
6545 }
6546 if self.clean_left_state {
6547 struct_ser.serialize_field("cleanLeftState", &self.clean_left_state)?;
6548 }
6549 if self.clean_right_state {
6550 struct_ser.serialize_field("cleanRightState", &self.clean_right_state)?;
6551 }
6552 if self.op != 0 {
6553 let v = InequalityType::try_from(self.op)
6554 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.op)))?;
6555 struct_ser.serialize_field("op", &v)?;
6556 }
6557 struct_ser.end()
6558 }
6559}
6560impl<'de> serde::Deserialize<'de> for InequalityPairV2 {
6561 #[allow(deprecated)]
6562 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6563 where
6564 D: serde::Deserializer<'de>,
6565 {
6566 const FIELDS: &[&str] = &[
6567 "left_idx",
6568 "leftIdx",
6569 "right_idx",
6570 "rightIdx",
6571 "clean_left_state",
6572 "cleanLeftState",
6573 "clean_right_state",
6574 "cleanRightState",
6575 "op",
6576 ];
6577
6578 #[allow(clippy::enum_variant_names)]
6579 enum GeneratedField {
6580 LeftIdx,
6581 RightIdx,
6582 CleanLeftState,
6583 CleanRightState,
6584 Op,
6585 }
6586 impl<'de> serde::Deserialize<'de> for GeneratedField {
6587 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6588 where
6589 D: serde::Deserializer<'de>,
6590 {
6591 struct GeneratedVisitor;
6592
6593 impl serde::de::Visitor<'_> for GeneratedVisitor {
6594 type Value = GeneratedField;
6595
6596 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6597 write!(formatter, "expected one of: {:?}", &FIELDS)
6598 }
6599
6600 #[allow(unused_variables)]
6601 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6602 where
6603 E: serde::de::Error,
6604 {
6605 match value {
6606 "leftIdx" | "left_idx" => Ok(GeneratedField::LeftIdx),
6607 "rightIdx" | "right_idx" => Ok(GeneratedField::RightIdx),
6608 "cleanLeftState" | "clean_left_state" => Ok(GeneratedField::CleanLeftState),
6609 "cleanRightState" | "clean_right_state" => Ok(GeneratedField::CleanRightState),
6610 "op" => Ok(GeneratedField::Op),
6611 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6612 }
6613 }
6614 }
6615 deserializer.deserialize_identifier(GeneratedVisitor)
6616 }
6617 }
6618 struct GeneratedVisitor;
6619 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6620 type Value = InequalityPairV2;
6621
6622 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6623 formatter.write_str("struct stream_plan.InequalityPairV2")
6624 }
6625
6626 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPairV2, V::Error>
6627 where
6628 V: serde::de::MapAccess<'de>,
6629 {
6630 let mut left_idx__ = None;
6631 let mut right_idx__ = None;
6632 let mut clean_left_state__ = None;
6633 let mut clean_right_state__ = None;
6634 let mut op__ = None;
6635 while let Some(k) = map_.next_key()? {
6636 match k {
6637 GeneratedField::LeftIdx => {
6638 if left_idx__.is_some() {
6639 return Err(serde::de::Error::duplicate_field("leftIdx"));
6640 }
6641 left_idx__ =
6642 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6643 ;
6644 }
6645 GeneratedField::RightIdx => {
6646 if right_idx__.is_some() {
6647 return Err(serde::de::Error::duplicate_field("rightIdx"));
6648 }
6649 right_idx__ =
6650 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6651 ;
6652 }
6653 GeneratedField::CleanLeftState => {
6654 if clean_left_state__.is_some() {
6655 return Err(serde::de::Error::duplicate_field("cleanLeftState"));
6656 }
6657 clean_left_state__ = Some(map_.next_value()?);
6658 }
6659 GeneratedField::CleanRightState => {
6660 if clean_right_state__.is_some() {
6661 return Err(serde::de::Error::duplicate_field("cleanRightState"));
6662 }
6663 clean_right_state__ = Some(map_.next_value()?);
6664 }
6665 GeneratedField::Op => {
6666 if op__.is_some() {
6667 return Err(serde::de::Error::duplicate_field("op"));
6668 }
6669 op__ = Some(map_.next_value::<InequalityType>()? as i32);
6670 }
6671 }
6672 }
6673 Ok(InequalityPairV2 {
6674 left_idx: left_idx__.unwrap_or_default(),
6675 right_idx: right_idx__.unwrap_or_default(),
6676 clean_left_state: clean_left_state__.unwrap_or_default(),
6677 clean_right_state: clean_right_state__.unwrap_or_default(),
6678 op: op__.unwrap_or_default(),
6679 })
6680 }
6681 }
6682 deserializer.deserialize_struct("stream_plan.InequalityPairV2", FIELDS, GeneratedVisitor)
6683 }
6684}
6685impl serde::Serialize for InequalityType {
6686 #[allow(deprecated)]
6687 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6688 where
6689 S: serde::Serializer,
6690 {
6691 let variant = match self {
6692 Self::Unspecified => "INEQUALITY_TYPE_UNSPECIFIED",
6693 Self::LessThan => "INEQUALITY_TYPE_LESS_THAN",
6694 Self::LessThanOrEqual => "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL",
6695 Self::GreaterThan => "INEQUALITY_TYPE_GREATER_THAN",
6696 Self::GreaterThanOrEqual => "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL",
6697 };
6698 serializer.serialize_str(variant)
6699 }
6700}
6701impl<'de> serde::Deserialize<'de> for InequalityType {
6702 #[allow(deprecated)]
6703 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6704 where
6705 D: serde::Deserializer<'de>,
6706 {
6707 const FIELDS: &[&str] = &[
6708 "INEQUALITY_TYPE_UNSPECIFIED",
6709 "INEQUALITY_TYPE_LESS_THAN",
6710 "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL",
6711 "INEQUALITY_TYPE_GREATER_THAN",
6712 "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL",
6713 ];
6714
6715 struct GeneratedVisitor;
6716
6717 impl serde::de::Visitor<'_> for GeneratedVisitor {
6718 type Value = InequalityType;
6719
6720 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6721 write!(formatter, "expected one of: {:?}", &FIELDS)
6722 }
6723
6724 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6725 where
6726 E: serde::de::Error,
6727 {
6728 i32::try_from(v)
6729 .ok()
6730 .and_then(|x| x.try_into().ok())
6731 .ok_or_else(|| {
6732 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6733 })
6734 }
6735
6736 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6737 where
6738 E: serde::de::Error,
6739 {
6740 i32::try_from(v)
6741 .ok()
6742 .and_then(|x| x.try_into().ok())
6743 .ok_or_else(|| {
6744 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6745 })
6746 }
6747
6748 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6749 where
6750 E: serde::de::Error,
6751 {
6752 match value {
6753 "INEQUALITY_TYPE_UNSPECIFIED" => Ok(InequalityType::Unspecified),
6754 "INEQUALITY_TYPE_LESS_THAN" => Ok(InequalityType::LessThan),
6755 "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL" => Ok(InequalityType::LessThanOrEqual),
6756 "INEQUALITY_TYPE_GREATER_THAN" => Ok(InequalityType::GreaterThan),
6757 "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL" => Ok(InequalityType::GreaterThanOrEqual),
6758 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6759 }
6760 }
6761 }
6762 deserializer.deserialize_any(GeneratedVisitor)
6763 }
6764}
6765impl serde::Serialize for InjectSourceOffsetsMutation {
6766 #[allow(deprecated)]
6767 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6768 where
6769 S: serde::Serializer,
6770 {
6771 use serde::ser::SerializeStruct;
6772 let mut len = 0;
6773 if self.source_id != 0 {
6774 len += 1;
6775 }
6776 if !self.split_offsets.is_empty() {
6777 len += 1;
6778 }
6779 let mut struct_ser = serializer.serialize_struct("stream_plan.InjectSourceOffsetsMutation", len)?;
6780 if self.source_id != 0 {
6781 struct_ser.serialize_field("sourceId", &self.source_id)?;
6782 }
6783 if !self.split_offsets.is_empty() {
6784 struct_ser.serialize_field("splitOffsets", &self.split_offsets)?;
6785 }
6786 struct_ser.end()
6787 }
6788}
6789impl<'de> serde::Deserialize<'de> for InjectSourceOffsetsMutation {
6790 #[allow(deprecated)]
6791 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6792 where
6793 D: serde::Deserializer<'de>,
6794 {
6795 const FIELDS: &[&str] = &[
6796 "source_id",
6797 "sourceId",
6798 "split_offsets",
6799 "splitOffsets",
6800 ];
6801
6802 #[allow(clippy::enum_variant_names)]
6803 enum GeneratedField {
6804 SourceId,
6805 SplitOffsets,
6806 }
6807 impl<'de> serde::Deserialize<'de> for GeneratedField {
6808 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6809 where
6810 D: serde::Deserializer<'de>,
6811 {
6812 struct GeneratedVisitor;
6813
6814 impl serde::de::Visitor<'_> for GeneratedVisitor {
6815 type Value = GeneratedField;
6816
6817 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6818 write!(formatter, "expected one of: {:?}", &FIELDS)
6819 }
6820
6821 #[allow(unused_variables)]
6822 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6823 where
6824 E: serde::de::Error,
6825 {
6826 match value {
6827 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
6828 "splitOffsets" | "split_offsets" => Ok(GeneratedField::SplitOffsets),
6829 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6830 }
6831 }
6832 }
6833 deserializer.deserialize_identifier(GeneratedVisitor)
6834 }
6835 }
6836 struct GeneratedVisitor;
6837 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6838 type Value = InjectSourceOffsetsMutation;
6839
6840 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6841 formatter.write_str("struct stream_plan.InjectSourceOffsetsMutation")
6842 }
6843
6844 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InjectSourceOffsetsMutation, V::Error>
6845 where
6846 V: serde::de::MapAccess<'de>,
6847 {
6848 let mut source_id__ = None;
6849 let mut split_offsets__ = None;
6850 while let Some(k) = map_.next_key()? {
6851 match k {
6852 GeneratedField::SourceId => {
6853 if source_id__.is_some() {
6854 return Err(serde::de::Error::duplicate_field("sourceId"));
6855 }
6856 source_id__ =
6857 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6858 ;
6859 }
6860 GeneratedField::SplitOffsets => {
6861 if split_offsets__.is_some() {
6862 return Err(serde::de::Error::duplicate_field("splitOffsets"));
6863 }
6864 split_offsets__ = Some(
6865 map_.next_value::<std::collections::HashMap<_, _>>()?
6866 );
6867 }
6868 }
6869 }
6870 Ok(InjectSourceOffsetsMutation {
6871 source_id: source_id__.unwrap_or_default(),
6872 split_offsets: split_offsets__.unwrap_or_default(),
6873 })
6874 }
6875 }
6876 deserializer.deserialize_struct("stream_plan.InjectSourceOffsetsMutation", FIELDS, GeneratedVisitor)
6877 }
6878}
6879impl serde::Serialize for JoinEncodingType {
6880 #[allow(deprecated)]
6881 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6882 where
6883 S: serde::Serializer,
6884 {
6885 let variant = match self {
6886 Self::Unspecified => "UNSPECIFIED",
6887 Self::MemoryOptimized => "MEMORY_OPTIMIZED",
6888 Self::CpuOptimized => "CPU_OPTIMIZED",
6889 };
6890 serializer.serialize_str(variant)
6891 }
6892}
6893impl<'de> serde::Deserialize<'de> for JoinEncodingType {
6894 #[allow(deprecated)]
6895 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6896 where
6897 D: serde::Deserializer<'de>,
6898 {
6899 const FIELDS: &[&str] = &[
6900 "UNSPECIFIED",
6901 "MEMORY_OPTIMIZED",
6902 "CPU_OPTIMIZED",
6903 ];
6904
6905 struct GeneratedVisitor;
6906
6907 impl serde::de::Visitor<'_> for GeneratedVisitor {
6908 type Value = JoinEncodingType;
6909
6910 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6911 write!(formatter, "expected one of: {:?}", &FIELDS)
6912 }
6913
6914 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6915 where
6916 E: serde::de::Error,
6917 {
6918 i32::try_from(v)
6919 .ok()
6920 .and_then(|x| x.try_into().ok())
6921 .ok_or_else(|| {
6922 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6923 })
6924 }
6925
6926 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6927 where
6928 E: serde::de::Error,
6929 {
6930 i32::try_from(v)
6931 .ok()
6932 .and_then(|x| x.try_into().ok())
6933 .ok_or_else(|| {
6934 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6935 })
6936 }
6937
6938 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6939 where
6940 E: serde::de::Error,
6941 {
6942 match value {
6943 "UNSPECIFIED" => Ok(JoinEncodingType::Unspecified),
6944 "MEMORY_OPTIMIZED" => Ok(JoinEncodingType::MemoryOptimized),
6945 "CPU_OPTIMIZED" => Ok(JoinEncodingType::CpuOptimized),
6946 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6947 }
6948 }
6949 }
6950 deserializer.deserialize_any(GeneratedVisitor)
6951 }
6952}
6953impl serde::Serialize for ListFinishMutation {
6954 #[allow(deprecated)]
6955 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6956 where
6957 S: serde::Serializer,
6958 {
6959 use serde::ser::SerializeStruct;
6960 let mut len = 0;
6961 if self.associated_source_id != 0 {
6962 len += 1;
6963 }
6964 let mut struct_ser = serializer.serialize_struct("stream_plan.ListFinishMutation", len)?;
6965 if self.associated_source_id != 0 {
6966 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
6967 }
6968 struct_ser.end()
6969 }
6970}
6971impl<'de> serde::Deserialize<'de> for ListFinishMutation {
6972 #[allow(deprecated)]
6973 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6974 where
6975 D: serde::Deserializer<'de>,
6976 {
6977 const FIELDS: &[&str] = &[
6978 "associated_source_id",
6979 "associatedSourceId",
6980 ];
6981
6982 #[allow(clippy::enum_variant_names)]
6983 enum GeneratedField {
6984 AssociatedSourceId,
6985 }
6986 impl<'de> serde::Deserialize<'de> for GeneratedField {
6987 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6988 where
6989 D: serde::Deserializer<'de>,
6990 {
6991 struct GeneratedVisitor;
6992
6993 impl serde::de::Visitor<'_> for GeneratedVisitor {
6994 type Value = GeneratedField;
6995
6996 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6997 write!(formatter, "expected one of: {:?}", &FIELDS)
6998 }
6999
7000 #[allow(unused_variables)]
7001 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7002 where
7003 E: serde::de::Error,
7004 {
7005 match value {
7006 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
7007 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7008 }
7009 }
7010 }
7011 deserializer.deserialize_identifier(GeneratedVisitor)
7012 }
7013 }
7014 struct GeneratedVisitor;
7015 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7016 type Value = ListFinishMutation;
7017
7018 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7019 formatter.write_str("struct stream_plan.ListFinishMutation")
7020 }
7021
7022 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFinishMutation, V::Error>
7023 where
7024 V: serde::de::MapAccess<'de>,
7025 {
7026 let mut associated_source_id__ = None;
7027 while let Some(k) = map_.next_key()? {
7028 match k {
7029 GeneratedField::AssociatedSourceId => {
7030 if associated_source_id__.is_some() {
7031 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
7032 }
7033 associated_source_id__ =
7034 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7035 ;
7036 }
7037 }
7038 }
7039 Ok(ListFinishMutation {
7040 associated_source_id: associated_source_id__.unwrap_or_default(),
7041 })
7042 }
7043 }
7044 deserializer.deserialize_struct("stream_plan.ListFinishMutation", FIELDS, GeneratedVisitor)
7045 }
7046}
7047impl serde::Serialize for LoadFinishMutation {
7048 #[allow(deprecated)]
7049 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7050 where
7051 S: serde::Serializer,
7052 {
7053 use serde::ser::SerializeStruct;
7054 let mut len = 0;
7055 if self.associated_source_id != 0 {
7056 len += 1;
7057 }
7058 let mut struct_ser = serializer.serialize_struct("stream_plan.LoadFinishMutation", len)?;
7059 if self.associated_source_id != 0 {
7060 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
7061 }
7062 struct_ser.end()
7063 }
7064}
7065impl<'de> serde::Deserialize<'de> for LoadFinishMutation {
7066 #[allow(deprecated)]
7067 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7068 where
7069 D: serde::Deserializer<'de>,
7070 {
7071 const FIELDS: &[&str] = &[
7072 "associated_source_id",
7073 "associatedSourceId",
7074 ];
7075
7076 #[allow(clippy::enum_variant_names)]
7077 enum GeneratedField {
7078 AssociatedSourceId,
7079 }
7080 impl<'de> serde::Deserialize<'de> for GeneratedField {
7081 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7082 where
7083 D: serde::Deserializer<'de>,
7084 {
7085 struct GeneratedVisitor;
7086
7087 impl serde::de::Visitor<'_> for GeneratedVisitor {
7088 type Value = GeneratedField;
7089
7090 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7091 write!(formatter, "expected one of: {:?}", &FIELDS)
7092 }
7093
7094 #[allow(unused_variables)]
7095 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7096 where
7097 E: serde::de::Error,
7098 {
7099 match value {
7100 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
7101 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7102 }
7103 }
7104 }
7105 deserializer.deserialize_identifier(GeneratedVisitor)
7106 }
7107 }
7108 struct GeneratedVisitor;
7109 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7110 type Value = LoadFinishMutation;
7111
7112 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7113 formatter.write_str("struct stream_plan.LoadFinishMutation")
7114 }
7115
7116 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LoadFinishMutation, V::Error>
7117 where
7118 V: serde::de::MapAccess<'de>,
7119 {
7120 let mut associated_source_id__ = None;
7121 while let Some(k) = map_.next_key()? {
7122 match k {
7123 GeneratedField::AssociatedSourceId => {
7124 if associated_source_id__.is_some() {
7125 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
7126 }
7127 associated_source_id__ =
7128 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7129 ;
7130 }
7131 }
7132 }
7133 Ok(LoadFinishMutation {
7134 associated_source_id: associated_source_id__.unwrap_or_default(),
7135 })
7136 }
7137 }
7138 deserializer.deserialize_struct("stream_plan.LoadFinishMutation", FIELDS, GeneratedVisitor)
7139 }
7140}
7141impl serde::Serialize for LocalApproxPercentileNode {
7142 #[allow(deprecated)]
7143 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7144 where
7145 S: serde::Serializer,
7146 {
7147 use serde::ser::SerializeStruct;
7148 let mut len = 0;
7149 if self.base != 0. {
7150 len += 1;
7151 }
7152 if self.percentile_index != 0 {
7153 len += 1;
7154 }
7155 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalApproxPercentileNode", len)?;
7156 if self.base != 0. {
7157 struct_ser.serialize_field("base", &self.base)?;
7158 }
7159 if self.percentile_index != 0 {
7160 struct_ser.serialize_field("percentileIndex", &self.percentile_index)?;
7161 }
7162 struct_ser.end()
7163 }
7164}
7165impl<'de> serde::Deserialize<'de> for LocalApproxPercentileNode {
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 "base",
7173 "percentile_index",
7174 "percentileIndex",
7175 ];
7176
7177 #[allow(clippy::enum_variant_names)]
7178 enum GeneratedField {
7179 Base,
7180 PercentileIndex,
7181 }
7182 impl<'de> serde::Deserialize<'de> for GeneratedField {
7183 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7184 where
7185 D: serde::Deserializer<'de>,
7186 {
7187 struct GeneratedVisitor;
7188
7189 impl serde::de::Visitor<'_> for GeneratedVisitor {
7190 type Value = GeneratedField;
7191
7192 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7193 write!(formatter, "expected one of: {:?}", &FIELDS)
7194 }
7195
7196 #[allow(unused_variables)]
7197 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7198 where
7199 E: serde::de::Error,
7200 {
7201 match value {
7202 "base" => Ok(GeneratedField::Base),
7203 "percentileIndex" | "percentile_index" => Ok(GeneratedField::PercentileIndex),
7204 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7205 }
7206 }
7207 }
7208 deserializer.deserialize_identifier(GeneratedVisitor)
7209 }
7210 }
7211 struct GeneratedVisitor;
7212 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7213 type Value = LocalApproxPercentileNode;
7214
7215 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7216 formatter.write_str("struct stream_plan.LocalApproxPercentileNode")
7217 }
7218
7219 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalApproxPercentileNode, V::Error>
7220 where
7221 V: serde::de::MapAccess<'de>,
7222 {
7223 let mut base__ = None;
7224 let mut percentile_index__ = None;
7225 while let Some(k) = map_.next_key()? {
7226 match k {
7227 GeneratedField::Base => {
7228 if base__.is_some() {
7229 return Err(serde::de::Error::duplicate_field("base"));
7230 }
7231 base__ =
7232 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7233 ;
7234 }
7235 GeneratedField::PercentileIndex => {
7236 if percentile_index__.is_some() {
7237 return Err(serde::de::Error::duplicate_field("percentileIndex"));
7238 }
7239 percentile_index__ =
7240 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7241 ;
7242 }
7243 }
7244 }
7245 Ok(LocalApproxPercentileNode {
7246 base: base__.unwrap_or_default(),
7247 percentile_index: percentile_index__.unwrap_or_default(),
7248 })
7249 }
7250 }
7251 deserializer.deserialize_struct("stream_plan.LocalApproxPercentileNode", FIELDS, GeneratedVisitor)
7252 }
7253}
7254impl serde::Serialize for LocalityProviderNode {
7255 #[allow(deprecated)]
7256 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7257 where
7258 S: serde::Serializer,
7259 {
7260 use serde::ser::SerializeStruct;
7261 let mut len = 0;
7262 if !self.locality_columns.is_empty() {
7263 len += 1;
7264 }
7265 if self.state_table.is_some() {
7266 len += 1;
7267 }
7268 if self.progress_table.is_some() {
7269 len += 1;
7270 }
7271 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalityProviderNode", len)?;
7272 if !self.locality_columns.is_empty() {
7273 struct_ser.serialize_field("localityColumns", &self.locality_columns)?;
7274 }
7275 if let Some(v) = self.state_table.as_ref() {
7276 struct_ser.serialize_field("stateTable", v)?;
7277 }
7278 if let Some(v) = self.progress_table.as_ref() {
7279 struct_ser.serialize_field("progressTable", v)?;
7280 }
7281 struct_ser.end()
7282 }
7283}
7284impl<'de> serde::Deserialize<'de> for LocalityProviderNode {
7285 #[allow(deprecated)]
7286 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7287 where
7288 D: serde::Deserializer<'de>,
7289 {
7290 const FIELDS: &[&str] = &[
7291 "locality_columns",
7292 "localityColumns",
7293 "state_table",
7294 "stateTable",
7295 "progress_table",
7296 "progressTable",
7297 ];
7298
7299 #[allow(clippy::enum_variant_names)]
7300 enum GeneratedField {
7301 LocalityColumns,
7302 StateTable,
7303 ProgressTable,
7304 }
7305 impl<'de> serde::Deserialize<'de> for GeneratedField {
7306 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7307 where
7308 D: serde::Deserializer<'de>,
7309 {
7310 struct GeneratedVisitor;
7311
7312 impl serde::de::Visitor<'_> for GeneratedVisitor {
7313 type Value = GeneratedField;
7314
7315 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7316 write!(formatter, "expected one of: {:?}", &FIELDS)
7317 }
7318
7319 #[allow(unused_variables)]
7320 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7321 where
7322 E: serde::de::Error,
7323 {
7324 match value {
7325 "localityColumns" | "locality_columns" => Ok(GeneratedField::LocalityColumns),
7326 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7327 "progressTable" | "progress_table" => Ok(GeneratedField::ProgressTable),
7328 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7329 }
7330 }
7331 }
7332 deserializer.deserialize_identifier(GeneratedVisitor)
7333 }
7334 }
7335 struct GeneratedVisitor;
7336 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7337 type Value = LocalityProviderNode;
7338
7339 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7340 formatter.write_str("struct stream_plan.LocalityProviderNode")
7341 }
7342
7343 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalityProviderNode, V::Error>
7344 where
7345 V: serde::de::MapAccess<'de>,
7346 {
7347 let mut locality_columns__ = None;
7348 let mut state_table__ = None;
7349 let mut progress_table__ = None;
7350 while let Some(k) = map_.next_key()? {
7351 match k {
7352 GeneratedField::LocalityColumns => {
7353 if locality_columns__.is_some() {
7354 return Err(serde::de::Error::duplicate_field("localityColumns"));
7355 }
7356 locality_columns__ =
7357 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7358 .into_iter().map(|x| x.0).collect())
7359 ;
7360 }
7361 GeneratedField::StateTable => {
7362 if state_table__.is_some() {
7363 return Err(serde::de::Error::duplicate_field("stateTable"));
7364 }
7365 state_table__ = map_.next_value()?;
7366 }
7367 GeneratedField::ProgressTable => {
7368 if progress_table__.is_some() {
7369 return Err(serde::de::Error::duplicate_field("progressTable"));
7370 }
7371 progress_table__ = map_.next_value()?;
7372 }
7373 }
7374 }
7375 Ok(LocalityProviderNode {
7376 locality_columns: locality_columns__.unwrap_or_default(),
7377 state_table: state_table__,
7378 progress_table: progress_table__,
7379 })
7380 }
7381 }
7382 deserializer.deserialize_struct("stream_plan.LocalityProviderNode", FIELDS, GeneratedVisitor)
7383 }
7384}
7385impl serde::Serialize for LookupNode {
7386 #[allow(deprecated)]
7387 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7388 where
7389 S: serde::Serializer,
7390 {
7391 use serde::ser::SerializeStruct;
7392 let mut len = 0;
7393 if !self.arrange_key.is_empty() {
7394 len += 1;
7395 }
7396 if !self.stream_key.is_empty() {
7397 len += 1;
7398 }
7399 if self.use_current_epoch {
7400 len += 1;
7401 }
7402 if !self.column_mapping.is_empty() {
7403 len += 1;
7404 }
7405 if self.arrangement_table_info.is_some() {
7406 len += 1;
7407 }
7408 if self.arrangement_table_id.is_some() {
7409 len += 1;
7410 }
7411 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupNode", len)?;
7412 if !self.arrange_key.is_empty() {
7413 struct_ser.serialize_field("arrangeKey", &self.arrange_key)?;
7414 }
7415 if !self.stream_key.is_empty() {
7416 struct_ser.serialize_field("streamKey", &self.stream_key)?;
7417 }
7418 if self.use_current_epoch {
7419 struct_ser.serialize_field("useCurrentEpoch", &self.use_current_epoch)?;
7420 }
7421 if !self.column_mapping.is_empty() {
7422 struct_ser.serialize_field("columnMapping", &self.column_mapping)?;
7423 }
7424 if let Some(v) = self.arrangement_table_info.as_ref() {
7425 struct_ser.serialize_field("arrangementTableInfo", v)?;
7426 }
7427 if let Some(v) = self.arrangement_table_id.as_ref() {
7428 match v {
7429 lookup_node::ArrangementTableId::TableId(v) => {
7430 struct_ser.serialize_field("tableId", v)?;
7431 }
7432 lookup_node::ArrangementTableId::IndexId(v) => {
7433 struct_ser.serialize_field("indexId", v)?;
7434 }
7435 }
7436 }
7437 struct_ser.end()
7438 }
7439}
7440impl<'de> serde::Deserialize<'de> for LookupNode {
7441 #[allow(deprecated)]
7442 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7443 where
7444 D: serde::Deserializer<'de>,
7445 {
7446 const FIELDS: &[&str] = &[
7447 "arrange_key",
7448 "arrangeKey",
7449 "stream_key",
7450 "streamKey",
7451 "use_current_epoch",
7452 "useCurrentEpoch",
7453 "column_mapping",
7454 "columnMapping",
7455 "arrangement_table_info",
7456 "arrangementTableInfo",
7457 "table_id",
7458 "tableId",
7459 "index_id",
7460 "indexId",
7461 ];
7462
7463 #[allow(clippy::enum_variant_names)]
7464 enum GeneratedField {
7465 ArrangeKey,
7466 StreamKey,
7467 UseCurrentEpoch,
7468 ColumnMapping,
7469 ArrangementTableInfo,
7470 TableId,
7471 IndexId,
7472 }
7473 impl<'de> serde::Deserialize<'de> for GeneratedField {
7474 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7475 where
7476 D: serde::Deserializer<'de>,
7477 {
7478 struct GeneratedVisitor;
7479
7480 impl serde::de::Visitor<'_> for GeneratedVisitor {
7481 type Value = GeneratedField;
7482
7483 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7484 write!(formatter, "expected one of: {:?}", &FIELDS)
7485 }
7486
7487 #[allow(unused_variables)]
7488 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7489 where
7490 E: serde::de::Error,
7491 {
7492 match value {
7493 "arrangeKey" | "arrange_key" => Ok(GeneratedField::ArrangeKey),
7494 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
7495 "useCurrentEpoch" | "use_current_epoch" => Ok(GeneratedField::UseCurrentEpoch),
7496 "columnMapping" | "column_mapping" => Ok(GeneratedField::ColumnMapping),
7497 "arrangementTableInfo" | "arrangement_table_info" => Ok(GeneratedField::ArrangementTableInfo),
7498 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7499 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
7500 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7501 }
7502 }
7503 }
7504 deserializer.deserialize_identifier(GeneratedVisitor)
7505 }
7506 }
7507 struct GeneratedVisitor;
7508 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7509 type Value = LookupNode;
7510
7511 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7512 formatter.write_str("struct stream_plan.LookupNode")
7513 }
7514
7515 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupNode, V::Error>
7516 where
7517 V: serde::de::MapAccess<'de>,
7518 {
7519 let mut arrange_key__ = None;
7520 let mut stream_key__ = None;
7521 let mut use_current_epoch__ = None;
7522 let mut column_mapping__ = None;
7523 let mut arrangement_table_info__ = None;
7524 let mut arrangement_table_id__ = None;
7525 while let Some(k) = map_.next_key()? {
7526 match k {
7527 GeneratedField::ArrangeKey => {
7528 if arrange_key__.is_some() {
7529 return Err(serde::de::Error::duplicate_field("arrangeKey"));
7530 }
7531 arrange_key__ =
7532 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7533 .into_iter().map(|x| x.0).collect())
7534 ;
7535 }
7536 GeneratedField::StreamKey => {
7537 if stream_key__.is_some() {
7538 return Err(serde::de::Error::duplicate_field("streamKey"));
7539 }
7540 stream_key__ =
7541 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7542 .into_iter().map(|x| x.0).collect())
7543 ;
7544 }
7545 GeneratedField::UseCurrentEpoch => {
7546 if use_current_epoch__.is_some() {
7547 return Err(serde::de::Error::duplicate_field("useCurrentEpoch"));
7548 }
7549 use_current_epoch__ = Some(map_.next_value()?);
7550 }
7551 GeneratedField::ColumnMapping => {
7552 if column_mapping__.is_some() {
7553 return Err(serde::de::Error::duplicate_field("columnMapping"));
7554 }
7555 column_mapping__ =
7556 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7557 .into_iter().map(|x| x.0).collect())
7558 ;
7559 }
7560 GeneratedField::ArrangementTableInfo => {
7561 if arrangement_table_info__.is_some() {
7562 return Err(serde::de::Error::duplicate_field("arrangementTableInfo"));
7563 }
7564 arrangement_table_info__ = map_.next_value()?;
7565 }
7566 GeneratedField::TableId => {
7567 if arrangement_table_id__.is_some() {
7568 return Err(serde::de::Error::duplicate_field("tableId"));
7569 }
7570 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::TableId(x.0));
7571 }
7572 GeneratedField::IndexId => {
7573 if arrangement_table_id__.is_some() {
7574 return Err(serde::de::Error::duplicate_field("indexId"));
7575 }
7576 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::IndexId(x.0));
7577 }
7578 }
7579 }
7580 Ok(LookupNode {
7581 arrange_key: arrange_key__.unwrap_or_default(),
7582 stream_key: stream_key__.unwrap_or_default(),
7583 use_current_epoch: use_current_epoch__.unwrap_or_default(),
7584 column_mapping: column_mapping__.unwrap_or_default(),
7585 arrangement_table_info: arrangement_table_info__,
7586 arrangement_table_id: arrangement_table_id__,
7587 })
7588 }
7589 }
7590 deserializer.deserialize_struct("stream_plan.LookupNode", FIELDS, GeneratedVisitor)
7591 }
7592}
7593impl serde::Serialize for LookupUnionNode {
7594 #[allow(deprecated)]
7595 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7596 where
7597 S: serde::Serializer,
7598 {
7599 use serde::ser::SerializeStruct;
7600 let mut len = 0;
7601 if !self.order.is_empty() {
7602 len += 1;
7603 }
7604 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupUnionNode", len)?;
7605 if !self.order.is_empty() {
7606 struct_ser.serialize_field("order", &self.order)?;
7607 }
7608 struct_ser.end()
7609 }
7610}
7611impl<'de> serde::Deserialize<'de> for LookupUnionNode {
7612 #[allow(deprecated)]
7613 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7614 where
7615 D: serde::Deserializer<'de>,
7616 {
7617 const FIELDS: &[&str] = &[
7618 "order",
7619 ];
7620
7621 #[allow(clippy::enum_variant_names)]
7622 enum GeneratedField {
7623 Order,
7624 }
7625 impl<'de> serde::Deserialize<'de> for GeneratedField {
7626 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7627 where
7628 D: serde::Deserializer<'de>,
7629 {
7630 struct GeneratedVisitor;
7631
7632 impl serde::de::Visitor<'_> for GeneratedVisitor {
7633 type Value = GeneratedField;
7634
7635 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7636 write!(formatter, "expected one of: {:?}", &FIELDS)
7637 }
7638
7639 #[allow(unused_variables)]
7640 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7641 where
7642 E: serde::de::Error,
7643 {
7644 match value {
7645 "order" => Ok(GeneratedField::Order),
7646 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7647 }
7648 }
7649 }
7650 deserializer.deserialize_identifier(GeneratedVisitor)
7651 }
7652 }
7653 struct GeneratedVisitor;
7654 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7655 type Value = LookupUnionNode;
7656
7657 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7658 formatter.write_str("struct stream_plan.LookupUnionNode")
7659 }
7660
7661 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupUnionNode, V::Error>
7662 where
7663 V: serde::de::MapAccess<'de>,
7664 {
7665 let mut order__ = None;
7666 while let Some(k) = map_.next_key()? {
7667 match k {
7668 GeneratedField::Order => {
7669 if order__.is_some() {
7670 return Err(serde::de::Error::duplicate_field("order"));
7671 }
7672 order__ =
7673 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7674 .into_iter().map(|x| x.0).collect())
7675 ;
7676 }
7677 }
7678 }
7679 Ok(LookupUnionNode {
7680 order: order__.unwrap_or_default(),
7681 })
7682 }
7683 }
7684 deserializer.deserialize_struct("stream_plan.LookupUnionNode", FIELDS, GeneratedVisitor)
7685 }
7686}
7687impl serde::Serialize for MaterializeNode {
7688 #[allow(deprecated)]
7689 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7690 where
7691 S: serde::Serializer,
7692 {
7693 use serde::ser::SerializeStruct;
7694 let mut len = 0;
7695 if self.table_id != 0 {
7696 len += 1;
7697 }
7698 if !self.column_orders.is_empty() {
7699 len += 1;
7700 }
7701 if self.table.is_some() {
7702 len += 1;
7703 }
7704 if self.staging_table.is_some() {
7705 len += 1;
7706 }
7707 if self.refresh_progress_table.is_some() {
7708 len += 1;
7709 }
7710 if self.cleaned_by_ttl_watermark {
7711 len += 1;
7712 }
7713 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializeNode", len)?;
7714 if self.table_id != 0 {
7715 struct_ser.serialize_field("tableId", &self.table_id)?;
7716 }
7717 if !self.column_orders.is_empty() {
7718 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
7719 }
7720 if let Some(v) = self.table.as_ref() {
7721 struct_ser.serialize_field("table", v)?;
7722 }
7723 if let Some(v) = self.staging_table.as_ref() {
7724 struct_ser.serialize_field("stagingTable", v)?;
7725 }
7726 if let Some(v) = self.refresh_progress_table.as_ref() {
7727 struct_ser.serialize_field("refreshProgressTable", v)?;
7728 }
7729 if self.cleaned_by_ttl_watermark {
7730 struct_ser.serialize_field("cleanedByTtlWatermark", &self.cleaned_by_ttl_watermark)?;
7731 }
7732 struct_ser.end()
7733 }
7734}
7735impl<'de> serde::Deserialize<'de> for MaterializeNode {
7736 #[allow(deprecated)]
7737 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7738 where
7739 D: serde::Deserializer<'de>,
7740 {
7741 const FIELDS: &[&str] = &[
7742 "table_id",
7743 "tableId",
7744 "column_orders",
7745 "columnOrders",
7746 "table",
7747 "staging_table",
7748 "stagingTable",
7749 "refresh_progress_table",
7750 "refreshProgressTable",
7751 "cleaned_by_ttl_watermark",
7752 "cleanedByTtlWatermark",
7753 ];
7754
7755 #[allow(clippy::enum_variant_names)]
7756 enum GeneratedField {
7757 TableId,
7758 ColumnOrders,
7759 Table,
7760 StagingTable,
7761 RefreshProgressTable,
7762 CleanedByTtlWatermark,
7763 }
7764 impl<'de> serde::Deserialize<'de> for GeneratedField {
7765 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7766 where
7767 D: serde::Deserializer<'de>,
7768 {
7769 struct GeneratedVisitor;
7770
7771 impl serde::de::Visitor<'_> for GeneratedVisitor {
7772 type Value = GeneratedField;
7773
7774 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7775 write!(formatter, "expected one of: {:?}", &FIELDS)
7776 }
7777
7778 #[allow(unused_variables)]
7779 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7780 where
7781 E: serde::de::Error,
7782 {
7783 match value {
7784 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7785 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
7786 "table" => Ok(GeneratedField::Table),
7787 "stagingTable" | "staging_table" => Ok(GeneratedField::StagingTable),
7788 "refreshProgressTable" | "refresh_progress_table" => Ok(GeneratedField::RefreshProgressTable),
7789 "cleanedByTtlWatermark" | "cleaned_by_ttl_watermark" => Ok(GeneratedField::CleanedByTtlWatermark),
7790 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7791 }
7792 }
7793 }
7794 deserializer.deserialize_identifier(GeneratedVisitor)
7795 }
7796 }
7797 struct GeneratedVisitor;
7798 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7799 type Value = MaterializeNode;
7800
7801 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7802 formatter.write_str("struct stream_plan.MaterializeNode")
7803 }
7804
7805 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializeNode, V::Error>
7806 where
7807 V: serde::de::MapAccess<'de>,
7808 {
7809 let mut table_id__ = None;
7810 let mut column_orders__ = None;
7811 let mut table__ = None;
7812 let mut staging_table__ = None;
7813 let mut refresh_progress_table__ = None;
7814 let mut cleaned_by_ttl_watermark__ = None;
7815 while let Some(k) = map_.next_key()? {
7816 match k {
7817 GeneratedField::TableId => {
7818 if table_id__.is_some() {
7819 return Err(serde::de::Error::duplicate_field("tableId"));
7820 }
7821 table_id__ =
7822 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7823 ;
7824 }
7825 GeneratedField::ColumnOrders => {
7826 if column_orders__.is_some() {
7827 return Err(serde::de::Error::duplicate_field("columnOrders"));
7828 }
7829 column_orders__ = Some(map_.next_value()?);
7830 }
7831 GeneratedField::Table => {
7832 if table__.is_some() {
7833 return Err(serde::de::Error::duplicate_field("table"));
7834 }
7835 table__ = map_.next_value()?;
7836 }
7837 GeneratedField::StagingTable => {
7838 if staging_table__.is_some() {
7839 return Err(serde::de::Error::duplicate_field("stagingTable"));
7840 }
7841 staging_table__ = map_.next_value()?;
7842 }
7843 GeneratedField::RefreshProgressTable => {
7844 if refresh_progress_table__.is_some() {
7845 return Err(serde::de::Error::duplicate_field("refreshProgressTable"));
7846 }
7847 refresh_progress_table__ = map_.next_value()?;
7848 }
7849 GeneratedField::CleanedByTtlWatermark => {
7850 if cleaned_by_ttl_watermark__.is_some() {
7851 return Err(serde::de::Error::duplicate_field("cleanedByTtlWatermark"));
7852 }
7853 cleaned_by_ttl_watermark__ = Some(map_.next_value()?);
7854 }
7855 }
7856 }
7857 Ok(MaterializeNode {
7858 table_id: table_id__.unwrap_or_default(),
7859 column_orders: column_orders__.unwrap_or_default(),
7860 table: table__,
7861 staging_table: staging_table__,
7862 refresh_progress_table: refresh_progress_table__,
7863 cleaned_by_ttl_watermark: cleaned_by_ttl_watermark__.unwrap_or_default(),
7864 })
7865 }
7866 }
7867 deserializer.deserialize_struct("stream_plan.MaterializeNode", FIELDS, GeneratedVisitor)
7868 }
7869}
7870impl serde::Serialize for MaterializedExprsNode {
7871 #[allow(deprecated)]
7872 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7873 where
7874 S: serde::Serializer,
7875 {
7876 use serde::ser::SerializeStruct;
7877 let mut len = 0;
7878 if !self.exprs.is_empty() {
7879 len += 1;
7880 }
7881 if self.state_table.is_some() {
7882 len += 1;
7883 }
7884 if self.state_clean_col_idx.is_some() {
7885 len += 1;
7886 }
7887 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializedExprsNode", len)?;
7888 if !self.exprs.is_empty() {
7889 struct_ser.serialize_field("exprs", &self.exprs)?;
7890 }
7891 if let Some(v) = self.state_table.as_ref() {
7892 struct_ser.serialize_field("stateTable", v)?;
7893 }
7894 if let Some(v) = self.state_clean_col_idx.as_ref() {
7895 struct_ser.serialize_field("stateCleanColIdx", v)?;
7896 }
7897 struct_ser.end()
7898 }
7899}
7900impl<'de> serde::Deserialize<'de> for MaterializedExprsNode {
7901 #[allow(deprecated)]
7902 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7903 where
7904 D: serde::Deserializer<'de>,
7905 {
7906 const FIELDS: &[&str] = &[
7907 "exprs",
7908 "state_table",
7909 "stateTable",
7910 "state_clean_col_idx",
7911 "stateCleanColIdx",
7912 ];
7913
7914 #[allow(clippy::enum_variant_names)]
7915 enum GeneratedField {
7916 Exprs,
7917 StateTable,
7918 StateCleanColIdx,
7919 }
7920 impl<'de> serde::Deserialize<'de> for GeneratedField {
7921 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7922 where
7923 D: serde::Deserializer<'de>,
7924 {
7925 struct GeneratedVisitor;
7926
7927 impl serde::de::Visitor<'_> for GeneratedVisitor {
7928 type Value = GeneratedField;
7929
7930 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7931 write!(formatter, "expected one of: {:?}", &FIELDS)
7932 }
7933
7934 #[allow(unused_variables)]
7935 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7936 where
7937 E: serde::de::Error,
7938 {
7939 match value {
7940 "exprs" => Ok(GeneratedField::Exprs),
7941 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7942 "stateCleanColIdx" | "state_clean_col_idx" => Ok(GeneratedField::StateCleanColIdx),
7943 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7944 }
7945 }
7946 }
7947 deserializer.deserialize_identifier(GeneratedVisitor)
7948 }
7949 }
7950 struct GeneratedVisitor;
7951 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7952 type Value = MaterializedExprsNode;
7953
7954 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7955 formatter.write_str("struct stream_plan.MaterializedExprsNode")
7956 }
7957
7958 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializedExprsNode, V::Error>
7959 where
7960 V: serde::de::MapAccess<'de>,
7961 {
7962 let mut exprs__ = None;
7963 let mut state_table__ = None;
7964 let mut state_clean_col_idx__ = None;
7965 while let Some(k) = map_.next_key()? {
7966 match k {
7967 GeneratedField::Exprs => {
7968 if exprs__.is_some() {
7969 return Err(serde::de::Error::duplicate_field("exprs"));
7970 }
7971 exprs__ = Some(map_.next_value()?);
7972 }
7973 GeneratedField::StateTable => {
7974 if state_table__.is_some() {
7975 return Err(serde::de::Error::duplicate_field("stateTable"));
7976 }
7977 state_table__ = map_.next_value()?;
7978 }
7979 GeneratedField::StateCleanColIdx => {
7980 if state_clean_col_idx__.is_some() {
7981 return Err(serde::de::Error::duplicate_field("stateCleanColIdx"));
7982 }
7983 state_clean_col_idx__ =
7984 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
7985 ;
7986 }
7987 }
7988 }
7989 Ok(MaterializedExprsNode {
7990 exprs: exprs__.unwrap_or_default(),
7991 state_table: state_table__,
7992 state_clean_col_idx: state_clean_col_idx__,
7993 })
7994 }
7995 }
7996 deserializer.deserialize_struct("stream_plan.MaterializedExprsNode", FIELDS, GeneratedVisitor)
7997 }
7998}
7999impl serde::Serialize for MergeNode {
8000 #[allow(deprecated)]
8001 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8002 where
8003 S: serde::Serializer,
8004 {
8005 use serde::ser::SerializeStruct;
8006 let mut len = 0;
8007 if !self.upstream_actor_id.is_empty() {
8008 len += 1;
8009 }
8010 if self.upstream_fragment_id != 0 {
8011 len += 1;
8012 }
8013 if self.upstream_dispatcher_type != 0 {
8014 len += 1;
8015 }
8016 if !self.fields.is_empty() {
8017 len += 1;
8018 }
8019 let mut struct_ser = serializer.serialize_struct("stream_plan.MergeNode", len)?;
8020 if !self.upstream_actor_id.is_empty() {
8021 struct_ser.serialize_field("upstreamActorId", &self.upstream_actor_id)?;
8022 }
8023 if self.upstream_fragment_id != 0 {
8024 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
8025 }
8026 if self.upstream_dispatcher_type != 0 {
8027 let v = DispatcherType::try_from(self.upstream_dispatcher_type)
8028 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.upstream_dispatcher_type)))?;
8029 struct_ser.serialize_field("upstreamDispatcherType", &v)?;
8030 }
8031 if !self.fields.is_empty() {
8032 struct_ser.serialize_field("fields", &self.fields)?;
8033 }
8034 struct_ser.end()
8035 }
8036}
8037impl<'de> serde::Deserialize<'de> for MergeNode {
8038 #[allow(deprecated)]
8039 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8040 where
8041 D: serde::Deserializer<'de>,
8042 {
8043 const FIELDS: &[&str] = &[
8044 "upstream_actor_id",
8045 "upstreamActorId",
8046 "upstream_fragment_id",
8047 "upstreamFragmentId",
8048 "upstream_dispatcher_type",
8049 "upstreamDispatcherType",
8050 "fields",
8051 ];
8052
8053 #[allow(clippy::enum_variant_names)]
8054 enum GeneratedField {
8055 UpstreamActorId,
8056 UpstreamFragmentId,
8057 UpstreamDispatcherType,
8058 Fields,
8059 }
8060 impl<'de> serde::Deserialize<'de> for GeneratedField {
8061 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8062 where
8063 D: serde::Deserializer<'de>,
8064 {
8065 struct GeneratedVisitor;
8066
8067 impl serde::de::Visitor<'_> for GeneratedVisitor {
8068 type Value = GeneratedField;
8069
8070 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8071 write!(formatter, "expected one of: {:?}", &FIELDS)
8072 }
8073
8074 #[allow(unused_variables)]
8075 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8076 where
8077 E: serde::de::Error,
8078 {
8079 match value {
8080 "upstreamActorId" | "upstream_actor_id" => Ok(GeneratedField::UpstreamActorId),
8081 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
8082 "upstreamDispatcherType" | "upstream_dispatcher_type" => Ok(GeneratedField::UpstreamDispatcherType),
8083 "fields" => Ok(GeneratedField::Fields),
8084 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8085 }
8086 }
8087 }
8088 deserializer.deserialize_identifier(GeneratedVisitor)
8089 }
8090 }
8091 struct GeneratedVisitor;
8092 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8093 type Value = MergeNode;
8094
8095 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8096 formatter.write_str("struct stream_plan.MergeNode")
8097 }
8098
8099 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeNode, V::Error>
8100 where
8101 V: serde::de::MapAccess<'de>,
8102 {
8103 let mut upstream_actor_id__ = None;
8104 let mut upstream_fragment_id__ = None;
8105 let mut upstream_dispatcher_type__ = None;
8106 let mut fields__ = None;
8107 while let Some(k) = map_.next_key()? {
8108 match k {
8109 GeneratedField::UpstreamActorId => {
8110 if upstream_actor_id__.is_some() {
8111 return Err(serde::de::Error::duplicate_field("upstreamActorId"));
8112 }
8113 upstream_actor_id__ =
8114 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8115 .into_iter().map(|x| x.0).collect())
8116 ;
8117 }
8118 GeneratedField::UpstreamFragmentId => {
8119 if upstream_fragment_id__.is_some() {
8120 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
8121 }
8122 upstream_fragment_id__ =
8123 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8124 ;
8125 }
8126 GeneratedField::UpstreamDispatcherType => {
8127 if upstream_dispatcher_type__.is_some() {
8128 return Err(serde::de::Error::duplicate_field("upstreamDispatcherType"));
8129 }
8130 upstream_dispatcher_type__ = Some(map_.next_value::<DispatcherType>()? as i32);
8131 }
8132 GeneratedField::Fields => {
8133 if fields__.is_some() {
8134 return Err(serde::de::Error::duplicate_field("fields"));
8135 }
8136 fields__ = Some(map_.next_value()?);
8137 }
8138 }
8139 }
8140 Ok(MergeNode {
8141 upstream_actor_id: upstream_actor_id__.unwrap_or_default(),
8142 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
8143 upstream_dispatcher_type: upstream_dispatcher_type__.unwrap_or_default(),
8144 fields: fields__.unwrap_or_default(),
8145 })
8146 }
8147 }
8148 deserializer.deserialize_struct("stream_plan.MergeNode", FIELDS, GeneratedVisitor)
8149 }
8150}
8151impl serde::Serialize for NoOpNode {
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 len = 0;
8159 let struct_ser = serializer.serialize_struct("stream_plan.NoOpNode", len)?;
8160 struct_ser.end()
8161 }
8162}
8163impl<'de> serde::Deserialize<'de> for NoOpNode {
8164 #[allow(deprecated)]
8165 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8166 where
8167 D: serde::Deserializer<'de>,
8168 {
8169 const FIELDS: &[&str] = &[
8170 ];
8171
8172 #[allow(clippy::enum_variant_names)]
8173 enum GeneratedField {
8174 }
8175 impl<'de> serde::Deserialize<'de> for GeneratedField {
8176 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8177 where
8178 D: serde::Deserializer<'de>,
8179 {
8180 struct GeneratedVisitor;
8181
8182 impl serde::de::Visitor<'_> for GeneratedVisitor {
8183 type Value = GeneratedField;
8184
8185 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8186 write!(formatter, "expected one of: {:?}", &FIELDS)
8187 }
8188
8189 #[allow(unused_variables)]
8190 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8191 where
8192 E: serde::de::Error,
8193 {
8194 Err(serde::de::Error::unknown_field(value, FIELDS))
8195 }
8196 }
8197 deserializer.deserialize_identifier(GeneratedVisitor)
8198 }
8199 }
8200 struct GeneratedVisitor;
8201 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8202 type Value = NoOpNode;
8203
8204 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8205 formatter.write_str("struct stream_plan.NoOpNode")
8206 }
8207
8208 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NoOpNode, V::Error>
8209 where
8210 V: serde::de::MapAccess<'de>,
8211 {
8212 while map_.next_key::<GeneratedField>()?.is_some() {
8213 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8214 }
8215 Ok(NoOpNode {
8216 })
8217 }
8218 }
8219 deserializer.deserialize_struct("stream_plan.NoOpNode", FIELDS, GeneratedVisitor)
8220 }
8221}
8222impl serde::Serialize for NowModeGenerateSeries {
8223 #[allow(deprecated)]
8224 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8225 where
8226 S: serde::Serializer,
8227 {
8228 use serde::ser::SerializeStruct;
8229 let mut len = 0;
8230 if self.start_timestamp.is_some() {
8231 len += 1;
8232 }
8233 if self.interval.is_some() {
8234 len += 1;
8235 }
8236 let mut struct_ser = serializer.serialize_struct("stream_plan.NowModeGenerateSeries", len)?;
8237 if let Some(v) = self.start_timestamp.as_ref() {
8238 struct_ser.serialize_field("startTimestamp", v)?;
8239 }
8240 if let Some(v) = self.interval.as_ref() {
8241 struct_ser.serialize_field("interval", v)?;
8242 }
8243 struct_ser.end()
8244 }
8245}
8246impl<'de> serde::Deserialize<'de> for NowModeGenerateSeries {
8247 #[allow(deprecated)]
8248 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8249 where
8250 D: serde::Deserializer<'de>,
8251 {
8252 const FIELDS: &[&str] = &[
8253 "start_timestamp",
8254 "startTimestamp",
8255 "interval",
8256 ];
8257
8258 #[allow(clippy::enum_variant_names)]
8259 enum GeneratedField {
8260 StartTimestamp,
8261 Interval,
8262 }
8263 impl<'de> serde::Deserialize<'de> for GeneratedField {
8264 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8265 where
8266 D: serde::Deserializer<'de>,
8267 {
8268 struct GeneratedVisitor;
8269
8270 impl serde::de::Visitor<'_> for GeneratedVisitor {
8271 type Value = GeneratedField;
8272
8273 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8274 write!(formatter, "expected one of: {:?}", &FIELDS)
8275 }
8276
8277 #[allow(unused_variables)]
8278 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8279 where
8280 E: serde::de::Error,
8281 {
8282 match value {
8283 "startTimestamp" | "start_timestamp" => Ok(GeneratedField::StartTimestamp),
8284 "interval" => Ok(GeneratedField::Interval),
8285 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8286 }
8287 }
8288 }
8289 deserializer.deserialize_identifier(GeneratedVisitor)
8290 }
8291 }
8292 struct GeneratedVisitor;
8293 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8294 type Value = NowModeGenerateSeries;
8295
8296 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8297 formatter.write_str("struct stream_plan.NowModeGenerateSeries")
8298 }
8299
8300 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeGenerateSeries, V::Error>
8301 where
8302 V: serde::de::MapAccess<'de>,
8303 {
8304 let mut start_timestamp__ = None;
8305 let mut interval__ = None;
8306 while let Some(k) = map_.next_key()? {
8307 match k {
8308 GeneratedField::StartTimestamp => {
8309 if start_timestamp__.is_some() {
8310 return Err(serde::de::Error::duplicate_field("startTimestamp"));
8311 }
8312 start_timestamp__ = map_.next_value()?;
8313 }
8314 GeneratedField::Interval => {
8315 if interval__.is_some() {
8316 return Err(serde::de::Error::duplicate_field("interval"));
8317 }
8318 interval__ = map_.next_value()?;
8319 }
8320 }
8321 }
8322 Ok(NowModeGenerateSeries {
8323 start_timestamp: start_timestamp__,
8324 interval: interval__,
8325 })
8326 }
8327 }
8328 deserializer.deserialize_struct("stream_plan.NowModeGenerateSeries", FIELDS, GeneratedVisitor)
8329 }
8330}
8331impl serde::Serialize for NowModeUpdateCurrent {
8332 #[allow(deprecated)]
8333 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8334 where
8335 S: serde::Serializer,
8336 {
8337 use serde::ser::SerializeStruct;
8338 let len = 0;
8339 let struct_ser = serializer.serialize_struct("stream_plan.NowModeUpdateCurrent", len)?;
8340 struct_ser.end()
8341 }
8342}
8343impl<'de> serde::Deserialize<'de> for NowModeUpdateCurrent {
8344 #[allow(deprecated)]
8345 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8346 where
8347 D: serde::Deserializer<'de>,
8348 {
8349 const FIELDS: &[&str] = &[
8350 ];
8351
8352 #[allow(clippy::enum_variant_names)]
8353 enum GeneratedField {
8354 }
8355 impl<'de> serde::Deserialize<'de> for GeneratedField {
8356 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8357 where
8358 D: serde::Deserializer<'de>,
8359 {
8360 struct GeneratedVisitor;
8361
8362 impl serde::de::Visitor<'_> for GeneratedVisitor {
8363 type Value = GeneratedField;
8364
8365 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8366 write!(formatter, "expected one of: {:?}", &FIELDS)
8367 }
8368
8369 #[allow(unused_variables)]
8370 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8371 where
8372 E: serde::de::Error,
8373 {
8374 Err(serde::de::Error::unknown_field(value, FIELDS))
8375 }
8376 }
8377 deserializer.deserialize_identifier(GeneratedVisitor)
8378 }
8379 }
8380 struct GeneratedVisitor;
8381 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8382 type Value = NowModeUpdateCurrent;
8383
8384 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8385 formatter.write_str("struct stream_plan.NowModeUpdateCurrent")
8386 }
8387
8388 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeUpdateCurrent, V::Error>
8389 where
8390 V: serde::de::MapAccess<'de>,
8391 {
8392 while map_.next_key::<GeneratedField>()?.is_some() {
8393 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8394 }
8395 Ok(NowModeUpdateCurrent {
8396 })
8397 }
8398 }
8399 deserializer.deserialize_struct("stream_plan.NowModeUpdateCurrent", FIELDS, GeneratedVisitor)
8400 }
8401}
8402impl serde::Serialize for NowNode {
8403 #[allow(deprecated)]
8404 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8405 where
8406 S: serde::Serializer,
8407 {
8408 use serde::ser::SerializeStruct;
8409 let mut len = 0;
8410 if self.state_table.is_some() {
8411 len += 1;
8412 }
8413 if self.mode.is_some() {
8414 len += 1;
8415 }
8416 let mut struct_ser = serializer.serialize_struct("stream_plan.NowNode", len)?;
8417 if let Some(v) = self.state_table.as_ref() {
8418 struct_ser.serialize_field("stateTable", v)?;
8419 }
8420 if let Some(v) = self.mode.as_ref() {
8421 match v {
8422 now_node::Mode::UpdateCurrent(v) => {
8423 struct_ser.serialize_field("updateCurrent", v)?;
8424 }
8425 now_node::Mode::GenerateSeries(v) => {
8426 struct_ser.serialize_field("generateSeries", v)?;
8427 }
8428 }
8429 }
8430 struct_ser.end()
8431 }
8432}
8433impl<'de> serde::Deserialize<'de> for NowNode {
8434 #[allow(deprecated)]
8435 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8436 where
8437 D: serde::Deserializer<'de>,
8438 {
8439 const FIELDS: &[&str] = &[
8440 "state_table",
8441 "stateTable",
8442 "update_current",
8443 "updateCurrent",
8444 "generate_series",
8445 "generateSeries",
8446 ];
8447
8448 #[allow(clippy::enum_variant_names)]
8449 enum GeneratedField {
8450 StateTable,
8451 UpdateCurrent,
8452 GenerateSeries,
8453 }
8454 impl<'de> serde::Deserialize<'de> for GeneratedField {
8455 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8456 where
8457 D: serde::Deserializer<'de>,
8458 {
8459 struct GeneratedVisitor;
8460
8461 impl serde::de::Visitor<'_> for GeneratedVisitor {
8462 type Value = GeneratedField;
8463
8464 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8465 write!(formatter, "expected one of: {:?}", &FIELDS)
8466 }
8467
8468 #[allow(unused_variables)]
8469 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8470 where
8471 E: serde::de::Error,
8472 {
8473 match value {
8474 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
8475 "updateCurrent" | "update_current" => Ok(GeneratedField::UpdateCurrent),
8476 "generateSeries" | "generate_series" => Ok(GeneratedField::GenerateSeries),
8477 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8478 }
8479 }
8480 }
8481 deserializer.deserialize_identifier(GeneratedVisitor)
8482 }
8483 }
8484 struct GeneratedVisitor;
8485 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8486 type Value = NowNode;
8487
8488 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8489 formatter.write_str("struct stream_plan.NowNode")
8490 }
8491
8492 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowNode, V::Error>
8493 where
8494 V: serde::de::MapAccess<'de>,
8495 {
8496 let mut state_table__ = None;
8497 let mut mode__ = None;
8498 while let Some(k) = map_.next_key()? {
8499 match k {
8500 GeneratedField::StateTable => {
8501 if state_table__.is_some() {
8502 return Err(serde::de::Error::duplicate_field("stateTable"));
8503 }
8504 state_table__ = map_.next_value()?;
8505 }
8506 GeneratedField::UpdateCurrent => {
8507 if mode__.is_some() {
8508 return Err(serde::de::Error::duplicate_field("updateCurrent"));
8509 }
8510 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::UpdateCurrent)
8511;
8512 }
8513 GeneratedField::GenerateSeries => {
8514 if mode__.is_some() {
8515 return Err(serde::de::Error::duplicate_field("generateSeries"));
8516 }
8517 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::GenerateSeries)
8518;
8519 }
8520 }
8521 }
8522 Ok(NowNode {
8523 state_table: state_table__,
8524 mode: mode__,
8525 })
8526 }
8527 }
8528 deserializer.deserialize_struct("stream_plan.NowNode", FIELDS, GeneratedVisitor)
8529 }
8530}
8531impl serde::Serialize for OverWindowCachePolicy {
8532 #[allow(deprecated)]
8533 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8534 where
8535 S: serde::Serializer,
8536 {
8537 let variant = match self {
8538 Self::Unspecified => "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
8539 Self::Full => "OVER_WINDOW_CACHE_POLICY_FULL",
8540 Self::Recent => "OVER_WINDOW_CACHE_POLICY_RECENT",
8541 Self::RecentFirstN => "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
8542 Self::RecentLastN => "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
8543 };
8544 serializer.serialize_str(variant)
8545 }
8546}
8547impl<'de> serde::Deserialize<'de> for OverWindowCachePolicy {
8548 #[allow(deprecated)]
8549 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8550 where
8551 D: serde::Deserializer<'de>,
8552 {
8553 const FIELDS: &[&str] = &[
8554 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
8555 "OVER_WINDOW_CACHE_POLICY_FULL",
8556 "OVER_WINDOW_CACHE_POLICY_RECENT",
8557 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
8558 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
8559 ];
8560
8561 struct GeneratedVisitor;
8562
8563 impl serde::de::Visitor<'_> for GeneratedVisitor {
8564 type Value = OverWindowCachePolicy;
8565
8566 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8567 write!(formatter, "expected one of: {:?}", &FIELDS)
8568 }
8569
8570 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8571 where
8572 E: serde::de::Error,
8573 {
8574 i32::try_from(v)
8575 .ok()
8576 .and_then(|x| x.try_into().ok())
8577 .ok_or_else(|| {
8578 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8579 })
8580 }
8581
8582 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8583 where
8584 E: serde::de::Error,
8585 {
8586 i32::try_from(v)
8587 .ok()
8588 .and_then(|x| x.try_into().ok())
8589 .ok_or_else(|| {
8590 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8591 })
8592 }
8593
8594 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8595 where
8596 E: serde::de::Error,
8597 {
8598 match value {
8599 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED" => Ok(OverWindowCachePolicy::Unspecified),
8600 "OVER_WINDOW_CACHE_POLICY_FULL" => Ok(OverWindowCachePolicy::Full),
8601 "OVER_WINDOW_CACHE_POLICY_RECENT" => Ok(OverWindowCachePolicy::Recent),
8602 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N" => Ok(OverWindowCachePolicy::RecentFirstN),
8603 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N" => Ok(OverWindowCachePolicy::RecentLastN),
8604 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8605 }
8606 }
8607 }
8608 deserializer.deserialize_any(GeneratedVisitor)
8609 }
8610}
8611impl serde::Serialize for OverWindowNode {
8612 #[allow(deprecated)]
8613 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8614 where
8615 S: serde::Serializer,
8616 {
8617 use serde::ser::SerializeStruct;
8618 let mut len = 0;
8619 if !self.calls.is_empty() {
8620 len += 1;
8621 }
8622 if !self.partition_by.is_empty() {
8623 len += 1;
8624 }
8625 if !self.order_by.is_empty() {
8626 len += 1;
8627 }
8628 if self.state_table.is_some() {
8629 len += 1;
8630 }
8631 if self.cache_policy != 0 {
8632 len += 1;
8633 }
8634 let mut struct_ser = serializer.serialize_struct("stream_plan.OverWindowNode", len)?;
8635 if !self.calls.is_empty() {
8636 struct_ser.serialize_field("calls", &self.calls)?;
8637 }
8638 if !self.partition_by.is_empty() {
8639 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
8640 }
8641 if !self.order_by.is_empty() {
8642 struct_ser.serialize_field("orderBy", &self.order_by)?;
8643 }
8644 if let Some(v) = self.state_table.as_ref() {
8645 struct_ser.serialize_field("stateTable", v)?;
8646 }
8647 if self.cache_policy != 0 {
8648 let v = OverWindowCachePolicy::try_from(self.cache_policy)
8649 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cache_policy)))?;
8650 struct_ser.serialize_field("cachePolicy", &v)?;
8651 }
8652 struct_ser.end()
8653 }
8654}
8655impl<'de> serde::Deserialize<'de> for OverWindowNode {
8656 #[allow(deprecated)]
8657 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8658 where
8659 D: serde::Deserializer<'de>,
8660 {
8661 const FIELDS: &[&str] = &[
8662 "calls",
8663 "partition_by",
8664 "partitionBy",
8665 "order_by",
8666 "orderBy",
8667 "state_table",
8668 "stateTable",
8669 "cache_policy",
8670 "cachePolicy",
8671 ];
8672
8673 #[allow(clippy::enum_variant_names)]
8674 enum GeneratedField {
8675 Calls,
8676 PartitionBy,
8677 OrderBy,
8678 StateTable,
8679 CachePolicy,
8680 }
8681 impl<'de> serde::Deserialize<'de> for GeneratedField {
8682 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8683 where
8684 D: serde::Deserializer<'de>,
8685 {
8686 struct GeneratedVisitor;
8687
8688 impl serde::de::Visitor<'_> for GeneratedVisitor {
8689 type Value = GeneratedField;
8690
8691 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8692 write!(formatter, "expected one of: {:?}", &FIELDS)
8693 }
8694
8695 #[allow(unused_variables)]
8696 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8697 where
8698 E: serde::de::Error,
8699 {
8700 match value {
8701 "calls" => Ok(GeneratedField::Calls),
8702 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
8703 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
8704 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
8705 "cachePolicy" | "cache_policy" => Ok(GeneratedField::CachePolicy),
8706 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8707 }
8708 }
8709 }
8710 deserializer.deserialize_identifier(GeneratedVisitor)
8711 }
8712 }
8713 struct GeneratedVisitor;
8714 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8715 type Value = OverWindowNode;
8716
8717 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8718 formatter.write_str("struct stream_plan.OverWindowNode")
8719 }
8720
8721 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverWindowNode, V::Error>
8722 where
8723 V: serde::de::MapAccess<'de>,
8724 {
8725 let mut calls__ = None;
8726 let mut partition_by__ = None;
8727 let mut order_by__ = None;
8728 let mut state_table__ = None;
8729 let mut cache_policy__ = None;
8730 while let Some(k) = map_.next_key()? {
8731 match k {
8732 GeneratedField::Calls => {
8733 if calls__.is_some() {
8734 return Err(serde::de::Error::duplicate_field("calls"));
8735 }
8736 calls__ = Some(map_.next_value()?);
8737 }
8738 GeneratedField::PartitionBy => {
8739 if partition_by__.is_some() {
8740 return Err(serde::de::Error::duplicate_field("partitionBy"));
8741 }
8742 partition_by__ =
8743 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8744 .into_iter().map(|x| x.0).collect())
8745 ;
8746 }
8747 GeneratedField::OrderBy => {
8748 if order_by__.is_some() {
8749 return Err(serde::de::Error::duplicate_field("orderBy"));
8750 }
8751 order_by__ = Some(map_.next_value()?);
8752 }
8753 GeneratedField::StateTable => {
8754 if state_table__.is_some() {
8755 return Err(serde::de::Error::duplicate_field("stateTable"));
8756 }
8757 state_table__ = map_.next_value()?;
8758 }
8759 GeneratedField::CachePolicy => {
8760 if cache_policy__.is_some() {
8761 return Err(serde::de::Error::duplicate_field("cachePolicy"));
8762 }
8763 cache_policy__ = Some(map_.next_value::<OverWindowCachePolicy>()? as i32);
8764 }
8765 }
8766 }
8767 Ok(OverWindowNode {
8768 calls: calls__.unwrap_or_default(),
8769 partition_by: partition_by__.unwrap_or_default(),
8770 order_by: order_by__.unwrap_or_default(),
8771 state_table: state_table__,
8772 cache_policy: cache_policy__.unwrap_or_default(),
8773 })
8774 }
8775 }
8776 deserializer.deserialize_struct("stream_plan.OverWindowNode", FIELDS, GeneratedVisitor)
8777 }
8778}
8779impl serde::Serialize for PauseMutation {
8780 #[allow(deprecated)]
8781 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8782 where
8783 S: serde::Serializer,
8784 {
8785 use serde::ser::SerializeStruct;
8786 let len = 0;
8787 let struct_ser = serializer.serialize_struct("stream_plan.PauseMutation", len)?;
8788 struct_ser.end()
8789 }
8790}
8791impl<'de> serde::Deserialize<'de> for PauseMutation {
8792 #[allow(deprecated)]
8793 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8794 where
8795 D: serde::Deserializer<'de>,
8796 {
8797 const FIELDS: &[&str] = &[
8798 ];
8799
8800 #[allow(clippy::enum_variant_names)]
8801 enum GeneratedField {
8802 }
8803 impl<'de> serde::Deserialize<'de> for GeneratedField {
8804 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8805 where
8806 D: serde::Deserializer<'de>,
8807 {
8808 struct GeneratedVisitor;
8809
8810 impl serde::de::Visitor<'_> for GeneratedVisitor {
8811 type Value = GeneratedField;
8812
8813 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8814 write!(formatter, "expected one of: {:?}", &FIELDS)
8815 }
8816
8817 #[allow(unused_variables)]
8818 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8819 where
8820 E: serde::de::Error,
8821 {
8822 Err(serde::de::Error::unknown_field(value, FIELDS))
8823 }
8824 }
8825 deserializer.deserialize_identifier(GeneratedVisitor)
8826 }
8827 }
8828 struct GeneratedVisitor;
8829 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8830 type Value = PauseMutation;
8831
8832 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8833 formatter.write_str("struct stream_plan.PauseMutation")
8834 }
8835
8836 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseMutation, V::Error>
8837 where
8838 V: serde::de::MapAccess<'de>,
8839 {
8840 while map_.next_key::<GeneratedField>()?.is_some() {
8841 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8842 }
8843 Ok(PauseMutation {
8844 })
8845 }
8846 }
8847 deserializer.deserialize_struct("stream_plan.PauseMutation", FIELDS, GeneratedVisitor)
8848 }
8849}
8850impl serde::Serialize for ProjectNode {
8851 #[allow(deprecated)]
8852 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8853 where
8854 S: serde::Serializer,
8855 {
8856 use serde::ser::SerializeStruct;
8857 let mut len = 0;
8858 if !self.select_list.is_empty() {
8859 len += 1;
8860 }
8861 if !self.watermark_input_cols.is_empty() {
8862 len += 1;
8863 }
8864 if !self.watermark_output_cols.is_empty() {
8865 len += 1;
8866 }
8867 if !self.nondecreasing_exprs.is_empty() {
8868 len += 1;
8869 }
8870 if self.noop_update_hint {
8871 len += 1;
8872 }
8873 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectNode", len)?;
8874 if !self.select_list.is_empty() {
8875 struct_ser.serialize_field("selectList", &self.select_list)?;
8876 }
8877 if !self.watermark_input_cols.is_empty() {
8878 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
8879 }
8880 if !self.watermark_output_cols.is_empty() {
8881 struct_ser.serialize_field("watermarkOutputCols", &self.watermark_output_cols)?;
8882 }
8883 if !self.nondecreasing_exprs.is_empty() {
8884 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
8885 }
8886 if self.noop_update_hint {
8887 struct_ser.serialize_field("noopUpdateHint", &self.noop_update_hint)?;
8888 }
8889 struct_ser.end()
8890 }
8891}
8892impl<'de> serde::Deserialize<'de> for ProjectNode {
8893 #[allow(deprecated)]
8894 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8895 where
8896 D: serde::Deserializer<'de>,
8897 {
8898 const FIELDS: &[&str] = &[
8899 "select_list",
8900 "selectList",
8901 "watermark_input_cols",
8902 "watermarkInputCols",
8903 "watermark_output_cols",
8904 "watermarkOutputCols",
8905 "nondecreasing_exprs",
8906 "nondecreasingExprs",
8907 "noop_update_hint",
8908 "noopUpdateHint",
8909 ];
8910
8911 #[allow(clippy::enum_variant_names)]
8912 enum GeneratedField {
8913 SelectList,
8914 WatermarkInputCols,
8915 WatermarkOutputCols,
8916 NondecreasingExprs,
8917 NoopUpdateHint,
8918 }
8919 impl<'de> serde::Deserialize<'de> for GeneratedField {
8920 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8921 where
8922 D: serde::Deserializer<'de>,
8923 {
8924 struct GeneratedVisitor;
8925
8926 impl serde::de::Visitor<'_> for GeneratedVisitor {
8927 type Value = GeneratedField;
8928
8929 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8930 write!(formatter, "expected one of: {:?}", &FIELDS)
8931 }
8932
8933 #[allow(unused_variables)]
8934 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8935 where
8936 E: serde::de::Error,
8937 {
8938 match value {
8939 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
8940 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
8941 "watermarkOutputCols" | "watermark_output_cols" => Ok(GeneratedField::WatermarkOutputCols),
8942 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
8943 "noopUpdateHint" | "noop_update_hint" => Ok(GeneratedField::NoopUpdateHint),
8944 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8945 }
8946 }
8947 }
8948 deserializer.deserialize_identifier(GeneratedVisitor)
8949 }
8950 }
8951 struct GeneratedVisitor;
8952 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8953 type Value = ProjectNode;
8954
8955 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8956 formatter.write_str("struct stream_plan.ProjectNode")
8957 }
8958
8959 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
8960 where
8961 V: serde::de::MapAccess<'de>,
8962 {
8963 let mut select_list__ = None;
8964 let mut watermark_input_cols__ = None;
8965 let mut watermark_output_cols__ = None;
8966 let mut nondecreasing_exprs__ = None;
8967 let mut noop_update_hint__ = None;
8968 while let Some(k) = map_.next_key()? {
8969 match k {
8970 GeneratedField::SelectList => {
8971 if select_list__.is_some() {
8972 return Err(serde::de::Error::duplicate_field("selectList"));
8973 }
8974 select_list__ = Some(map_.next_value()?);
8975 }
8976 GeneratedField::WatermarkInputCols => {
8977 if watermark_input_cols__.is_some() {
8978 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
8979 }
8980 watermark_input_cols__ =
8981 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8982 .into_iter().map(|x| x.0).collect())
8983 ;
8984 }
8985 GeneratedField::WatermarkOutputCols => {
8986 if watermark_output_cols__.is_some() {
8987 return Err(serde::de::Error::duplicate_field("watermarkOutputCols"));
8988 }
8989 watermark_output_cols__ =
8990 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8991 .into_iter().map(|x| x.0).collect())
8992 ;
8993 }
8994 GeneratedField::NondecreasingExprs => {
8995 if nondecreasing_exprs__.is_some() {
8996 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
8997 }
8998 nondecreasing_exprs__ =
8999 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9000 .into_iter().map(|x| x.0).collect())
9001 ;
9002 }
9003 GeneratedField::NoopUpdateHint => {
9004 if noop_update_hint__.is_some() {
9005 return Err(serde::de::Error::duplicate_field("noopUpdateHint"));
9006 }
9007 noop_update_hint__ = Some(map_.next_value()?);
9008 }
9009 }
9010 }
9011 Ok(ProjectNode {
9012 select_list: select_list__.unwrap_or_default(),
9013 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
9014 watermark_output_cols: watermark_output_cols__.unwrap_or_default(),
9015 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
9016 noop_update_hint: noop_update_hint__.unwrap_or_default(),
9017 })
9018 }
9019 }
9020 deserializer.deserialize_struct("stream_plan.ProjectNode", FIELDS, GeneratedVisitor)
9021 }
9022}
9023impl serde::Serialize for ProjectSetNode {
9024 #[allow(deprecated)]
9025 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9026 where
9027 S: serde::Serializer,
9028 {
9029 use serde::ser::SerializeStruct;
9030 let mut len = 0;
9031 if !self.select_list.is_empty() {
9032 len += 1;
9033 }
9034 if !self.watermark_input_cols.is_empty() {
9035 len += 1;
9036 }
9037 if !self.watermark_expr_indices.is_empty() {
9038 len += 1;
9039 }
9040 if !self.nondecreasing_exprs.is_empty() {
9041 len += 1;
9042 }
9043 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectSetNode", len)?;
9044 if !self.select_list.is_empty() {
9045 struct_ser.serialize_field("selectList", &self.select_list)?;
9046 }
9047 if !self.watermark_input_cols.is_empty() {
9048 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
9049 }
9050 if !self.watermark_expr_indices.is_empty() {
9051 struct_ser.serialize_field("watermarkExprIndices", &self.watermark_expr_indices)?;
9052 }
9053 if !self.nondecreasing_exprs.is_empty() {
9054 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
9055 }
9056 struct_ser.end()
9057 }
9058}
9059impl<'de> serde::Deserialize<'de> for ProjectSetNode {
9060 #[allow(deprecated)]
9061 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9062 where
9063 D: serde::Deserializer<'de>,
9064 {
9065 const FIELDS: &[&str] = &[
9066 "select_list",
9067 "selectList",
9068 "watermark_input_cols",
9069 "watermarkInputCols",
9070 "watermark_expr_indices",
9071 "watermarkExprIndices",
9072 "nondecreasing_exprs",
9073 "nondecreasingExprs",
9074 ];
9075
9076 #[allow(clippy::enum_variant_names)]
9077 enum GeneratedField {
9078 SelectList,
9079 WatermarkInputCols,
9080 WatermarkExprIndices,
9081 NondecreasingExprs,
9082 }
9083 impl<'de> serde::Deserialize<'de> for GeneratedField {
9084 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9085 where
9086 D: serde::Deserializer<'de>,
9087 {
9088 struct GeneratedVisitor;
9089
9090 impl serde::de::Visitor<'_> for GeneratedVisitor {
9091 type Value = GeneratedField;
9092
9093 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9094 write!(formatter, "expected one of: {:?}", &FIELDS)
9095 }
9096
9097 #[allow(unused_variables)]
9098 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9099 where
9100 E: serde::de::Error,
9101 {
9102 match value {
9103 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
9104 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
9105 "watermarkExprIndices" | "watermark_expr_indices" => Ok(GeneratedField::WatermarkExprIndices),
9106 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
9107 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9108 }
9109 }
9110 }
9111 deserializer.deserialize_identifier(GeneratedVisitor)
9112 }
9113 }
9114 struct GeneratedVisitor;
9115 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9116 type Value = ProjectSetNode;
9117
9118 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9119 formatter.write_str("struct stream_plan.ProjectSetNode")
9120 }
9121
9122 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
9123 where
9124 V: serde::de::MapAccess<'de>,
9125 {
9126 let mut select_list__ = None;
9127 let mut watermark_input_cols__ = None;
9128 let mut watermark_expr_indices__ = None;
9129 let mut nondecreasing_exprs__ = None;
9130 while let Some(k) = map_.next_key()? {
9131 match k {
9132 GeneratedField::SelectList => {
9133 if select_list__.is_some() {
9134 return Err(serde::de::Error::duplicate_field("selectList"));
9135 }
9136 select_list__ = Some(map_.next_value()?);
9137 }
9138 GeneratedField::WatermarkInputCols => {
9139 if watermark_input_cols__.is_some() {
9140 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
9141 }
9142 watermark_input_cols__ =
9143 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9144 .into_iter().map(|x| x.0).collect())
9145 ;
9146 }
9147 GeneratedField::WatermarkExprIndices => {
9148 if watermark_expr_indices__.is_some() {
9149 return Err(serde::de::Error::duplicate_field("watermarkExprIndices"));
9150 }
9151 watermark_expr_indices__ =
9152 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9153 .into_iter().map(|x| x.0).collect())
9154 ;
9155 }
9156 GeneratedField::NondecreasingExprs => {
9157 if nondecreasing_exprs__.is_some() {
9158 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
9159 }
9160 nondecreasing_exprs__ =
9161 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9162 .into_iter().map(|x| x.0).collect())
9163 ;
9164 }
9165 }
9166 }
9167 Ok(ProjectSetNode {
9168 select_list: select_list__.unwrap_or_default(),
9169 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
9170 watermark_expr_indices: watermark_expr_indices__.unwrap_or_default(),
9171 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
9172 })
9173 }
9174 }
9175 deserializer.deserialize_struct("stream_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
9176 }
9177}
9178impl serde::Serialize for RefreshStartMutation {
9179 #[allow(deprecated)]
9180 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9181 where
9182 S: serde::Serializer,
9183 {
9184 use serde::ser::SerializeStruct;
9185 let mut len = 0;
9186 if self.table_id != 0 {
9187 len += 1;
9188 }
9189 if self.associated_source_id != 0 {
9190 len += 1;
9191 }
9192 let mut struct_ser = serializer.serialize_struct("stream_plan.RefreshStartMutation", len)?;
9193 if self.table_id != 0 {
9194 struct_ser.serialize_field("tableId", &self.table_id)?;
9195 }
9196 if self.associated_source_id != 0 {
9197 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
9198 }
9199 struct_ser.end()
9200 }
9201}
9202impl<'de> serde::Deserialize<'de> for RefreshStartMutation {
9203 #[allow(deprecated)]
9204 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9205 where
9206 D: serde::Deserializer<'de>,
9207 {
9208 const FIELDS: &[&str] = &[
9209 "table_id",
9210 "tableId",
9211 "associated_source_id",
9212 "associatedSourceId",
9213 ];
9214
9215 #[allow(clippy::enum_variant_names)]
9216 enum GeneratedField {
9217 TableId,
9218 AssociatedSourceId,
9219 }
9220 impl<'de> serde::Deserialize<'de> for GeneratedField {
9221 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9222 where
9223 D: serde::Deserializer<'de>,
9224 {
9225 struct GeneratedVisitor;
9226
9227 impl serde::de::Visitor<'_> for GeneratedVisitor {
9228 type Value = GeneratedField;
9229
9230 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9231 write!(formatter, "expected one of: {:?}", &FIELDS)
9232 }
9233
9234 #[allow(unused_variables)]
9235 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9236 where
9237 E: serde::de::Error,
9238 {
9239 match value {
9240 "tableId" | "table_id" => Ok(GeneratedField::TableId),
9241 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
9242 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9243 }
9244 }
9245 }
9246 deserializer.deserialize_identifier(GeneratedVisitor)
9247 }
9248 }
9249 struct GeneratedVisitor;
9250 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9251 type Value = RefreshStartMutation;
9252
9253 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9254 formatter.write_str("struct stream_plan.RefreshStartMutation")
9255 }
9256
9257 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshStartMutation, V::Error>
9258 where
9259 V: serde::de::MapAccess<'de>,
9260 {
9261 let mut table_id__ = None;
9262 let mut associated_source_id__ = None;
9263 while let Some(k) = map_.next_key()? {
9264 match k {
9265 GeneratedField::TableId => {
9266 if table_id__.is_some() {
9267 return Err(serde::de::Error::duplicate_field("tableId"));
9268 }
9269 table_id__ =
9270 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9271 ;
9272 }
9273 GeneratedField::AssociatedSourceId => {
9274 if associated_source_id__.is_some() {
9275 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
9276 }
9277 associated_source_id__ =
9278 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9279 ;
9280 }
9281 }
9282 }
9283 Ok(RefreshStartMutation {
9284 table_id: table_id__.unwrap_or_default(),
9285 associated_source_id: associated_source_id__.unwrap_or_default(),
9286 })
9287 }
9288 }
9289 deserializer.deserialize_struct("stream_plan.RefreshStartMutation", FIELDS, GeneratedVisitor)
9290 }
9291}
9292impl serde::Serialize for ResetSourceMutation {
9293 #[allow(deprecated)]
9294 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9295 where
9296 S: serde::Serializer,
9297 {
9298 use serde::ser::SerializeStruct;
9299 let mut len = 0;
9300 if self.source_id != 0 {
9301 len += 1;
9302 }
9303 let mut struct_ser = serializer.serialize_struct("stream_plan.ResetSourceMutation", len)?;
9304 if self.source_id != 0 {
9305 struct_ser.serialize_field("sourceId", &self.source_id)?;
9306 }
9307 struct_ser.end()
9308 }
9309}
9310impl<'de> serde::Deserialize<'de> for ResetSourceMutation {
9311 #[allow(deprecated)]
9312 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9313 where
9314 D: serde::Deserializer<'de>,
9315 {
9316 const FIELDS: &[&str] = &[
9317 "source_id",
9318 "sourceId",
9319 ];
9320
9321 #[allow(clippy::enum_variant_names)]
9322 enum GeneratedField {
9323 SourceId,
9324 }
9325 impl<'de> serde::Deserialize<'de> for GeneratedField {
9326 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9327 where
9328 D: serde::Deserializer<'de>,
9329 {
9330 struct GeneratedVisitor;
9331
9332 impl serde::de::Visitor<'_> for GeneratedVisitor {
9333 type Value = GeneratedField;
9334
9335 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9336 write!(formatter, "expected one of: {:?}", &FIELDS)
9337 }
9338
9339 #[allow(unused_variables)]
9340 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9341 where
9342 E: serde::de::Error,
9343 {
9344 match value {
9345 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
9346 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9347 }
9348 }
9349 }
9350 deserializer.deserialize_identifier(GeneratedVisitor)
9351 }
9352 }
9353 struct GeneratedVisitor;
9354 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9355 type Value = ResetSourceMutation;
9356
9357 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9358 formatter.write_str("struct stream_plan.ResetSourceMutation")
9359 }
9360
9361 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceMutation, V::Error>
9362 where
9363 V: serde::de::MapAccess<'de>,
9364 {
9365 let mut source_id__ = None;
9366 while let Some(k) = map_.next_key()? {
9367 match k {
9368 GeneratedField::SourceId => {
9369 if source_id__.is_some() {
9370 return Err(serde::de::Error::duplicate_field("sourceId"));
9371 }
9372 source_id__ =
9373 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9374 ;
9375 }
9376 }
9377 }
9378 Ok(ResetSourceMutation {
9379 source_id: source_id__.unwrap_or_default(),
9380 })
9381 }
9382 }
9383 deserializer.deserialize_struct("stream_plan.ResetSourceMutation", FIELDS, GeneratedVisitor)
9384 }
9385}
9386impl serde::Serialize for ResumeMutation {
9387 #[allow(deprecated)]
9388 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9389 where
9390 S: serde::Serializer,
9391 {
9392 use serde::ser::SerializeStruct;
9393 let len = 0;
9394 let struct_ser = serializer.serialize_struct("stream_plan.ResumeMutation", len)?;
9395 struct_ser.end()
9396 }
9397}
9398impl<'de> serde::Deserialize<'de> for ResumeMutation {
9399 #[allow(deprecated)]
9400 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9401 where
9402 D: serde::Deserializer<'de>,
9403 {
9404 const FIELDS: &[&str] = &[
9405 ];
9406
9407 #[allow(clippy::enum_variant_names)]
9408 enum GeneratedField {
9409 }
9410 impl<'de> serde::Deserialize<'de> for GeneratedField {
9411 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9412 where
9413 D: serde::Deserializer<'de>,
9414 {
9415 struct GeneratedVisitor;
9416
9417 impl serde::de::Visitor<'_> for GeneratedVisitor {
9418 type Value = GeneratedField;
9419
9420 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9421 write!(formatter, "expected one of: {:?}", &FIELDS)
9422 }
9423
9424 #[allow(unused_variables)]
9425 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9426 where
9427 E: serde::de::Error,
9428 {
9429 Err(serde::de::Error::unknown_field(value, FIELDS))
9430 }
9431 }
9432 deserializer.deserialize_identifier(GeneratedVisitor)
9433 }
9434 }
9435 struct GeneratedVisitor;
9436 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9437 type Value = ResumeMutation;
9438
9439 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9440 formatter.write_str("struct stream_plan.ResumeMutation")
9441 }
9442
9443 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeMutation, V::Error>
9444 where
9445 V: serde::de::MapAccess<'de>,
9446 {
9447 while map_.next_key::<GeneratedField>()?.is_some() {
9448 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9449 }
9450 Ok(ResumeMutation {
9451 })
9452 }
9453 }
9454 deserializer.deserialize_struct("stream_plan.ResumeMutation", FIELDS, GeneratedVisitor)
9455 }
9456}
9457impl serde::Serialize for RowIdGenNode {
9458 #[allow(deprecated)]
9459 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9460 where
9461 S: serde::Serializer,
9462 {
9463 use serde::ser::SerializeStruct;
9464 let mut len = 0;
9465 if self.row_id_index != 0 {
9466 len += 1;
9467 }
9468 let mut struct_ser = serializer.serialize_struct("stream_plan.RowIdGenNode", len)?;
9469 if self.row_id_index != 0 {
9470 #[allow(clippy::needless_borrow)]
9471 #[allow(clippy::needless_borrows_for_generic_args)]
9472 struct_ser.serialize_field("rowIdIndex", ToString::to_string(&self.row_id_index).as_str())?;
9473 }
9474 struct_ser.end()
9475 }
9476}
9477impl<'de> serde::Deserialize<'de> for RowIdGenNode {
9478 #[allow(deprecated)]
9479 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9480 where
9481 D: serde::Deserializer<'de>,
9482 {
9483 const FIELDS: &[&str] = &[
9484 "row_id_index",
9485 "rowIdIndex",
9486 ];
9487
9488 #[allow(clippy::enum_variant_names)]
9489 enum GeneratedField {
9490 RowIdIndex,
9491 }
9492 impl<'de> serde::Deserialize<'de> for GeneratedField {
9493 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9494 where
9495 D: serde::Deserializer<'de>,
9496 {
9497 struct GeneratedVisitor;
9498
9499 impl serde::de::Visitor<'_> for GeneratedVisitor {
9500 type Value = GeneratedField;
9501
9502 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9503 write!(formatter, "expected one of: {:?}", &FIELDS)
9504 }
9505
9506 #[allow(unused_variables)]
9507 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9508 where
9509 E: serde::de::Error,
9510 {
9511 match value {
9512 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
9513 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9514 }
9515 }
9516 }
9517 deserializer.deserialize_identifier(GeneratedVisitor)
9518 }
9519 }
9520 struct GeneratedVisitor;
9521 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9522 type Value = RowIdGenNode;
9523
9524 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9525 formatter.write_str("struct stream_plan.RowIdGenNode")
9526 }
9527
9528 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowIdGenNode, V::Error>
9529 where
9530 V: serde::de::MapAccess<'de>,
9531 {
9532 let mut row_id_index__ = None;
9533 while let Some(k) = map_.next_key()? {
9534 match k {
9535 GeneratedField::RowIdIndex => {
9536 if row_id_index__.is_some() {
9537 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
9538 }
9539 row_id_index__ =
9540 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9541 ;
9542 }
9543 }
9544 }
9545 Ok(RowIdGenNode {
9546 row_id_index: row_id_index__.unwrap_or_default(),
9547 })
9548 }
9549 }
9550 deserializer.deserialize_struct("stream_plan.RowIdGenNode", FIELDS, GeneratedVisitor)
9551 }
9552}
9553impl serde::Serialize for RowMergeNode {
9554 #[allow(deprecated)]
9555 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9556 where
9557 S: serde::Serializer,
9558 {
9559 use serde::ser::SerializeStruct;
9560 let mut len = 0;
9561 if self.lhs_mapping.is_some() {
9562 len += 1;
9563 }
9564 if self.rhs_mapping.is_some() {
9565 len += 1;
9566 }
9567 let mut struct_ser = serializer.serialize_struct("stream_plan.RowMergeNode", len)?;
9568 if let Some(v) = self.lhs_mapping.as_ref() {
9569 struct_ser.serialize_field("lhsMapping", v)?;
9570 }
9571 if let Some(v) = self.rhs_mapping.as_ref() {
9572 struct_ser.serialize_field("rhsMapping", v)?;
9573 }
9574 struct_ser.end()
9575 }
9576}
9577impl<'de> serde::Deserialize<'de> for RowMergeNode {
9578 #[allow(deprecated)]
9579 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9580 where
9581 D: serde::Deserializer<'de>,
9582 {
9583 const FIELDS: &[&str] = &[
9584 "lhs_mapping",
9585 "lhsMapping",
9586 "rhs_mapping",
9587 "rhsMapping",
9588 ];
9589
9590 #[allow(clippy::enum_variant_names)]
9591 enum GeneratedField {
9592 LhsMapping,
9593 RhsMapping,
9594 }
9595 impl<'de> serde::Deserialize<'de> for GeneratedField {
9596 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9597 where
9598 D: serde::Deserializer<'de>,
9599 {
9600 struct GeneratedVisitor;
9601
9602 impl serde::de::Visitor<'_> for GeneratedVisitor {
9603 type Value = GeneratedField;
9604
9605 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9606 write!(formatter, "expected one of: {:?}", &FIELDS)
9607 }
9608
9609 #[allow(unused_variables)]
9610 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9611 where
9612 E: serde::de::Error,
9613 {
9614 match value {
9615 "lhsMapping" | "lhs_mapping" => Ok(GeneratedField::LhsMapping),
9616 "rhsMapping" | "rhs_mapping" => Ok(GeneratedField::RhsMapping),
9617 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9618 }
9619 }
9620 }
9621 deserializer.deserialize_identifier(GeneratedVisitor)
9622 }
9623 }
9624 struct GeneratedVisitor;
9625 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9626 type Value = RowMergeNode;
9627
9628 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9629 formatter.write_str("struct stream_plan.RowMergeNode")
9630 }
9631
9632 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowMergeNode, V::Error>
9633 where
9634 V: serde::de::MapAccess<'de>,
9635 {
9636 let mut lhs_mapping__ = None;
9637 let mut rhs_mapping__ = None;
9638 while let Some(k) = map_.next_key()? {
9639 match k {
9640 GeneratedField::LhsMapping => {
9641 if lhs_mapping__.is_some() {
9642 return Err(serde::de::Error::duplicate_field("lhsMapping"));
9643 }
9644 lhs_mapping__ = map_.next_value()?;
9645 }
9646 GeneratedField::RhsMapping => {
9647 if rhs_mapping__.is_some() {
9648 return Err(serde::de::Error::duplicate_field("rhsMapping"));
9649 }
9650 rhs_mapping__ = map_.next_value()?;
9651 }
9652 }
9653 }
9654 Ok(RowMergeNode {
9655 lhs_mapping: lhs_mapping__,
9656 rhs_mapping: rhs_mapping__,
9657 })
9658 }
9659 }
9660 deserializer.deserialize_struct("stream_plan.RowMergeNode", FIELDS, GeneratedVisitor)
9661 }
9662}
9663impl serde::Serialize for SimpleAggNode {
9664 #[allow(deprecated)]
9665 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9666 where
9667 S: serde::Serializer,
9668 {
9669 use serde::ser::SerializeStruct;
9670 let mut len = 0;
9671 if !self.agg_calls.is_empty() {
9672 len += 1;
9673 }
9674 if !self.agg_call_states.is_empty() {
9675 len += 1;
9676 }
9677 if self.intermediate_state_table.is_some() {
9678 len += 1;
9679 }
9680 if self.is_append_only {
9681 len += 1;
9682 }
9683 if !self.distinct_dedup_tables.is_empty() {
9684 len += 1;
9685 }
9686 if self.row_count_index != 0 {
9687 len += 1;
9688 }
9689 if self.version != 0 {
9690 len += 1;
9691 }
9692 if self.must_output_per_barrier {
9693 len += 1;
9694 }
9695 let mut struct_ser = serializer.serialize_struct("stream_plan.SimpleAggNode", len)?;
9696 if !self.agg_calls.is_empty() {
9697 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
9698 }
9699 if !self.agg_call_states.is_empty() {
9700 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
9701 }
9702 if let Some(v) = self.intermediate_state_table.as_ref() {
9703 struct_ser.serialize_field("intermediateStateTable", v)?;
9704 }
9705 if self.is_append_only {
9706 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
9707 }
9708 if !self.distinct_dedup_tables.is_empty() {
9709 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
9710 }
9711 if self.row_count_index != 0 {
9712 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
9713 }
9714 if self.version != 0 {
9715 let v = AggNodeVersion::try_from(self.version)
9716 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
9717 struct_ser.serialize_field("version", &v)?;
9718 }
9719 if self.must_output_per_barrier {
9720 struct_ser.serialize_field("mustOutputPerBarrier", &self.must_output_per_barrier)?;
9721 }
9722 struct_ser.end()
9723 }
9724}
9725impl<'de> serde::Deserialize<'de> for SimpleAggNode {
9726 #[allow(deprecated)]
9727 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9728 where
9729 D: serde::Deserializer<'de>,
9730 {
9731 const FIELDS: &[&str] = &[
9732 "agg_calls",
9733 "aggCalls",
9734 "agg_call_states",
9735 "aggCallStates",
9736 "intermediate_state_table",
9737 "intermediateStateTable",
9738 "is_append_only",
9739 "isAppendOnly",
9740 "distinct_dedup_tables",
9741 "distinctDedupTables",
9742 "row_count_index",
9743 "rowCountIndex",
9744 "version",
9745 "must_output_per_barrier",
9746 "mustOutputPerBarrier",
9747 ];
9748
9749 #[allow(clippy::enum_variant_names)]
9750 enum GeneratedField {
9751 AggCalls,
9752 AggCallStates,
9753 IntermediateStateTable,
9754 IsAppendOnly,
9755 DistinctDedupTables,
9756 RowCountIndex,
9757 Version,
9758 MustOutputPerBarrier,
9759 }
9760 impl<'de> serde::Deserialize<'de> for GeneratedField {
9761 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9762 where
9763 D: serde::Deserializer<'de>,
9764 {
9765 struct GeneratedVisitor;
9766
9767 impl serde::de::Visitor<'_> for GeneratedVisitor {
9768 type Value = GeneratedField;
9769
9770 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9771 write!(formatter, "expected one of: {:?}", &FIELDS)
9772 }
9773
9774 #[allow(unused_variables)]
9775 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9776 where
9777 E: serde::de::Error,
9778 {
9779 match value {
9780 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
9781 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
9782 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
9783 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
9784 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
9785 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
9786 "version" => Ok(GeneratedField::Version),
9787 "mustOutputPerBarrier" | "must_output_per_barrier" => Ok(GeneratedField::MustOutputPerBarrier),
9788 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9789 }
9790 }
9791 }
9792 deserializer.deserialize_identifier(GeneratedVisitor)
9793 }
9794 }
9795 struct GeneratedVisitor;
9796 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9797 type Value = SimpleAggNode;
9798
9799 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9800 formatter.write_str("struct stream_plan.SimpleAggNode")
9801 }
9802
9803 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SimpleAggNode, V::Error>
9804 where
9805 V: serde::de::MapAccess<'de>,
9806 {
9807 let mut agg_calls__ = None;
9808 let mut agg_call_states__ = None;
9809 let mut intermediate_state_table__ = None;
9810 let mut is_append_only__ = None;
9811 let mut distinct_dedup_tables__ = None;
9812 let mut row_count_index__ = None;
9813 let mut version__ = None;
9814 let mut must_output_per_barrier__ = None;
9815 while let Some(k) = map_.next_key()? {
9816 match k {
9817 GeneratedField::AggCalls => {
9818 if agg_calls__.is_some() {
9819 return Err(serde::de::Error::duplicate_field("aggCalls"));
9820 }
9821 agg_calls__ = Some(map_.next_value()?);
9822 }
9823 GeneratedField::AggCallStates => {
9824 if agg_call_states__.is_some() {
9825 return Err(serde::de::Error::duplicate_field("aggCallStates"));
9826 }
9827 agg_call_states__ = Some(map_.next_value()?);
9828 }
9829 GeneratedField::IntermediateStateTable => {
9830 if intermediate_state_table__.is_some() {
9831 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
9832 }
9833 intermediate_state_table__ = map_.next_value()?;
9834 }
9835 GeneratedField::IsAppendOnly => {
9836 if is_append_only__.is_some() {
9837 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
9838 }
9839 is_append_only__ = Some(map_.next_value()?);
9840 }
9841 GeneratedField::DistinctDedupTables => {
9842 if distinct_dedup_tables__.is_some() {
9843 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
9844 }
9845 distinct_dedup_tables__ = Some(
9846 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
9847 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
9848 );
9849 }
9850 GeneratedField::RowCountIndex => {
9851 if row_count_index__.is_some() {
9852 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
9853 }
9854 row_count_index__ =
9855 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9856 ;
9857 }
9858 GeneratedField::Version => {
9859 if version__.is_some() {
9860 return Err(serde::de::Error::duplicate_field("version"));
9861 }
9862 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
9863 }
9864 GeneratedField::MustOutputPerBarrier => {
9865 if must_output_per_barrier__.is_some() {
9866 return Err(serde::de::Error::duplicate_field("mustOutputPerBarrier"));
9867 }
9868 must_output_per_barrier__ = Some(map_.next_value()?);
9869 }
9870 }
9871 }
9872 Ok(SimpleAggNode {
9873 agg_calls: agg_calls__.unwrap_or_default(),
9874 agg_call_states: agg_call_states__.unwrap_or_default(),
9875 intermediate_state_table: intermediate_state_table__,
9876 is_append_only: is_append_only__.unwrap_or_default(),
9877 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
9878 row_count_index: row_count_index__.unwrap_or_default(),
9879 version: version__.unwrap_or_default(),
9880 must_output_per_barrier: must_output_per_barrier__.unwrap_or_default(),
9881 })
9882 }
9883 }
9884 deserializer.deserialize_struct("stream_plan.SimpleAggNode", FIELDS, GeneratedVisitor)
9885 }
9886}
9887impl serde::Serialize for SinkAddColumnsOp {
9888 #[allow(deprecated)]
9889 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9890 where
9891 S: serde::Serializer,
9892 {
9893 use serde::ser::SerializeStruct;
9894 let mut len = 0;
9895 if !self.fields.is_empty() {
9896 len += 1;
9897 }
9898 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkAddColumnsOp", len)?;
9899 if !self.fields.is_empty() {
9900 struct_ser.serialize_field("fields", &self.fields)?;
9901 }
9902 struct_ser.end()
9903 }
9904}
9905impl<'de> serde::Deserialize<'de> for SinkAddColumnsOp {
9906 #[allow(deprecated)]
9907 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9908 where
9909 D: serde::Deserializer<'de>,
9910 {
9911 const FIELDS: &[&str] = &[
9912 "fields",
9913 ];
9914
9915 #[allow(clippy::enum_variant_names)]
9916 enum GeneratedField {
9917 Fields,
9918 }
9919 impl<'de> serde::Deserialize<'de> for GeneratedField {
9920 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9921 where
9922 D: serde::Deserializer<'de>,
9923 {
9924 struct GeneratedVisitor;
9925
9926 impl serde::de::Visitor<'_> for GeneratedVisitor {
9927 type Value = GeneratedField;
9928
9929 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9930 write!(formatter, "expected one of: {:?}", &FIELDS)
9931 }
9932
9933 #[allow(unused_variables)]
9934 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9935 where
9936 E: serde::de::Error,
9937 {
9938 match value {
9939 "fields" => Ok(GeneratedField::Fields),
9940 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9941 }
9942 }
9943 }
9944 deserializer.deserialize_identifier(GeneratedVisitor)
9945 }
9946 }
9947 struct GeneratedVisitor;
9948 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9949 type Value = SinkAddColumnsOp;
9950
9951 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9952 formatter.write_str("struct stream_plan.SinkAddColumnsOp")
9953 }
9954
9955 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkAddColumnsOp, V::Error>
9956 where
9957 V: serde::de::MapAccess<'de>,
9958 {
9959 let mut fields__ = None;
9960 while let Some(k) = map_.next_key()? {
9961 match k {
9962 GeneratedField::Fields => {
9963 if fields__.is_some() {
9964 return Err(serde::de::Error::duplicate_field("fields"));
9965 }
9966 fields__ = Some(map_.next_value()?);
9967 }
9968 }
9969 }
9970 Ok(SinkAddColumnsOp {
9971 fields: fields__.unwrap_or_default(),
9972 })
9973 }
9974 }
9975 deserializer.deserialize_struct("stream_plan.SinkAddColumnsOp", FIELDS, GeneratedVisitor)
9976 }
9977}
9978impl serde::Serialize for SinkDesc {
9979 #[allow(deprecated)]
9980 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9981 where
9982 S: serde::Serializer,
9983 {
9984 use serde::ser::SerializeStruct;
9985 let mut len = 0;
9986 if self.id != 0 {
9987 len += 1;
9988 }
9989 if !self.name.is_empty() {
9990 len += 1;
9991 }
9992 if !self.definition.is_empty() {
9993 len += 1;
9994 }
9995 if !self.plan_pk.is_empty() {
9996 len += 1;
9997 }
9998 if !self.downstream_pk.is_empty() {
9999 len += 1;
10000 }
10001 if !self.distribution_key.is_empty() {
10002 len += 1;
10003 }
10004 if !self.properties.is_empty() {
10005 len += 1;
10006 }
10007 if self.sink_type != 0 {
10008 len += 1;
10009 }
10010 if !self.column_catalogs.is_empty() {
10011 len += 1;
10012 }
10013 if !self.db_name.is_empty() {
10014 len += 1;
10015 }
10016 if !self.sink_from_name.is_empty() {
10017 len += 1;
10018 }
10019 if self.format_desc.is_some() {
10020 len += 1;
10021 }
10022 if self.target_table.is_some() {
10023 len += 1;
10024 }
10025 if self.extra_partition_col_idx.is_some() {
10026 len += 1;
10027 }
10028 if !self.secret_refs.is_empty() {
10029 len += 1;
10030 }
10031 if self.raw_ignore_delete {
10032 len += 1;
10033 }
10034 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDesc", len)?;
10035 if self.id != 0 {
10036 struct_ser.serialize_field("id", &self.id)?;
10037 }
10038 if !self.name.is_empty() {
10039 struct_ser.serialize_field("name", &self.name)?;
10040 }
10041 if !self.definition.is_empty() {
10042 struct_ser.serialize_field("definition", &self.definition)?;
10043 }
10044 if !self.plan_pk.is_empty() {
10045 struct_ser.serialize_field("planPk", &self.plan_pk)?;
10046 }
10047 if !self.downstream_pk.is_empty() {
10048 struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
10049 }
10050 if !self.distribution_key.is_empty() {
10051 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
10052 }
10053 if !self.properties.is_empty() {
10054 struct_ser.serialize_field("properties", &self.properties)?;
10055 }
10056 if self.sink_type != 0 {
10057 let v = super::catalog::SinkType::try_from(self.sink_type)
10058 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
10059 struct_ser.serialize_field("sinkType", &v)?;
10060 }
10061 if !self.column_catalogs.is_empty() {
10062 struct_ser.serialize_field("columnCatalogs", &self.column_catalogs)?;
10063 }
10064 if !self.db_name.is_empty() {
10065 struct_ser.serialize_field("dbName", &self.db_name)?;
10066 }
10067 if !self.sink_from_name.is_empty() {
10068 struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
10069 }
10070 if let Some(v) = self.format_desc.as_ref() {
10071 struct_ser.serialize_field("formatDesc", v)?;
10072 }
10073 if let Some(v) = self.target_table.as_ref() {
10074 struct_ser.serialize_field("targetTable", v)?;
10075 }
10076 if let Some(v) = self.extra_partition_col_idx.as_ref() {
10077 #[allow(clippy::needless_borrow)]
10078 #[allow(clippy::needless_borrows_for_generic_args)]
10079 struct_ser.serialize_field("extraPartitionColIdx", ToString::to_string(&v).as_str())?;
10080 }
10081 if !self.secret_refs.is_empty() {
10082 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
10083 }
10084 if self.raw_ignore_delete {
10085 struct_ser.serialize_field("rawIgnoreDelete", &self.raw_ignore_delete)?;
10086 }
10087 struct_ser.end()
10088 }
10089}
10090impl<'de> serde::Deserialize<'de> for SinkDesc {
10091 #[allow(deprecated)]
10092 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10093 where
10094 D: serde::Deserializer<'de>,
10095 {
10096 const FIELDS: &[&str] = &[
10097 "id",
10098 "name",
10099 "definition",
10100 "plan_pk",
10101 "planPk",
10102 "downstream_pk",
10103 "downstreamPk",
10104 "distribution_key",
10105 "distributionKey",
10106 "properties",
10107 "sink_type",
10108 "sinkType",
10109 "column_catalogs",
10110 "columnCatalogs",
10111 "db_name",
10112 "dbName",
10113 "sink_from_name",
10114 "sinkFromName",
10115 "format_desc",
10116 "formatDesc",
10117 "target_table",
10118 "targetTable",
10119 "extra_partition_col_idx",
10120 "extraPartitionColIdx",
10121 "secret_refs",
10122 "secretRefs",
10123 "raw_ignore_delete",
10124 "rawIgnoreDelete",
10125 ];
10126
10127 #[allow(clippy::enum_variant_names)]
10128 enum GeneratedField {
10129 Id,
10130 Name,
10131 Definition,
10132 PlanPk,
10133 DownstreamPk,
10134 DistributionKey,
10135 Properties,
10136 SinkType,
10137 ColumnCatalogs,
10138 DbName,
10139 SinkFromName,
10140 FormatDesc,
10141 TargetTable,
10142 ExtraPartitionColIdx,
10143 SecretRefs,
10144 RawIgnoreDelete,
10145 }
10146 impl<'de> serde::Deserialize<'de> for GeneratedField {
10147 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10148 where
10149 D: serde::Deserializer<'de>,
10150 {
10151 struct GeneratedVisitor;
10152
10153 impl serde::de::Visitor<'_> for GeneratedVisitor {
10154 type Value = GeneratedField;
10155
10156 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10157 write!(formatter, "expected one of: {:?}", &FIELDS)
10158 }
10159
10160 #[allow(unused_variables)]
10161 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10162 where
10163 E: serde::de::Error,
10164 {
10165 match value {
10166 "id" => Ok(GeneratedField::Id),
10167 "name" => Ok(GeneratedField::Name),
10168 "definition" => Ok(GeneratedField::Definition),
10169 "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
10170 "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
10171 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
10172 "properties" => Ok(GeneratedField::Properties),
10173 "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
10174 "columnCatalogs" | "column_catalogs" => Ok(GeneratedField::ColumnCatalogs),
10175 "dbName" | "db_name" => Ok(GeneratedField::DbName),
10176 "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
10177 "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
10178 "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
10179 "extraPartitionColIdx" | "extra_partition_col_idx" => Ok(GeneratedField::ExtraPartitionColIdx),
10180 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
10181 "rawIgnoreDelete" | "raw_ignore_delete" => Ok(GeneratedField::RawIgnoreDelete),
10182 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10183 }
10184 }
10185 }
10186 deserializer.deserialize_identifier(GeneratedVisitor)
10187 }
10188 }
10189 struct GeneratedVisitor;
10190 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10191 type Value = SinkDesc;
10192
10193 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10194 formatter.write_str("struct stream_plan.SinkDesc")
10195 }
10196
10197 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDesc, V::Error>
10198 where
10199 V: serde::de::MapAccess<'de>,
10200 {
10201 let mut id__ = None;
10202 let mut name__ = None;
10203 let mut definition__ = None;
10204 let mut plan_pk__ = None;
10205 let mut downstream_pk__ = None;
10206 let mut distribution_key__ = None;
10207 let mut properties__ = None;
10208 let mut sink_type__ = None;
10209 let mut column_catalogs__ = None;
10210 let mut db_name__ = None;
10211 let mut sink_from_name__ = None;
10212 let mut format_desc__ = None;
10213 let mut target_table__ = None;
10214 let mut extra_partition_col_idx__ = None;
10215 let mut secret_refs__ = None;
10216 let mut raw_ignore_delete__ = None;
10217 while let Some(k) = map_.next_key()? {
10218 match k {
10219 GeneratedField::Id => {
10220 if id__.is_some() {
10221 return Err(serde::de::Error::duplicate_field("id"));
10222 }
10223 id__ =
10224 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10225 ;
10226 }
10227 GeneratedField::Name => {
10228 if name__.is_some() {
10229 return Err(serde::de::Error::duplicate_field("name"));
10230 }
10231 name__ = Some(map_.next_value()?);
10232 }
10233 GeneratedField::Definition => {
10234 if definition__.is_some() {
10235 return Err(serde::de::Error::duplicate_field("definition"));
10236 }
10237 definition__ = Some(map_.next_value()?);
10238 }
10239 GeneratedField::PlanPk => {
10240 if plan_pk__.is_some() {
10241 return Err(serde::de::Error::duplicate_field("planPk"));
10242 }
10243 plan_pk__ = Some(map_.next_value()?);
10244 }
10245 GeneratedField::DownstreamPk => {
10246 if downstream_pk__.is_some() {
10247 return Err(serde::de::Error::duplicate_field("downstreamPk"));
10248 }
10249 downstream_pk__ =
10250 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10251 .into_iter().map(|x| x.0).collect())
10252 ;
10253 }
10254 GeneratedField::DistributionKey => {
10255 if distribution_key__.is_some() {
10256 return Err(serde::de::Error::duplicate_field("distributionKey"));
10257 }
10258 distribution_key__ =
10259 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10260 .into_iter().map(|x| x.0).collect())
10261 ;
10262 }
10263 GeneratedField::Properties => {
10264 if properties__.is_some() {
10265 return Err(serde::de::Error::duplicate_field("properties"));
10266 }
10267 properties__ = Some(
10268 map_.next_value::<std::collections::BTreeMap<_, _>>()?
10269 );
10270 }
10271 GeneratedField::SinkType => {
10272 if sink_type__.is_some() {
10273 return Err(serde::de::Error::duplicate_field("sinkType"));
10274 }
10275 sink_type__ = Some(map_.next_value::<super::catalog::SinkType>()? as i32);
10276 }
10277 GeneratedField::ColumnCatalogs => {
10278 if column_catalogs__.is_some() {
10279 return Err(serde::de::Error::duplicate_field("columnCatalogs"));
10280 }
10281 column_catalogs__ = Some(map_.next_value()?);
10282 }
10283 GeneratedField::DbName => {
10284 if db_name__.is_some() {
10285 return Err(serde::de::Error::duplicate_field("dbName"));
10286 }
10287 db_name__ = Some(map_.next_value()?);
10288 }
10289 GeneratedField::SinkFromName => {
10290 if sink_from_name__.is_some() {
10291 return Err(serde::de::Error::duplicate_field("sinkFromName"));
10292 }
10293 sink_from_name__ = Some(map_.next_value()?);
10294 }
10295 GeneratedField::FormatDesc => {
10296 if format_desc__.is_some() {
10297 return Err(serde::de::Error::duplicate_field("formatDesc"));
10298 }
10299 format_desc__ = map_.next_value()?;
10300 }
10301 GeneratedField::TargetTable => {
10302 if target_table__.is_some() {
10303 return Err(serde::de::Error::duplicate_field("targetTable"));
10304 }
10305 target_table__ =
10306 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10307 ;
10308 }
10309 GeneratedField::ExtraPartitionColIdx => {
10310 if extra_partition_col_idx__.is_some() {
10311 return Err(serde::de::Error::duplicate_field("extraPartitionColIdx"));
10312 }
10313 extra_partition_col_idx__ =
10314 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10315 ;
10316 }
10317 GeneratedField::SecretRefs => {
10318 if secret_refs__.is_some() {
10319 return Err(serde::de::Error::duplicate_field("secretRefs"));
10320 }
10321 secret_refs__ = Some(
10322 map_.next_value::<std::collections::BTreeMap<_, _>>()?
10323 );
10324 }
10325 GeneratedField::RawIgnoreDelete => {
10326 if raw_ignore_delete__.is_some() {
10327 return Err(serde::de::Error::duplicate_field("rawIgnoreDelete"));
10328 }
10329 raw_ignore_delete__ = Some(map_.next_value()?);
10330 }
10331 }
10332 }
10333 Ok(SinkDesc {
10334 id: id__.unwrap_or_default(),
10335 name: name__.unwrap_or_default(),
10336 definition: definition__.unwrap_or_default(),
10337 plan_pk: plan_pk__.unwrap_or_default(),
10338 downstream_pk: downstream_pk__.unwrap_or_default(),
10339 distribution_key: distribution_key__.unwrap_or_default(),
10340 properties: properties__.unwrap_or_default(),
10341 sink_type: sink_type__.unwrap_or_default(),
10342 column_catalogs: column_catalogs__.unwrap_or_default(),
10343 db_name: db_name__.unwrap_or_default(),
10344 sink_from_name: sink_from_name__.unwrap_or_default(),
10345 format_desc: format_desc__,
10346 target_table: target_table__,
10347 extra_partition_col_idx: extra_partition_col_idx__,
10348 secret_refs: secret_refs__.unwrap_or_default(),
10349 raw_ignore_delete: raw_ignore_delete__.unwrap_or_default(),
10350 })
10351 }
10352 }
10353 deserializer.deserialize_struct("stream_plan.SinkDesc", FIELDS, GeneratedVisitor)
10354 }
10355}
10356impl serde::Serialize for SinkDropColumnsOp {
10357 #[allow(deprecated)]
10358 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10359 where
10360 S: serde::Serializer,
10361 {
10362 use serde::ser::SerializeStruct;
10363 let mut len = 0;
10364 if !self.column_names.is_empty() {
10365 len += 1;
10366 }
10367 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDropColumnsOp", len)?;
10368 if !self.column_names.is_empty() {
10369 struct_ser.serialize_field("columnNames", &self.column_names)?;
10370 }
10371 struct_ser.end()
10372 }
10373}
10374impl<'de> serde::Deserialize<'de> for SinkDropColumnsOp {
10375 #[allow(deprecated)]
10376 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10377 where
10378 D: serde::Deserializer<'de>,
10379 {
10380 const FIELDS: &[&str] = &[
10381 "column_names",
10382 "columnNames",
10383 ];
10384
10385 #[allow(clippy::enum_variant_names)]
10386 enum GeneratedField {
10387 ColumnNames,
10388 }
10389 impl<'de> serde::Deserialize<'de> for GeneratedField {
10390 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10391 where
10392 D: serde::Deserializer<'de>,
10393 {
10394 struct GeneratedVisitor;
10395
10396 impl serde::de::Visitor<'_> for GeneratedVisitor {
10397 type Value = GeneratedField;
10398
10399 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10400 write!(formatter, "expected one of: {:?}", &FIELDS)
10401 }
10402
10403 #[allow(unused_variables)]
10404 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10405 where
10406 E: serde::de::Error,
10407 {
10408 match value {
10409 "columnNames" | "column_names" => Ok(GeneratedField::ColumnNames),
10410 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10411 }
10412 }
10413 }
10414 deserializer.deserialize_identifier(GeneratedVisitor)
10415 }
10416 }
10417 struct GeneratedVisitor;
10418 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10419 type Value = SinkDropColumnsOp;
10420
10421 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10422 formatter.write_str("struct stream_plan.SinkDropColumnsOp")
10423 }
10424
10425 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDropColumnsOp, V::Error>
10426 where
10427 V: serde::de::MapAccess<'de>,
10428 {
10429 let mut column_names__ = None;
10430 while let Some(k) = map_.next_key()? {
10431 match k {
10432 GeneratedField::ColumnNames => {
10433 if column_names__.is_some() {
10434 return Err(serde::de::Error::duplicate_field("columnNames"));
10435 }
10436 column_names__ = Some(map_.next_value()?);
10437 }
10438 }
10439 }
10440 Ok(SinkDropColumnsOp {
10441 column_names: column_names__.unwrap_or_default(),
10442 })
10443 }
10444 }
10445 deserializer.deserialize_struct("stream_plan.SinkDropColumnsOp", FIELDS, GeneratedVisitor)
10446 }
10447}
10448impl serde::Serialize for SinkLogStoreType {
10449 #[allow(deprecated)]
10450 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10451 where
10452 S: serde::Serializer,
10453 {
10454 let variant = match self {
10455 Self::Unspecified => "SINK_LOG_STORE_TYPE_UNSPECIFIED",
10456 Self::KvLogStore => "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
10457 Self::InMemoryLogStore => "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
10458 };
10459 serializer.serialize_str(variant)
10460 }
10461}
10462impl<'de> serde::Deserialize<'de> for SinkLogStoreType {
10463 #[allow(deprecated)]
10464 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10465 where
10466 D: serde::Deserializer<'de>,
10467 {
10468 const FIELDS: &[&str] = &[
10469 "SINK_LOG_STORE_TYPE_UNSPECIFIED",
10470 "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
10471 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
10472 ];
10473
10474 struct GeneratedVisitor;
10475
10476 impl serde::de::Visitor<'_> for GeneratedVisitor {
10477 type Value = SinkLogStoreType;
10478
10479 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10480 write!(formatter, "expected one of: {:?}", &FIELDS)
10481 }
10482
10483 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
10484 where
10485 E: serde::de::Error,
10486 {
10487 i32::try_from(v)
10488 .ok()
10489 .and_then(|x| x.try_into().ok())
10490 .ok_or_else(|| {
10491 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
10492 })
10493 }
10494
10495 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
10496 where
10497 E: serde::de::Error,
10498 {
10499 i32::try_from(v)
10500 .ok()
10501 .and_then(|x| x.try_into().ok())
10502 .ok_or_else(|| {
10503 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
10504 })
10505 }
10506
10507 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
10508 where
10509 E: serde::de::Error,
10510 {
10511 match value {
10512 "SINK_LOG_STORE_TYPE_UNSPECIFIED" => Ok(SinkLogStoreType::Unspecified),
10513 "SINK_LOG_STORE_TYPE_KV_LOG_STORE" => Ok(SinkLogStoreType::KvLogStore),
10514 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE" => Ok(SinkLogStoreType::InMemoryLogStore),
10515 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
10516 }
10517 }
10518 }
10519 deserializer.deserialize_any(GeneratedVisitor)
10520 }
10521}
10522impl serde::Serialize for SinkNode {
10523 #[allow(deprecated)]
10524 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10525 where
10526 S: serde::Serializer,
10527 {
10528 use serde::ser::SerializeStruct;
10529 let mut len = 0;
10530 if self.sink_desc.is_some() {
10531 len += 1;
10532 }
10533 if self.table.is_some() {
10534 len += 1;
10535 }
10536 if self.log_store_type != 0 {
10537 len += 1;
10538 }
10539 if self.rate_limit.is_some() {
10540 len += 1;
10541 }
10542 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkNode", len)?;
10543 if let Some(v) = self.sink_desc.as_ref() {
10544 struct_ser.serialize_field("sinkDesc", v)?;
10545 }
10546 if let Some(v) = self.table.as_ref() {
10547 struct_ser.serialize_field("table", v)?;
10548 }
10549 if self.log_store_type != 0 {
10550 let v = SinkLogStoreType::try_from(self.log_store_type)
10551 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.log_store_type)))?;
10552 struct_ser.serialize_field("logStoreType", &v)?;
10553 }
10554 if let Some(v) = self.rate_limit.as_ref() {
10555 struct_ser.serialize_field("rateLimit", v)?;
10556 }
10557 struct_ser.end()
10558 }
10559}
10560impl<'de> serde::Deserialize<'de> for SinkNode {
10561 #[allow(deprecated)]
10562 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10563 where
10564 D: serde::Deserializer<'de>,
10565 {
10566 const FIELDS: &[&str] = &[
10567 "sink_desc",
10568 "sinkDesc",
10569 "table",
10570 "log_store_type",
10571 "logStoreType",
10572 "rate_limit",
10573 "rateLimit",
10574 ];
10575
10576 #[allow(clippy::enum_variant_names)]
10577 enum GeneratedField {
10578 SinkDesc,
10579 Table,
10580 LogStoreType,
10581 RateLimit,
10582 }
10583 impl<'de> serde::Deserialize<'de> for GeneratedField {
10584 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10585 where
10586 D: serde::Deserializer<'de>,
10587 {
10588 struct GeneratedVisitor;
10589
10590 impl serde::de::Visitor<'_> for GeneratedVisitor {
10591 type Value = GeneratedField;
10592
10593 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10594 write!(formatter, "expected one of: {:?}", &FIELDS)
10595 }
10596
10597 #[allow(unused_variables)]
10598 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10599 where
10600 E: serde::de::Error,
10601 {
10602 match value {
10603 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
10604 "table" => Ok(GeneratedField::Table),
10605 "logStoreType" | "log_store_type" => Ok(GeneratedField::LogStoreType),
10606 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
10607 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10608 }
10609 }
10610 }
10611 deserializer.deserialize_identifier(GeneratedVisitor)
10612 }
10613 }
10614 struct GeneratedVisitor;
10615 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10616 type Value = SinkNode;
10617
10618 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10619 formatter.write_str("struct stream_plan.SinkNode")
10620 }
10621
10622 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkNode, V::Error>
10623 where
10624 V: serde::de::MapAccess<'de>,
10625 {
10626 let mut sink_desc__ = None;
10627 let mut table__ = None;
10628 let mut log_store_type__ = None;
10629 let mut rate_limit__ = None;
10630 while let Some(k) = map_.next_key()? {
10631 match k {
10632 GeneratedField::SinkDesc => {
10633 if sink_desc__.is_some() {
10634 return Err(serde::de::Error::duplicate_field("sinkDesc"));
10635 }
10636 sink_desc__ = map_.next_value()?;
10637 }
10638 GeneratedField::Table => {
10639 if table__.is_some() {
10640 return Err(serde::de::Error::duplicate_field("table"));
10641 }
10642 table__ = map_.next_value()?;
10643 }
10644 GeneratedField::LogStoreType => {
10645 if log_store_type__.is_some() {
10646 return Err(serde::de::Error::duplicate_field("logStoreType"));
10647 }
10648 log_store_type__ = Some(map_.next_value::<SinkLogStoreType>()? as i32);
10649 }
10650 GeneratedField::RateLimit => {
10651 if rate_limit__.is_some() {
10652 return Err(serde::de::Error::duplicate_field("rateLimit"));
10653 }
10654 rate_limit__ =
10655 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10656 ;
10657 }
10658 }
10659 }
10660 Ok(SinkNode {
10661 sink_desc: sink_desc__,
10662 table: table__,
10663 log_store_type: log_store_type__.unwrap_or_default(),
10664 rate_limit: rate_limit__,
10665 })
10666 }
10667 }
10668 deserializer.deserialize_struct("stream_plan.SinkNode", FIELDS, GeneratedVisitor)
10669 }
10670}
10671impl serde::Serialize for SinkSchemaChange {
10672 #[allow(deprecated)]
10673 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10674 where
10675 S: serde::Serializer,
10676 {
10677 use serde::ser::SerializeStruct;
10678 let mut len = 0;
10679 if !self.original_schema.is_empty() {
10680 len += 1;
10681 }
10682 if self.op.is_some() {
10683 len += 1;
10684 }
10685 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkSchemaChange", len)?;
10686 if !self.original_schema.is_empty() {
10687 struct_ser.serialize_field("originalSchema", &self.original_schema)?;
10688 }
10689 if let Some(v) = self.op.as_ref() {
10690 match v {
10691 sink_schema_change::Op::AddColumns(v) => {
10692 struct_ser.serialize_field("addColumns", v)?;
10693 }
10694 sink_schema_change::Op::DropColumns(v) => {
10695 struct_ser.serialize_field("dropColumns", v)?;
10696 }
10697 }
10698 }
10699 struct_ser.end()
10700 }
10701}
10702impl<'de> serde::Deserialize<'de> for SinkSchemaChange {
10703 #[allow(deprecated)]
10704 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10705 where
10706 D: serde::Deserializer<'de>,
10707 {
10708 const FIELDS: &[&str] = &[
10709 "original_schema",
10710 "originalSchema",
10711 "add_columns",
10712 "addColumns",
10713 "drop_columns",
10714 "dropColumns",
10715 ];
10716
10717 #[allow(clippy::enum_variant_names)]
10718 enum GeneratedField {
10719 OriginalSchema,
10720 AddColumns,
10721 DropColumns,
10722 }
10723 impl<'de> serde::Deserialize<'de> for GeneratedField {
10724 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10725 where
10726 D: serde::Deserializer<'de>,
10727 {
10728 struct GeneratedVisitor;
10729
10730 impl serde::de::Visitor<'_> for GeneratedVisitor {
10731 type Value = GeneratedField;
10732
10733 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10734 write!(formatter, "expected one of: {:?}", &FIELDS)
10735 }
10736
10737 #[allow(unused_variables)]
10738 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10739 where
10740 E: serde::de::Error,
10741 {
10742 match value {
10743 "originalSchema" | "original_schema" => Ok(GeneratedField::OriginalSchema),
10744 "addColumns" | "add_columns" => Ok(GeneratedField::AddColumns),
10745 "dropColumns" | "drop_columns" => Ok(GeneratedField::DropColumns),
10746 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10747 }
10748 }
10749 }
10750 deserializer.deserialize_identifier(GeneratedVisitor)
10751 }
10752 }
10753 struct GeneratedVisitor;
10754 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10755 type Value = SinkSchemaChange;
10756
10757 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10758 formatter.write_str("struct stream_plan.SinkSchemaChange")
10759 }
10760
10761 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkSchemaChange, V::Error>
10762 where
10763 V: serde::de::MapAccess<'de>,
10764 {
10765 let mut original_schema__ = None;
10766 let mut op__ = None;
10767 while let Some(k) = map_.next_key()? {
10768 match k {
10769 GeneratedField::OriginalSchema => {
10770 if original_schema__.is_some() {
10771 return Err(serde::de::Error::duplicate_field("originalSchema"));
10772 }
10773 original_schema__ = Some(map_.next_value()?);
10774 }
10775 GeneratedField::AddColumns => {
10776 if op__.is_some() {
10777 return Err(serde::de::Error::duplicate_field("addColumns"));
10778 }
10779 op__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_schema_change::Op::AddColumns)
10780;
10781 }
10782 GeneratedField::DropColumns => {
10783 if op__.is_some() {
10784 return Err(serde::de::Error::duplicate_field("dropColumns"));
10785 }
10786 op__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_schema_change::Op::DropColumns)
10787;
10788 }
10789 }
10790 }
10791 Ok(SinkSchemaChange {
10792 original_schema: original_schema__.unwrap_or_default(),
10793 op: op__,
10794 })
10795 }
10796 }
10797 deserializer.deserialize_struct("stream_plan.SinkSchemaChange", FIELDS, GeneratedVisitor)
10798 }
10799}
10800impl serde::Serialize for SortNode {
10801 #[allow(deprecated)]
10802 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10803 where
10804 S: serde::Serializer,
10805 {
10806 use serde::ser::SerializeStruct;
10807 let mut len = 0;
10808 if self.state_table.is_some() {
10809 len += 1;
10810 }
10811 if self.sort_column_index != 0 {
10812 len += 1;
10813 }
10814 let mut struct_ser = serializer.serialize_struct("stream_plan.SortNode", len)?;
10815 if let Some(v) = self.state_table.as_ref() {
10816 struct_ser.serialize_field("stateTable", v)?;
10817 }
10818 if self.sort_column_index != 0 {
10819 struct_ser.serialize_field("sortColumnIndex", &self.sort_column_index)?;
10820 }
10821 struct_ser.end()
10822 }
10823}
10824impl<'de> serde::Deserialize<'de> for SortNode {
10825 #[allow(deprecated)]
10826 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10827 where
10828 D: serde::Deserializer<'de>,
10829 {
10830 const FIELDS: &[&str] = &[
10831 "state_table",
10832 "stateTable",
10833 "sort_column_index",
10834 "sortColumnIndex",
10835 ];
10836
10837 #[allow(clippy::enum_variant_names)]
10838 enum GeneratedField {
10839 StateTable,
10840 SortColumnIndex,
10841 }
10842 impl<'de> serde::Deserialize<'de> for GeneratedField {
10843 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10844 where
10845 D: serde::Deserializer<'de>,
10846 {
10847 struct GeneratedVisitor;
10848
10849 impl serde::de::Visitor<'_> for GeneratedVisitor {
10850 type Value = GeneratedField;
10851
10852 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10853 write!(formatter, "expected one of: {:?}", &FIELDS)
10854 }
10855
10856 #[allow(unused_variables)]
10857 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10858 where
10859 E: serde::de::Error,
10860 {
10861 match value {
10862 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
10863 "sortColumnIndex" | "sort_column_index" => Ok(GeneratedField::SortColumnIndex),
10864 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10865 }
10866 }
10867 }
10868 deserializer.deserialize_identifier(GeneratedVisitor)
10869 }
10870 }
10871 struct GeneratedVisitor;
10872 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10873 type Value = SortNode;
10874
10875 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10876 formatter.write_str("struct stream_plan.SortNode")
10877 }
10878
10879 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
10880 where
10881 V: serde::de::MapAccess<'de>,
10882 {
10883 let mut state_table__ = None;
10884 let mut sort_column_index__ = None;
10885 while let Some(k) = map_.next_key()? {
10886 match k {
10887 GeneratedField::StateTable => {
10888 if state_table__.is_some() {
10889 return Err(serde::de::Error::duplicate_field("stateTable"));
10890 }
10891 state_table__ = map_.next_value()?;
10892 }
10893 GeneratedField::SortColumnIndex => {
10894 if sort_column_index__.is_some() {
10895 return Err(serde::de::Error::duplicate_field("sortColumnIndex"));
10896 }
10897 sort_column_index__ =
10898 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10899 ;
10900 }
10901 }
10902 }
10903 Ok(SortNode {
10904 state_table: state_table__,
10905 sort_column_index: sort_column_index__.unwrap_or_default(),
10906 })
10907 }
10908 }
10909 deserializer.deserialize_struct("stream_plan.SortNode", FIELDS, GeneratedVisitor)
10910 }
10911}
10912impl serde::Serialize for SourceBackfillNode {
10913 #[allow(deprecated)]
10914 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10915 where
10916 S: serde::Serializer,
10917 {
10918 use serde::ser::SerializeStruct;
10919 let mut len = 0;
10920 if self.upstream_source_id != 0 {
10921 len += 1;
10922 }
10923 if self.row_id_index.is_some() {
10924 len += 1;
10925 }
10926 if !self.columns.is_empty() {
10927 len += 1;
10928 }
10929 if self.info.is_some() {
10930 len += 1;
10931 }
10932 if !self.source_name.is_empty() {
10933 len += 1;
10934 }
10935 if !self.with_properties.is_empty() {
10936 len += 1;
10937 }
10938 if self.rate_limit.is_some() {
10939 len += 1;
10940 }
10941 if self.state_table.is_some() {
10942 len += 1;
10943 }
10944 if !self.secret_refs.is_empty() {
10945 len += 1;
10946 }
10947 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceBackfillNode", len)?;
10948 if self.upstream_source_id != 0 {
10949 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
10950 }
10951 if let Some(v) = self.row_id_index.as_ref() {
10952 struct_ser.serialize_field("rowIdIndex", v)?;
10953 }
10954 if !self.columns.is_empty() {
10955 struct_ser.serialize_field("columns", &self.columns)?;
10956 }
10957 if let Some(v) = self.info.as_ref() {
10958 struct_ser.serialize_field("info", v)?;
10959 }
10960 if !self.source_name.is_empty() {
10961 struct_ser.serialize_field("sourceName", &self.source_name)?;
10962 }
10963 if !self.with_properties.is_empty() {
10964 struct_ser.serialize_field("withProperties", &self.with_properties)?;
10965 }
10966 if let Some(v) = self.rate_limit.as_ref() {
10967 struct_ser.serialize_field("rateLimit", v)?;
10968 }
10969 if let Some(v) = self.state_table.as_ref() {
10970 struct_ser.serialize_field("stateTable", v)?;
10971 }
10972 if !self.secret_refs.is_empty() {
10973 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
10974 }
10975 struct_ser.end()
10976 }
10977}
10978impl<'de> serde::Deserialize<'de> for SourceBackfillNode {
10979 #[allow(deprecated)]
10980 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10981 where
10982 D: serde::Deserializer<'de>,
10983 {
10984 const FIELDS: &[&str] = &[
10985 "upstream_source_id",
10986 "upstreamSourceId",
10987 "row_id_index",
10988 "rowIdIndex",
10989 "columns",
10990 "info",
10991 "source_name",
10992 "sourceName",
10993 "with_properties",
10994 "withProperties",
10995 "rate_limit",
10996 "rateLimit",
10997 "state_table",
10998 "stateTable",
10999 "secret_refs",
11000 "secretRefs",
11001 ];
11002
11003 #[allow(clippy::enum_variant_names)]
11004 enum GeneratedField {
11005 UpstreamSourceId,
11006 RowIdIndex,
11007 Columns,
11008 Info,
11009 SourceName,
11010 WithProperties,
11011 RateLimit,
11012 StateTable,
11013 SecretRefs,
11014 }
11015 impl<'de> serde::Deserialize<'de> for GeneratedField {
11016 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11017 where
11018 D: serde::Deserializer<'de>,
11019 {
11020 struct GeneratedVisitor;
11021
11022 impl serde::de::Visitor<'_> for GeneratedVisitor {
11023 type Value = GeneratedField;
11024
11025 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11026 write!(formatter, "expected one of: {:?}", &FIELDS)
11027 }
11028
11029 #[allow(unused_variables)]
11030 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11031 where
11032 E: serde::de::Error,
11033 {
11034 match value {
11035 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
11036 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
11037 "columns" => Ok(GeneratedField::Columns),
11038 "info" => Ok(GeneratedField::Info),
11039 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
11040 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
11041 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11042 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11043 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
11044 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11045 }
11046 }
11047 }
11048 deserializer.deserialize_identifier(GeneratedVisitor)
11049 }
11050 }
11051 struct GeneratedVisitor;
11052 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11053 type Value = SourceBackfillNode;
11054
11055 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11056 formatter.write_str("struct stream_plan.SourceBackfillNode")
11057 }
11058
11059 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceBackfillNode, V::Error>
11060 where
11061 V: serde::de::MapAccess<'de>,
11062 {
11063 let mut upstream_source_id__ = None;
11064 let mut row_id_index__ = None;
11065 let mut columns__ = None;
11066 let mut info__ = None;
11067 let mut source_name__ = None;
11068 let mut with_properties__ = None;
11069 let mut rate_limit__ = None;
11070 let mut state_table__ = None;
11071 let mut secret_refs__ = None;
11072 while let Some(k) = map_.next_key()? {
11073 match k {
11074 GeneratedField::UpstreamSourceId => {
11075 if upstream_source_id__.is_some() {
11076 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
11077 }
11078 upstream_source_id__ =
11079 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11080 ;
11081 }
11082 GeneratedField::RowIdIndex => {
11083 if row_id_index__.is_some() {
11084 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
11085 }
11086 row_id_index__ =
11087 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11088 ;
11089 }
11090 GeneratedField::Columns => {
11091 if columns__.is_some() {
11092 return Err(serde::de::Error::duplicate_field("columns"));
11093 }
11094 columns__ = Some(map_.next_value()?);
11095 }
11096 GeneratedField::Info => {
11097 if info__.is_some() {
11098 return Err(serde::de::Error::duplicate_field("info"));
11099 }
11100 info__ = map_.next_value()?;
11101 }
11102 GeneratedField::SourceName => {
11103 if source_name__.is_some() {
11104 return Err(serde::de::Error::duplicate_field("sourceName"));
11105 }
11106 source_name__ = Some(map_.next_value()?);
11107 }
11108 GeneratedField::WithProperties => {
11109 if with_properties__.is_some() {
11110 return Err(serde::de::Error::duplicate_field("withProperties"));
11111 }
11112 with_properties__ = Some(
11113 map_.next_value::<std::collections::BTreeMap<_, _>>()?
11114 );
11115 }
11116 GeneratedField::RateLimit => {
11117 if rate_limit__.is_some() {
11118 return Err(serde::de::Error::duplicate_field("rateLimit"));
11119 }
11120 rate_limit__ =
11121 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11122 ;
11123 }
11124 GeneratedField::StateTable => {
11125 if state_table__.is_some() {
11126 return Err(serde::de::Error::duplicate_field("stateTable"));
11127 }
11128 state_table__ = map_.next_value()?;
11129 }
11130 GeneratedField::SecretRefs => {
11131 if secret_refs__.is_some() {
11132 return Err(serde::de::Error::duplicate_field("secretRefs"));
11133 }
11134 secret_refs__ = Some(
11135 map_.next_value::<std::collections::BTreeMap<_, _>>()?
11136 );
11137 }
11138 }
11139 }
11140 Ok(SourceBackfillNode {
11141 upstream_source_id: upstream_source_id__.unwrap_or_default(),
11142 row_id_index: row_id_index__,
11143 columns: columns__.unwrap_or_default(),
11144 info: info__,
11145 source_name: source_name__.unwrap_or_default(),
11146 with_properties: with_properties__.unwrap_or_default(),
11147 rate_limit: rate_limit__,
11148 state_table: state_table__,
11149 secret_refs: secret_refs__.unwrap_or_default(),
11150 })
11151 }
11152 }
11153 deserializer.deserialize_struct("stream_plan.SourceBackfillNode", FIELDS, GeneratedVisitor)
11154 }
11155}
11156impl serde::Serialize for SourceChangeSplitMutation {
11157 #[allow(deprecated)]
11158 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11159 where
11160 S: serde::Serializer,
11161 {
11162 use serde::ser::SerializeStruct;
11163 let mut len = 0;
11164 if !self.actor_splits.is_empty() {
11165 len += 1;
11166 }
11167 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceChangeSplitMutation", len)?;
11168 if !self.actor_splits.is_empty() {
11169 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
11170 }
11171 struct_ser.end()
11172 }
11173}
11174impl<'de> serde::Deserialize<'de> for SourceChangeSplitMutation {
11175 #[allow(deprecated)]
11176 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11177 where
11178 D: serde::Deserializer<'de>,
11179 {
11180 const FIELDS: &[&str] = &[
11181 "actor_splits",
11182 "actorSplits",
11183 ];
11184
11185 #[allow(clippy::enum_variant_names)]
11186 enum GeneratedField {
11187 ActorSplits,
11188 }
11189 impl<'de> serde::Deserialize<'de> for GeneratedField {
11190 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11191 where
11192 D: serde::Deserializer<'de>,
11193 {
11194 struct GeneratedVisitor;
11195
11196 impl serde::de::Visitor<'_> for GeneratedVisitor {
11197 type Value = GeneratedField;
11198
11199 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11200 write!(formatter, "expected one of: {:?}", &FIELDS)
11201 }
11202
11203 #[allow(unused_variables)]
11204 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11205 where
11206 E: serde::de::Error,
11207 {
11208 match value {
11209 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
11210 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11211 }
11212 }
11213 }
11214 deserializer.deserialize_identifier(GeneratedVisitor)
11215 }
11216 }
11217 struct GeneratedVisitor;
11218 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11219 type Value = SourceChangeSplitMutation;
11220
11221 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11222 formatter.write_str("struct stream_plan.SourceChangeSplitMutation")
11223 }
11224
11225 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceChangeSplitMutation, V::Error>
11226 where
11227 V: serde::de::MapAccess<'de>,
11228 {
11229 let mut actor_splits__ = None;
11230 while let Some(k) = map_.next_key()? {
11231 match k {
11232 GeneratedField::ActorSplits => {
11233 if actor_splits__.is_some() {
11234 return Err(serde::de::Error::duplicate_field("actorSplits"));
11235 }
11236 actor_splits__ = Some(
11237 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11238 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
11239 );
11240 }
11241 }
11242 }
11243 Ok(SourceChangeSplitMutation {
11244 actor_splits: actor_splits__.unwrap_or_default(),
11245 })
11246 }
11247 }
11248 deserializer.deserialize_struct("stream_plan.SourceChangeSplitMutation", FIELDS, GeneratedVisitor)
11249 }
11250}
11251impl serde::Serialize for SourceNode {
11252 #[allow(deprecated)]
11253 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11254 where
11255 S: serde::Serializer,
11256 {
11257 use serde::ser::SerializeStruct;
11258 let mut len = 0;
11259 if self.source_inner.is_some() {
11260 len += 1;
11261 }
11262 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceNode", len)?;
11263 if let Some(v) = self.source_inner.as_ref() {
11264 struct_ser.serialize_field("sourceInner", v)?;
11265 }
11266 struct_ser.end()
11267 }
11268}
11269impl<'de> serde::Deserialize<'de> for SourceNode {
11270 #[allow(deprecated)]
11271 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11272 where
11273 D: serde::Deserializer<'de>,
11274 {
11275 const FIELDS: &[&str] = &[
11276 "source_inner",
11277 "sourceInner",
11278 ];
11279
11280 #[allow(clippy::enum_variant_names)]
11281 enum GeneratedField {
11282 SourceInner,
11283 }
11284 impl<'de> serde::Deserialize<'de> for GeneratedField {
11285 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11286 where
11287 D: serde::Deserializer<'de>,
11288 {
11289 struct GeneratedVisitor;
11290
11291 impl serde::de::Visitor<'_> for GeneratedVisitor {
11292 type Value = GeneratedField;
11293
11294 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11295 write!(formatter, "expected one of: {:?}", &FIELDS)
11296 }
11297
11298 #[allow(unused_variables)]
11299 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11300 where
11301 E: serde::de::Error,
11302 {
11303 match value {
11304 "sourceInner" | "source_inner" => Ok(GeneratedField::SourceInner),
11305 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11306 }
11307 }
11308 }
11309 deserializer.deserialize_identifier(GeneratedVisitor)
11310 }
11311 }
11312 struct GeneratedVisitor;
11313 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11314 type Value = SourceNode;
11315
11316 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11317 formatter.write_str("struct stream_plan.SourceNode")
11318 }
11319
11320 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
11321 where
11322 V: serde::de::MapAccess<'de>,
11323 {
11324 let mut source_inner__ = None;
11325 while let Some(k) = map_.next_key()? {
11326 match k {
11327 GeneratedField::SourceInner => {
11328 if source_inner__.is_some() {
11329 return Err(serde::de::Error::duplicate_field("sourceInner"));
11330 }
11331 source_inner__ = map_.next_value()?;
11332 }
11333 }
11334 }
11335 Ok(SourceNode {
11336 source_inner: source_inner__,
11337 })
11338 }
11339 }
11340 deserializer.deserialize_struct("stream_plan.SourceNode", FIELDS, GeneratedVisitor)
11341 }
11342}
11343impl serde::Serialize for StartFragmentBackfillMutation {
11344 #[allow(deprecated)]
11345 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11346 where
11347 S: serde::Serializer,
11348 {
11349 use serde::ser::SerializeStruct;
11350 let mut len = 0;
11351 if !self.fragment_ids.is_empty() {
11352 len += 1;
11353 }
11354 let mut struct_ser = serializer.serialize_struct("stream_plan.StartFragmentBackfillMutation", len)?;
11355 if !self.fragment_ids.is_empty() {
11356 struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
11357 }
11358 struct_ser.end()
11359 }
11360}
11361impl<'de> serde::Deserialize<'de> for StartFragmentBackfillMutation {
11362 #[allow(deprecated)]
11363 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11364 where
11365 D: serde::Deserializer<'de>,
11366 {
11367 const FIELDS: &[&str] = &[
11368 "fragment_ids",
11369 "fragmentIds",
11370 ];
11371
11372 #[allow(clippy::enum_variant_names)]
11373 enum GeneratedField {
11374 FragmentIds,
11375 }
11376 impl<'de> serde::Deserialize<'de> for GeneratedField {
11377 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11378 where
11379 D: serde::Deserializer<'de>,
11380 {
11381 struct GeneratedVisitor;
11382
11383 impl serde::de::Visitor<'_> for GeneratedVisitor {
11384 type Value = GeneratedField;
11385
11386 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11387 write!(formatter, "expected one of: {:?}", &FIELDS)
11388 }
11389
11390 #[allow(unused_variables)]
11391 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11392 where
11393 E: serde::de::Error,
11394 {
11395 match value {
11396 "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
11397 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11398 }
11399 }
11400 }
11401 deserializer.deserialize_identifier(GeneratedVisitor)
11402 }
11403 }
11404 struct GeneratedVisitor;
11405 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11406 type Value = StartFragmentBackfillMutation;
11407
11408 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11409 formatter.write_str("struct stream_plan.StartFragmentBackfillMutation")
11410 }
11411
11412 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StartFragmentBackfillMutation, V::Error>
11413 where
11414 V: serde::de::MapAccess<'de>,
11415 {
11416 let mut fragment_ids__ = None;
11417 while let Some(k) = map_.next_key()? {
11418 match k {
11419 GeneratedField::FragmentIds => {
11420 if fragment_ids__.is_some() {
11421 return Err(serde::de::Error::duplicate_field("fragmentIds"));
11422 }
11423 fragment_ids__ =
11424 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11425 .into_iter().map(|x| x.0).collect())
11426 ;
11427 }
11428 }
11429 }
11430 Ok(StartFragmentBackfillMutation {
11431 fragment_ids: fragment_ids__.unwrap_or_default(),
11432 })
11433 }
11434 }
11435 deserializer.deserialize_struct("stream_plan.StartFragmentBackfillMutation", FIELDS, GeneratedVisitor)
11436 }
11437}
11438impl serde::Serialize for StopMutation {
11439 #[allow(deprecated)]
11440 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11441 where
11442 S: serde::Serializer,
11443 {
11444 use serde::ser::SerializeStruct;
11445 let mut len = 0;
11446 if !self.actors.is_empty() {
11447 len += 1;
11448 }
11449 if !self.dropped_sink_fragments.is_empty() {
11450 len += 1;
11451 }
11452 let mut struct_ser = serializer.serialize_struct("stream_plan.StopMutation", len)?;
11453 if !self.actors.is_empty() {
11454 struct_ser.serialize_field("actors", &self.actors)?;
11455 }
11456 if !self.dropped_sink_fragments.is_empty() {
11457 struct_ser.serialize_field("droppedSinkFragments", &self.dropped_sink_fragments)?;
11458 }
11459 struct_ser.end()
11460 }
11461}
11462impl<'de> serde::Deserialize<'de> for StopMutation {
11463 #[allow(deprecated)]
11464 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11465 where
11466 D: serde::Deserializer<'de>,
11467 {
11468 const FIELDS: &[&str] = &[
11469 "actors",
11470 "dropped_sink_fragments",
11471 "droppedSinkFragments",
11472 ];
11473
11474 #[allow(clippy::enum_variant_names)]
11475 enum GeneratedField {
11476 Actors,
11477 DroppedSinkFragments,
11478 }
11479 impl<'de> serde::Deserialize<'de> for GeneratedField {
11480 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11481 where
11482 D: serde::Deserializer<'de>,
11483 {
11484 struct GeneratedVisitor;
11485
11486 impl serde::de::Visitor<'_> for GeneratedVisitor {
11487 type Value = GeneratedField;
11488
11489 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11490 write!(formatter, "expected one of: {:?}", &FIELDS)
11491 }
11492
11493 #[allow(unused_variables)]
11494 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11495 where
11496 E: serde::de::Error,
11497 {
11498 match value {
11499 "actors" => Ok(GeneratedField::Actors),
11500 "droppedSinkFragments" | "dropped_sink_fragments" => Ok(GeneratedField::DroppedSinkFragments),
11501 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11502 }
11503 }
11504 }
11505 deserializer.deserialize_identifier(GeneratedVisitor)
11506 }
11507 }
11508 struct GeneratedVisitor;
11509 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11510 type Value = StopMutation;
11511
11512 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11513 formatter.write_str("struct stream_plan.StopMutation")
11514 }
11515
11516 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopMutation, V::Error>
11517 where
11518 V: serde::de::MapAccess<'de>,
11519 {
11520 let mut actors__ = None;
11521 let mut dropped_sink_fragments__ = None;
11522 while let Some(k) = map_.next_key()? {
11523 match k {
11524 GeneratedField::Actors => {
11525 if actors__.is_some() {
11526 return Err(serde::de::Error::duplicate_field("actors"));
11527 }
11528 actors__ =
11529 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11530 .into_iter().map(|x| x.0).collect())
11531 ;
11532 }
11533 GeneratedField::DroppedSinkFragments => {
11534 if dropped_sink_fragments__.is_some() {
11535 return Err(serde::de::Error::duplicate_field("droppedSinkFragments"));
11536 }
11537 dropped_sink_fragments__ =
11538 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11539 .into_iter().map(|x| x.0).collect())
11540 ;
11541 }
11542 }
11543 }
11544 Ok(StopMutation {
11545 actors: actors__.unwrap_or_default(),
11546 dropped_sink_fragments: dropped_sink_fragments__.unwrap_or_default(),
11547 })
11548 }
11549 }
11550 deserializer.deserialize_struct("stream_plan.StopMutation", FIELDS, GeneratedVisitor)
11551 }
11552}
11553impl serde::Serialize for StreamActor {
11554 #[allow(deprecated)]
11555 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11556 where
11557 S: serde::Serializer,
11558 {
11559 use serde::ser::SerializeStruct;
11560 let mut len = 0;
11561 if self.actor_id != 0 {
11562 len += 1;
11563 }
11564 if self.fragment_id != 0 {
11565 len += 1;
11566 }
11567 if !self.dispatcher.is_empty() {
11568 len += 1;
11569 }
11570 if self.vnode_bitmap.is_some() {
11571 len += 1;
11572 }
11573 if !self.mview_definition.is_empty() {
11574 len += 1;
11575 }
11576 if self.expr_context.is_some() {
11577 len += 1;
11578 }
11579 if !self.config_override.is_empty() {
11580 len += 1;
11581 }
11582 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamActor", len)?;
11583 if self.actor_id != 0 {
11584 struct_ser.serialize_field("actorId", &self.actor_id)?;
11585 }
11586 if self.fragment_id != 0 {
11587 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
11588 }
11589 if !self.dispatcher.is_empty() {
11590 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
11591 }
11592 if let Some(v) = self.vnode_bitmap.as_ref() {
11593 struct_ser.serialize_field("vnodeBitmap", v)?;
11594 }
11595 if !self.mview_definition.is_empty() {
11596 struct_ser.serialize_field("mviewDefinition", &self.mview_definition)?;
11597 }
11598 if let Some(v) = self.expr_context.as_ref() {
11599 struct_ser.serialize_field("exprContext", v)?;
11600 }
11601 if !self.config_override.is_empty() {
11602 struct_ser.serialize_field("configOverride", &self.config_override)?;
11603 }
11604 struct_ser.end()
11605 }
11606}
11607impl<'de> serde::Deserialize<'de> for StreamActor {
11608 #[allow(deprecated)]
11609 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11610 where
11611 D: serde::Deserializer<'de>,
11612 {
11613 const FIELDS: &[&str] = &[
11614 "actor_id",
11615 "actorId",
11616 "fragment_id",
11617 "fragmentId",
11618 "dispatcher",
11619 "vnode_bitmap",
11620 "vnodeBitmap",
11621 "mview_definition",
11622 "mviewDefinition",
11623 "expr_context",
11624 "exprContext",
11625 "config_override",
11626 "configOverride",
11627 ];
11628
11629 #[allow(clippy::enum_variant_names)]
11630 enum GeneratedField {
11631 ActorId,
11632 FragmentId,
11633 Dispatcher,
11634 VnodeBitmap,
11635 MviewDefinition,
11636 ExprContext,
11637 ConfigOverride,
11638 }
11639 impl<'de> serde::Deserialize<'de> for GeneratedField {
11640 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11641 where
11642 D: serde::Deserializer<'de>,
11643 {
11644 struct GeneratedVisitor;
11645
11646 impl serde::de::Visitor<'_> for GeneratedVisitor {
11647 type Value = GeneratedField;
11648
11649 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11650 write!(formatter, "expected one of: {:?}", &FIELDS)
11651 }
11652
11653 #[allow(unused_variables)]
11654 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11655 where
11656 E: serde::de::Error,
11657 {
11658 match value {
11659 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
11660 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
11661 "dispatcher" => Ok(GeneratedField::Dispatcher),
11662 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
11663 "mviewDefinition" | "mview_definition" => Ok(GeneratedField::MviewDefinition),
11664 "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
11665 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
11666 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11667 }
11668 }
11669 }
11670 deserializer.deserialize_identifier(GeneratedVisitor)
11671 }
11672 }
11673 struct GeneratedVisitor;
11674 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11675 type Value = StreamActor;
11676
11677 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11678 formatter.write_str("struct stream_plan.StreamActor")
11679 }
11680
11681 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamActor, V::Error>
11682 where
11683 V: serde::de::MapAccess<'de>,
11684 {
11685 let mut actor_id__ = None;
11686 let mut fragment_id__ = None;
11687 let mut dispatcher__ = None;
11688 let mut vnode_bitmap__ = None;
11689 let mut mview_definition__ = None;
11690 let mut expr_context__ = None;
11691 let mut config_override__ = None;
11692 while let Some(k) = map_.next_key()? {
11693 match k {
11694 GeneratedField::ActorId => {
11695 if actor_id__.is_some() {
11696 return Err(serde::de::Error::duplicate_field("actorId"));
11697 }
11698 actor_id__ =
11699 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11700 ;
11701 }
11702 GeneratedField::FragmentId => {
11703 if fragment_id__.is_some() {
11704 return Err(serde::de::Error::duplicate_field("fragmentId"));
11705 }
11706 fragment_id__ =
11707 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11708 ;
11709 }
11710 GeneratedField::Dispatcher => {
11711 if dispatcher__.is_some() {
11712 return Err(serde::de::Error::duplicate_field("dispatcher"));
11713 }
11714 dispatcher__ = Some(map_.next_value()?);
11715 }
11716 GeneratedField::VnodeBitmap => {
11717 if vnode_bitmap__.is_some() {
11718 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
11719 }
11720 vnode_bitmap__ = map_.next_value()?;
11721 }
11722 GeneratedField::MviewDefinition => {
11723 if mview_definition__.is_some() {
11724 return Err(serde::de::Error::duplicate_field("mviewDefinition"));
11725 }
11726 mview_definition__ = Some(map_.next_value()?);
11727 }
11728 GeneratedField::ExprContext => {
11729 if expr_context__.is_some() {
11730 return Err(serde::de::Error::duplicate_field("exprContext"));
11731 }
11732 expr_context__ = map_.next_value()?;
11733 }
11734 GeneratedField::ConfigOverride => {
11735 if config_override__.is_some() {
11736 return Err(serde::de::Error::duplicate_field("configOverride"));
11737 }
11738 config_override__ = Some(map_.next_value()?);
11739 }
11740 }
11741 }
11742 Ok(StreamActor {
11743 actor_id: actor_id__.unwrap_or_default(),
11744 fragment_id: fragment_id__.unwrap_or_default(),
11745 dispatcher: dispatcher__.unwrap_or_default(),
11746 vnode_bitmap: vnode_bitmap__,
11747 mview_definition: mview_definition__.unwrap_or_default(),
11748 expr_context: expr_context__,
11749 config_override: config_override__.unwrap_or_default(),
11750 })
11751 }
11752 }
11753 deserializer.deserialize_struct("stream_plan.StreamActor", FIELDS, GeneratedVisitor)
11754 }
11755}
11756impl serde::Serialize for StreamCdcScanNode {
11757 #[allow(deprecated)]
11758 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11759 where
11760 S: serde::Serializer,
11761 {
11762 use serde::ser::SerializeStruct;
11763 let mut len = 0;
11764 if self.table_id != 0 {
11765 len += 1;
11766 }
11767 if !self.upstream_column_ids.is_empty() {
11768 len += 1;
11769 }
11770 if !self.output_indices.is_empty() {
11771 len += 1;
11772 }
11773 if self.state_table.is_some() {
11774 len += 1;
11775 }
11776 if self.cdc_table_desc.is_some() {
11777 len += 1;
11778 }
11779 if self.rate_limit.is_some() {
11780 len += 1;
11781 }
11782 if self.disable_backfill {
11783 len += 1;
11784 }
11785 if self.options.is_some() {
11786 len += 1;
11787 }
11788 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanNode", len)?;
11789 if self.table_id != 0 {
11790 struct_ser.serialize_field("tableId", &self.table_id)?;
11791 }
11792 if !self.upstream_column_ids.is_empty() {
11793 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
11794 }
11795 if !self.output_indices.is_empty() {
11796 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
11797 }
11798 if let Some(v) = self.state_table.as_ref() {
11799 struct_ser.serialize_field("stateTable", v)?;
11800 }
11801 if let Some(v) = self.cdc_table_desc.as_ref() {
11802 struct_ser.serialize_field("cdcTableDesc", v)?;
11803 }
11804 if let Some(v) = self.rate_limit.as_ref() {
11805 struct_ser.serialize_field("rateLimit", v)?;
11806 }
11807 if self.disable_backfill {
11808 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
11809 }
11810 if let Some(v) = self.options.as_ref() {
11811 struct_ser.serialize_field("options", v)?;
11812 }
11813 struct_ser.end()
11814 }
11815}
11816impl<'de> serde::Deserialize<'de> for StreamCdcScanNode {
11817 #[allow(deprecated)]
11818 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11819 where
11820 D: serde::Deserializer<'de>,
11821 {
11822 const FIELDS: &[&str] = &[
11823 "table_id",
11824 "tableId",
11825 "upstream_column_ids",
11826 "upstreamColumnIds",
11827 "output_indices",
11828 "outputIndices",
11829 "state_table",
11830 "stateTable",
11831 "cdc_table_desc",
11832 "cdcTableDesc",
11833 "rate_limit",
11834 "rateLimit",
11835 "disable_backfill",
11836 "disableBackfill",
11837 "options",
11838 ];
11839
11840 #[allow(clippy::enum_variant_names)]
11841 enum GeneratedField {
11842 TableId,
11843 UpstreamColumnIds,
11844 OutputIndices,
11845 StateTable,
11846 CdcTableDesc,
11847 RateLimit,
11848 DisableBackfill,
11849 Options,
11850 }
11851 impl<'de> serde::Deserialize<'de> for GeneratedField {
11852 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11853 where
11854 D: serde::Deserializer<'de>,
11855 {
11856 struct GeneratedVisitor;
11857
11858 impl serde::de::Visitor<'_> for GeneratedVisitor {
11859 type Value = GeneratedField;
11860
11861 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11862 write!(formatter, "expected one of: {:?}", &FIELDS)
11863 }
11864
11865 #[allow(unused_variables)]
11866 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11867 where
11868 E: serde::de::Error,
11869 {
11870 match value {
11871 "tableId" | "table_id" => Ok(GeneratedField::TableId),
11872 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
11873 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
11874 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11875 "cdcTableDesc" | "cdc_table_desc" => Ok(GeneratedField::CdcTableDesc),
11876 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11877 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
11878 "options" => Ok(GeneratedField::Options),
11879 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11880 }
11881 }
11882 }
11883 deserializer.deserialize_identifier(GeneratedVisitor)
11884 }
11885 }
11886 struct GeneratedVisitor;
11887 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11888 type Value = StreamCdcScanNode;
11889
11890 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11891 formatter.write_str("struct stream_plan.StreamCdcScanNode")
11892 }
11893
11894 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanNode, V::Error>
11895 where
11896 V: serde::de::MapAccess<'de>,
11897 {
11898 let mut table_id__ = None;
11899 let mut upstream_column_ids__ = None;
11900 let mut output_indices__ = None;
11901 let mut state_table__ = None;
11902 let mut cdc_table_desc__ = None;
11903 let mut rate_limit__ = None;
11904 let mut disable_backfill__ = None;
11905 let mut options__ = None;
11906 while let Some(k) = map_.next_key()? {
11907 match k {
11908 GeneratedField::TableId => {
11909 if table_id__.is_some() {
11910 return Err(serde::de::Error::duplicate_field("tableId"));
11911 }
11912 table_id__ =
11913 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11914 ;
11915 }
11916 GeneratedField::UpstreamColumnIds => {
11917 if upstream_column_ids__.is_some() {
11918 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
11919 }
11920 upstream_column_ids__ =
11921 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11922 .into_iter().map(|x| x.0).collect())
11923 ;
11924 }
11925 GeneratedField::OutputIndices => {
11926 if output_indices__.is_some() {
11927 return Err(serde::de::Error::duplicate_field("outputIndices"));
11928 }
11929 output_indices__ =
11930 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11931 .into_iter().map(|x| x.0).collect())
11932 ;
11933 }
11934 GeneratedField::StateTable => {
11935 if state_table__.is_some() {
11936 return Err(serde::de::Error::duplicate_field("stateTable"));
11937 }
11938 state_table__ = map_.next_value()?;
11939 }
11940 GeneratedField::CdcTableDesc => {
11941 if cdc_table_desc__.is_some() {
11942 return Err(serde::de::Error::duplicate_field("cdcTableDesc"));
11943 }
11944 cdc_table_desc__ = map_.next_value()?;
11945 }
11946 GeneratedField::RateLimit => {
11947 if rate_limit__.is_some() {
11948 return Err(serde::de::Error::duplicate_field("rateLimit"));
11949 }
11950 rate_limit__ =
11951 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11952 ;
11953 }
11954 GeneratedField::DisableBackfill => {
11955 if disable_backfill__.is_some() {
11956 return Err(serde::de::Error::duplicate_field("disableBackfill"));
11957 }
11958 disable_backfill__ = Some(map_.next_value()?);
11959 }
11960 GeneratedField::Options => {
11961 if options__.is_some() {
11962 return Err(serde::de::Error::duplicate_field("options"));
11963 }
11964 options__ = map_.next_value()?;
11965 }
11966 }
11967 }
11968 Ok(StreamCdcScanNode {
11969 table_id: table_id__.unwrap_or_default(),
11970 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
11971 output_indices: output_indices__.unwrap_or_default(),
11972 state_table: state_table__,
11973 cdc_table_desc: cdc_table_desc__,
11974 rate_limit: rate_limit__,
11975 disable_backfill: disable_backfill__.unwrap_or_default(),
11976 options: options__,
11977 })
11978 }
11979 }
11980 deserializer.deserialize_struct("stream_plan.StreamCdcScanNode", FIELDS, GeneratedVisitor)
11981 }
11982}
11983impl serde::Serialize for StreamCdcScanOptions {
11984 #[allow(deprecated)]
11985 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11986 where
11987 S: serde::Serializer,
11988 {
11989 use serde::ser::SerializeStruct;
11990 let mut len = 0;
11991 if self.disable_backfill {
11992 len += 1;
11993 }
11994 if self.snapshot_barrier_interval != 0 {
11995 len += 1;
11996 }
11997 if self.snapshot_batch_size != 0 {
11998 len += 1;
11999 }
12000 if self.backfill_parallelism != 0 {
12001 len += 1;
12002 }
12003 if self.backfill_num_rows_per_split != 0 {
12004 len += 1;
12005 }
12006 if self.backfill_as_even_splits {
12007 len += 1;
12008 }
12009 if self.backfill_split_pk_column_index != 0 {
12010 len += 1;
12011 }
12012 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanOptions", len)?;
12013 if self.disable_backfill {
12014 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
12015 }
12016 if self.snapshot_barrier_interval != 0 {
12017 struct_ser.serialize_field("snapshotBarrierInterval", &self.snapshot_barrier_interval)?;
12018 }
12019 if self.snapshot_batch_size != 0 {
12020 struct_ser.serialize_field("snapshotBatchSize", &self.snapshot_batch_size)?;
12021 }
12022 if self.backfill_parallelism != 0 {
12023 struct_ser.serialize_field("backfillParallelism", &self.backfill_parallelism)?;
12024 }
12025 if self.backfill_num_rows_per_split != 0 {
12026 #[allow(clippy::needless_borrow)]
12027 #[allow(clippy::needless_borrows_for_generic_args)]
12028 struct_ser.serialize_field("backfillNumRowsPerSplit", ToString::to_string(&self.backfill_num_rows_per_split).as_str())?;
12029 }
12030 if self.backfill_as_even_splits {
12031 struct_ser.serialize_field("backfillAsEvenSplits", &self.backfill_as_even_splits)?;
12032 }
12033 if self.backfill_split_pk_column_index != 0 {
12034 struct_ser.serialize_field("backfillSplitPkColumnIndex", &self.backfill_split_pk_column_index)?;
12035 }
12036 struct_ser.end()
12037 }
12038}
12039impl<'de> serde::Deserialize<'de> for StreamCdcScanOptions {
12040 #[allow(deprecated)]
12041 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12042 where
12043 D: serde::Deserializer<'de>,
12044 {
12045 const FIELDS: &[&str] = &[
12046 "disable_backfill",
12047 "disableBackfill",
12048 "snapshot_barrier_interval",
12049 "snapshotBarrierInterval",
12050 "snapshot_batch_size",
12051 "snapshotBatchSize",
12052 "backfill_parallelism",
12053 "backfillParallelism",
12054 "backfill_num_rows_per_split",
12055 "backfillNumRowsPerSplit",
12056 "backfill_as_even_splits",
12057 "backfillAsEvenSplits",
12058 "backfill_split_pk_column_index",
12059 "backfillSplitPkColumnIndex",
12060 ];
12061
12062 #[allow(clippy::enum_variant_names)]
12063 enum GeneratedField {
12064 DisableBackfill,
12065 SnapshotBarrierInterval,
12066 SnapshotBatchSize,
12067 BackfillParallelism,
12068 BackfillNumRowsPerSplit,
12069 BackfillAsEvenSplits,
12070 BackfillSplitPkColumnIndex,
12071 }
12072 impl<'de> serde::Deserialize<'de> for GeneratedField {
12073 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12074 where
12075 D: serde::Deserializer<'de>,
12076 {
12077 struct GeneratedVisitor;
12078
12079 impl serde::de::Visitor<'_> for GeneratedVisitor {
12080 type Value = GeneratedField;
12081
12082 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12083 write!(formatter, "expected one of: {:?}", &FIELDS)
12084 }
12085
12086 #[allow(unused_variables)]
12087 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12088 where
12089 E: serde::de::Error,
12090 {
12091 match value {
12092 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
12093 "snapshotBarrierInterval" | "snapshot_barrier_interval" => Ok(GeneratedField::SnapshotBarrierInterval),
12094 "snapshotBatchSize" | "snapshot_batch_size" => Ok(GeneratedField::SnapshotBatchSize),
12095 "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
12096 "backfillNumRowsPerSplit" | "backfill_num_rows_per_split" => Ok(GeneratedField::BackfillNumRowsPerSplit),
12097 "backfillAsEvenSplits" | "backfill_as_even_splits" => Ok(GeneratedField::BackfillAsEvenSplits),
12098 "backfillSplitPkColumnIndex" | "backfill_split_pk_column_index" => Ok(GeneratedField::BackfillSplitPkColumnIndex),
12099 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12100 }
12101 }
12102 }
12103 deserializer.deserialize_identifier(GeneratedVisitor)
12104 }
12105 }
12106 struct GeneratedVisitor;
12107 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12108 type Value = StreamCdcScanOptions;
12109
12110 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12111 formatter.write_str("struct stream_plan.StreamCdcScanOptions")
12112 }
12113
12114 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanOptions, V::Error>
12115 where
12116 V: serde::de::MapAccess<'de>,
12117 {
12118 let mut disable_backfill__ = None;
12119 let mut snapshot_barrier_interval__ = None;
12120 let mut snapshot_batch_size__ = None;
12121 let mut backfill_parallelism__ = None;
12122 let mut backfill_num_rows_per_split__ = None;
12123 let mut backfill_as_even_splits__ = None;
12124 let mut backfill_split_pk_column_index__ = None;
12125 while let Some(k) = map_.next_key()? {
12126 match k {
12127 GeneratedField::DisableBackfill => {
12128 if disable_backfill__.is_some() {
12129 return Err(serde::de::Error::duplicate_field("disableBackfill"));
12130 }
12131 disable_backfill__ = Some(map_.next_value()?);
12132 }
12133 GeneratedField::SnapshotBarrierInterval => {
12134 if snapshot_barrier_interval__.is_some() {
12135 return Err(serde::de::Error::duplicate_field("snapshotBarrierInterval"));
12136 }
12137 snapshot_barrier_interval__ =
12138 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12139 ;
12140 }
12141 GeneratedField::SnapshotBatchSize => {
12142 if snapshot_batch_size__.is_some() {
12143 return Err(serde::de::Error::duplicate_field("snapshotBatchSize"));
12144 }
12145 snapshot_batch_size__ =
12146 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12147 ;
12148 }
12149 GeneratedField::BackfillParallelism => {
12150 if backfill_parallelism__.is_some() {
12151 return Err(serde::de::Error::duplicate_field("backfillParallelism"));
12152 }
12153 backfill_parallelism__ =
12154 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12155 ;
12156 }
12157 GeneratedField::BackfillNumRowsPerSplit => {
12158 if backfill_num_rows_per_split__.is_some() {
12159 return Err(serde::de::Error::duplicate_field("backfillNumRowsPerSplit"));
12160 }
12161 backfill_num_rows_per_split__ =
12162 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12163 ;
12164 }
12165 GeneratedField::BackfillAsEvenSplits => {
12166 if backfill_as_even_splits__.is_some() {
12167 return Err(serde::de::Error::duplicate_field("backfillAsEvenSplits"));
12168 }
12169 backfill_as_even_splits__ = Some(map_.next_value()?);
12170 }
12171 GeneratedField::BackfillSplitPkColumnIndex => {
12172 if backfill_split_pk_column_index__.is_some() {
12173 return Err(serde::de::Error::duplicate_field("backfillSplitPkColumnIndex"));
12174 }
12175 backfill_split_pk_column_index__ =
12176 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12177 ;
12178 }
12179 }
12180 }
12181 Ok(StreamCdcScanOptions {
12182 disable_backfill: disable_backfill__.unwrap_or_default(),
12183 snapshot_barrier_interval: snapshot_barrier_interval__.unwrap_or_default(),
12184 snapshot_batch_size: snapshot_batch_size__.unwrap_or_default(),
12185 backfill_parallelism: backfill_parallelism__.unwrap_or_default(),
12186 backfill_num_rows_per_split: backfill_num_rows_per_split__.unwrap_or_default(),
12187 backfill_as_even_splits: backfill_as_even_splits__.unwrap_or_default(),
12188 backfill_split_pk_column_index: backfill_split_pk_column_index__.unwrap_or_default(),
12189 })
12190 }
12191 }
12192 deserializer.deserialize_struct("stream_plan.StreamCdcScanOptions", FIELDS, GeneratedVisitor)
12193 }
12194}
12195impl serde::Serialize for StreamContext {
12196 #[allow(deprecated)]
12197 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12198 where
12199 S: serde::Serializer,
12200 {
12201 use serde::ser::SerializeStruct;
12202 let mut len = 0;
12203 if !self.timezone.is_empty() {
12204 len += 1;
12205 }
12206 if !self.config_override.is_empty() {
12207 len += 1;
12208 }
12209 if !self.adaptive_parallelism_strategy.is_empty() {
12210 len += 1;
12211 }
12212 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamContext", len)?;
12213 if !self.timezone.is_empty() {
12214 struct_ser.serialize_field("timezone", &self.timezone)?;
12215 }
12216 if !self.config_override.is_empty() {
12217 struct_ser.serialize_field("configOverride", &self.config_override)?;
12218 }
12219 if !self.adaptive_parallelism_strategy.is_empty() {
12220 struct_ser.serialize_field("adaptiveParallelismStrategy", &self.adaptive_parallelism_strategy)?;
12221 }
12222 struct_ser.end()
12223 }
12224}
12225impl<'de> serde::Deserialize<'de> for StreamContext {
12226 #[allow(deprecated)]
12227 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12228 where
12229 D: serde::Deserializer<'de>,
12230 {
12231 const FIELDS: &[&str] = &[
12232 "timezone",
12233 "config_override",
12234 "configOverride",
12235 "adaptive_parallelism_strategy",
12236 "adaptiveParallelismStrategy",
12237 ];
12238
12239 #[allow(clippy::enum_variant_names)]
12240 enum GeneratedField {
12241 Timezone,
12242 ConfigOverride,
12243 AdaptiveParallelismStrategy,
12244 }
12245 impl<'de> serde::Deserialize<'de> for GeneratedField {
12246 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12247 where
12248 D: serde::Deserializer<'de>,
12249 {
12250 struct GeneratedVisitor;
12251
12252 impl serde::de::Visitor<'_> for GeneratedVisitor {
12253 type Value = GeneratedField;
12254
12255 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12256 write!(formatter, "expected one of: {:?}", &FIELDS)
12257 }
12258
12259 #[allow(unused_variables)]
12260 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12261 where
12262 E: serde::de::Error,
12263 {
12264 match value {
12265 "timezone" => Ok(GeneratedField::Timezone),
12266 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
12267 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
12268 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12269 }
12270 }
12271 }
12272 deserializer.deserialize_identifier(GeneratedVisitor)
12273 }
12274 }
12275 struct GeneratedVisitor;
12276 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12277 type Value = StreamContext;
12278
12279 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12280 formatter.write_str("struct stream_plan.StreamContext")
12281 }
12282
12283 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamContext, V::Error>
12284 where
12285 V: serde::de::MapAccess<'de>,
12286 {
12287 let mut timezone__ = None;
12288 let mut config_override__ = None;
12289 let mut adaptive_parallelism_strategy__ = None;
12290 while let Some(k) = map_.next_key()? {
12291 match k {
12292 GeneratedField::Timezone => {
12293 if timezone__.is_some() {
12294 return Err(serde::de::Error::duplicate_field("timezone"));
12295 }
12296 timezone__ = Some(map_.next_value()?);
12297 }
12298 GeneratedField::ConfigOverride => {
12299 if config_override__.is_some() {
12300 return Err(serde::de::Error::duplicate_field("configOverride"));
12301 }
12302 config_override__ = Some(map_.next_value()?);
12303 }
12304 GeneratedField::AdaptiveParallelismStrategy => {
12305 if adaptive_parallelism_strategy__.is_some() {
12306 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
12307 }
12308 adaptive_parallelism_strategy__ = Some(map_.next_value()?);
12309 }
12310 }
12311 }
12312 Ok(StreamContext {
12313 timezone: timezone__.unwrap_or_default(),
12314 config_override: config_override__.unwrap_or_default(),
12315 adaptive_parallelism_strategy: adaptive_parallelism_strategy__.unwrap_or_default(),
12316 })
12317 }
12318 }
12319 deserializer.deserialize_struct("stream_plan.StreamContext", FIELDS, GeneratedVisitor)
12320 }
12321}
12322impl serde::Serialize for StreamFragmentGraph {
12323 #[allow(deprecated)]
12324 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12325 where
12326 S: serde::Serializer,
12327 {
12328 use serde::ser::SerializeStruct;
12329 let mut len = 0;
12330 if !self.fragments.is_empty() {
12331 len += 1;
12332 }
12333 if !self.edges.is_empty() {
12334 len += 1;
12335 }
12336 if !self.dependent_table_ids.is_empty() {
12337 len += 1;
12338 }
12339 if self.table_ids_cnt != 0 {
12340 len += 1;
12341 }
12342 if self.ctx.is_some() {
12343 len += 1;
12344 }
12345 if self.parallelism.is_some() {
12346 len += 1;
12347 }
12348 if self.backfill_parallelism.is_some() {
12349 len += 1;
12350 }
12351 if self.max_parallelism != 0 {
12352 len += 1;
12353 }
12354 if self.backfill_order.is_some() {
12355 len += 1;
12356 }
12357 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph", len)?;
12358 if !self.fragments.is_empty() {
12359 struct_ser.serialize_field("fragments", &self.fragments)?;
12360 }
12361 if !self.edges.is_empty() {
12362 struct_ser.serialize_field("edges", &self.edges)?;
12363 }
12364 if !self.dependent_table_ids.is_empty() {
12365 struct_ser.serialize_field("dependentTableIds", &self.dependent_table_ids)?;
12366 }
12367 if self.table_ids_cnt != 0 {
12368 struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
12369 }
12370 if let Some(v) = self.ctx.as_ref() {
12371 struct_ser.serialize_field("ctx", v)?;
12372 }
12373 if let Some(v) = self.parallelism.as_ref() {
12374 struct_ser.serialize_field("parallelism", v)?;
12375 }
12376 if let Some(v) = self.backfill_parallelism.as_ref() {
12377 struct_ser.serialize_field("backfillParallelism", v)?;
12378 }
12379 if self.max_parallelism != 0 {
12380 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
12381 }
12382 if let Some(v) = self.backfill_order.as_ref() {
12383 struct_ser.serialize_field("backfillOrder", v)?;
12384 }
12385 struct_ser.end()
12386 }
12387}
12388impl<'de> serde::Deserialize<'de> for StreamFragmentGraph {
12389 #[allow(deprecated)]
12390 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12391 where
12392 D: serde::Deserializer<'de>,
12393 {
12394 const FIELDS: &[&str] = &[
12395 "fragments",
12396 "edges",
12397 "dependent_table_ids",
12398 "dependentTableIds",
12399 "table_ids_cnt",
12400 "tableIdsCnt",
12401 "ctx",
12402 "parallelism",
12403 "backfill_parallelism",
12404 "backfillParallelism",
12405 "max_parallelism",
12406 "maxParallelism",
12407 "backfill_order",
12408 "backfillOrder",
12409 ];
12410
12411 #[allow(clippy::enum_variant_names)]
12412 enum GeneratedField {
12413 Fragments,
12414 Edges,
12415 DependentTableIds,
12416 TableIdsCnt,
12417 Ctx,
12418 Parallelism,
12419 BackfillParallelism,
12420 MaxParallelism,
12421 BackfillOrder,
12422 }
12423 impl<'de> serde::Deserialize<'de> for GeneratedField {
12424 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12425 where
12426 D: serde::Deserializer<'de>,
12427 {
12428 struct GeneratedVisitor;
12429
12430 impl serde::de::Visitor<'_> for GeneratedVisitor {
12431 type Value = GeneratedField;
12432
12433 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12434 write!(formatter, "expected one of: {:?}", &FIELDS)
12435 }
12436
12437 #[allow(unused_variables)]
12438 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12439 where
12440 E: serde::de::Error,
12441 {
12442 match value {
12443 "fragments" => Ok(GeneratedField::Fragments),
12444 "edges" => Ok(GeneratedField::Edges),
12445 "dependentTableIds" | "dependent_table_ids" => Ok(GeneratedField::DependentTableIds),
12446 "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
12447 "ctx" => Ok(GeneratedField::Ctx),
12448 "parallelism" => Ok(GeneratedField::Parallelism),
12449 "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
12450 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
12451 "backfillOrder" | "backfill_order" => Ok(GeneratedField::BackfillOrder),
12452 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12453 }
12454 }
12455 }
12456 deserializer.deserialize_identifier(GeneratedVisitor)
12457 }
12458 }
12459 struct GeneratedVisitor;
12460 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12461 type Value = StreamFragmentGraph;
12462
12463 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12464 formatter.write_str("struct stream_plan.StreamFragmentGraph")
12465 }
12466
12467 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFragmentGraph, V::Error>
12468 where
12469 V: serde::de::MapAccess<'de>,
12470 {
12471 let mut fragments__ = None;
12472 let mut edges__ = None;
12473 let mut dependent_table_ids__ = None;
12474 let mut table_ids_cnt__ = None;
12475 let mut ctx__ = None;
12476 let mut parallelism__ = None;
12477 let mut backfill_parallelism__ = None;
12478 let mut max_parallelism__ = None;
12479 let mut backfill_order__ = None;
12480 while let Some(k) = map_.next_key()? {
12481 match k {
12482 GeneratedField::Fragments => {
12483 if fragments__.is_some() {
12484 return Err(serde::de::Error::duplicate_field("fragments"));
12485 }
12486 fragments__ = Some(
12487 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
12488 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
12489 );
12490 }
12491 GeneratedField::Edges => {
12492 if edges__.is_some() {
12493 return Err(serde::de::Error::duplicate_field("edges"));
12494 }
12495 edges__ = Some(map_.next_value()?);
12496 }
12497 GeneratedField::DependentTableIds => {
12498 if dependent_table_ids__.is_some() {
12499 return Err(serde::de::Error::duplicate_field("dependentTableIds"));
12500 }
12501 dependent_table_ids__ =
12502 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12503 .into_iter().map(|x| x.0).collect())
12504 ;
12505 }
12506 GeneratedField::TableIdsCnt => {
12507 if table_ids_cnt__.is_some() {
12508 return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
12509 }
12510 table_ids_cnt__ =
12511 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12512 ;
12513 }
12514 GeneratedField::Ctx => {
12515 if ctx__.is_some() {
12516 return Err(serde::de::Error::duplicate_field("ctx"));
12517 }
12518 ctx__ = map_.next_value()?;
12519 }
12520 GeneratedField::Parallelism => {
12521 if parallelism__.is_some() {
12522 return Err(serde::de::Error::duplicate_field("parallelism"));
12523 }
12524 parallelism__ = map_.next_value()?;
12525 }
12526 GeneratedField::BackfillParallelism => {
12527 if backfill_parallelism__.is_some() {
12528 return Err(serde::de::Error::duplicate_field("backfillParallelism"));
12529 }
12530 backfill_parallelism__ = map_.next_value()?;
12531 }
12532 GeneratedField::MaxParallelism => {
12533 if max_parallelism__.is_some() {
12534 return Err(serde::de::Error::duplicate_field("maxParallelism"));
12535 }
12536 max_parallelism__ =
12537 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12538 ;
12539 }
12540 GeneratedField::BackfillOrder => {
12541 if backfill_order__.is_some() {
12542 return Err(serde::de::Error::duplicate_field("backfillOrder"));
12543 }
12544 backfill_order__ = map_.next_value()?;
12545 }
12546 }
12547 }
12548 Ok(StreamFragmentGraph {
12549 fragments: fragments__.unwrap_or_default(),
12550 edges: edges__.unwrap_or_default(),
12551 dependent_table_ids: dependent_table_ids__.unwrap_or_default(),
12552 table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
12553 ctx: ctx__,
12554 parallelism: parallelism__,
12555 backfill_parallelism: backfill_parallelism__,
12556 max_parallelism: max_parallelism__.unwrap_or_default(),
12557 backfill_order: backfill_order__,
12558 })
12559 }
12560 }
12561 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph", FIELDS, GeneratedVisitor)
12562 }
12563}
12564impl serde::Serialize for stream_fragment_graph::Parallelism {
12565 #[allow(deprecated)]
12566 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12567 where
12568 S: serde::Serializer,
12569 {
12570 use serde::ser::SerializeStruct;
12571 let mut len = 0;
12572 if self.parallelism != 0 {
12573 len += 1;
12574 }
12575 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.Parallelism", len)?;
12576 if self.parallelism != 0 {
12577 #[allow(clippy::needless_borrow)]
12578 #[allow(clippy::needless_borrows_for_generic_args)]
12579 struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
12580 }
12581 struct_ser.end()
12582 }
12583}
12584impl<'de> serde::Deserialize<'de> for stream_fragment_graph::Parallelism {
12585 #[allow(deprecated)]
12586 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12587 where
12588 D: serde::Deserializer<'de>,
12589 {
12590 const FIELDS: &[&str] = &[
12591 "parallelism",
12592 ];
12593
12594 #[allow(clippy::enum_variant_names)]
12595 enum GeneratedField {
12596 Parallelism,
12597 }
12598 impl<'de> serde::Deserialize<'de> for GeneratedField {
12599 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12600 where
12601 D: serde::Deserializer<'de>,
12602 {
12603 struct GeneratedVisitor;
12604
12605 impl serde::de::Visitor<'_> for GeneratedVisitor {
12606 type Value = GeneratedField;
12607
12608 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12609 write!(formatter, "expected one of: {:?}", &FIELDS)
12610 }
12611
12612 #[allow(unused_variables)]
12613 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12614 where
12615 E: serde::de::Error,
12616 {
12617 match value {
12618 "parallelism" => Ok(GeneratedField::Parallelism),
12619 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12620 }
12621 }
12622 }
12623 deserializer.deserialize_identifier(GeneratedVisitor)
12624 }
12625 }
12626 struct GeneratedVisitor;
12627 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12628 type Value = stream_fragment_graph::Parallelism;
12629
12630 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12631 formatter.write_str("struct stream_plan.StreamFragmentGraph.Parallelism")
12632 }
12633
12634 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::Parallelism, V::Error>
12635 where
12636 V: serde::de::MapAccess<'de>,
12637 {
12638 let mut parallelism__ = None;
12639 while let Some(k) = map_.next_key()? {
12640 match k {
12641 GeneratedField::Parallelism => {
12642 if parallelism__.is_some() {
12643 return Err(serde::de::Error::duplicate_field("parallelism"));
12644 }
12645 parallelism__ =
12646 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12647 ;
12648 }
12649 }
12650 }
12651 Ok(stream_fragment_graph::Parallelism {
12652 parallelism: parallelism__.unwrap_or_default(),
12653 })
12654 }
12655 }
12656 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.Parallelism", FIELDS, GeneratedVisitor)
12657 }
12658}
12659impl serde::Serialize for stream_fragment_graph::StreamFragment {
12660 #[allow(deprecated)]
12661 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12662 where
12663 S: serde::Serializer,
12664 {
12665 use serde::ser::SerializeStruct;
12666 let mut len = 0;
12667 if self.fragment_id != 0 {
12668 len += 1;
12669 }
12670 if self.node.is_some() {
12671 len += 1;
12672 }
12673 if self.fragment_type_mask != 0 {
12674 len += 1;
12675 }
12676 if self.requires_singleton {
12677 len += 1;
12678 }
12679 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", len)?;
12680 if self.fragment_id != 0 {
12681 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
12682 }
12683 if let Some(v) = self.node.as_ref() {
12684 struct_ser.serialize_field("node", v)?;
12685 }
12686 if self.fragment_type_mask != 0 {
12687 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
12688 }
12689 if self.requires_singleton {
12690 struct_ser.serialize_field("requiresSingleton", &self.requires_singleton)?;
12691 }
12692 struct_ser.end()
12693 }
12694}
12695impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragment {
12696 #[allow(deprecated)]
12697 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12698 where
12699 D: serde::Deserializer<'de>,
12700 {
12701 const FIELDS: &[&str] = &[
12702 "fragment_id",
12703 "fragmentId",
12704 "node",
12705 "fragment_type_mask",
12706 "fragmentTypeMask",
12707 "requires_singleton",
12708 "requiresSingleton",
12709 ];
12710
12711 #[allow(clippy::enum_variant_names)]
12712 enum GeneratedField {
12713 FragmentId,
12714 Node,
12715 FragmentTypeMask,
12716 RequiresSingleton,
12717 }
12718 impl<'de> serde::Deserialize<'de> for GeneratedField {
12719 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12720 where
12721 D: serde::Deserializer<'de>,
12722 {
12723 struct GeneratedVisitor;
12724
12725 impl serde::de::Visitor<'_> for GeneratedVisitor {
12726 type Value = GeneratedField;
12727
12728 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12729 write!(formatter, "expected one of: {:?}", &FIELDS)
12730 }
12731
12732 #[allow(unused_variables)]
12733 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12734 where
12735 E: serde::de::Error,
12736 {
12737 match value {
12738 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
12739 "node" => Ok(GeneratedField::Node),
12740 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
12741 "requiresSingleton" | "requires_singleton" => Ok(GeneratedField::RequiresSingleton),
12742 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12743 }
12744 }
12745 }
12746 deserializer.deserialize_identifier(GeneratedVisitor)
12747 }
12748 }
12749 struct GeneratedVisitor;
12750 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12751 type Value = stream_fragment_graph::StreamFragment;
12752
12753 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12754 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragment")
12755 }
12756
12757 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragment, V::Error>
12758 where
12759 V: serde::de::MapAccess<'de>,
12760 {
12761 let mut fragment_id__ = None;
12762 let mut node__ = None;
12763 let mut fragment_type_mask__ = None;
12764 let mut requires_singleton__ = None;
12765 while let Some(k) = map_.next_key()? {
12766 match k {
12767 GeneratedField::FragmentId => {
12768 if fragment_id__.is_some() {
12769 return Err(serde::de::Error::duplicate_field("fragmentId"));
12770 }
12771 fragment_id__ =
12772 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12773 ;
12774 }
12775 GeneratedField::Node => {
12776 if node__.is_some() {
12777 return Err(serde::de::Error::duplicate_field("node"));
12778 }
12779 node__ = map_.next_value()?;
12780 }
12781 GeneratedField::FragmentTypeMask => {
12782 if fragment_type_mask__.is_some() {
12783 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
12784 }
12785 fragment_type_mask__ =
12786 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12787 ;
12788 }
12789 GeneratedField::RequiresSingleton => {
12790 if requires_singleton__.is_some() {
12791 return Err(serde::de::Error::duplicate_field("requiresSingleton"));
12792 }
12793 requires_singleton__ = Some(map_.next_value()?);
12794 }
12795 }
12796 }
12797 Ok(stream_fragment_graph::StreamFragment {
12798 fragment_id: fragment_id__.unwrap_or_default(),
12799 node: node__,
12800 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
12801 requires_singleton: requires_singleton__.unwrap_or_default(),
12802 })
12803 }
12804 }
12805 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", FIELDS, GeneratedVisitor)
12806 }
12807}
12808impl serde::Serialize for stream_fragment_graph::StreamFragmentEdge {
12809 #[allow(deprecated)]
12810 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12811 where
12812 S: serde::Serializer,
12813 {
12814 use serde::ser::SerializeStruct;
12815 let mut len = 0;
12816 if self.dispatch_strategy.is_some() {
12817 len += 1;
12818 }
12819 if self.link_id != 0 {
12820 len += 1;
12821 }
12822 if self.upstream_id != 0 {
12823 len += 1;
12824 }
12825 if self.downstream_id != 0 {
12826 len += 1;
12827 }
12828 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", len)?;
12829 if let Some(v) = self.dispatch_strategy.as_ref() {
12830 struct_ser.serialize_field("dispatchStrategy", v)?;
12831 }
12832 if self.link_id != 0 {
12833 #[allow(clippy::needless_borrow)]
12834 #[allow(clippy::needless_borrows_for_generic_args)]
12835 struct_ser.serialize_field("linkId", ToString::to_string(&self.link_id).as_str())?;
12836 }
12837 if self.upstream_id != 0 {
12838 struct_ser.serialize_field("upstreamId", &self.upstream_id)?;
12839 }
12840 if self.downstream_id != 0 {
12841 struct_ser.serialize_field("downstreamId", &self.downstream_id)?;
12842 }
12843 struct_ser.end()
12844 }
12845}
12846impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragmentEdge {
12847 #[allow(deprecated)]
12848 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12849 where
12850 D: serde::Deserializer<'de>,
12851 {
12852 const FIELDS: &[&str] = &[
12853 "dispatch_strategy",
12854 "dispatchStrategy",
12855 "link_id",
12856 "linkId",
12857 "upstream_id",
12858 "upstreamId",
12859 "downstream_id",
12860 "downstreamId",
12861 ];
12862
12863 #[allow(clippy::enum_variant_names)]
12864 enum GeneratedField {
12865 DispatchStrategy,
12866 LinkId,
12867 UpstreamId,
12868 DownstreamId,
12869 }
12870 impl<'de> serde::Deserialize<'de> for GeneratedField {
12871 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12872 where
12873 D: serde::Deserializer<'de>,
12874 {
12875 struct GeneratedVisitor;
12876
12877 impl serde::de::Visitor<'_> for GeneratedVisitor {
12878 type Value = GeneratedField;
12879
12880 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12881 write!(formatter, "expected one of: {:?}", &FIELDS)
12882 }
12883
12884 #[allow(unused_variables)]
12885 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12886 where
12887 E: serde::de::Error,
12888 {
12889 match value {
12890 "dispatchStrategy" | "dispatch_strategy" => Ok(GeneratedField::DispatchStrategy),
12891 "linkId" | "link_id" => Ok(GeneratedField::LinkId),
12892 "upstreamId" | "upstream_id" => Ok(GeneratedField::UpstreamId),
12893 "downstreamId" | "downstream_id" => Ok(GeneratedField::DownstreamId),
12894 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12895 }
12896 }
12897 }
12898 deserializer.deserialize_identifier(GeneratedVisitor)
12899 }
12900 }
12901 struct GeneratedVisitor;
12902 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12903 type Value = stream_fragment_graph::StreamFragmentEdge;
12904
12905 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12906 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragmentEdge")
12907 }
12908
12909 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragmentEdge, V::Error>
12910 where
12911 V: serde::de::MapAccess<'de>,
12912 {
12913 let mut dispatch_strategy__ = None;
12914 let mut link_id__ = None;
12915 let mut upstream_id__ = None;
12916 let mut downstream_id__ = None;
12917 while let Some(k) = map_.next_key()? {
12918 match k {
12919 GeneratedField::DispatchStrategy => {
12920 if dispatch_strategy__.is_some() {
12921 return Err(serde::de::Error::duplicate_field("dispatchStrategy"));
12922 }
12923 dispatch_strategy__ = map_.next_value()?;
12924 }
12925 GeneratedField::LinkId => {
12926 if link_id__.is_some() {
12927 return Err(serde::de::Error::duplicate_field("linkId"));
12928 }
12929 link_id__ =
12930 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12931 ;
12932 }
12933 GeneratedField::UpstreamId => {
12934 if upstream_id__.is_some() {
12935 return Err(serde::de::Error::duplicate_field("upstreamId"));
12936 }
12937 upstream_id__ =
12938 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12939 ;
12940 }
12941 GeneratedField::DownstreamId => {
12942 if downstream_id__.is_some() {
12943 return Err(serde::de::Error::duplicate_field("downstreamId"));
12944 }
12945 downstream_id__ =
12946 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12947 ;
12948 }
12949 }
12950 }
12951 Ok(stream_fragment_graph::StreamFragmentEdge {
12952 dispatch_strategy: dispatch_strategy__,
12953 link_id: link_id__.unwrap_or_default(),
12954 upstream_id: upstream_id__.unwrap_or_default(),
12955 downstream_id: downstream_id__.unwrap_or_default(),
12956 })
12957 }
12958 }
12959 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", FIELDS, GeneratedVisitor)
12960 }
12961}
12962impl serde::Serialize for StreamFsFetch {
12963 #[allow(deprecated)]
12964 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12965 where
12966 S: serde::Serializer,
12967 {
12968 use serde::ser::SerializeStruct;
12969 let mut len = 0;
12970 if self.source_id != 0 {
12971 len += 1;
12972 }
12973 if self.state_table.is_some() {
12974 len += 1;
12975 }
12976 if self.row_id_index.is_some() {
12977 len += 1;
12978 }
12979 if !self.columns.is_empty() {
12980 len += 1;
12981 }
12982 if !self.with_properties.is_empty() {
12983 len += 1;
12984 }
12985 if self.info.is_some() {
12986 len += 1;
12987 }
12988 if !self.source_name.is_empty() {
12989 len += 1;
12990 }
12991 if self.rate_limit.is_some() {
12992 len += 1;
12993 }
12994 if !self.secret_refs.is_empty() {
12995 len += 1;
12996 }
12997 if self.refresh_mode.is_some() {
12998 len += 1;
12999 }
13000 if self.associated_table_id.is_some() {
13001 len += 1;
13002 }
13003 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetch", len)?;
13004 if self.source_id != 0 {
13005 struct_ser.serialize_field("sourceId", &self.source_id)?;
13006 }
13007 if let Some(v) = self.state_table.as_ref() {
13008 struct_ser.serialize_field("stateTable", v)?;
13009 }
13010 if let Some(v) = self.row_id_index.as_ref() {
13011 struct_ser.serialize_field("rowIdIndex", v)?;
13012 }
13013 if !self.columns.is_empty() {
13014 struct_ser.serialize_field("columns", &self.columns)?;
13015 }
13016 if !self.with_properties.is_empty() {
13017 struct_ser.serialize_field("withProperties", &self.with_properties)?;
13018 }
13019 if let Some(v) = self.info.as_ref() {
13020 struct_ser.serialize_field("info", v)?;
13021 }
13022 if !self.source_name.is_empty() {
13023 struct_ser.serialize_field("sourceName", &self.source_name)?;
13024 }
13025 if let Some(v) = self.rate_limit.as_ref() {
13026 struct_ser.serialize_field("rateLimit", v)?;
13027 }
13028 if !self.secret_refs.is_empty() {
13029 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
13030 }
13031 if let Some(v) = self.refresh_mode.as_ref() {
13032 struct_ser.serialize_field("refreshMode", v)?;
13033 }
13034 if let Some(v) = self.associated_table_id.as_ref() {
13035 struct_ser.serialize_field("associatedTableId", v)?;
13036 }
13037 struct_ser.end()
13038 }
13039}
13040impl<'de> serde::Deserialize<'de> for StreamFsFetch {
13041 #[allow(deprecated)]
13042 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13043 where
13044 D: serde::Deserializer<'de>,
13045 {
13046 const FIELDS: &[&str] = &[
13047 "source_id",
13048 "sourceId",
13049 "state_table",
13050 "stateTable",
13051 "row_id_index",
13052 "rowIdIndex",
13053 "columns",
13054 "with_properties",
13055 "withProperties",
13056 "info",
13057 "source_name",
13058 "sourceName",
13059 "rate_limit",
13060 "rateLimit",
13061 "secret_refs",
13062 "secretRefs",
13063 "refresh_mode",
13064 "refreshMode",
13065 "associated_table_id",
13066 "associatedTableId",
13067 ];
13068
13069 #[allow(clippy::enum_variant_names)]
13070 enum GeneratedField {
13071 SourceId,
13072 StateTable,
13073 RowIdIndex,
13074 Columns,
13075 WithProperties,
13076 Info,
13077 SourceName,
13078 RateLimit,
13079 SecretRefs,
13080 RefreshMode,
13081 AssociatedTableId,
13082 }
13083 impl<'de> serde::Deserialize<'de> for GeneratedField {
13084 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13085 where
13086 D: serde::Deserializer<'de>,
13087 {
13088 struct GeneratedVisitor;
13089
13090 impl serde::de::Visitor<'_> for GeneratedVisitor {
13091 type Value = GeneratedField;
13092
13093 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13094 write!(formatter, "expected one of: {:?}", &FIELDS)
13095 }
13096
13097 #[allow(unused_variables)]
13098 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13099 where
13100 E: serde::de::Error,
13101 {
13102 match value {
13103 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
13104 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
13105 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
13106 "columns" => Ok(GeneratedField::Columns),
13107 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
13108 "info" => Ok(GeneratedField::Info),
13109 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
13110 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
13111 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
13112 "refreshMode" | "refresh_mode" => Ok(GeneratedField::RefreshMode),
13113 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
13114 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13115 }
13116 }
13117 }
13118 deserializer.deserialize_identifier(GeneratedVisitor)
13119 }
13120 }
13121 struct GeneratedVisitor;
13122 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13123 type Value = StreamFsFetch;
13124
13125 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13126 formatter.write_str("struct stream_plan.StreamFsFetch")
13127 }
13128
13129 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetch, V::Error>
13130 where
13131 V: serde::de::MapAccess<'de>,
13132 {
13133 let mut source_id__ = None;
13134 let mut state_table__ = None;
13135 let mut row_id_index__ = None;
13136 let mut columns__ = None;
13137 let mut with_properties__ = None;
13138 let mut info__ = None;
13139 let mut source_name__ = None;
13140 let mut rate_limit__ = None;
13141 let mut secret_refs__ = None;
13142 let mut refresh_mode__ = None;
13143 let mut associated_table_id__ = None;
13144 while let Some(k) = map_.next_key()? {
13145 match k {
13146 GeneratedField::SourceId => {
13147 if source_id__.is_some() {
13148 return Err(serde::de::Error::duplicate_field("sourceId"));
13149 }
13150 source_id__ =
13151 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13152 ;
13153 }
13154 GeneratedField::StateTable => {
13155 if state_table__.is_some() {
13156 return Err(serde::de::Error::duplicate_field("stateTable"));
13157 }
13158 state_table__ = map_.next_value()?;
13159 }
13160 GeneratedField::RowIdIndex => {
13161 if row_id_index__.is_some() {
13162 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
13163 }
13164 row_id_index__ =
13165 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13166 ;
13167 }
13168 GeneratedField::Columns => {
13169 if columns__.is_some() {
13170 return Err(serde::de::Error::duplicate_field("columns"));
13171 }
13172 columns__ = Some(map_.next_value()?);
13173 }
13174 GeneratedField::WithProperties => {
13175 if with_properties__.is_some() {
13176 return Err(serde::de::Error::duplicate_field("withProperties"));
13177 }
13178 with_properties__ = Some(
13179 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13180 );
13181 }
13182 GeneratedField::Info => {
13183 if info__.is_some() {
13184 return Err(serde::de::Error::duplicate_field("info"));
13185 }
13186 info__ = map_.next_value()?;
13187 }
13188 GeneratedField::SourceName => {
13189 if source_name__.is_some() {
13190 return Err(serde::de::Error::duplicate_field("sourceName"));
13191 }
13192 source_name__ = Some(map_.next_value()?);
13193 }
13194 GeneratedField::RateLimit => {
13195 if rate_limit__.is_some() {
13196 return Err(serde::de::Error::duplicate_field("rateLimit"));
13197 }
13198 rate_limit__ =
13199 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13200 ;
13201 }
13202 GeneratedField::SecretRefs => {
13203 if secret_refs__.is_some() {
13204 return Err(serde::de::Error::duplicate_field("secretRefs"));
13205 }
13206 secret_refs__ = Some(
13207 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13208 );
13209 }
13210 GeneratedField::RefreshMode => {
13211 if refresh_mode__.is_some() {
13212 return Err(serde::de::Error::duplicate_field("refreshMode"));
13213 }
13214 refresh_mode__ = map_.next_value()?;
13215 }
13216 GeneratedField::AssociatedTableId => {
13217 if associated_table_id__.is_some() {
13218 return Err(serde::de::Error::duplicate_field("associatedTableId"));
13219 }
13220 associated_table_id__ =
13221 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13222 ;
13223 }
13224 }
13225 }
13226 Ok(StreamFsFetch {
13227 source_id: source_id__.unwrap_or_default(),
13228 state_table: state_table__,
13229 row_id_index: row_id_index__,
13230 columns: columns__.unwrap_or_default(),
13231 with_properties: with_properties__.unwrap_or_default(),
13232 info: info__,
13233 source_name: source_name__.unwrap_or_default(),
13234 rate_limit: rate_limit__,
13235 secret_refs: secret_refs__.unwrap_or_default(),
13236 refresh_mode: refresh_mode__,
13237 associated_table_id: associated_table_id__,
13238 })
13239 }
13240 }
13241 deserializer.deserialize_struct("stream_plan.StreamFsFetch", FIELDS, GeneratedVisitor)
13242 }
13243}
13244impl serde::Serialize for StreamFsFetchNode {
13245 #[allow(deprecated)]
13246 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13247 where
13248 S: serde::Serializer,
13249 {
13250 use serde::ser::SerializeStruct;
13251 let mut len = 0;
13252 if self.node_inner.is_some() {
13253 len += 1;
13254 }
13255 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetchNode", len)?;
13256 if let Some(v) = self.node_inner.as_ref() {
13257 struct_ser.serialize_field("nodeInner", v)?;
13258 }
13259 struct_ser.end()
13260 }
13261}
13262impl<'de> serde::Deserialize<'de> for StreamFsFetchNode {
13263 #[allow(deprecated)]
13264 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13265 where
13266 D: serde::Deserializer<'de>,
13267 {
13268 const FIELDS: &[&str] = &[
13269 "node_inner",
13270 "nodeInner",
13271 ];
13272
13273 #[allow(clippy::enum_variant_names)]
13274 enum GeneratedField {
13275 NodeInner,
13276 }
13277 impl<'de> serde::Deserialize<'de> for GeneratedField {
13278 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13279 where
13280 D: serde::Deserializer<'de>,
13281 {
13282 struct GeneratedVisitor;
13283
13284 impl serde::de::Visitor<'_> for GeneratedVisitor {
13285 type Value = GeneratedField;
13286
13287 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13288 write!(formatter, "expected one of: {:?}", &FIELDS)
13289 }
13290
13291 #[allow(unused_variables)]
13292 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13293 where
13294 E: serde::de::Error,
13295 {
13296 match value {
13297 "nodeInner" | "node_inner" => Ok(GeneratedField::NodeInner),
13298 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13299 }
13300 }
13301 }
13302 deserializer.deserialize_identifier(GeneratedVisitor)
13303 }
13304 }
13305 struct GeneratedVisitor;
13306 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13307 type Value = StreamFsFetchNode;
13308
13309 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13310 formatter.write_str("struct stream_plan.StreamFsFetchNode")
13311 }
13312
13313 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetchNode, V::Error>
13314 where
13315 V: serde::de::MapAccess<'de>,
13316 {
13317 let mut node_inner__ = None;
13318 while let Some(k) = map_.next_key()? {
13319 match k {
13320 GeneratedField::NodeInner => {
13321 if node_inner__.is_some() {
13322 return Err(serde::de::Error::duplicate_field("nodeInner"));
13323 }
13324 node_inner__ = map_.next_value()?;
13325 }
13326 }
13327 }
13328 Ok(StreamFsFetchNode {
13329 node_inner: node_inner__,
13330 })
13331 }
13332 }
13333 deserializer.deserialize_struct("stream_plan.StreamFsFetchNode", FIELDS, GeneratedVisitor)
13334 }
13335}
13336impl serde::Serialize for StreamMessage {
13337 #[allow(deprecated)]
13338 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13339 where
13340 S: serde::Serializer,
13341 {
13342 use serde::ser::SerializeStruct;
13343 let mut len = 0;
13344 if self.stream_message.is_some() {
13345 len += 1;
13346 }
13347 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessage", len)?;
13348 if let Some(v) = self.stream_message.as_ref() {
13349 match v {
13350 stream_message::StreamMessage::StreamChunk(v) => {
13351 struct_ser.serialize_field("streamChunk", v)?;
13352 }
13353 stream_message::StreamMessage::Barrier(v) => {
13354 struct_ser.serialize_field("barrier", v)?;
13355 }
13356 stream_message::StreamMessage::Watermark(v) => {
13357 struct_ser.serialize_field("watermark", v)?;
13358 }
13359 }
13360 }
13361 struct_ser.end()
13362 }
13363}
13364impl<'de> serde::Deserialize<'de> for StreamMessage {
13365 #[allow(deprecated)]
13366 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13367 where
13368 D: serde::Deserializer<'de>,
13369 {
13370 const FIELDS: &[&str] = &[
13371 "stream_chunk",
13372 "streamChunk",
13373 "barrier",
13374 "watermark",
13375 ];
13376
13377 #[allow(clippy::enum_variant_names)]
13378 enum GeneratedField {
13379 StreamChunk,
13380 Barrier,
13381 Watermark,
13382 }
13383 impl<'de> serde::Deserialize<'de> for GeneratedField {
13384 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13385 where
13386 D: serde::Deserializer<'de>,
13387 {
13388 struct GeneratedVisitor;
13389
13390 impl serde::de::Visitor<'_> for GeneratedVisitor {
13391 type Value = GeneratedField;
13392
13393 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13394 write!(formatter, "expected one of: {:?}", &FIELDS)
13395 }
13396
13397 #[allow(unused_variables)]
13398 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13399 where
13400 E: serde::de::Error,
13401 {
13402 match value {
13403 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
13404 "barrier" => Ok(GeneratedField::Barrier),
13405 "watermark" => Ok(GeneratedField::Watermark),
13406 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13407 }
13408 }
13409 }
13410 deserializer.deserialize_identifier(GeneratedVisitor)
13411 }
13412 }
13413 struct GeneratedVisitor;
13414 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13415 type Value = StreamMessage;
13416
13417 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13418 formatter.write_str("struct stream_plan.StreamMessage")
13419 }
13420
13421 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessage, V::Error>
13422 where
13423 V: serde::de::MapAccess<'de>,
13424 {
13425 let mut stream_message__ = None;
13426 while let Some(k) = map_.next_key()? {
13427 match k {
13428 GeneratedField::StreamChunk => {
13429 if stream_message__.is_some() {
13430 return Err(serde::de::Error::duplicate_field("streamChunk"));
13431 }
13432 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::StreamChunk)
13433;
13434 }
13435 GeneratedField::Barrier => {
13436 if stream_message__.is_some() {
13437 return Err(serde::de::Error::duplicate_field("barrier"));
13438 }
13439 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Barrier)
13440;
13441 }
13442 GeneratedField::Watermark => {
13443 if stream_message__.is_some() {
13444 return Err(serde::de::Error::duplicate_field("watermark"));
13445 }
13446 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Watermark)
13447;
13448 }
13449 }
13450 }
13451 Ok(StreamMessage {
13452 stream_message: stream_message__,
13453 })
13454 }
13455 }
13456 deserializer.deserialize_struct("stream_plan.StreamMessage", FIELDS, GeneratedVisitor)
13457 }
13458}
13459impl serde::Serialize for StreamMessageBatch {
13460 #[allow(deprecated)]
13461 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13462 where
13463 S: serde::Serializer,
13464 {
13465 use serde::ser::SerializeStruct;
13466 let mut len = 0;
13467 if self.stream_message_batch.is_some() {
13468 len += 1;
13469 }
13470 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch", len)?;
13471 if let Some(v) = self.stream_message_batch.as_ref() {
13472 match v {
13473 stream_message_batch::StreamMessageBatch::StreamChunk(v) => {
13474 struct_ser.serialize_field("streamChunk", v)?;
13475 }
13476 stream_message_batch::StreamMessageBatch::BarrierBatch(v) => {
13477 struct_ser.serialize_field("barrierBatch", v)?;
13478 }
13479 stream_message_batch::StreamMessageBatch::Watermark(v) => {
13480 struct_ser.serialize_field("watermark", v)?;
13481 }
13482 }
13483 }
13484 struct_ser.end()
13485 }
13486}
13487impl<'de> serde::Deserialize<'de> for StreamMessageBatch {
13488 #[allow(deprecated)]
13489 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13490 where
13491 D: serde::Deserializer<'de>,
13492 {
13493 const FIELDS: &[&str] = &[
13494 "stream_chunk",
13495 "streamChunk",
13496 "barrier_batch",
13497 "barrierBatch",
13498 "watermark",
13499 ];
13500
13501 #[allow(clippy::enum_variant_names)]
13502 enum GeneratedField {
13503 StreamChunk,
13504 BarrierBatch,
13505 Watermark,
13506 }
13507 impl<'de> serde::Deserialize<'de> for GeneratedField {
13508 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13509 where
13510 D: serde::Deserializer<'de>,
13511 {
13512 struct GeneratedVisitor;
13513
13514 impl serde::de::Visitor<'_> for GeneratedVisitor {
13515 type Value = GeneratedField;
13516
13517 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13518 write!(formatter, "expected one of: {:?}", &FIELDS)
13519 }
13520
13521 #[allow(unused_variables)]
13522 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13523 where
13524 E: serde::de::Error,
13525 {
13526 match value {
13527 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
13528 "barrierBatch" | "barrier_batch" => Ok(GeneratedField::BarrierBatch),
13529 "watermark" => Ok(GeneratedField::Watermark),
13530 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13531 }
13532 }
13533 }
13534 deserializer.deserialize_identifier(GeneratedVisitor)
13535 }
13536 }
13537 struct GeneratedVisitor;
13538 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13539 type Value = StreamMessageBatch;
13540
13541 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13542 formatter.write_str("struct stream_plan.StreamMessageBatch")
13543 }
13544
13545 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessageBatch, V::Error>
13546 where
13547 V: serde::de::MapAccess<'de>,
13548 {
13549 let mut stream_message_batch__ = None;
13550 while let Some(k) = map_.next_key()? {
13551 match k {
13552 GeneratedField::StreamChunk => {
13553 if stream_message_batch__.is_some() {
13554 return Err(serde::de::Error::duplicate_field("streamChunk"));
13555 }
13556 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::StreamChunk)
13557;
13558 }
13559 GeneratedField::BarrierBatch => {
13560 if stream_message_batch__.is_some() {
13561 return Err(serde::de::Error::duplicate_field("barrierBatch"));
13562 }
13563 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::BarrierBatch)
13564;
13565 }
13566 GeneratedField::Watermark => {
13567 if stream_message_batch__.is_some() {
13568 return Err(serde::de::Error::duplicate_field("watermark"));
13569 }
13570 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::Watermark)
13571;
13572 }
13573 }
13574 }
13575 Ok(StreamMessageBatch {
13576 stream_message_batch: stream_message_batch__,
13577 })
13578 }
13579 }
13580 deserializer.deserialize_struct("stream_plan.StreamMessageBatch", FIELDS, GeneratedVisitor)
13581 }
13582}
13583impl serde::Serialize for stream_message_batch::BarrierBatch {
13584 #[allow(deprecated)]
13585 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13586 where
13587 S: serde::Serializer,
13588 {
13589 use serde::ser::SerializeStruct;
13590 let mut len = 0;
13591 if !self.barriers.is_empty() {
13592 len += 1;
13593 }
13594 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", len)?;
13595 if !self.barriers.is_empty() {
13596 struct_ser.serialize_field("barriers", &self.barriers)?;
13597 }
13598 struct_ser.end()
13599 }
13600}
13601impl<'de> serde::Deserialize<'de> for stream_message_batch::BarrierBatch {
13602 #[allow(deprecated)]
13603 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13604 where
13605 D: serde::Deserializer<'de>,
13606 {
13607 const FIELDS: &[&str] = &[
13608 "barriers",
13609 ];
13610
13611 #[allow(clippy::enum_variant_names)]
13612 enum GeneratedField {
13613 Barriers,
13614 }
13615 impl<'de> serde::Deserialize<'de> for GeneratedField {
13616 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13617 where
13618 D: serde::Deserializer<'de>,
13619 {
13620 struct GeneratedVisitor;
13621
13622 impl serde::de::Visitor<'_> for GeneratedVisitor {
13623 type Value = GeneratedField;
13624
13625 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13626 write!(formatter, "expected one of: {:?}", &FIELDS)
13627 }
13628
13629 #[allow(unused_variables)]
13630 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13631 where
13632 E: serde::de::Error,
13633 {
13634 match value {
13635 "barriers" => Ok(GeneratedField::Barriers),
13636 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13637 }
13638 }
13639 }
13640 deserializer.deserialize_identifier(GeneratedVisitor)
13641 }
13642 }
13643 struct GeneratedVisitor;
13644 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13645 type Value = stream_message_batch::BarrierBatch;
13646
13647 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13648 formatter.write_str("struct stream_plan.StreamMessageBatch.BarrierBatch")
13649 }
13650
13651 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_message_batch::BarrierBatch, V::Error>
13652 where
13653 V: serde::de::MapAccess<'de>,
13654 {
13655 let mut barriers__ = None;
13656 while let Some(k) = map_.next_key()? {
13657 match k {
13658 GeneratedField::Barriers => {
13659 if barriers__.is_some() {
13660 return Err(serde::de::Error::duplicate_field("barriers"));
13661 }
13662 barriers__ = Some(map_.next_value()?);
13663 }
13664 }
13665 }
13666 Ok(stream_message_batch::BarrierBatch {
13667 barriers: barriers__.unwrap_or_default(),
13668 })
13669 }
13670 }
13671 deserializer.deserialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", FIELDS, GeneratedVisitor)
13672 }
13673}
13674impl serde::Serialize for StreamNode {
13675 #[allow(deprecated)]
13676 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13677 where
13678 S: serde::Serializer,
13679 {
13680 use serde::ser::SerializeStruct;
13681 let mut len = 0;
13682 if self.operator_id != 0 {
13683 len += 1;
13684 }
13685 if !self.input.is_empty() {
13686 len += 1;
13687 }
13688 if !self.stream_key.is_empty() {
13689 len += 1;
13690 }
13691 if self.stream_kind != 0 {
13692 len += 1;
13693 }
13694 if !self.identity.is_empty() {
13695 len += 1;
13696 }
13697 if !self.fields.is_empty() {
13698 len += 1;
13699 }
13700 if self.node_body.is_some() {
13701 len += 1;
13702 }
13703 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamNode", len)?;
13704 if self.operator_id != 0 {
13705 #[allow(clippy::needless_borrow)]
13706 #[allow(clippy::needless_borrows_for_generic_args)]
13707 struct_ser.serialize_field("operatorId", ToString::to_string(&self.operator_id).as_str())?;
13708 }
13709 if !self.input.is_empty() {
13710 struct_ser.serialize_field("input", &self.input)?;
13711 }
13712 if !self.stream_key.is_empty() {
13713 struct_ser.serialize_field("streamKey", &self.stream_key)?;
13714 }
13715 if self.stream_kind != 0 {
13716 let v = stream_node::StreamKind::try_from(self.stream_kind)
13717 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_kind)))?;
13718 struct_ser.serialize_field("streamKind", &v)?;
13719 }
13720 if !self.identity.is_empty() {
13721 struct_ser.serialize_field("identity", &self.identity)?;
13722 }
13723 if !self.fields.is_empty() {
13724 struct_ser.serialize_field("fields", &self.fields)?;
13725 }
13726 if let Some(v) = self.node_body.as_ref() {
13727 match v {
13728 stream_node::NodeBody::Source(v) => {
13729 struct_ser.serialize_field("source", v)?;
13730 }
13731 stream_node::NodeBody::Project(v) => {
13732 struct_ser.serialize_field("project", v)?;
13733 }
13734 stream_node::NodeBody::Filter(v) => {
13735 struct_ser.serialize_field("filter", v)?;
13736 }
13737 stream_node::NodeBody::Materialize(v) => {
13738 struct_ser.serialize_field("materialize", v)?;
13739 }
13740 stream_node::NodeBody::StatelessSimpleAgg(v) => {
13741 struct_ser.serialize_field("statelessSimpleAgg", v)?;
13742 }
13743 stream_node::NodeBody::SimpleAgg(v) => {
13744 struct_ser.serialize_field("simpleAgg", v)?;
13745 }
13746 stream_node::NodeBody::HashAgg(v) => {
13747 struct_ser.serialize_field("hashAgg", v)?;
13748 }
13749 stream_node::NodeBody::AppendOnlyTopN(v) => {
13750 struct_ser.serialize_field("appendOnlyTopN", v)?;
13751 }
13752 stream_node::NodeBody::HashJoin(v) => {
13753 struct_ser.serialize_field("hashJoin", v)?;
13754 }
13755 stream_node::NodeBody::TopN(v) => {
13756 struct_ser.serialize_field("topN", v)?;
13757 }
13758 stream_node::NodeBody::HopWindow(v) => {
13759 struct_ser.serialize_field("hopWindow", v)?;
13760 }
13761 stream_node::NodeBody::Merge(v) => {
13762 struct_ser.serialize_field("merge", v)?;
13763 }
13764 stream_node::NodeBody::Exchange(v) => {
13765 struct_ser.serialize_field("exchange", v)?;
13766 }
13767 stream_node::NodeBody::StreamScan(v) => {
13768 struct_ser.serialize_field("streamScan", v)?;
13769 }
13770 stream_node::NodeBody::BatchPlan(v) => {
13771 struct_ser.serialize_field("batchPlan", v)?;
13772 }
13773 stream_node::NodeBody::Lookup(v) => {
13774 struct_ser.serialize_field("lookup", v)?;
13775 }
13776 stream_node::NodeBody::Arrange(v) => {
13777 struct_ser.serialize_field("arrange", v)?;
13778 }
13779 stream_node::NodeBody::LookupUnion(v) => {
13780 struct_ser.serialize_field("lookupUnion", v)?;
13781 }
13782 stream_node::NodeBody::Union(v) => {
13783 struct_ser.serialize_field("union", v)?;
13784 }
13785 stream_node::NodeBody::DeltaIndexJoin(v) => {
13786 struct_ser.serialize_field("deltaIndexJoin", v)?;
13787 }
13788 stream_node::NodeBody::Sink(v) => {
13789 struct_ser.serialize_field("sink", v)?;
13790 }
13791 stream_node::NodeBody::Expand(v) => {
13792 struct_ser.serialize_field("expand", v)?;
13793 }
13794 stream_node::NodeBody::DynamicFilter(v) => {
13795 struct_ser.serialize_field("dynamicFilter", v)?;
13796 }
13797 stream_node::NodeBody::ProjectSet(v) => {
13798 struct_ser.serialize_field("projectSet", v)?;
13799 }
13800 stream_node::NodeBody::GroupTopN(v) => {
13801 struct_ser.serialize_field("groupTopN", v)?;
13802 }
13803 stream_node::NodeBody::Sort(v) => {
13804 struct_ser.serialize_field("sort", v)?;
13805 }
13806 stream_node::NodeBody::WatermarkFilter(v) => {
13807 struct_ser.serialize_field("watermarkFilter", v)?;
13808 }
13809 stream_node::NodeBody::Dml(v) => {
13810 struct_ser.serialize_field("dml", v)?;
13811 }
13812 stream_node::NodeBody::RowIdGen(v) => {
13813 struct_ser.serialize_field("rowIdGen", v)?;
13814 }
13815 stream_node::NodeBody::Now(v) => {
13816 struct_ser.serialize_field("now", v)?;
13817 }
13818 stream_node::NodeBody::AppendOnlyGroupTopN(v) => {
13819 struct_ser.serialize_field("appendOnlyGroupTopN", v)?;
13820 }
13821 stream_node::NodeBody::TemporalJoin(v) => {
13822 struct_ser.serialize_field("temporalJoin", v)?;
13823 }
13824 stream_node::NodeBody::BarrierRecv(v) => {
13825 struct_ser.serialize_field("barrierRecv", v)?;
13826 }
13827 stream_node::NodeBody::Values(v) => {
13828 struct_ser.serialize_field("values", v)?;
13829 }
13830 stream_node::NodeBody::AppendOnlyDedup(v) => {
13831 struct_ser.serialize_field("appendOnlyDedup", v)?;
13832 }
13833 stream_node::NodeBody::NoOp(v) => {
13834 struct_ser.serialize_field("noOp", v)?;
13835 }
13836 stream_node::NodeBody::EowcOverWindow(v) => {
13837 struct_ser.serialize_field("eowcOverWindow", v)?;
13838 }
13839 stream_node::NodeBody::OverWindow(v) => {
13840 struct_ser.serialize_field("overWindow", v)?;
13841 }
13842 stream_node::NodeBody::StreamFsFetch(v) => {
13843 struct_ser.serialize_field("streamFsFetch", v)?;
13844 }
13845 stream_node::NodeBody::StreamCdcScan(v) => {
13846 struct_ser.serialize_field("streamCdcScan", v)?;
13847 }
13848 stream_node::NodeBody::CdcFilter(v) => {
13849 struct_ser.serialize_field("cdcFilter", v)?;
13850 }
13851 stream_node::NodeBody::SourceBackfill(v) => {
13852 struct_ser.serialize_field("sourceBackfill", v)?;
13853 }
13854 stream_node::NodeBody::Changelog(v) => {
13855 struct_ser.serialize_field("changelog", v)?;
13856 }
13857 stream_node::NodeBody::LocalApproxPercentile(v) => {
13858 struct_ser.serialize_field("localApproxPercentile", v)?;
13859 }
13860 stream_node::NodeBody::GlobalApproxPercentile(v) => {
13861 struct_ser.serialize_field("globalApproxPercentile", v)?;
13862 }
13863 stream_node::NodeBody::RowMerge(v) => {
13864 struct_ser.serialize_field("rowMerge", v)?;
13865 }
13866 stream_node::NodeBody::AsOfJoin(v) => {
13867 struct_ser.serialize_field("asOfJoin", v)?;
13868 }
13869 stream_node::NodeBody::SyncLogStore(v) => {
13870 struct_ser.serialize_field("syncLogStore", v)?;
13871 }
13872 stream_node::NodeBody::MaterializedExprs(v) => {
13873 struct_ser.serialize_field("materializedExprs", v)?;
13874 }
13875 stream_node::NodeBody::VectorIndexWrite(v) => {
13876 struct_ser.serialize_field("vectorIndexWrite", v)?;
13877 }
13878 stream_node::NodeBody::UpstreamSinkUnion(v) => {
13879 struct_ser.serialize_field("upstreamSinkUnion", v)?;
13880 }
13881 stream_node::NodeBody::LocalityProvider(v) => {
13882 struct_ser.serialize_field("localityProvider", v)?;
13883 }
13884 stream_node::NodeBody::EowcGapFill(v) => {
13885 struct_ser.serialize_field("eowcGapFill", v)?;
13886 }
13887 stream_node::NodeBody::GapFill(v) => {
13888 struct_ser.serialize_field("gapFill", v)?;
13889 }
13890 stream_node::NodeBody::VectorIndexLookupJoin(v) => {
13891 struct_ser.serialize_field("vectorIndexLookupJoin", v)?;
13892 }
13893 }
13894 }
13895 struct_ser.end()
13896 }
13897}
13898impl<'de> serde::Deserialize<'de> for StreamNode {
13899 #[allow(deprecated)]
13900 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13901 where
13902 D: serde::Deserializer<'de>,
13903 {
13904 const FIELDS: &[&str] = &[
13905 "operator_id",
13906 "operatorId",
13907 "input",
13908 "stream_key",
13909 "streamKey",
13910 "stream_kind",
13911 "streamKind",
13912 "identity",
13913 "fields",
13914 "source",
13915 "project",
13916 "filter",
13917 "materialize",
13918 "stateless_simple_agg",
13919 "statelessSimpleAgg",
13920 "simple_agg",
13921 "simpleAgg",
13922 "hash_agg",
13923 "hashAgg",
13924 "append_only_top_n",
13925 "appendOnlyTopN",
13926 "hash_join",
13927 "hashJoin",
13928 "top_n",
13929 "topN",
13930 "hop_window",
13931 "hopWindow",
13932 "merge",
13933 "exchange",
13934 "stream_scan",
13935 "streamScan",
13936 "batch_plan",
13937 "batchPlan",
13938 "lookup",
13939 "arrange",
13940 "lookup_union",
13941 "lookupUnion",
13942 "union",
13943 "delta_index_join",
13944 "deltaIndexJoin",
13945 "sink",
13946 "expand",
13947 "dynamic_filter",
13948 "dynamicFilter",
13949 "project_set",
13950 "projectSet",
13951 "group_top_n",
13952 "groupTopN",
13953 "sort",
13954 "watermark_filter",
13955 "watermarkFilter",
13956 "dml",
13957 "row_id_gen",
13958 "rowIdGen",
13959 "now",
13960 "append_only_group_top_n",
13961 "appendOnlyGroupTopN",
13962 "temporal_join",
13963 "temporalJoin",
13964 "barrier_recv",
13965 "barrierRecv",
13966 "values",
13967 "append_only_dedup",
13968 "appendOnlyDedup",
13969 "no_op",
13970 "noOp",
13971 "eowc_over_window",
13972 "eowcOverWindow",
13973 "over_window",
13974 "overWindow",
13975 "stream_fs_fetch",
13976 "streamFsFetch",
13977 "stream_cdc_scan",
13978 "streamCdcScan",
13979 "cdc_filter",
13980 "cdcFilter",
13981 "source_backfill",
13982 "sourceBackfill",
13983 "changelog",
13984 "local_approx_percentile",
13985 "localApproxPercentile",
13986 "global_approx_percentile",
13987 "globalApproxPercentile",
13988 "row_merge",
13989 "rowMerge",
13990 "as_of_join",
13991 "asOfJoin",
13992 "sync_log_store",
13993 "syncLogStore",
13994 "materialized_exprs",
13995 "materializedExprs",
13996 "vector_index_write",
13997 "vectorIndexWrite",
13998 "upstream_sink_union",
13999 "upstreamSinkUnion",
14000 "locality_provider",
14001 "localityProvider",
14002 "eowc_gap_fill",
14003 "eowcGapFill",
14004 "gap_fill",
14005 "gapFill",
14006 "vector_index_lookup_join",
14007 "vectorIndexLookupJoin",
14008 ];
14009
14010 #[allow(clippy::enum_variant_names)]
14011 enum GeneratedField {
14012 OperatorId,
14013 Input,
14014 StreamKey,
14015 StreamKind,
14016 Identity,
14017 Fields,
14018 Source,
14019 Project,
14020 Filter,
14021 Materialize,
14022 StatelessSimpleAgg,
14023 SimpleAgg,
14024 HashAgg,
14025 AppendOnlyTopN,
14026 HashJoin,
14027 TopN,
14028 HopWindow,
14029 Merge,
14030 Exchange,
14031 StreamScan,
14032 BatchPlan,
14033 Lookup,
14034 Arrange,
14035 LookupUnion,
14036 Union,
14037 DeltaIndexJoin,
14038 Sink,
14039 Expand,
14040 DynamicFilter,
14041 ProjectSet,
14042 GroupTopN,
14043 Sort,
14044 WatermarkFilter,
14045 Dml,
14046 RowIdGen,
14047 Now,
14048 AppendOnlyGroupTopN,
14049 TemporalJoin,
14050 BarrierRecv,
14051 Values,
14052 AppendOnlyDedup,
14053 NoOp,
14054 EowcOverWindow,
14055 OverWindow,
14056 StreamFsFetch,
14057 StreamCdcScan,
14058 CdcFilter,
14059 SourceBackfill,
14060 Changelog,
14061 LocalApproxPercentile,
14062 GlobalApproxPercentile,
14063 RowMerge,
14064 AsOfJoin,
14065 SyncLogStore,
14066 MaterializedExprs,
14067 VectorIndexWrite,
14068 UpstreamSinkUnion,
14069 LocalityProvider,
14070 EowcGapFill,
14071 GapFill,
14072 VectorIndexLookupJoin,
14073 }
14074 impl<'de> serde::Deserialize<'de> for GeneratedField {
14075 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14076 where
14077 D: serde::Deserializer<'de>,
14078 {
14079 struct GeneratedVisitor;
14080
14081 impl serde::de::Visitor<'_> for GeneratedVisitor {
14082 type Value = GeneratedField;
14083
14084 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14085 write!(formatter, "expected one of: {:?}", &FIELDS)
14086 }
14087
14088 #[allow(unused_variables)]
14089 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14090 where
14091 E: serde::de::Error,
14092 {
14093 match value {
14094 "operatorId" | "operator_id" => Ok(GeneratedField::OperatorId),
14095 "input" => Ok(GeneratedField::Input),
14096 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
14097 "streamKind" | "stream_kind" => Ok(GeneratedField::StreamKind),
14098 "identity" => Ok(GeneratedField::Identity),
14099 "fields" => Ok(GeneratedField::Fields),
14100 "source" => Ok(GeneratedField::Source),
14101 "project" => Ok(GeneratedField::Project),
14102 "filter" => Ok(GeneratedField::Filter),
14103 "materialize" => Ok(GeneratedField::Materialize),
14104 "statelessSimpleAgg" | "stateless_simple_agg" => Ok(GeneratedField::StatelessSimpleAgg),
14105 "simpleAgg" | "simple_agg" => Ok(GeneratedField::SimpleAgg),
14106 "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
14107 "appendOnlyTopN" | "append_only_top_n" => Ok(GeneratedField::AppendOnlyTopN),
14108 "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
14109 "topN" | "top_n" => Ok(GeneratedField::TopN),
14110 "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
14111 "merge" => Ok(GeneratedField::Merge),
14112 "exchange" => Ok(GeneratedField::Exchange),
14113 "streamScan" | "stream_scan" => Ok(GeneratedField::StreamScan),
14114 "batchPlan" | "batch_plan" => Ok(GeneratedField::BatchPlan),
14115 "lookup" => Ok(GeneratedField::Lookup),
14116 "arrange" => Ok(GeneratedField::Arrange),
14117 "lookupUnion" | "lookup_union" => Ok(GeneratedField::LookupUnion),
14118 "union" => Ok(GeneratedField::Union),
14119 "deltaIndexJoin" | "delta_index_join" => Ok(GeneratedField::DeltaIndexJoin),
14120 "sink" => Ok(GeneratedField::Sink),
14121 "expand" => Ok(GeneratedField::Expand),
14122 "dynamicFilter" | "dynamic_filter" => Ok(GeneratedField::DynamicFilter),
14123 "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
14124 "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
14125 "sort" => Ok(GeneratedField::Sort),
14126 "watermarkFilter" | "watermark_filter" => Ok(GeneratedField::WatermarkFilter),
14127 "dml" => Ok(GeneratedField::Dml),
14128 "rowIdGen" | "row_id_gen" => Ok(GeneratedField::RowIdGen),
14129 "now" => Ok(GeneratedField::Now),
14130 "appendOnlyGroupTopN" | "append_only_group_top_n" => Ok(GeneratedField::AppendOnlyGroupTopN),
14131 "temporalJoin" | "temporal_join" => Ok(GeneratedField::TemporalJoin),
14132 "barrierRecv" | "barrier_recv" => Ok(GeneratedField::BarrierRecv),
14133 "values" => Ok(GeneratedField::Values),
14134 "appendOnlyDedup" | "append_only_dedup" => Ok(GeneratedField::AppendOnlyDedup),
14135 "noOp" | "no_op" => Ok(GeneratedField::NoOp),
14136 "eowcOverWindow" | "eowc_over_window" => Ok(GeneratedField::EowcOverWindow),
14137 "overWindow" | "over_window" => Ok(GeneratedField::OverWindow),
14138 "streamFsFetch" | "stream_fs_fetch" => Ok(GeneratedField::StreamFsFetch),
14139 "streamCdcScan" | "stream_cdc_scan" => Ok(GeneratedField::StreamCdcScan),
14140 "cdcFilter" | "cdc_filter" => Ok(GeneratedField::CdcFilter),
14141 "sourceBackfill" | "source_backfill" => Ok(GeneratedField::SourceBackfill),
14142 "changelog" => Ok(GeneratedField::Changelog),
14143 "localApproxPercentile" | "local_approx_percentile" => Ok(GeneratedField::LocalApproxPercentile),
14144 "globalApproxPercentile" | "global_approx_percentile" => Ok(GeneratedField::GlobalApproxPercentile),
14145 "rowMerge" | "row_merge" => Ok(GeneratedField::RowMerge),
14146 "asOfJoin" | "as_of_join" => Ok(GeneratedField::AsOfJoin),
14147 "syncLogStore" | "sync_log_store" => Ok(GeneratedField::SyncLogStore),
14148 "materializedExprs" | "materialized_exprs" => Ok(GeneratedField::MaterializedExprs),
14149 "vectorIndexWrite" | "vector_index_write" => Ok(GeneratedField::VectorIndexWrite),
14150 "upstreamSinkUnion" | "upstream_sink_union" => Ok(GeneratedField::UpstreamSinkUnion),
14151 "localityProvider" | "locality_provider" => Ok(GeneratedField::LocalityProvider),
14152 "eowcGapFill" | "eowc_gap_fill" => Ok(GeneratedField::EowcGapFill),
14153 "gapFill" | "gap_fill" => Ok(GeneratedField::GapFill),
14154 "vectorIndexLookupJoin" | "vector_index_lookup_join" => Ok(GeneratedField::VectorIndexLookupJoin),
14155 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14156 }
14157 }
14158 }
14159 deserializer.deserialize_identifier(GeneratedVisitor)
14160 }
14161 }
14162 struct GeneratedVisitor;
14163 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14164 type Value = StreamNode;
14165
14166 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14167 formatter.write_str("struct stream_plan.StreamNode")
14168 }
14169
14170 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamNode, V::Error>
14171 where
14172 V: serde::de::MapAccess<'de>,
14173 {
14174 let mut operator_id__ = None;
14175 let mut input__ = None;
14176 let mut stream_key__ = None;
14177 let mut stream_kind__ = None;
14178 let mut identity__ = None;
14179 let mut fields__ = None;
14180 let mut node_body__ = None;
14181 while let Some(k) = map_.next_key()? {
14182 match k {
14183 GeneratedField::OperatorId => {
14184 if operator_id__.is_some() {
14185 return Err(serde::de::Error::duplicate_field("operatorId"));
14186 }
14187 operator_id__ =
14188 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14189 ;
14190 }
14191 GeneratedField::Input => {
14192 if input__.is_some() {
14193 return Err(serde::de::Error::duplicate_field("input"));
14194 }
14195 input__ = Some(map_.next_value()?);
14196 }
14197 GeneratedField::StreamKey => {
14198 if stream_key__.is_some() {
14199 return Err(serde::de::Error::duplicate_field("streamKey"));
14200 }
14201 stream_key__ =
14202 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14203 .into_iter().map(|x| x.0).collect())
14204 ;
14205 }
14206 GeneratedField::StreamKind => {
14207 if stream_kind__.is_some() {
14208 return Err(serde::de::Error::duplicate_field("streamKind"));
14209 }
14210 stream_kind__ = Some(map_.next_value::<stream_node::StreamKind>()? as i32);
14211 }
14212 GeneratedField::Identity => {
14213 if identity__.is_some() {
14214 return Err(serde::de::Error::duplicate_field("identity"));
14215 }
14216 identity__ = Some(map_.next_value()?);
14217 }
14218 GeneratedField::Fields => {
14219 if fields__.is_some() {
14220 return Err(serde::de::Error::duplicate_field("fields"));
14221 }
14222 fields__ = Some(map_.next_value()?);
14223 }
14224 GeneratedField::Source => {
14225 if node_body__.is_some() {
14226 return Err(serde::de::Error::duplicate_field("source"));
14227 }
14228 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Source)
14229;
14230 }
14231 GeneratedField::Project => {
14232 if node_body__.is_some() {
14233 return Err(serde::de::Error::duplicate_field("project"));
14234 }
14235 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Project)
14236;
14237 }
14238 GeneratedField::Filter => {
14239 if node_body__.is_some() {
14240 return Err(serde::de::Error::duplicate_field("filter"));
14241 }
14242 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Filter)
14243;
14244 }
14245 GeneratedField::Materialize => {
14246 if node_body__.is_some() {
14247 return Err(serde::de::Error::duplicate_field("materialize"));
14248 }
14249 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Materialize)
14250;
14251 }
14252 GeneratedField::StatelessSimpleAgg => {
14253 if node_body__.is_some() {
14254 return Err(serde::de::Error::duplicate_field("statelessSimpleAgg"));
14255 }
14256 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StatelessSimpleAgg)
14257;
14258 }
14259 GeneratedField::SimpleAgg => {
14260 if node_body__.is_some() {
14261 return Err(serde::de::Error::duplicate_field("simpleAgg"));
14262 }
14263 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SimpleAgg)
14264;
14265 }
14266 GeneratedField::HashAgg => {
14267 if node_body__.is_some() {
14268 return Err(serde::de::Error::duplicate_field("hashAgg"));
14269 }
14270 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashAgg)
14271;
14272 }
14273 GeneratedField::AppendOnlyTopN => {
14274 if node_body__.is_some() {
14275 return Err(serde::de::Error::duplicate_field("appendOnlyTopN"));
14276 }
14277 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyTopN)
14278;
14279 }
14280 GeneratedField::HashJoin => {
14281 if node_body__.is_some() {
14282 return Err(serde::de::Error::duplicate_field("hashJoin"));
14283 }
14284 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashJoin)
14285;
14286 }
14287 GeneratedField::TopN => {
14288 if node_body__.is_some() {
14289 return Err(serde::de::Error::duplicate_field("topN"));
14290 }
14291 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TopN)
14292;
14293 }
14294 GeneratedField::HopWindow => {
14295 if node_body__.is_some() {
14296 return Err(serde::de::Error::duplicate_field("hopWindow"));
14297 }
14298 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HopWindow)
14299;
14300 }
14301 GeneratedField::Merge => {
14302 if node_body__.is_some() {
14303 return Err(serde::de::Error::duplicate_field("merge"));
14304 }
14305 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Merge)
14306;
14307 }
14308 GeneratedField::Exchange => {
14309 if node_body__.is_some() {
14310 return Err(serde::de::Error::duplicate_field("exchange"));
14311 }
14312 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Exchange)
14313;
14314 }
14315 GeneratedField::StreamScan => {
14316 if node_body__.is_some() {
14317 return Err(serde::de::Error::duplicate_field("streamScan"));
14318 }
14319 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamScan)
14320;
14321 }
14322 GeneratedField::BatchPlan => {
14323 if node_body__.is_some() {
14324 return Err(serde::de::Error::duplicate_field("batchPlan"));
14325 }
14326 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BatchPlan)
14327;
14328 }
14329 GeneratedField::Lookup => {
14330 if node_body__.is_some() {
14331 return Err(serde::de::Error::duplicate_field("lookup"));
14332 }
14333 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Lookup)
14334;
14335 }
14336 GeneratedField::Arrange => {
14337 if node_body__.is_some() {
14338 return Err(serde::de::Error::duplicate_field("arrange"));
14339 }
14340 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Arrange)
14341;
14342 }
14343 GeneratedField::LookupUnion => {
14344 if node_body__.is_some() {
14345 return Err(serde::de::Error::duplicate_field("lookupUnion"));
14346 }
14347 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LookupUnion)
14348;
14349 }
14350 GeneratedField::Union => {
14351 if node_body__.is_some() {
14352 return Err(serde::de::Error::duplicate_field("union"));
14353 }
14354 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Union)
14355;
14356 }
14357 GeneratedField::DeltaIndexJoin => {
14358 if node_body__.is_some() {
14359 return Err(serde::de::Error::duplicate_field("deltaIndexJoin"));
14360 }
14361 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DeltaIndexJoin)
14362;
14363 }
14364 GeneratedField::Sink => {
14365 if node_body__.is_some() {
14366 return Err(serde::de::Error::duplicate_field("sink"));
14367 }
14368 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sink)
14369;
14370 }
14371 GeneratedField::Expand => {
14372 if node_body__.is_some() {
14373 return Err(serde::de::Error::duplicate_field("expand"));
14374 }
14375 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Expand)
14376;
14377 }
14378 GeneratedField::DynamicFilter => {
14379 if node_body__.is_some() {
14380 return Err(serde::de::Error::duplicate_field("dynamicFilter"));
14381 }
14382 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DynamicFilter)
14383;
14384 }
14385 GeneratedField::ProjectSet => {
14386 if node_body__.is_some() {
14387 return Err(serde::de::Error::duplicate_field("projectSet"));
14388 }
14389 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::ProjectSet)
14390;
14391 }
14392 GeneratedField::GroupTopN => {
14393 if node_body__.is_some() {
14394 return Err(serde::de::Error::duplicate_field("groupTopN"));
14395 }
14396 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GroupTopN)
14397;
14398 }
14399 GeneratedField::Sort => {
14400 if node_body__.is_some() {
14401 return Err(serde::de::Error::duplicate_field("sort"));
14402 }
14403 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sort)
14404;
14405 }
14406 GeneratedField::WatermarkFilter => {
14407 if node_body__.is_some() {
14408 return Err(serde::de::Error::duplicate_field("watermarkFilter"));
14409 }
14410 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::WatermarkFilter)
14411;
14412 }
14413 GeneratedField::Dml => {
14414 if node_body__.is_some() {
14415 return Err(serde::de::Error::duplicate_field("dml"));
14416 }
14417 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Dml)
14418;
14419 }
14420 GeneratedField::RowIdGen => {
14421 if node_body__.is_some() {
14422 return Err(serde::de::Error::duplicate_field("rowIdGen"));
14423 }
14424 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowIdGen)
14425;
14426 }
14427 GeneratedField::Now => {
14428 if node_body__.is_some() {
14429 return Err(serde::de::Error::duplicate_field("now"));
14430 }
14431 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Now)
14432;
14433 }
14434 GeneratedField::AppendOnlyGroupTopN => {
14435 if node_body__.is_some() {
14436 return Err(serde::de::Error::duplicate_field("appendOnlyGroupTopN"));
14437 }
14438 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyGroupTopN)
14439;
14440 }
14441 GeneratedField::TemporalJoin => {
14442 if node_body__.is_some() {
14443 return Err(serde::de::Error::duplicate_field("temporalJoin"));
14444 }
14445 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TemporalJoin)
14446;
14447 }
14448 GeneratedField::BarrierRecv => {
14449 if node_body__.is_some() {
14450 return Err(serde::de::Error::duplicate_field("barrierRecv"));
14451 }
14452 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BarrierRecv)
14453;
14454 }
14455 GeneratedField::Values => {
14456 if node_body__.is_some() {
14457 return Err(serde::de::Error::duplicate_field("values"));
14458 }
14459 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Values)
14460;
14461 }
14462 GeneratedField::AppendOnlyDedup => {
14463 if node_body__.is_some() {
14464 return Err(serde::de::Error::duplicate_field("appendOnlyDedup"));
14465 }
14466 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyDedup)
14467;
14468 }
14469 GeneratedField::NoOp => {
14470 if node_body__.is_some() {
14471 return Err(serde::de::Error::duplicate_field("noOp"));
14472 }
14473 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::NoOp)
14474;
14475 }
14476 GeneratedField::EowcOverWindow => {
14477 if node_body__.is_some() {
14478 return Err(serde::de::Error::duplicate_field("eowcOverWindow"));
14479 }
14480 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcOverWindow)
14481;
14482 }
14483 GeneratedField::OverWindow => {
14484 if node_body__.is_some() {
14485 return Err(serde::de::Error::duplicate_field("overWindow"));
14486 }
14487 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::OverWindow)
14488;
14489 }
14490 GeneratedField::StreamFsFetch => {
14491 if node_body__.is_some() {
14492 return Err(serde::de::Error::duplicate_field("streamFsFetch"));
14493 }
14494 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamFsFetch)
14495;
14496 }
14497 GeneratedField::StreamCdcScan => {
14498 if node_body__.is_some() {
14499 return Err(serde::de::Error::duplicate_field("streamCdcScan"));
14500 }
14501 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamCdcScan)
14502;
14503 }
14504 GeneratedField::CdcFilter => {
14505 if node_body__.is_some() {
14506 return Err(serde::de::Error::duplicate_field("cdcFilter"));
14507 }
14508 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CdcFilter)
14509;
14510 }
14511 GeneratedField::SourceBackfill => {
14512 if node_body__.is_some() {
14513 return Err(serde::de::Error::duplicate_field("sourceBackfill"));
14514 }
14515 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SourceBackfill)
14516;
14517 }
14518 GeneratedField::Changelog => {
14519 if node_body__.is_some() {
14520 return Err(serde::de::Error::duplicate_field("changelog"));
14521 }
14522 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Changelog)
14523;
14524 }
14525 GeneratedField::LocalApproxPercentile => {
14526 if node_body__.is_some() {
14527 return Err(serde::de::Error::duplicate_field("localApproxPercentile"));
14528 }
14529 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalApproxPercentile)
14530;
14531 }
14532 GeneratedField::GlobalApproxPercentile => {
14533 if node_body__.is_some() {
14534 return Err(serde::de::Error::duplicate_field("globalApproxPercentile"));
14535 }
14536 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GlobalApproxPercentile)
14537;
14538 }
14539 GeneratedField::RowMerge => {
14540 if node_body__.is_some() {
14541 return Err(serde::de::Error::duplicate_field("rowMerge"));
14542 }
14543 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowMerge)
14544;
14545 }
14546 GeneratedField::AsOfJoin => {
14547 if node_body__.is_some() {
14548 return Err(serde::de::Error::duplicate_field("asOfJoin"));
14549 }
14550 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AsOfJoin)
14551;
14552 }
14553 GeneratedField::SyncLogStore => {
14554 if node_body__.is_some() {
14555 return Err(serde::de::Error::duplicate_field("syncLogStore"));
14556 }
14557 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SyncLogStore)
14558;
14559 }
14560 GeneratedField::MaterializedExprs => {
14561 if node_body__.is_some() {
14562 return Err(serde::de::Error::duplicate_field("materializedExprs"));
14563 }
14564 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MaterializedExprs)
14565;
14566 }
14567 GeneratedField::VectorIndexWrite => {
14568 if node_body__.is_some() {
14569 return Err(serde::de::Error::duplicate_field("vectorIndexWrite"));
14570 }
14571 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexWrite)
14572;
14573 }
14574 GeneratedField::UpstreamSinkUnion => {
14575 if node_body__.is_some() {
14576 return Err(serde::de::Error::duplicate_field("upstreamSinkUnion"));
14577 }
14578 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::UpstreamSinkUnion)
14579;
14580 }
14581 GeneratedField::LocalityProvider => {
14582 if node_body__.is_some() {
14583 return Err(serde::de::Error::duplicate_field("localityProvider"));
14584 }
14585 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalityProvider)
14586;
14587 }
14588 GeneratedField::EowcGapFill => {
14589 if node_body__.is_some() {
14590 return Err(serde::de::Error::duplicate_field("eowcGapFill"));
14591 }
14592 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcGapFill)
14593;
14594 }
14595 GeneratedField::GapFill => {
14596 if node_body__.is_some() {
14597 return Err(serde::de::Error::duplicate_field("gapFill"));
14598 }
14599 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GapFill)
14600;
14601 }
14602 GeneratedField::VectorIndexLookupJoin => {
14603 if node_body__.is_some() {
14604 return Err(serde::de::Error::duplicate_field("vectorIndexLookupJoin"));
14605 }
14606 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexLookupJoin)
14607;
14608 }
14609 }
14610 }
14611 Ok(StreamNode {
14612 operator_id: operator_id__.unwrap_or_default(),
14613 input: input__.unwrap_or_default(),
14614 stream_key: stream_key__.unwrap_or_default(),
14615 stream_kind: stream_kind__.unwrap_or_default(),
14616 identity: identity__.unwrap_or_default(),
14617 fields: fields__.unwrap_or_default(),
14618 node_body: node_body__,
14619 })
14620 }
14621 }
14622 deserializer.deserialize_struct("stream_plan.StreamNode", FIELDS, GeneratedVisitor)
14623 }
14624}
14625impl serde::Serialize for stream_node::StreamKind {
14626 #[allow(deprecated)]
14627 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14628 where
14629 S: serde::Serializer,
14630 {
14631 let variant = match self {
14632 Self::Retract => "STREAM_KIND_RETRACT",
14633 Self::AppendOnly => "STREAM_KIND_APPEND_ONLY",
14634 Self::Upsert => "STREAM_KIND_UPSERT",
14635 };
14636 serializer.serialize_str(variant)
14637 }
14638}
14639impl<'de> serde::Deserialize<'de> for stream_node::StreamKind {
14640 #[allow(deprecated)]
14641 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14642 where
14643 D: serde::Deserializer<'de>,
14644 {
14645 const FIELDS: &[&str] = &[
14646 "STREAM_KIND_RETRACT",
14647 "STREAM_KIND_APPEND_ONLY",
14648 "STREAM_KIND_UPSERT",
14649 ];
14650
14651 struct GeneratedVisitor;
14652
14653 impl serde::de::Visitor<'_> for GeneratedVisitor {
14654 type Value = stream_node::StreamKind;
14655
14656 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14657 write!(formatter, "expected one of: {:?}", &FIELDS)
14658 }
14659
14660 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14661 where
14662 E: serde::de::Error,
14663 {
14664 i32::try_from(v)
14665 .ok()
14666 .and_then(|x| x.try_into().ok())
14667 .ok_or_else(|| {
14668 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14669 })
14670 }
14671
14672 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14673 where
14674 E: serde::de::Error,
14675 {
14676 i32::try_from(v)
14677 .ok()
14678 .and_then(|x| x.try_into().ok())
14679 .ok_or_else(|| {
14680 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14681 })
14682 }
14683
14684 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14685 where
14686 E: serde::de::Error,
14687 {
14688 match value {
14689 "STREAM_KIND_RETRACT" => Ok(stream_node::StreamKind::Retract),
14690 "STREAM_KIND_APPEND_ONLY" => Ok(stream_node::StreamKind::AppendOnly),
14691 "STREAM_KIND_UPSERT" => Ok(stream_node::StreamKind::Upsert),
14692 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14693 }
14694 }
14695 }
14696 deserializer.deserialize_any(GeneratedVisitor)
14697 }
14698}
14699impl serde::Serialize for StreamScanNode {
14700 #[allow(deprecated)]
14701 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14702 where
14703 S: serde::Serializer,
14704 {
14705 use serde::ser::SerializeStruct;
14706 let mut len = 0;
14707 if self.table_id != 0 {
14708 len += 1;
14709 }
14710 if !self.upstream_column_ids.is_empty() {
14711 len += 1;
14712 }
14713 if !self.output_indices.is_empty() {
14714 len += 1;
14715 }
14716 if self.stream_scan_type != 0 {
14717 len += 1;
14718 }
14719 if self.state_table.is_some() {
14720 len += 1;
14721 }
14722 if self.table_desc.is_some() {
14723 len += 1;
14724 }
14725 if self.rate_limit.is_some() {
14726 len += 1;
14727 }
14728 if self.snapshot_read_barrier_interval != 0 {
14729 len += 1;
14730 }
14731 if self.arrangement_table.is_some() {
14732 len += 1;
14733 }
14734 if self.snapshot_backfill_epoch.is_some() {
14735 len += 1;
14736 }
14737 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamScanNode", len)?;
14738 if self.table_id != 0 {
14739 struct_ser.serialize_field("tableId", &self.table_id)?;
14740 }
14741 if !self.upstream_column_ids.is_empty() {
14742 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
14743 }
14744 if !self.output_indices.is_empty() {
14745 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
14746 }
14747 if self.stream_scan_type != 0 {
14748 let v = StreamScanType::try_from(self.stream_scan_type)
14749 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_scan_type)))?;
14750 struct_ser.serialize_field("streamScanType", &v)?;
14751 }
14752 if let Some(v) = self.state_table.as_ref() {
14753 struct_ser.serialize_field("stateTable", v)?;
14754 }
14755 if let Some(v) = self.table_desc.as_ref() {
14756 struct_ser.serialize_field("tableDesc", v)?;
14757 }
14758 if let Some(v) = self.rate_limit.as_ref() {
14759 struct_ser.serialize_field("rateLimit", v)?;
14760 }
14761 if self.snapshot_read_barrier_interval != 0 {
14762 struct_ser.serialize_field("snapshotReadBarrierInterval", &self.snapshot_read_barrier_interval)?;
14763 }
14764 if let Some(v) = self.arrangement_table.as_ref() {
14765 struct_ser.serialize_field("arrangementTable", v)?;
14766 }
14767 if let Some(v) = self.snapshot_backfill_epoch.as_ref() {
14768 #[allow(clippy::needless_borrow)]
14769 #[allow(clippy::needless_borrows_for_generic_args)]
14770 struct_ser.serialize_field("snapshotBackfillEpoch", ToString::to_string(&v).as_str())?;
14771 }
14772 struct_ser.end()
14773 }
14774}
14775impl<'de> serde::Deserialize<'de> for StreamScanNode {
14776 #[allow(deprecated)]
14777 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14778 where
14779 D: serde::Deserializer<'de>,
14780 {
14781 const FIELDS: &[&str] = &[
14782 "table_id",
14783 "tableId",
14784 "upstream_column_ids",
14785 "upstreamColumnIds",
14786 "output_indices",
14787 "outputIndices",
14788 "stream_scan_type",
14789 "streamScanType",
14790 "state_table",
14791 "stateTable",
14792 "table_desc",
14793 "tableDesc",
14794 "rate_limit",
14795 "rateLimit",
14796 "snapshot_read_barrier_interval",
14797 "snapshotReadBarrierInterval",
14798 "arrangement_table",
14799 "arrangementTable",
14800 "snapshot_backfill_epoch",
14801 "snapshotBackfillEpoch",
14802 ];
14803
14804 #[allow(clippy::enum_variant_names)]
14805 enum GeneratedField {
14806 TableId,
14807 UpstreamColumnIds,
14808 OutputIndices,
14809 StreamScanType,
14810 StateTable,
14811 TableDesc,
14812 RateLimit,
14813 SnapshotReadBarrierInterval,
14814 ArrangementTable,
14815 SnapshotBackfillEpoch,
14816 }
14817 impl<'de> serde::Deserialize<'de> for GeneratedField {
14818 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14819 where
14820 D: serde::Deserializer<'de>,
14821 {
14822 struct GeneratedVisitor;
14823
14824 impl serde::de::Visitor<'_> for GeneratedVisitor {
14825 type Value = GeneratedField;
14826
14827 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14828 write!(formatter, "expected one of: {:?}", &FIELDS)
14829 }
14830
14831 #[allow(unused_variables)]
14832 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14833 where
14834 E: serde::de::Error,
14835 {
14836 match value {
14837 "tableId" | "table_id" => Ok(GeneratedField::TableId),
14838 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
14839 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
14840 "streamScanType" | "stream_scan_type" => Ok(GeneratedField::StreamScanType),
14841 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
14842 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
14843 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
14844 "snapshotReadBarrierInterval" | "snapshot_read_barrier_interval" => Ok(GeneratedField::SnapshotReadBarrierInterval),
14845 "arrangementTable" | "arrangement_table" => Ok(GeneratedField::ArrangementTable),
14846 "snapshotBackfillEpoch" | "snapshot_backfill_epoch" => Ok(GeneratedField::SnapshotBackfillEpoch),
14847 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14848 }
14849 }
14850 }
14851 deserializer.deserialize_identifier(GeneratedVisitor)
14852 }
14853 }
14854 struct GeneratedVisitor;
14855 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14856 type Value = StreamScanNode;
14857
14858 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14859 formatter.write_str("struct stream_plan.StreamScanNode")
14860 }
14861
14862 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamScanNode, V::Error>
14863 where
14864 V: serde::de::MapAccess<'de>,
14865 {
14866 let mut table_id__ = None;
14867 let mut upstream_column_ids__ = None;
14868 let mut output_indices__ = None;
14869 let mut stream_scan_type__ = None;
14870 let mut state_table__ = None;
14871 let mut table_desc__ = None;
14872 let mut rate_limit__ = None;
14873 let mut snapshot_read_barrier_interval__ = None;
14874 let mut arrangement_table__ = None;
14875 let mut snapshot_backfill_epoch__ = None;
14876 while let Some(k) = map_.next_key()? {
14877 match k {
14878 GeneratedField::TableId => {
14879 if table_id__.is_some() {
14880 return Err(serde::de::Error::duplicate_field("tableId"));
14881 }
14882 table_id__ =
14883 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14884 ;
14885 }
14886 GeneratedField::UpstreamColumnIds => {
14887 if upstream_column_ids__.is_some() {
14888 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
14889 }
14890 upstream_column_ids__ =
14891 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14892 .into_iter().map(|x| x.0).collect())
14893 ;
14894 }
14895 GeneratedField::OutputIndices => {
14896 if output_indices__.is_some() {
14897 return Err(serde::de::Error::duplicate_field("outputIndices"));
14898 }
14899 output_indices__ =
14900 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14901 .into_iter().map(|x| x.0).collect())
14902 ;
14903 }
14904 GeneratedField::StreamScanType => {
14905 if stream_scan_type__.is_some() {
14906 return Err(serde::de::Error::duplicate_field("streamScanType"));
14907 }
14908 stream_scan_type__ = Some(map_.next_value::<StreamScanType>()? as i32);
14909 }
14910 GeneratedField::StateTable => {
14911 if state_table__.is_some() {
14912 return Err(serde::de::Error::duplicate_field("stateTable"));
14913 }
14914 state_table__ = map_.next_value()?;
14915 }
14916 GeneratedField::TableDesc => {
14917 if table_desc__.is_some() {
14918 return Err(serde::de::Error::duplicate_field("tableDesc"));
14919 }
14920 table_desc__ = map_.next_value()?;
14921 }
14922 GeneratedField::RateLimit => {
14923 if rate_limit__.is_some() {
14924 return Err(serde::de::Error::duplicate_field("rateLimit"));
14925 }
14926 rate_limit__ =
14927 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14928 ;
14929 }
14930 GeneratedField::SnapshotReadBarrierInterval => {
14931 if snapshot_read_barrier_interval__.is_some() {
14932 return Err(serde::de::Error::duplicate_field("snapshotReadBarrierInterval"));
14933 }
14934 snapshot_read_barrier_interval__ =
14935 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14936 ;
14937 }
14938 GeneratedField::ArrangementTable => {
14939 if arrangement_table__.is_some() {
14940 return Err(serde::de::Error::duplicate_field("arrangementTable"));
14941 }
14942 arrangement_table__ = map_.next_value()?;
14943 }
14944 GeneratedField::SnapshotBackfillEpoch => {
14945 if snapshot_backfill_epoch__.is_some() {
14946 return Err(serde::de::Error::duplicate_field("snapshotBackfillEpoch"));
14947 }
14948 snapshot_backfill_epoch__ =
14949 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14950 ;
14951 }
14952 }
14953 }
14954 Ok(StreamScanNode {
14955 table_id: table_id__.unwrap_or_default(),
14956 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
14957 output_indices: output_indices__.unwrap_or_default(),
14958 stream_scan_type: stream_scan_type__.unwrap_or_default(),
14959 state_table: state_table__,
14960 table_desc: table_desc__,
14961 rate_limit: rate_limit__,
14962 snapshot_read_barrier_interval: snapshot_read_barrier_interval__.unwrap_or_default(),
14963 arrangement_table: arrangement_table__,
14964 snapshot_backfill_epoch: snapshot_backfill_epoch__,
14965 })
14966 }
14967 }
14968 deserializer.deserialize_struct("stream_plan.StreamScanNode", FIELDS, GeneratedVisitor)
14969 }
14970}
14971impl serde::Serialize for StreamScanType {
14972 #[allow(deprecated)]
14973 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14974 where
14975 S: serde::Serializer,
14976 {
14977 let variant = match self {
14978 Self::Unspecified => "STREAM_SCAN_TYPE_UNSPECIFIED",
14979 Self::Chain => "STREAM_SCAN_TYPE_CHAIN",
14980 Self::Rearrange => "STREAM_SCAN_TYPE_REARRANGE",
14981 Self::Backfill => "STREAM_SCAN_TYPE_BACKFILL",
14982 Self::UpstreamOnly => "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
14983 Self::ArrangementBackfill => "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
14984 Self::SnapshotBackfill => "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
14985 Self::CrossDbSnapshotBackfill => "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
14986 };
14987 serializer.serialize_str(variant)
14988 }
14989}
14990impl<'de> serde::Deserialize<'de> for StreamScanType {
14991 #[allow(deprecated)]
14992 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14993 where
14994 D: serde::Deserializer<'de>,
14995 {
14996 const FIELDS: &[&str] = &[
14997 "STREAM_SCAN_TYPE_UNSPECIFIED",
14998 "STREAM_SCAN_TYPE_CHAIN",
14999 "STREAM_SCAN_TYPE_REARRANGE",
15000 "STREAM_SCAN_TYPE_BACKFILL",
15001 "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
15002 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
15003 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
15004 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
15005 ];
15006
15007 struct GeneratedVisitor;
15008
15009 impl serde::de::Visitor<'_> for GeneratedVisitor {
15010 type Value = StreamScanType;
15011
15012 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15013 write!(formatter, "expected one of: {:?}", &FIELDS)
15014 }
15015
15016 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15017 where
15018 E: serde::de::Error,
15019 {
15020 i32::try_from(v)
15021 .ok()
15022 .and_then(|x| x.try_into().ok())
15023 .ok_or_else(|| {
15024 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15025 })
15026 }
15027
15028 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15029 where
15030 E: serde::de::Error,
15031 {
15032 i32::try_from(v)
15033 .ok()
15034 .and_then(|x| x.try_into().ok())
15035 .ok_or_else(|| {
15036 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15037 })
15038 }
15039
15040 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15041 where
15042 E: serde::de::Error,
15043 {
15044 match value {
15045 "STREAM_SCAN_TYPE_UNSPECIFIED" => Ok(StreamScanType::Unspecified),
15046 "STREAM_SCAN_TYPE_CHAIN" => Ok(StreamScanType::Chain),
15047 "STREAM_SCAN_TYPE_REARRANGE" => Ok(StreamScanType::Rearrange),
15048 "STREAM_SCAN_TYPE_BACKFILL" => Ok(StreamScanType::Backfill),
15049 "STREAM_SCAN_TYPE_UPSTREAM_ONLY" => Ok(StreamScanType::UpstreamOnly),
15050 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL" => Ok(StreamScanType::ArrangementBackfill),
15051 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL" => Ok(StreamScanType::SnapshotBackfill),
15052 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL" => Ok(StreamScanType::CrossDbSnapshotBackfill),
15053 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15054 }
15055 }
15056 }
15057 deserializer.deserialize_any(GeneratedVisitor)
15058 }
15059}
15060impl serde::Serialize for StreamSource {
15061 #[allow(deprecated)]
15062 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15063 where
15064 S: serde::Serializer,
15065 {
15066 use serde::ser::SerializeStruct;
15067 let mut len = 0;
15068 if self.source_id != 0 {
15069 len += 1;
15070 }
15071 if self.state_table.is_some() {
15072 len += 1;
15073 }
15074 if self.row_id_index.is_some() {
15075 len += 1;
15076 }
15077 if !self.columns.is_empty() {
15078 len += 1;
15079 }
15080 if !self.with_properties.is_empty() {
15081 len += 1;
15082 }
15083 if self.info.is_some() {
15084 len += 1;
15085 }
15086 if !self.source_name.is_empty() {
15087 len += 1;
15088 }
15089 if self.rate_limit.is_some() {
15090 len += 1;
15091 }
15092 if !self.secret_refs.is_empty() {
15093 len += 1;
15094 }
15095 if self.downstream_columns.is_some() {
15096 len += 1;
15097 }
15098 if self.refresh_mode.is_some() {
15099 len += 1;
15100 }
15101 if self.associated_table_id.is_some() {
15102 len += 1;
15103 }
15104 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamSource", len)?;
15105 if self.source_id != 0 {
15106 struct_ser.serialize_field("sourceId", &self.source_id)?;
15107 }
15108 if let Some(v) = self.state_table.as_ref() {
15109 struct_ser.serialize_field("stateTable", v)?;
15110 }
15111 if let Some(v) = self.row_id_index.as_ref() {
15112 struct_ser.serialize_field("rowIdIndex", v)?;
15113 }
15114 if !self.columns.is_empty() {
15115 struct_ser.serialize_field("columns", &self.columns)?;
15116 }
15117 if !self.with_properties.is_empty() {
15118 struct_ser.serialize_field("withProperties", &self.with_properties)?;
15119 }
15120 if let Some(v) = self.info.as_ref() {
15121 struct_ser.serialize_field("info", v)?;
15122 }
15123 if !self.source_name.is_empty() {
15124 struct_ser.serialize_field("sourceName", &self.source_name)?;
15125 }
15126 if let Some(v) = self.rate_limit.as_ref() {
15127 struct_ser.serialize_field("rateLimit", v)?;
15128 }
15129 if !self.secret_refs.is_empty() {
15130 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
15131 }
15132 if let Some(v) = self.downstream_columns.as_ref() {
15133 struct_ser.serialize_field("downstreamColumns", v)?;
15134 }
15135 if let Some(v) = self.refresh_mode.as_ref() {
15136 struct_ser.serialize_field("refreshMode", v)?;
15137 }
15138 if let Some(v) = self.associated_table_id.as_ref() {
15139 struct_ser.serialize_field("associatedTableId", v)?;
15140 }
15141 struct_ser.end()
15142 }
15143}
15144impl<'de> serde::Deserialize<'de> for StreamSource {
15145 #[allow(deprecated)]
15146 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15147 where
15148 D: serde::Deserializer<'de>,
15149 {
15150 const FIELDS: &[&str] = &[
15151 "source_id",
15152 "sourceId",
15153 "state_table",
15154 "stateTable",
15155 "row_id_index",
15156 "rowIdIndex",
15157 "columns",
15158 "with_properties",
15159 "withProperties",
15160 "info",
15161 "source_name",
15162 "sourceName",
15163 "rate_limit",
15164 "rateLimit",
15165 "secret_refs",
15166 "secretRefs",
15167 "downstream_columns",
15168 "downstreamColumns",
15169 "refresh_mode",
15170 "refreshMode",
15171 "associated_table_id",
15172 "associatedTableId",
15173 ];
15174
15175 #[allow(clippy::enum_variant_names)]
15176 enum GeneratedField {
15177 SourceId,
15178 StateTable,
15179 RowIdIndex,
15180 Columns,
15181 WithProperties,
15182 Info,
15183 SourceName,
15184 RateLimit,
15185 SecretRefs,
15186 DownstreamColumns,
15187 RefreshMode,
15188 AssociatedTableId,
15189 }
15190 impl<'de> serde::Deserialize<'de> for GeneratedField {
15191 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15192 where
15193 D: serde::Deserializer<'de>,
15194 {
15195 struct GeneratedVisitor;
15196
15197 impl serde::de::Visitor<'_> for GeneratedVisitor {
15198 type Value = GeneratedField;
15199
15200 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15201 write!(formatter, "expected one of: {:?}", &FIELDS)
15202 }
15203
15204 #[allow(unused_variables)]
15205 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15206 where
15207 E: serde::de::Error,
15208 {
15209 match value {
15210 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
15211 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
15212 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
15213 "columns" => Ok(GeneratedField::Columns),
15214 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
15215 "info" => Ok(GeneratedField::Info),
15216 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
15217 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
15218 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
15219 "downstreamColumns" | "downstream_columns" => Ok(GeneratedField::DownstreamColumns),
15220 "refreshMode" | "refresh_mode" => Ok(GeneratedField::RefreshMode),
15221 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
15222 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15223 }
15224 }
15225 }
15226 deserializer.deserialize_identifier(GeneratedVisitor)
15227 }
15228 }
15229 struct GeneratedVisitor;
15230 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15231 type Value = StreamSource;
15232
15233 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15234 formatter.write_str("struct stream_plan.StreamSource")
15235 }
15236
15237 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSource, V::Error>
15238 where
15239 V: serde::de::MapAccess<'de>,
15240 {
15241 let mut source_id__ = None;
15242 let mut state_table__ = None;
15243 let mut row_id_index__ = None;
15244 let mut columns__ = None;
15245 let mut with_properties__ = None;
15246 let mut info__ = None;
15247 let mut source_name__ = None;
15248 let mut rate_limit__ = None;
15249 let mut secret_refs__ = None;
15250 let mut downstream_columns__ = None;
15251 let mut refresh_mode__ = None;
15252 let mut associated_table_id__ = None;
15253 while let Some(k) = map_.next_key()? {
15254 match k {
15255 GeneratedField::SourceId => {
15256 if source_id__.is_some() {
15257 return Err(serde::de::Error::duplicate_field("sourceId"));
15258 }
15259 source_id__ =
15260 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15261 ;
15262 }
15263 GeneratedField::StateTable => {
15264 if state_table__.is_some() {
15265 return Err(serde::de::Error::duplicate_field("stateTable"));
15266 }
15267 state_table__ = map_.next_value()?;
15268 }
15269 GeneratedField::RowIdIndex => {
15270 if row_id_index__.is_some() {
15271 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
15272 }
15273 row_id_index__ =
15274 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15275 ;
15276 }
15277 GeneratedField::Columns => {
15278 if columns__.is_some() {
15279 return Err(serde::de::Error::duplicate_field("columns"));
15280 }
15281 columns__ = Some(map_.next_value()?);
15282 }
15283 GeneratedField::WithProperties => {
15284 if with_properties__.is_some() {
15285 return Err(serde::de::Error::duplicate_field("withProperties"));
15286 }
15287 with_properties__ = Some(
15288 map_.next_value::<std::collections::BTreeMap<_, _>>()?
15289 );
15290 }
15291 GeneratedField::Info => {
15292 if info__.is_some() {
15293 return Err(serde::de::Error::duplicate_field("info"));
15294 }
15295 info__ = map_.next_value()?;
15296 }
15297 GeneratedField::SourceName => {
15298 if source_name__.is_some() {
15299 return Err(serde::de::Error::duplicate_field("sourceName"));
15300 }
15301 source_name__ = Some(map_.next_value()?);
15302 }
15303 GeneratedField::RateLimit => {
15304 if rate_limit__.is_some() {
15305 return Err(serde::de::Error::duplicate_field("rateLimit"));
15306 }
15307 rate_limit__ =
15308 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15309 ;
15310 }
15311 GeneratedField::SecretRefs => {
15312 if secret_refs__.is_some() {
15313 return Err(serde::de::Error::duplicate_field("secretRefs"));
15314 }
15315 secret_refs__ = Some(
15316 map_.next_value::<std::collections::BTreeMap<_, _>>()?
15317 );
15318 }
15319 GeneratedField::DownstreamColumns => {
15320 if downstream_columns__.is_some() {
15321 return Err(serde::de::Error::duplicate_field("downstreamColumns"));
15322 }
15323 downstream_columns__ = map_.next_value()?;
15324 }
15325 GeneratedField::RefreshMode => {
15326 if refresh_mode__.is_some() {
15327 return Err(serde::de::Error::duplicate_field("refreshMode"));
15328 }
15329 refresh_mode__ = map_.next_value()?;
15330 }
15331 GeneratedField::AssociatedTableId => {
15332 if associated_table_id__.is_some() {
15333 return Err(serde::de::Error::duplicate_field("associatedTableId"));
15334 }
15335 associated_table_id__ =
15336 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15337 ;
15338 }
15339 }
15340 }
15341 Ok(StreamSource {
15342 source_id: source_id__.unwrap_or_default(),
15343 state_table: state_table__,
15344 row_id_index: row_id_index__,
15345 columns: columns__.unwrap_or_default(),
15346 with_properties: with_properties__.unwrap_or_default(),
15347 info: info__,
15348 source_name: source_name__.unwrap_or_default(),
15349 rate_limit: rate_limit__,
15350 secret_refs: secret_refs__.unwrap_or_default(),
15351 downstream_columns: downstream_columns__,
15352 refresh_mode: refresh_mode__,
15353 associated_table_id: associated_table_id__,
15354 })
15355 }
15356 }
15357 deserializer.deserialize_struct("stream_plan.StreamSource", FIELDS, GeneratedVisitor)
15358 }
15359}
15360impl serde::Serialize for SubscriptionUpstreamInfo {
15361 #[allow(deprecated)]
15362 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15363 where
15364 S: serde::Serializer,
15365 {
15366 use serde::ser::SerializeStruct;
15367 let mut len = 0;
15368 if self.subscriber_id != 0 {
15369 len += 1;
15370 }
15371 if self.upstream_mv_table_id != 0 {
15372 len += 1;
15373 }
15374 let mut struct_ser = serializer.serialize_struct("stream_plan.SubscriptionUpstreamInfo", len)?;
15375 if self.subscriber_id != 0 {
15376 struct_ser.serialize_field("subscriberId", &self.subscriber_id)?;
15377 }
15378 if self.upstream_mv_table_id != 0 {
15379 struct_ser.serialize_field("upstreamMvTableId", &self.upstream_mv_table_id)?;
15380 }
15381 struct_ser.end()
15382 }
15383}
15384impl<'de> serde::Deserialize<'de> for SubscriptionUpstreamInfo {
15385 #[allow(deprecated)]
15386 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15387 where
15388 D: serde::Deserializer<'de>,
15389 {
15390 const FIELDS: &[&str] = &[
15391 "subscriber_id",
15392 "subscriberId",
15393 "upstream_mv_table_id",
15394 "upstreamMvTableId",
15395 ];
15396
15397 #[allow(clippy::enum_variant_names)]
15398 enum GeneratedField {
15399 SubscriberId,
15400 UpstreamMvTableId,
15401 }
15402 impl<'de> serde::Deserialize<'de> for GeneratedField {
15403 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15404 where
15405 D: serde::Deserializer<'de>,
15406 {
15407 struct GeneratedVisitor;
15408
15409 impl serde::de::Visitor<'_> for GeneratedVisitor {
15410 type Value = GeneratedField;
15411
15412 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15413 write!(formatter, "expected one of: {:?}", &FIELDS)
15414 }
15415
15416 #[allow(unused_variables)]
15417 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15418 where
15419 E: serde::de::Error,
15420 {
15421 match value {
15422 "subscriberId" | "subscriber_id" => Ok(GeneratedField::SubscriberId),
15423 "upstreamMvTableId" | "upstream_mv_table_id" => Ok(GeneratedField::UpstreamMvTableId),
15424 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15425 }
15426 }
15427 }
15428 deserializer.deserialize_identifier(GeneratedVisitor)
15429 }
15430 }
15431 struct GeneratedVisitor;
15432 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15433 type Value = SubscriptionUpstreamInfo;
15434
15435 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15436 formatter.write_str("struct stream_plan.SubscriptionUpstreamInfo")
15437 }
15438
15439 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscriptionUpstreamInfo, V::Error>
15440 where
15441 V: serde::de::MapAccess<'de>,
15442 {
15443 let mut subscriber_id__ = None;
15444 let mut upstream_mv_table_id__ = None;
15445 while let Some(k) = map_.next_key()? {
15446 match k {
15447 GeneratedField::SubscriberId => {
15448 if subscriber_id__.is_some() {
15449 return Err(serde::de::Error::duplicate_field("subscriberId"));
15450 }
15451 subscriber_id__ =
15452 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15453 ;
15454 }
15455 GeneratedField::UpstreamMvTableId => {
15456 if upstream_mv_table_id__.is_some() {
15457 return Err(serde::de::Error::duplicate_field("upstreamMvTableId"));
15458 }
15459 upstream_mv_table_id__ =
15460 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15461 ;
15462 }
15463 }
15464 }
15465 Ok(SubscriptionUpstreamInfo {
15466 subscriber_id: subscriber_id__.unwrap_or_default(),
15467 upstream_mv_table_id: upstream_mv_table_id__.unwrap_or_default(),
15468 })
15469 }
15470 }
15471 deserializer.deserialize_struct("stream_plan.SubscriptionUpstreamInfo", FIELDS, GeneratedVisitor)
15472 }
15473}
15474impl serde::Serialize for SyncLogStoreNode {
15475 #[allow(deprecated)]
15476 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15477 where
15478 S: serde::Serializer,
15479 {
15480 use serde::ser::SerializeStruct;
15481 let mut len = 0;
15482 if self.log_store_table.is_some() {
15483 len += 1;
15484 }
15485 if self.pause_duration_ms.is_some() {
15486 len += 1;
15487 }
15488 if self.buffer_size.is_some() {
15489 len += 1;
15490 }
15491 if self.aligned {
15492 len += 1;
15493 }
15494 let mut struct_ser = serializer.serialize_struct("stream_plan.SyncLogStoreNode", len)?;
15495 if let Some(v) = self.log_store_table.as_ref() {
15496 struct_ser.serialize_field("logStoreTable", v)?;
15497 }
15498 if let Some(v) = self.pause_duration_ms.as_ref() {
15499 struct_ser.serialize_field("pauseDurationMs", v)?;
15500 }
15501 if let Some(v) = self.buffer_size.as_ref() {
15502 struct_ser.serialize_field("bufferSize", v)?;
15503 }
15504 if self.aligned {
15505 struct_ser.serialize_field("aligned", &self.aligned)?;
15506 }
15507 struct_ser.end()
15508 }
15509}
15510impl<'de> serde::Deserialize<'de> for SyncLogStoreNode {
15511 #[allow(deprecated)]
15512 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15513 where
15514 D: serde::Deserializer<'de>,
15515 {
15516 const FIELDS: &[&str] = &[
15517 "log_store_table",
15518 "logStoreTable",
15519 "pause_duration_ms",
15520 "pauseDurationMs",
15521 "buffer_size",
15522 "bufferSize",
15523 "aligned",
15524 ];
15525
15526 #[allow(clippy::enum_variant_names)]
15527 enum GeneratedField {
15528 LogStoreTable,
15529 PauseDurationMs,
15530 BufferSize,
15531 Aligned,
15532 }
15533 impl<'de> serde::Deserialize<'de> for GeneratedField {
15534 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15535 where
15536 D: serde::Deserializer<'de>,
15537 {
15538 struct GeneratedVisitor;
15539
15540 impl serde::de::Visitor<'_> for GeneratedVisitor {
15541 type Value = GeneratedField;
15542
15543 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15544 write!(formatter, "expected one of: {:?}", &FIELDS)
15545 }
15546
15547 #[allow(unused_variables)]
15548 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15549 where
15550 E: serde::de::Error,
15551 {
15552 match value {
15553 "logStoreTable" | "log_store_table" => Ok(GeneratedField::LogStoreTable),
15554 "pauseDurationMs" | "pause_duration_ms" => Ok(GeneratedField::PauseDurationMs),
15555 "bufferSize" | "buffer_size" => Ok(GeneratedField::BufferSize),
15556 "aligned" => Ok(GeneratedField::Aligned),
15557 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15558 }
15559 }
15560 }
15561 deserializer.deserialize_identifier(GeneratedVisitor)
15562 }
15563 }
15564 struct GeneratedVisitor;
15565 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15566 type Value = SyncLogStoreNode;
15567
15568 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15569 formatter.write_str("struct stream_plan.SyncLogStoreNode")
15570 }
15571
15572 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SyncLogStoreNode, V::Error>
15573 where
15574 V: serde::de::MapAccess<'de>,
15575 {
15576 let mut log_store_table__ = None;
15577 let mut pause_duration_ms__ = None;
15578 let mut buffer_size__ = None;
15579 let mut aligned__ = None;
15580 while let Some(k) = map_.next_key()? {
15581 match k {
15582 GeneratedField::LogStoreTable => {
15583 if log_store_table__.is_some() {
15584 return Err(serde::de::Error::duplicate_field("logStoreTable"));
15585 }
15586 log_store_table__ = map_.next_value()?;
15587 }
15588 GeneratedField::PauseDurationMs => {
15589 if pause_duration_ms__.is_some() {
15590 return Err(serde::de::Error::duplicate_field("pauseDurationMs"));
15591 }
15592 pause_duration_ms__ =
15593 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15594 ;
15595 }
15596 GeneratedField::BufferSize => {
15597 if buffer_size__.is_some() {
15598 return Err(serde::de::Error::duplicate_field("bufferSize"));
15599 }
15600 buffer_size__ =
15601 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15602 ;
15603 }
15604 GeneratedField::Aligned => {
15605 if aligned__.is_some() {
15606 return Err(serde::de::Error::duplicate_field("aligned"));
15607 }
15608 aligned__ = Some(map_.next_value()?);
15609 }
15610 }
15611 }
15612 Ok(SyncLogStoreNode {
15613 log_store_table: log_store_table__,
15614 pause_duration_ms: pause_duration_ms__,
15615 buffer_size: buffer_size__,
15616 aligned: aligned__.unwrap_or_default(),
15617 })
15618 }
15619 }
15620 deserializer.deserialize_struct("stream_plan.SyncLogStoreNode", FIELDS, GeneratedVisitor)
15621 }
15622}
15623impl serde::Serialize for TemporalJoinNode {
15624 #[allow(deprecated)]
15625 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15626 where
15627 S: serde::Serializer,
15628 {
15629 use serde::ser::SerializeStruct;
15630 let mut len = 0;
15631 if self.join_type != 0 {
15632 len += 1;
15633 }
15634 if !self.left_key.is_empty() {
15635 len += 1;
15636 }
15637 if !self.right_key.is_empty() {
15638 len += 1;
15639 }
15640 if !self.null_safe.is_empty() {
15641 len += 1;
15642 }
15643 if self.condition.is_some() {
15644 len += 1;
15645 }
15646 if !self.output_indices.is_empty() {
15647 len += 1;
15648 }
15649 if self.table_desc.is_some() {
15650 len += 1;
15651 }
15652 if !self.table_output_indices.is_empty() {
15653 len += 1;
15654 }
15655 if self.memo_table.is_some() {
15656 len += 1;
15657 }
15658 if self.is_nested_loop {
15659 len += 1;
15660 }
15661 let mut struct_ser = serializer.serialize_struct("stream_plan.TemporalJoinNode", len)?;
15662 if self.join_type != 0 {
15663 let v = super::plan_common::JoinType::try_from(self.join_type)
15664 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
15665 struct_ser.serialize_field("joinType", &v)?;
15666 }
15667 if !self.left_key.is_empty() {
15668 struct_ser.serialize_field("leftKey", &self.left_key)?;
15669 }
15670 if !self.right_key.is_empty() {
15671 struct_ser.serialize_field("rightKey", &self.right_key)?;
15672 }
15673 if !self.null_safe.is_empty() {
15674 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
15675 }
15676 if let Some(v) = self.condition.as_ref() {
15677 struct_ser.serialize_field("condition", v)?;
15678 }
15679 if !self.output_indices.is_empty() {
15680 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
15681 }
15682 if let Some(v) = self.table_desc.as_ref() {
15683 struct_ser.serialize_field("tableDesc", v)?;
15684 }
15685 if !self.table_output_indices.is_empty() {
15686 struct_ser.serialize_field("tableOutputIndices", &self.table_output_indices)?;
15687 }
15688 if let Some(v) = self.memo_table.as_ref() {
15689 struct_ser.serialize_field("memoTable", v)?;
15690 }
15691 if self.is_nested_loop {
15692 struct_ser.serialize_field("isNestedLoop", &self.is_nested_loop)?;
15693 }
15694 struct_ser.end()
15695 }
15696}
15697impl<'de> serde::Deserialize<'de> for TemporalJoinNode {
15698 #[allow(deprecated)]
15699 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15700 where
15701 D: serde::Deserializer<'de>,
15702 {
15703 const FIELDS: &[&str] = &[
15704 "join_type",
15705 "joinType",
15706 "left_key",
15707 "leftKey",
15708 "right_key",
15709 "rightKey",
15710 "null_safe",
15711 "nullSafe",
15712 "condition",
15713 "output_indices",
15714 "outputIndices",
15715 "table_desc",
15716 "tableDesc",
15717 "table_output_indices",
15718 "tableOutputIndices",
15719 "memo_table",
15720 "memoTable",
15721 "is_nested_loop",
15722 "isNestedLoop",
15723 ];
15724
15725 #[allow(clippy::enum_variant_names)]
15726 enum GeneratedField {
15727 JoinType,
15728 LeftKey,
15729 RightKey,
15730 NullSafe,
15731 Condition,
15732 OutputIndices,
15733 TableDesc,
15734 TableOutputIndices,
15735 MemoTable,
15736 IsNestedLoop,
15737 }
15738 impl<'de> serde::Deserialize<'de> for GeneratedField {
15739 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15740 where
15741 D: serde::Deserializer<'de>,
15742 {
15743 struct GeneratedVisitor;
15744
15745 impl serde::de::Visitor<'_> for GeneratedVisitor {
15746 type Value = GeneratedField;
15747
15748 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15749 write!(formatter, "expected one of: {:?}", &FIELDS)
15750 }
15751
15752 #[allow(unused_variables)]
15753 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15754 where
15755 E: serde::de::Error,
15756 {
15757 match value {
15758 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
15759 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
15760 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
15761 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
15762 "condition" => Ok(GeneratedField::Condition),
15763 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
15764 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
15765 "tableOutputIndices" | "table_output_indices" => Ok(GeneratedField::TableOutputIndices),
15766 "memoTable" | "memo_table" => Ok(GeneratedField::MemoTable),
15767 "isNestedLoop" | "is_nested_loop" => Ok(GeneratedField::IsNestedLoop),
15768 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15769 }
15770 }
15771 }
15772 deserializer.deserialize_identifier(GeneratedVisitor)
15773 }
15774 }
15775 struct GeneratedVisitor;
15776 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15777 type Value = TemporalJoinNode;
15778
15779 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15780 formatter.write_str("struct stream_plan.TemporalJoinNode")
15781 }
15782
15783 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TemporalJoinNode, V::Error>
15784 where
15785 V: serde::de::MapAccess<'de>,
15786 {
15787 let mut join_type__ = None;
15788 let mut left_key__ = None;
15789 let mut right_key__ = None;
15790 let mut null_safe__ = None;
15791 let mut condition__ = None;
15792 let mut output_indices__ = None;
15793 let mut table_desc__ = None;
15794 let mut table_output_indices__ = None;
15795 let mut memo_table__ = None;
15796 let mut is_nested_loop__ = None;
15797 while let Some(k) = map_.next_key()? {
15798 match k {
15799 GeneratedField::JoinType => {
15800 if join_type__.is_some() {
15801 return Err(serde::de::Error::duplicate_field("joinType"));
15802 }
15803 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
15804 }
15805 GeneratedField::LeftKey => {
15806 if left_key__.is_some() {
15807 return Err(serde::de::Error::duplicate_field("leftKey"));
15808 }
15809 left_key__ =
15810 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15811 .into_iter().map(|x| x.0).collect())
15812 ;
15813 }
15814 GeneratedField::RightKey => {
15815 if right_key__.is_some() {
15816 return Err(serde::de::Error::duplicate_field("rightKey"));
15817 }
15818 right_key__ =
15819 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15820 .into_iter().map(|x| x.0).collect())
15821 ;
15822 }
15823 GeneratedField::NullSafe => {
15824 if null_safe__.is_some() {
15825 return Err(serde::de::Error::duplicate_field("nullSafe"));
15826 }
15827 null_safe__ = Some(map_.next_value()?);
15828 }
15829 GeneratedField::Condition => {
15830 if condition__.is_some() {
15831 return Err(serde::de::Error::duplicate_field("condition"));
15832 }
15833 condition__ = map_.next_value()?;
15834 }
15835 GeneratedField::OutputIndices => {
15836 if output_indices__.is_some() {
15837 return Err(serde::de::Error::duplicate_field("outputIndices"));
15838 }
15839 output_indices__ =
15840 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15841 .into_iter().map(|x| x.0).collect())
15842 ;
15843 }
15844 GeneratedField::TableDesc => {
15845 if table_desc__.is_some() {
15846 return Err(serde::de::Error::duplicate_field("tableDesc"));
15847 }
15848 table_desc__ = map_.next_value()?;
15849 }
15850 GeneratedField::TableOutputIndices => {
15851 if table_output_indices__.is_some() {
15852 return Err(serde::de::Error::duplicate_field("tableOutputIndices"));
15853 }
15854 table_output_indices__ =
15855 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15856 .into_iter().map(|x| x.0).collect())
15857 ;
15858 }
15859 GeneratedField::MemoTable => {
15860 if memo_table__.is_some() {
15861 return Err(serde::de::Error::duplicate_field("memoTable"));
15862 }
15863 memo_table__ = map_.next_value()?;
15864 }
15865 GeneratedField::IsNestedLoop => {
15866 if is_nested_loop__.is_some() {
15867 return Err(serde::de::Error::duplicate_field("isNestedLoop"));
15868 }
15869 is_nested_loop__ = Some(map_.next_value()?);
15870 }
15871 }
15872 }
15873 Ok(TemporalJoinNode {
15874 join_type: join_type__.unwrap_or_default(),
15875 left_key: left_key__.unwrap_or_default(),
15876 right_key: right_key__.unwrap_or_default(),
15877 null_safe: null_safe__.unwrap_or_default(),
15878 condition: condition__,
15879 output_indices: output_indices__.unwrap_or_default(),
15880 table_desc: table_desc__,
15881 table_output_indices: table_output_indices__.unwrap_or_default(),
15882 memo_table: memo_table__,
15883 is_nested_loop: is_nested_loop__.unwrap_or_default(),
15884 })
15885 }
15886 }
15887 deserializer.deserialize_struct("stream_plan.TemporalJoinNode", FIELDS, GeneratedVisitor)
15888 }
15889}
15890impl serde::Serialize for ThrottleMutation {
15891 #[allow(deprecated)]
15892 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15893 where
15894 S: serde::Serializer,
15895 {
15896 use serde::ser::SerializeStruct;
15897 let mut len = 0;
15898 if !self.fragment_throttle.is_empty() {
15899 len += 1;
15900 }
15901 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation", len)?;
15902 if !self.fragment_throttle.is_empty() {
15903 struct_ser.serialize_field("fragmentThrottle", &self.fragment_throttle)?;
15904 }
15905 struct_ser.end()
15906 }
15907}
15908impl<'de> serde::Deserialize<'de> for ThrottleMutation {
15909 #[allow(deprecated)]
15910 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15911 where
15912 D: serde::Deserializer<'de>,
15913 {
15914 const FIELDS: &[&str] = &[
15915 "fragment_throttle",
15916 "fragmentThrottle",
15917 ];
15918
15919 #[allow(clippy::enum_variant_names)]
15920 enum GeneratedField {
15921 FragmentThrottle,
15922 }
15923 impl<'de> serde::Deserialize<'de> for GeneratedField {
15924 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15925 where
15926 D: serde::Deserializer<'de>,
15927 {
15928 struct GeneratedVisitor;
15929
15930 impl serde::de::Visitor<'_> for GeneratedVisitor {
15931 type Value = GeneratedField;
15932
15933 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15934 write!(formatter, "expected one of: {:?}", &FIELDS)
15935 }
15936
15937 #[allow(unused_variables)]
15938 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15939 where
15940 E: serde::de::Error,
15941 {
15942 match value {
15943 "fragmentThrottle" | "fragment_throttle" => Ok(GeneratedField::FragmentThrottle),
15944 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15945 }
15946 }
15947 }
15948 deserializer.deserialize_identifier(GeneratedVisitor)
15949 }
15950 }
15951 struct GeneratedVisitor;
15952 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15953 type Value = ThrottleMutation;
15954
15955 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15956 formatter.write_str("struct stream_plan.ThrottleMutation")
15957 }
15958
15959 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ThrottleMutation, V::Error>
15960 where
15961 V: serde::de::MapAccess<'de>,
15962 {
15963 let mut fragment_throttle__ = None;
15964 while let Some(k) = map_.next_key()? {
15965 match k {
15966 GeneratedField::FragmentThrottle => {
15967 if fragment_throttle__.is_some() {
15968 return Err(serde::de::Error::duplicate_field("fragmentThrottle"));
15969 }
15970 fragment_throttle__ = Some(
15971 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15972 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15973 );
15974 }
15975 }
15976 }
15977 Ok(ThrottleMutation {
15978 fragment_throttle: fragment_throttle__.unwrap_or_default(),
15979 })
15980 }
15981 }
15982 deserializer.deserialize_struct("stream_plan.ThrottleMutation", FIELDS, GeneratedVisitor)
15983 }
15984}
15985impl serde::Serialize for throttle_mutation::ThrottleConfig {
15986 #[allow(deprecated)]
15987 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15988 where
15989 S: serde::Serializer,
15990 {
15991 use serde::ser::SerializeStruct;
15992 let mut len = 0;
15993 if self.rate_limit.is_some() {
15994 len += 1;
15995 }
15996 if self.throttle_type != 0 {
15997 len += 1;
15998 }
15999 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation.ThrottleConfig", len)?;
16000 if let Some(v) = self.rate_limit.as_ref() {
16001 struct_ser.serialize_field("rateLimit", v)?;
16002 }
16003 if self.throttle_type != 0 {
16004 let v = super::common::ThrottleType::try_from(self.throttle_type)
16005 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.throttle_type)))?;
16006 struct_ser.serialize_field("throttleType", &v)?;
16007 }
16008 struct_ser.end()
16009 }
16010}
16011impl<'de> serde::Deserialize<'de> for throttle_mutation::ThrottleConfig {
16012 #[allow(deprecated)]
16013 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16014 where
16015 D: serde::Deserializer<'de>,
16016 {
16017 const FIELDS: &[&str] = &[
16018 "rate_limit",
16019 "rateLimit",
16020 "throttle_type",
16021 "throttleType",
16022 ];
16023
16024 #[allow(clippy::enum_variant_names)]
16025 enum GeneratedField {
16026 RateLimit,
16027 ThrottleType,
16028 }
16029 impl<'de> serde::Deserialize<'de> for GeneratedField {
16030 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16031 where
16032 D: serde::Deserializer<'de>,
16033 {
16034 struct GeneratedVisitor;
16035
16036 impl serde::de::Visitor<'_> for GeneratedVisitor {
16037 type Value = GeneratedField;
16038
16039 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16040 write!(formatter, "expected one of: {:?}", &FIELDS)
16041 }
16042
16043 #[allow(unused_variables)]
16044 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16045 where
16046 E: serde::de::Error,
16047 {
16048 match value {
16049 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
16050 "throttleType" | "throttle_type" => Ok(GeneratedField::ThrottleType),
16051 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16052 }
16053 }
16054 }
16055 deserializer.deserialize_identifier(GeneratedVisitor)
16056 }
16057 }
16058 struct GeneratedVisitor;
16059 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16060 type Value = throttle_mutation::ThrottleConfig;
16061
16062 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16063 formatter.write_str("struct stream_plan.ThrottleMutation.ThrottleConfig")
16064 }
16065
16066 fn visit_map<V>(self, mut map_: V) -> std::result::Result<throttle_mutation::ThrottleConfig, V::Error>
16067 where
16068 V: serde::de::MapAccess<'de>,
16069 {
16070 let mut rate_limit__ = None;
16071 let mut throttle_type__ = None;
16072 while let Some(k) = map_.next_key()? {
16073 match k {
16074 GeneratedField::RateLimit => {
16075 if rate_limit__.is_some() {
16076 return Err(serde::de::Error::duplicate_field("rateLimit"));
16077 }
16078 rate_limit__ =
16079 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16080 ;
16081 }
16082 GeneratedField::ThrottleType => {
16083 if throttle_type__.is_some() {
16084 return Err(serde::de::Error::duplicate_field("throttleType"));
16085 }
16086 throttle_type__ = Some(map_.next_value::<super::common::ThrottleType>()? as i32);
16087 }
16088 }
16089 }
16090 Ok(throttle_mutation::ThrottleConfig {
16091 rate_limit: rate_limit__,
16092 throttle_type: throttle_type__.unwrap_or_default(),
16093 })
16094 }
16095 }
16096 deserializer.deserialize_struct("stream_plan.ThrottleMutation.ThrottleConfig", FIELDS, GeneratedVisitor)
16097 }
16098}
16099impl serde::Serialize for TopNNode {
16100 #[allow(deprecated)]
16101 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16102 where
16103 S: serde::Serializer,
16104 {
16105 use serde::ser::SerializeStruct;
16106 let mut len = 0;
16107 if self.limit != 0 {
16108 len += 1;
16109 }
16110 if self.offset != 0 {
16111 len += 1;
16112 }
16113 if self.table.is_some() {
16114 len += 1;
16115 }
16116 if !self.order_by.is_empty() {
16117 len += 1;
16118 }
16119 if self.with_ties {
16120 len += 1;
16121 }
16122 let mut struct_ser = serializer.serialize_struct("stream_plan.TopNNode", len)?;
16123 if self.limit != 0 {
16124 #[allow(clippy::needless_borrow)]
16125 #[allow(clippy::needless_borrows_for_generic_args)]
16126 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
16127 }
16128 if self.offset != 0 {
16129 #[allow(clippy::needless_borrow)]
16130 #[allow(clippy::needless_borrows_for_generic_args)]
16131 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
16132 }
16133 if let Some(v) = self.table.as_ref() {
16134 struct_ser.serialize_field("table", v)?;
16135 }
16136 if !self.order_by.is_empty() {
16137 struct_ser.serialize_field("orderBy", &self.order_by)?;
16138 }
16139 if self.with_ties {
16140 struct_ser.serialize_field("withTies", &self.with_ties)?;
16141 }
16142 struct_ser.end()
16143 }
16144}
16145impl<'de> serde::Deserialize<'de> for TopNNode {
16146 #[allow(deprecated)]
16147 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16148 where
16149 D: serde::Deserializer<'de>,
16150 {
16151 const FIELDS: &[&str] = &[
16152 "limit",
16153 "offset",
16154 "table",
16155 "order_by",
16156 "orderBy",
16157 "with_ties",
16158 "withTies",
16159 ];
16160
16161 #[allow(clippy::enum_variant_names)]
16162 enum GeneratedField {
16163 Limit,
16164 Offset,
16165 Table,
16166 OrderBy,
16167 WithTies,
16168 }
16169 impl<'de> serde::Deserialize<'de> for GeneratedField {
16170 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16171 where
16172 D: serde::Deserializer<'de>,
16173 {
16174 struct GeneratedVisitor;
16175
16176 impl serde::de::Visitor<'_> for GeneratedVisitor {
16177 type Value = GeneratedField;
16178
16179 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16180 write!(formatter, "expected one of: {:?}", &FIELDS)
16181 }
16182
16183 #[allow(unused_variables)]
16184 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16185 where
16186 E: serde::de::Error,
16187 {
16188 match value {
16189 "limit" => Ok(GeneratedField::Limit),
16190 "offset" => Ok(GeneratedField::Offset),
16191 "table" => Ok(GeneratedField::Table),
16192 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
16193 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
16194 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16195 }
16196 }
16197 }
16198 deserializer.deserialize_identifier(GeneratedVisitor)
16199 }
16200 }
16201 struct GeneratedVisitor;
16202 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16203 type Value = TopNNode;
16204
16205 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16206 formatter.write_str("struct stream_plan.TopNNode")
16207 }
16208
16209 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
16210 where
16211 V: serde::de::MapAccess<'de>,
16212 {
16213 let mut limit__ = None;
16214 let mut offset__ = None;
16215 let mut table__ = None;
16216 let mut order_by__ = None;
16217 let mut with_ties__ = None;
16218 while let Some(k) = map_.next_key()? {
16219 match k {
16220 GeneratedField::Limit => {
16221 if limit__.is_some() {
16222 return Err(serde::de::Error::duplicate_field("limit"));
16223 }
16224 limit__ =
16225 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16226 ;
16227 }
16228 GeneratedField::Offset => {
16229 if offset__.is_some() {
16230 return Err(serde::de::Error::duplicate_field("offset"));
16231 }
16232 offset__ =
16233 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16234 ;
16235 }
16236 GeneratedField::Table => {
16237 if table__.is_some() {
16238 return Err(serde::de::Error::duplicate_field("table"));
16239 }
16240 table__ = map_.next_value()?;
16241 }
16242 GeneratedField::OrderBy => {
16243 if order_by__.is_some() {
16244 return Err(serde::de::Error::duplicate_field("orderBy"));
16245 }
16246 order_by__ = Some(map_.next_value()?);
16247 }
16248 GeneratedField::WithTies => {
16249 if with_ties__.is_some() {
16250 return Err(serde::de::Error::duplicate_field("withTies"));
16251 }
16252 with_ties__ = Some(map_.next_value()?);
16253 }
16254 }
16255 }
16256 Ok(TopNNode {
16257 limit: limit__.unwrap_or_default(),
16258 offset: offset__.unwrap_or_default(),
16259 table: table__,
16260 order_by: order_by__.unwrap_or_default(),
16261 with_ties: with_ties__.unwrap_or_default(),
16262 })
16263 }
16264 }
16265 deserializer.deserialize_struct("stream_plan.TopNNode", FIELDS, GeneratedVisitor)
16266 }
16267}
16268impl serde::Serialize for UnionNode {
16269 #[allow(deprecated)]
16270 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16271 where
16272 S: serde::Serializer,
16273 {
16274 use serde::ser::SerializeStruct;
16275 let len = 0;
16276 let struct_ser = serializer.serialize_struct("stream_plan.UnionNode", len)?;
16277 struct_ser.end()
16278 }
16279}
16280impl<'de> serde::Deserialize<'de> for UnionNode {
16281 #[allow(deprecated)]
16282 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16283 where
16284 D: serde::Deserializer<'de>,
16285 {
16286 const FIELDS: &[&str] = &[
16287 ];
16288
16289 #[allow(clippy::enum_variant_names)]
16290 enum GeneratedField {
16291 }
16292 impl<'de> serde::Deserialize<'de> for GeneratedField {
16293 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16294 where
16295 D: serde::Deserializer<'de>,
16296 {
16297 struct GeneratedVisitor;
16298
16299 impl serde::de::Visitor<'_> for GeneratedVisitor {
16300 type Value = GeneratedField;
16301
16302 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16303 write!(formatter, "expected one of: {:?}", &FIELDS)
16304 }
16305
16306 #[allow(unused_variables)]
16307 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16308 where
16309 E: serde::de::Error,
16310 {
16311 Err(serde::de::Error::unknown_field(value, FIELDS))
16312 }
16313 }
16314 deserializer.deserialize_identifier(GeneratedVisitor)
16315 }
16316 }
16317 struct GeneratedVisitor;
16318 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16319 type Value = UnionNode;
16320
16321 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16322 formatter.write_str("struct stream_plan.UnionNode")
16323 }
16324
16325 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
16326 where
16327 V: serde::de::MapAccess<'de>,
16328 {
16329 while map_.next_key::<GeneratedField>()?.is_some() {
16330 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16331 }
16332 Ok(UnionNode {
16333 })
16334 }
16335 }
16336 deserializer.deserialize_struct("stream_plan.UnionNode", FIELDS, GeneratedVisitor)
16337 }
16338}
16339impl serde::Serialize for UpdateMutation {
16340 #[allow(deprecated)]
16341 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16342 where
16343 S: serde::Serializer,
16344 {
16345 use serde::ser::SerializeStruct;
16346 let mut len = 0;
16347 if !self.dispatcher_update.is_empty() {
16348 len += 1;
16349 }
16350 if !self.merge_update.is_empty() {
16351 len += 1;
16352 }
16353 if !self.actor_vnode_bitmap_update.is_empty() {
16354 len += 1;
16355 }
16356 if !self.dropped_actors.is_empty() {
16357 len += 1;
16358 }
16359 if !self.actor_splits.is_empty() {
16360 len += 1;
16361 }
16362 if !self.actor_new_dispatchers.is_empty() {
16363 len += 1;
16364 }
16365 if self.actor_cdc_table_snapshot_splits.is_some() {
16366 len += 1;
16367 }
16368 if !self.sink_schema_change.is_empty() {
16369 len += 1;
16370 }
16371 if !self.subscriptions_to_drop.is_empty() {
16372 len += 1;
16373 }
16374 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation", len)?;
16375 if !self.dispatcher_update.is_empty() {
16376 struct_ser.serialize_field("dispatcherUpdate", &self.dispatcher_update)?;
16377 }
16378 if !self.merge_update.is_empty() {
16379 struct_ser.serialize_field("mergeUpdate", &self.merge_update)?;
16380 }
16381 if !self.actor_vnode_bitmap_update.is_empty() {
16382 struct_ser.serialize_field("actorVnodeBitmapUpdate", &self.actor_vnode_bitmap_update)?;
16383 }
16384 if !self.dropped_actors.is_empty() {
16385 struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
16386 }
16387 if !self.actor_splits.is_empty() {
16388 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
16389 }
16390 if !self.actor_new_dispatchers.is_empty() {
16391 struct_ser.serialize_field("actorNewDispatchers", &self.actor_new_dispatchers)?;
16392 }
16393 if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
16394 struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
16395 }
16396 if !self.sink_schema_change.is_empty() {
16397 struct_ser.serialize_field("sinkSchemaChange", &self.sink_schema_change)?;
16398 }
16399 if !self.subscriptions_to_drop.is_empty() {
16400 struct_ser.serialize_field("subscriptionsToDrop", &self.subscriptions_to_drop)?;
16401 }
16402 struct_ser.end()
16403 }
16404}
16405impl<'de> serde::Deserialize<'de> for UpdateMutation {
16406 #[allow(deprecated)]
16407 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16408 where
16409 D: serde::Deserializer<'de>,
16410 {
16411 const FIELDS: &[&str] = &[
16412 "dispatcher_update",
16413 "dispatcherUpdate",
16414 "merge_update",
16415 "mergeUpdate",
16416 "actor_vnode_bitmap_update",
16417 "actorVnodeBitmapUpdate",
16418 "dropped_actors",
16419 "droppedActors",
16420 "actor_splits",
16421 "actorSplits",
16422 "actor_new_dispatchers",
16423 "actorNewDispatchers",
16424 "actor_cdc_table_snapshot_splits",
16425 "actorCdcTableSnapshotSplits",
16426 "sink_schema_change",
16427 "sinkSchemaChange",
16428 "subscriptions_to_drop",
16429 "subscriptionsToDrop",
16430 ];
16431
16432 #[allow(clippy::enum_variant_names)]
16433 enum GeneratedField {
16434 DispatcherUpdate,
16435 MergeUpdate,
16436 ActorVnodeBitmapUpdate,
16437 DroppedActors,
16438 ActorSplits,
16439 ActorNewDispatchers,
16440 ActorCdcTableSnapshotSplits,
16441 SinkSchemaChange,
16442 SubscriptionsToDrop,
16443 }
16444 impl<'de> serde::Deserialize<'de> for GeneratedField {
16445 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16446 where
16447 D: serde::Deserializer<'de>,
16448 {
16449 struct GeneratedVisitor;
16450
16451 impl serde::de::Visitor<'_> for GeneratedVisitor {
16452 type Value = GeneratedField;
16453
16454 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16455 write!(formatter, "expected one of: {:?}", &FIELDS)
16456 }
16457
16458 #[allow(unused_variables)]
16459 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16460 where
16461 E: serde::de::Error,
16462 {
16463 match value {
16464 "dispatcherUpdate" | "dispatcher_update" => Ok(GeneratedField::DispatcherUpdate),
16465 "mergeUpdate" | "merge_update" => Ok(GeneratedField::MergeUpdate),
16466 "actorVnodeBitmapUpdate" | "actor_vnode_bitmap_update" => Ok(GeneratedField::ActorVnodeBitmapUpdate),
16467 "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
16468 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
16469 "actorNewDispatchers" | "actor_new_dispatchers" => Ok(GeneratedField::ActorNewDispatchers),
16470 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
16471 "sinkSchemaChange" | "sink_schema_change" => Ok(GeneratedField::SinkSchemaChange),
16472 "subscriptionsToDrop" | "subscriptions_to_drop" => Ok(GeneratedField::SubscriptionsToDrop),
16473 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16474 }
16475 }
16476 }
16477 deserializer.deserialize_identifier(GeneratedVisitor)
16478 }
16479 }
16480 struct GeneratedVisitor;
16481 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16482 type Value = UpdateMutation;
16483
16484 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16485 formatter.write_str("struct stream_plan.UpdateMutation")
16486 }
16487
16488 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateMutation, V::Error>
16489 where
16490 V: serde::de::MapAccess<'de>,
16491 {
16492 let mut dispatcher_update__ = None;
16493 let mut merge_update__ = None;
16494 let mut actor_vnode_bitmap_update__ = None;
16495 let mut dropped_actors__ = None;
16496 let mut actor_splits__ = None;
16497 let mut actor_new_dispatchers__ = None;
16498 let mut actor_cdc_table_snapshot_splits__ = None;
16499 let mut sink_schema_change__ = None;
16500 let mut subscriptions_to_drop__ = None;
16501 while let Some(k) = map_.next_key()? {
16502 match k {
16503 GeneratedField::DispatcherUpdate => {
16504 if dispatcher_update__.is_some() {
16505 return Err(serde::de::Error::duplicate_field("dispatcherUpdate"));
16506 }
16507 dispatcher_update__ = Some(map_.next_value()?);
16508 }
16509 GeneratedField::MergeUpdate => {
16510 if merge_update__.is_some() {
16511 return Err(serde::de::Error::duplicate_field("mergeUpdate"));
16512 }
16513 merge_update__ = Some(map_.next_value()?);
16514 }
16515 GeneratedField::ActorVnodeBitmapUpdate => {
16516 if actor_vnode_bitmap_update__.is_some() {
16517 return Err(serde::de::Error::duplicate_field("actorVnodeBitmapUpdate"));
16518 }
16519 actor_vnode_bitmap_update__ = Some(
16520 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
16521 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
16522 );
16523 }
16524 GeneratedField::DroppedActors => {
16525 if dropped_actors__.is_some() {
16526 return Err(serde::de::Error::duplicate_field("droppedActors"));
16527 }
16528 dropped_actors__ =
16529 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16530 .into_iter().map(|x| x.0).collect())
16531 ;
16532 }
16533 GeneratedField::ActorSplits => {
16534 if actor_splits__.is_some() {
16535 return Err(serde::de::Error::duplicate_field("actorSplits"));
16536 }
16537 actor_splits__ = Some(
16538 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
16539 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
16540 );
16541 }
16542 GeneratedField::ActorNewDispatchers => {
16543 if actor_new_dispatchers__.is_some() {
16544 return Err(serde::de::Error::duplicate_field("actorNewDispatchers"));
16545 }
16546 actor_new_dispatchers__ = Some(
16547 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
16548 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
16549 );
16550 }
16551 GeneratedField::ActorCdcTableSnapshotSplits => {
16552 if actor_cdc_table_snapshot_splits__.is_some() {
16553 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
16554 }
16555 actor_cdc_table_snapshot_splits__ = map_.next_value()?;
16556 }
16557 GeneratedField::SinkSchemaChange => {
16558 if sink_schema_change__.is_some() {
16559 return Err(serde::de::Error::duplicate_field("sinkSchemaChange"));
16560 }
16561 sink_schema_change__ = Some(
16562 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
16563 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
16564 );
16565 }
16566 GeneratedField::SubscriptionsToDrop => {
16567 if subscriptions_to_drop__.is_some() {
16568 return Err(serde::de::Error::duplicate_field("subscriptionsToDrop"));
16569 }
16570 subscriptions_to_drop__ = Some(map_.next_value()?);
16571 }
16572 }
16573 }
16574 Ok(UpdateMutation {
16575 dispatcher_update: dispatcher_update__.unwrap_or_default(),
16576 merge_update: merge_update__.unwrap_or_default(),
16577 actor_vnode_bitmap_update: actor_vnode_bitmap_update__.unwrap_or_default(),
16578 dropped_actors: dropped_actors__.unwrap_or_default(),
16579 actor_splits: actor_splits__.unwrap_or_default(),
16580 actor_new_dispatchers: actor_new_dispatchers__.unwrap_or_default(),
16581 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
16582 sink_schema_change: sink_schema_change__.unwrap_or_default(),
16583 subscriptions_to_drop: subscriptions_to_drop__.unwrap_or_default(),
16584 })
16585 }
16586 }
16587 deserializer.deserialize_struct("stream_plan.UpdateMutation", FIELDS, GeneratedVisitor)
16588 }
16589}
16590impl serde::Serialize for update_mutation::DispatcherUpdate {
16591 #[allow(deprecated)]
16592 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16593 where
16594 S: serde::Serializer,
16595 {
16596 use serde::ser::SerializeStruct;
16597 let mut len = 0;
16598 if self.actor_id != 0 {
16599 len += 1;
16600 }
16601 if self.dispatcher_id != 0 {
16602 len += 1;
16603 }
16604 if self.hash_mapping.is_some() {
16605 len += 1;
16606 }
16607 if !self.added_downstream_actor_id.is_empty() {
16608 len += 1;
16609 }
16610 if !self.removed_downstream_actor_id.is_empty() {
16611 len += 1;
16612 }
16613 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", len)?;
16614 if self.actor_id != 0 {
16615 struct_ser.serialize_field("actorId", &self.actor_id)?;
16616 }
16617 if self.dispatcher_id != 0 {
16618 struct_ser.serialize_field("dispatcherId", &self.dispatcher_id)?;
16619 }
16620 if let Some(v) = self.hash_mapping.as_ref() {
16621 struct_ser.serialize_field("hashMapping", v)?;
16622 }
16623 if !self.added_downstream_actor_id.is_empty() {
16624 struct_ser.serialize_field("addedDownstreamActorId", &self.added_downstream_actor_id)?;
16625 }
16626 if !self.removed_downstream_actor_id.is_empty() {
16627 struct_ser.serialize_field("removedDownstreamActorId", &self.removed_downstream_actor_id)?;
16628 }
16629 struct_ser.end()
16630 }
16631}
16632impl<'de> serde::Deserialize<'de> for update_mutation::DispatcherUpdate {
16633 #[allow(deprecated)]
16634 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16635 where
16636 D: serde::Deserializer<'de>,
16637 {
16638 const FIELDS: &[&str] = &[
16639 "actor_id",
16640 "actorId",
16641 "dispatcher_id",
16642 "dispatcherId",
16643 "hash_mapping",
16644 "hashMapping",
16645 "added_downstream_actor_id",
16646 "addedDownstreamActorId",
16647 "removed_downstream_actor_id",
16648 "removedDownstreamActorId",
16649 ];
16650
16651 #[allow(clippy::enum_variant_names)]
16652 enum GeneratedField {
16653 ActorId,
16654 DispatcherId,
16655 HashMapping,
16656 AddedDownstreamActorId,
16657 RemovedDownstreamActorId,
16658 }
16659 impl<'de> serde::Deserialize<'de> for GeneratedField {
16660 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16661 where
16662 D: serde::Deserializer<'de>,
16663 {
16664 struct GeneratedVisitor;
16665
16666 impl serde::de::Visitor<'_> for GeneratedVisitor {
16667 type Value = GeneratedField;
16668
16669 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16670 write!(formatter, "expected one of: {:?}", &FIELDS)
16671 }
16672
16673 #[allow(unused_variables)]
16674 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16675 where
16676 E: serde::de::Error,
16677 {
16678 match value {
16679 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
16680 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
16681 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
16682 "addedDownstreamActorId" | "added_downstream_actor_id" => Ok(GeneratedField::AddedDownstreamActorId),
16683 "removedDownstreamActorId" | "removed_downstream_actor_id" => Ok(GeneratedField::RemovedDownstreamActorId),
16684 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16685 }
16686 }
16687 }
16688 deserializer.deserialize_identifier(GeneratedVisitor)
16689 }
16690 }
16691 struct GeneratedVisitor;
16692 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16693 type Value = update_mutation::DispatcherUpdate;
16694
16695 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16696 formatter.write_str("struct stream_plan.UpdateMutation.DispatcherUpdate")
16697 }
16698
16699 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::DispatcherUpdate, V::Error>
16700 where
16701 V: serde::de::MapAccess<'de>,
16702 {
16703 let mut actor_id__ = None;
16704 let mut dispatcher_id__ = None;
16705 let mut hash_mapping__ = None;
16706 let mut added_downstream_actor_id__ = None;
16707 let mut removed_downstream_actor_id__ = None;
16708 while let Some(k) = map_.next_key()? {
16709 match k {
16710 GeneratedField::ActorId => {
16711 if actor_id__.is_some() {
16712 return Err(serde::de::Error::duplicate_field("actorId"));
16713 }
16714 actor_id__ =
16715 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16716 ;
16717 }
16718 GeneratedField::DispatcherId => {
16719 if dispatcher_id__.is_some() {
16720 return Err(serde::de::Error::duplicate_field("dispatcherId"));
16721 }
16722 dispatcher_id__ =
16723 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16724 ;
16725 }
16726 GeneratedField::HashMapping => {
16727 if hash_mapping__.is_some() {
16728 return Err(serde::de::Error::duplicate_field("hashMapping"));
16729 }
16730 hash_mapping__ = map_.next_value()?;
16731 }
16732 GeneratedField::AddedDownstreamActorId => {
16733 if added_downstream_actor_id__.is_some() {
16734 return Err(serde::de::Error::duplicate_field("addedDownstreamActorId"));
16735 }
16736 added_downstream_actor_id__ =
16737 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16738 .into_iter().map(|x| x.0).collect())
16739 ;
16740 }
16741 GeneratedField::RemovedDownstreamActorId => {
16742 if removed_downstream_actor_id__.is_some() {
16743 return Err(serde::de::Error::duplicate_field("removedDownstreamActorId"));
16744 }
16745 removed_downstream_actor_id__ =
16746 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16747 .into_iter().map(|x| x.0).collect())
16748 ;
16749 }
16750 }
16751 }
16752 Ok(update_mutation::DispatcherUpdate {
16753 actor_id: actor_id__.unwrap_or_default(),
16754 dispatcher_id: dispatcher_id__.unwrap_or_default(),
16755 hash_mapping: hash_mapping__,
16756 added_downstream_actor_id: added_downstream_actor_id__.unwrap_or_default(),
16757 removed_downstream_actor_id: removed_downstream_actor_id__.unwrap_or_default(),
16758 })
16759 }
16760 }
16761 deserializer.deserialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", FIELDS, GeneratedVisitor)
16762 }
16763}
16764impl serde::Serialize for update_mutation::MergeUpdate {
16765 #[allow(deprecated)]
16766 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16767 where
16768 S: serde::Serializer,
16769 {
16770 use serde::ser::SerializeStruct;
16771 let mut len = 0;
16772 if self.actor_id != 0 {
16773 len += 1;
16774 }
16775 if self.upstream_fragment_id != 0 {
16776 len += 1;
16777 }
16778 if self.new_upstream_fragment_id.is_some() {
16779 len += 1;
16780 }
16781 if !self.added_upstream_actors.is_empty() {
16782 len += 1;
16783 }
16784 if !self.removed_upstream_actor_id.is_empty() {
16785 len += 1;
16786 }
16787 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.MergeUpdate", len)?;
16788 if self.actor_id != 0 {
16789 struct_ser.serialize_field("actorId", &self.actor_id)?;
16790 }
16791 if self.upstream_fragment_id != 0 {
16792 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
16793 }
16794 if let Some(v) = self.new_upstream_fragment_id.as_ref() {
16795 struct_ser.serialize_field("newUpstreamFragmentId", v)?;
16796 }
16797 if !self.added_upstream_actors.is_empty() {
16798 struct_ser.serialize_field("addedUpstreamActors", &self.added_upstream_actors)?;
16799 }
16800 if !self.removed_upstream_actor_id.is_empty() {
16801 struct_ser.serialize_field("removedUpstreamActorId", &self.removed_upstream_actor_id)?;
16802 }
16803 struct_ser.end()
16804 }
16805}
16806impl<'de> serde::Deserialize<'de> for update_mutation::MergeUpdate {
16807 #[allow(deprecated)]
16808 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16809 where
16810 D: serde::Deserializer<'de>,
16811 {
16812 const FIELDS: &[&str] = &[
16813 "actor_id",
16814 "actorId",
16815 "upstream_fragment_id",
16816 "upstreamFragmentId",
16817 "new_upstream_fragment_id",
16818 "newUpstreamFragmentId",
16819 "added_upstream_actors",
16820 "addedUpstreamActors",
16821 "removed_upstream_actor_id",
16822 "removedUpstreamActorId",
16823 ];
16824
16825 #[allow(clippy::enum_variant_names)]
16826 enum GeneratedField {
16827 ActorId,
16828 UpstreamFragmentId,
16829 NewUpstreamFragmentId,
16830 AddedUpstreamActors,
16831 RemovedUpstreamActorId,
16832 }
16833 impl<'de> serde::Deserialize<'de> for GeneratedField {
16834 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16835 where
16836 D: serde::Deserializer<'de>,
16837 {
16838 struct GeneratedVisitor;
16839
16840 impl serde::de::Visitor<'_> for GeneratedVisitor {
16841 type Value = GeneratedField;
16842
16843 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16844 write!(formatter, "expected one of: {:?}", &FIELDS)
16845 }
16846
16847 #[allow(unused_variables)]
16848 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16849 where
16850 E: serde::de::Error,
16851 {
16852 match value {
16853 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
16854 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
16855 "newUpstreamFragmentId" | "new_upstream_fragment_id" => Ok(GeneratedField::NewUpstreamFragmentId),
16856 "addedUpstreamActors" | "added_upstream_actors" => Ok(GeneratedField::AddedUpstreamActors),
16857 "removedUpstreamActorId" | "removed_upstream_actor_id" => Ok(GeneratedField::RemovedUpstreamActorId),
16858 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16859 }
16860 }
16861 }
16862 deserializer.deserialize_identifier(GeneratedVisitor)
16863 }
16864 }
16865 struct GeneratedVisitor;
16866 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16867 type Value = update_mutation::MergeUpdate;
16868
16869 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16870 formatter.write_str("struct stream_plan.UpdateMutation.MergeUpdate")
16871 }
16872
16873 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::MergeUpdate, V::Error>
16874 where
16875 V: serde::de::MapAccess<'de>,
16876 {
16877 let mut actor_id__ = None;
16878 let mut upstream_fragment_id__ = None;
16879 let mut new_upstream_fragment_id__ = None;
16880 let mut added_upstream_actors__ = None;
16881 let mut removed_upstream_actor_id__ = None;
16882 while let Some(k) = map_.next_key()? {
16883 match k {
16884 GeneratedField::ActorId => {
16885 if actor_id__.is_some() {
16886 return Err(serde::de::Error::duplicate_field("actorId"));
16887 }
16888 actor_id__ =
16889 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16890 ;
16891 }
16892 GeneratedField::UpstreamFragmentId => {
16893 if upstream_fragment_id__.is_some() {
16894 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
16895 }
16896 upstream_fragment_id__ =
16897 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16898 ;
16899 }
16900 GeneratedField::NewUpstreamFragmentId => {
16901 if new_upstream_fragment_id__.is_some() {
16902 return Err(serde::de::Error::duplicate_field("newUpstreamFragmentId"));
16903 }
16904 new_upstream_fragment_id__ =
16905 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16906 ;
16907 }
16908 GeneratedField::AddedUpstreamActors => {
16909 if added_upstream_actors__.is_some() {
16910 return Err(serde::de::Error::duplicate_field("addedUpstreamActors"));
16911 }
16912 added_upstream_actors__ = Some(map_.next_value()?);
16913 }
16914 GeneratedField::RemovedUpstreamActorId => {
16915 if removed_upstream_actor_id__.is_some() {
16916 return Err(serde::de::Error::duplicate_field("removedUpstreamActorId"));
16917 }
16918 removed_upstream_actor_id__ =
16919 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16920 .into_iter().map(|x| x.0).collect())
16921 ;
16922 }
16923 }
16924 }
16925 Ok(update_mutation::MergeUpdate {
16926 actor_id: actor_id__.unwrap_or_default(),
16927 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
16928 new_upstream_fragment_id: new_upstream_fragment_id__,
16929 added_upstream_actors: added_upstream_actors__.unwrap_or_default(),
16930 removed_upstream_actor_id: removed_upstream_actor_id__.unwrap_or_default(),
16931 })
16932 }
16933 }
16934 deserializer.deserialize_struct("stream_plan.UpdateMutation.MergeUpdate", FIELDS, GeneratedVisitor)
16935 }
16936}
16937impl serde::Serialize for UpstreamSinkInfo {
16938 #[allow(deprecated)]
16939 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16940 where
16941 S: serde::Serializer,
16942 {
16943 use serde::ser::SerializeStruct;
16944 let mut len = 0;
16945 if self.upstream_fragment_id != 0 {
16946 len += 1;
16947 }
16948 if !self.sink_output_schema.is_empty() {
16949 len += 1;
16950 }
16951 if !self.project_exprs.is_empty() {
16952 len += 1;
16953 }
16954 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkInfo", len)?;
16955 if self.upstream_fragment_id != 0 {
16956 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
16957 }
16958 if !self.sink_output_schema.is_empty() {
16959 struct_ser.serialize_field("sinkOutputSchema", &self.sink_output_schema)?;
16960 }
16961 if !self.project_exprs.is_empty() {
16962 struct_ser.serialize_field("projectExprs", &self.project_exprs)?;
16963 }
16964 struct_ser.end()
16965 }
16966}
16967impl<'de> serde::Deserialize<'de> for UpstreamSinkInfo {
16968 #[allow(deprecated)]
16969 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16970 where
16971 D: serde::Deserializer<'de>,
16972 {
16973 const FIELDS: &[&str] = &[
16974 "upstream_fragment_id",
16975 "upstreamFragmentId",
16976 "sink_output_schema",
16977 "sinkOutputSchema",
16978 "project_exprs",
16979 "projectExprs",
16980 ];
16981
16982 #[allow(clippy::enum_variant_names)]
16983 enum GeneratedField {
16984 UpstreamFragmentId,
16985 SinkOutputSchema,
16986 ProjectExprs,
16987 }
16988 impl<'de> serde::Deserialize<'de> for GeneratedField {
16989 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16990 where
16991 D: serde::Deserializer<'de>,
16992 {
16993 struct GeneratedVisitor;
16994
16995 impl serde::de::Visitor<'_> for GeneratedVisitor {
16996 type Value = GeneratedField;
16997
16998 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16999 write!(formatter, "expected one of: {:?}", &FIELDS)
17000 }
17001
17002 #[allow(unused_variables)]
17003 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17004 where
17005 E: serde::de::Error,
17006 {
17007 match value {
17008 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
17009 "sinkOutputSchema" | "sink_output_schema" => Ok(GeneratedField::SinkOutputSchema),
17010 "projectExprs" | "project_exprs" => Ok(GeneratedField::ProjectExprs),
17011 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17012 }
17013 }
17014 }
17015 deserializer.deserialize_identifier(GeneratedVisitor)
17016 }
17017 }
17018 struct GeneratedVisitor;
17019 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17020 type Value = UpstreamSinkInfo;
17021
17022 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17023 formatter.write_str("struct stream_plan.UpstreamSinkInfo")
17024 }
17025
17026 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkInfo, V::Error>
17027 where
17028 V: serde::de::MapAccess<'de>,
17029 {
17030 let mut upstream_fragment_id__ = None;
17031 let mut sink_output_schema__ = None;
17032 let mut project_exprs__ = None;
17033 while let Some(k) = map_.next_key()? {
17034 match k {
17035 GeneratedField::UpstreamFragmentId => {
17036 if upstream_fragment_id__.is_some() {
17037 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
17038 }
17039 upstream_fragment_id__ =
17040 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17041 ;
17042 }
17043 GeneratedField::SinkOutputSchema => {
17044 if sink_output_schema__.is_some() {
17045 return Err(serde::de::Error::duplicate_field("sinkOutputSchema"));
17046 }
17047 sink_output_schema__ = Some(map_.next_value()?);
17048 }
17049 GeneratedField::ProjectExprs => {
17050 if project_exprs__.is_some() {
17051 return Err(serde::de::Error::duplicate_field("projectExprs"));
17052 }
17053 project_exprs__ = Some(map_.next_value()?);
17054 }
17055 }
17056 }
17057 Ok(UpstreamSinkInfo {
17058 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
17059 sink_output_schema: sink_output_schema__.unwrap_or_default(),
17060 project_exprs: project_exprs__.unwrap_or_default(),
17061 })
17062 }
17063 }
17064 deserializer.deserialize_struct("stream_plan.UpstreamSinkInfo", FIELDS, GeneratedVisitor)
17065 }
17066}
17067impl serde::Serialize for UpstreamSinkUnionNode {
17068 #[allow(deprecated)]
17069 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17070 where
17071 S: serde::Serializer,
17072 {
17073 use serde::ser::SerializeStruct;
17074 let mut len = 0;
17075 if !self.init_upstreams.is_empty() {
17076 len += 1;
17077 }
17078 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkUnionNode", len)?;
17079 if !self.init_upstreams.is_empty() {
17080 struct_ser.serialize_field("initUpstreams", &self.init_upstreams)?;
17081 }
17082 struct_ser.end()
17083 }
17084}
17085impl<'de> serde::Deserialize<'de> for UpstreamSinkUnionNode {
17086 #[allow(deprecated)]
17087 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17088 where
17089 D: serde::Deserializer<'de>,
17090 {
17091 const FIELDS: &[&str] = &[
17092 "init_upstreams",
17093 "initUpstreams",
17094 ];
17095
17096 #[allow(clippy::enum_variant_names)]
17097 enum GeneratedField {
17098 InitUpstreams,
17099 }
17100 impl<'de> serde::Deserialize<'de> for GeneratedField {
17101 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17102 where
17103 D: serde::Deserializer<'de>,
17104 {
17105 struct GeneratedVisitor;
17106
17107 impl serde::de::Visitor<'_> for GeneratedVisitor {
17108 type Value = GeneratedField;
17109
17110 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17111 write!(formatter, "expected one of: {:?}", &FIELDS)
17112 }
17113
17114 #[allow(unused_variables)]
17115 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17116 where
17117 E: serde::de::Error,
17118 {
17119 match value {
17120 "initUpstreams" | "init_upstreams" => Ok(GeneratedField::InitUpstreams),
17121 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17122 }
17123 }
17124 }
17125 deserializer.deserialize_identifier(GeneratedVisitor)
17126 }
17127 }
17128 struct GeneratedVisitor;
17129 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17130 type Value = UpstreamSinkUnionNode;
17131
17132 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17133 formatter.write_str("struct stream_plan.UpstreamSinkUnionNode")
17134 }
17135
17136 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkUnionNode, V::Error>
17137 where
17138 V: serde::de::MapAccess<'de>,
17139 {
17140 let mut init_upstreams__ = None;
17141 while let Some(k) = map_.next_key()? {
17142 match k {
17143 GeneratedField::InitUpstreams => {
17144 if init_upstreams__.is_some() {
17145 return Err(serde::de::Error::duplicate_field("initUpstreams"));
17146 }
17147 init_upstreams__ = Some(map_.next_value()?);
17148 }
17149 }
17150 }
17151 Ok(UpstreamSinkUnionNode {
17152 init_upstreams: init_upstreams__.unwrap_or_default(),
17153 })
17154 }
17155 }
17156 deserializer.deserialize_struct("stream_plan.UpstreamSinkUnionNode", FIELDS, GeneratedVisitor)
17157 }
17158}
17159impl serde::Serialize for ValuesNode {
17160 #[allow(deprecated)]
17161 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17162 where
17163 S: serde::Serializer,
17164 {
17165 use serde::ser::SerializeStruct;
17166 let mut len = 0;
17167 if !self.tuples.is_empty() {
17168 len += 1;
17169 }
17170 if !self.fields.is_empty() {
17171 len += 1;
17172 }
17173 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode", len)?;
17174 if !self.tuples.is_empty() {
17175 struct_ser.serialize_field("tuples", &self.tuples)?;
17176 }
17177 if !self.fields.is_empty() {
17178 struct_ser.serialize_field("fields", &self.fields)?;
17179 }
17180 struct_ser.end()
17181 }
17182}
17183impl<'de> serde::Deserialize<'de> for ValuesNode {
17184 #[allow(deprecated)]
17185 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17186 where
17187 D: serde::Deserializer<'de>,
17188 {
17189 const FIELDS: &[&str] = &[
17190 "tuples",
17191 "fields",
17192 ];
17193
17194 #[allow(clippy::enum_variant_names)]
17195 enum GeneratedField {
17196 Tuples,
17197 Fields,
17198 }
17199 impl<'de> serde::Deserialize<'de> for GeneratedField {
17200 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17201 where
17202 D: serde::Deserializer<'de>,
17203 {
17204 struct GeneratedVisitor;
17205
17206 impl serde::de::Visitor<'_> for GeneratedVisitor {
17207 type Value = GeneratedField;
17208
17209 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17210 write!(formatter, "expected one of: {:?}", &FIELDS)
17211 }
17212
17213 #[allow(unused_variables)]
17214 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17215 where
17216 E: serde::de::Error,
17217 {
17218 match value {
17219 "tuples" => Ok(GeneratedField::Tuples),
17220 "fields" => Ok(GeneratedField::Fields),
17221 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17222 }
17223 }
17224 }
17225 deserializer.deserialize_identifier(GeneratedVisitor)
17226 }
17227 }
17228 struct GeneratedVisitor;
17229 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17230 type Value = ValuesNode;
17231
17232 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17233 formatter.write_str("struct stream_plan.ValuesNode")
17234 }
17235
17236 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
17237 where
17238 V: serde::de::MapAccess<'de>,
17239 {
17240 let mut tuples__ = None;
17241 let mut fields__ = None;
17242 while let Some(k) = map_.next_key()? {
17243 match k {
17244 GeneratedField::Tuples => {
17245 if tuples__.is_some() {
17246 return Err(serde::de::Error::duplicate_field("tuples"));
17247 }
17248 tuples__ = Some(map_.next_value()?);
17249 }
17250 GeneratedField::Fields => {
17251 if fields__.is_some() {
17252 return Err(serde::de::Error::duplicate_field("fields"));
17253 }
17254 fields__ = Some(map_.next_value()?);
17255 }
17256 }
17257 }
17258 Ok(ValuesNode {
17259 tuples: tuples__.unwrap_or_default(),
17260 fields: fields__.unwrap_or_default(),
17261 })
17262 }
17263 }
17264 deserializer.deserialize_struct("stream_plan.ValuesNode", FIELDS, GeneratedVisitor)
17265 }
17266}
17267impl serde::Serialize for values_node::ExprTuple {
17268 #[allow(deprecated)]
17269 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17270 where
17271 S: serde::Serializer,
17272 {
17273 use serde::ser::SerializeStruct;
17274 let mut len = 0;
17275 if !self.cells.is_empty() {
17276 len += 1;
17277 }
17278 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode.ExprTuple", len)?;
17279 if !self.cells.is_empty() {
17280 struct_ser.serialize_field("cells", &self.cells)?;
17281 }
17282 struct_ser.end()
17283 }
17284}
17285impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
17286 #[allow(deprecated)]
17287 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17288 where
17289 D: serde::Deserializer<'de>,
17290 {
17291 const FIELDS: &[&str] = &[
17292 "cells",
17293 ];
17294
17295 #[allow(clippy::enum_variant_names)]
17296 enum GeneratedField {
17297 Cells,
17298 }
17299 impl<'de> serde::Deserialize<'de> for GeneratedField {
17300 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17301 where
17302 D: serde::Deserializer<'de>,
17303 {
17304 struct GeneratedVisitor;
17305
17306 impl serde::de::Visitor<'_> for GeneratedVisitor {
17307 type Value = GeneratedField;
17308
17309 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17310 write!(formatter, "expected one of: {:?}", &FIELDS)
17311 }
17312
17313 #[allow(unused_variables)]
17314 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17315 where
17316 E: serde::de::Error,
17317 {
17318 match value {
17319 "cells" => Ok(GeneratedField::Cells),
17320 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17321 }
17322 }
17323 }
17324 deserializer.deserialize_identifier(GeneratedVisitor)
17325 }
17326 }
17327 struct GeneratedVisitor;
17328 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17329 type Value = values_node::ExprTuple;
17330
17331 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17332 formatter.write_str("struct stream_plan.ValuesNode.ExprTuple")
17333 }
17334
17335 fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
17336 where
17337 V: serde::de::MapAccess<'de>,
17338 {
17339 let mut cells__ = None;
17340 while let Some(k) = map_.next_key()? {
17341 match k {
17342 GeneratedField::Cells => {
17343 if cells__.is_some() {
17344 return Err(serde::de::Error::duplicate_field("cells"));
17345 }
17346 cells__ = Some(map_.next_value()?);
17347 }
17348 }
17349 }
17350 Ok(values_node::ExprTuple {
17351 cells: cells__.unwrap_or_default(),
17352 })
17353 }
17354 }
17355 deserializer.deserialize_struct("stream_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
17356 }
17357}
17358impl serde::Serialize for VectorIndexLookupJoinNode {
17359 #[allow(deprecated)]
17360 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17361 where
17362 S: serde::Serializer,
17363 {
17364 use serde::ser::SerializeStruct;
17365 let mut len = 0;
17366 if self.reader_desc.is_some() {
17367 len += 1;
17368 }
17369 if self.vector_column_idx != 0 {
17370 len += 1;
17371 }
17372 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexLookupJoinNode", len)?;
17373 if let Some(v) = self.reader_desc.as_ref() {
17374 struct_ser.serialize_field("readerDesc", v)?;
17375 }
17376 if self.vector_column_idx != 0 {
17377 struct_ser.serialize_field("vectorColumnIdx", &self.vector_column_idx)?;
17378 }
17379 struct_ser.end()
17380 }
17381}
17382impl<'de> serde::Deserialize<'de> for VectorIndexLookupJoinNode {
17383 #[allow(deprecated)]
17384 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17385 where
17386 D: serde::Deserializer<'de>,
17387 {
17388 const FIELDS: &[&str] = &[
17389 "reader_desc",
17390 "readerDesc",
17391 "vector_column_idx",
17392 "vectorColumnIdx",
17393 ];
17394
17395 #[allow(clippy::enum_variant_names)]
17396 enum GeneratedField {
17397 ReaderDesc,
17398 VectorColumnIdx,
17399 }
17400 impl<'de> serde::Deserialize<'de> for GeneratedField {
17401 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17402 where
17403 D: serde::Deserializer<'de>,
17404 {
17405 struct GeneratedVisitor;
17406
17407 impl serde::de::Visitor<'_> for GeneratedVisitor {
17408 type Value = GeneratedField;
17409
17410 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17411 write!(formatter, "expected one of: {:?}", &FIELDS)
17412 }
17413
17414 #[allow(unused_variables)]
17415 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17416 where
17417 E: serde::de::Error,
17418 {
17419 match value {
17420 "readerDesc" | "reader_desc" => Ok(GeneratedField::ReaderDesc),
17421 "vectorColumnIdx" | "vector_column_idx" => Ok(GeneratedField::VectorColumnIdx),
17422 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17423 }
17424 }
17425 }
17426 deserializer.deserialize_identifier(GeneratedVisitor)
17427 }
17428 }
17429 struct GeneratedVisitor;
17430 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17431 type Value = VectorIndexLookupJoinNode;
17432
17433 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17434 formatter.write_str("struct stream_plan.VectorIndexLookupJoinNode")
17435 }
17436
17437 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexLookupJoinNode, V::Error>
17438 where
17439 V: serde::de::MapAccess<'de>,
17440 {
17441 let mut reader_desc__ = None;
17442 let mut vector_column_idx__ = None;
17443 while let Some(k) = map_.next_key()? {
17444 match k {
17445 GeneratedField::ReaderDesc => {
17446 if reader_desc__.is_some() {
17447 return Err(serde::de::Error::duplicate_field("readerDesc"));
17448 }
17449 reader_desc__ = map_.next_value()?;
17450 }
17451 GeneratedField::VectorColumnIdx => {
17452 if vector_column_idx__.is_some() {
17453 return Err(serde::de::Error::duplicate_field("vectorColumnIdx"));
17454 }
17455 vector_column_idx__ =
17456 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17457 ;
17458 }
17459 }
17460 }
17461 Ok(VectorIndexLookupJoinNode {
17462 reader_desc: reader_desc__,
17463 vector_column_idx: vector_column_idx__.unwrap_or_default(),
17464 })
17465 }
17466 }
17467 deserializer.deserialize_struct("stream_plan.VectorIndexLookupJoinNode", FIELDS, GeneratedVisitor)
17468 }
17469}
17470impl serde::Serialize for VectorIndexWriteNode {
17471 #[allow(deprecated)]
17472 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17473 where
17474 S: serde::Serializer,
17475 {
17476 use serde::ser::SerializeStruct;
17477 let mut len = 0;
17478 if self.table.is_some() {
17479 len += 1;
17480 }
17481 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexWriteNode", len)?;
17482 if let Some(v) = self.table.as_ref() {
17483 struct_ser.serialize_field("table", v)?;
17484 }
17485 struct_ser.end()
17486 }
17487}
17488impl<'de> serde::Deserialize<'de> for VectorIndexWriteNode {
17489 #[allow(deprecated)]
17490 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17491 where
17492 D: serde::Deserializer<'de>,
17493 {
17494 const FIELDS: &[&str] = &[
17495 "table",
17496 ];
17497
17498 #[allow(clippy::enum_variant_names)]
17499 enum GeneratedField {
17500 Table,
17501 }
17502 impl<'de> serde::Deserialize<'de> for GeneratedField {
17503 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17504 where
17505 D: serde::Deserializer<'de>,
17506 {
17507 struct GeneratedVisitor;
17508
17509 impl serde::de::Visitor<'_> for GeneratedVisitor {
17510 type Value = GeneratedField;
17511
17512 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17513 write!(formatter, "expected one of: {:?}", &FIELDS)
17514 }
17515
17516 #[allow(unused_variables)]
17517 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17518 where
17519 E: serde::de::Error,
17520 {
17521 match value {
17522 "table" => Ok(GeneratedField::Table),
17523 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17524 }
17525 }
17526 }
17527 deserializer.deserialize_identifier(GeneratedVisitor)
17528 }
17529 }
17530 struct GeneratedVisitor;
17531 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17532 type Value = VectorIndexWriteNode;
17533
17534 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17535 formatter.write_str("struct stream_plan.VectorIndexWriteNode")
17536 }
17537
17538 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexWriteNode, V::Error>
17539 where
17540 V: serde::de::MapAccess<'de>,
17541 {
17542 let mut table__ = None;
17543 while let Some(k) = map_.next_key()? {
17544 match k {
17545 GeneratedField::Table => {
17546 if table__.is_some() {
17547 return Err(serde::de::Error::duplicate_field("table"));
17548 }
17549 table__ = map_.next_value()?;
17550 }
17551 }
17552 }
17553 Ok(VectorIndexWriteNode {
17554 table: table__,
17555 })
17556 }
17557 }
17558 deserializer.deserialize_struct("stream_plan.VectorIndexWriteNode", FIELDS, GeneratedVisitor)
17559 }
17560}
17561impl serde::Serialize for Watermark {
17562 #[allow(deprecated)]
17563 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17564 where
17565 S: serde::Serializer,
17566 {
17567 use serde::ser::SerializeStruct;
17568 let mut len = 0;
17569 if self.column.is_some() {
17570 len += 1;
17571 }
17572 if self.val.is_some() {
17573 len += 1;
17574 }
17575 let mut struct_ser = serializer.serialize_struct("stream_plan.Watermark", len)?;
17576 if let Some(v) = self.column.as_ref() {
17577 struct_ser.serialize_field("column", v)?;
17578 }
17579 if let Some(v) = self.val.as_ref() {
17580 struct_ser.serialize_field("val", v)?;
17581 }
17582 struct_ser.end()
17583 }
17584}
17585impl<'de> serde::Deserialize<'de> for Watermark {
17586 #[allow(deprecated)]
17587 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17588 where
17589 D: serde::Deserializer<'de>,
17590 {
17591 const FIELDS: &[&str] = &[
17592 "column",
17593 "val",
17594 ];
17595
17596 #[allow(clippy::enum_variant_names)]
17597 enum GeneratedField {
17598 Column,
17599 Val,
17600 }
17601 impl<'de> serde::Deserialize<'de> for GeneratedField {
17602 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17603 where
17604 D: serde::Deserializer<'de>,
17605 {
17606 struct GeneratedVisitor;
17607
17608 impl serde::de::Visitor<'_> for GeneratedVisitor {
17609 type Value = GeneratedField;
17610
17611 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17612 write!(formatter, "expected one of: {:?}", &FIELDS)
17613 }
17614
17615 #[allow(unused_variables)]
17616 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17617 where
17618 E: serde::de::Error,
17619 {
17620 match value {
17621 "column" => Ok(GeneratedField::Column),
17622 "val" => Ok(GeneratedField::Val),
17623 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17624 }
17625 }
17626 }
17627 deserializer.deserialize_identifier(GeneratedVisitor)
17628 }
17629 }
17630 struct GeneratedVisitor;
17631 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17632 type Value = Watermark;
17633
17634 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17635 formatter.write_str("struct stream_plan.Watermark")
17636 }
17637
17638 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Watermark, V::Error>
17639 where
17640 V: serde::de::MapAccess<'de>,
17641 {
17642 let mut column__ = None;
17643 let mut val__ = None;
17644 while let Some(k) = map_.next_key()? {
17645 match k {
17646 GeneratedField::Column => {
17647 if column__.is_some() {
17648 return Err(serde::de::Error::duplicate_field("column"));
17649 }
17650 column__ = map_.next_value()?;
17651 }
17652 GeneratedField::Val => {
17653 if val__.is_some() {
17654 return Err(serde::de::Error::duplicate_field("val"));
17655 }
17656 val__ = map_.next_value()?;
17657 }
17658 }
17659 }
17660 Ok(Watermark {
17661 column: column__,
17662 val: val__,
17663 })
17664 }
17665 }
17666 deserializer.deserialize_struct("stream_plan.Watermark", FIELDS, GeneratedVisitor)
17667 }
17668}
17669impl serde::Serialize for WatermarkFilterNode {
17670 #[allow(deprecated)]
17671 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17672 where
17673 S: serde::Serializer,
17674 {
17675 use serde::ser::SerializeStruct;
17676 let mut len = 0;
17677 if !self.watermark_descs.is_empty() {
17678 len += 1;
17679 }
17680 if !self.tables.is_empty() {
17681 len += 1;
17682 }
17683 let mut struct_ser = serializer.serialize_struct("stream_plan.WatermarkFilterNode", len)?;
17684 if !self.watermark_descs.is_empty() {
17685 struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
17686 }
17687 if !self.tables.is_empty() {
17688 struct_ser.serialize_field("tables", &self.tables)?;
17689 }
17690 struct_ser.end()
17691 }
17692}
17693impl<'de> serde::Deserialize<'de> for WatermarkFilterNode {
17694 #[allow(deprecated)]
17695 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17696 where
17697 D: serde::Deserializer<'de>,
17698 {
17699 const FIELDS: &[&str] = &[
17700 "watermark_descs",
17701 "watermarkDescs",
17702 "tables",
17703 ];
17704
17705 #[allow(clippy::enum_variant_names)]
17706 enum GeneratedField {
17707 WatermarkDescs,
17708 Tables,
17709 }
17710 impl<'de> serde::Deserialize<'de> for GeneratedField {
17711 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17712 where
17713 D: serde::Deserializer<'de>,
17714 {
17715 struct GeneratedVisitor;
17716
17717 impl serde::de::Visitor<'_> for GeneratedVisitor {
17718 type Value = GeneratedField;
17719
17720 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17721 write!(formatter, "expected one of: {:?}", &FIELDS)
17722 }
17723
17724 #[allow(unused_variables)]
17725 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17726 where
17727 E: serde::de::Error,
17728 {
17729 match value {
17730 "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
17731 "tables" => Ok(GeneratedField::Tables),
17732 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17733 }
17734 }
17735 }
17736 deserializer.deserialize_identifier(GeneratedVisitor)
17737 }
17738 }
17739 struct GeneratedVisitor;
17740 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17741 type Value = WatermarkFilterNode;
17742
17743 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17744 formatter.write_str("struct stream_plan.WatermarkFilterNode")
17745 }
17746
17747 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkFilterNode, V::Error>
17748 where
17749 V: serde::de::MapAccess<'de>,
17750 {
17751 let mut watermark_descs__ = None;
17752 let mut tables__ = None;
17753 while let Some(k) = map_.next_key()? {
17754 match k {
17755 GeneratedField::WatermarkDescs => {
17756 if watermark_descs__.is_some() {
17757 return Err(serde::de::Error::duplicate_field("watermarkDescs"));
17758 }
17759 watermark_descs__ = Some(map_.next_value()?);
17760 }
17761 GeneratedField::Tables => {
17762 if tables__.is_some() {
17763 return Err(serde::de::Error::duplicate_field("tables"));
17764 }
17765 tables__ = Some(map_.next_value()?);
17766 }
17767 }
17768 }
17769 Ok(WatermarkFilterNode {
17770 watermark_descs: watermark_descs__.unwrap_or_default(),
17771 tables: tables__.unwrap_or_default(),
17772 })
17773 }
17774 }
17775 deserializer.deserialize_struct("stream_plan.WatermarkFilterNode", FIELDS, GeneratedVisitor)
17776 }
17777}