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<'de> serde::de::Visitor<'de> 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<'de> serde::de::Visitor<'de> 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<'de> serde::de::Visitor<'de> 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<'de> serde::de::Visitor<'de> 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<'de> serde::de::Visitor<'de> 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<'de> serde::de::Visitor<'de> 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<'de> serde::de::Visitor<'de> 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<'de> serde::de::Visitor<'de> 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<'de> serde::de::Visitor<'de> 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<'de> serde::de::Visitor<'de> 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<'de> serde::de::Visitor<'de> 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 if !self.passed_actors.is_empty() {
1551 len += 1;
1552 }
1553 let mut struct_ser = serializer.serialize_struct("stream_plan.Barrier", len)?;
1554 if let Some(v) = self.epoch.as_ref() {
1555 struct_ser.serialize_field("epoch", v)?;
1556 }
1557 if let Some(v) = self.mutation.as_ref() {
1558 struct_ser.serialize_field("mutation", v)?;
1559 }
1560 if !self.tracing_context.is_empty() {
1561 struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
1562 }
1563 if self.kind != 0 {
1564 let v = barrier::BarrierKind::try_from(self.kind)
1565 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
1566 struct_ser.serialize_field("kind", &v)?;
1567 }
1568 if !self.passed_actors.is_empty() {
1569 struct_ser.serialize_field("passedActors", &self.passed_actors)?;
1570 }
1571 struct_ser.end()
1572 }
1573}
1574impl<'de> serde::Deserialize<'de> for Barrier {
1575 #[allow(deprecated)]
1576 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1577 where
1578 D: serde::Deserializer<'de>,
1579 {
1580 const FIELDS: &[&str] = &[
1581 "epoch",
1582 "mutation",
1583 "tracing_context",
1584 "tracingContext",
1585 "kind",
1586 "passed_actors",
1587 "passedActors",
1588 ];
1589
1590 #[allow(clippy::enum_variant_names)]
1591 enum GeneratedField {
1592 Epoch,
1593 Mutation,
1594 TracingContext,
1595 Kind,
1596 PassedActors,
1597 }
1598 impl<'de> serde::Deserialize<'de> for GeneratedField {
1599 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1600 where
1601 D: serde::Deserializer<'de>,
1602 {
1603 struct GeneratedVisitor;
1604
1605 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1606 type Value = GeneratedField;
1607
1608 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1609 write!(formatter, "expected one of: {:?}", &FIELDS)
1610 }
1611
1612 #[allow(unused_variables)]
1613 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1614 where
1615 E: serde::de::Error,
1616 {
1617 match value {
1618 "epoch" => Ok(GeneratedField::Epoch),
1619 "mutation" => Ok(GeneratedField::Mutation),
1620 "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
1621 "kind" => Ok(GeneratedField::Kind),
1622 "passedActors" | "passed_actors" => Ok(GeneratedField::PassedActors),
1623 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1624 }
1625 }
1626 }
1627 deserializer.deserialize_identifier(GeneratedVisitor)
1628 }
1629 }
1630 struct GeneratedVisitor;
1631 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1632 type Value = Barrier;
1633
1634 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1635 formatter.write_str("struct stream_plan.Barrier")
1636 }
1637
1638 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Barrier, V::Error>
1639 where
1640 V: serde::de::MapAccess<'de>,
1641 {
1642 let mut epoch__ = None;
1643 let mut mutation__ = None;
1644 let mut tracing_context__ = None;
1645 let mut kind__ = None;
1646 let mut passed_actors__ = None;
1647 while let Some(k) = map_.next_key()? {
1648 match k {
1649 GeneratedField::Epoch => {
1650 if epoch__.is_some() {
1651 return Err(serde::de::Error::duplicate_field("epoch"));
1652 }
1653 epoch__ = map_.next_value()?;
1654 }
1655 GeneratedField::Mutation => {
1656 if mutation__.is_some() {
1657 return Err(serde::de::Error::duplicate_field("mutation"));
1658 }
1659 mutation__ = map_.next_value()?;
1660 }
1661 GeneratedField::TracingContext => {
1662 if tracing_context__.is_some() {
1663 return Err(serde::de::Error::duplicate_field("tracingContext"));
1664 }
1665 tracing_context__ = Some(
1666 map_.next_value::<std::collections::HashMap<_, _>>()?
1667 );
1668 }
1669 GeneratedField::Kind => {
1670 if kind__.is_some() {
1671 return Err(serde::de::Error::duplicate_field("kind"));
1672 }
1673 kind__ = Some(map_.next_value::<barrier::BarrierKind>()? as i32);
1674 }
1675 GeneratedField::PassedActors => {
1676 if passed_actors__.is_some() {
1677 return Err(serde::de::Error::duplicate_field("passedActors"));
1678 }
1679 passed_actors__ =
1680 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1681 .into_iter().map(|x| x.0).collect())
1682 ;
1683 }
1684 }
1685 }
1686 Ok(Barrier {
1687 epoch: epoch__,
1688 mutation: mutation__,
1689 tracing_context: tracing_context__.unwrap_or_default(),
1690 kind: kind__.unwrap_or_default(),
1691 passed_actors: passed_actors__.unwrap_or_default(),
1692 })
1693 }
1694 }
1695 deserializer.deserialize_struct("stream_plan.Barrier", FIELDS, GeneratedVisitor)
1696 }
1697}
1698impl serde::Serialize for barrier::BarrierKind {
1699 #[allow(deprecated)]
1700 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1701 where
1702 S: serde::Serializer,
1703 {
1704 let variant = match self {
1705 Self::Unspecified => "BARRIER_KIND_UNSPECIFIED",
1706 Self::Initial => "BARRIER_KIND_INITIAL",
1707 Self::Barrier => "BARRIER_KIND_BARRIER",
1708 Self::Checkpoint => "BARRIER_KIND_CHECKPOINT",
1709 };
1710 serializer.serialize_str(variant)
1711 }
1712}
1713impl<'de> serde::Deserialize<'de> for barrier::BarrierKind {
1714 #[allow(deprecated)]
1715 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1716 where
1717 D: serde::Deserializer<'de>,
1718 {
1719 const FIELDS: &[&str] = &[
1720 "BARRIER_KIND_UNSPECIFIED",
1721 "BARRIER_KIND_INITIAL",
1722 "BARRIER_KIND_BARRIER",
1723 "BARRIER_KIND_CHECKPOINT",
1724 ];
1725
1726 struct GeneratedVisitor;
1727
1728 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1729 type Value = barrier::BarrierKind;
1730
1731 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1732 write!(formatter, "expected one of: {:?}", &FIELDS)
1733 }
1734
1735 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1736 where
1737 E: serde::de::Error,
1738 {
1739 i32::try_from(v)
1740 .ok()
1741 .and_then(|x| x.try_into().ok())
1742 .ok_or_else(|| {
1743 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1744 })
1745 }
1746
1747 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1748 where
1749 E: serde::de::Error,
1750 {
1751 i32::try_from(v)
1752 .ok()
1753 .and_then(|x| x.try_into().ok())
1754 .ok_or_else(|| {
1755 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1756 })
1757 }
1758
1759 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1760 where
1761 E: serde::de::Error,
1762 {
1763 match value {
1764 "BARRIER_KIND_UNSPECIFIED" => Ok(barrier::BarrierKind::Unspecified),
1765 "BARRIER_KIND_INITIAL" => Ok(barrier::BarrierKind::Initial),
1766 "BARRIER_KIND_BARRIER" => Ok(barrier::BarrierKind::Barrier),
1767 "BARRIER_KIND_CHECKPOINT" => Ok(barrier::BarrierKind::Checkpoint),
1768 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1769 }
1770 }
1771 }
1772 deserializer.deserialize_any(GeneratedVisitor)
1773 }
1774}
1775impl serde::Serialize for BarrierMutation {
1776 #[allow(deprecated)]
1777 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1778 where
1779 S: serde::Serializer,
1780 {
1781 use serde::ser::SerializeStruct;
1782 let mut len = 0;
1783 if self.mutation.is_some() {
1784 len += 1;
1785 }
1786 let mut struct_ser = serializer.serialize_struct("stream_plan.BarrierMutation", len)?;
1787 if let Some(v) = self.mutation.as_ref() {
1788 match v {
1789 barrier_mutation::Mutation::Add(v) => {
1790 struct_ser.serialize_field("add", v)?;
1791 }
1792 barrier_mutation::Mutation::Stop(v) => {
1793 struct_ser.serialize_field("stop", v)?;
1794 }
1795 barrier_mutation::Mutation::Update(v) => {
1796 struct_ser.serialize_field("update", v)?;
1797 }
1798 barrier_mutation::Mutation::Splits(v) => {
1799 struct_ser.serialize_field("splits", v)?;
1800 }
1801 barrier_mutation::Mutation::Pause(v) => {
1802 struct_ser.serialize_field("pause", v)?;
1803 }
1804 barrier_mutation::Mutation::Resume(v) => {
1805 struct_ser.serialize_field("resume", v)?;
1806 }
1807 barrier_mutation::Mutation::Throttle(v) => {
1808 struct_ser.serialize_field("throttle", v)?;
1809 }
1810 barrier_mutation::Mutation::DropSubscriptions(v) => {
1811 struct_ser.serialize_field("dropSubscriptions", v)?;
1812 }
1813 barrier_mutation::Mutation::ConnectorPropsChange(v) => {
1814 struct_ser.serialize_field("connectorPropsChange", v)?;
1815 }
1816 barrier_mutation::Mutation::StartFragmentBackfill(v) => {
1817 struct_ser.serialize_field("startFragmentBackfill", v)?;
1818 }
1819 barrier_mutation::Mutation::RefreshStart(v) => {
1820 struct_ser.serialize_field("refreshStart", v)?;
1821 }
1822 barrier_mutation::Mutation::LoadFinish(v) => {
1823 struct_ser.serialize_field("loadFinish", v)?;
1824 }
1825 barrier_mutation::Mutation::ListFinish(v) => {
1826 struct_ser.serialize_field("listFinish", v)?;
1827 }
1828 }
1829 }
1830 struct_ser.end()
1831 }
1832}
1833impl<'de> serde::Deserialize<'de> for BarrierMutation {
1834 #[allow(deprecated)]
1835 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1836 where
1837 D: serde::Deserializer<'de>,
1838 {
1839 const FIELDS: &[&str] = &[
1840 "add",
1841 "stop",
1842 "update",
1843 "splits",
1844 "pause",
1845 "resume",
1846 "throttle",
1847 "drop_subscriptions",
1848 "dropSubscriptions",
1849 "connector_props_change",
1850 "connectorPropsChange",
1851 "start_fragment_backfill",
1852 "startFragmentBackfill",
1853 "refresh_start",
1854 "refreshStart",
1855 "load_finish",
1856 "loadFinish",
1857 "list_finish",
1858 "listFinish",
1859 ];
1860
1861 #[allow(clippy::enum_variant_names)]
1862 enum GeneratedField {
1863 Add,
1864 Stop,
1865 Update,
1866 Splits,
1867 Pause,
1868 Resume,
1869 Throttle,
1870 DropSubscriptions,
1871 ConnectorPropsChange,
1872 StartFragmentBackfill,
1873 RefreshStart,
1874 LoadFinish,
1875 ListFinish,
1876 }
1877 impl<'de> serde::Deserialize<'de> for GeneratedField {
1878 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1879 where
1880 D: serde::Deserializer<'de>,
1881 {
1882 struct GeneratedVisitor;
1883
1884 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1885 type Value = GeneratedField;
1886
1887 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1888 write!(formatter, "expected one of: {:?}", &FIELDS)
1889 }
1890
1891 #[allow(unused_variables)]
1892 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1893 where
1894 E: serde::de::Error,
1895 {
1896 match value {
1897 "add" => Ok(GeneratedField::Add),
1898 "stop" => Ok(GeneratedField::Stop),
1899 "update" => Ok(GeneratedField::Update),
1900 "splits" => Ok(GeneratedField::Splits),
1901 "pause" => Ok(GeneratedField::Pause),
1902 "resume" => Ok(GeneratedField::Resume),
1903 "throttle" => Ok(GeneratedField::Throttle),
1904 "dropSubscriptions" | "drop_subscriptions" => Ok(GeneratedField::DropSubscriptions),
1905 "connectorPropsChange" | "connector_props_change" => Ok(GeneratedField::ConnectorPropsChange),
1906 "startFragmentBackfill" | "start_fragment_backfill" => Ok(GeneratedField::StartFragmentBackfill),
1907 "refreshStart" | "refresh_start" => Ok(GeneratedField::RefreshStart),
1908 "loadFinish" | "load_finish" => Ok(GeneratedField::LoadFinish),
1909 "listFinish" | "list_finish" => Ok(GeneratedField::ListFinish),
1910 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1911 }
1912 }
1913 }
1914 deserializer.deserialize_identifier(GeneratedVisitor)
1915 }
1916 }
1917 struct GeneratedVisitor;
1918 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1919 type Value = BarrierMutation;
1920
1921 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1922 formatter.write_str("struct stream_plan.BarrierMutation")
1923 }
1924
1925 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierMutation, V::Error>
1926 where
1927 V: serde::de::MapAccess<'de>,
1928 {
1929 let mut mutation__ = None;
1930 while let Some(k) = map_.next_key()? {
1931 match k {
1932 GeneratedField::Add => {
1933 if mutation__.is_some() {
1934 return Err(serde::de::Error::duplicate_field("add"));
1935 }
1936 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Add)
1937;
1938 }
1939 GeneratedField::Stop => {
1940 if mutation__.is_some() {
1941 return Err(serde::de::Error::duplicate_field("stop"));
1942 }
1943 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Stop)
1944;
1945 }
1946 GeneratedField::Update => {
1947 if mutation__.is_some() {
1948 return Err(serde::de::Error::duplicate_field("update"));
1949 }
1950 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Update)
1951;
1952 }
1953 GeneratedField::Splits => {
1954 if mutation__.is_some() {
1955 return Err(serde::de::Error::duplicate_field("splits"));
1956 }
1957 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Splits)
1958;
1959 }
1960 GeneratedField::Pause => {
1961 if mutation__.is_some() {
1962 return Err(serde::de::Error::duplicate_field("pause"));
1963 }
1964 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Pause)
1965;
1966 }
1967 GeneratedField::Resume => {
1968 if mutation__.is_some() {
1969 return Err(serde::de::Error::duplicate_field("resume"));
1970 }
1971 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Resume)
1972;
1973 }
1974 GeneratedField::Throttle => {
1975 if mutation__.is_some() {
1976 return Err(serde::de::Error::duplicate_field("throttle"));
1977 }
1978 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Throttle)
1979;
1980 }
1981 GeneratedField::DropSubscriptions => {
1982 if mutation__.is_some() {
1983 return Err(serde::de::Error::duplicate_field("dropSubscriptions"));
1984 }
1985 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::DropSubscriptions)
1986;
1987 }
1988 GeneratedField::ConnectorPropsChange => {
1989 if mutation__.is_some() {
1990 return Err(serde::de::Error::duplicate_field("connectorPropsChange"));
1991 }
1992 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ConnectorPropsChange)
1993;
1994 }
1995 GeneratedField::StartFragmentBackfill => {
1996 if mutation__.is_some() {
1997 return Err(serde::de::Error::duplicate_field("startFragmentBackfill"));
1998 }
1999 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::StartFragmentBackfill)
2000;
2001 }
2002 GeneratedField::RefreshStart => {
2003 if mutation__.is_some() {
2004 return Err(serde::de::Error::duplicate_field("refreshStart"));
2005 }
2006 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::RefreshStart)
2007;
2008 }
2009 GeneratedField::LoadFinish => {
2010 if mutation__.is_some() {
2011 return Err(serde::de::Error::duplicate_field("loadFinish"));
2012 }
2013 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::LoadFinish)
2014;
2015 }
2016 GeneratedField::ListFinish => {
2017 if mutation__.is_some() {
2018 return Err(serde::de::Error::duplicate_field("listFinish"));
2019 }
2020 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ListFinish)
2021;
2022 }
2023 }
2024 }
2025 Ok(BarrierMutation {
2026 mutation: mutation__,
2027 })
2028 }
2029 }
2030 deserializer.deserialize_struct("stream_plan.BarrierMutation", FIELDS, GeneratedVisitor)
2031 }
2032}
2033impl serde::Serialize for BarrierRecvNode {
2034 #[allow(deprecated)]
2035 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2036 where
2037 S: serde::Serializer,
2038 {
2039 use serde::ser::SerializeStruct;
2040 let len = 0;
2041 let struct_ser = serializer.serialize_struct("stream_plan.BarrierRecvNode", len)?;
2042 struct_ser.end()
2043 }
2044}
2045impl<'de> serde::Deserialize<'de> for BarrierRecvNode {
2046 #[allow(deprecated)]
2047 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2048 where
2049 D: serde::Deserializer<'de>,
2050 {
2051 const FIELDS: &[&str] = &[
2052 ];
2053
2054 #[allow(clippy::enum_variant_names)]
2055 enum GeneratedField {
2056 }
2057 impl<'de> serde::Deserialize<'de> for GeneratedField {
2058 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2059 where
2060 D: serde::Deserializer<'de>,
2061 {
2062 struct GeneratedVisitor;
2063
2064 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2065 type Value = GeneratedField;
2066
2067 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2068 write!(formatter, "expected one of: {:?}", &FIELDS)
2069 }
2070
2071 #[allow(unused_variables)]
2072 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2073 where
2074 E: serde::de::Error,
2075 {
2076 Err(serde::de::Error::unknown_field(value, FIELDS))
2077 }
2078 }
2079 deserializer.deserialize_identifier(GeneratedVisitor)
2080 }
2081 }
2082 struct GeneratedVisitor;
2083 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2084 type Value = BarrierRecvNode;
2085
2086 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2087 formatter.write_str("struct stream_plan.BarrierRecvNode")
2088 }
2089
2090 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierRecvNode, V::Error>
2091 where
2092 V: serde::de::MapAccess<'de>,
2093 {
2094 while map_.next_key::<GeneratedField>()?.is_some() {
2095 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2096 }
2097 Ok(BarrierRecvNode {
2098 })
2099 }
2100 }
2101 deserializer.deserialize_struct("stream_plan.BarrierRecvNode", FIELDS, GeneratedVisitor)
2102 }
2103}
2104impl serde::Serialize for BatchPlanNode {
2105 #[allow(deprecated)]
2106 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2107 where
2108 S: serde::Serializer,
2109 {
2110 use serde::ser::SerializeStruct;
2111 let mut len = 0;
2112 if self.table_desc.is_some() {
2113 len += 1;
2114 }
2115 if !self.column_ids.is_empty() {
2116 len += 1;
2117 }
2118 let mut struct_ser = serializer.serialize_struct("stream_plan.BatchPlanNode", len)?;
2119 if let Some(v) = self.table_desc.as_ref() {
2120 struct_ser.serialize_field("tableDesc", v)?;
2121 }
2122 if !self.column_ids.is_empty() {
2123 struct_ser.serialize_field("columnIds", &self.column_ids)?;
2124 }
2125 struct_ser.end()
2126 }
2127}
2128impl<'de> serde::Deserialize<'de> for BatchPlanNode {
2129 #[allow(deprecated)]
2130 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2131 where
2132 D: serde::Deserializer<'de>,
2133 {
2134 const FIELDS: &[&str] = &[
2135 "table_desc",
2136 "tableDesc",
2137 "column_ids",
2138 "columnIds",
2139 ];
2140
2141 #[allow(clippy::enum_variant_names)]
2142 enum GeneratedField {
2143 TableDesc,
2144 ColumnIds,
2145 }
2146 impl<'de> serde::Deserialize<'de> for GeneratedField {
2147 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2148 where
2149 D: serde::Deserializer<'de>,
2150 {
2151 struct GeneratedVisitor;
2152
2153 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2154 type Value = GeneratedField;
2155
2156 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2157 write!(formatter, "expected one of: {:?}", &FIELDS)
2158 }
2159
2160 #[allow(unused_variables)]
2161 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2162 where
2163 E: serde::de::Error,
2164 {
2165 match value {
2166 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
2167 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
2168 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2169 }
2170 }
2171 }
2172 deserializer.deserialize_identifier(GeneratedVisitor)
2173 }
2174 }
2175 struct GeneratedVisitor;
2176 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2177 type Value = BatchPlanNode;
2178
2179 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2180 formatter.write_str("struct stream_plan.BatchPlanNode")
2181 }
2182
2183 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BatchPlanNode, V::Error>
2184 where
2185 V: serde::de::MapAccess<'de>,
2186 {
2187 let mut table_desc__ = None;
2188 let mut column_ids__ = None;
2189 while let Some(k) = map_.next_key()? {
2190 match k {
2191 GeneratedField::TableDesc => {
2192 if table_desc__.is_some() {
2193 return Err(serde::de::Error::duplicate_field("tableDesc"));
2194 }
2195 table_desc__ = map_.next_value()?;
2196 }
2197 GeneratedField::ColumnIds => {
2198 if column_ids__.is_some() {
2199 return Err(serde::de::Error::duplicate_field("columnIds"));
2200 }
2201 column_ids__ =
2202 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2203 .into_iter().map(|x| x.0).collect())
2204 ;
2205 }
2206 }
2207 }
2208 Ok(BatchPlanNode {
2209 table_desc: table_desc__,
2210 column_ids: column_ids__.unwrap_or_default(),
2211 })
2212 }
2213 }
2214 deserializer.deserialize_struct("stream_plan.BatchPlanNode", FIELDS, GeneratedVisitor)
2215 }
2216}
2217impl serde::Serialize for CdcFilterNode {
2218 #[allow(deprecated)]
2219 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2220 where
2221 S: serde::Serializer,
2222 {
2223 use serde::ser::SerializeStruct;
2224 let mut len = 0;
2225 if self.search_condition.is_some() {
2226 len += 1;
2227 }
2228 if self.upstream_source_id != 0 {
2229 len += 1;
2230 }
2231 let mut struct_ser = serializer.serialize_struct("stream_plan.CdcFilterNode", len)?;
2232 if let Some(v) = self.search_condition.as_ref() {
2233 struct_ser.serialize_field("searchCondition", v)?;
2234 }
2235 if self.upstream_source_id != 0 {
2236 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
2237 }
2238 struct_ser.end()
2239 }
2240}
2241impl<'de> serde::Deserialize<'de> for CdcFilterNode {
2242 #[allow(deprecated)]
2243 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2244 where
2245 D: serde::Deserializer<'de>,
2246 {
2247 const FIELDS: &[&str] = &[
2248 "search_condition",
2249 "searchCondition",
2250 "upstream_source_id",
2251 "upstreamSourceId",
2252 ];
2253
2254 #[allow(clippy::enum_variant_names)]
2255 enum GeneratedField {
2256 SearchCondition,
2257 UpstreamSourceId,
2258 }
2259 impl<'de> serde::Deserialize<'de> for GeneratedField {
2260 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2261 where
2262 D: serde::Deserializer<'de>,
2263 {
2264 struct GeneratedVisitor;
2265
2266 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2267 type Value = GeneratedField;
2268
2269 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2270 write!(formatter, "expected one of: {:?}", &FIELDS)
2271 }
2272
2273 #[allow(unused_variables)]
2274 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2275 where
2276 E: serde::de::Error,
2277 {
2278 match value {
2279 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
2280 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
2281 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2282 }
2283 }
2284 }
2285 deserializer.deserialize_identifier(GeneratedVisitor)
2286 }
2287 }
2288 struct GeneratedVisitor;
2289 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2290 type Value = CdcFilterNode;
2291
2292 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2293 formatter.write_str("struct stream_plan.CdcFilterNode")
2294 }
2295
2296 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcFilterNode, V::Error>
2297 where
2298 V: serde::de::MapAccess<'de>,
2299 {
2300 let mut search_condition__ = None;
2301 let mut upstream_source_id__ = None;
2302 while let Some(k) = map_.next_key()? {
2303 match k {
2304 GeneratedField::SearchCondition => {
2305 if search_condition__.is_some() {
2306 return Err(serde::de::Error::duplicate_field("searchCondition"));
2307 }
2308 search_condition__ = map_.next_value()?;
2309 }
2310 GeneratedField::UpstreamSourceId => {
2311 if upstream_source_id__.is_some() {
2312 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
2313 }
2314 upstream_source_id__ =
2315 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2316 ;
2317 }
2318 }
2319 }
2320 Ok(CdcFilterNode {
2321 search_condition: search_condition__,
2322 upstream_source_id: upstream_source_id__.unwrap_or_default(),
2323 })
2324 }
2325 }
2326 deserializer.deserialize_struct("stream_plan.CdcFilterNode", FIELDS, GeneratedVisitor)
2327 }
2328}
2329impl serde::Serialize for ChangeLogNode {
2330 #[allow(deprecated)]
2331 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2332 where
2333 S: serde::Serializer,
2334 {
2335 use serde::ser::SerializeStruct;
2336 let mut len = 0;
2337 if self.need_op {
2338 len += 1;
2339 }
2340 if !self.distribution_keys.is_empty() {
2341 len += 1;
2342 }
2343 let mut struct_ser = serializer.serialize_struct("stream_plan.ChangeLogNode", len)?;
2344 if self.need_op {
2345 struct_ser.serialize_field("needOp", &self.need_op)?;
2346 }
2347 if !self.distribution_keys.is_empty() {
2348 struct_ser.serialize_field("distributionKeys", &self.distribution_keys)?;
2349 }
2350 struct_ser.end()
2351 }
2352}
2353impl<'de> serde::Deserialize<'de> for ChangeLogNode {
2354 #[allow(deprecated)]
2355 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2356 where
2357 D: serde::Deserializer<'de>,
2358 {
2359 const FIELDS: &[&str] = &[
2360 "need_op",
2361 "needOp",
2362 "distribution_keys",
2363 "distributionKeys",
2364 ];
2365
2366 #[allow(clippy::enum_variant_names)]
2367 enum GeneratedField {
2368 NeedOp,
2369 DistributionKeys,
2370 }
2371 impl<'de> serde::Deserialize<'de> for GeneratedField {
2372 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2373 where
2374 D: serde::Deserializer<'de>,
2375 {
2376 struct GeneratedVisitor;
2377
2378 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2379 type Value = GeneratedField;
2380
2381 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2382 write!(formatter, "expected one of: {:?}", &FIELDS)
2383 }
2384
2385 #[allow(unused_variables)]
2386 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2387 where
2388 E: serde::de::Error,
2389 {
2390 match value {
2391 "needOp" | "need_op" => Ok(GeneratedField::NeedOp),
2392 "distributionKeys" | "distribution_keys" => Ok(GeneratedField::DistributionKeys),
2393 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2394 }
2395 }
2396 }
2397 deserializer.deserialize_identifier(GeneratedVisitor)
2398 }
2399 }
2400 struct GeneratedVisitor;
2401 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2402 type Value = ChangeLogNode;
2403
2404 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2405 formatter.write_str("struct stream_plan.ChangeLogNode")
2406 }
2407
2408 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ChangeLogNode, V::Error>
2409 where
2410 V: serde::de::MapAccess<'de>,
2411 {
2412 let mut need_op__ = None;
2413 let mut distribution_keys__ = None;
2414 while let Some(k) = map_.next_key()? {
2415 match k {
2416 GeneratedField::NeedOp => {
2417 if need_op__.is_some() {
2418 return Err(serde::de::Error::duplicate_field("needOp"));
2419 }
2420 need_op__ = Some(map_.next_value()?);
2421 }
2422 GeneratedField::DistributionKeys => {
2423 if distribution_keys__.is_some() {
2424 return Err(serde::de::Error::duplicate_field("distributionKeys"));
2425 }
2426 distribution_keys__ =
2427 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2428 .into_iter().map(|x| x.0).collect())
2429 ;
2430 }
2431 }
2432 }
2433 Ok(ChangeLogNode {
2434 need_op: need_op__.unwrap_or_default(),
2435 distribution_keys: distribution_keys__.unwrap_or_default(),
2436 })
2437 }
2438 }
2439 deserializer.deserialize_struct("stream_plan.ChangeLogNode", FIELDS, GeneratedVisitor)
2440 }
2441}
2442impl serde::Serialize for Columns {
2443 #[allow(deprecated)]
2444 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2445 where
2446 S: serde::Serializer,
2447 {
2448 use serde::ser::SerializeStruct;
2449 let mut len = 0;
2450 if !self.columns.is_empty() {
2451 len += 1;
2452 }
2453 let mut struct_ser = serializer.serialize_struct("stream_plan.Columns", len)?;
2454 if !self.columns.is_empty() {
2455 struct_ser.serialize_field("columns", &self.columns)?;
2456 }
2457 struct_ser.end()
2458 }
2459}
2460impl<'de> serde::Deserialize<'de> for Columns {
2461 #[allow(deprecated)]
2462 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2463 where
2464 D: serde::Deserializer<'de>,
2465 {
2466 const FIELDS: &[&str] = &[
2467 "columns",
2468 ];
2469
2470 #[allow(clippy::enum_variant_names)]
2471 enum GeneratedField {
2472 Columns,
2473 }
2474 impl<'de> serde::Deserialize<'de> for GeneratedField {
2475 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2476 where
2477 D: serde::Deserializer<'de>,
2478 {
2479 struct GeneratedVisitor;
2480
2481 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2482 type Value = GeneratedField;
2483
2484 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2485 write!(formatter, "expected one of: {:?}", &FIELDS)
2486 }
2487
2488 #[allow(unused_variables)]
2489 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2490 where
2491 E: serde::de::Error,
2492 {
2493 match value {
2494 "columns" => Ok(GeneratedField::Columns),
2495 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2496 }
2497 }
2498 }
2499 deserializer.deserialize_identifier(GeneratedVisitor)
2500 }
2501 }
2502 struct GeneratedVisitor;
2503 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2504 type Value = Columns;
2505
2506 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2507 formatter.write_str("struct stream_plan.Columns")
2508 }
2509
2510 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Columns, V::Error>
2511 where
2512 V: serde::de::MapAccess<'de>,
2513 {
2514 let mut columns__ = None;
2515 while let Some(k) = map_.next_key()? {
2516 match k {
2517 GeneratedField::Columns => {
2518 if columns__.is_some() {
2519 return Err(serde::de::Error::duplicate_field("columns"));
2520 }
2521 columns__ = Some(map_.next_value()?);
2522 }
2523 }
2524 }
2525 Ok(Columns {
2526 columns: columns__.unwrap_or_default(),
2527 })
2528 }
2529 }
2530 deserializer.deserialize_struct("stream_plan.Columns", FIELDS, GeneratedVisitor)
2531 }
2532}
2533impl serde::Serialize for ConnectorPropsChangeMutation {
2534 #[allow(deprecated)]
2535 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2536 where
2537 S: serde::Serializer,
2538 {
2539 use serde::ser::SerializeStruct;
2540 let mut len = 0;
2541 if !self.connector_props_infos.is_empty() {
2542 len += 1;
2543 }
2544 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation", len)?;
2545 if !self.connector_props_infos.is_empty() {
2546 struct_ser.serialize_field("connectorPropsInfos", &self.connector_props_infos)?;
2547 }
2548 struct_ser.end()
2549 }
2550}
2551impl<'de> serde::Deserialize<'de> for ConnectorPropsChangeMutation {
2552 #[allow(deprecated)]
2553 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2554 where
2555 D: serde::Deserializer<'de>,
2556 {
2557 const FIELDS: &[&str] = &[
2558 "connector_props_infos",
2559 "connectorPropsInfos",
2560 ];
2561
2562 #[allow(clippy::enum_variant_names)]
2563 enum GeneratedField {
2564 ConnectorPropsInfos,
2565 }
2566 impl<'de> serde::Deserialize<'de> for GeneratedField {
2567 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2568 where
2569 D: serde::Deserializer<'de>,
2570 {
2571 struct GeneratedVisitor;
2572
2573 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2574 type Value = GeneratedField;
2575
2576 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2577 write!(formatter, "expected one of: {:?}", &FIELDS)
2578 }
2579
2580 #[allow(unused_variables)]
2581 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2582 where
2583 E: serde::de::Error,
2584 {
2585 match value {
2586 "connectorPropsInfos" | "connector_props_infos" => Ok(GeneratedField::ConnectorPropsInfos),
2587 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2588 }
2589 }
2590 }
2591 deserializer.deserialize_identifier(GeneratedVisitor)
2592 }
2593 }
2594 struct GeneratedVisitor;
2595 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2596 type Value = ConnectorPropsChangeMutation;
2597
2598 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2599 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation")
2600 }
2601
2602 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectorPropsChangeMutation, V::Error>
2603 where
2604 V: serde::de::MapAccess<'de>,
2605 {
2606 let mut connector_props_infos__ = None;
2607 while let Some(k) = map_.next_key()? {
2608 match k {
2609 GeneratedField::ConnectorPropsInfos => {
2610 if connector_props_infos__.is_some() {
2611 return Err(serde::de::Error::duplicate_field("connectorPropsInfos"));
2612 }
2613 connector_props_infos__ = Some(
2614 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
2615 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
2616 );
2617 }
2618 }
2619 }
2620 Ok(ConnectorPropsChangeMutation {
2621 connector_props_infos: connector_props_infos__.unwrap_or_default(),
2622 })
2623 }
2624 }
2625 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation", FIELDS, GeneratedVisitor)
2626 }
2627}
2628impl serde::Serialize for connector_props_change_mutation::ConnectorPropsInfo {
2629 #[allow(deprecated)]
2630 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2631 where
2632 S: serde::Serializer,
2633 {
2634 use serde::ser::SerializeStruct;
2635 let mut len = 0;
2636 if !self.connector_props_info.is_empty() {
2637 len += 1;
2638 }
2639 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", len)?;
2640 if !self.connector_props_info.is_empty() {
2641 struct_ser.serialize_field("connectorPropsInfo", &self.connector_props_info)?;
2642 }
2643 struct_ser.end()
2644 }
2645}
2646impl<'de> serde::Deserialize<'de> for connector_props_change_mutation::ConnectorPropsInfo {
2647 #[allow(deprecated)]
2648 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2649 where
2650 D: serde::Deserializer<'de>,
2651 {
2652 const FIELDS: &[&str] = &[
2653 "connector_props_info",
2654 "connectorPropsInfo",
2655 ];
2656
2657 #[allow(clippy::enum_variant_names)]
2658 enum GeneratedField {
2659 ConnectorPropsInfo,
2660 }
2661 impl<'de> serde::Deserialize<'de> for GeneratedField {
2662 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2663 where
2664 D: serde::Deserializer<'de>,
2665 {
2666 struct GeneratedVisitor;
2667
2668 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2669 type Value = GeneratedField;
2670
2671 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2672 write!(formatter, "expected one of: {:?}", &FIELDS)
2673 }
2674
2675 #[allow(unused_variables)]
2676 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2677 where
2678 E: serde::de::Error,
2679 {
2680 match value {
2681 "connectorPropsInfo" | "connector_props_info" => Ok(GeneratedField::ConnectorPropsInfo),
2682 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2683 }
2684 }
2685 }
2686 deserializer.deserialize_identifier(GeneratedVisitor)
2687 }
2688 }
2689 struct GeneratedVisitor;
2690 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2691 type Value = connector_props_change_mutation::ConnectorPropsInfo;
2692
2693 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2694 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo")
2695 }
2696
2697 fn visit_map<V>(self, mut map_: V) -> std::result::Result<connector_props_change_mutation::ConnectorPropsInfo, V::Error>
2698 where
2699 V: serde::de::MapAccess<'de>,
2700 {
2701 let mut connector_props_info__ = None;
2702 while let Some(k) = map_.next_key()? {
2703 match k {
2704 GeneratedField::ConnectorPropsInfo => {
2705 if connector_props_info__.is_some() {
2706 return Err(serde::de::Error::duplicate_field("connectorPropsInfo"));
2707 }
2708 connector_props_info__ = Some(
2709 map_.next_value::<std::collections::HashMap<_, _>>()?
2710 );
2711 }
2712 }
2713 }
2714 Ok(connector_props_change_mutation::ConnectorPropsInfo {
2715 connector_props_info: connector_props_info__.unwrap_or_default(),
2716 })
2717 }
2718 }
2719 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", FIELDS, GeneratedVisitor)
2720 }
2721}
2722impl serde::Serialize for DedupNode {
2723 #[allow(deprecated)]
2724 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2725 where
2726 S: serde::Serializer,
2727 {
2728 use serde::ser::SerializeStruct;
2729 let mut len = 0;
2730 if self.state_table.is_some() {
2731 len += 1;
2732 }
2733 if !self.dedup_column_indices.is_empty() {
2734 len += 1;
2735 }
2736 let mut struct_ser = serializer.serialize_struct("stream_plan.DedupNode", len)?;
2737 if let Some(v) = self.state_table.as_ref() {
2738 struct_ser.serialize_field("stateTable", v)?;
2739 }
2740 if !self.dedup_column_indices.is_empty() {
2741 struct_ser.serialize_field("dedupColumnIndices", &self.dedup_column_indices)?;
2742 }
2743 struct_ser.end()
2744 }
2745}
2746impl<'de> serde::Deserialize<'de> for DedupNode {
2747 #[allow(deprecated)]
2748 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2749 where
2750 D: serde::Deserializer<'de>,
2751 {
2752 const FIELDS: &[&str] = &[
2753 "state_table",
2754 "stateTable",
2755 "dedup_column_indices",
2756 "dedupColumnIndices",
2757 ];
2758
2759 #[allow(clippy::enum_variant_names)]
2760 enum GeneratedField {
2761 StateTable,
2762 DedupColumnIndices,
2763 }
2764 impl<'de> serde::Deserialize<'de> for GeneratedField {
2765 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2766 where
2767 D: serde::Deserializer<'de>,
2768 {
2769 struct GeneratedVisitor;
2770
2771 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2772 type Value = GeneratedField;
2773
2774 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2775 write!(formatter, "expected one of: {:?}", &FIELDS)
2776 }
2777
2778 #[allow(unused_variables)]
2779 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2780 where
2781 E: serde::de::Error,
2782 {
2783 match value {
2784 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
2785 "dedupColumnIndices" | "dedup_column_indices" => Ok(GeneratedField::DedupColumnIndices),
2786 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2787 }
2788 }
2789 }
2790 deserializer.deserialize_identifier(GeneratedVisitor)
2791 }
2792 }
2793 struct GeneratedVisitor;
2794 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2795 type Value = DedupNode;
2796
2797 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2798 formatter.write_str("struct stream_plan.DedupNode")
2799 }
2800
2801 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DedupNode, V::Error>
2802 where
2803 V: serde::de::MapAccess<'de>,
2804 {
2805 let mut state_table__ = None;
2806 let mut dedup_column_indices__ = None;
2807 while let Some(k) = map_.next_key()? {
2808 match k {
2809 GeneratedField::StateTable => {
2810 if state_table__.is_some() {
2811 return Err(serde::de::Error::duplicate_field("stateTable"));
2812 }
2813 state_table__ = map_.next_value()?;
2814 }
2815 GeneratedField::DedupColumnIndices => {
2816 if dedup_column_indices__.is_some() {
2817 return Err(serde::de::Error::duplicate_field("dedupColumnIndices"));
2818 }
2819 dedup_column_indices__ =
2820 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2821 .into_iter().map(|x| x.0).collect())
2822 ;
2823 }
2824 }
2825 }
2826 Ok(DedupNode {
2827 state_table: state_table__,
2828 dedup_column_indices: dedup_column_indices__.unwrap_or_default(),
2829 })
2830 }
2831 }
2832 deserializer.deserialize_struct("stream_plan.DedupNode", FIELDS, GeneratedVisitor)
2833 }
2834}
2835impl serde::Serialize for DeltaExpression {
2836 #[allow(deprecated)]
2837 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2838 where
2839 S: serde::Serializer,
2840 {
2841 use serde::ser::SerializeStruct;
2842 let mut len = 0;
2843 if self.delta_type != 0 {
2844 len += 1;
2845 }
2846 if self.delta.is_some() {
2847 len += 1;
2848 }
2849 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaExpression", len)?;
2850 if self.delta_type != 0 {
2851 let v = super::expr::expr_node::Type::try_from(self.delta_type)
2852 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.delta_type)))?;
2853 struct_ser.serialize_field("deltaType", &v)?;
2854 }
2855 if let Some(v) = self.delta.as_ref() {
2856 struct_ser.serialize_field("delta", v)?;
2857 }
2858 struct_ser.end()
2859 }
2860}
2861impl<'de> serde::Deserialize<'de> for DeltaExpression {
2862 #[allow(deprecated)]
2863 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2864 where
2865 D: serde::Deserializer<'de>,
2866 {
2867 const FIELDS: &[&str] = &[
2868 "delta_type",
2869 "deltaType",
2870 "delta",
2871 ];
2872
2873 #[allow(clippy::enum_variant_names)]
2874 enum GeneratedField {
2875 DeltaType,
2876 Delta,
2877 }
2878 impl<'de> serde::Deserialize<'de> for GeneratedField {
2879 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2880 where
2881 D: serde::Deserializer<'de>,
2882 {
2883 struct GeneratedVisitor;
2884
2885 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2886 type Value = GeneratedField;
2887
2888 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2889 write!(formatter, "expected one of: {:?}", &FIELDS)
2890 }
2891
2892 #[allow(unused_variables)]
2893 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2894 where
2895 E: serde::de::Error,
2896 {
2897 match value {
2898 "deltaType" | "delta_type" => Ok(GeneratedField::DeltaType),
2899 "delta" => Ok(GeneratedField::Delta),
2900 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2901 }
2902 }
2903 }
2904 deserializer.deserialize_identifier(GeneratedVisitor)
2905 }
2906 }
2907 struct GeneratedVisitor;
2908 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2909 type Value = DeltaExpression;
2910
2911 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2912 formatter.write_str("struct stream_plan.DeltaExpression")
2913 }
2914
2915 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaExpression, V::Error>
2916 where
2917 V: serde::de::MapAccess<'de>,
2918 {
2919 let mut delta_type__ = None;
2920 let mut delta__ = None;
2921 while let Some(k) = map_.next_key()? {
2922 match k {
2923 GeneratedField::DeltaType => {
2924 if delta_type__.is_some() {
2925 return Err(serde::de::Error::duplicate_field("deltaType"));
2926 }
2927 delta_type__ = Some(map_.next_value::<super::expr::expr_node::Type>()? as i32);
2928 }
2929 GeneratedField::Delta => {
2930 if delta__.is_some() {
2931 return Err(serde::de::Error::duplicate_field("delta"));
2932 }
2933 delta__ = map_.next_value()?;
2934 }
2935 }
2936 }
2937 Ok(DeltaExpression {
2938 delta_type: delta_type__.unwrap_or_default(),
2939 delta: delta__,
2940 })
2941 }
2942 }
2943 deserializer.deserialize_struct("stream_plan.DeltaExpression", FIELDS, GeneratedVisitor)
2944 }
2945}
2946impl serde::Serialize for DeltaIndexJoinNode {
2947 #[allow(deprecated)]
2948 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2949 where
2950 S: serde::Serializer,
2951 {
2952 use serde::ser::SerializeStruct;
2953 let mut len = 0;
2954 if self.join_type != 0 {
2955 len += 1;
2956 }
2957 if !self.left_key.is_empty() {
2958 len += 1;
2959 }
2960 if !self.right_key.is_empty() {
2961 len += 1;
2962 }
2963 if self.condition.is_some() {
2964 len += 1;
2965 }
2966 if self.left_table_id != 0 {
2967 len += 1;
2968 }
2969 if self.right_table_id != 0 {
2970 len += 1;
2971 }
2972 if self.left_info.is_some() {
2973 len += 1;
2974 }
2975 if self.right_info.is_some() {
2976 len += 1;
2977 }
2978 if !self.output_indices.is_empty() {
2979 len += 1;
2980 }
2981 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaIndexJoinNode", len)?;
2982 if self.join_type != 0 {
2983 let v = super::plan_common::JoinType::try_from(self.join_type)
2984 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
2985 struct_ser.serialize_field("joinType", &v)?;
2986 }
2987 if !self.left_key.is_empty() {
2988 struct_ser.serialize_field("leftKey", &self.left_key)?;
2989 }
2990 if !self.right_key.is_empty() {
2991 struct_ser.serialize_field("rightKey", &self.right_key)?;
2992 }
2993 if let Some(v) = self.condition.as_ref() {
2994 struct_ser.serialize_field("condition", v)?;
2995 }
2996 if self.left_table_id != 0 {
2997 struct_ser.serialize_field("leftTableId", &self.left_table_id)?;
2998 }
2999 if self.right_table_id != 0 {
3000 struct_ser.serialize_field("rightTableId", &self.right_table_id)?;
3001 }
3002 if let Some(v) = self.left_info.as_ref() {
3003 struct_ser.serialize_field("leftInfo", v)?;
3004 }
3005 if let Some(v) = self.right_info.as_ref() {
3006 struct_ser.serialize_field("rightInfo", v)?;
3007 }
3008 if !self.output_indices.is_empty() {
3009 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
3010 }
3011 struct_ser.end()
3012 }
3013}
3014impl<'de> serde::Deserialize<'de> for DeltaIndexJoinNode {
3015 #[allow(deprecated)]
3016 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3017 where
3018 D: serde::Deserializer<'de>,
3019 {
3020 const FIELDS: &[&str] = &[
3021 "join_type",
3022 "joinType",
3023 "left_key",
3024 "leftKey",
3025 "right_key",
3026 "rightKey",
3027 "condition",
3028 "left_table_id",
3029 "leftTableId",
3030 "right_table_id",
3031 "rightTableId",
3032 "left_info",
3033 "leftInfo",
3034 "right_info",
3035 "rightInfo",
3036 "output_indices",
3037 "outputIndices",
3038 ];
3039
3040 #[allow(clippy::enum_variant_names)]
3041 enum GeneratedField {
3042 JoinType,
3043 LeftKey,
3044 RightKey,
3045 Condition,
3046 LeftTableId,
3047 RightTableId,
3048 LeftInfo,
3049 RightInfo,
3050 OutputIndices,
3051 }
3052 impl<'de> serde::Deserialize<'de> for GeneratedField {
3053 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3054 where
3055 D: serde::Deserializer<'de>,
3056 {
3057 struct GeneratedVisitor;
3058
3059 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3060 type Value = GeneratedField;
3061
3062 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3063 write!(formatter, "expected one of: {:?}", &FIELDS)
3064 }
3065
3066 #[allow(unused_variables)]
3067 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3068 where
3069 E: serde::de::Error,
3070 {
3071 match value {
3072 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
3073 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
3074 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
3075 "condition" => Ok(GeneratedField::Condition),
3076 "leftTableId" | "left_table_id" => Ok(GeneratedField::LeftTableId),
3077 "rightTableId" | "right_table_id" => Ok(GeneratedField::RightTableId),
3078 "leftInfo" | "left_info" => Ok(GeneratedField::LeftInfo),
3079 "rightInfo" | "right_info" => Ok(GeneratedField::RightInfo),
3080 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
3081 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3082 }
3083 }
3084 }
3085 deserializer.deserialize_identifier(GeneratedVisitor)
3086 }
3087 }
3088 struct GeneratedVisitor;
3089 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3090 type Value = DeltaIndexJoinNode;
3091
3092 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3093 formatter.write_str("struct stream_plan.DeltaIndexJoinNode")
3094 }
3095
3096 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaIndexJoinNode, V::Error>
3097 where
3098 V: serde::de::MapAccess<'de>,
3099 {
3100 let mut join_type__ = None;
3101 let mut left_key__ = None;
3102 let mut right_key__ = None;
3103 let mut condition__ = None;
3104 let mut left_table_id__ = None;
3105 let mut right_table_id__ = None;
3106 let mut left_info__ = None;
3107 let mut right_info__ = None;
3108 let mut output_indices__ = None;
3109 while let Some(k) = map_.next_key()? {
3110 match k {
3111 GeneratedField::JoinType => {
3112 if join_type__.is_some() {
3113 return Err(serde::de::Error::duplicate_field("joinType"));
3114 }
3115 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
3116 }
3117 GeneratedField::LeftKey => {
3118 if left_key__.is_some() {
3119 return Err(serde::de::Error::duplicate_field("leftKey"));
3120 }
3121 left_key__ =
3122 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3123 .into_iter().map(|x| x.0).collect())
3124 ;
3125 }
3126 GeneratedField::RightKey => {
3127 if right_key__.is_some() {
3128 return Err(serde::de::Error::duplicate_field("rightKey"));
3129 }
3130 right_key__ =
3131 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3132 .into_iter().map(|x| x.0).collect())
3133 ;
3134 }
3135 GeneratedField::Condition => {
3136 if condition__.is_some() {
3137 return Err(serde::de::Error::duplicate_field("condition"));
3138 }
3139 condition__ = map_.next_value()?;
3140 }
3141 GeneratedField::LeftTableId => {
3142 if left_table_id__.is_some() {
3143 return Err(serde::de::Error::duplicate_field("leftTableId"));
3144 }
3145 left_table_id__ =
3146 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3147 ;
3148 }
3149 GeneratedField::RightTableId => {
3150 if right_table_id__.is_some() {
3151 return Err(serde::de::Error::duplicate_field("rightTableId"));
3152 }
3153 right_table_id__ =
3154 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3155 ;
3156 }
3157 GeneratedField::LeftInfo => {
3158 if left_info__.is_some() {
3159 return Err(serde::de::Error::duplicate_field("leftInfo"));
3160 }
3161 left_info__ = map_.next_value()?;
3162 }
3163 GeneratedField::RightInfo => {
3164 if right_info__.is_some() {
3165 return Err(serde::de::Error::duplicate_field("rightInfo"));
3166 }
3167 right_info__ = map_.next_value()?;
3168 }
3169 GeneratedField::OutputIndices => {
3170 if output_indices__.is_some() {
3171 return Err(serde::de::Error::duplicate_field("outputIndices"));
3172 }
3173 output_indices__ =
3174 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3175 .into_iter().map(|x| x.0).collect())
3176 ;
3177 }
3178 }
3179 }
3180 Ok(DeltaIndexJoinNode {
3181 join_type: join_type__.unwrap_or_default(),
3182 left_key: left_key__.unwrap_or_default(),
3183 right_key: right_key__.unwrap_or_default(),
3184 condition: condition__,
3185 left_table_id: left_table_id__.unwrap_or_default(),
3186 right_table_id: right_table_id__.unwrap_or_default(),
3187 left_info: left_info__,
3188 right_info: right_info__,
3189 output_indices: output_indices__.unwrap_or_default(),
3190 })
3191 }
3192 }
3193 deserializer.deserialize_struct("stream_plan.DeltaIndexJoinNode", FIELDS, GeneratedVisitor)
3194 }
3195}
3196impl serde::Serialize for DispatchOutputMapping {
3197 #[allow(deprecated)]
3198 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3199 where
3200 S: serde::Serializer,
3201 {
3202 use serde::ser::SerializeStruct;
3203 let mut len = 0;
3204 if !self.indices.is_empty() {
3205 len += 1;
3206 }
3207 if !self.types.is_empty() {
3208 len += 1;
3209 }
3210 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping", len)?;
3211 if !self.indices.is_empty() {
3212 struct_ser.serialize_field("indices", &self.indices)?;
3213 }
3214 if !self.types.is_empty() {
3215 struct_ser.serialize_field("types", &self.types)?;
3216 }
3217 struct_ser.end()
3218 }
3219}
3220impl<'de> serde::Deserialize<'de> for DispatchOutputMapping {
3221 #[allow(deprecated)]
3222 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3223 where
3224 D: serde::Deserializer<'de>,
3225 {
3226 const FIELDS: &[&str] = &[
3227 "indices",
3228 "types",
3229 ];
3230
3231 #[allow(clippy::enum_variant_names)]
3232 enum GeneratedField {
3233 Indices,
3234 Types,
3235 }
3236 impl<'de> serde::Deserialize<'de> for GeneratedField {
3237 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3238 where
3239 D: serde::Deserializer<'de>,
3240 {
3241 struct GeneratedVisitor;
3242
3243 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3244 type Value = GeneratedField;
3245
3246 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3247 write!(formatter, "expected one of: {:?}", &FIELDS)
3248 }
3249
3250 #[allow(unused_variables)]
3251 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3252 where
3253 E: serde::de::Error,
3254 {
3255 match value {
3256 "indices" => Ok(GeneratedField::Indices),
3257 "types" => Ok(GeneratedField::Types),
3258 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3259 }
3260 }
3261 }
3262 deserializer.deserialize_identifier(GeneratedVisitor)
3263 }
3264 }
3265 struct GeneratedVisitor;
3266 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3267 type Value = DispatchOutputMapping;
3268
3269 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3270 formatter.write_str("struct stream_plan.DispatchOutputMapping")
3271 }
3272
3273 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchOutputMapping, V::Error>
3274 where
3275 V: serde::de::MapAccess<'de>,
3276 {
3277 let mut indices__ = None;
3278 let mut types__ = None;
3279 while let Some(k) = map_.next_key()? {
3280 match k {
3281 GeneratedField::Indices => {
3282 if indices__.is_some() {
3283 return Err(serde::de::Error::duplicate_field("indices"));
3284 }
3285 indices__ =
3286 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3287 .into_iter().map(|x| x.0).collect())
3288 ;
3289 }
3290 GeneratedField::Types => {
3291 if types__.is_some() {
3292 return Err(serde::de::Error::duplicate_field("types"));
3293 }
3294 types__ = Some(map_.next_value()?);
3295 }
3296 }
3297 }
3298 Ok(DispatchOutputMapping {
3299 indices: indices__.unwrap_or_default(),
3300 types: types__.unwrap_or_default(),
3301 })
3302 }
3303 }
3304 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping", FIELDS, GeneratedVisitor)
3305 }
3306}
3307impl serde::Serialize for dispatch_output_mapping::TypePair {
3308 #[allow(deprecated)]
3309 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3310 where
3311 S: serde::Serializer,
3312 {
3313 use serde::ser::SerializeStruct;
3314 let mut len = 0;
3315 if self.upstream.is_some() {
3316 len += 1;
3317 }
3318 if self.downstream.is_some() {
3319 len += 1;
3320 }
3321 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping.TypePair", len)?;
3322 if let Some(v) = self.upstream.as_ref() {
3323 struct_ser.serialize_field("upstream", v)?;
3324 }
3325 if let Some(v) = self.downstream.as_ref() {
3326 struct_ser.serialize_field("downstream", v)?;
3327 }
3328 struct_ser.end()
3329 }
3330}
3331impl<'de> serde::Deserialize<'de> for dispatch_output_mapping::TypePair {
3332 #[allow(deprecated)]
3333 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3334 where
3335 D: serde::Deserializer<'de>,
3336 {
3337 const FIELDS: &[&str] = &[
3338 "upstream",
3339 "downstream",
3340 ];
3341
3342 #[allow(clippy::enum_variant_names)]
3343 enum GeneratedField {
3344 Upstream,
3345 Downstream,
3346 }
3347 impl<'de> serde::Deserialize<'de> for GeneratedField {
3348 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3349 where
3350 D: serde::Deserializer<'de>,
3351 {
3352 struct GeneratedVisitor;
3353
3354 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3355 type Value = GeneratedField;
3356
3357 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3358 write!(formatter, "expected one of: {:?}", &FIELDS)
3359 }
3360
3361 #[allow(unused_variables)]
3362 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3363 where
3364 E: serde::de::Error,
3365 {
3366 match value {
3367 "upstream" => Ok(GeneratedField::Upstream),
3368 "downstream" => Ok(GeneratedField::Downstream),
3369 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3370 }
3371 }
3372 }
3373 deserializer.deserialize_identifier(GeneratedVisitor)
3374 }
3375 }
3376 struct GeneratedVisitor;
3377 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3378 type Value = dispatch_output_mapping::TypePair;
3379
3380 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3381 formatter.write_str("struct stream_plan.DispatchOutputMapping.TypePair")
3382 }
3383
3384 fn visit_map<V>(self, mut map_: V) -> std::result::Result<dispatch_output_mapping::TypePair, V::Error>
3385 where
3386 V: serde::de::MapAccess<'de>,
3387 {
3388 let mut upstream__ = None;
3389 let mut downstream__ = None;
3390 while let Some(k) = map_.next_key()? {
3391 match k {
3392 GeneratedField::Upstream => {
3393 if upstream__.is_some() {
3394 return Err(serde::de::Error::duplicate_field("upstream"));
3395 }
3396 upstream__ = map_.next_value()?;
3397 }
3398 GeneratedField::Downstream => {
3399 if downstream__.is_some() {
3400 return Err(serde::de::Error::duplicate_field("downstream"));
3401 }
3402 downstream__ = map_.next_value()?;
3403 }
3404 }
3405 }
3406 Ok(dispatch_output_mapping::TypePair {
3407 upstream: upstream__,
3408 downstream: downstream__,
3409 })
3410 }
3411 }
3412 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping.TypePair", FIELDS, GeneratedVisitor)
3413 }
3414}
3415impl serde::Serialize for DispatchStrategy {
3416 #[allow(deprecated)]
3417 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3418 where
3419 S: serde::Serializer,
3420 {
3421 use serde::ser::SerializeStruct;
3422 let mut len = 0;
3423 if self.r#type != 0 {
3424 len += 1;
3425 }
3426 if !self.dist_key_indices.is_empty() {
3427 len += 1;
3428 }
3429 if self.output_mapping.is_some() {
3430 len += 1;
3431 }
3432 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchStrategy", len)?;
3433 if self.r#type != 0 {
3434 let v = DispatcherType::try_from(self.r#type)
3435 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3436 struct_ser.serialize_field("type", &v)?;
3437 }
3438 if !self.dist_key_indices.is_empty() {
3439 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3440 }
3441 if let Some(v) = self.output_mapping.as_ref() {
3442 struct_ser.serialize_field("outputMapping", v)?;
3443 }
3444 struct_ser.end()
3445 }
3446}
3447impl<'de> serde::Deserialize<'de> for DispatchStrategy {
3448 #[allow(deprecated)]
3449 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3450 where
3451 D: serde::Deserializer<'de>,
3452 {
3453 const FIELDS: &[&str] = &[
3454 "type",
3455 "dist_key_indices",
3456 "distKeyIndices",
3457 "output_mapping",
3458 "outputMapping",
3459 ];
3460
3461 #[allow(clippy::enum_variant_names)]
3462 enum GeneratedField {
3463 Type,
3464 DistKeyIndices,
3465 OutputMapping,
3466 }
3467 impl<'de> serde::Deserialize<'de> for GeneratedField {
3468 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3469 where
3470 D: serde::Deserializer<'de>,
3471 {
3472 struct GeneratedVisitor;
3473
3474 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3475 type Value = GeneratedField;
3476
3477 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3478 write!(formatter, "expected one of: {:?}", &FIELDS)
3479 }
3480
3481 #[allow(unused_variables)]
3482 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3483 where
3484 E: serde::de::Error,
3485 {
3486 match value {
3487 "type" => Ok(GeneratedField::Type),
3488 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3489 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3490 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3491 }
3492 }
3493 }
3494 deserializer.deserialize_identifier(GeneratedVisitor)
3495 }
3496 }
3497 struct GeneratedVisitor;
3498 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3499 type Value = DispatchStrategy;
3500
3501 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3502 formatter.write_str("struct stream_plan.DispatchStrategy")
3503 }
3504
3505 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchStrategy, V::Error>
3506 where
3507 V: serde::de::MapAccess<'de>,
3508 {
3509 let mut r#type__ = None;
3510 let mut dist_key_indices__ = None;
3511 let mut output_mapping__ = None;
3512 while let Some(k) = map_.next_key()? {
3513 match k {
3514 GeneratedField::Type => {
3515 if r#type__.is_some() {
3516 return Err(serde::de::Error::duplicate_field("type"));
3517 }
3518 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3519 }
3520 GeneratedField::DistKeyIndices => {
3521 if dist_key_indices__.is_some() {
3522 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3523 }
3524 dist_key_indices__ =
3525 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3526 .into_iter().map(|x| x.0).collect())
3527 ;
3528 }
3529 GeneratedField::OutputMapping => {
3530 if output_mapping__.is_some() {
3531 return Err(serde::de::Error::duplicate_field("outputMapping"));
3532 }
3533 output_mapping__ = map_.next_value()?;
3534 }
3535 }
3536 }
3537 Ok(DispatchStrategy {
3538 r#type: r#type__.unwrap_or_default(),
3539 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3540 output_mapping: output_mapping__,
3541 })
3542 }
3543 }
3544 deserializer.deserialize_struct("stream_plan.DispatchStrategy", FIELDS, GeneratedVisitor)
3545 }
3546}
3547impl serde::Serialize for Dispatcher {
3548 #[allow(deprecated)]
3549 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3550 where
3551 S: serde::Serializer,
3552 {
3553 use serde::ser::SerializeStruct;
3554 let mut len = 0;
3555 if self.r#type != 0 {
3556 len += 1;
3557 }
3558 if !self.dist_key_indices.is_empty() {
3559 len += 1;
3560 }
3561 if self.output_mapping.is_some() {
3562 len += 1;
3563 }
3564 if self.hash_mapping.is_some() {
3565 len += 1;
3566 }
3567 if self.dispatcher_id != 0 {
3568 len += 1;
3569 }
3570 if !self.downstream_actor_id.is_empty() {
3571 len += 1;
3572 }
3573 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatcher", len)?;
3574 if self.r#type != 0 {
3575 let v = DispatcherType::try_from(self.r#type)
3576 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3577 struct_ser.serialize_field("type", &v)?;
3578 }
3579 if !self.dist_key_indices.is_empty() {
3580 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3581 }
3582 if let Some(v) = self.output_mapping.as_ref() {
3583 struct_ser.serialize_field("outputMapping", v)?;
3584 }
3585 if let Some(v) = self.hash_mapping.as_ref() {
3586 struct_ser.serialize_field("hashMapping", v)?;
3587 }
3588 if self.dispatcher_id != 0 {
3589 #[allow(clippy::needless_borrow)]
3590 #[allow(clippy::needless_borrows_for_generic_args)]
3591 struct_ser.serialize_field("dispatcherId", ToString::to_string(&self.dispatcher_id).as_str())?;
3592 }
3593 if !self.downstream_actor_id.is_empty() {
3594 struct_ser.serialize_field("downstreamActorId", &self.downstream_actor_id)?;
3595 }
3596 struct_ser.end()
3597 }
3598}
3599impl<'de> serde::Deserialize<'de> for Dispatcher {
3600 #[allow(deprecated)]
3601 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3602 where
3603 D: serde::Deserializer<'de>,
3604 {
3605 const FIELDS: &[&str] = &[
3606 "type",
3607 "dist_key_indices",
3608 "distKeyIndices",
3609 "output_mapping",
3610 "outputMapping",
3611 "hash_mapping",
3612 "hashMapping",
3613 "dispatcher_id",
3614 "dispatcherId",
3615 "downstream_actor_id",
3616 "downstreamActorId",
3617 ];
3618
3619 #[allow(clippy::enum_variant_names)]
3620 enum GeneratedField {
3621 Type,
3622 DistKeyIndices,
3623 OutputMapping,
3624 HashMapping,
3625 DispatcherId,
3626 DownstreamActorId,
3627 }
3628 impl<'de> serde::Deserialize<'de> for GeneratedField {
3629 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3630 where
3631 D: serde::Deserializer<'de>,
3632 {
3633 struct GeneratedVisitor;
3634
3635 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3636 type Value = GeneratedField;
3637
3638 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3639 write!(formatter, "expected one of: {:?}", &FIELDS)
3640 }
3641
3642 #[allow(unused_variables)]
3643 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3644 where
3645 E: serde::de::Error,
3646 {
3647 match value {
3648 "type" => Ok(GeneratedField::Type),
3649 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3650 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3651 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
3652 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
3653 "downstreamActorId" | "downstream_actor_id" => Ok(GeneratedField::DownstreamActorId),
3654 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3655 }
3656 }
3657 }
3658 deserializer.deserialize_identifier(GeneratedVisitor)
3659 }
3660 }
3661 struct GeneratedVisitor;
3662 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3663 type Value = Dispatcher;
3664
3665 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3666 formatter.write_str("struct stream_plan.Dispatcher")
3667 }
3668
3669 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatcher, V::Error>
3670 where
3671 V: serde::de::MapAccess<'de>,
3672 {
3673 let mut r#type__ = None;
3674 let mut dist_key_indices__ = None;
3675 let mut output_mapping__ = None;
3676 let mut hash_mapping__ = None;
3677 let mut dispatcher_id__ = None;
3678 let mut downstream_actor_id__ = None;
3679 while let Some(k) = map_.next_key()? {
3680 match k {
3681 GeneratedField::Type => {
3682 if r#type__.is_some() {
3683 return Err(serde::de::Error::duplicate_field("type"));
3684 }
3685 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3686 }
3687 GeneratedField::DistKeyIndices => {
3688 if dist_key_indices__.is_some() {
3689 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3690 }
3691 dist_key_indices__ =
3692 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3693 .into_iter().map(|x| x.0).collect())
3694 ;
3695 }
3696 GeneratedField::OutputMapping => {
3697 if output_mapping__.is_some() {
3698 return Err(serde::de::Error::duplicate_field("outputMapping"));
3699 }
3700 output_mapping__ = map_.next_value()?;
3701 }
3702 GeneratedField::HashMapping => {
3703 if hash_mapping__.is_some() {
3704 return Err(serde::de::Error::duplicate_field("hashMapping"));
3705 }
3706 hash_mapping__ = map_.next_value()?;
3707 }
3708 GeneratedField::DispatcherId => {
3709 if dispatcher_id__.is_some() {
3710 return Err(serde::de::Error::duplicate_field("dispatcherId"));
3711 }
3712 dispatcher_id__ =
3713 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3714 ;
3715 }
3716 GeneratedField::DownstreamActorId => {
3717 if downstream_actor_id__.is_some() {
3718 return Err(serde::de::Error::duplicate_field("downstreamActorId"));
3719 }
3720 downstream_actor_id__ =
3721 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3722 .into_iter().map(|x| x.0).collect())
3723 ;
3724 }
3725 }
3726 }
3727 Ok(Dispatcher {
3728 r#type: r#type__.unwrap_or_default(),
3729 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3730 output_mapping: output_mapping__,
3731 hash_mapping: hash_mapping__,
3732 dispatcher_id: dispatcher_id__.unwrap_or_default(),
3733 downstream_actor_id: downstream_actor_id__.unwrap_or_default(),
3734 })
3735 }
3736 }
3737 deserializer.deserialize_struct("stream_plan.Dispatcher", FIELDS, GeneratedVisitor)
3738 }
3739}
3740impl serde::Serialize for DispatcherType {
3741 #[allow(deprecated)]
3742 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3743 where
3744 S: serde::Serializer,
3745 {
3746 let variant = match self {
3747 Self::Unspecified => "DISPATCHER_TYPE_UNSPECIFIED",
3748 Self::Hash => "DISPATCHER_TYPE_HASH",
3749 Self::Broadcast => "DISPATCHER_TYPE_BROADCAST",
3750 Self::Simple => "DISPATCHER_TYPE_SIMPLE",
3751 Self::NoShuffle => "DISPATCHER_TYPE_NO_SHUFFLE",
3752 };
3753 serializer.serialize_str(variant)
3754 }
3755}
3756impl<'de> serde::Deserialize<'de> for DispatcherType {
3757 #[allow(deprecated)]
3758 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3759 where
3760 D: serde::Deserializer<'de>,
3761 {
3762 const FIELDS: &[&str] = &[
3763 "DISPATCHER_TYPE_UNSPECIFIED",
3764 "DISPATCHER_TYPE_HASH",
3765 "DISPATCHER_TYPE_BROADCAST",
3766 "DISPATCHER_TYPE_SIMPLE",
3767 "DISPATCHER_TYPE_NO_SHUFFLE",
3768 ];
3769
3770 struct GeneratedVisitor;
3771
3772 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3773 type Value = DispatcherType;
3774
3775 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3776 write!(formatter, "expected one of: {:?}", &FIELDS)
3777 }
3778
3779 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3780 where
3781 E: serde::de::Error,
3782 {
3783 i32::try_from(v)
3784 .ok()
3785 .and_then(|x| x.try_into().ok())
3786 .ok_or_else(|| {
3787 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3788 })
3789 }
3790
3791 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3792 where
3793 E: serde::de::Error,
3794 {
3795 i32::try_from(v)
3796 .ok()
3797 .and_then(|x| x.try_into().ok())
3798 .ok_or_else(|| {
3799 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3800 })
3801 }
3802
3803 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3804 where
3805 E: serde::de::Error,
3806 {
3807 match value {
3808 "DISPATCHER_TYPE_UNSPECIFIED" => Ok(DispatcherType::Unspecified),
3809 "DISPATCHER_TYPE_HASH" => Ok(DispatcherType::Hash),
3810 "DISPATCHER_TYPE_BROADCAST" => Ok(DispatcherType::Broadcast),
3811 "DISPATCHER_TYPE_SIMPLE" => Ok(DispatcherType::Simple),
3812 "DISPATCHER_TYPE_NO_SHUFFLE" => Ok(DispatcherType::NoShuffle),
3813 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3814 }
3815 }
3816 }
3817 deserializer.deserialize_any(GeneratedVisitor)
3818 }
3819}
3820impl serde::Serialize for Dispatchers {
3821 #[allow(deprecated)]
3822 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3823 where
3824 S: serde::Serializer,
3825 {
3826 use serde::ser::SerializeStruct;
3827 let mut len = 0;
3828 if !self.dispatchers.is_empty() {
3829 len += 1;
3830 }
3831 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatchers", len)?;
3832 if !self.dispatchers.is_empty() {
3833 struct_ser.serialize_field("dispatchers", &self.dispatchers)?;
3834 }
3835 struct_ser.end()
3836 }
3837}
3838impl<'de> serde::Deserialize<'de> for Dispatchers {
3839 #[allow(deprecated)]
3840 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3841 where
3842 D: serde::Deserializer<'de>,
3843 {
3844 const FIELDS: &[&str] = &[
3845 "dispatchers",
3846 ];
3847
3848 #[allow(clippy::enum_variant_names)]
3849 enum GeneratedField {
3850 Dispatchers,
3851 }
3852 impl<'de> serde::Deserialize<'de> for GeneratedField {
3853 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3854 where
3855 D: serde::Deserializer<'de>,
3856 {
3857 struct GeneratedVisitor;
3858
3859 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3860 type Value = GeneratedField;
3861
3862 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3863 write!(formatter, "expected one of: {:?}", &FIELDS)
3864 }
3865
3866 #[allow(unused_variables)]
3867 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3868 where
3869 E: serde::de::Error,
3870 {
3871 match value {
3872 "dispatchers" => Ok(GeneratedField::Dispatchers),
3873 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3874 }
3875 }
3876 }
3877 deserializer.deserialize_identifier(GeneratedVisitor)
3878 }
3879 }
3880 struct GeneratedVisitor;
3881 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3882 type Value = Dispatchers;
3883
3884 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3885 formatter.write_str("struct stream_plan.Dispatchers")
3886 }
3887
3888 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatchers, V::Error>
3889 where
3890 V: serde::de::MapAccess<'de>,
3891 {
3892 let mut dispatchers__ = None;
3893 while let Some(k) = map_.next_key()? {
3894 match k {
3895 GeneratedField::Dispatchers => {
3896 if dispatchers__.is_some() {
3897 return Err(serde::de::Error::duplicate_field("dispatchers"));
3898 }
3899 dispatchers__ = Some(map_.next_value()?);
3900 }
3901 }
3902 }
3903 Ok(Dispatchers {
3904 dispatchers: dispatchers__.unwrap_or_default(),
3905 })
3906 }
3907 }
3908 deserializer.deserialize_struct("stream_plan.Dispatchers", FIELDS, GeneratedVisitor)
3909 }
3910}
3911impl serde::Serialize for DmlNode {
3912 #[allow(deprecated)]
3913 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3914 where
3915 S: serde::Serializer,
3916 {
3917 use serde::ser::SerializeStruct;
3918 let mut len = 0;
3919 if self.table_id != 0 {
3920 len += 1;
3921 }
3922 if self.table_version_id != 0 {
3923 len += 1;
3924 }
3925 if !self.column_descs.is_empty() {
3926 len += 1;
3927 }
3928 if self.rate_limit.is_some() {
3929 len += 1;
3930 }
3931 let mut struct_ser = serializer.serialize_struct("stream_plan.DmlNode", len)?;
3932 if self.table_id != 0 {
3933 struct_ser.serialize_field("tableId", &self.table_id)?;
3934 }
3935 if self.table_version_id != 0 {
3936 #[allow(clippy::needless_borrow)]
3937 #[allow(clippy::needless_borrows_for_generic_args)]
3938 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
3939 }
3940 if !self.column_descs.is_empty() {
3941 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
3942 }
3943 if let Some(v) = self.rate_limit.as_ref() {
3944 struct_ser.serialize_field("rateLimit", v)?;
3945 }
3946 struct_ser.end()
3947 }
3948}
3949impl<'de> serde::Deserialize<'de> for DmlNode {
3950 #[allow(deprecated)]
3951 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3952 where
3953 D: serde::Deserializer<'de>,
3954 {
3955 const FIELDS: &[&str] = &[
3956 "table_id",
3957 "tableId",
3958 "table_version_id",
3959 "tableVersionId",
3960 "column_descs",
3961 "columnDescs",
3962 "rate_limit",
3963 "rateLimit",
3964 ];
3965
3966 #[allow(clippy::enum_variant_names)]
3967 enum GeneratedField {
3968 TableId,
3969 TableVersionId,
3970 ColumnDescs,
3971 RateLimit,
3972 }
3973 impl<'de> serde::Deserialize<'de> for GeneratedField {
3974 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3975 where
3976 D: serde::Deserializer<'de>,
3977 {
3978 struct GeneratedVisitor;
3979
3980 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3981 type Value = GeneratedField;
3982
3983 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3984 write!(formatter, "expected one of: {:?}", &FIELDS)
3985 }
3986
3987 #[allow(unused_variables)]
3988 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3989 where
3990 E: serde::de::Error,
3991 {
3992 match value {
3993 "tableId" | "table_id" => Ok(GeneratedField::TableId),
3994 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
3995 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
3996 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
3997 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3998 }
3999 }
4000 }
4001 deserializer.deserialize_identifier(GeneratedVisitor)
4002 }
4003 }
4004 struct GeneratedVisitor;
4005 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4006 type Value = DmlNode;
4007
4008 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4009 formatter.write_str("struct stream_plan.DmlNode")
4010 }
4011
4012 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DmlNode, V::Error>
4013 where
4014 V: serde::de::MapAccess<'de>,
4015 {
4016 let mut table_id__ = None;
4017 let mut table_version_id__ = None;
4018 let mut column_descs__ = None;
4019 let mut rate_limit__ = None;
4020 while let Some(k) = map_.next_key()? {
4021 match k {
4022 GeneratedField::TableId => {
4023 if table_id__.is_some() {
4024 return Err(serde::de::Error::duplicate_field("tableId"));
4025 }
4026 table_id__ =
4027 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4028 ;
4029 }
4030 GeneratedField::TableVersionId => {
4031 if table_version_id__.is_some() {
4032 return Err(serde::de::Error::duplicate_field("tableVersionId"));
4033 }
4034 table_version_id__ =
4035 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4036 ;
4037 }
4038 GeneratedField::ColumnDescs => {
4039 if column_descs__.is_some() {
4040 return Err(serde::de::Error::duplicate_field("columnDescs"));
4041 }
4042 column_descs__ = Some(map_.next_value()?);
4043 }
4044 GeneratedField::RateLimit => {
4045 if rate_limit__.is_some() {
4046 return Err(serde::de::Error::duplicate_field("rateLimit"));
4047 }
4048 rate_limit__ =
4049 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4050 ;
4051 }
4052 }
4053 }
4054 Ok(DmlNode {
4055 table_id: table_id__.unwrap_or_default(),
4056 table_version_id: table_version_id__.unwrap_or_default(),
4057 column_descs: column_descs__.unwrap_or_default(),
4058 rate_limit: rate_limit__,
4059 })
4060 }
4061 }
4062 deserializer.deserialize_struct("stream_plan.DmlNode", FIELDS, GeneratedVisitor)
4063 }
4064}
4065impl serde::Serialize for DropSubscriptionsMutation {
4066 #[allow(deprecated)]
4067 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4068 where
4069 S: serde::Serializer,
4070 {
4071 use serde::ser::SerializeStruct;
4072 let mut len = 0;
4073 if !self.info.is_empty() {
4074 len += 1;
4075 }
4076 let mut struct_ser = serializer.serialize_struct("stream_plan.DropSubscriptionsMutation", len)?;
4077 if !self.info.is_empty() {
4078 struct_ser.serialize_field("info", &self.info)?;
4079 }
4080 struct_ser.end()
4081 }
4082}
4083impl<'de> serde::Deserialize<'de> for DropSubscriptionsMutation {
4084 #[allow(deprecated)]
4085 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4086 where
4087 D: serde::Deserializer<'de>,
4088 {
4089 const FIELDS: &[&str] = &[
4090 "info",
4091 ];
4092
4093 #[allow(clippy::enum_variant_names)]
4094 enum GeneratedField {
4095 Info,
4096 }
4097 impl<'de> serde::Deserialize<'de> for GeneratedField {
4098 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4099 where
4100 D: serde::Deserializer<'de>,
4101 {
4102 struct GeneratedVisitor;
4103
4104 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4105 type Value = GeneratedField;
4106
4107 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4108 write!(formatter, "expected one of: {:?}", &FIELDS)
4109 }
4110
4111 #[allow(unused_variables)]
4112 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4113 where
4114 E: serde::de::Error,
4115 {
4116 match value {
4117 "info" => Ok(GeneratedField::Info),
4118 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4119 }
4120 }
4121 }
4122 deserializer.deserialize_identifier(GeneratedVisitor)
4123 }
4124 }
4125 struct GeneratedVisitor;
4126 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4127 type Value = DropSubscriptionsMutation;
4128
4129 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4130 formatter.write_str("struct stream_plan.DropSubscriptionsMutation")
4131 }
4132
4133 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionsMutation, V::Error>
4134 where
4135 V: serde::de::MapAccess<'de>,
4136 {
4137 let mut info__ = None;
4138 while let Some(k) = map_.next_key()? {
4139 match k {
4140 GeneratedField::Info => {
4141 if info__.is_some() {
4142 return Err(serde::de::Error::duplicate_field("info"));
4143 }
4144 info__ = Some(map_.next_value()?);
4145 }
4146 }
4147 }
4148 Ok(DropSubscriptionsMutation {
4149 info: info__.unwrap_or_default(),
4150 })
4151 }
4152 }
4153 deserializer.deserialize_struct("stream_plan.DropSubscriptionsMutation", FIELDS, GeneratedVisitor)
4154 }
4155}
4156impl serde::Serialize for DynamicFilterNode {
4157 #[allow(deprecated)]
4158 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4159 where
4160 S: serde::Serializer,
4161 {
4162 use serde::ser::SerializeStruct;
4163 let mut len = 0;
4164 if self.left_key != 0 {
4165 len += 1;
4166 }
4167 if self.condition.is_some() {
4168 len += 1;
4169 }
4170 if self.left_table.is_some() {
4171 len += 1;
4172 }
4173 if self.right_table.is_some() {
4174 len += 1;
4175 }
4176 if self.condition_always_relax {
4177 len += 1;
4178 }
4179 let mut struct_ser = serializer.serialize_struct("stream_plan.DynamicFilterNode", len)?;
4180 if self.left_key != 0 {
4181 struct_ser.serialize_field("leftKey", &self.left_key)?;
4182 }
4183 if let Some(v) = self.condition.as_ref() {
4184 struct_ser.serialize_field("condition", v)?;
4185 }
4186 if let Some(v) = self.left_table.as_ref() {
4187 struct_ser.serialize_field("leftTable", v)?;
4188 }
4189 if let Some(v) = self.right_table.as_ref() {
4190 struct_ser.serialize_field("rightTable", v)?;
4191 }
4192 if self.condition_always_relax {
4193 struct_ser.serialize_field("conditionAlwaysRelax", &self.condition_always_relax)?;
4194 }
4195 struct_ser.end()
4196 }
4197}
4198impl<'de> serde::Deserialize<'de> for DynamicFilterNode {
4199 #[allow(deprecated)]
4200 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4201 where
4202 D: serde::Deserializer<'de>,
4203 {
4204 const FIELDS: &[&str] = &[
4205 "left_key",
4206 "leftKey",
4207 "condition",
4208 "left_table",
4209 "leftTable",
4210 "right_table",
4211 "rightTable",
4212 "condition_always_relax",
4213 "conditionAlwaysRelax",
4214 ];
4215
4216 #[allow(clippy::enum_variant_names)]
4217 enum GeneratedField {
4218 LeftKey,
4219 Condition,
4220 LeftTable,
4221 RightTable,
4222 ConditionAlwaysRelax,
4223 }
4224 impl<'de> serde::Deserialize<'de> for GeneratedField {
4225 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4226 where
4227 D: serde::Deserializer<'de>,
4228 {
4229 struct GeneratedVisitor;
4230
4231 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4232 type Value = GeneratedField;
4233
4234 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4235 write!(formatter, "expected one of: {:?}", &FIELDS)
4236 }
4237
4238 #[allow(unused_variables)]
4239 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4240 where
4241 E: serde::de::Error,
4242 {
4243 match value {
4244 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
4245 "condition" => Ok(GeneratedField::Condition),
4246 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
4247 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
4248 "conditionAlwaysRelax" | "condition_always_relax" => Ok(GeneratedField::ConditionAlwaysRelax),
4249 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4250 }
4251 }
4252 }
4253 deserializer.deserialize_identifier(GeneratedVisitor)
4254 }
4255 }
4256 struct GeneratedVisitor;
4257 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4258 type Value = DynamicFilterNode;
4259
4260 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4261 formatter.write_str("struct stream_plan.DynamicFilterNode")
4262 }
4263
4264 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DynamicFilterNode, V::Error>
4265 where
4266 V: serde::de::MapAccess<'de>,
4267 {
4268 let mut left_key__ = None;
4269 let mut condition__ = None;
4270 let mut left_table__ = None;
4271 let mut right_table__ = None;
4272 let mut condition_always_relax__ = None;
4273 while let Some(k) = map_.next_key()? {
4274 match k {
4275 GeneratedField::LeftKey => {
4276 if left_key__.is_some() {
4277 return Err(serde::de::Error::duplicate_field("leftKey"));
4278 }
4279 left_key__ =
4280 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4281 ;
4282 }
4283 GeneratedField::Condition => {
4284 if condition__.is_some() {
4285 return Err(serde::de::Error::duplicate_field("condition"));
4286 }
4287 condition__ = map_.next_value()?;
4288 }
4289 GeneratedField::LeftTable => {
4290 if left_table__.is_some() {
4291 return Err(serde::de::Error::duplicate_field("leftTable"));
4292 }
4293 left_table__ = map_.next_value()?;
4294 }
4295 GeneratedField::RightTable => {
4296 if right_table__.is_some() {
4297 return Err(serde::de::Error::duplicate_field("rightTable"));
4298 }
4299 right_table__ = map_.next_value()?;
4300 }
4301 GeneratedField::ConditionAlwaysRelax => {
4302 if condition_always_relax__.is_some() {
4303 return Err(serde::de::Error::duplicate_field("conditionAlwaysRelax"));
4304 }
4305 condition_always_relax__ = Some(map_.next_value()?);
4306 }
4307 }
4308 }
4309 Ok(DynamicFilterNode {
4310 left_key: left_key__.unwrap_or_default(),
4311 condition: condition__,
4312 left_table: left_table__,
4313 right_table: right_table__,
4314 condition_always_relax: condition_always_relax__.unwrap_or_default(),
4315 })
4316 }
4317 }
4318 deserializer.deserialize_struct("stream_plan.DynamicFilterNode", FIELDS, GeneratedVisitor)
4319 }
4320}
4321impl serde::Serialize for EowcGapFillNode {
4322 #[allow(deprecated)]
4323 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4324 where
4325 S: serde::Serializer,
4326 {
4327 use serde::ser::SerializeStruct;
4328 let mut len = 0;
4329 if self.time_column_index != 0 {
4330 len += 1;
4331 }
4332 if self.interval.is_some() {
4333 len += 1;
4334 }
4335 if !self.fill_columns.is_empty() {
4336 len += 1;
4337 }
4338 if !self.fill_strategies.is_empty() {
4339 len += 1;
4340 }
4341 if self.buffer_table.is_some() {
4342 len += 1;
4343 }
4344 if self.prev_row_table.is_some() {
4345 len += 1;
4346 }
4347 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcGapFillNode", len)?;
4348 if self.time_column_index != 0 {
4349 struct_ser.serialize_field("timeColumnIndex", &self.time_column_index)?;
4350 }
4351 if let Some(v) = self.interval.as_ref() {
4352 struct_ser.serialize_field("interval", v)?;
4353 }
4354 if !self.fill_columns.is_empty() {
4355 struct_ser.serialize_field("fillColumns", &self.fill_columns)?;
4356 }
4357 if !self.fill_strategies.is_empty() {
4358 struct_ser.serialize_field("fillStrategies", &self.fill_strategies)?;
4359 }
4360 if let Some(v) = self.buffer_table.as_ref() {
4361 struct_ser.serialize_field("bufferTable", v)?;
4362 }
4363 if let Some(v) = self.prev_row_table.as_ref() {
4364 struct_ser.serialize_field("prevRowTable", v)?;
4365 }
4366 struct_ser.end()
4367 }
4368}
4369impl<'de> serde::Deserialize<'de> for EowcGapFillNode {
4370 #[allow(deprecated)]
4371 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4372 where
4373 D: serde::Deserializer<'de>,
4374 {
4375 const FIELDS: &[&str] = &[
4376 "time_column_index",
4377 "timeColumnIndex",
4378 "interval",
4379 "fill_columns",
4380 "fillColumns",
4381 "fill_strategies",
4382 "fillStrategies",
4383 "buffer_table",
4384 "bufferTable",
4385 "prev_row_table",
4386 "prevRowTable",
4387 ];
4388
4389 #[allow(clippy::enum_variant_names)]
4390 enum GeneratedField {
4391 TimeColumnIndex,
4392 Interval,
4393 FillColumns,
4394 FillStrategies,
4395 BufferTable,
4396 PrevRowTable,
4397 }
4398 impl<'de> serde::Deserialize<'de> for GeneratedField {
4399 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4400 where
4401 D: serde::Deserializer<'de>,
4402 {
4403 struct GeneratedVisitor;
4404
4405 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4406 type Value = GeneratedField;
4407
4408 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4409 write!(formatter, "expected one of: {:?}", &FIELDS)
4410 }
4411
4412 #[allow(unused_variables)]
4413 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4414 where
4415 E: serde::de::Error,
4416 {
4417 match value {
4418 "timeColumnIndex" | "time_column_index" => Ok(GeneratedField::TimeColumnIndex),
4419 "interval" => Ok(GeneratedField::Interval),
4420 "fillColumns" | "fill_columns" => Ok(GeneratedField::FillColumns),
4421 "fillStrategies" | "fill_strategies" => Ok(GeneratedField::FillStrategies),
4422 "bufferTable" | "buffer_table" => Ok(GeneratedField::BufferTable),
4423 "prevRowTable" | "prev_row_table" => Ok(GeneratedField::PrevRowTable),
4424 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4425 }
4426 }
4427 }
4428 deserializer.deserialize_identifier(GeneratedVisitor)
4429 }
4430 }
4431 struct GeneratedVisitor;
4432 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4433 type Value = EowcGapFillNode;
4434
4435 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4436 formatter.write_str("struct stream_plan.EowcGapFillNode")
4437 }
4438
4439 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcGapFillNode, V::Error>
4440 where
4441 V: serde::de::MapAccess<'de>,
4442 {
4443 let mut time_column_index__ = None;
4444 let mut interval__ = None;
4445 let mut fill_columns__ = None;
4446 let mut fill_strategies__ = None;
4447 let mut buffer_table__ = None;
4448 let mut prev_row_table__ = None;
4449 while let Some(k) = map_.next_key()? {
4450 match k {
4451 GeneratedField::TimeColumnIndex => {
4452 if time_column_index__.is_some() {
4453 return Err(serde::de::Error::duplicate_field("timeColumnIndex"));
4454 }
4455 time_column_index__ =
4456 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4457 ;
4458 }
4459 GeneratedField::Interval => {
4460 if interval__.is_some() {
4461 return Err(serde::de::Error::duplicate_field("interval"));
4462 }
4463 interval__ = map_.next_value()?;
4464 }
4465 GeneratedField::FillColumns => {
4466 if fill_columns__.is_some() {
4467 return Err(serde::de::Error::duplicate_field("fillColumns"));
4468 }
4469 fill_columns__ =
4470 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4471 .into_iter().map(|x| x.0).collect())
4472 ;
4473 }
4474 GeneratedField::FillStrategies => {
4475 if fill_strategies__.is_some() {
4476 return Err(serde::de::Error::duplicate_field("fillStrategies"));
4477 }
4478 fill_strategies__ = Some(map_.next_value()?);
4479 }
4480 GeneratedField::BufferTable => {
4481 if buffer_table__.is_some() {
4482 return Err(serde::de::Error::duplicate_field("bufferTable"));
4483 }
4484 buffer_table__ = map_.next_value()?;
4485 }
4486 GeneratedField::PrevRowTable => {
4487 if prev_row_table__.is_some() {
4488 return Err(serde::de::Error::duplicate_field("prevRowTable"));
4489 }
4490 prev_row_table__ = map_.next_value()?;
4491 }
4492 }
4493 }
4494 Ok(EowcGapFillNode {
4495 time_column_index: time_column_index__.unwrap_or_default(),
4496 interval: interval__,
4497 fill_columns: fill_columns__.unwrap_or_default(),
4498 fill_strategies: fill_strategies__.unwrap_or_default(),
4499 buffer_table: buffer_table__,
4500 prev_row_table: prev_row_table__,
4501 })
4502 }
4503 }
4504 deserializer.deserialize_struct("stream_plan.EowcGapFillNode", FIELDS, GeneratedVisitor)
4505 }
4506}
4507impl serde::Serialize for EowcOverWindowNode {
4508 #[allow(deprecated)]
4509 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4510 where
4511 S: serde::Serializer,
4512 {
4513 use serde::ser::SerializeStruct;
4514 let mut len = 0;
4515 if !self.calls.is_empty() {
4516 len += 1;
4517 }
4518 if !self.partition_by.is_empty() {
4519 len += 1;
4520 }
4521 if !self.order_by.is_empty() {
4522 len += 1;
4523 }
4524 if self.state_table.is_some() {
4525 len += 1;
4526 }
4527 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcOverWindowNode", len)?;
4528 if !self.calls.is_empty() {
4529 struct_ser.serialize_field("calls", &self.calls)?;
4530 }
4531 if !self.partition_by.is_empty() {
4532 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
4533 }
4534 if !self.order_by.is_empty() {
4535 struct_ser.serialize_field("orderBy", &self.order_by)?;
4536 }
4537 if let Some(v) = self.state_table.as_ref() {
4538 struct_ser.serialize_field("stateTable", v)?;
4539 }
4540 struct_ser.end()
4541 }
4542}
4543impl<'de> serde::Deserialize<'de> for EowcOverWindowNode {
4544 #[allow(deprecated)]
4545 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4546 where
4547 D: serde::Deserializer<'de>,
4548 {
4549 const FIELDS: &[&str] = &[
4550 "calls",
4551 "partition_by",
4552 "partitionBy",
4553 "order_by",
4554 "orderBy",
4555 "state_table",
4556 "stateTable",
4557 ];
4558
4559 #[allow(clippy::enum_variant_names)]
4560 enum GeneratedField {
4561 Calls,
4562 PartitionBy,
4563 OrderBy,
4564 StateTable,
4565 }
4566 impl<'de> serde::Deserialize<'de> for GeneratedField {
4567 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4568 where
4569 D: serde::Deserializer<'de>,
4570 {
4571 struct GeneratedVisitor;
4572
4573 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4574 type Value = GeneratedField;
4575
4576 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4577 write!(formatter, "expected one of: {:?}", &FIELDS)
4578 }
4579
4580 #[allow(unused_variables)]
4581 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4582 where
4583 E: serde::de::Error,
4584 {
4585 match value {
4586 "calls" => Ok(GeneratedField::Calls),
4587 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
4588 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
4589 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
4590 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4591 }
4592 }
4593 }
4594 deserializer.deserialize_identifier(GeneratedVisitor)
4595 }
4596 }
4597 struct GeneratedVisitor;
4598 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4599 type Value = EowcOverWindowNode;
4600
4601 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4602 formatter.write_str("struct stream_plan.EowcOverWindowNode")
4603 }
4604
4605 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcOverWindowNode, V::Error>
4606 where
4607 V: serde::de::MapAccess<'de>,
4608 {
4609 let mut calls__ = None;
4610 let mut partition_by__ = None;
4611 let mut order_by__ = None;
4612 let mut state_table__ = None;
4613 while let Some(k) = map_.next_key()? {
4614 match k {
4615 GeneratedField::Calls => {
4616 if calls__.is_some() {
4617 return Err(serde::de::Error::duplicate_field("calls"));
4618 }
4619 calls__ = Some(map_.next_value()?);
4620 }
4621 GeneratedField::PartitionBy => {
4622 if partition_by__.is_some() {
4623 return Err(serde::de::Error::duplicate_field("partitionBy"));
4624 }
4625 partition_by__ =
4626 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4627 .into_iter().map(|x| x.0).collect())
4628 ;
4629 }
4630 GeneratedField::OrderBy => {
4631 if order_by__.is_some() {
4632 return Err(serde::de::Error::duplicate_field("orderBy"));
4633 }
4634 order_by__ = Some(map_.next_value()?);
4635 }
4636 GeneratedField::StateTable => {
4637 if state_table__.is_some() {
4638 return Err(serde::de::Error::duplicate_field("stateTable"));
4639 }
4640 state_table__ = map_.next_value()?;
4641 }
4642 }
4643 }
4644 Ok(EowcOverWindowNode {
4645 calls: calls__.unwrap_or_default(),
4646 partition_by: partition_by__.unwrap_or_default(),
4647 order_by: order_by__.unwrap_or_default(),
4648 state_table: state_table__,
4649 })
4650 }
4651 }
4652 deserializer.deserialize_struct("stream_plan.EowcOverWindowNode", FIELDS, GeneratedVisitor)
4653 }
4654}
4655impl serde::Serialize for ExchangeNode {
4656 #[allow(deprecated)]
4657 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4658 where
4659 S: serde::Serializer,
4660 {
4661 use serde::ser::SerializeStruct;
4662 let mut len = 0;
4663 if self.strategy.is_some() {
4664 len += 1;
4665 }
4666 let mut struct_ser = serializer.serialize_struct("stream_plan.ExchangeNode", len)?;
4667 if let Some(v) = self.strategy.as_ref() {
4668 struct_ser.serialize_field("strategy", v)?;
4669 }
4670 struct_ser.end()
4671 }
4672}
4673impl<'de> serde::Deserialize<'de> for ExchangeNode {
4674 #[allow(deprecated)]
4675 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4676 where
4677 D: serde::Deserializer<'de>,
4678 {
4679 const FIELDS: &[&str] = &[
4680 "strategy",
4681 ];
4682
4683 #[allow(clippy::enum_variant_names)]
4684 enum GeneratedField {
4685 Strategy,
4686 }
4687 impl<'de> serde::Deserialize<'de> for GeneratedField {
4688 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4689 where
4690 D: serde::Deserializer<'de>,
4691 {
4692 struct GeneratedVisitor;
4693
4694 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4695 type Value = GeneratedField;
4696
4697 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4698 write!(formatter, "expected one of: {:?}", &FIELDS)
4699 }
4700
4701 #[allow(unused_variables)]
4702 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4703 where
4704 E: serde::de::Error,
4705 {
4706 match value {
4707 "strategy" => Ok(GeneratedField::Strategy),
4708 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4709 }
4710 }
4711 }
4712 deserializer.deserialize_identifier(GeneratedVisitor)
4713 }
4714 }
4715 struct GeneratedVisitor;
4716 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4717 type Value = ExchangeNode;
4718
4719 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4720 formatter.write_str("struct stream_plan.ExchangeNode")
4721 }
4722
4723 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExchangeNode, V::Error>
4724 where
4725 V: serde::de::MapAccess<'de>,
4726 {
4727 let mut strategy__ = None;
4728 while let Some(k) = map_.next_key()? {
4729 match k {
4730 GeneratedField::Strategy => {
4731 if strategy__.is_some() {
4732 return Err(serde::de::Error::duplicate_field("strategy"));
4733 }
4734 strategy__ = map_.next_value()?;
4735 }
4736 }
4737 }
4738 Ok(ExchangeNode {
4739 strategy: strategy__,
4740 })
4741 }
4742 }
4743 deserializer.deserialize_struct("stream_plan.ExchangeNode", FIELDS, GeneratedVisitor)
4744 }
4745}
4746impl serde::Serialize for ExpandNode {
4747 #[allow(deprecated)]
4748 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4749 where
4750 S: serde::Serializer,
4751 {
4752 use serde::ser::SerializeStruct;
4753 let mut len = 0;
4754 if !self.column_subsets.is_empty() {
4755 len += 1;
4756 }
4757 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode", len)?;
4758 if !self.column_subsets.is_empty() {
4759 struct_ser.serialize_field("columnSubsets", &self.column_subsets)?;
4760 }
4761 struct_ser.end()
4762 }
4763}
4764impl<'de> serde::Deserialize<'de> for ExpandNode {
4765 #[allow(deprecated)]
4766 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4767 where
4768 D: serde::Deserializer<'de>,
4769 {
4770 const FIELDS: &[&str] = &[
4771 "column_subsets",
4772 "columnSubsets",
4773 ];
4774
4775 #[allow(clippy::enum_variant_names)]
4776 enum GeneratedField {
4777 ColumnSubsets,
4778 }
4779 impl<'de> serde::Deserialize<'de> for GeneratedField {
4780 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4781 where
4782 D: serde::Deserializer<'de>,
4783 {
4784 struct GeneratedVisitor;
4785
4786 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4787 type Value = GeneratedField;
4788
4789 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4790 write!(formatter, "expected one of: {:?}", &FIELDS)
4791 }
4792
4793 #[allow(unused_variables)]
4794 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4795 where
4796 E: serde::de::Error,
4797 {
4798 match value {
4799 "columnSubsets" | "column_subsets" => Ok(GeneratedField::ColumnSubsets),
4800 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4801 }
4802 }
4803 }
4804 deserializer.deserialize_identifier(GeneratedVisitor)
4805 }
4806 }
4807 struct GeneratedVisitor;
4808 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4809 type Value = ExpandNode;
4810
4811 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4812 formatter.write_str("struct stream_plan.ExpandNode")
4813 }
4814
4815 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpandNode, V::Error>
4816 where
4817 V: serde::de::MapAccess<'de>,
4818 {
4819 let mut column_subsets__ = None;
4820 while let Some(k) = map_.next_key()? {
4821 match k {
4822 GeneratedField::ColumnSubsets => {
4823 if column_subsets__.is_some() {
4824 return Err(serde::de::Error::duplicate_field("columnSubsets"));
4825 }
4826 column_subsets__ = Some(map_.next_value()?);
4827 }
4828 }
4829 }
4830 Ok(ExpandNode {
4831 column_subsets: column_subsets__.unwrap_or_default(),
4832 })
4833 }
4834 }
4835 deserializer.deserialize_struct("stream_plan.ExpandNode", FIELDS, GeneratedVisitor)
4836 }
4837}
4838impl serde::Serialize for expand_node::Subset {
4839 #[allow(deprecated)]
4840 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4841 where
4842 S: serde::Serializer,
4843 {
4844 use serde::ser::SerializeStruct;
4845 let mut len = 0;
4846 if !self.column_indices.is_empty() {
4847 len += 1;
4848 }
4849 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode.Subset", len)?;
4850 if !self.column_indices.is_empty() {
4851 struct_ser.serialize_field("columnIndices", &self.column_indices)?;
4852 }
4853 struct_ser.end()
4854 }
4855}
4856impl<'de> serde::Deserialize<'de> for expand_node::Subset {
4857 #[allow(deprecated)]
4858 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4859 where
4860 D: serde::Deserializer<'de>,
4861 {
4862 const FIELDS: &[&str] = &[
4863 "column_indices",
4864 "columnIndices",
4865 ];
4866
4867 #[allow(clippy::enum_variant_names)]
4868 enum GeneratedField {
4869 ColumnIndices,
4870 }
4871 impl<'de> serde::Deserialize<'de> for GeneratedField {
4872 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4873 where
4874 D: serde::Deserializer<'de>,
4875 {
4876 struct GeneratedVisitor;
4877
4878 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4879 type Value = GeneratedField;
4880
4881 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4882 write!(formatter, "expected one of: {:?}", &FIELDS)
4883 }
4884
4885 #[allow(unused_variables)]
4886 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4887 where
4888 E: serde::de::Error,
4889 {
4890 match value {
4891 "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
4892 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4893 }
4894 }
4895 }
4896 deserializer.deserialize_identifier(GeneratedVisitor)
4897 }
4898 }
4899 struct GeneratedVisitor;
4900 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4901 type Value = expand_node::Subset;
4902
4903 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4904 formatter.write_str("struct stream_plan.ExpandNode.Subset")
4905 }
4906
4907 fn visit_map<V>(self, mut map_: V) -> std::result::Result<expand_node::Subset, V::Error>
4908 where
4909 V: serde::de::MapAccess<'de>,
4910 {
4911 let mut column_indices__ = None;
4912 while let Some(k) = map_.next_key()? {
4913 match k {
4914 GeneratedField::ColumnIndices => {
4915 if column_indices__.is_some() {
4916 return Err(serde::de::Error::duplicate_field("columnIndices"));
4917 }
4918 column_indices__ =
4919 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4920 .into_iter().map(|x| x.0).collect())
4921 ;
4922 }
4923 }
4924 }
4925 Ok(expand_node::Subset {
4926 column_indices: column_indices__.unwrap_or_default(),
4927 })
4928 }
4929 }
4930 deserializer.deserialize_struct("stream_plan.ExpandNode.Subset", FIELDS, GeneratedVisitor)
4931 }
4932}
4933impl serde::Serialize for FilterNode {
4934 #[allow(deprecated)]
4935 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4936 where
4937 S: serde::Serializer,
4938 {
4939 use serde::ser::SerializeStruct;
4940 let mut len = 0;
4941 if self.search_condition.is_some() {
4942 len += 1;
4943 }
4944 let mut struct_ser = serializer.serialize_struct("stream_plan.FilterNode", len)?;
4945 if let Some(v) = self.search_condition.as_ref() {
4946 struct_ser.serialize_field("searchCondition", v)?;
4947 }
4948 struct_ser.end()
4949 }
4950}
4951impl<'de> serde::Deserialize<'de> for FilterNode {
4952 #[allow(deprecated)]
4953 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4954 where
4955 D: serde::Deserializer<'de>,
4956 {
4957 const FIELDS: &[&str] = &[
4958 "search_condition",
4959 "searchCondition",
4960 ];
4961
4962 #[allow(clippy::enum_variant_names)]
4963 enum GeneratedField {
4964 SearchCondition,
4965 }
4966 impl<'de> serde::Deserialize<'de> for GeneratedField {
4967 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4968 where
4969 D: serde::Deserializer<'de>,
4970 {
4971 struct GeneratedVisitor;
4972
4973 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4974 type Value = GeneratedField;
4975
4976 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4977 write!(formatter, "expected one of: {:?}", &FIELDS)
4978 }
4979
4980 #[allow(unused_variables)]
4981 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4982 where
4983 E: serde::de::Error,
4984 {
4985 match value {
4986 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
4987 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4988 }
4989 }
4990 }
4991 deserializer.deserialize_identifier(GeneratedVisitor)
4992 }
4993 }
4994 struct GeneratedVisitor;
4995 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4996 type Value = FilterNode;
4997
4998 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4999 formatter.write_str("struct stream_plan.FilterNode")
5000 }
5001
5002 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FilterNode, V::Error>
5003 where
5004 V: serde::de::MapAccess<'de>,
5005 {
5006 let mut search_condition__ = None;
5007 while let Some(k) = map_.next_key()? {
5008 match k {
5009 GeneratedField::SearchCondition => {
5010 if search_condition__.is_some() {
5011 return Err(serde::de::Error::duplicate_field("searchCondition"));
5012 }
5013 search_condition__ = map_.next_value()?;
5014 }
5015 }
5016 }
5017 Ok(FilterNode {
5018 search_condition: search_condition__,
5019 })
5020 }
5021 }
5022 deserializer.deserialize_struct("stream_plan.FilterNode", FIELDS, GeneratedVisitor)
5023 }
5024}
5025impl serde::Serialize for GapFillNode {
5026 #[allow(deprecated)]
5027 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5028 where
5029 S: serde::Serializer,
5030 {
5031 use serde::ser::SerializeStruct;
5032 let mut len = 0;
5033 if self.time_column_index != 0 {
5034 len += 1;
5035 }
5036 if self.interval.is_some() {
5037 len += 1;
5038 }
5039 if !self.fill_columns.is_empty() {
5040 len += 1;
5041 }
5042 if !self.fill_strategies.is_empty() {
5043 len += 1;
5044 }
5045 if self.state_table.is_some() {
5046 len += 1;
5047 }
5048 let mut struct_ser = serializer.serialize_struct("stream_plan.GapFillNode", len)?;
5049 if self.time_column_index != 0 {
5050 struct_ser.serialize_field("timeColumnIndex", &self.time_column_index)?;
5051 }
5052 if let Some(v) = self.interval.as_ref() {
5053 struct_ser.serialize_field("interval", v)?;
5054 }
5055 if !self.fill_columns.is_empty() {
5056 struct_ser.serialize_field("fillColumns", &self.fill_columns)?;
5057 }
5058 if !self.fill_strategies.is_empty() {
5059 struct_ser.serialize_field("fillStrategies", &self.fill_strategies)?;
5060 }
5061 if let Some(v) = self.state_table.as_ref() {
5062 struct_ser.serialize_field("stateTable", v)?;
5063 }
5064 struct_ser.end()
5065 }
5066}
5067impl<'de> serde::Deserialize<'de> for GapFillNode {
5068 #[allow(deprecated)]
5069 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5070 where
5071 D: serde::Deserializer<'de>,
5072 {
5073 const FIELDS: &[&str] = &[
5074 "time_column_index",
5075 "timeColumnIndex",
5076 "interval",
5077 "fill_columns",
5078 "fillColumns",
5079 "fill_strategies",
5080 "fillStrategies",
5081 "state_table",
5082 "stateTable",
5083 ];
5084
5085 #[allow(clippy::enum_variant_names)]
5086 enum GeneratedField {
5087 TimeColumnIndex,
5088 Interval,
5089 FillColumns,
5090 FillStrategies,
5091 StateTable,
5092 }
5093 impl<'de> serde::Deserialize<'de> for GeneratedField {
5094 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5095 where
5096 D: serde::Deserializer<'de>,
5097 {
5098 struct GeneratedVisitor;
5099
5100 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5101 type Value = GeneratedField;
5102
5103 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5104 write!(formatter, "expected one of: {:?}", &FIELDS)
5105 }
5106
5107 #[allow(unused_variables)]
5108 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5109 where
5110 E: serde::de::Error,
5111 {
5112 match value {
5113 "timeColumnIndex" | "time_column_index" => Ok(GeneratedField::TimeColumnIndex),
5114 "interval" => Ok(GeneratedField::Interval),
5115 "fillColumns" | "fill_columns" => Ok(GeneratedField::FillColumns),
5116 "fillStrategies" | "fill_strategies" => Ok(GeneratedField::FillStrategies),
5117 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
5118 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5119 }
5120 }
5121 }
5122 deserializer.deserialize_identifier(GeneratedVisitor)
5123 }
5124 }
5125 struct GeneratedVisitor;
5126 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5127 type Value = GapFillNode;
5128
5129 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5130 formatter.write_str("struct stream_plan.GapFillNode")
5131 }
5132
5133 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GapFillNode, V::Error>
5134 where
5135 V: serde::de::MapAccess<'de>,
5136 {
5137 let mut time_column_index__ = None;
5138 let mut interval__ = None;
5139 let mut fill_columns__ = None;
5140 let mut fill_strategies__ = None;
5141 let mut state_table__ = None;
5142 while let Some(k) = map_.next_key()? {
5143 match k {
5144 GeneratedField::TimeColumnIndex => {
5145 if time_column_index__.is_some() {
5146 return Err(serde::de::Error::duplicate_field("timeColumnIndex"));
5147 }
5148 time_column_index__ =
5149 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5150 ;
5151 }
5152 GeneratedField::Interval => {
5153 if interval__.is_some() {
5154 return Err(serde::de::Error::duplicate_field("interval"));
5155 }
5156 interval__ = map_.next_value()?;
5157 }
5158 GeneratedField::FillColumns => {
5159 if fill_columns__.is_some() {
5160 return Err(serde::de::Error::duplicate_field("fillColumns"));
5161 }
5162 fill_columns__ =
5163 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5164 .into_iter().map(|x| x.0).collect())
5165 ;
5166 }
5167 GeneratedField::FillStrategies => {
5168 if fill_strategies__.is_some() {
5169 return Err(serde::de::Error::duplicate_field("fillStrategies"));
5170 }
5171 fill_strategies__ = Some(map_.next_value()?);
5172 }
5173 GeneratedField::StateTable => {
5174 if state_table__.is_some() {
5175 return Err(serde::de::Error::duplicate_field("stateTable"));
5176 }
5177 state_table__ = map_.next_value()?;
5178 }
5179 }
5180 }
5181 Ok(GapFillNode {
5182 time_column_index: time_column_index__.unwrap_or_default(),
5183 interval: interval__,
5184 fill_columns: fill_columns__.unwrap_or_default(),
5185 fill_strategies: fill_strategies__.unwrap_or_default(),
5186 state_table: state_table__,
5187 })
5188 }
5189 }
5190 deserializer.deserialize_struct("stream_plan.GapFillNode", FIELDS, GeneratedVisitor)
5191 }
5192}
5193impl serde::Serialize for GlobalApproxPercentileNode {
5194 #[allow(deprecated)]
5195 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5196 where
5197 S: serde::Serializer,
5198 {
5199 use serde::ser::SerializeStruct;
5200 let mut len = 0;
5201 if self.base != 0. {
5202 len += 1;
5203 }
5204 if self.quantile != 0. {
5205 len += 1;
5206 }
5207 if self.bucket_state_table.is_some() {
5208 len += 1;
5209 }
5210 if self.count_state_table.is_some() {
5211 len += 1;
5212 }
5213 let mut struct_ser = serializer.serialize_struct("stream_plan.GlobalApproxPercentileNode", len)?;
5214 if self.base != 0. {
5215 struct_ser.serialize_field("base", &self.base)?;
5216 }
5217 if self.quantile != 0. {
5218 struct_ser.serialize_field("quantile", &self.quantile)?;
5219 }
5220 if let Some(v) = self.bucket_state_table.as_ref() {
5221 struct_ser.serialize_field("bucketStateTable", v)?;
5222 }
5223 if let Some(v) = self.count_state_table.as_ref() {
5224 struct_ser.serialize_field("countStateTable", v)?;
5225 }
5226 struct_ser.end()
5227 }
5228}
5229impl<'de> serde::Deserialize<'de> for GlobalApproxPercentileNode {
5230 #[allow(deprecated)]
5231 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5232 where
5233 D: serde::Deserializer<'de>,
5234 {
5235 const FIELDS: &[&str] = &[
5236 "base",
5237 "quantile",
5238 "bucket_state_table",
5239 "bucketStateTable",
5240 "count_state_table",
5241 "countStateTable",
5242 ];
5243
5244 #[allow(clippy::enum_variant_names)]
5245 enum GeneratedField {
5246 Base,
5247 Quantile,
5248 BucketStateTable,
5249 CountStateTable,
5250 }
5251 impl<'de> serde::Deserialize<'de> for GeneratedField {
5252 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5253 where
5254 D: serde::Deserializer<'de>,
5255 {
5256 struct GeneratedVisitor;
5257
5258 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5259 type Value = GeneratedField;
5260
5261 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5262 write!(formatter, "expected one of: {:?}", &FIELDS)
5263 }
5264
5265 #[allow(unused_variables)]
5266 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5267 where
5268 E: serde::de::Error,
5269 {
5270 match value {
5271 "base" => Ok(GeneratedField::Base),
5272 "quantile" => Ok(GeneratedField::Quantile),
5273 "bucketStateTable" | "bucket_state_table" => Ok(GeneratedField::BucketStateTable),
5274 "countStateTable" | "count_state_table" => Ok(GeneratedField::CountStateTable),
5275 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5276 }
5277 }
5278 }
5279 deserializer.deserialize_identifier(GeneratedVisitor)
5280 }
5281 }
5282 struct GeneratedVisitor;
5283 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5284 type Value = GlobalApproxPercentileNode;
5285
5286 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5287 formatter.write_str("struct stream_plan.GlobalApproxPercentileNode")
5288 }
5289
5290 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GlobalApproxPercentileNode, V::Error>
5291 where
5292 V: serde::de::MapAccess<'de>,
5293 {
5294 let mut base__ = None;
5295 let mut quantile__ = None;
5296 let mut bucket_state_table__ = None;
5297 let mut count_state_table__ = None;
5298 while let Some(k) = map_.next_key()? {
5299 match k {
5300 GeneratedField::Base => {
5301 if base__.is_some() {
5302 return Err(serde::de::Error::duplicate_field("base"));
5303 }
5304 base__ =
5305 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5306 ;
5307 }
5308 GeneratedField::Quantile => {
5309 if quantile__.is_some() {
5310 return Err(serde::de::Error::duplicate_field("quantile"));
5311 }
5312 quantile__ =
5313 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5314 ;
5315 }
5316 GeneratedField::BucketStateTable => {
5317 if bucket_state_table__.is_some() {
5318 return Err(serde::de::Error::duplicate_field("bucketStateTable"));
5319 }
5320 bucket_state_table__ = map_.next_value()?;
5321 }
5322 GeneratedField::CountStateTable => {
5323 if count_state_table__.is_some() {
5324 return Err(serde::de::Error::duplicate_field("countStateTable"));
5325 }
5326 count_state_table__ = map_.next_value()?;
5327 }
5328 }
5329 }
5330 Ok(GlobalApproxPercentileNode {
5331 base: base__.unwrap_or_default(),
5332 quantile: quantile__.unwrap_or_default(),
5333 bucket_state_table: bucket_state_table__,
5334 count_state_table: count_state_table__,
5335 })
5336 }
5337 }
5338 deserializer.deserialize_struct("stream_plan.GlobalApproxPercentileNode", FIELDS, GeneratedVisitor)
5339 }
5340}
5341impl serde::Serialize for GroupTopNNode {
5342 #[allow(deprecated)]
5343 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5344 where
5345 S: serde::Serializer,
5346 {
5347 use serde::ser::SerializeStruct;
5348 let mut len = 0;
5349 if self.limit != 0 {
5350 len += 1;
5351 }
5352 if self.offset != 0 {
5353 len += 1;
5354 }
5355 if !self.group_key.is_empty() {
5356 len += 1;
5357 }
5358 if self.table.is_some() {
5359 len += 1;
5360 }
5361 if !self.order_by.is_empty() {
5362 len += 1;
5363 }
5364 if self.with_ties {
5365 len += 1;
5366 }
5367 let mut struct_ser = serializer.serialize_struct("stream_plan.GroupTopNNode", len)?;
5368 if self.limit != 0 {
5369 #[allow(clippy::needless_borrow)]
5370 #[allow(clippy::needless_borrows_for_generic_args)]
5371 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
5372 }
5373 if self.offset != 0 {
5374 #[allow(clippy::needless_borrow)]
5375 #[allow(clippy::needless_borrows_for_generic_args)]
5376 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
5377 }
5378 if !self.group_key.is_empty() {
5379 struct_ser.serialize_field("groupKey", &self.group_key)?;
5380 }
5381 if let Some(v) = self.table.as_ref() {
5382 struct_ser.serialize_field("table", v)?;
5383 }
5384 if !self.order_by.is_empty() {
5385 struct_ser.serialize_field("orderBy", &self.order_by)?;
5386 }
5387 if self.with_ties {
5388 struct_ser.serialize_field("withTies", &self.with_ties)?;
5389 }
5390 struct_ser.end()
5391 }
5392}
5393impl<'de> serde::Deserialize<'de> for GroupTopNNode {
5394 #[allow(deprecated)]
5395 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5396 where
5397 D: serde::Deserializer<'de>,
5398 {
5399 const FIELDS: &[&str] = &[
5400 "limit",
5401 "offset",
5402 "group_key",
5403 "groupKey",
5404 "table",
5405 "order_by",
5406 "orderBy",
5407 "with_ties",
5408 "withTies",
5409 ];
5410
5411 #[allow(clippy::enum_variant_names)]
5412 enum GeneratedField {
5413 Limit,
5414 Offset,
5415 GroupKey,
5416 Table,
5417 OrderBy,
5418 WithTies,
5419 }
5420 impl<'de> serde::Deserialize<'de> for GeneratedField {
5421 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5422 where
5423 D: serde::Deserializer<'de>,
5424 {
5425 struct GeneratedVisitor;
5426
5427 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5428 type Value = GeneratedField;
5429
5430 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5431 write!(formatter, "expected one of: {:?}", &FIELDS)
5432 }
5433
5434 #[allow(unused_variables)]
5435 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5436 where
5437 E: serde::de::Error,
5438 {
5439 match value {
5440 "limit" => Ok(GeneratedField::Limit),
5441 "offset" => Ok(GeneratedField::Offset),
5442 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5443 "table" => Ok(GeneratedField::Table),
5444 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
5445 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
5446 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5447 }
5448 }
5449 }
5450 deserializer.deserialize_identifier(GeneratedVisitor)
5451 }
5452 }
5453 struct GeneratedVisitor;
5454 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5455 type Value = GroupTopNNode;
5456
5457 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5458 formatter.write_str("struct stream_plan.GroupTopNNode")
5459 }
5460
5461 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupTopNNode, V::Error>
5462 where
5463 V: serde::de::MapAccess<'de>,
5464 {
5465 let mut limit__ = None;
5466 let mut offset__ = None;
5467 let mut group_key__ = None;
5468 let mut table__ = None;
5469 let mut order_by__ = None;
5470 let mut with_ties__ = None;
5471 while let Some(k) = map_.next_key()? {
5472 match k {
5473 GeneratedField::Limit => {
5474 if limit__.is_some() {
5475 return Err(serde::de::Error::duplicate_field("limit"));
5476 }
5477 limit__ =
5478 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5479 ;
5480 }
5481 GeneratedField::Offset => {
5482 if offset__.is_some() {
5483 return Err(serde::de::Error::duplicate_field("offset"));
5484 }
5485 offset__ =
5486 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5487 ;
5488 }
5489 GeneratedField::GroupKey => {
5490 if group_key__.is_some() {
5491 return Err(serde::de::Error::duplicate_field("groupKey"));
5492 }
5493 group_key__ =
5494 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5495 .into_iter().map(|x| x.0).collect())
5496 ;
5497 }
5498 GeneratedField::Table => {
5499 if table__.is_some() {
5500 return Err(serde::de::Error::duplicate_field("table"));
5501 }
5502 table__ = map_.next_value()?;
5503 }
5504 GeneratedField::OrderBy => {
5505 if order_by__.is_some() {
5506 return Err(serde::de::Error::duplicate_field("orderBy"));
5507 }
5508 order_by__ = Some(map_.next_value()?);
5509 }
5510 GeneratedField::WithTies => {
5511 if with_ties__.is_some() {
5512 return Err(serde::de::Error::duplicate_field("withTies"));
5513 }
5514 with_ties__ = Some(map_.next_value()?);
5515 }
5516 }
5517 }
5518 Ok(GroupTopNNode {
5519 limit: limit__.unwrap_or_default(),
5520 offset: offset__.unwrap_or_default(),
5521 group_key: group_key__.unwrap_or_default(),
5522 table: table__,
5523 order_by: order_by__.unwrap_or_default(),
5524 with_ties: with_ties__.unwrap_or_default(),
5525 })
5526 }
5527 }
5528 deserializer.deserialize_struct("stream_plan.GroupTopNNode", FIELDS, GeneratedVisitor)
5529 }
5530}
5531impl serde::Serialize for HashAggNode {
5532 #[allow(deprecated)]
5533 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5534 where
5535 S: serde::Serializer,
5536 {
5537 use serde::ser::SerializeStruct;
5538 let mut len = 0;
5539 if !self.group_key.is_empty() {
5540 len += 1;
5541 }
5542 if !self.agg_calls.is_empty() {
5543 len += 1;
5544 }
5545 if !self.agg_call_states.is_empty() {
5546 len += 1;
5547 }
5548 if self.intermediate_state_table.is_some() {
5549 len += 1;
5550 }
5551 if self.is_append_only {
5552 len += 1;
5553 }
5554 if !self.distinct_dedup_tables.is_empty() {
5555 len += 1;
5556 }
5557 if self.row_count_index != 0 {
5558 len += 1;
5559 }
5560 if self.emit_on_window_close {
5561 len += 1;
5562 }
5563 if self.version != 0 {
5564 len += 1;
5565 }
5566 let mut struct_ser = serializer.serialize_struct("stream_plan.HashAggNode", len)?;
5567 if !self.group_key.is_empty() {
5568 struct_ser.serialize_field("groupKey", &self.group_key)?;
5569 }
5570 if !self.agg_calls.is_empty() {
5571 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
5572 }
5573 if !self.agg_call_states.is_empty() {
5574 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
5575 }
5576 if let Some(v) = self.intermediate_state_table.as_ref() {
5577 struct_ser.serialize_field("intermediateStateTable", v)?;
5578 }
5579 if self.is_append_only {
5580 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5581 }
5582 if !self.distinct_dedup_tables.is_empty() {
5583 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
5584 }
5585 if self.row_count_index != 0 {
5586 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
5587 }
5588 if self.emit_on_window_close {
5589 struct_ser.serialize_field("emitOnWindowClose", &self.emit_on_window_close)?;
5590 }
5591 if self.version != 0 {
5592 let v = AggNodeVersion::try_from(self.version)
5593 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
5594 struct_ser.serialize_field("version", &v)?;
5595 }
5596 struct_ser.end()
5597 }
5598}
5599impl<'de> serde::Deserialize<'de> for HashAggNode {
5600 #[allow(deprecated)]
5601 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5602 where
5603 D: serde::Deserializer<'de>,
5604 {
5605 const FIELDS: &[&str] = &[
5606 "group_key",
5607 "groupKey",
5608 "agg_calls",
5609 "aggCalls",
5610 "agg_call_states",
5611 "aggCallStates",
5612 "intermediate_state_table",
5613 "intermediateStateTable",
5614 "is_append_only",
5615 "isAppendOnly",
5616 "distinct_dedup_tables",
5617 "distinctDedupTables",
5618 "row_count_index",
5619 "rowCountIndex",
5620 "emit_on_window_close",
5621 "emitOnWindowClose",
5622 "version",
5623 ];
5624
5625 #[allow(clippy::enum_variant_names)]
5626 enum GeneratedField {
5627 GroupKey,
5628 AggCalls,
5629 AggCallStates,
5630 IntermediateStateTable,
5631 IsAppendOnly,
5632 DistinctDedupTables,
5633 RowCountIndex,
5634 EmitOnWindowClose,
5635 Version,
5636 }
5637 impl<'de> serde::Deserialize<'de> for GeneratedField {
5638 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5639 where
5640 D: serde::Deserializer<'de>,
5641 {
5642 struct GeneratedVisitor;
5643
5644 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5645 type Value = GeneratedField;
5646
5647 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5648 write!(formatter, "expected one of: {:?}", &FIELDS)
5649 }
5650
5651 #[allow(unused_variables)]
5652 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5653 where
5654 E: serde::de::Error,
5655 {
5656 match value {
5657 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5658 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
5659 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
5660 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
5661 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5662 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
5663 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
5664 "emitOnWindowClose" | "emit_on_window_close" => Ok(GeneratedField::EmitOnWindowClose),
5665 "version" => Ok(GeneratedField::Version),
5666 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5667 }
5668 }
5669 }
5670 deserializer.deserialize_identifier(GeneratedVisitor)
5671 }
5672 }
5673 struct GeneratedVisitor;
5674 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5675 type Value = HashAggNode;
5676
5677 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5678 formatter.write_str("struct stream_plan.HashAggNode")
5679 }
5680
5681 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashAggNode, V::Error>
5682 where
5683 V: serde::de::MapAccess<'de>,
5684 {
5685 let mut group_key__ = None;
5686 let mut agg_calls__ = None;
5687 let mut agg_call_states__ = None;
5688 let mut intermediate_state_table__ = None;
5689 let mut is_append_only__ = None;
5690 let mut distinct_dedup_tables__ = None;
5691 let mut row_count_index__ = None;
5692 let mut emit_on_window_close__ = None;
5693 let mut version__ = None;
5694 while let Some(k) = map_.next_key()? {
5695 match k {
5696 GeneratedField::GroupKey => {
5697 if group_key__.is_some() {
5698 return Err(serde::de::Error::duplicate_field("groupKey"));
5699 }
5700 group_key__ =
5701 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5702 .into_iter().map(|x| x.0).collect())
5703 ;
5704 }
5705 GeneratedField::AggCalls => {
5706 if agg_calls__.is_some() {
5707 return Err(serde::de::Error::duplicate_field("aggCalls"));
5708 }
5709 agg_calls__ = Some(map_.next_value()?);
5710 }
5711 GeneratedField::AggCallStates => {
5712 if agg_call_states__.is_some() {
5713 return Err(serde::de::Error::duplicate_field("aggCallStates"));
5714 }
5715 agg_call_states__ = Some(map_.next_value()?);
5716 }
5717 GeneratedField::IntermediateStateTable => {
5718 if intermediate_state_table__.is_some() {
5719 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
5720 }
5721 intermediate_state_table__ = map_.next_value()?;
5722 }
5723 GeneratedField::IsAppendOnly => {
5724 if is_append_only__.is_some() {
5725 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
5726 }
5727 is_append_only__ = Some(map_.next_value()?);
5728 }
5729 GeneratedField::DistinctDedupTables => {
5730 if distinct_dedup_tables__.is_some() {
5731 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
5732 }
5733 distinct_dedup_tables__ = Some(
5734 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5735 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
5736 );
5737 }
5738 GeneratedField::RowCountIndex => {
5739 if row_count_index__.is_some() {
5740 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
5741 }
5742 row_count_index__ =
5743 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5744 ;
5745 }
5746 GeneratedField::EmitOnWindowClose => {
5747 if emit_on_window_close__.is_some() {
5748 return Err(serde::de::Error::duplicate_field("emitOnWindowClose"));
5749 }
5750 emit_on_window_close__ = Some(map_.next_value()?);
5751 }
5752 GeneratedField::Version => {
5753 if version__.is_some() {
5754 return Err(serde::de::Error::duplicate_field("version"));
5755 }
5756 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
5757 }
5758 }
5759 }
5760 Ok(HashAggNode {
5761 group_key: group_key__.unwrap_or_default(),
5762 agg_calls: agg_calls__.unwrap_or_default(),
5763 agg_call_states: agg_call_states__.unwrap_or_default(),
5764 intermediate_state_table: intermediate_state_table__,
5765 is_append_only: is_append_only__.unwrap_or_default(),
5766 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
5767 row_count_index: row_count_index__.unwrap_or_default(),
5768 emit_on_window_close: emit_on_window_close__.unwrap_or_default(),
5769 version: version__.unwrap_or_default(),
5770 })
5771 }
5772 }
5773 deserializer.deserialize_struct("stream_plan.HashAggNode", FIELDS, GeneratedVisitor)
5774 }
5775}
5776impl serde::Serialize for HashJoinNode {
5777 #[allow(deprecated)]
5778 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5779 where
5780 S: serde::Serializer,
5781 {
5782 use serde::ser::SerializeStruct;
5783 let mut len = 0;
5784 if self.join_type != 0 {
5785 len += 1;
5786 }
5787 if !self.left_key.is_empty() {
5788 len += 1;
5789 }
5790 if !self.right_key.is_empty() {
5791 len += 1;
5792 }
5793 if self.condition.is_some() {
5794 len += 1;
5795 }
5796 if !self.inequality_pairs.is_empty() {
5797 len += 1;
5798 }
5799 if self.left_table.is_some() {
5800 len += 1;
5801 }
5802 if self.right_table.is_some() {
5803 len += 1;
5804 }
5805 if self.left_degree_table.is_some() {
5806 len += 1;
5807 }
5808 if self.right_degree_table.is_some() {
5809 len += 1;
5810 }
5811 if !self.output_indices.is_empty() {
5812 len += 1;
5813 }
5814 if !self.left_deduped_input_pk_indices.is_empty() {
5815 len += 1;
5816 }
5817 if !self.right_deduped_input_pk_indices.is_empty() {
5818 len += 1;
5819 }
5820 if !self.null_safe.is_empty() {
5821 len += 1;
5822 }
5823 if self.is_append_only {
5824 len += 1;
5825 }
5826 if self.join_encoding_type != 0 {
5827 len += 1;
5828 }
5829 let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinNode", len)?;
5830 if self.join_type != 0 {
5831 let v = super::plan_common::JoinType::try_from(self.join_type)
5832 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
5833 struct_ser.serialize_field("joinType", &v)?;
5834 }
5835 if !self.left_key.is_empty() {
5836 struct_ser.serialize_field("leftKey", &self.left_key)?;
5837 }
5838 if !self.right_key.is_empty() {
5839 struct_ser.serialize_field("rightKey", &self.right_key)?;
5840 }
5841 if let Some(v) = self.condition.as_ref() {
5842 struct_ser.serialize_field("condition", v)?;
5843 }
5844 if !self.inequality_pairs.is_empty() {
5845 struct_ser.serialize_field("inequalityPairs", &self.inequality_pairs)?;
5846 }
5847 if let Some(v) = self.left_table.as_ref() {
5848 struct_ser.serialize_field("leftTable", v)?;
5849 }
5850 if let Some(v) = self.right_table.as_ref() {
5851 struct_ser.serialize_field("rightTable", v)?;
5852 }
5853 if let Some(v) = self.left_degree_table.as_ref() {
5854 struct_ser.serialize_field("leftDegreeTable", v)?;
5855 }
5856 if let Some(v) = self.right_degree_table.as_ref() {
5857 struct_ser.serialize_field("rightDegreeTable", v)?;
5858 }
5859 if !self.output_indices.is_empty() {
5860 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
5861 }
5862 if !self.left_deduped_input_pk_indices.is_empty() {
5863 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
5864 }
5865 if !self.right_deduped_input_pk_indices.is_empty() {
5866 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
5867 }
5868 if !self.null_safe.is_empty() {
5869 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
5870 }
5871 if self.is_append_only {
5872 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5873 }
5874 if self.join_encoding_type != 0 {
5875 let v = JoinEncodingType::try_from(self.join_encoding_type)
5876 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
5877 struct_ser.serialize_field("joinEncodingType", &v)?;
5878 }
5879 struct_ser.end()
5880 }
5881}
5882impl<'de> serde::Deserialize<'de> for HashJoinNode {
5883 #[allow(deprecated)]
5884 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5885 where
5886 D: serde::Deserializer<'de>,
5887 {
5888 const FIELDS: &[&str] = &[
5889 "join_type",
5890 "joinType",
5891 "left_key",
5892 "leftKey",
5893 "right_key",
5894 "rightKey",
5895 "condition",
5896 "inequality_pairs",
5897 "inequalityPairs",
5898 "left_table",
5899 "leftTable",
5900 "right_table",
5901 "rightTable",
5902 "left_degree_table",
5903 "leftDegreeTable",
5904 "right_degree_table",
5905 "rightDegreeTable",
5906 "output_indices",
5907 "outputIndices",
5908 "left_deduped_input_pk_indices",
5909 "leftDedupedInputPkIndices",
5910 "right_deduped_input_pk_indices",
5911 "rightDedupedInputPkIndices",
5912 "null_safe",
5913 "nullSafe",
5914 "is_append_only",
5915 "isAppendOnly",
5916 "join_encoding_type",
5917 "joinEncodingType",
5918 ];
5919
5920 #[allow(clippy::enum_variant_names)]
5921 enum GeneratedField {
5922 JoinType,
5923 LeftKey,
5924 RightKey,
5925 Condition,
5926 InequalityPairs,
5927 LeftTable,
5928 RightTable,
5929 LeftDegreeTable,
5930 RightDegreeTable,
5931 OutputIndices,
5932 LeftDedupedInputPkIndices,
5933 RightDedupedInputPkIndices,
5934 NullSafe,
5935 IsAppendOnly,
5936 JoinEncodingType,
5937 }
5938 impl<'de> serde::Deserialize<'de> for GeneratedField {
5939 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5940 where
5941 D: serde::Deserializer<'de>,
5942 {
5943 struct GeneratedVisitor;
5944
5945 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5946 type Value = GeneratedField;
5947
5948 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5949 write!(formatter, "expected one of: {:?}", &FIELDS)
5950 }
5951
5952 #[allow(unused_variables)]
5953 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5954 where
5955 E: serde::de::Error,
5956 {
5957 match value {
5958 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
5959 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
5960 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
5961 "condition" => Ok(GeneratedField::Condition),
5962 "inequalityPairs" | "inequality_pairs" => Ok(GeneratedField::InequalityPairs),
5963 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
5964 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
5965 "leftDegreeTable" | "left_degree_table" => Ok(GeneratedField::LeftDegreeTable),
5966 "rightDegreeTable" | "right_degree_table" => Ok(GeneratedField::RightDegreeTable),
5967 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
5968 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
5969 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
5970 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
5971 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5972 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
5973 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5974 }
5975 }
5976 }
5977 deserializer.deserialize_identifier(GeneratedVisitor)
5978 }
5979 }
5980 struct GeneratedVisitor;
5981 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5982 type Value = HashJoinNode;
5983
5984 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5985 formatter.write_str("struct stream_plan.HashJoinNode")
5986 }
5987
5988 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinNode, V::Error>
5989 where
5990 V: serde::de::MapAccess<'de>,
5991 {
5992 let mut join_type__ = None;
5993 let mut left_key__ = None;
5994 let mut right_key__ = None;
5995 let mut condition__ = None;
5996 let mut inequality_pairs__ = None;
5997 let mut left_table__ = None;
5998 let mut right_table__ = None;
5999 let mut left_degree_table__ = None;
6000 let mut right_degree_table__ = None;
6001 let mut output_indices__ = None;
6002 let mut left_deduped_input_pk_indices__ = None;
6003 let mut right_deduped_input_pk_indices__ = None;
6004 let mut null_safe__ = None;
6005 let mut is_append_only__ = None;
6006 let mut join_encoding_type__ = None;
6007 while let Some(k) = map_.next_key()? {
6008 match k {
6009 GeneratedField::JoinType => {
6010 if join_type__.is_some() {
6011 return Err(serde::de::Error::duplicate_field("joinType"));
6012 }
6013 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
6014 }
6015 GeneratedField::LeftKey => {
6016 if left_key__.is_some() {
6017 return Err(serde::de::Error::duplicate_field("leftKey"));
6018 }
6019 left_key__ =
6020 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6021 .into_iter().map(|x| x.0).collect())
6022 ;
6023 }
6024 GeneratedField::RightKey => {
6025 if right_key__.is_some() {
6026 return Err(serde::de::Error::duplicate_field("rightKey"));
6027 }
6028 right_key__ =
6029 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6030 .into_iter().map(|x| x.0).collect())
6031 ;
6032 }
6033 GeneratedField::Condition => {
6034 if condition__.is_some() {
6035 return Err(serde::de::Error::duplicate_field("condition"));
6036 }
6037 condition__ = map_.next_value()?;
6038 }
6039 GeneratedField::InequalityPairs => {
6040 if inequality_pairs__.is_some() {
6041 return Err(serde::de::Error::duplicate_field("inequalityPairs"));
6042 }
6043 inequality_pairs__ = Some(map_.next_value()?);
6044 }
6045 GeneratedField::LeftTable => {
6046 if left_table__.is_some() {
6047 return Err(serde::de::Error::duplicate_field("leftTable"));
6048 }
6049 left_table__ = map_.next_value()?;
6050 }
6051 GeneratedField::RightTable => {
6052 if right_table__.is_some() {
6053 return Err(serde::de::Error::duplicate_field("rightTable"));
6054 }
6055 right_table__ = map_.next_value()?;
6056 }
6057 GeneratedField::LeftDegreeTable => {
6058 if left_degree_table__.is_some() {
6059 return Err(serde::de::Error::duplicate_field("leftDegreeTable"));
6060 }
6061 left_degree_table__ = map_.next_value()?;
6062 }
6063 GeneratedField::RightDegreeTable => {
6064 if right_degree_table__.is_some() {
6065 return Err(serde::de::Error::duplicate_field("rightDegreeTable"));
6066 }
6067 right_degree_table__ = map_.next_value()?;
6068 }
6069 GeneratedField::OutputIndices => {
6070 if output_indices__.is_some() {
6071 return Err(serde::de::Error::duplicate_field("outputIndices"));
6072 }
6073 output_indices__ =
6074 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6075 .into_iter().map(|x| x.0).collect())
6076 ;
6077 }
6078 GeneratedField::LeftDedupedInputPkIndices => {
6079 if left_deduped_input_pk_indices__.is_some() {
6080 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
6081 }
6082 left_deduped_input_pk_indices__ =
6083 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6084 .into_iter().map(|x| x.0).collect())
6085 ;
6086 }
6087 GeneratedField::RightDedupedInputPkIndices => {
6088 if right_deduped_input_pk_indices__.is_some() {
6089 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
6090 }
6091 right_deduped_input_pk_indices__ =
6092 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6093 .into_iter().map(|x| x.0).collect())
6094 ;
6095 }
6096 GeneratedField::NullSafe => {
6097 if null_safe__.is_some() {
6098 return Err(serde::de::Error::duplicate_field("nullSafe"));
6099 }
6100 null_safe__ = Some(map_.next_value()?);
6101 }
6102 GeneratedField::IsAppendOnly => {
6103 if is_append_only__.is_some() {
6104 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
6105 }
6106 is_append_only__ = Some(map_.next_value()?);
6107 }
6108 GeneratedField::JoinEncodingType => {
6109 if join_encoding_type__.is_some() {
6110 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
6111 }
6112 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
6113 }
6114 }
6115 }
6116 Ok(HashJoinNode {
6117 join_type: join_type__.unwrap_or_default(),
6118 left_key: left_key__.unwrap_or_default(),
6119 right_key: right_key__.unwrap_or_default(),
6120 condition: condition__,
6121 inequality_pairs: inequality_pairs__.unwrap_or_default(),
6122 left_table: left_table__,
6123 right_table: right_table__,
6124 left_degree_table: left_degree_table__,
6125 right_degree_table: right_degree_table__,
6126 output_indices: output_indices__.unwrap_or_default(),
6127 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
6128 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
6129 null_safe: null_safe__.unwrap_or_default(),
6130 is_append_only: is_append_only__.unwrap_or_default(),
6131 join_encoding_type: join_encoding_type__.unwrap_or_default(),
6132 })
6133 }
6134 }
6135 deserializer.deserialize_struct("stream_plan.HashJoinNode", FIELDS, GeneratedVisitor)
6136 }
6137}
6138impl serde::Serialize for HopWindowNode {
6139 #[allow(deprecated)]
6140 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6141 where
6142 S: serde::Serializer,
6143 {
6144 use serde::ser::SerializeStruct;
6145 let mut len = 0;
6146 if self.time_col != 0 {
6147 len += 1;
6148 }
6149 if self.window_slide.is_some() {
6150 len += 1;
6151 }
6152 if self.window_size.is_some() {
6153 len += 1;
6154 }
6155 if !self.output_indices.is_empty() {
6156 len += 1;
6157 }
6158 if !self.window_start_exprs.is_empty() {
6159 len += 1;
6160 }
6161 if !self.window_end_exprs.is_empty() {
6162 len += 1;
6163 }
6164 let mut struct_ser = serializer.serialize_struct("stream_plan.HopWindowNode", len)?;
6165 if self.time_col != 0 {
6166 struct_ser.serialize_field("timeCol", &self.time_col)?;
6167 }
6168 if let Some(v) = self.window_slide.as_ref() {
6169 struct_ser.serialize_field("windowSlide", v)?;
6170 }
6171 if let Some(v) = self.window_size.as_ref() {
6172 struct_ser.serialize_field("windowSize", v)?;
6173 }
6174 if !self.output_indices.is_empty() {
6175 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
6176 }
6177 if !self.window_start_exprs.is_empty() {
6178 struct_ser.serialize_field("windowStartExprs", &self.window_start_exprs)?;
6179 }
6180 if !self.window_end_exprs.is_empty() {
6181 struct_ser.serialize_field("windowEndExprs", &self.window_end_exprs)?;
6182 }
6183 struct_ser.end()
6184 }
6185}
6186impl<'de> serde::Deserialize<'de> for HopWindowNode {
6187 #[allow(deprecated)]
6188 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6189 where
6190 D: serde::Deserializer<'de>,
6191 {
6192 const FIELDS: &[&str] = &[
6193 "time_col",
6194 "timeCol",
6195 "window_slide",
6196 "windowSlide",
6197 "window_size",
6198 "windowSize",
6199 "output_indices",
6200 "outputIndices",
6201 "window_start_exprs",
6202 "windowStartExprs",
6203 "window_end_exprs",
6204 "windowEndExprs",
6205 ];
6206
6207 #[allow(clippy::enum_variant_names)]
6208 enum GeneratedField {
6209 TimeCol,
6210 WindowSlide,
6211 WindowSize,
6212 OutputIndices,
6213 WindowStartExprs,
6214 WindowEndExprs,
6215 }
6216 impl<'de> serde::Deserialize<'de> for GeneratedField {
6217 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6218 where
6219 D: serde::Deserializer<'de>,
6220 {
6221 struct GeneratedVisitor;
6222
6223 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6224 type Value = GeneratedField;
6225
6226 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6227 write!(formatter, "expected one of: {:?}", &FIELDS)
6228 }
6229
6230 #[allow(unused_variables)]
6231 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6232 where
6233 E: serde::de::Error,
6234 {
6235 match value {
6236 "timeCol" | "time_col" => Ok(GeneratedField::TimeCol),
6237 "windowSlide" | "window_slide" => Ok(GeneratedField::WindowSlide),
6238 "windowSize" | "window_size" => Ok(GeneratedField::WindowSize),
6239 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
6240 "windowStartExprs" | "window_start_exprs" => Ok(GeneratedField::WindowStartExprs),
6241 "windowEndExprs" | "window_end_exprs" => Ok(GeneratedField::WindowEndExprs),
6242 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6243 }
6244 }
6245 }
6246 deserializer.deserialize_identifier(GeneratedVisitor)
6247 }
6248 }
6249 struct GeneratedVisitor;
6250 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6251 type Value = HopWindowNode;
6252
6253 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6254 formatter.write_str("struct stream_plan.HopWindowNode")
6255 }
6256
6257 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HopWindowNode, V::Error>
6258 where
6259 V: serde::de::MapAccess<'de>,
6260 {
6261 let mut time_col__ = None;
6262 let mut window_slide__ = None;
6263 let mut window_size__ = None;
6264 let mut output_indices__ = None;
6265 let mut window_start_exprs__ = None;
6266 let mut window_end_exprs__ = None;
6267 while let Some(k) = map_.next_key()? {
6268 match k {
6269 GeneratedField::TimeCol => {
6270 if time_col__.is_some() {
6271 return Err(serde::de::Error::duplicate_field("timeCol"));
6272 }
6273 time_col__ =
6274 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6275 ;
6276 }
6277 GeneratedField::WindowSlide => {
6278 if window_slide__.is_some() {
6279 return Err(serde::de::Error::duplicate_field("windowSlide"));
6280 }
6281 window_slide__ = map_.next_value()?;
6282 }
6283 GeneratedField::WindowSize => {
6284 if window_size__.is_some() {
6285 return Err(serde::de::Error::duplicate_field("windowSize"));
6286 }
6287 window_size__ = map_.next_value()?;
6288 }
6289 GeneratedField::OutputIndices => {
6290 if output_indices__.is_some() {
6291 return Err(serde::de::Error::duplicate_field("outputIndices"));
6292 }
6293 output_indices__ =
6294 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6295 .into_iter().map(|x| x.0).collect())
6296 ;
6297 }
6298 GeneratedField::WindowStartExprs => {
6299 if window_start_exprs__.is_some() {
6300 return Err(serde::de::Error::duplicate_field("windowStartExprs"));
6301 }
6302 window_start_exprs__ = Some(map_.next_value()?);
6303 }
6304 GeneratedField::WindowEndExprs => {
6305 if window_end_exprs__.is_some() {
6306 return Err(serde::de::Error::duplicate_field("windowEndExprs"));
6307 }
6308 window_end_exprs__ = Some(map_.next_value()?);
6309 }
6310 }
6311 }
6312 Ok(HopWindowNode {
6313 time_col: time_col__.unwrap_or_default(),
6314 window_slide: window_slide__,
6315 window_size: window_size__,
6316 output_indices: output_indices__.unwrap_or_default(),
6317 window_start_exprs: window_start_exprs__.unwrap_or_default(),
6318 window_end_exprs: window_end_exprs__.unwrap_or_default(),
6319 })
6320 }
6321 }
6322 deserializer.deserialize_struct("stream_plan.HopWindowNode", FIELDS, GeneratedVisitor)
6323 }
6324}
6325impl serde::Serialize for InequalityPair {
6326 #[allow(deprecated)]
6327 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6328 where
6329 S: serde::Serializer,
6330 {
6331 use serde::ser::SerializeStruct;
6332 let mut len = 0;
6333 if self.key_required_larger != 0 {
6334 len += 1;
6335 }
6336 if self.key_required_smaller != 0 {
6337 len += 1;
6338 }
6339 if self.clean_state {
6340 len += 1;
6341 }
6342 if self.delta_expression.is_some() {
6343 len += 1;
6344 }
6345 let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPair", len)?;
6346 if self.key_required_larger != 0 {
6347 struct_ser.serialize_field("keyRequiredLarger", &self.key_required_larger)?;
6348 }
6349 if self.key_required_smaller != 0 {
6350 struct_ser.serialize_field("keyRequiredSmaller", &self.key_required_smaller)?;
6351 }
6352 if self.clean_state {
6353 struct_ser.serialize_field("cleanState", &self.clean_state)?;
6354 }
6355 if let Some(v) = self.delta_expression.as_ref() {
6356 struct_ser.serialize_field("deltaExpression", v)?;
6357 }
6358 struct_ser.end()
6359 }
6360}
6361impl<'de> serde::Deserialize<'de> for InequalityPair {
6362 #[allow(deprecated)]
6363 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6364 where
6365 D: serde::Deserializer<'de>,
6366 {
6367 const FIELDS: &[&str] = &[
6368 "key_required_larger",
6369 "keyRequiredLarger",
6370 "key_required_smaller",
6371 "keyRequiredSmaller",
6372 "clean_state",
6373 "cleanState",
6374 "delta_expression",
6375 "deltaExpression",
6376 ];
6377
6378 #[allow(clippy::enum_variant_names)]
6379 enum GeneratedField {
6380 KeyRequiredLarger,
6381 KeyRequiredSmaller,
6382 CleanState,
6383 DeltaExpression,
6384 }
6385 impl<'de> serde::Deserialize<'de> for GeneratedField {
6386 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6387 where
6388 D: serde::Deserializer<'de>,
6389 {
6390 struct GeneratedVisitor;
6391
6392 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6393 type Value = GeneratedField;
6394
6395 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6396 write!(formatter, "expected one of: {:?}", &FIELDS)
6397 }
6398
6399 #[allow(unused_variables)]
6400 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6401 where
6402 E: serde::de::Error,
6403 {
6404 match value {
6405 "keyRequiredLarger" | "key_required_larger" => Ok(GeneratedField::KeyRequiredLarger),
6406 "keyRequiredSmaller" | "key_required_smaller" => Ok(GeneratedField::KeyRequiredSmaller),
6407 "cleanState" | "clean_state" => Ok(GeneratedField::CleanState),
6408 "deltaExpression" | "delta_expression" => Ok(GeneratedField::DeltaExpression),
6409 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6410 }
6411 }
6412 }
6413 deserializer.deserialize_identifier(GeneratedVisitor)
6414 }
6415 }
6416 struct GeneratedVisitor;
6417 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6418 type Value = InequalityPair;
6419
6420 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6421 formatter.write_str("struct stream_plan.InequalityPair")
6422 }
6423
6424 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPair, V::Error>
6425 where
6426 V: serde::de::MapAccess<'de>,
6427 {
6428 let mut key_required_larger__ = None;
6429 let mut key_required_smaller__ = None;
6430 let mut clean_state__ = None;
6431 let mut delta_expression__ = None;
6432 while let Some(k) = map_.next_key()? {
6433 match k {
6434 GeneratedField::KeyRequiredLarger => {
6435 if key_required_larger__.is_some() {
6436 return Err(serde::de::Error::duplicate_field("keyRequiredLarger"));
6437 }
6438 key_required_larger__ =
6439 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6440 ;
6441 }
6442 GeneratedField::KeyRequiredSmaller => {
6443 if key_required_smaller__.is_some() {
6444 return Err(serde::de::Error::duplicate_field("keyRequiredSmaller"));
6445 }
6446 key_required_smaller__ =
6447 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6448 ;
6449 }
6450 GeneratedField::CleanState => {
6451 if clean_state__.is_some() {
6452 return Err(serde::de::Error::duplicate_field("cleanState"));
6453 }
6454 clean_state__ = Some(map_.next_value()?);
6455 }
6456 GeneratedField::DeltaExpression => {
6457 if delta_expression__.is_some() {
6458 return Err(serde::de::Error::duplicate_field("deltaExpression"));
6459 }
6460 delta_expression__ = map_.next_value()?;
6461 }
6462 }
6463 }
6464 Ok(InequalityPair {
6465 key_required_larger: key_required_larger__.unwrap_or_default(),
6466 key_required_smaller: key_required_smaller__.unwrap_or_default(),
6467 clean_state: clean_state__.unwrap_or_default(),
6468 delta_expression: delta_expression__,
6469 })
6470 }
6471 }
6472 deserializer.deserialize_struct("stream_plan.InequalityPair", FIELDS, GeneratedVisitor)
6473 }
6474}
6475impl serde::Serialize for JoinEncodingType {
6476 #[allow(deprecated)]
6477 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6478 where
6479 S: serde::Serializer,
6480 {
6481 let variant = match self {
6482 Self::Unspecified => "UNSPECIFIED",
6483 Self::MemoryOptimized => "MEMORY_OPTIMIZED",
6484 Self::CpuOptimized => "CPU_OPTIMIZED",
6485 };
6486 serializer.serialize_str(variant)
6487 }
6488}
6489impl<'de> serde::Deserialize<'de> for JoinEncodingType {
6490 #[allow(deprecated)]
6491 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6492 where
6493 D: serde::Deserializer<'de>,
6494 {
6495 const FIELDS: &[&str] = &[
6496 "UNSPECIFIED",
6497 "MEMORY_OPTIMIZED",
6498 "CPU_OPTIMIZED",
6499 ];
6500
6501 struct GeneratedVisitor;
6502
6503 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6504 type Value = JoinEncodingType;
6505
6506 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6507 write!(formatter, "expected one of: {:?}", &FIELDS)
6508 }
6509
6510 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6511 where
6512 E: serde::de::Error,
6513 {
6514 i32::try_from(v)
6515 .ok()
6516 .and_then(|x| x.try_into().ok())
6517 .ok_or_else(|| {
6518 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6519 })
6520 }
6521
6522 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6523 where
6524 E: serde::de::Error,
6525 {
6526 i32::try_from(v)
6527 .ok()
6528 .and_then(|x| x.try_into().ok())
6529 .ok_or_else(|| {
6530 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6531 })
6532 }
6533
6534 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6535 where
6536 E: serde::de::Error,
6537 {
6538 match value {
6539 "UNSPECIFIED" => Ok(JoinEncodingType::Unspecified),
6540 "MEMORY_OPTIMIZED" => Ok(JoinEncodingType::MemoryOptimized),
6541 "CPU_OPTIMIZED" => Ok(JoinEncodingType::CpuOptimized),
6542 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6543 }
6544 }
6545 }
6546 deserializer.deserialize_any(GeneratedVisitor)
6547 }
6548}
6549impl serde::Serialize for ListFinishMutation {
6550 #[allow(deprecated)]
6551 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6552 where
6553 S: serde::Serializer,
6554 {
6555 use serde::ser::SerializeStruct;
6556 let mut len = 0;
6557 if self.associated_source_id != 0 {
6558 len += 1;
6559 }
6560 let mut struct_ser = serializer.serialize_struct("stream_plan.ListFinishMutation", len)?;
6561 if self.associated_source_id != 0 {
6562 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
6563 }
6564 struct_ser.end()
6565 }
6566}
6567impl<'de> serde::Deserialize<'de> for ListFinishMutation {
6568 #[allow(deprecated)]
6569 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6570 where
6571 D: serde::Deserializer<'de>,
6572 {
6573 const FIELDS: &[&str] = &[
6574 "associated_source_id",
6575 "associatedSourceId",
6576 ];
6577
6578 #[allow(clippy::enum_variant_names)]
6579 enum GeneratedField {
6580 AssociatedSourceId,
6581 }
6582 impl<'de> serde::Deserialize<'de> for GeneratedField {
6583 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6584 where
6585 D: serde::Deserializer<'de>,
6586 {
6587 struct GeneratedVisitor;
6588
6589 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6590 type Value = GeneratedField;
6591
6592 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6593 write!(formatter, "expected one of: {:?}", &FIELDS)
6594 }
6595
6596 #[allow(unused_variables)]
6597 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6598 where
6599 E: serde::de::Error,
6600 {
6601 match value {
6602 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
6603 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6604 }
6605 }
6606 }
6607 deserializer.deserialize_identifier(GeneratedVisitor)
6608 }
6609 }
6610 struct GeneratedVisitor;
6611 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6612 type Value = ListFinishMutation;
6613
6614 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6615 formatter.write_str("struct stream_plan.ListFinishMutation")
6616 }
6617
6618 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFinishMutation, V::Error>
6619 where
6620 V: serde::de::MapAccess<'de>,
6621 {
6622 let mut associated_source_id__ = None;
6623 while let Some(k) = map_.next_key()? {
6624 match k {
6625 GeneratedField::AssociatedSourceId => {
6626 if associated_source_id__.is_some() {
6627 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
6628 }
6629 associated_source_id__ =
6630 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6631 ;
6632 }
6633 }
6634 }
6635 Ok(ListFinishMutation {
6636 associated_source_id: associated_source_id__.unwrap_or_default(),
6637 })
6638 }
6639 }
6640 deserializer.deserialize_struct("stream_plan.ListFinishMutation", FIELDS, GeneratedVisitor)
6641 }
6642}
6643impl serde::Serialize for LoadFinishMutation {
6644 #[allow(deprecated)]
6645 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6646 where
6647 S: serde::Serializer,
6648 {
6649 use serde::ser::SerializeStruct;
6650 let mut len = 0;
6651 if self.associated_source_id != 0 {
6652 len += 1;
6653 }
6654 let mut struct_ser = serializer.serialize_struct("stream_plan.LoadFinishMutation", len)?;
6655 if self.associated_source_id != 0 {
6656 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
6657 }
6658 struct_ser.end()
6659 }
6660}
6661impl<'de> serde::Deserialize<'de> for LoadFinishMutation {
6662 #[allow(deprecated)]
6663 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6664 where
6665 D: serde::Deserializer<'de>,
6666 {
6667 const FIELDS: &[&str] = &[
6668 "associated_source_id",
6669 "associatedSourceId",
6670 ];
6671
6672 #[allow(clippy::enum_variant_names)]
6673 enum GeneratedField {
6674 AssociatedSourceId,
6675 }
6676 impl<'de> serde::Deserialize<'de> for GeneratedField {
6677 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6678 where
6679 D: serde::Deserializer<'de>,
6680 {
6681 struct GeneratedVisitor;
6682
6683 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6684 type Value = GeneratedField;
6685
6686 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6687 write!(formatter, "expected one of: {:?}", &FIELDS)
6688 }
6689
6690 #[allow(unused_variables)]
6691 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6692 where
6693 E: serde::de::Error,
6694 {
6695 match value {
6696 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
6697 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6698 }
6699 }
6700 }
6701 deserializer.deserialize_identifier(GeneratedVisitor)
6702 }
6703 }
6704 struct GeneratedVisitor;
6705 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6706 type Value = LoadFinishMutation;
6707
6708 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6709 formatter.write_str("struct stream_plan.LoadFinishMutation")
6710 }
6711
6712 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LoadFinishMutation, V::Error>
6713 where
6714 V: serde::de::MapAccess<'de>,
6715 {
6716 let mut associated_source_id__ = None;
6717 while let Some(k) = map_.next_key()? {
6718 match k {
6719 GeneratedField::AssociatedSourceId => {
6720 if associated_source_id__.is_some() {
6721 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
6722 }
6723 associated_source_id__ =
6724 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6725 ;
6726 }
6727 }
6728 }
6729 Ok(LoadFinishMutation {
6730 associated_source_id: associated_source_id__.unwrap_or_default(),
6731 })
6732 }
6733 }
6734 deserializer.deserialize_struct("stream_plan.LoadFinishMutation", FIELDS, GeneratedVisitor)
6735 }
6736}
6737impl serde::Serialize for LocalApproxPercentileNode {
6738 #[allow(deprecated)]
6739 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6740 where
6741 S: serde::Serializer,
6742 {
6743 use serde::ser::SerializeStruct;
6744 let mut len = 0;
6745 if self.base != 0. {
6746 len += 1;
6747 }
6748 if self.percentile_index != 0 {
6749 len += 1;
6750 }
6751 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalApproxPercentileNode", len)?;
6752 if self.base != 0. {
6753 struct_ser.serialize_field("base", &self.base)?;
6754 }
6755 if self.percentile_index != 0 {
6756 struct_ser.serialize_field("percentileIndex", &self.percentile_index)?;
6757 }
6758 struct_ser.end()
6759 }
6760}
6761impl<'de> serde::Deserialize<'de> for LocalApproxPercentileNode {
6762 #[allow(deprecated)]
6763 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6764 where
6765 D: serde::Deserializer<'de>,
6766 {
6767 const FIELDS: &[&str] = &[
6768 "base",
6769 "percentile_index",
6770 "percentileIndex",
6771 ];
6772
6773 #[allow(clippy::enum_variant_names)]
6774 enum GeneratedField {
6775 Base,
6776 PercentileIndex,
6777 }
6778 impl<'de> serde::Deserialize<'de> for GeneratedField {
6779 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6780 where
6781 D: serde::Deserializer<'de>,
6782 {
6783 struct GeneratedVisitor;
6784
6785 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6786 type Value = GeneratedField;
6787
6788 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6789 write!(formatter, "expected one of: {:?}", &FIELDS)
6790 }
6791
6792 #[allow(unused_variables)]
6793 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6794 where
6795 E: serde::de::Error,
6796 {
6797 match value {
6798 "base" => Ok(GeneratedField::Base),
6799 "percentileIndex" | "percentile_index" => Ok(GeneratedField::PercentileIndex),
6800 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6801 }
6802 }
6803 }
6804 deserializer.deserialize_identifier(GeneratedVisitor)
6805 }
6806 }
6807 struct GeneratedVisitor;
6808 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6809 type Value = LocalApproxPercentileNode;
6810
6811 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6812 formatter.write_str("struct stream_plan.LocalApproxPercentileNode")
6813 }
6814
6815 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalApproxPercentileNode, V::Error>
6816 where
6817 V: serde::de::MapAccess<'de>,
6818 {
6819 let mut base__ = None;
6820 let mut percentile_index__ = None;
6821 while let Some(k) = map_.next_key()? {
6822 match k {
6823 GeneratedField::Base => {
6824 if base__.is_some() {
6825 return Err(serde::de::Error::duplicate_field("base"));
6826 }
6827 base__ =
6828 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6829 ;
6830 }
6831 GeneratedField::PercentileIndex => {
6832 if percentile_index__.is_some() {
6833 return Err(serde::de::Error::duplicate_field("percentileIndex"));
6834 }
6835 percentile_index__ =
6836 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6837 ;
6838 }
6839 }
6840 }
6841 Ok(LocalApproxPercentileNode {
6842 base: base__.unwrap_or_default(),
6843 percentile_index: percentile_index__.unwrap_or_default(),
6844 })
6845 }
6846 }
6847 deserializer.deserialize_struct("stream_plan.LocalApproxPercentileNode", FIELDS, GeneratedVisitor)
6848 }
6849}
6850impl serde::Serialize for LocalityProviderNode {
6851 #[allow(deprecated)]
6852 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6853 where
6854 S: serde::Serializer,
6855 {
6856 use serde::ser::SerializeStruct;
6857 let mut len = 0;
6858 if !self.locality_columns.is_empty() {
6859 len += 1;
6860 }
6861 if self.state_table.is_some() {
6862 len += 1;
6863 }
6864 if self.progress_table.is_some() {
6865 len += 1;
6866 }
6867 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalityProviderNode", len)?;
6868 if !self.locality_columns.is_empty() {
6869 struct_ser.serialize_field("localityColumns", &self.locality_columns)?;
6870 }
6871 if let Some(v) = self.state_table.as_ref() {
6872 struct_ser.serialize_field("stateTable", v)?;
6873 }
6874 if let Some(v) = self.progress_table.as_ref() {
6875 struct_ser.serialize_field("progressTable", v)?;
6876 }
6877 struct_ser.end()
6878 }
6879}
6880impl<'de> serde::Deserialize<'de> for LocalityProviderNode {
6881 #[allow(deprecated)]
6882 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6883 where
6884 D: serde::Deserializer<'de>,
6885 {
6886 const FIELDS: &[&str] = &[
6887 "locality_columns",
6888 "localityColumns",
6889 "state_table",
6890 "stateTable",
6891 "progress_table",
6892 "progressTable",
6893 ];
6894
6895 #[allow(clippy::enum_variant_names)]
6896 enum GeneratedField {
6897 LocalityColumns,
6898 StateTable,
6899 ProgressTable,
6900 }
6901 impl<'de> serde::Deserialize<'de> for GeneratedField {
6902 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6903 where
6904 D: serde::Deserializer<'de>,
6905 {
6906 struct GeneratedVisitor;
6907
6908 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6909 type Value = GeneratedField;
6910
6911 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6912 write!(formatter, "expected one of: {:?}", &FIELDS)
6913 }
6914
6915 #[allow(unused_variables)]
6916 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6917 where
6918 E: serde::de::Error,
6919 {
6920 match value {
6921 "localityColumns" | "locality_columns" => Ok(GeneratedField::LocalityColumns),
6922 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
6923 "progressTable" | "progress_table" => Ok(GeneratedField::ProgressTable),
6924 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6925 }
6926 }
6927 }
6928 deserializer.deserialize_identifier(GeneratedVisitor)
6929 }
6930 }
6931 struct GeneratedVisitor;
6932 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6933 type Value = LocalityProviderNode;
6934
6935 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6936 formatter.write_str("struct stream_plan.LocalityProviderNode")
6937 }
6938
6939 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalityProviderNode, V::Error>
6940 where
6941 V: serde::de::MapAccess<'de>,
6942 {
6943 let mut locality_columns__ = None;
6944 let mut state_table__ = None;
6945 let mut progress_table__ = None;
6946 while let Some(k) = map_.next_key()? {
6947 match k {
6948 GeneratedField::LocalityColumns => {
6949 if locality_columns__.is_some() {
6950 return Err(serde::de::Error::duplicate_field("localityColumns"));
6951 }
6952 locality_columns__ =
6953 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6954 .into_iter().map(|x| x.0).collect())
6955 ;
6956 }
6957 GeneratedField::StateTable => {
6958 if state_table__.is_some() {
6959 return Err(serde::de::Error::duplicate_field("stateTable"));
6960 }
6961 state_table__ = map_.next_value()?;
6962 }
6963 GeneratedField::ProgressTable => {
6964 if progress_table__.is_some() {
6965 return Err(serde::de::Error::duplicate_field("progressTable"));
6966 }
6967 progress_table__ = map_.next_value()?;
6968 }
6969 }
6970 }
6971 Ok(LocalityProviderNode {
6972 locality_columns: locality_columns__.unwrap_or_default(),
6973 state_table: state_table__,
6974 progress_table: progress_table__,
6975 })
6976 }
6977 }
6978 deserializer.deserialize_struct("stream_plan.LocalityProviderNode", FIELDS, GeneratedVisitor)
6979 }
6980}
6981impl serde::Serialize for LookupNode {
6982 #[allow(deprecated)]
6983 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6984 where
6985 S: serde::Serializer,
6986 {
6987 use serde::ser::SerializeStruct;
6988 let mut len = 0;
6989 if !self.arrange_key.is_empty() {
6990 len += 1;
6991 }
6992 if !self.stream_key.is_empty() {
6993 len += 1;
6994 }
6995 if self.use_current_epoch {
6996 len += 1;
6997 }
6998 if !self.column_mapping.is_empty() {
6999 len += 1;
7000 }
7001 if self.arrangement_table_info.is_some() {
7002 len += 1;
7003 }
7004 if self.arrangement_table_id.is_some() {
7005 len += 1;
7006 }
7007 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupNode", len)?;
7008 if !self.arrange_key.is_empty() {
7009 struct_ser.serialize_field("arrangeKey", &self.arrange_key)?;
7010 }
7011 if !self.stream_key.is_empty() {
7012 struct_ser.serialize_field("streamKey", &self.stream_key)?;
7013 }
7014 if self.use_current_epoch {
7015 struct_ser.serialize_field("useCurrentEpoch", &self.use_current_epoch)?;
7016 }
7017 if !self.column_mapping.is_empty() {
7018 struct_ser.serialize_field("columnMapping", &self.column_mapping)?;
7019 }
7020 if let Some(v) = self.arrangement_table_info.as_ref() {
7021 struct_ser.serialize_field("arrangementTableInfo", v)?;
7022 }
7023 if let Some(v) = self.arrangement_table_id.as_ref() {
7024 match v {
7025 lookup_node::ArrangementTableId::TableId(v) => {
7026 struct_ser.serialize_field("tableId", v)?;
7027 }
7028 lookup_node::ArrangementTableId::IndexId(v) => {
7029 struct_ser.serialize_field("indexId", v)?;
7030 }
7031 }
7032 }
7033 struct_ser.end()
7034 }
7035}
7036impl<'de> serde::Deserialize<'de> for LookupNode {
7037 #[allow(deprecated)]
7038 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7039 where
7040 D: serde::Deserializer<'de>,
7041 {
7042 const FIELDS: &[&str] = &[
7043 "arrange_key",
7044 "arrangeKey",
7045 "stream_key",
7046 "streamKey",
7047 "use_current_epoch",
7048 "useCurrentEpoch",
7049 "column_mapping",
7050 "columnMapping",
7051 "arrangement_table_info",
7052 "arrangementTableInfo",
7053 "table_id",
7054 "tableId",
7055 "index_id",
7056 "indexId",
7057 ];
7058
7059 #[allow(clippy::enum_variant_names)]
7060 enum GeneratedField {
7061 ArrangeKey,
7062 StreamKey,
7063 UseCurrentEpoch,
7064 ColumnMapping,
7065 ArrangementTableInfo,
7066 TableId,
7067 IndexId,
7068 }
7069 impl<'de> serde::Deserialize<'de> for GeneratedField {
7070 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7071 where
7072 D: serde::Deserializer<'de>,
7073 {
7074 struct GeneratedVisitor;
7075
7076 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7077 type Value = GeneratedField;
7078
7079 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7080 write!(formatter, "expected one of: {:?}", &FIELDS)
7081 }
7082
7083 #[allow(unused_variables)]
7084 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7085 where
7086 E: serde::de::Error,
7087 {
7088 match value {
7089 "arrangeKey" | "arrange_key" => Ok(GeneratedField::ArrangeKey),
7090 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
7091 "useCurrentEpoch" | "use_current_epoch" => Ok(GeneratedField::UseCurrentEpoch),
7092 "columnMapping" | "column_mapping" => Ok(GeneratedField::ColumnMapping),
7093 "arrangementTableInfo" | "arrangement_table_info" => Ok(GeneratedField::ArrangementTableInfo),
7094 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7095 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
7096 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7097 }
7098 }
7099 }
7100 deserializer.deserialize_identifier(GeneratedVisitor)
7101 }
7102 }
7103 struct GeneratedVisitor;
7104 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7105 type Value = LookupNode;
7106
7107 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7108 formatter.write_str("struct stream_plan.LookupNode")
7109 }
7110
7111 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupNode, V::Error>
7112 where
7113 V: serde::de::MapAccess<'de>,
7114 {
7115 let mut arrange_key__ = None;
7116 let mut stream_key__ = None;
7117 let mut use_current_epoch__ = None;
7118 let mut column_mapping__ = None;
7119 let mut arrangement_table_info__ = None;
7120 let mut arrangement_table_id__ = None;
7121 while let Some(k) = map_.next_key()? {
7122 match k {
7123 GeneratedField::ArrangeKey => {
7124 if arrange_key__.is_some() {
7125 return Err(serde::de::Error::duplicate_field("arrangeKey"));
7126 }
7127 arrange_key__ =
7128 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7129 .into_iter().map(|x| x.0).collect())
7130 ;
7131 }
7132 GeneratedField::StreamKey => {
7133 if stream_key__.is_some() {
7134 return Err(serde::de::Error::duplicate_field("streamKey"));
7135 }
7136 stream_key__ =
7137 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7138 .into_iter().map(|x| x.0).collect())
7139 ;
7140 }
7141 GeneratedField::UseCurrentEpoch => {
7142 if use_current_epoch__.is_some() {
7143 return Err(serde::de::Error::duplicate_field("useCurrentEpoch"));
7144 }
7145 use_current_epoch__ = Some(map_.next_value()?);
7146 }
7147 GeneratedField::ColumnMapping => {
7148 if column_mapping__.is_some() {
7149 return Err(serde::de::Error::duplicate_field("columnMapping"));
7150 }
7151 column_mapping__ =
7152 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7153 .into_iter().map(|x| x.0).collect())
7154 ;
7155 }
7156 GeneratedField::ArrangementTableInfo => {
7157 if arrangement_table_info__.is_some() {
7158 return Err(serde::de::Error::duplicate_field("arrangementTableInfo"));
7159 }
7160 arrangement_table_info__ = map_.next_value()?;
7161 }
7162 GeneratedField::TableId => {
7163 if arrangement_table_id__.is_some() {
7164 return Err(serde::de::Error::duplicate_field("tableId"));
7165 }
7166 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::TableId(x.0));
7167 }
7168 GeneratedField::IndexId => {
7169 if arrangement_table_id__.is_some() {
7170 return Err(serde::de::Error::duplicate_field("indexId"));
7171 }
7172 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::IndexId(x.0));
7173 }
7174 }
7175 }
7176 Ok(LookupNode {
7177 arrange_key: arrange_key__.unwrap_or_default(),
7178 stream_key: stream_key__.unwrap_or_default(),
7179 use_current_epoch: use_current_epoch__.unwrap_or_default(),
7180 column_mapping: column_mapping__.unwrap_or_default(),
7181 arrangement_table_info: arrangement_table_info__,
7182 arrangement_table_id: arrangement_table_id__,
7183 })
7184 }
7185 }
7186 deserializer.deserialize_struct("stream_plan.LookupNode", FIELDS, GeneratedVisitor)
7187 }
7188}
7189impl serde::Serialize for LookupUnionNode {
7190 #[allow(deprecated)]
7191 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7192 where
7193 S: serde::Serializer,
7194 {
7195 use serde::ser::SerializeStruct;
7196 let mut len = 0;
7197 if !self.order.is_empty() {
7198 len += 1;
7199 }
7200 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupUnionNode", len)?;
7201 if !self.order.is_empty() {
7202 struct_ser.serialize_field("order", &self.order)?;
7203 }
7204 struct_ser.end()
7205 }
7206}
7207impl<'de> serde::Deserialize<'de> for LookupUnionNode {
7208 #[allow(deprecated)]
7209 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7210 where
7211 D: serde::Deserializer<'de>,
7212 {
7213 const FIELDS: &[&str] = &[
7214 "order",
7215 ];
7216
7217 #[allow(clippy::enum_variant_names)]
7218 enum GeneratedField {
7219 Order,
7220 }
7221 impl<'de> serde::Deserialize<'de> for GeneratedField {
7222 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7223 where
7224 D: serde::Deserializer<'de>,
7225 {
7226 struct GeneratedVisitor;
7227
7228 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7229 type Value = GeneratedField;
7230
7231 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7232 write!(formatter, "expected one of: {:?}", &FIELDS)
7233 }
7234
7235 #[allow(unused_variables)]
7236 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7237 where
7238 E: serde::de::Error,
7239 {
7240 match value {
7241 "order" => Ok(GeneratedField::Order),
7242 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7243 }
7244 }
7245 }
7246 deserializer.deserialize_identifier(GeneratedVisitor)
7247 }
7248 }
7249 struct GeneratedVisitor;
7250 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7251 type Value = LookupUnionNode;
7252
7253 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7254 formatter.write_str("struct stream_plan.LookupUnionNode")
7255 }
7256
7257 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupUnionNode, V::Error>
7258 where
7259 V: serde::de::MapAccess<'de>,
7260 {
7261 let mut order__ = None;
7262 while let Some(k) = map_.next_key()? {
7263 match k {
7264 GeneratedField::Order => {
7265 if order__.is_some() {
7266 return Err(serde::de::Error::duplicate_field("order"));
7267 }
7268 order__ =
7269 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7270 .into_iter().map(|x| x.0).collect())
7271 ;
7272 }
7273 }
7274 }
7275 Ok(LookupUnionNode {
7276 order: order__.unwrap_or_default(),
7277 })
7278 }
7279 }
7280 deserializer.deserialize_struct("stream_plan.LookupUnionNode", FIELDS, GeneratedVisitor)
7281 }
7282}
7283impl serde::Serialize for MaterializeNode {
7284 #[allow(deprecated)]
7285 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7286 where
7287 S: serde::Serializer,
7288 {
7289 use serde::ser::SerializeStruct;
7290 let mut len = 0;
7291 if self.table_id != 0 {
7292 len += 1;
7293 }
7294 if !self.column_orders.is_empty() {
7295 len += 1;
7296 }
7297 if self.table.is_some() {
7298 len += 1;
7299 }
7300 if self.staging_table.is_some() {
7301 len += 1;
7302 }
7303 if self.refresh_progress_table.is_some() {
7304 len += 1;
7305 }
7306 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializeNode", len)?;
7307 if self.table_id != 0 {
7308 struct_ser.serialize_field("tableId", &self.table_id)?;
7309 }
7310 if !self.column_orders.is_empty() {
7311 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
7312 }
7313 if let Some(v) = self.table.as_ref() {
7314 struct_ser.serialize_field("table", v)?;
7315 }
7316 if let Some(v) = self.staging_table.as_ref() {
7317 struct_ser.serialize_field("stagingTable", v)?;
7318 }
7319 if let Some(v) = self.refresh_progress_table.as_ref() {
7320 struct_ser.serialize_field("refreshProgressTable", v)?;
7321 }
7322 struct_ser.end()
7323 }
7324}
7325impl<'de> serde::Deserialize<'de> for MaterializeNode {
7326 #[allow(deprecated)]
7327 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7328 where
7329 D: serde::Deserializer<'de>,
7330 {
7331 const FIELDS: &[&str] = &[
7332 "table_id",
7333 "tableId",
7334 "column_orders",
7335 "columnOrders",
7336 "table",
7337 "staging_table",
7338 "stagingTable",
7339 "refresh_progress_table",
7340 "refreshProgressTable",
7341 ];
7342
7343 #[allow(clippy::enum_variant_names)]
7344 enum GeneratedField {
7345 TableId,
7346 ColumnOrders,
7347 Table,
7348 StagingTable,
7349 RefreshProgressTable,
7350 }
7351 impl<'de> serde::Deserialize<'de> for GeneratedField {
7352 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7353 where
7354 D: serde::Deserializer<'de>,
7355 {
7356 struct GeneratedVisitor;
7357
7358 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7359 type Value = GeneratedField;
7360
7361 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7362 write!(formatter, "expected one of: {:?}", &FIELDS)
7363 }
7364
7365 #[allow(unused_variables)]
7366 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7367 where
7368 E: serde::de::Error,
7369 {
7370 match value {
7371 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7372 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
7373 "table" => Ok(GeneratedField::Table),
7374 "stagingTable" | "staging_table" => Ok(GeneratedField::StagingTable),
7375 "refreshProgressTable" | "refresh_progress_table" => Ok(GeneratedField::RefreshProgressTable),
7376 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7377 }
7378 }
7379 }
7380 deserializer.deserialize_identifier(GeneratedVisitor)
7381 }
7382 }
7383 struct GeneratedVisitor;
7384 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7385 type Value = MaterializeNode;
7386
7387 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7388 formatter.write_str("struct stream_plan.MaterializeNode")
7389 }
7390
7391 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializeNode, V::Error>
7392 where
7393 V: serde::de::MapAccess<'de>,
7394 {
7395 let mut table_id__ = None;
7396 let mut column_orders__ = None;
7397 let mut table__ = None;
7398 let mut staging_table__ = None;
7399 let mut refresh_progress_table__ = None;
7400 while let Some(k) = map_.next_key()? {
7401 match k {
7402 GeneratedField::TableId => {
7403 if table_id__.is_some() {
7404 return Err(serde::de::Error::duplicate_field("tableId"));
7405 }
7406 table_id__ =
7407 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7408 ;
7409 }
7410 GeneratedField::ColumnOrders => {
7411 if column_orders__.is_some() {
7412 return Err(serde::de::Error::duplicate_field("columnOrders"));
7413 }
7414 column_orders__ = Some(map_.next_value()?);
7415 }
7416 GeneratedField::Table => {
7417 if table__.is_some() {
7418 return Err(serde::de::Error::duplicate_field("table"));
7419 }
7420 table__ = map_.next_value()?;
7421 }
7422 GeneratedField::StagingTable => {
7423 if staging_table__.is_some() {
7424 return Err(serde::de::Error::duplicate_field("stagingTable"));
7425 }
7426 staging_table__ = map_.next_value()?;
7427 }
7428 GeneratedField::RefreshProgressTable => {
7429 if refresh_progress_table__.is_some() {
7430 return Err(serde::de::Error::duplicate_field("refreshProgressTable"));
7431 }
7432 refresh_progress_table__ = map_.next_value()?;
7433 }
7434 }
7435 }
7436 Ok(MaterializeNode {
7437 table_id: table_id__.unwrap_or_default(),
7438 column_orders: column_orders__.unwrap_or_default(),
7439 table: table__,
7440 staging_table: staging_table__,
7441 refresh_progress_table: refresh_progress_table__,
7442 })
7443 }
7444 }
7445 deserializer.deserialize_struct("stream_plan.MaterializeNode", FIELDS, GeneratedVisitor)
7446 }
7447}
7448impl serde::Serialize for MaterializedExprsNode {
7449 #[allow(deprecated)]
7450 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7451 where
7452 S: serde::Serializer,
7453 {
7454 use serde::ser::SerializeStruct;
7455 let mut len = 0;
7456 if !self.exprs.is_empty() {
7457 len += 1;
7458 }
7459 if self.state_table.is_some() {
7460 len += 1;
7461 }
7462 if self.state_clean_col_idx.is_some() {
7463 len += 1;
7464 }
7465 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializedExprsNode", len)?;
7466 if !self.exprs.is_empty() {
7467 struct_ser.serialize_field("exprs", &self.exprs)?;
7468 }
7469 if let Some(v) = self.state_table.as_ref() {
7470 struct_ser.serialize_field("stateTable", v)?;
7471 }
7472 if let Some(v) = self.state_clean_col_idx.as_ref() {
7473 struct_ser.serialize_field("stateCleanColIdx", v)?;
7474 }
7475 struct_ser.end()
7476 }
7477}
7478impl<'de> serde::Deserialize<'de> for MaterializedExprsNode {
7479 #[allow(deprecated)]
7480 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7481 where
7482 D: serde::Deserializer<'de>,
7483 {
7484 const FIELDS: &[&str] = &[
7485 "exprs",
7486 "state_table",
7487 "stateTable",
7488 "state_clean_col_idx",
7489 "stateCleanColIdx",
7490 ];
7491
7492 #[allow(clippy::enum_variant_names)]
7493 enum GeneratedField {
7494 Exprs,
7495 StateTable,
7496 StateCleanColIdx,
7497 }
7498 impl<'de> serde::Deserialize<'de> for GeneratedField {
7499 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7500 where
7501 D: serde::Deserializer<'de>,
7502 {
7503 struct GeneratedVisitor;
7504
7505 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7506 type Value = GeneratedField;
7507
7508 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7509 write!(formatter, "expected one of: {:?}", &FIELDS)
7510 }
7511
7512 #[allow(unused_variables)]
7513 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7514 where
7515 E: serde::de::Error,
7516 {
7517 match value {
7518 "exprs" => Ok(GeneratedField::Exprs),
7519 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7520 "stateCleanColIdx" | "state_clean_col_idx" => Ok(GeneratedField::StateCleanColIdx),
7521 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7522 }
7523 }
7524 }
7525 deserializer.deserialize_identifier(GeneratedVisitor)
7526 }
7527 }
7528 struct GeneratedVisitor;
7529 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7530 type Value = MaterializedExprsNode;
7531
7532 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7533 formatter.write_str("struct stream_plan.MaterializedExprsNode")
7534 }
7535
7536 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializedExprsNode, V::Error>
7537 where
7538 V: serde::de::MapAccess<'de>,
7539 {
7540 let mut exprs__ = None;
7541 let mut state_table__ = None;
7542 let mut state_clean_col_idx__ = None;
7543 while let Some(k) = map_.next_key()? {
7544 match k {
7545 GeneratedField::Exprs => {
7546 if exprs__.is_some() {
7547 return Err(serde::de::Error::duplicate_field("exprs"));
7548 }
7549 exprs__ = Some(map_.next_value()?);
7550 }
7551 GeneratedField::StateTable => {
7552 if state_table__.is_some() {
7553 return Err(serde::de::Error::duplicate_field("stateTable"));
7554 }
7555 state_table__ = map_.next_value()?;
7556 }
7557 GeneratedField::StateCleanColIdx => {
7558 if state_clean_col_idx__.is_some() {
7559 return Err(serde::de::Error::duplicate_field("stateCleanColIdx"));
7560 }
7561 state_clean_col_idx__ =
7562 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
7563 ;
7564 }
7565 }
7566 }
7567 Ok(MaterializedExprsNode {
7568 exprs: exprs__.unwrap_or_default(),
7569 state_table: state_table__,
7570 state_clean_col_idx: state_clean_col_idx__,
7571 })
7572 }
7573 }
7574 deserializer.deserialize_struct("stream_plan.MaterializedExprsNode", FIELDS, GeneratedVisitor)
7575 }
7576}
7577impl serde::Serialize for MergeNode {
7578 #[allow(deprecated)]
7579 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7580 where
7581 S: serde::Serializer,
7582 {
7583 use serde::ser::SerializeStruct;
7584 let mut len = 0;
7585 if !self.upstream_actor_id.is_empty() {
7586 len += 1;
7587 }
7588 if self.upstream_fragment_id != 0 {
7589 len += 1;
7590 }
7591 if self.upstream_dispatcher_type != 0 {
7592 len += 1;
7593 }
7594 if !self.fields.is_empty() {
7595 len += 1;
7596 }
7597 let mut struct_ser = serializer.serialize_struct("stream_plan.MergeNode", len)?;
7598 if !self.upstream_actor_id.is_empty() {
7599 struct_ser.serialize_field("upstreamActorId", &self.upstream_actor_id)?;
7600 }
7601 if self.upstream_fragment_id != 0 {
7602 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
7603 }
7604 if self.upstream_dispatcher_type != 0 {
7605 let v = DispatcherType::try_from(self.upstream_dispatcher_type)
7606 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.upstream_dispatcher_type)))?;
7607 struct_ser.serialize_field("upstreamDispatcherType", &v)?;
7608 }
7609 if !self.fields.is_empty() {
7610 struct_ser.serialize_field("fields", &self.fields)?;
7611 }
7612 struct_ser.end()
7613 }
7614}
7615impl<'de> serde::Deserialize<'de> for MergeNode {
7616 #[allow(deprecated)]
7617 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7618 where
7619 D: serde::Deserializer<'de>,
7620 {
7621 const FIELDS: &[&str] = &[
7622 "upstream_actor_id",
7623 "upstreamActorId",
7624 "upstream_fragment_id",
7625 "upstreamFragmentId",
7626 "upstream_dispatcher_type",
7627 "upstreamDispatcherType",
7628 "fields",
7629 ];
7630
7631 #[allow(clippy::enum_variant_names)]
7632 enum GeneratedField {
7633 UpstreamActorId,
7634 UpstreamFragmentId,
7635 UpstreamDispatcherType,
7636 Fields,
7637 }
7638 impl<'de> serde::Deserialize<'de> for GeneratedField {
7639 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7640 where
7641 D: serde::Deserializer<'de>,
7642 {
7643 struct GeneratedVisitor;
7644
7645 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7646 type Value = GeneratedField;
7647
7648 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7649 write!(formatter, "expected one of: {:?}", &FIELDS)
7650 }
7651
7652 #[allow(unused_variables)]
7653 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7654 where
7655 E: serde::de::Error,
7656 {
7657 match value {
7658 "upstreamActorId" | "upstream_actor_id" => Ok(GeneratedField::UpstreamActorId),
7659 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
7660 "upstreamDispatcherType" | "upstream_dispatcher_type" => Ok(GeneratedField::UpstreamDispatcherType),
7661 "fields" => Ok(GeneratedField::Fields),
7662 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7663 }
7664 }
7665 }
7666 deserializer.deserialize_identifier(GeneratedVisitor)
7667 }
7668 }
7669 struct GeneratedVisitor;
7670 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7671 type Value = MergeNode;
7672
7673 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7674 formatter.write_str("struct stream_plan.MergeNode")
7675 }
7676
7677 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeNode, V::Error>
7678 where
7679 V: serde::de::MapAccess<'de>,
7680 {
7681 let mut upstream_actor_id__ = None;
7682 let mut upstream_fragment_id__ = None;
7683 let mut upstream_dispatcher_type__ = None;
7684 let mut fields__ = None;
7685 while let Some(k) = map_.next_key()? {
7686 match k {
7687 GeneratedField::UpstreamActorId => {
7688 if upstream_actor_id__.is_some() {
7689 return Err(serde::de::Error::duplicate_field("upstreamActorId"));
7690 }
7691 upstream_actor_id__ =
7692 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7693 .into_iter().map(|x| x.0).collect())
7694 ;
7695 }
7696 GeneratedField::UpstreamFragmentId => {
7697 if upstream_fragment_id__.is_some() {
7698 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
7699 }
7700 upstream_fragment_id__ =
7701 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7702 ;
7703 }
7704 GeneratedField::UpstreamDispatcherType => {
7705 if upstream_dispatcher_type__.is_some() {
7706 return Err(serde::de::Error::duplicate_field("upstreamDispatcherType"));
7707 }
7708 upstream_dispatcher_type__ = Some(map_.next_value::<DispatcherType>()? as i32);
7709 }
7710 GeneratedField::Fields => {
7711 if fields__.is_some() {
7712 return Err(serde::de::Error::duplicate_field("fields"));
7713 }
7714 fields__ = Some(map_.next_value()?);
7715 }
7716 }
7717 }
7718 Ok(MergeNode {
7719 upstream_actor_id: upstream_actor_id__.unwrap_or_default(),
7720 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
7721 upstream_dispatcher_type: upstream_dispatcher_type__.unwrap_or_default(),
7722 fields: fields__.unwrap_or_default(),
7723 })
7724 }
7725 }
7726 deserializer.deserialize_struct("stream_plan.MergeNode", FIELDS, GeneratedVisitor)
7727 }
7728}
7729impl serde::Serialize for NoOpNode {
7730 #[allow(deprecated)]
7731 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7732 where
7733 S: serde::Serializer,
7734 {
7735 use serde::ser::SerializeStruct;
7736 let len = 0;
7737 let struct_ser = serializer.serialize_struct("stream_plan.NoOpNode", len)?;
7738 struct_ser.end()
7739 }
7740}
7741impl<'de> serde::Deserialize<'de> for NoOpNode {
7742 #[allow(deprecated)]
7743 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7744 where
7745 D: serde::Deserializer<'de>,
7746 {
7747 const FIELDS: &[&str] = &[
7748 ];
7749
7750 #[allow(clippy::enum_variant_names)]
7751 enum GeneratedField {
7752 }
7753 impl<'de> serde::Deserialize<'de> for GeneratedField {
7754 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7755 where
7756 D: serde::Deserializer<'de>,
7757 {
7758 struct GeneratedVisitor;
7759
7760 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7761 type Value = GeneratedField;
7762
7763 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7764 write!(formatter, "expected one of: {:?}", &FIELDS)
7765 }
7766
7767 #[allow(unused_variables)]
7768 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7769 where
7770 E: serde::de::Error,
7771 {
7772 Err(serde::de::Error::unknown_field(value, FIELDS))
7773 }
7774 }
7775 deserializer.deserialize_identifier(GeneratedVisitor)
7776 }
7777 }
7778 struct GeneratedVisitor;
7779 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7780 type Value = NoOpNode;
7781
7782 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7783 formatter.write_str("struct stream_plan.NoOpNode")
7784 }
7785
7786 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NoOpNode, V::Error>
7787 where
7788 V: serde::de::MapAccess<'de>,
7789 {
7790 while map_.next_key::<GeneratedField>()?.is_some() {
7791 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7792 }
7793 Ok(NoOpNode {
7794 })
7795 }
7796 }
7797 deserializer.deserialize_struct("stream_plan.NoOpNode", FIELDS, GeneratedVisitor)
7798 }
7799}
7800impl serde::Serialize for NowModeGenerateSeries {
7801 #[allow(deprecated)]
7802 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7803 where
7804 S: serde::Serializer,
7805 {
7806 use serde::ser::SerializeStruct;
7807 let mut len = 0;
7808 if self.start_timestamp.is_some() {
7809 len += 1;
7810 }
7811 if self.interval.is_some() {
7812 len += 1;
7813 }
7814 let mut struct_ser = serializer.serialize_struct("stream_plan.NowModeGenerateSeries", len)?;
7815 if let Some(v) = self.start_timestamp.as_ref() {
7816 struct_ser.serialize_field("startTimestamp", v)?;
7817 }
7818 if let Some(v) = self.interval.as_ref() {
7819 struct_ser.serialize_field("interval", v)?;
7820 }
7821 struct_ser.end()
7822 }
7823}
7824impl<'de> serde::Deserialize<'de> for NowModeGenerateSeries {
7825 #[allow(deprecated)]
7826 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7827 where
7828 D: serde::Deserializer<'de>,
7829 {
7830 const FIELDS: &[&str] = &[
7831 "start_timestamp",
7832 "startTimestamp",
7833 "interval",
7834 ];
7835
7836 #[allow(clippy::enum_variant_names)]
7837 enum GeneratedField {
7838 StartTimestamp,
7839 Interval,
7840 }
7841 impl<'de> serde::Deserialize<'de> for GeneratedField {
7842 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7843 where
7844 D: serde::Deserializer<'de>,
7845 {
7846 struct GeneratedVisitor;
7847
7848 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7849 type Value = GeneratedField;
7850
7851 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7852 write!(formatter, "expected one of: {:?}", &FIELDS)
7853 }
7854
7855 #[allow(unused_variables)]
7856 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7857 where
7858 E: serde::de::Error,
7859 {
7860 match value {
7861 "startTimestamp" | "start_timestamp" => Ok(GeneratedField::StartTimestamp),
7862 "interval" => Ok(GeneratedField::Interval),
7863 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7864 }
7865 }
7866 }
7867 deserializer.deserialize_identifier(GeneratedVisitor)
7868 }
7869 }
7870 struct GeneratedVisitor;
7871 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7872 type Value = NowModeGenerateSeries;
7873
7874 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7875 formatter.write_str("struct stream_plan.NowModeGenerateSeries")
7876 }
7877
7878 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeGenerateSeries, V::Error>
7879 where
7880 V: serde::de::MapAccess<'de>,
7881 {
7882 let mut start_timestamp__ = None;
7883 let mut interval__ = None;
7884 while let Some(k) = map_.next_key()? {
7885 match k {
7886 GeneratedField::StartTimestamp => {
7887 if start_timestamp__.is_some() {
7888 return Err(serde::de::Error::duplicate_field("startTimestamp"));
7889 }
7890 start_timestamp__ = map_.next_value()?;
7891 }
7892 GeneratedField::Interval => {
7893 if interval__.is_some() {
7894 return Err(serde::de::Error::duplicate_field("interval"));
7895 }
7896 interval__ = map_.next_value()?;
7897 }
7898 }
7899 }
7900 Ok(NowModeGenerateSeries {
7901 start_timestamp: start_timestamp__,
7902 interval: interval__,
7903 })
7904 }
7905 }
7906 deserializer.deserialize_struct("stream_plan.NowModeGenerateSeries", FIELDS, GeneratedVisitor)
7907 }
7908}
7909impl serde::Serialize for NowModeUpdateCurrent {
7910 #[allow(deprecated)]
7911 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7912 where
7913 S: serde::Serializer,
7914 {
7915 use serde::ser::SerializeStruct;
7916 let len = 0;
7917 let struct_ser = serializer.serialize_struct("stream_plan.NowModeUpdateCurrent", len)?;
7918 struct_ser.end()
7919 }
7920}
7921impl<'de> serde::Deserialize<'de> for NowModeUpdateCurrent {
7922 #[allow(deprecated)]
7923 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7924 where
7925 D: serde::Deserializer<'de>,
7926 {
7927 const FIELDS: &[&str] = &[
7928 ];
7929
7930 #[allow(clippy::enum_variant_names)]
7931 enum GeneratedField {
7932 }
7933 impl<'de> serde::Deserialize<'de> for GeneratedField {
7934 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7935 where
7936 D: serde::Deserializer<'de>,
7937 {
7938 struct GeneratedVisitor;
7939
7940 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7941 type Value = GeneratedField;
7942
7943 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7944 write!(formatter, "expected one of: {:?}", &FIELDS)
7945 }
7946
7947 #[allow(unused_variables)]
7948 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7949 where
7950 E: serde::de::Error,
7951 {
7952 Err(serde::de::Error::unknown_field(value, FIELDS))
7953 }
7954 }
7955 deserializer.deserialize_identifier(GeneratedVisitor)
7956 }
7957 }
7958 struct GeneratedVisitor;
7959 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7960 type Value = NowModeUpdateCurrent;
7961
7962 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7963 formatter.write_str("struct stream_plan.NowModeUpdateCurrent")
7964 }
7965
7966 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeUpdateCurrent, V::Error>
7967 where
7968 V: serde::de::MapAccess<'de>,
7969 {
7970 while map_.next_key::<GeneratedField>()?.is_some() {
7971 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7972 }
7973 Ok(NowModeUpdateCurrent {
7974 })
7975 }
7976 }
7977 deserializer.deserialize_struct("stream_plan.NowModeUpdateCurrent", FIELDS, GeneratedVisitor)
7978 }
7979}
7980impl serde::Serialize for NowNode {
7981 #[allow(deprecated)]
7982 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7983 where
7984 S: serde::Serializer,
7985 {
7986 use serde::ser::SerializeStruct;
7987 let mut len = 0;
7988 if self.state_table.is_some() {
7989 len += 1;
7990 }
7991 if self.mode.is_some() {
7992 len += 1;
7993 }
7994 let mut struct_ser = serializer.serialize_struct("stream_plan.NowNode", len)?;
7995 if let Some(v) = self.state_table.as_ref() {
7996 struct_ser.serialize_field("stateTable", v)?;
7997 }
7998 if let Some(v) = self.mode.as_ref() {
7999 match v {
8000 now_node::Mode::UpdateCurrent(v) => {
8001 struct_ser.serialize_field("updateCurrent", v)?;
8002 }
8003 now_node::Mode::GenerateSeries(v) => {
8004 struct_ser.serialize_field("generateSeries", v)?;
8005 }
8006 }
8007 }
8008 struct_ser.end()
8009 }
8010}
8011impl<'de> serde::Deserialize<'de> for NowNode {
8012 #[allow(deprecated)]
8013 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8014 where
8015 D: serde::Deserializer<'de>,
8016 {
8017 const FIELDS: &[&str] = &[
8018 "state_table",
8019 "stateTable",
8020 "update_current",
8021 "updateCurrent",
8022 "generate_series",
8023 "generateSeries",
8024 ];
8025
8026 #[allow(clippy::enum_variant_names)]
8027 enum GeneratedField {
8028 StateTable,
8029 UpdateCurrent,
8030 GenerateSeries,
8031 }
8032 impl<'de> serde::Deserialize<'de> for GeneratedField {
8033 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8034 where
8035 D: serde::Deserializer<'de>,
8036 {
8037 struct GeneratedVisitor;
8038
8039 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8040 type Value = GeneratedField;
8041
8042 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8043 write!(formatter, "expected one of: {:?}", &FIELDS)
8044 }
8045
8046 #[allow(unused_variables)]
8047 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8048 where
8049 E: serde::de::Error,
8050 {
8051 match value {
8052 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
8053 "updateCurrent" | "update_current" => Ok(GeneratedField::UpdateCurrent),
8054 "generateSeries" | "generate_series" => Ok(GeneratedField::GenerateSeries),
8055 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8056 }
8057 }
8058 }
8059 deserializer.deserialize_identifier(GeneratedVisitor)
8060 }
8061 }
8062 struct GeneratedVisitor;
8063 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8064 type Value = NowNode;
8065
8066 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8067 formatter.write_str("struct stream_plan.NowNode")
8068 }
8069
8070 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowNode, V::Error>
8071 where
8072 V: serde::de::MapAccess<'de>,
8073 {
8074 let mut state_table__ = None;
8075 let mut mode__ = None;
8076 while let Some(k) = map_.next_key()? {
8077 match k {
8078 GeneratedField::StateTable => {
8079 if state_table__.is_some() {
8080 return Err(serde::de::Error::duplicate_field("stateTable"));
8081 }
8082 state_table__ = map_.next_value()?;
8083 }
8084 GeneratedField::UpdateCurrent => {
8085 if mode__.is_some() {
8086 return Err(serde::de::Error::duplicate_field("updateCurrent"));
8087 }
8088 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::UpdateCurrent)
8089;
8090 }
8091 GeneratedField::GenerateSeries => {
8092 if mode__.is_some() {
8093 return Err(serde::de::Error::duplicate_field("generateSeries"));
8094 }
8095 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::GenerateSeries)
8096;
8097 }
8098 }
8099 }
8100 Ok(NowNode {
8101 state_table: state_table__,
8102 mode: mode__,
8103 })
8104 }
8105 }
8106 deserializer.deserialize_struct("stream_plan.NowNode", FIELDS, GeneratedVisitor)
8107 }
8108}
8109impl serde::Serialize for OverWindowCachePolicy {
8110 #[allow(deprecated)]
8111 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8112 where
8113 S: serde::Serializer,
8114 {
8115 let variant = match self {
8116 Self::Unspecified => "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
8117 Self::Full => "OVER_WINDOW_CACHE_POLICY_FULL",
8118 Self::Recent => "OVER_WINDOW_CACHE_POLICY_RECENT",
8119 Self::RecentFirstN => "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
8120 Self::RecentLastN => "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
8121 };
8122 serializer.serialize_str(variant)
8123 }
8124}
8125impl<'de> serde::Deserialize<'de> for OverWindowCachePolicy {
8126 #[allow(deprecated)]
8127 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8128 where
8129 D: serde::Deserializer<'de>,
8130 {
8131 const FIELDS: &[&str] = &[
8132 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
8133 "OVER_WINDOW_CACHE_POLICY_FULL",
8134 "OVER_WINDOW_CACHE_POLICY_RECENT",
8135 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
8136 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
8137 ];
8138
8139 struct GeneratedVisitor;
8140
8141 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8142 type Value = OverWindowCachePolicy;
8143
8144 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8145 write!(formatter, "expected one of: {:?}", &FIELDS)
8146 }
8147
8148 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8149 where
8150 E: serde::de::Error,
8151 {
8152 i32::try_from(v)
8153 .ok()
8154 .and_then(|x| x.try_into().ok())
8155 .ok_or_else(|| {
8156 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8157 })
8158 }
8159
8160 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8161 where
8162 E: serde::de::Error,
8163 {
8164 i32::try_from(v)
8165 .ok()
8166 .and_then(|x| x.try_into().ok())
8167 .ok_or_else(|| {
8168 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8169 })
8170 }
8171
8172 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8173 where
8174 E: serde::de::Error,
8175 {
8176 match value {
8177 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED" => Ok(OverWindowCachePolicy::Unspecified),
8178 "OVER_WINDOW_CACHE_POLICY_FULL" => Ok(OverWindowCachePolicy::Full),
8179 "OVER_WINDOW_CACHE_POLICY_RECENT" => Ok(OverWindowCachePolicy::Recent),
8180 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N" => Ok(OverWindowCachePolicy::RecentFirstN),
8181 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N" => Ok(OverWindowCachePolicy::RecentLastN),
8182 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8183 }
8184 }
8185 }
8186 deserializer.deserialize_any(GeneratedVisitor)
8187 }
8188}
8189impl serde::Serialize for OverWindowNode {
8190 #[allow(deprecated)]
8191 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8192 where
8193 S: serde::Serializer,
8194 {
8195 use serde::ser::SerializeStruct;
8196 let mut len = 0;
8197 if !self.calls.is_empty() {
8198 len += 1;
8199 }
8200 if !self.partition_by.is_empty() {
8201 len += 1;
8202 }
8203 if !self.order_by.is_empty() {
8204 len += 1;
8205 }
8206 if self.state_table.is_some() {
8207 len += 1;
8208 }
8209 if self.cache_policy != 0 {
8210 len += 1;
8211 }
8212 let mut struct_ser = serializer.serialize_struct("stream_plan.OverWindowNode", len)?;
8213 if !self.calls.is_empty() {
8214 struct_ser.serialize_field("calls", &self.calls)?;
8215 }
8216 if !self.partition_by.is_empty() {
8217 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
8218 }
8219 if !self.order_by.is_empty() {
8220 struct_ser.serialize_field("orderBy", &self.order_by)?;
8221 }
8222 if let Some(v) = self.state_table.as_ref() {
8223 struct_ser.serialize_field("stateTable", v)?;
8224 }
8225 if self.cache_policy != 0 {
8226 let v = OverWindowCachePolicy::try_from(self.cache_policy)
8227 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cache_policy)))?;
8228 struct_ser.serialize_field("cachePolicy", &v)?;
8229 }
8230 struct_ser.end()
8231 }
8232}
8233impl<'de> serde::Deserialize<'de> for OverWindowNode {
8234 #[allow(deprecated)]
8235 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8236 where
8237 D: serde::Deserializer<'de>,
8238 {
8239 const FIELDS: &[&str] = &[
8240 "calls",
8241 "partition_by",
8242 "partitionBy",
8243 "order_by",
8244 "orderBy",
8245 "state_table",
8246 "stateTable",
8247 "cache_policy",
8248 "cachePolicy",
8249 ];
8250
8251 #[allow(clippy::enum_variant_names)]
8252 enum GeneratedField {
8253 Calls,
8254 PartitionBy,
8255 OrderBy,
8256 StateTable,
8257 CachePolicy,
8258 }
8259 impl<'de> serde::Deserialize<'de> for GeneratedField {
8260 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8261 where
8262 D: serde::Deserializer<'de>,
8263 {
8264 struct GeneratedVisitor;
8265
8266 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8267 type Value = GeneratedField;
8268
8269 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8270 write!(formatter, "expected one of: {:?}", &FIELDS)
8271 }
8272
8273 #[allow(unused_variables)]
8274 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8275 where
8276 E: serde::de::Error,
8277 {
8278 match value {
8279 "calls" => Ok(GeneratedField::Calls),
8280 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
8281 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
8282 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
8283 "cachePolicy" | "cache_policy" => Ok(GeneratedField::CachePolicy),
8284 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8285 }
8286 }
8287 }
8288 deserializer.deserialize_identifier(GeneratedVisitor)
8289 }
8290 }
8291 struct GeneratedVisitor;
8292 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8293 type Value = OverWindowNode;
8294
8295 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8296 formatter.write_str("struct stream_plan.OverWindowNode")
8297 }
8298
8299 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverWindowNode, V::Error>
8300 where
8301 V: serde::de::MapAccess<'de>,
8302 {
8303 let mut calls__ = None;
8304 let mut partition_by__ = None;
8305 let mut order_by__ = None;
8306 let mut state_table__ = None;
8307 let mut cache_policy__ = None;
8308 while let Some(k) = map_.next_key()? {
8309 match k {
8310 GeneratedField::Calls => {
8311 if calls__.is_some() {
8312 return Err(serde::de::Error::duplicate_field("calls"));
8313 }
8314 calls__ = Some(map_.next_value()?);
8315 }
8316 GeneratedField::PartitionBy => {
8317 if partition_by__.is_some() {
8318 return Err(serde::de::Error::duplicate_field("partitionBy"));
8319 }
8320 partition_by__ =
8321 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8322 .into_iter().map(|x| x.0).collect())
8323 ;
8324 }
8325 GeneratedField::OrderBy => {
8326 if order_by__.is_some() {
8327 return Err(serde::de::Error::duplicate_field("orderBy"));
8328 }
8329 order_by__ = Some(map_.next_value()?);
8330 }
8331 GeneratedField::StateTable => {
8332 if state_table__.is_some() {
8333 return Err(serde::de::Error::duplicate_field("stateTable"));
8334 }
8335 state_table__ = map_.next_value()?;
8336 }
8337 GeneratedField::CachePolicy => {
8338 if cache_policy__.is_some() {
8339 return Err(serde::de::Error::duplicate_field("cachePolicy"));
8340 }
8341 cache_policy__ = Some(map_.next_value::<OverWindowCachePolicy>()? as i32);
8342 }
8343 }
8344 }
8345 Ok(OverWindowNode {
8346 calls: calls__.unwrap_or_default(),
8347 partition_by: partition_by__.unwrap_or_default(),
8348 order_by: order_by__.unwrap_or_default(),
8349 state_table: state_table__,
8350 cache_policy: cache_policy__.unwrap_or_default(),
8351 })
8352 }
8353 }
8354 deserializer.deserialize_struct("stream_plan.OverWindowNode", FIELDS, GeneratedVisitor)
8355 }
8356}
8357impl serde::Serialize for PauseMutation {
8358 #[allow(deprecated)]
8359 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8360 where
8361 S: serde::Serializer,
8362 {
8363 use serde::ser::SerializeStruct;
8364 let len = 0;
8365 let struct_ser = serializer.serialize_struct("stream_plan.PauseMutation", len)?;
8366 struct_ser.end()
8367 }
8368}
8369impl<'de> serde::Deserialize<'de> for PauseMutation {
8370 #[allow(deprecated)]
8371 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8372 where
8373 D: serde::Deserializer<'de>,
8374 {
8375 const FIELDS: &[&str] = &[
8376 ];
8377
8378 #[allow(clippy::enum_variant_names)]
8379 enum GeneratedField {
8380 }
8381 impl<'de> serde::Deserialize<'de> for GeneratedField {
8382 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8383 where
8384 D: serde::Deserializer<'de>,
8385 {
8386 struct GeneratedVisitor;
8387
8388 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8389 type Value = GeneratedField;
8390
8391 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8392 write!(formatter, "expected one of: {:?}", &FIELDS)
8393 }
8394
8395 #[allow(unused_variables)]
8396 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8397 where
8398 E: serde::de::Error,
8399 {
8400 Err(serde::de::Error::unknown_field(value, FIELDS))
8401 }
8402 }
8403 deserializer.deserialize_identifier(GeneratedVisitor)
8404 }
8405 }
8406 struct GeneratedVisitor;
8407 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8408 type Value = PauseMutation;
8409
8410 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8411 formatter.write_str("struct stream_plan.PauseMutation")
8412 }
8413
8414 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseMutation, V::Error>
8415 where
8416 V: serde::de::MapAccess<'de>,
8417 {
8418 while map_.next_key::<GeneratedField>()?.is_some() {
8419 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8420 }
8421 Ok(PauseMutation {
8422 })
8423 }
8424 }
8425 deserializer.deserialize_struct("stream_plan.PauseMutation", FIELDS, GeneratedVisitor)
8426 }
8427}
8428impl serde::Serialize for ProjectNode {
8429 #[allow(deprecated)]
8430 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8431 where
8432 S: serde::Serializer,
8433 {
8434 use serde::ser::SerializeStruct;
8435 let mut len = 0;
8436 if !self.select_list.is_empty() {
8437 len += 1;
8438 }
8439 if !self.watermark_input_cols.is_empty() {
8440 len += 1;
8441 }
8442 if !self.watermark_output_cols.is_empty() {
8443 len += 1;
8444 }
8445 if !self.nondecreasing_exprs.is_empty() {
8446 len += 1;
8447 }
8448 if self.noop_update_hint {
8449 len += 1;
8450 }
8451 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectNode", len)?;
8452 if !self.select_list.is_empty() {
8453 struct_ser.serialize_field("selectList", &self.select_list)?;
8454 }
8455 if !self.watermark_input_cols.is_empty() {
8456 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
8457 }
8458 if !self.watermark_output_cols.is_empty() {
8459 struct_ser.serialize_field("watermarkOutputCols", &self.watermark_output_cols)?;
8460 }
8461 if !self.nondecreasing_exprs.is_empty() {
8462 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
8463 }
8464 if self.noop_update_hint {
8465 struct_ser.serialize_field("noopUpdateHint", &self.noop_update_hint)?;
8466 }
8467 struct_ser.end()
8468 }
8469}
8470impl<'de> serde::Deserialize<'de> for ProjectNode {
8471 #[allow(deprecated)]
8472 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8473 where
8474 D: serde::Deserializer<'de>,
8475 {
8476 const FIELDS: &[&str] = &[
8477 "select_list",
8478 "selectList",
8479 "watermark_input_cols",
8480 "watermarkInputCols",
8481 "watermark_output_cols",
8482 "watermarkOutputCols",
8483 "nondecreasing_exprs",
8484 "nondecreasingExprs",
8485 "noop_update_hint",
8486 "noopUpdateHint",
8487 ];
8488
8489 #[allow(clippy::enum_variant_names)]
8490 enum GeneratedField {
8491 SelectList,
8492 WatermarkInputCols,
8493 WatermarkOutputCols,
8494 NondecreasingExprs,
8495 NoopUpdateHint,
8496 }
8497 impl<'de> serde::Deserialize<'de> for GeneratedField {
8498 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8499 where
8500 D: serde::Deserializer<'de>,
8501 {
8502 struct GeneratedVisitor;
8503
8504 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8505 type Value = GeneratedField;
8506
8507 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8508 write!(formatter, "expected one of: {:?}", &FIELDS)
8509 }
8510
8511 #[allow(unused_variables)]
8512 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8513 where
8514 E: serde::de::Error,
8515 {
8516 match value {
8517 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
8518 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
8519 "watermarkOutputCols" | "watermark_output_cols" => Ok(GeneratedField::WatermarkOutputCols),
8520 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
8521 "noopUpdateHint" | "noop_update_hint" => Ok(GeneratedField::NoopUpdateHint),
8522 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8523 }
8524 }
8525 }
8526 deserializer.deserialize_identifier(GeneratedVisitor)
8527 }
8528 }
8529 struct GeneratedVisitor;
8530 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8531 type Value = ProjectNode;
8532
8533 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8534 formatter.write_str("struct stream_plan.ProjectNode")
8535 }
8536
8537 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
8538 where
8539 V: serde::de::MapAccess<'de>,
8540 {
8541 let mut select_list__ = None;
8542 let mut watermark_input_cols__ = None;
8543 let mut watermark_output_cols__ = None;
8544 let mut nondecreasing_exprs__ = None;
8545 let mut noop_update_hint__ = None;
8546 while let Some(k) = map_.next_key()? {
8547 match k {
8548 GeneratedField::SelectList => {
8549 if select_list__.is_some() {
8550 return Err(serde::de::Error::duplicate_field("selectList"));
8551 }
8552 select_list__ = Some(map_.next_value()?);
8553 }
8554 GeneratedField::WatermarkInputCols => {
8555 if watermark_input_cols__.is_some() {
8556 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
8557 }
8558 watermark_input_cols__ =
8559 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8560 .into_iter().map(|x| x.0).collect())
8561 ;
8562 }
8563 GeneratedField::WatermarkOutputCols => {
8564 if watermark_output_cols__.is_some() {
8565 return Err(serde::de::Error::duplicate_field("watermarkOutputCols"));
8566 }
8567 watermark_output_cols__ =
8568 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8569 .into_iter().map(|x| x.0).collect())
8570 ;
8571 }
8572 GeneratedField::NondecreasingExprs => {
8573 if nondecreasing_exprs__.is_some() {
8574 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
8575 }
8576 nondecreasing_exprs__ =
8577 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8578 .into_iter().map(|x| x.0).collect())
8579 ;
8580 }
8581 GeneratedField::NoopUpdateHint => {
8582 if noop_update_hint__.is_some() {
8583 return Err(serde::de::Error::duplicate_field("noopUpdateHint"));
8584 }
8585 noop_update_hint__ = Some(map_.next_value()?);
8586 }
8587 }
8588 }
8589 Ok(ProjectNode {
8590 select_list: select_list__.unwrap_or_default(),
8591 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
8592 watermark_output_cols: watermark_output_cols__.unwrap_or_default(),
8593 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
8594 noop_update_hint: noop_update_hint__.unwrap_or_default(),
8595 })
8596 }
8597 }
8598 deserializer.deserialize_struct("stream_plan.ProjectNode", FIELDS, GeneratedVisitor)
8599 }
8600}
8601impl serde::Serialize for ProjectSetNode {
8602 #[allow(deprecated)]
8603 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8604 where
8605 S: serde::Serializer,
8606 {
8607 use serde::ser::SerializeStruct;
8608 let mut len = 0;
8609 if !self.select_list.is_empty() {
8610 len += 1;
8611 }
8612 if !self.watermark_input_cols.is_empty() {
8613 len += 1;
8614 }
8615 if !self.watermark_expr_indices.is_empty() {
8616 len += 1;
8617 }
8618 if !self.nondecreasing_exprs.is_empty() {
8619 len += 1;
8620 }
8621 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectSetNode", len)?;
8622 if !self.select_list.is_empty() {
8623 struct_ser.serialize_field("selectList", &self.select_list)?;
8624 }
8625 if !self.watermark_input_cols.is_empty() {
8626 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
8627 }
8628 if !self.watermark_expr_indices.is_empty() {
8629 struct_ser.serialize_field("watermarkExprIndices", &self.watermark_expr_indices)?;
8630 }
8631 if !self.nondecreasing_exprs.is_empty() {
8632 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
8633 }
8634 struct_ser.end()
8635 }
8636}
8637impl<'de> serde::Deserialize<'de> for ProjectSetNode {
8638 #[allow(deprecated)]
8639 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8640 where
8641 D: serde::Deserializer<'de>,
8642 {
8643 const FIELDS: &[&str] = &[
8644 "select_list",
8645 "selectList",
8646 "watermark_input_cols",
8647 "watermarkInputCols",
8648 "watermark_expr_indices",
8649 "watermarkExprIndices",
8650 "nondecreasing_exprs",
8651 "nondecreasingExprs",
8652 ];
8653
8654 #[allow(clippy::enum_variant_names)]
8655 enum GeneratedField {
8656 SelectList,
8657 WatermarkInputCols,
8658 WatermarkExprIndices,
8659 NondecreasingExprs,
8660 }
8661 impl<'de> serde::Deserialize<'de> for GeneratedField {
8662 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8663 where
8664 D: serde::Deserializer<'de>,
8665 {
8666 struct GeneratedVisitor;
8667
8668 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8669 type Value = GeneratedField;
8670
8671 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8672 write!(formatter, "expected one of: {:?}", &FIELDS)
8673 }
8674
8675 #[allow(unused_variables)]
8676 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8677 where
8678 E: serde::de::Error,
8679 {
8680 match value {
8681 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
8682 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
8683 "watermarkExprIndices" | "watermark_expr_indices" => Ok(GeneratedField::WatermarkExprIndices),
8684 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
8685 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8686 }
8687 }
8688 }
8689 deserializer.deserialize_identifier(GeneratedVisitor)
8690 }
8691 }
8692 struct GeneratedVisitor;
8693 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8694 type Value = ProjectSetNode;
8695
8696 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8697 formatter.write_str("struct stream_plan.ProjectSetNode")
8698 }
8699
8700 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
8701 where
8702 V: serde::de::MapAccess<'de>,
8703 {
8704 let mut select_list__ = None;
8705 let mut watermark_input_cols__ = None;
8706 let mut watermark_expr_indices__ = None;
8707 let mut nondecreasing_exprs__ = None;
8708 while let Some(k) = map_.next_key()? {
8709 match k {
8710 GeneratedField::SelectList => {
8711 if select_list__.is_some() {
8712 return Err(serde::de::Error::duplicate_field("selectList"));
8713 }
8714 select_list__ = Some(map_.next_value()?);
8715 }
8716 GeneratedField::WatermarkInputCols => {
8717 if watermark_input_cols__.is_some() {
8718 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
8719 }
8720 watermark_input_cols__ =
8721 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8722 .into_iter().map(|x| x.0).collect())
8723 ;
8724 }
8725 GeneratedField::WatermarkExprIndices => {
8726 if watermark_expr_indices__.is_some() {
8727 return Err(serde::de::Error::duplicate_field("watermarkExprIndices"));
8728 }
8729 watermark_expr_indices__ =
8730 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8731 .into_iter().map(|x| x.0).collect())
8732 ;
8733 }
8734 GeneratedField::NondecreasingExprs => {
8735 if nondecreasing_exprs__.is_some() {
8736 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
8737 }
8738 nondecreasing_exprs__ =
8739 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8740 .into_iter().map(|x| x.0).collect())
8741 ;
8742 }
8743 }
8744 }
8745 Ok(ProjectSetNode {
8746 select_list: select_list__.unwrap_or_default(),
8747 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
8748 watermark_expr_indices: watermark_expr_indices__.unwrap_or_default(),
8749 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
8750 })
8751 }
8752 }
8753 deserializer.deserialize_struct("stream_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
8754 }
8755}
8756impl serde::Serialize for RefreshStartMutation {
8757 #[allow(deprecated)]
8758 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8759 where
8760 S: serde::Serializer,
8761 {
8762 use serde::ser::SerializeStruct;
8763 let mut len = 0;
8764 if self.table_id != 0 {
8765 len += 1;
8766 }
8767 if self.associated_source_id != 0 {
8768 len += 1;
8769 }
8770 let mut struct_ser = serializer.serialize_struct("stream_plan.RefreshStartMutation", len)?;
8771 if self.table_id != 0 {
8772 struct_ser.serialize_field("tableId", &self.table_id)?;
8773 }
8774 if self.associated_source_id != 0 {
8775 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
8776 }
8777 struct_ser.end()
8778 }
8779}
8780impl<'de> serde::Deserialize<'de> for RefreshStartMutation {
8781 #[allow(deprecated)]
8782 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8783 where
8784 D: serde::Deserializer<'de>,
8785 {
8786 const FIELDS: &[&str] = &[
8787 "table_id",
8788 "tableId",
8789 "associated_source_id",
8790 "associatedSourceId",
8791 ];
8792
8793 #[allow(clippy::enum_variant_names)]
8794 enum GeneratedField {
8795 TableId,
8796 AssociatedSourceId,
8797 }
8798 impl<'de> serde::Deserialize<'de> for GeneratedField {
8799 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8800 where
8801 D: serde::Deserializer<'de>,
8802 {
8803 struct GeneratedVisitor;
8804
8805 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8806 type Value = GeneratedField;
8807
8808 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8809 write!(formatter, "expected one of: {:?}", &FIELDS)
8810 }
8811
8812 #[allow(unused_variables)]
8813 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8814 where
8815 E: serde::de::Error,
8816 {
8817 match value {
8818 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8819 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
8820 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8821 }
8822 }
8823 }
8824 deserializer.deserialize_identifier(GeneratedVisitor)
8825 }
8826 }
8827 struct GeneratedVisitor;
8828 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8829 type Value = RefreshStartMutation;
8830
8831 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8832 formatter.write_str("struct stream_plan.RefreshStartMutation")
8833 }
8834
8835 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshStartMutation, V::Error>
8836 where
8837 V: serde::de::MapAccess<'de>,
8838 {
8839 let mut table_id__ = None;
8840 let mut associated_source_id__ = None;
8841 while let Some(k) = map_.next_key()? {
8842 match k {
8843 GeneratedField::TableId => {
8844 if table_id__.is_some() {
8845 return Err(serde::de::Error::duplicate_field("tableId"));
8846 }
8847 table_id__ =
8848 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8849 ;
8850 }
8851 GeneratedField::AssociatedSourceId => {
8852 if associated_source_id__.is_some() {
8853 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
8854 }
8855 associated_source_id__ =
8856 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8857 ;
8858 }
8859 }
8860 }
8861 Ok(RefreshStartMutation {
8862 table_id: table_id__.unwrap_or_default(),
8863 associated_source_id: associated_source_id__.unwrap_or_default(),
8864 })
8865 }
8866 }
8867 deserializer.deserialize_struct("stream_plan.RefreshStartMutation", FIELDS, GeneratedVisitor)
8868 }
8869}
8870impl serde::Serialize for ResumeMutation {
8871 #[allow(deprecated)]
8872 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8873 where
8874 S: serde::Serializer,
8875 {
8876 use serde::ser::SerializeStruct;
8877 let len = 0;
8878 let struct_ser = serializer.serialize_struct("stream_plan.ResumeMutation", len)?;
8879 struct_ser.end()
8880 }
8881}
8882impl<'de> serde::Deserialize<'de> for ResumeMutation {
8883 #[allow(deprecated)]
8884 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8885 where
8886 D: serde::Deserializer<'de>,
8887 {
8888 const FIELDS: &[&str] = &[
8889 ];
8890
8891 #[allow(clippy::enum_variant_names)]
8892 enum GeneratedField {
8893 }
8894 impl<'de> serde::Deserialize<'de> for GeneratedField {
8895 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8896 where
8897 D: serde::Deserializer<'de>,
8898 {
8899 struct GeneratedVisitor;
8900
8901 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8902 type Value = GeneratedField;
8903
8904 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8905 write!(formatter, "expected one of: {:?}", &FIELDS)
8906 }
8907
8908 #[allow(unused_variables)]
8909 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8910 where
8911 E: serde::de::Error,
8912 {
8913 Err(serde::de::Error::unknown_field(value, FIELDS))
8914 }
8915 }
8916 deserializer.deserialize_identifier(GeneratedVisitor)
8917 }
8918 }
8919 struct GeneratedVisitor;
8920 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8921 type Value = ResumeMutation;
8922
8923 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8924 formatter.write_str("struct stream_plan.ResumeMutation")
8925 }
8926
8927 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeMutation, V::Error>
8928 where
8929 V: serde::de::MapAccess<'de>,
8930 {
8931 while map_.next_key::<GeneratedField>()?.is_some() {
8932 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8933 }
8934 Ok(ResumeMutation {
8935 })
8936 }
8937 }
8938 deserializer.deserialize_struct("stream_plan.ResumeMutation", FIELDS, GeneratedVisitor)
8939 }
8940}
8941impl serde::Serialize for RowIdGenNode {
8942 #[allow(deprecated)]
8943 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8944 where
8945 S: serde::Serializer,
8946 {
8947 use serde::ser::SerializeStruct;
8948 let mut len = 0;
8949 if self.row_id_index != 0 {
8950 len += 1;
8951 }
8952 let mut struct_ser = serializer.serialize_struct("stream_plan.RowIdGenNode", len)?;
8953 if self.row_id_index != 0 {
8954 #[allow(clippy::needless_borrow)]
8955 #[allow(clippy::needless_borrows_for_generic_args)]
8956 struct_ser.serialize_field("rowIdIndex", ToString::to_string(&self.row_id_index).as_str())?;
8957 }
8958 struct_ser.end()
8959 }
8960}
8961impl<'de> serde::Deserialize<'de> for RowIdGenNode {
8962 #[allow(deprecated)]
8963 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8964 where
8965 D: serde::Deserializer<'de>,
8966 {
8967 const FIELDS: &[&str] = &[
8968 "row_id_index",
8969 "rowIdIndex",
8970 ];
8971
8972 #[allow(clippy::enum_variant_names)]
8973 enum GeneratedField {
8974 RowIdIndex,
8975 }
8976 impl<'de> serde::Deserialize<'de> for GeneratedField {
8977 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8978 where
8979 D: serde::Deserializer<'de>,
8980 {
8981 struct GeneratedVisitor;
8982
8983 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8984 type Value = GeneratedField;
8985
8986 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8987 write!(formatter, "expected one of: {:?}", &FIELDS)
8988 }
8989
8990 #[allow(unused_variables)]
8991 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8992 where
8993 E: serde::de::Error,
8994 {
8995 match value {
8996 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
8997 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8998 }
8999 }
9000 }
9001 deserializer.deserialize_identifier(GeneratedVisitor)
9002 }
9003 }
9004 struct GeneratedVisitor;
9005 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9006 type Value = RowIdGenNode;
9007
9008 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9009 formatter.write_str("struct stream_plan.RowIdGenNode")
9010 }
9011
9012 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowIdGenNode, V::Error>
9013 where
9014 V: serde::de::MapAccess<'de>,
9015 {
9016 let mut row_id_index__ = None;
9017 while let Some(k) = map_.next_key()? {
9018 match k {
9019 GeneratedField::RowIdIndex => {
9020 if row_id_index__.is_some() {
9021 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
9022 }
9023 row_id_index__ =
9024 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9025 ;
9026 }
9027 }
9028 }
9029 Ok(RowIdGenNode {
9030 row_id_index: row_id_index__.unwrap_or_default(),
9031 })
9032 }
9033 }
9034 deserializer.deserialize_struct("stream_plan.RowIdGenNode", FIELDS, GeneratedVisitor)
9035 }
9036}
9037impl serde::Serialize for RowMergeNode {
9038 #[allow(deprecated)]
9039 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9040 where
9041 S: serde::Serializer,
9042 {
9043 use serde::ser::SerializeStruct;
9044 let mut len = 0;
9045 if self.lhs_mapping.is_some() {
9046 len += 1;
9047 }
9048 if self.rhs_mapping.is_some() {
9049 len += 1;
9050 }
9051 let mut struct_ser = serializer.serialize_struct("stream_plan.RowMergeNode", len)?;
9052 if let Some(v) = self.lhs_mapping.as_ref() {
9053 struct_ser.serialize_field("lhsMapping", v)?;
9054 }
9055 if let Some(v) = self.rhs_mapping.as_ref() {
9056 struct_ser.serialize_field("rhsMapping", v)?;
9057 }
9058 struct_ser.end()
9059 }
9060}
9061impl<'de> serde::Deserialize<'de> for RowMergeNode {
9062 #[allow(deprecated)]
9063 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9064 where
9065 D: serde::Deserializer<'de>,
9066 {
9067 const FIELDS: &[&str] = &[
9068 "lhs_mapping",
9069 "lhsMapping",
9070 "rhs_mapping",
9071 "rhsMapping",
9072 ];
9073
9074 #[allow(clippy::enum_variant_names)]
9075 enum GeneratedField {
9076 LhsMapping,
9077 RhsMapping,
9078 }
9079 impl<'de> serde::Deserialize<'de> for GeneratedField {
9080 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9081 where
9082 D: serde::Deserializer<'de>,
9083 {
9084 struct GeneratedVisitor;
9085
9086 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9087 type Value = GeneratedField;
9088
9089 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9090 write!(formatter, "expected one of: {:?}", &FIELDS)
9091 }
9092
9093 #[allow(unused_variables)]
9094 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9095 where
9096 E: serde::de::Error,
9097 {
9098 match value {
9099 "lhsMapping" | "lhs_mapping" => Ok(GeneratedField::LhsMapping),
9100 "rhsMapping" | "rhs_mapping" => Ok(GeneratedField::RhsMapping),
9101 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9102 }
9103 }
9104 }
9105 deserializer.deserialize_identifier(GeneratedVisitor)
9106 }
9107 }
9108 struct GeneratedVisitor;
9109 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9110 type Value = RowMergeNode;
9111
9112 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9113 formatter.write_str("struct stream_plan.RowMergeNode")
9114 }
9115
9116 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowMergeNode, V::Error>
9117 where
9118 V: serde::de::MapAccess<'de>,
9119 {
9120 let mut lhs_mapping__ = None;
9121 let mut rhs_mapping__ = None;
9122 while let Some(k) = map_.next_key()? {
9123 match k {
9124 GeneratedField::LhsMapping => {
9125 if lhs_mapping__.is_some() {
9126 return Err(serde::de::Error::duplicate_field("lhsMapping"));
9127 }
9128 lhs_mapping__ = map_.next_value()?;
9129 }
9130 GeneratedField::RhsMapping => {
9131 if rhs_mapping__.is_some() {
9132 return Err(serde::de::Error::duplicate_field("rhsMapping"));
9133 }
9134 rhs_mapping__ = map_.next_value()?;
9135 }
9136 }
9137 }
9138 Ok(RowMergeNode {
9139 lhs_mapping: lhs_mapping__,
9140 rhs_mapping: rhs_mapping__,
9141 })
9142 }
9143 }
9144 deserializer.deserialize_struct("stream_plan.RowMergeNode", FIELDS, GeneratedVisitor)
9145 }
9146}
9147impl serde::Serialize for SimpleAggNode {
9148 #[allow(deprecated)]
9149 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9150 where
9151 S: serde::Serializer,
9152 {
9153 use serde::ser::SerializeStruct;
9154 let mut len = 0;
9155 if !self.agg_calls.is_empty() {
9156 len += 1;
9157 }
9158 if !self.agg_call_states.is_empty() {
9159 len += 1;
9160 }
9161 if self.intermediate_state_table.is_some() {
9162 len += 1;
9163 }
9164 if self.is_append_only {
9165 len += 1;
9166 }
9167 if !self.distinct_dedup_tables.is_empty() {
9168 len += 1;
9169 }
9170 if self.row_count_index != 0 {
9171 len += 1;
9172 }
9173 if self.version != 0 {
9174 len += 1;
9175 }
9176 if self.must_output_per_barrier {
9177 len += 1;
9178 }
9179 let mut struct_ser = serializer.serialize_struct("stream_plan.SimpleAggNode", len)?;
9180 if !self.agg_calls.is_empty() {
9181 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
9182 }
9183 if !self.agg_call_states.is_empty() {
9184 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
9185 }
9186 if let Some(v) = self.intermediate_state_table.as_ref() {
9187 struct_ser.serialize_field("intermediateStateTable", v)?;
9188 }
9189 if self.is_append_only {
9190 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
9191 }
9192 if !self.distinct_dedup_tables.is_empty() {
9193 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
9194 }
9195 if self.row_count_index != 0 {
9196 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
9197 }
9198 if self.version != 0 {
9199 let v = AggNodeVersion::try_from(self.version)
9200 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
9201 struct_ser.serialize_field("version", &v)?;
9202 }
9203 if self.must_output_per_barrier {
9204 struct_ser.serialize_field("mustOutputPerBarrier", &self.must_output_per_barrier)?;
9205 }
9206 struct_ser.end()
9207 }
9208}
9209impl<'de> serde::Deserialize<'de> for SimpleAggNode {
9210 #[allow(deprecated)]
9211 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9212 where
9213 D: serde::Deserializer<'de>,
9214 {
9215 const FIELDS: &[&str] = &[
9216 "agg_calls",
9217 "aggCalls",
9218 "agg_call_states",
9219 "aggCallStates",
9220 "intermediate_state_table",
9221 "intermediateStateTable",
9222 "is_append_only",
9223 "isAppendOnly",
9224 "distinct_dedup_tables",
9225 "distinctDedupTables",
9226 "row_count_index",
9227 "rowCountIndex",
9228 "version",
9229 "must_output_per_barrier",
9230 "mustOutputPerBarrier",
9231 ];
9232
9233 #[allow(clippy::enum_variant_names)]
9234 enum GeneratedField {
9235 AggCalls,
9236 AggCallStates,
9237 IntermediateStateTable,
9238 IsAppendOnly,
9239 DistinctDedupTables,
9240 RowCountIndex,
9241 Version,
9242 MustOutputPerBarrier,
9243 }
9244 impl<'de> serde::Deserialize<'de> for GeneratedField {
9245 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9246 where
9247 D: serde::Deserializer<'de>,
9248 {
9249 struct GeneratedVisitor;
9250
9251 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9252 type Value = GeneratedField;
9253
9254 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9255 write!(formatter, "expected one of: {:?}", &FIELDS)
9256 }
9257
9258 #[allow(unused_variables)]
9259 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9260 where
9261 E: serde::de::Error,
9262 {
9263 match value {
9264 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
9265 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
9266 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
9267 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
9268 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
9269 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
9270 "version" => Ok(GeneratedField::Version),
9271 "mustOutputPerBarrier" | "must_output_per_barrier" => Ok(GeneratedField::MustOutputPerBarrier),
9272 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9273 }
9274 }
9275 }
9276 deserializer.deserialize_identifier(GeneratedVisitor)
9277 }
9278 }
9279 struct GeneratedVisitor;
9280 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9281 type Value = SimpleAggNode;
9282
9283 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9284 formatter.write_str("struct stream_plan.SimpleAggNode")
9285 }
9286
9287 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SimpleAggNode, V::Error>
9288 where
9289 V: serde::de::MapAccess<'de>,
9290 {
9291 let mut agg_calls__ = None;
9292 let mut agg_call_states__ = None;
9293 let mut intermediate_state_table__ = None;
9294 let mut is_append_only__ = None;
9295 let mut distinct_dedup_tables__ = None;
9296 let mut row_count_index__ = None;
9297 let mut version__ = None;
9298 let mut must_output_per_barrier__ = None;
9299 while let Some(k) = map_.next_key()? {
9300 match k {
9301 GeneratedField::AggCalls => {
9302 if agg_calls__.is_some() {
9303 return Err(serde::de::Error::duplicate_field("aggCalls"));
9304 }
9305 agg_calls__ = Some(map_.next_value()?);
9306 }
9307 GeneratedField::AggCallStates => {
9308 if agg_call_states__.is_some() {
9309 return Err(serde::de::Error::duplicate_field("aggCallStates"));
9310 }
9311 agg_call_states__ = Some(map_.next_value()?);
9312 }
9313 GeneratedField::IntermediateStateTable => {
9314 if intermediate_state_table__.is_some() {
9315 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
9316 }
9317 intermediate_state_table__ = map_.next_value()?;
9318 }
9319 GeneratedField::IsAppendOnly => {
9320 if is_append_only__.is_some() {
9321 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
9322 }
9323 is_append_only__ = Some(map_.next_value()?);
9324 }
9325 GeneratedField::DistinctDedupTables => {
9326 if distinct_dedup_tables__.is_some() {
9327 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
9328 }
9329 distinct_dedup_tables__ = Some(
9330 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
9331 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
9332 );
9333 }
9334 GeneratedField::RowCountIndex => {
9335 if row_count_index__.is_some() {
9336 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
9337 }
9338 row_count_index__ =
9339 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9340 ;
9341 }
9342 GeneratedField::Version => {
9343 if version__.is_some() {
9344 return Err(serde::de::Error::duplicate_field("version"));
9345 }
9346 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
9347 }
9348 GeneratedField::MustOutputPerBarrier => {
9349 if must_output_per_barrier__.is_some() {
9350 return Err(serde::de::Error::duplicate_field("mustOutputPerBarrier"));
9351 }
9352 must_output_per_barrier__ = Some(map_.next_value()?);
9353 }
9354 }
9355 }
9356 Ok(SimpleAggNode {
9357 agg_calls: agg_calls__.unwrap_or_default(),
9358 agg_call_states: agg_call_states__.unwrap_or_default(),
9359 intermediate_state_table: intermediate_state_table__,
9360 is_append_only: is_append_only__.unwrap_or_default(),
9361 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
9362 row_count_index: row_count_index__.unwrap_or_default(),
9363 version: version__.unwrap_or_default(),
9364 must_output_per_barrier: must_output_per_barrier__.unwrap_or_default(),
9365 })
9366 }
9367 }
9368 deserializer.deserialize_struct("stream_plan.SimpleAggNode", FIELDS, GeneratedVisitor)
9369 }
9370}
9371impl serde::Serialize for SinkAddColumns {
9372 #[allow(deprecated)]
9373 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9374 where
9375 S: serde::Serializer,
9376 {
9377 use serde::ser::SerializeStruct;
9378 let mut len = 0;
9379 if !self.fields.is_empty() {
9380 len += 1;
9381 }
9382 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkAddColumns", len)?;
9383 if !self.fields.is_empty() {
9384 struct_ser.serialize_field("fields", &self.fields)?;
9385 }
9386 struct_ser.end()
9387 }
9388}
9389impl<'de> serde::Deserialize<'de> for SinkAddColumns {
9390 #[allow(deprecated)]
9391 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9392 where
9393 D: serde::Deserializer<'de>,
9394 {
9395 const FIELDS: &[&str] = &[
9396 "fields",
9397 ];
9398
9399 #[allow(clippy::enum_variant_names)]
9400 enum GeneratedField {
9401 Fields,
9402 }
9403 impl<'de> serde::Deserialize<'de> for GeneratedField {
9404 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9405 where
9406 D: serde::Deserializer<'de>,
9407 {
9408 struct GeneratedVisitor;
9409
9410 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9411 type Value = GeneratedField;
9412
9413 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9414 write!(formatter, "expected one of: {:?}", &FIELDS)
9415 }
9416
9417 #[allow(unused_variables)]
9418 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9419 where
9420 E: serde::de::Error,
9421 {
9422 match value {
9423 "fields" => Ok(GeneratedField::Fields),
9424 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9425 }
9426 }
9427 }
9428 deserializer.deserialize_identifier(GeneratedVisitor)
9429 }
9430 }
9431 struct GeneratedVisitor;
9432 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9433 type Value = SinkAddColumns;
9434
9435 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9436 formatter.write_str("struct stream_plan.SinkAddColumns")
9437 }
9438
9439 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkAddColumns, V::Error>
9440 where
9441 V: serde::de::MapAccess<'de>,
9442 {
9443 let mut fields__ = None;
9444 while let Some(k) = map_.next_key()? {
9445 match k {
9446 GeneratedField::Fields => {
9447 if fields__.is_some() {
9448 return Err(serde::de::Error::duplicate_field("fields"));
9449 }
9450 fields__ = Some(map_.next_value()?);
9451 }
9452 }
9453 }
9454 Ok(SinkAddColumns {
9455 fields: fields__.unwrap_or_default(),
9456 })
9457 }
9458 }
9459 deserializer.deserialize_struct("stream_plan.SinkAddColumns", FIELDS, GeneratedVisitor)
9460 }
9461}
9462impl serde::Serialize for SinkDesc {
9463 #[allow(deprecated)]
9464 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9465 where
9466 S: serde::Serializer,
9467 {
9468 use serde::ser::SerializeStruct;
9469 let mut len = 0;
9470 if self.id != 0 {
9471 len += 1;
9472 }
9473 if !self.name.is_empty() {
9474 len += 1;
9475 }
9476 if !self.definition.is_empty() {
9477 len += 1;
9478 }
9479 if !self.plan_pk.is_empty() {
9480 len += 1;
9481 }
9482 if !self.downstream_pk.is_empty() {
9483 len += 1;
9484 }
9485 if !self.distribution_key.is_empty() {
9486 len += 1;
9487 }
9488 if !self.properties.is_empty() {
9489 len += 1;
9490 }
9491 if self.sink_type != 0 {
9492 len += 1;
9493 }
9494 if !self.column_catalogs.is_empty() {
9495 len += 1;
9496 }
9497 if !self.db_name.is_empty() {
9498 len += 1;
9499 }
9500 if !self.sink_from_name.is_empty() {
9501 len += 1;
9502 }
9503 if self.format_desc.is_some() {
9504 len += 1;
9505 }
9506 if self.target_table.is_some() {
9507 len += 1;
9508 }
9509 if self.extra_partition_col_idx.is_some() {
9510 len += 1;
9511 }
9512 if !self.secret_refs.is_empty() {
9513 len += 1;
9514 }
9515 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDesc", len)?;
9516 if self.id != 0 {
9517 struct_ser.serialize_field("id", &self.id)?;
9518 }
9519 if !self.name.is_empty() {
9520 struct_ser.serialize_field("name", &self.name)?;
9521 }
9522 if !self.definition.is_empty() {
9523 struct_ser.serialize_field("definition", &self.definition)?;
9524 }
9525 if !self.plan_pk.is_empty() {
9526 struct_ser.serialize_field("planPk", &self.plan_pk)?;
9527 }
9528 if !self.downstream_pk.is_empty() {
9529 struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
9530 }
9531 if !self.distribution_key.is_empty() {
9532 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
9533 }
9534 if !self.properties.is_empty() {
9535 struct_ser.serialize_field("properties", &self.properties)?;
9536 }
9537 if self.sink_type != 0 {
9538 let v = super::catalog::SinkType::try_from(self.sink_type)
9539 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
9540 struct_ser.serialize_field("sinkType", &v)?;
9541 }
9542 if !self.column_catalogs.is_empty() {
9543 struct_ser.serialize_field("columnCatalogs", &self.column_catalogs)?;
9544 }
9545 if !self.db_name.is_empty() {
9546 struct_ser.serialize_field("dbName", &self.db_name)?;
9547 }
9548 if !self.sink_from_name.is_empty() {
9549 struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
9550 }
9551 if let Some(v) = self.format_desc.as_ref() {
9552 struct_ser.serialize_field("formatDesc", v)?;
9553 }
9554 if let Some(v) = self.target_table.as_ref() {
9555 struct_ser.serialize_field("targetTable", v)?;
9556 }
9557 if let Some(v) = self.extra_partition_col_idx.as_ref() {
9558 #[allow(clippy::needless_borrow)]
9559 #[allow(clippy::needless_borrows_for_generic_args)]
9560 struct_ser.serialize_field("extraPartitionColIdx", ToString::to_string(&v).as_str())?;
9561 }
9562 if !self.secret_refs.is_empty() {
9563 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
9564 }
9565 struct_ser.end()
9566 }
9567}
9568impl<'de> serde::Deserialize<'de> for SinkDesc {
9569 #[allow(deprecated)]
9570 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9571 where
9572 D: serde::Deserializer<'de>,
9573 {
9574 const FIELDS: &[&str] = &[
9575 "id",
9576 "name",
9577 "definition",
9578 "plan_pk",
9579 "planPk",
9580 "downstream_pk",
9581 "downstreamPk",
9582 "distribution_key",
9583 "distributionKey",
9584 "properties",
9585 "sink_type",
9586 "sinkType",
9587 "column_catalogs",
9588 "columnCatalogs",
9589 "db_name",
9590 "dbName",
9591 "sink_from_name",
9592 "sinkFromName",
9593 "format_desc",
9594 "formatDesc",
9595 "target_table",
9596 "targetTable",
9597 "extra_partition_col_idx",
9598 "extraPartitionColIdx",
9599 "secret_refs",
9600 "secretRefs",
9601 ];
9602
9603 #[allow(clippy::enum_variant_names)]
9604 enum GeneratedField {
9605 Id,
9606 Name,
9607 Definition,
9608 PlanPk,
9609 DownstreamPk,
9610 DistributionKey,
9611 Properties,
9612 SinkType,
9613 ColumnCatalogs,
9614 DbName,
9615 SinkFromName,
9616 FormatDesc,
9617 TargetTable,
9618 ExtraPartitionColIdx,
9619 SecretRefs,
9620 }
9621 impl<'de> serde::Deserialize<'de> for GeneratedField {
9622 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9623 where
9624 D: serde::Deserializer<'de>,
9625 {
9626 struct GeneratedVisitor;
9627
9628 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9629 type Value = GeneratedField;
9630
9631 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9632 write!(formatter, "expected one of: {:?}", &FIELDS)
9633 }
9634
9635 #[allow(unused_variables)]
9636 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9637 where
9638 E: serde::de::Error,
9639 {
9640 match value {
9641 "id" => Ok(GeneratedField::Id),
9642 "name" => Ok(GeneratedField::Name),
9643 "definition" => Ok(GeneratedField::Definition),
9644 "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
9645 "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
9646 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
9647 "properties" => Ok(GeneratedField::Properties),
9648 "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
9649 "columnCatalogs" | "column_catalogs" => Ok(GeneratedField::ColumnCatalogs),
9650 "dbName" | "db_name" => Ok(GeneratedField::DbName),
9651 "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
9652 "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
9653 "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
9654 "extraPartitionColIdx" | "extra_partition_col_idx" => Ok(GeneratedField::ExtraPartitionColIdx),
9655 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
9656 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9657 }
9658 }
9659 }
9660 deserializer.deserialize_identifier(GeneratedVisitor)
9661 }
9662 }
9663 struct GeneratedVisitor;
9664 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9665 type Value = SinkDesc;
9666
9667 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9668 formatter.write_str("struct stream_plan.SinkDesc")
9669 }
9670
9671 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDesc, V::Error>
9672 where
9673 V: serde::de::MapAccess<'de>,
9674 {
9675 let mut id__ = None;
9676 let mut name__ = None;
9677 let mut definition__ = None;
9678 let mut plan_pk__ = None;
9679 let mut downstream_pk__ = None;
9680 let mut distribution_key__ = None;
9681 let mut properties__ = None;
9682 let mut sink_type__ = None;
9683 let mut column_catalogs__ = None;
9684 let mut db_name__ = None;
9685 let mut sink_from_name__ = None;
9686 let mut format_desc__ = None;
9687 let mut target_table__ = None;
9688 let mut extra_partition_col_idx__ = None;
9689 let mut secret_refs__ = None;
9690 while let Some(k) = map_.next_key()? {
9691 match k {
9692 GeneratedField::Id => {
9693 if id__.is_some() {
9694 return Err(serde::de::Error::duplicate_field("id"));
9695 }
9696 id__ =
9697 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9698 ;
9699 }
9700 GeneratedField::Name => {
9701 if name__.is_some() {
9702 return Err(serde::de::Error::duplicate_field("name"));
9703 }
9704 name__ = Some(map_.next_value()?);
9705 }
9706 GeneratedField::Definition => {
9707 if definition__.is_some() {
9708 return Err(serde::de::Error::duplicate_field("definition"));
9709 }
9710 definition__ = Some(map_.next_value()?);
9711 }
9712 GeneratedField::PlanPk => {
9713 if plan_pk__.is_some() {
9714 return Err(serde::de::Error::duplicate_field("planPk"));
9715 }
9716 plan_pk__ = Some(map_.next_value()?);
9717 }
9718 GeneratedField::DownstreamPk => {
9719 if downstream_pk__.is_some() {
9720 return Err(serde::de::Error::duplicate_field("downstreamPk"));
9721 }
9722 downstream_pk__ =
9723 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9724 .into_iter().map(|x| x.0).collect())
9725 ;
9726 }
9727 GeneratedField::DistributionKey => {
9728 if distribution_key__.is_some() {
9729 return Err(serde::de::Error::duplicate_field("distributionKey"));
9730 }
9731 distribution_key__ =
9732 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9733 .into_iter().map(|x| x.0).collect())
9734 ;
9735 }
9736 GeneratedField::Properties => {
9737 if properties__.is_some() {
9738 return Err(serde::de::Error::duplicate_field("properties"));
9739 }
9740 properties__ = Some(
9741 map_.next_value::<std::collections::BTreeMap<_, _>>()?
9742 );
9743 }
9744 GeneratedField::SinkType => {
9745 if sink_type__.is_some() {
9746 return Err(serde::de::Error::duplicate_field("sinkType"));
9747 }
9748 sink_type__ = Some(map_.next_value::<super::catalog::SinkType>()? as i32);
9749 }
9750 GeneratedField::ColumnCatalogs => {
9751 if column_catalogs__.is_some() {
9752 return Err(serde::de::Error::duplicate_field("columnCatalogs"));
9753 }
9754 column_catalogs__ = Some(map_.next_value()?);
9755 }
9756 GeneratedField::DbName => {
9757 if db_name__.is_some() {
9758 return Err(serde::de::Error::duplicate_field("dbName"));
9759 }
9760 db_name__ = Some(map_.next_value()?);
9761 }
9762 GeneratedField::SinkFromName => {
9763 if sink_from_name__.is_some() {
9764 return Err(serde::de::Error::duplicate_field("sinkFromName"));
9765 }
9766 sink_from_name__ = Some(map_.next_value()?);
9767 }
9768 GeneratedField::FormatDesc => {
9769 if format_desc__.is_some() {
9770 return Err(serde::de::Error::duplicate_field("formatDesc"));
9771 }
9772 format_desc__ = map_.next_value()?;
9773 }
9774 GeneratedField::TargetTable => {
9775 if target_table__.is_some() {
9776 return Err(serde::de::Error::duplicate_field("targetTable"));
9777 }
9778 target_table__ =
9779 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9780 ;
9781 }
9782 GeneratedField::ExtraPartitionColIdx => {
9783 if extra_partition_col_idx__.is_some() {
9784 return Err(serde::de::Error::duplicate_field("extraPartitionColIdx"));
9785 }
9786 extra_partition_col_idx__ =
9787 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9788 ;
9789 }
9790 GeneratedField::SecretRefs => {
9791 if secret_refs__.is_some() {
9792 return Err(serde::de::Error::duplicate_field("secretRefs"));
9793 }
9794 secret_refs__ = Some(
9795 map_.next_value::<std::collections::BTreeMap<_, _>>()?
9796 );
9797 }
9798 }
9799 }
9800 Ok(SinkDesc {
9801 id: id__.unwrap_or_default(),
9802 name: name__.unwrap_or_default(),
9803 definition: definition__.unwrap_or_default(),
9804 plan_pk: plan_pk__.unwrap_or_default(),
9805 downstream_pk: downstream_pk__.unwrap_or_default(),
9806 distribution_key: distribution_key__.unwrap_or_default(),
9807 properties: properties__.unwrap_or_default(),
9808 sink_type: sink_type__.unwrap_or_default(),
9809 column_catalogs: column_catalogs__.unwrap_or_default(),
9810 db_name: db_name__.unwrap_or_default(),
9811 sink_from_name: sink_from_name__.unwrap_or_default(),
9812 format_desc: format_desc__,
9813 target_table: target_table__,
9814 extra_partition_col_idx: extra_partition_col_idx__,
9815 secret_refs: secret_refs__.unwrap_or_default(),
9816 })
9817 }
9818 }
9819 deserializer.deserialize_struct("stream_plan.SinkDesc", FIELDS, GeneratedVisitor)
9820 }
9821}
9822impl serde::Serialize for SinkLogStoreType {
9823 #[allow(deprecated)]
9824 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9825 where
9826 S: serde::Serializer,
9827 {
9828 let variant = match self {
9829 Self::Unspecified => "SINK_LOG_STORE_TYPE_UNSPECIFIED",
9830 Self::KvLogStore => "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
9831 Self::InMemoryLogStore => "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
9832 };
9833 serializer.serialize_str(variant)
9834 }
9835}
9836impl<'de> serde::Deserialize<'de> for SinkLogStoreType {
9837 #[allow(deprecated)]
9838 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9839 where
9840 D: serde::Deserializer<'de>,
9841 {
9842 const FIELDS: &[&str] = &[
9843 "SINK_LOG_STORE_TYPE_UNSPECIFIED",
9844 "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
9845 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
9846 ];
9847
9848 struct GeneratedVisitor;
9849
9850 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9851 type Value = SinkLogStoreType;
9852
9853 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9854 write!(formatter, "expected one of: {:?}", &FIELDS)
9855 }
9856
9857 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9858 where
9859 E: serde::de::Error,
9860 {
9861 i32::try_from(v)
9862 .ok()
9863 .and_then(|x| x.try_into().ok())
9864 .ok_or_else(|| {
9865 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9866 })
9867 }
9868
9869 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9870 where
9871 E: serde::de::Error,
9872 {
9873 i32::try_from(v)
9874 .ok()
9875 .and_then(|x| x.try_into().ok())
9876 .ok_or_else(|| {
9877 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9878 })
9879 }
9880
9881 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9882 where
9883 E: serde::de::Error,
9884 {
9885 match value {
9886 "SINK_LOG_STORE_TYPE_UNSPECIFIED" => Ok(SinkLogStoreType::Unspecified),
9887 "SINK_LOG_STORE_TYPE_KV_LOG_STORE" => Ok(SinkLogStoreType::KvLogStore),
9888 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE" => Ok(SinkLogStoreType::InMemoryLogStore),
9889 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9890 }
9891 }
9892 }
9893 deserializer.deserialize_any(GeneratedVisitor)
9894 }
9895}
9896impl serde::Serialize for SinkNode {
9897 #[allow(deprecated)]
9898 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9899 where
9900 S: serde::Serializer,
9901 {
9902 use serde::ser::SerializeStruct;
9903 let mut len = 0;
9904 if self.sink_desc.is_some() {
9905 len += 1;
9906 }
9907 if self.table.is_some() {
9908 len += 1;
9909 }
9910 if self.log_store_type != 0 {
9911 len += 1;
9912 }
9913 if self.rate_limit.is_some() {
9914 len += 1;
9915 }
9916 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkNode", len)?;
9917 if let Some(v) = self.sink_desc.as_ref() {
9918 struct_ser.serialize_field("sinkDesc", v)?;
9919 }
9920 if let Some(v) = self.table.as_ref() {
9921 struct_ser.serialize_field("table", v)?;
9922 }
9923 if self.log_store_type != 0 {
9924 let v = SinkLogStoreType::try_from(self.log_store_type)
9925 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.log_store_type)))?;
9926 struct_ser.serialize_field("logStoreType", &v)?;
9927 }
9928 if let Some(v) = self.rate_limit.as_ref() {
9929 struct_ser.serialize_field("rateLimit", v)?;
9930 }
9931 struct_ser.end()
9932 }
9933}
9934impl<'de> serde::Deserialize<'de> for SinkNode {
9935 #[allow(deprecated)]
9936 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9937 where
9938 D: serde::Deserializer<'de>,
9939 {
9940 const FIELDS: &[&str] = &[
9941 "sink_desc",
9942 "sinkDesc",
9943 "table",
9944 "log_store_type",
9945 "logStoreType",
9946 "rate_limit",
9947 "rateLimit",
9948 ];
9949
9950 #[allow(clippy::enum_variant_names)]
9951 enum GeneratedField {
9952 SinkDesc,
9953 Table,
9954 LogStoreType,
9955 RateLimit,
9956 }
9957 impl<'de> serde::Deserialize<'de> for GeneratedField {
9958 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9959 where
9960 D: serde::Deserializer<'de>,
9961 {
9962 struct GeneratedVisitor;
9963
9964 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9965 type Value = GeneratedField;
9966
9967 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9968 write!(formatter, "expected one of: {:?}", &FIELDS)
9969 }
9970
9971 #[allow(unused_variables)]
9972 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9973 where
9974 E: serde::de::Error,
9975 {
9976 match value {
9977 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
9978 "table" => Ok(GeneratedField::Table),
9979 "logStoreType" | "log_store_type" => Ok(GeneratedField::LogStoreType),
9980 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
9981 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9982 }
9983 }
9984 }
9985 deserializer.deserialize_identifier(GeneratedVisitor)
9986 }
9987 }
9988 struct GeneratedVisitor;
9989 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9990 type Value = SinkNode;
9991
9992 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9993 formatter.write_str("struct stream_plan.SinkNode")
9994 }
9995
9996 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkNode, V::Error>
9997 where
9998 V: serde::de::MapAccess<'de>,
9999 {
10000 let mut sink_desc__ = None;
10001 let mut table__ = None;
10002 let mut log_store_type__ = None;
10003 let mut rate_limit__ = None;
10004 while let Some(k) = map_.next_key()? {
10005 match k {
10006 GeneratedField::SinkDesc => {
10007 if sink_desc__.is_some() {
10008 return Err(serde::de::Error::duplicate_field("sinkDesc"));
10009 }
10010 sink_desc__ = map_.next_value()?;
10011 }
10012 GeneratedField::Table => {
10013 if table__.is_some() {
10014 return Err(serde::de::Error::duplicate_field("table"));
10015 }
10016 table__ = map_.next_value()?;
10017 }
10018 GeneratedField::LogStoreType => {
10019 if log_store_type__.is_some() {
10020 return Err(serde::de::Error::duplicate_field("logStoreType"));
10021 }
10022 log_store_type__ = Some(map_.next_value::<SinkLogStoreType>()? as i32);
10023 }
10024 GeneratedField::RateLimit => {
10025 if rate_limit__.is_some() {
10026 return Err(serde::de::Error::duplicate_field("rateLimit"));
10027 }
10028 rate_limit__ =
10029 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10030 ;
10031 }
10032 }
10033 }
10034 Ok(SinkNode {
10035 sink_desc: sink_desc__,
10036 table: table__,
10037 log_store_type: log_store_type__.unwrap_or_default(),
10038 rate_limit: rate_limit__,
10039 })
10040 }
10041 }
10042 deserializer.deserialize_struct("stream_plan.SinkNode", FIELDS, GeneratedVisitor)
10043 }
10044}
10045impl serde::Serialize for SortNode {
10046 #[allow(deprecated)]
10047 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10048 where
10049 S: serde::Serializer,
10050 {
10051 use serde::ser::SerializeStruct;
10052 let mut len = 0;
10053 if self.state_table.is_some() {
10054 len += 1;
10055 }
10056 if self.sort_column_index != 0 {
10057 len += 1;
10058 }
10059 let mut struct_ser = serializer.serialize_struct("stream_plan.SortNode", len)?;
10060 if let Some(v) = self.state_table.as_ref() {
10061 struct_ser.serialize_field("stateTable", v)?;
10062 }
10063 if self.sort_column_index != 0 {
10064 struct_ser.serialize_field("sortColumnIndex", &self.sort_column_index)?;
10065 }
10066 struct_ser.end()
10067 }
10068}
10069impl<'de> serde::Deserialize<'de> for SortNode {
10070 #[allow(deprecated)]
10071 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10072 where
10073 D: serde::Deserializer<'de>,
10074 {
10075 const FIELDS: &[&str] = &[
10076 "state_table",
10077 "stateTable",
10078 "sort_column_index",
10079 "sortColumnIndex",
10080 ];
10081
10082 #[allow(clippy::enum_variant_names)]
10083 enum GeneratedField {
10084 StateTable,
10085 SortColumnIndex,
10086 }
10087 impl<'de> serde::Deserialize<'de> for GeneratedField {
10088 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10089 where
10090 D: serde::Deserializer<'de>,
10091 {
10092 struct GeneratedVisitor;
10093
10094 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10095 type Value = GeneratedField;
10096
10097 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10098 write!(formatter, "expected one of: {:?}", &FIELDS)
10099 }
10100
10101 #[allow(unused_variables)]
10102 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10103 where
10104 E: serde::de::Error,
10105 {
10106 match value {
10107 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
10108 "sortColumnIndex" | "sort_column_index" => Ok(GeneratedField::SortColumnIndex),
10109 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10110 }
10111 }
10112 }
10113 deserializer.deserialize_identifier(GeneratedVisitor)
10114 }
10115 }
10116 struct GeneratedVisitor;
10117 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10118 type Value = SortNode;
10119
10120 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10121 formatter.write_str("struct stream_plan.SortNode")
10122 }
10123
10124 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
10125 where
10126 V: serde::de::MapAccess<'de>,
10127 {
10128 let mut state_table__ = None;
10129 let mut sort_column_index__ = None;
10130 while let Some(k) = map_.next_key()? {
10131 match k {
10132 GeneratedField::StateTable => {
10133 if state_table__.is_some() {
10134 return Err(serde::de::Error::duplicate_field("stateTable"));
10135 }
10136 state_table__ = map_.next_value()?;
10137 }
10138 GeneratedField::SortColumnIndex => {
10139 if sort_column_index__.is_some() {
10140 return Err(serde::de::Error::duplicate_field("sortColumnIndex"));
10141 }
10142 sort_column_index__ =
10143 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10144 ;
10145 }
10146 }
10147 }
10148 Ok(SortNode {
10149 state_table: state_table__,
10150 sort_column_index: sort_column_index__.unwrap_or_default(),
10151 })
10152 }
10153 }
10154 deserializer.deserialize_struct("stream_plan.SortNode", FIELDS, GeneratedVisitor)
10155 }
10156}
10157impl serde::Serialize for SourceBackfillNode {
10158 #[allow(deprecated)]
10159 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10160 where
10161 S: serde::Serializer,
10162 {
10163 use serde::ser::SerializeStruct;
10164 let mut len = 0;
10165 if self.upstream_source_id != 0 {
10166 len += 1;
10167 }
10168 if self.row_id_index.is_some() {
10169 len += 1;
10170 }
10171 if !self.columns.is_empty() {
10172 len += 1;
10173 }
10174 if self.info.is_some() {
10175 len += 1;
10176 }
10177 if !self.source_name.is_empty() {
10178 len += 1;
10179 }
10180 if !self.with_properties.is_empty() {
10181 len += 1;
10182 }
10183 if self.rate_limit.is_some() {
10184 len += 1;
10185 }
10186 if self.state_table.is_some() {
10187 len += 1;
10188 }
10189 if !self.secret_refs.is_empty() {
10190 len += 1;
10191 }
10192 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceBackfillNode", len)?;
10193 if self.upstream_source_id != 0 {
10194 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
10195 }
10196 if let Some(v) = self.row_id_index.as_ref() {
10197 struct_ser.serialize_field("rowIdIndex", v)?;
10198 }
10199 if !self.columns.is_empty() {
10200 struct_ser.serialize_field("columns", &self.columns)?;
10201 }
10202 if let Some(v) = self.info.as_ref() {
10203 struct_ser.serialize_field("info", v)?;
10204 }
10205 if !self.source_name.is_empty() {
10206 struct_ser.serialize_field("sourceName", &self.source_name)?;
10207 }
10208 if !self.with_properties.is_empty() {
10209 struct_ser.serialize_field("withProperties", &self.with_properties)?;
10210 }
10211 if let Some(v) = self.rate_limit.as_ref() {
10212 struct_ser.serialize_field("rateLimit", v)?;
10213 }
10214 if let Some(v) = self.state_table.as_ref() {
10215 struct_ser.serialize_field("stateTable", v)?;
10216 }
10217 if !self.secret_refs.is_empty() {
10218 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
10219 }
10220 struct_ser.end()
10221 }
10222}
10223impl<'de> serde::Deserialize<'de> for SourceBackfillNode {
10224 #[allow(deprecated)]
10225 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10226 where
10227 D: serde::Deserializer<'de>,
10228 {
10229 const FIELDS: &[&str] = &[
10230 "upstream_source_id",
10231 "upstreamSourceId",
10232 "row_id_index",
10233 "rowIdIndex",
10234 "columns",
10235 "info",
10236 "source_name",
10237 "sourceName",
10238 "with_properties",
10239 "withProperties",
10240 "rate_limit",
10241 "rateLimit",
10242 "state_table",
10243 "stateTable",
10244 "secret_refs",
10245 "secretRefs",
10246 ];
10247
10248 #[allow(clippy::enum_variant_names)]
10249 enum GeneratedField {
10250 UpstreamSourceId,
10251 RowIdIndex,
10252 Columns,
10253 Info,
10254 SourceName,
10255 WithProperties,
10256 RateLimit,
10257 StateTable,
10258 SecretRefs,
10259 }
10260 impl<'de> serde::Deserialize<'de> for GeneratedField {
10261 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10262 where
10263 D: serde::Deserializer<'de>,
10264 {
10265 struct GeneratedVisitor;
10266
10267 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10268 type Value = GeneratedField;
10269
10270 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10271 write!(formatter, "expected one of: {:?}", &FIELDS)
10272 }
10273
10274 #[allow(unused_variables)]
10275 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10276 where
10277 E: serde::de::Error,
10278 {
10279 match value {
10280 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
10281 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
10282 "columns" => Ok(GeneratedField::Columns),
10283 "info" => Ok(GeneratedField::Info),
10284 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
10285 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
10286 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
10287 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
10288 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
10289 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10290 }
10291 }
10292 }
10293 deserializer.deserialize_identifier(GeneratedVisitor)
10294 }
10295 }
10296 struct GeneratedVisitor;
10297 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10298 type Value = SourceBackfillNode;
10299
10300 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10301 formatter.write_str("struct stream_plan.SourceBackfillNode")
10302 }
10303
10304 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceBackfillNode, V::Error>
10305 where
10306 V: serde::de::MapAccess<'de>,
10307 {
10308 let mut upstream_source_id__ = None;
10309 let mut row_id_index__ = None;
10310 let mut columns__ = None;
10311 let mut info__ = None;
10312 let mut source_name__ = None;
10313 let mut with_properties__ = None;
10314 let mut rate_limit__ = None;
10315 let mut state_table__ = None;
10316 let mut secret_refs__ = None;
10317 while let Some(k) = map_.next_key()? {
10318 match k {
10319 GeneratedField::UpstreamSourceId => {
10320 if upstream_source_id__.is_some() {
10321 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
10322 }
10323 upstream_source_id__ =
10324 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10325 ;
10326 }
10327 GeneratedField::RowIdIndex => {
10328 if row_id_index__.is_some() {
10329 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
10330 }
10331 row_id_index__ =
10332 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10333 ;
10334 }
10335 GeneratedField::Columns => {
10336 if columns__.is_some() {
10337 return Err(serde::de::Error::duplicate_field("columns"));
10338 }
10339 columns__ = Some(map_.next_value()?);
10340 }
10341 GeneratedField::Info => {
10342 if info__.is_some() {
10343 return Err(serde::de::Error::duplicate_field("info"));
10344 }
10345 info__ = map_.next_value()?;
10346 }
10347 GeneratedField::SourceName => {
10348 if source_name__.is_some() {
10349 return Err(serde::de::Error::duplicate_field("sourceName"));
10350 }
10351 source_name__ = Some(map_.next_value()?);
10352 }
10353 GeneratedField::WithProperties => {
10354 if with_properties__.is_some() {
10355 return Err(serde::de::Error::duplicate_field("withProperties"));
10356 }
10357 with_properties__ = Some(
10358 map_.next_value::<std::collections::BTreeMap<_, _>>()?
10359 );
10360 }
10361 GeneratedField::RateLimit => {
10362 if rate_limit__.is_some() {
10363 return Err(serde::de::Error::duplicate_field("rateLimit"));
10364 }
10365 rate_limit__ =
10366 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10367 ;
10368 }
10369 GeneratedField::StateTable => {
10370 if state_table__.is_some() {
10371 return Err(serde::de::Error::duplicate_field("stateTable"));
10372 }
10373 state_table__ = map_.next_value()?;
10374 }
10375 GeneratedField::SecretRefs => {
10376 if secret_refs__.is_some() {
10377 return Err(serde::de::Error::duplicate_field("secretRefs"));
10378 }
10379 secret_refs__ = Some(
10380 map_.next_value::<std::collections::BTreeMap<_, _>>()?
10381 );
10382 }
10383 }
10384 }
10385 Ok(SourceBackfillNode {
10386 upstream_source_id: upstream_source_id__.unwrap_or_default(),
10387 row_id_index: row_id_index__,
10388 columns: columns__.unwrap_or_default(),
10389 info: info__,
10390 source_name: source_name__.unwrap_or_default(),
10391 with_properties: with_properties__.unwrap_or_default(),
10392 rate_limit: rate_limit__,
10393 state_table: state_table__,
10394 secret_refs: secret_refs__.unwrap_or_default(),
10395 })
10396 }
10397 }
10398 deserializer.deserialize_struct("stream_plan.SourceBackfillNode", FIELDS, GeneratedVisitor)
10399 }
10400}
10401impl serde::Serialize for SourceChangeSplitMutation {
10402 #[allow(deprecated)]
10403 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10404 where
10405 S: serde::Serializer,
10406 {
10407 use serde::ser::SerializeStruct;
10408 let mut len = 0;
10409 if !self.actor_splits.is_empty() {
10410 len += 1;
10411 }
10412 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceChangeSplitMutation", len)?;
10413 if !self.actor_splits.is_empty() {
10414 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
10415 }
10416 struct_ser.end()
10417 }
10418}
10419impl<'de> serde::Deserialize<'de> for SourceChangeSplitMutation {
10420 #[allow(deprecated)]
10421 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10422 where
10423 D: serde::Deserializer<'de>,
10424 {
10425 const FIELDS: &[&str] = &[
10426 "actor_splits",
10427 "actorSplits",
10428 ];
10429
10430 #[allow(clippy::enum_variant_names)]
10431 enum GeneratedField {
10432 ActorSplits,
10433 }
10434 impl<'de> serde::Deserialize<'de> for GeneratedField {
10435 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10436 where
10437 D: serde::Deserializer<'de>,
10438 {
10439 struct GeneratedVisitor;
10440
10441 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10442 type Value = GeneratedField;
10443
10444 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10445 write!(formatter, "expected one of: {:?}", &FIELDS)
10446 }
10447
10448 #[allow(unused_variables)]
10449 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10450 where
10451 E: serde::de::Error,
10452 {
10453 match value {
10454 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
10455 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10456 }
10457 }
10458 }
10459 deserializer.deserialize_identifier(GeneratedVisitor)
10460 }
10461 }
10462 struct GeneratedVisitor;
10463 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10464 type Value = SourceChangeSplitMutation;
10465
10466 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10467 formatter.write_str("struct stream_plan.SourceChangeSplitMutation")
10468 }
10469
10470 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceChangeSplitMutation, V::Error>
10471 where
10472 V: serde::de::MapAccess<'de>,
10473 {
10474 let mut actor_splits__ = None;
10475 while let Some(k) = map_.next_key()? {
10476 match k {
10477 GeneratedField::ActorSplits => {
10478 if actor_splits__.is_some() {
10479 return Err(serde::de::Error::duplicate_field("actorSplits"));
10480 }
10481 actor_splits__ = Some(
10482 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10483 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
10484 );
10485 }
10486 }
10487 }
10488 Ok(SourceChangeSplitMutation {
10489 actor_splits: actor_splits__.unwrap_or_default(),
10490 })
10491 }
10492 }
10493 deserializer.deserialize_struct("stream_plan.SourceChangeSplitMutation", FIELDS, GeneratedVisitor)
10494 }
10495}
10496impl serde::Serialize for SourceNode {
10497 #[allow(deprecated)]
10498 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10499 where
10500 S: serde::Serializer,
10501 {
10502 use serde::ser::SerializeStruct;
10503 let mut len = 0;
10504 if self.source_inner.is_some() {
10505 len += 1;
10506 }
10507 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceNode", len)?;
10508 if let Some(v) = self.source_inner.as_ref() {
10509 struct_ser.serialize_field("sourceInner", v)?;
10510 }
10511 struct_ser.end()
10512 }
10513}
10514impl<'de> serde::Deserialize<'de> for SourceNode {
10515 #[allow(deprecated)]
10516 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10517 where
10518 D: serde::Deserializer<'de>,
10519 {
10520 const FIELDS: &[&str] = &[
10521 "source_inner",
10522 "sourceInner",
10523 ];
10524
10525 #[allow(clippy::enum_variant_names)]
10526 enum GeneratedField {
10527 SourceInner,
10528 }
10529 impl<'de> serde::Deserialize<'de> for GeneratedField {
10530 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10531 where
10532 D: serde::Deserializer<'de>,
10533 {
10534 struct GeneratedVisitor;
10535
10536 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10537 type Value = GeneratedField;
10538
10539 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10540 write!(formatter, "expected one of: {:?}", &FIELDS)
10541 }
10542
10543 #[allow(unused_variables)]
10544 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10545 where
10546 E: serde::de::Error,
10547 {
10548 match value {
10549 "sourceInner" | "source_inner" => Ok(GeneratedField::SourceInner),
10550 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10551 }
10552 }
10553 }
10554 deserializer.deserialize_identifier(GeneratedVisitor)
10555 }
10556 }
10557 struct GeneratedVisitor;
10558 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10559 type Value = SourceNode;
10560
10561 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10562 formatter.write_str("struct stream_plan.SourceNode")
10563 }
10564
10565 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
10566 where
10567 V: serde::de::MapAccess<'de>,
10568 {
10569 let mut source_inner__ = None;
10570 while let Some(k) = map_.next_key()? {
10571 match k {
10572 GeneratedField::SourceInner => {
10573 if source_inner__.is_some() {
10574 return Err(serde::de::Error::duplicate_field("sourceInner"));
10575 }
10576 source_inner__ = map_.next_value()?;
10577 }
10578 }
10579 }
10580 Ok(SourceNode {
10581 source_inner: source_inner__,
10582 })
10583 }
10584 }
10585 deserializer.deserialize_struct("stream_plan.SourceNode", FIELDS, GeneratedVisitor)
10586 }
10587}
10588impl serde::Serialize for StartFragmentBackfillMutation {
10589 #[allow(deprecated)]
10590 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10591 where
10592 S: serde::Serializer,
10593 {
10594 use serde::ser::SerializeStruct;
10595 let mut len = 0;
10596 if !self.fragment_ids.is_empty() {
10597 len += 1;
10598 }
10599 let mut struct_ser = serializer.serialize_struct("stream_plan.StartFragmentBackfillMutation", len)?;
10600 if !self.fragment_ids.is_empty() {
10601 struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
10602 }
10603 struct_ser.end()
10604 }
10605}
10606impl<'de> serde::Deserialize<'de> for StartFragmentBackfillMutation {
10607 #[allow(deprecated)]
10608 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10609 where
10610 D: serde::Deserializer<'de>,
10611 {
10612 const FIELDS: &[&str] = &[
10613 "fragment_ids",
10614 "fragmentIds",
10615 ];
10616
10617 #[allow(clippy::enum_variant_names)]
10618 enum GeneratedField {
10619 FragmentIds,
10620 }
10621 impl<'de> serde::Deserialize<'de> for GeneratedField {
10622 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10623 where
10624 D: serde::Deserializer<'de>,
10625 {
10626 struct GeneratedVisitor;
10627
10628 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10629 type Value = GeneratedField;
10630
10631 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10632 write!(formatter, "expected one of: {:?}", &FIELDS)
10633 }
10634
10635 #[allow(unused_variables)]
10636 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10637 where
10638 E: serde::de::Error,
10639 {
10640 match value {
10641 "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
10642 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10643 }
10644 }
10645 }
10646 deserializer.deserialize_identifier(GeneratedVisitor)
10647 }
10648 }
10649 struct GeneratedVisitor;
10650 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10651 type Value = StartFragmentBackfillMutation;
10652
10653 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10654 formatter.write_str("struct stream_plan.StartFragmentBackfillMutation")
10655 }
10656
10657 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StartFragmentBackfillMutation, V::Error>
10658 where
10659 V: serde::de::MapAccess<'de>,
10660 {
10661 let mut fragment_ids__ = None;
10662 while let Some(k) = map_.next_key()? {
10663 match k {
10664 GeneratedField::FragmentIds => {
10665 if fragment_ids__.is_some() {
10666 return Err(serde::de::Error::duplicate_field("fragmentIds"));
10667 }
10668 fragment_ids__ =
10669 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10670 .into_iter().map(|x| x.0).collect())
10671 ;
10672 }
10673 }
10674 }
10675 Ok(StartFragmentBackfillMutation {
10676 fragment_ids: fragment_ids__.unwrap_or_default(),
10677 })
10678 }
10679 }
10680 deserializer.deserialize_struct("stream_plan.StartFragmentBackfillMutation", FIELDS, GeneratedVisitor)
10681 }
10682}
10683impl serde::Serialize for StopMutation {
10684 #[allow(deprecated)]
10685 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10686 where
10687 S: serde::Serializer,
10688 {
10689 use serde::ser::SerializeStruct;
10690 let mut len = 0;
10691 if !self.actors.is_empty() {
10692 len += 1;
10693 }
10694 if !self.dropped_sink_fragments.is_empty() {
10695 len += 1;
10696 }
10697 let mut struct_ser = serializer.serialize_struct("stream_plan.StopMutation", len)?;
10698 if !self.actors.is_empty() {
10699 struct_ser.serialize_field("actors", &self.actors)?;
10700 }
10701 if !self.dropped_sink_fragments.is_empty() {
10702 struct_ser.serialize_field("droppedSinkFragments", &self.dropped_sink_fragments)?;
10703 }
10704 struct_ser.end()
10705 }
10706}
10707impl<'de> serde::Deserialize<'de> for StopMutation {
10708 #[allow(deprecated)]
10709 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10710 where
10711 D: serde::Deserializer<'de>,
10712 {
10713 const FIELDS: &[&str] = &[
10714 "actors",
10715 "dropped_sink_fragments",
10716 "droppedSinkFragments",
10717 ];
10718
10719 #[allow(clippy::enum_variant_names)]
10720 enum GeneratedField {
10721 Actors,
10722 DroppedSinkFragments,
10723 }
10724 impl<'de> serde::Deserialize<'de> for GeneratedField {
10725 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10726 where
10727 D: serde::Deserializer<'de>,
10728 {
10729 struct GeneratedVisitor;
10730
10731 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10732 type Value = GeneratedField;
10733
10734 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10735 write!(formatter, "expected one of: {:?}", &FIELDS)
10736 }
10737
10738 #[allow(unused_variables)]
10739 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10740 where
10741 E: serde::de::Error,
10742 {
10743 match value {
10744 "actors" => Ok(GeneratedField::Actors),
10745 "droppedSinkFragments" | "dropped_sink_fragments" => Ok(GeneratedField::DroppedSinkFragments),
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 = StopMutation;
10756
10757 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10758 formatter.write_str("struct stream_plan.StopMutation")
10759 }
10760
10761 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopMutation, V::Error>
10762 where
10763 V: serde::de::MapAccess<'de>,
10764 {
10765 let mut actors__ = None;
10766 let mut dropped_sink_fragments__ = None;
10767 while let Some(k) = map_.next_key()? {
10768 match k {
10769 GeneratedField::Actors => {
10770 if actors__.is_some() {
10771 return Err(serde::de::Error::duplicate_field("actors"));
10772 }
10773 actors__ =
10774 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10775 .into_iter().map(|x| x.0).collect())
10776 ;
10777 }
10778 GeneratedField::DroppedSinkFragments => {
10779 if dropped_sink_fragments__.is_some() {
10780 return Err(serde::de::Error::duplicate_field("droppedSinkFragments"));
10781 }
10782 dropped_sink_fragments__ =
10783 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10784 .into_iter().map(|x| x.0).collect())
10785 ;
10786 }
10787 }
10788 }
10789 Ok(StopMutation {
10790 actors: actors__.unwrap_or_default(),
10791 dropped_sink_fragments: dropped_sink_fragments__.unwrap_or_default(),
10792 })
10793 }
10794 }
10795 deserializer.deserialize_struct("stream_plan.StopMutation", FIELDS, GeneratedVisitor)
10796 }
10797}
10798impl serde::Serialize for StreamActor {
10799 #[allow(deprecated)]
10800 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10801 where
10802 S: serde::Serializer,
10803 {
10804 use serde::ser::SerializeStruct;
10805 let mut len = 0;
10806 if self.actor_id != 0 {
10807 len += 1;
10808 }
10809 if self.fragment_id != 0 {
10810 len += 1;
10811 }
10812 if !self.dispatcher.is_empty() {
10813 len += 1;
10814 }
10815 if self.vnode_bitmap.is_some() {
10816 len += 1;
10817 }
10818 if !self.mview_definition.is_empty() {
10819 len += 1;
10820 }
10821 if self.expr_context.is_some() {
10822 len += 1;
10823 }
10824 if !self.config_override.is_empty() {
10825 len += 1;
10826 }
10827 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamActor", len)?;
10828 if self.actor_id != 0 {
10829 struct_ser.serialize_field("actorId", &self.actor_id)?;
10830 }
10831 if self.fragment_id != 0 {
10832 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
10833 }
10834 if !self.dispatcher.is_empty() {
10835 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
10836 }
10837 if let Some(v) = self.vnode_bitmap.as_ref() {
10838 struct_ser.serialize_field("vnodeBitmap", v)?;
10839 }
10840 if !self.mview_definition.is_empty() {
10841 struct_ser.serialize_field("mviewDefinition", &self.mview_definition)?;
10842 }
10843 if let Some(v) = self.expr_context.as_ref() {
10844 struct_ser.serialize_field("exprContext", v)?;
10845 }
10846 if !self.config_override.is_empty() {
10847 struct_ser.serialize_field("configOverride", &self.config_override)?;
10848 }
10849 struct_ser.end()
10850 }
10851}
10852impl<'de> serde::Deserialize<'de> for StreamActor {
10853 #[allow(deprecated)]
10854 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10855 where
10856 D: serde::Deserializer<'de>,
10857 {
10858 const FIELDS: &[&str] = &[
10859 "actor_id",
10860 "actorId",
10861 "fragment_id",
10862 "fragmentId",
10863 "dispatcher",
10864 "vnode_bitmap",
10865 "vnodeBitmap",
10866 "mview_definition",
10867 "mviewDefinition",
10868 "expr_context",
10869 "exprContext",
10870 "config_override",
10871 "configOverride",
10872 ];
10873
10874 #[allow(clippy::enum_variant_names)]
10875 enum GeneratedField {
10876 ActorId,
10877 FragmentId,
10878 Dispatcher,
10879 VnodeBitmap,
10880 MviewDefinition,
10881 ExprContext,
10882 ConfigOverride,
10883 }
10884 impl<'de> serde::Deserialize<'de> for GeneratedField {
10885 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10886 where
10887 D: serde::Deserializer<'de>,
10888 {
10889 struct GeneratedVisitor;
10890
10891 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10892 type Value = GeneratedField;
10893
10894 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10895 write!(formatter, "expected one of: {:?}", &FIELDS)
10896 }
10897
10898 #[allow(unused_variables)]
10899 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10900 where
10901 E: serde::de::Error,
10902 {
10903 match value {
10904 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
10905 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
10906 "dispatcher" => Ok(GeneratedField::Dispatcher),
10907 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
10908 "mviewDefinition" | "mview_definition" => Ok(GeneratedField::MviewDefinition),
10909 "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
10910 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
10911 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10912 }
10913 }
10914 }
10915 deserializer.deserialize_identifier(GeneratedVisitor)
10916 }
10917 }
10918 struct GeneratedVisitor;
10919 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10920 type Value = StreamActor;
10921
10922 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10923 formatter.write_str("struct stream_plan.StreamActor")
10924 }
10925
10926 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamActor, V::Error>
10927 where
10928 V: serde::de::MapAccess<'de>,
10929 {
10930 let mut actor_id__ = None;
10931 let mut fragment_id__ = None;
10932 let mut dispatcher__ = None;
10933 let mut vnode_bitmap__ = None;
10934 let mut mview_definition__ = None;
10935 let mut expr_context__ = None;
10936 let mut config_override__ = None;
10937 while let Some(k) = map_.next_key()? {
10938 match k {
10939 GeneratedField::ActorId => {
10940 if actor_id__.is_some() {
10941 return Err(serde::de::Error::duplicate_field("actorId"));
10942 }
10943 actor_id__ =
10944 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10945 ;
10946 }
10947 GeneratedField::FragmentId => {
10948 if fragment_id__.is_some() {
10949 return Err(serde::de::Error::duplicate_field("fragmentId"));
10950 }
10951 fragment_id__ =
10952 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10953 ;
10954 }
10955 GeneratedField::Dispatcher => {
10956 if dispatcher__.is_some() {
10957 return Err(serde::de::Error::duplicate_field("dispatcher"));
10958 }
10959 dispatcher__ = Some(map_.next_value()?);
10960 }
10961 GeneratedField::VnodeBitmap => {
10962 if vnode_bitmap__.is_some() {
10963 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
10964 }
10965 vnode_bitmap__ = map_.next_value()?;
10966 }
10967 GeneratedField::MviewDefinition => {
10968 if mview_definition__.is_some() {
10969 return Err(serde::de::Error::duplicate_field("mviewDefinition"));
10970 }
10971 mview_definition__ = Some(map_.next_value()?);
10972 }
10973 GeneratedField::ExprContext => {
10974 if expr_context__.is_some() {
10975 return Err(serde::de::Error::duplicate_field("exprContext"));
10976 }
10977 expr_context__ = map_.next_value()?;
10978 }
10979 GeneratedField::ConfigOverride => {
10980 if config_override__.is_some() {
10981 return Err(serde::de::Error::duplicate_field("configOverride"));
10982 }
10983 config_override__ = Some(map_.next_value()?);
10984 }
10985 }
10986 }
10987 Ok(StreamActor {
10988 actor_id: actor_id__.unwrap_or_default(),
10989 fragment_id: fragment_id__.unwrap_or_default(),
10990 dispatcher: dispatcher__.unwrap_or_default(),
10991 vnode_bitmap: vnode_bitmap__,
10992 mview_definition: mview_definition__.unwrap_or_default(),
10993 expr_context: expr_context__,
10994 config_override: config_override__.unwrap_or_default(),
10995 })
10996 }
10997 }
10998 deserializer.deserialize_struct("stream_plan.StreamActor", FIELDS, GeneratedVisitor)
10999 }
11000}
11001impl serde::Serialize for StreamCdcScanNode {
11002 #[allow(deprecated)]
11003 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11004 where
11005 S: serde::Serializer,
11006 {
11007 use serde::ser::SerializeStruct;
11008 let mut len = 0;
11009 if self.table_id != 0 {
11010 len += 1;
11011 }
11012 if !self.upstream_column_ids.is_empty() {
11013 len += 1;
11014 }
11015 if !self.output_indices.is_empty() {
11016 len += 1;
11017 }
11018 if self.state_table.is_some() {
11019 len += 1;
11020 }
11021 if self.cdc_table_desc.is_some() {
11022 len += 1;
11023 }
11024 if self.rate_limit.is_some() {
11025 len += 1;
11026 }
11027 if self.disable_backfill {
11028 len += 1;
11029 }
11030 if self.options.is_some() {
11031 len += 1;
11032 }
11033 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanNode", len)?;
11034 if self.table_id != 0 {
11035 struct_ser.serialize_field("tableId", &self.table_id)?;
11036 }
11037 if !self.upstream_column_ids.is_empty() {
11038 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
11039 }
11040 if !self.output_indices.is_empty() {
11041 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
11042 }
11043 if let Some(v) = self.state_table.as_ref() {
11044 struct_ser.serialize_field("stateTable", v)?;
11045 }
11046 if let Some(v) = self.cdc_table_desc.as_ref() {
11047 struct_ser.serialize_field("cdcTableDesc", v)?;
11048 }
11049 if let Some(v) = self.rate_limit.as_ref() {
11050 struct_ser.serialize_field("rateLimit", v)?;
11051 }
11052 if self.disable_backfill {
11053 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
11054 }
11055 if let Some(v) = self.options.as_ref() {
11056 struct_ser.serialize_field("options", v)?;
11057 }
11058 struct_ser.end()
11059 }
11060}
11061impl<'de> serde::Deserialize<'de> for StreamCdcScanNode {
11062 #[allow(deprecated)]
11063 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11064 where
11065 D: serde::Deserializer<'de>,
11066 {
11067 const FIELDS: &[&str] = &[
11068 "table_id",
11069 "tableId",
11070 "upstream_column_ids",
11071 "upstreamColumnIds",
11072 "output_indices",
11073 "outputIndices",
11074 "state_table",
11075 "stateTable",
11076 "cdc_table_desc",
11077 "cdcTableDesc",
11078 "rate_limit",
11079 "rateLimit",
11080 "disable_backfill",
11081 "disableBackfill",
11082 "options",
11083 ];
11084
11085 #[allow(clippy::enum_variant_names)]
11086 enum GeneratedField {
11087 TableId,
11088 UpstreamColumnIds,
11089 OutputIndices,
11090 StateTable,
11091 CdcTableDesc,
11092 RateLimit,
11093 DisableBackfill,
11094 Options,
11095 }
11096 impl<'de> serde::Deserialize<'de> for GeneratedField {
11097 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11098 where
11099 D: serde::Deserializer<'de>,
11100 {
11101 struct GeneratedVisitor;
11102
11103 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11104 type Value = GeneratedField;
11105
11106 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11107 write!(formatter, "expected one of: {:?}", &FIELDS)
11108 }
11109
11110 #[allow(unused_variables)]
11111 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11112 where
11113 E: serde::de::Error,
11114 {
11115 match value {
11116 "tableId" | "table_id" => Ok(GeneratedField::TableId),
11117 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
11118 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
11119 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11120 "cdcTableDesc" | "cdc_table_desc" => Ok(GeneratedField::CdcTableDesc),
11121 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11122 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
11123 "options" => Ok(GeneratedField::Options),
11124 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11125 }
11126 }
11127 }
11128 deserializer.deserialize_identifier(GeneratedVisitor)
11129 }
11130 }
11131 struct GeneratedVisitor;
11132 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11133 type Value = StreamCdcScanNode;
11134
11135 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11136 formatter.write_str("struct stream_plan.StreamCdcScanNode")
11137 }
11138
11139 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanNode, V::Error>
11140 where
11141 V: serde::de::MapAccess<'de>,
11142 {
11143 let mut table_id__ = None;
11144 let mut upstream_column_ids__ = None;
11145 let mut output_indices__ = None;
11146 let mut state_table__ = None;
11147 let mut cdc_table_desc__ = None;
11148 let mut rate_limit__ = None;
11149 let mut disable_backfill__ = None;
11150 let mut options__ = None;
11151 while let Some(k) = map_.next_key()? {
11152 match k {
11153 GeneratedField::TableId => {
11154 if table_id__.is_some() {
11155 return Err(serde::de::Error::duplicate_field("tableId"));
11156 }
11157 table_id__ =
11158 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11159 ;
11160 }
11161 GeneratedField::UpstreamColumnIds => {
11162 if upstream_column_ids__.is_some() {
11163 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
11164 }
11165 upstream_column_ids__ =
11166 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11167 .into_iter().map(|x| x.0).collect())
11168 ;
11169 }
11170 GeneratedField::OutputIndices => {
11171 if output_indices__.is_some() {
11172 return Err(serde::de::Error::duplicate_field("outputIndices"));
11173 }
11174 output_indices__ =
11175 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11176 .into_iter().map(|x| x.0).collect())
11177 ;
11178 }
11179 GeneratedField::StateTable => {
11180 if state_table__.is_some() {
11181 return Err(serde::de::Error::duplicate_field("stateTable"));
11182 }
11183 state_table__ = map_.next_value()?;
11184 }
11185 GeneratedField::CdcTableDesc => {
11186 if cdc_table_desc__.is_some() {
11187 return Err(serde::de::Error::duplicate_field("cdcTableDesc"));
11188 }
11189 cdc_table_desc__ = map_.next_value()?;
11190 }
11191 GeneratedField::RateLimit => {
11192 if rate_limit__.is_some() {
11193 return Err(serde::de::Error::duplicate_field("rateLimit"));
11194 }
11195 rate_limit__ =
11196 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11197 ;
11198 }
11199 GeneratedField::DisableBackfill => {
11200 if disable_backfill__.is_some() {
11201 return Err(serde::de::Error::duplicate_field("disableBackfill"));
11202 }
11203 disable_backfill__ = Some(map_.next_value()?);
11204 }
11205 GeneratedField::Options => {
11206 if options__.is_some() {
11207 return Err(serde::de::Error::duplicate_field("options"));
11208 }
11209 options__ = map_.next_value()?;
11210 }
11211 }
11212 }
11213 Ok(StreamCdcScanNode {
11214 table_id: table_id__.unwrap_or_default(),
11215 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
11216 output_indices: output_indices__.unwrap_or_default(),
11217 state_table: state_table__,
11218 cdc_table_desc: cdc_table_desc__,
11219 rate_limit: rate_limit__,
11220 disable_backfill: disable_backfill__.unwrap_or_default(),
11221 options: options__,
11222 })
11223 }
11224 }
11225 deserializer.deserialize_struct("stream_plan.StreamCdcScanNode", FIELDS, GeneratedVisitor)
11226 }
11227}
11228impl serde::Serialize for StreamCdcScanOptions {
11229 #[allow(deprecated)]
11230 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11231 where
11232 S: serde::Serializer,
11233 {
11234 use serde::ser::SerializeStruct;
11235 let mut len = 0;
11236 if self.disable_backfill {
11237 len += 1;
11238 }
11239 if self.snapshot_barrier_interval != 0 {
11240 len += 1;
11241 }
11242 if self.snapshot_batch_size != 0 {
11243 len += 1;
11244 }
11245 if self.backfill_parallelism != 0 {
11246 len += 1;
11247 }
11248 if self.backfill_num_rows_per_split != 0 {
11249 len += 1;
11250 }
11251 if self.backfill_as_even_splits {
11252 len += 1;
11253 }
11254 if self.backfill_split_pk_column_index != 0 {
11255 len += 1;
11256 }
11257 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanOptions", len)?;
11258 if self.disable_backfill {
11259 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
11260 }
11261 if self.snapshot_barrier_interval != 0 {
11262 struct_ser.serialize_field("snapshotBarrierInterval", &self.snapshot_barrier_interval)?;
11263 }
11264 if self.snapshot_batch_size != 0 {
11265 struct_ser.serialize_field("snapshotBatchSize", &self.snapshot_batch_size)?;
11266 }
11267 if self.backfill_parallelism != 0 {
11268 struct_ser.serialize_field("backfillParallelism", &self.backfill_parallelism)?;
11269 }
11270 if self.backfill_num_rows_per_split != 0 {
11271 #[allow(clippy::needless_borrow)]
11272 #[allow(clippy::needless_borrows_for_generic_args)]
11273 struct_ser.serialize_field("backfillNumRowsPerSplit", ToString::to_string(&self.backfill_num_rows_per_split).as_str())?;
11274 }
11275 if self.backfill_as_even_splits {
11276 struct_ser.serialize_field("backfillAsEvenSplits", &self.backfill_as_even_splits)?;
11277 }
11278 if self.backfill_split_pk_column_index != 0 {
11279 struct_ser.serialize_field("backfillSplitPkColumnIndex", &self.backfill_split_pk_column_index)?;
11280 }
11281 struct_ser.end()
11282 }
11283}
11284impl<'de> serde::Deserialize<'de> for StreamCdcScanOptions {
11285 #[allow(deprecated)]
11286 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11287 where
11288 D: serde::Deserializer<'de>,
11289 {
11290 const FIELDS: &[&str] = &[
11291 "disable_backfill",
11292 "disableBackfill",
11293 "snapshot_barrier_interval",
11294 "snapshotBarrierInterval",
11295 "snapshot_batch_size",
11296 "snapshotBatchSize",
11297 "backfill_parallelism",
11298 "backfillParallelism",
11299 "backfill_num_rows_per_split",
11300 "backfillNumRowsPerSplit",
11301 "backfill_as_even_splits",
11302 "backfillAsEvenSplits",
11303 "backfill_split_pk_column_index",
11304 "backfillSplitPkColumnIndex",
11305 ];
11306
11307 #[allow(clippy::enum_variant_names)]
11308 enum GeneratedField {
11309 DisableBackfill,
11310 SnapshotBarrierInterval,
11311 SnapshotBatchSize,
11312 BackfillParallelism,
11313 BackfillNumRowsPerSplit,
11314 BackfillAsEvenSplits,
11315 BackfillSplitPkColumnIndex,
11316 }
11317 impl<'de> serde::Deserialize<'de> for GeneratedField {
11318 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11319 where
11320 D: serde::Deserializer<'de>,
11321 {
11322 struct GeneratedVisitor;
11323
11324 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11325 type Value = GeneratedField;
11326
11327 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11328 write!(formatter, "expected one of: {:?}", &FIELDS)
11329 }
11330
11331 #[allow(unused_variables)]
11332 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11333 where
11334 E: serde::de::Error,
11335 {
11336 match value {
11337 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
11338 "snapshotBarrierInterval" | "snapshot_barrier_interval" => Ok(GeneratedField::SnapshotBarrierInterval),
11339 "snapshotBatchSize" | "snapshot_batch_size" => Ok(GeneratedField::SnapshotBatchSize),
11340 "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
11341 "backfillNumRowsPerSplit" | "backfill_num_rows_per_split" => Ok(GeneratedField::BackfillNumRowsPerSplit),
11342 "backfillAsEvenSplits" | "backfill_as_even_splits" => Ok(GeneratedField::BackfillAsEvenSplits),
11343 "backfillSplitPkColumnIndex" | "backfill_split_pk_column_index" => Ok(GeneratedField::BackfillSplitPkColumnIndex),
11344 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11345 }
11346 }
11347 }
11348 deserializer.deserialize_identifier(GeneratedVisitor)
11349 }
11350 }
11351 struct GeneratedVisitor;
11352 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11353 type Value = StreamCdcScanOptions;
11354
11355 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11356 formatter.write_str("struct stream_plan.StreamCdcScanOptions")
11357 }
11358
11359 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanOptions, V::Error>
11360 where
11361 V: serde::de::MapAccess<'de>,
11362 {
11363 let mut disable_backfill__ = None;
11364 let mut snapshot_barrier_interval__ = None;
11365 let mut snapshot_batch_size__ = None;
11366 let mut backfill_parallelism__ = None;
11367 let mut backfill_num_rows_per_split__ = None;
11368 let mut backfill_as_even_splits__ = None;
11369 let mut backfill_split_pk_column_index__ = None;
11370 while let Some(k) = map_.next_key()? {
11371 match k {
11372 GeneratedField::DisableBackfill => {
11373 if disable_backfill__.is_some() {
11374 return Err(serde::de::Error::duplicate_field("disableBackfill"));
11375 }
11376 disable_backfill__ = Some(map_.next_value()?);
11377 }
11378 GeneratedField::SnapshotBarrierInterval => {
11379 if snapshot_barrier_interval__.is_some() {
11380 return Err(serde::de::Error::duplicate_field("snapshotBarrierInterval"));
11381 }
11382 snapshot_barrier_interval__ =
11383 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11384 ;
11385 }
11386 GeneratedField::SnapshotBatchSize => {
11387 if snapshot_batch_size__.is_some() {
11388 return Err(serde::de::Error::duplicate_field("snapshotBatchSize"));
11389 }
11390 snapshot_batch_size__ =
11391 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11392 ;
11393 }
11394 GeneratedField::BackfillParallelism => {
11395 if backfill_parallelism__.is_some() {
11396 return Err(serde::de::Error::duplicate_field("backfillParallelism"));
11397 }
11398 backfill_parallelism__ =
11399 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11400 ;
11401 }
11402 GeneratedField::BackfillNumRowsPerSplit => {
11403 if backfill_num_rows_per_split__.is_some() {
11404 return Err(serde::de::Error::duplicate_field("backfillNumRowsPerSplit"));
11405 }
11406 backfill_num_rows_per_split__ =
11407 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11408 ;
11409 }
11410 GeneratedField::BackfillAsEvenSplits => {
11411 if backfill_as_even_splits__.is_some() {
11412 return Err(serde::de::Error::duplicate_field("backfillAsEvenSplits"));
11413 }
11414 backfill_as_even_splits__ = Some(map_.next_value()?);
11415 }
11416 GeneratedField::BackfillSplitPkColumnIndex => {
11417 if backfill_split_pk_column_index__.is_some() {
11418 return Err(serde::de::Error::duplicate_field("backfillSplitPkColumnIndex"));
11419 }
11420 backfill_split_pk_column_index__ =
11421 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11422 ;
11423 }
11424 }
11425 }
11426 Ok(StreamCdcScanOptions {
11427 disable_backfill: disable_backfill__.unwrap_or_default(),
11428 snapshot_barrier_interval: snapshot_barrier_interval__.unwrap_or_default(),
11429 snapshot_batch_size: snapshot_batch_size__.unwrap_or_default(),
11430 backfill_parallelism: backfill_parallelism__.unwrap_or_default(),
11431 backfill_num_rows_per_split: backfill_num_rows_per_split__.unwrap_or_default(),
11432 backfill_as_even_splits: backfill_as_even_splits__.unwrap_or_default(),
11433 backfill_split_pk_column_index: backfill_split_pk_column_index__.unwrap_or_default(),
11434 })
11435 }
11436 }
11437 deserializer.deserialize_struct("stream_plan.StreamCdcScanOptions", FIELDS, GeneratedVisitor)
11438 }
11439}
11440impl serde::Serialize for StreamContext {
11441 #[allow(deprecated)]
11442 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11443 where
11444 S: serde::Serializer,
11445 {
11446 use serde::ser::SerializeStruct;
11447 let mut len = 0;
11448 if !self.timezone.is_empty() {
11449 len += 1;
11450 }
11451 if !self.config_override.is_empty() {
11452 len += 1;
11453 }
11454 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamContext", len)?;
11455 if !self.timezone.is_empty() {
11456 struct_ser.serialize_field("timezone", &self.timezone)?;
11457 }
11458 if !self.config_override.is_empty() {
11459 struct_ser.serialize_field("configOverride", &self.config_override)?;
11460 }
11461 struct_ser.end()
11462 }
11463}
11464impl<'de> serde::Deserialize<'de> for StreamContext {
11465 #[allow(deprecated)]
11466 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11467 where
11468 D: serde::Deserializer<'de>,
11469 {
11470 const FIELDS: &[&str] = &[
11471 "timezone",
11472 "config_override",
11473 "configOverride",
11474 ];
11475
11476 #[allow(clippy::enum_variant_names)]
11477 enum GeneratedField {
11478 Timezone,
11479 ConfigOverride,
11480 }
11481 impl<'de> serde::Deserialize<'de> for GeneratedField {
11482 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11483 where
11484 D: serde::Deserializer<'de>,
11485 {
11486 struct GeneratedVisitor;
11487
11488 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11489 type Value = GeneratedField;
11490
11491 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11492 write!(formatter, "expected one of: {:?}", &FIELDS)
11493 }
11494
11495 #[allow(unused_variables)]
11496 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11497 where
11498 E: serde::de::Error,
11499 {
11500 match value {
11501 "timezone" => Ok(GeneratedField::Timezone),
11502 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
11503 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11504 }
11505 }
11506 }
11507 deserializer.deserialize_identifier(GeneratedVisitor)
11508 }
11509 }
11510 struct GeneratedVisitor;
11511 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11512 type Value = StreamContext;
11513
11514 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11515 formatter.write_str("struct stream_plan.StreamContext")
11516 }
11517
11518 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamContext, V::Error>
11519 where
11520 V: serde::de::MapAccess<'de>,
11521 {
11522 let mut timezone__ = None;
11523 let mut config_override__ = None;
11524 while let Some(k) = map_.next_key()? {
11525 match k {
11526 GeneratedField::Timezone => {
11527 if timezone__.is_some() {
11528 return Err(serde::de::Error::duplicate_field("timezone"));
11529 }
11530 timezone__ = Some(map_.next_value()?);
11531 }
11532 GeneratedField::ConfigOverride => {
11533 if config_override__.is_some() {
11534 return Err(serde::de::Error::duplicate_field("configOverride"));
11535 }
11536 config_override__ = Some(map_.next_value()?);
11537 }
11538 }
11539 }
11540 Ok(StreamContext {
11541 timezone: timezone__.unwrap_or_default(),
11542 config_override: config_override__.unwrap_or_default(),
11543 })
11544 }
11545 }
11546 deserializer.deserialize_struct("stream_plan.StreamContext", FIELDS, GeneratedVisitor)
11547 }
11548}
11549impl serde::Serialize for StreamFragmentGraph {
11550 #[allow(deprecated)]
11551 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11552 where
11553 S: serde::Serializer,
11554 {
11555 use serde::ser::SerializeStruct;
11556 let mut len = 0;
11557 if !self.fragments.is_empty() {
11558 len += 1;
11559 }
11560 if !self.edges.is_empty() {
11561 len += 1;
11562 }
11563 if !self.dependent_table_ids.is_empty() {
11564 len += 1;
11565 }
11566 if self.table_ids_cnt != 0 {
11567 len += 1;
11568 }
11569 if self.ctx.is_some() {
11570 len += 1;
11571 }
11572 if self.parallelism.is_some() {
11573 len += 1;
11574 }
11575 if self.max_parallelism != 0 {
11576 len += 1;
11577 }
11578 if self.backfill_order.is_some() {
11579 len += 1;
11580 }
11581 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph", len)?;
11582 if !self.fragments.is_empty() {
11583 struct_ser.serialize_field("fragments", &self.fragments)?;
11584 }
11585 if !self.edges.is_empty() {
11586 struct_ser.serialize_field("edges", &self.edges)?;
11587 }
11588 if !self.dependent_table_ids.is_empty() {
11589 struct_ser.serialize_field("dependentTableIds", &self.dependent_table_ids)?;
11590 }
11591 if self.table_ids_cnt != 0 {
11592 struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
11593 }
11594 if let Some(v) = self.ctx.as_ref() {
11595 struct_ser.serialize_field("ctx", v)?;
11596 }
11597 if let Some(v) = self.parallelism.as_ref() {
11598 struct_ser.serialize_field("parallelism", v)?;
11599 }
11600 if self.max_parallelism != 0 {
11601 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
11602 }
11603 if let Some(v) = self.backfill_order.as_ref() {
11604 struct_ser.serialize_field("backfillOrder", v)?;
11605 }
11606 struct_ser.end()
11607 }
11608}
11609impl<'de> serde::Deserialize<'de> for StreamFragmentGraph {
11610 #[allow(deprecated)]
11611 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11612 where
11613 D: serde::Deserializer<'de>,
11614 {
11615 const FIELDS: &[&str] = &[
11616 "fragments",
11617 "edges",
11618 "dependent_table_ids",
11619 "dependentTableIds",
11620 "table_ids_cnt",
11621 "tableIdsCnt",
11622 "ctx",
11623 "parallelism",
11624 "max_parallelism",
11625 "maxParallelism",
11626 "backfill_order",
11627 "backfillOrder",
11628 ];
11629
11630 #[allow(clippy::enum_variant_names)]
11631 enum GeneratedField {
11632 Fragments,
11633 Edges,
11634 DependentTableIds,
11635 TableIdsCnt,
11636 Ctx,
11637 Parallelism,
11638 MaxParallelism,
11639 BackfillOrder,
11640 }
11641 impl<'de> serde::Deserialize<'de> for GeneratedField {
11642 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11643 where
11644 D: serde::Deserializer<'de>,
11645 {
11646 struct GeneratedVisitor;
11647
11648 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11649 type Value = GeneratedField;
11650
11651 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11652 write!(formatter, "expected one of: {:?}", &FIELDS)
11653 }
11654
11655 #[allow(unused_variables)]
11656 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11657 where
11658 E: serde::de::Error,
11659 {
11660 match value {
11661 "fragments" => Ok(GeneratedField::Fragments),
11662 "edges" => Ok(GeneratedField::Edges),
11663 "dependentTableIds" | "dependent_table_ids" => Ok(GeneratedField::DependentTableIds),
11664 "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
11665 "ctx" => Ok(GeneratedField::Ctx),
11666 "parallelism" => Ok(GeneratedField::Parallelism),
11667 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
11668 "backfillOrder" | "backfill_order" => Ok(GeneratedField::BackfillOrder),
11669 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11670 }
11671 }
11672 }
11673 deserializer.deserialize_identifier(GeneratedVisitor)
11674 }
11675 }
11676 struct GeneratedVisitor;
11677 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11678 type Value = StreamFragmentGraph;
11679
11680 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11681 formatter.write_str("struct stream_plan.StreamFragmentGraph")
11682 }
11683
11684 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFragmentGraph, V::Error>
11685 where
11686 V: serde::de::MapAccess<'de>,
11687 {
11688 let mut fragments__ = None;
11689 let mut edges__ = None;
11690 let mut dependent_table_ids__ = None;
11691 let mut table_ids_cnt__ = None;
11692 let mut ctx__ = None;
11693 let mut parallelism__ = None;
11694 let mut max_parallelism__ = None;
11695 let mut backfill_order__ = None;
11696 while let Some(k) = map_.next_key()? {
11697 match k {
11698 GeneratedField::Fragments => {
11699 if fragments__.is_some() {
11700 return Err(serde::de::Error::duplicate_field("fragments"));
11701 }
11702 fragments__ = Some(
11703 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11704 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
11705 );
11706 }
11707 GeneratedField::Edges => {
11708 if edges__.is_some() {
11709 return Err(serde::de::Error::duplicate_field("edges"));
11710 }
11711 edges__ = Some(map_.next_value()?);
11712 }
11713 GeneratedField::DependentTableIds => {
11714 if dependent_table_ids__.is_some() {
11715 return Err(serde::de::Error::duplicate_field("dependentTableIds"));
11716 }
11717 dependent_table_ids__ =
11718 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11719 .into_iter().map(|x| x.0).collect())
11720 ;
11721 }
11722 GeneratedField::TableIdsCnt => {
11723 if table_ids_cnt__.is_some() {
11724 return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
11725 }
11726 table_ids_cnt__ =
11727 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11728 ;
11729 }
11730 GeneratedField::Ctx => {
11731 if ctx__.is_some() {
11732 return Err(serde::de::Error::duplicate_field("ctx"));
11733 }
11734 ctx__ = map_.next_value()?;
11735 }
11736 GeneratedField::Parallelism => {
11737 if parallelism__.is_some() {
11738 return Err(serde::de::Error::duplicate_field("parallelism"));
11739 }
11740 parallelism__ = map_.next_value()?;
11741 }
11742 GeneratedField::MaxParallelism => {
11743 if max_parallelism__.is_some() {
11744 return Err(serde::de::Error::duplicate_field("maxParallelism"));
11745 }
11746 max_parallelism__ =
11747 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11748 ;
11749 }
11750 GeneratedField::BackfillOrder => {
11751 if backfill_order__.is_some() {
11752 return Err(serde::de::Error::duplicate_field("backfillOrder"));
11753 }
11754 backfill_order__ = map_.next_value()?;
11755 }
11756 }
11757 }
11758 Ok(StreamFragmentGraph {
11759 fragments: fragments__.unwrap_or_default(),
11760 edges: edges__.unwrap_or_default(),
11761 dependent_table_ids: dependent_table_ids__.unwrap_or_default(),
11762 table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
11763 ctx: ctx__,
11764 parallelism: parallelism__,
11765 max_parallelism: max_parallelism__.unwrap_or_default(),
11766 backfill_order: backfill_order__,
11767 })
11768 }
11769 }
11770 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph", FIELDS, GeneratedVisitor)
11771 }
11772}
11773impl serde::Serialize for stream_fragment_graph::Parallelism {
11774 #[allow(deprecated)]
11775 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11776 where
11777 S: serde::Serializer,
11778 {
11779 use serde::ser::SerializeStruct;
11780 let mut len = 0;
11781 if self.parallelism != 0 {
11782 len += 1;
11783 }
11784 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.Parallelism", len)?;
11785 if self.parallelism != 0 {
11786 #[allow(clippy::needless_borrow)]
11787 #[allow(clippy::needless_borrows_for_generic_args)]
11788 struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
11789 }
11790 struct_ser.end()
11791 }
11792}
11793impl<'de> serde::Deserialize<'de> for stream_fragment_graph::Parallelism {
11794 #[allow(deprecated)]
11795 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11796 where
11797 D: serde::Deserializer<'de>,
11798 {
11799 const FIELDS: &[&str] = &[
11800 "parallelism",
11801 ];
11802
11803 #[allow(clippy::enum_variant_names)]
11804 enum GeneratedField {
11805 Parallelism,
11806 }
11807 impl<'de> serde::Deserialize<'de> for GeneratedField {
11808 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11809 where
11810 D: serde::Deserializer<'de>,
11811 {
11812 struct GeneratedVisitor;
11813
11814 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11815 type Value = GeneratedField;
11816
11817 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11818 write!(formatter, "expected one of: {:?}", &FIELDS)
11819 }
11820
11821 #[allow(unused_variables)]
11822 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11823 where
11824 E: serde::de::Error,
11825 {
11826 match value {
11827 "parallelism" => Ok(GeneratedField::Parallelism),
11828 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11829 }
11830 }
11831 }
11832 deserializer.deserialize_identifier(GeneratedVisitor)
11833 }
11834 }
11835 struct GeneratedVisitor;
11836 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11837 type Value = stream_fragment_graph::Parallelism;
11838
11839 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11840 formatter.write_str("struct stream_plan.StreamFragmentGraph.Parallelism")
11841 }
11842
11843 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::Parallelism, V::Error>
11844 where
11845 V: serde::de::MapAccess<'de>,
11846 {
11847 let mut parallelism__ = None;
11848 while let Some(k) = map_.next_key()? {
11849 match k {
11850 GeneratedField::Parallelism => {
11851 if parallelism__.is_some() {
11852 return Err(serde::de::Error::duplicate_field("parallelism"));
11853 }
11854 parallelism__ =
11855 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11856 ;
11857 }
11858 }
11859 }
11860 Ok(stream_fragment_graph::Parallelism {
11861 parallelism: parallelism__.unwrap_or_default(),
11862 })
11863 }
11864 }
11865 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.Parallelism", FIELDS, GeneratedVisitor)
11866 }
11867}
11868impl serde::Serialize for stream_fragment_graph::StreamFragment {
11869 #[allow(deprecated)]
11870 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11871 where
11872 S: serde::Serializer,
11873 {
11874 use serde::ser::SerializeStruct;
11875 let mut len = 0;
11876 if self.fragment_id != 0 {
11877 len += 1;
11878 }
11879 if self.node.is_some() {
11880 len += 1;
11881 }
11882 if self.fragment_type_mask != 0 {
11883 len += 1;
11884 }
11885 if self.requires_singleton {
11886 len += 1;
11887 }
11888 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", len)?;
11889 if self.fragment_id != 0 {
11890 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
11891 }
11892 if let Some(v) = self.node.as_ref() {
11893 struct_ser.serialize_field("node", v)?;
11894 }
11895 if self.fragment_type_mask != 0 {
11896 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
11897 }
11898 if self.requires_singleton {
11899 struct_ser.serialize_field("requiresSingleton", &self.requires_singleton)?;
11900 }
11901 struct_ser.end()
11902 }
11903}
11904impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragment {
11905 #[allow(deprecated)]
11906 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11907 where
11908 D: serde::Deserializer<'de>,
11909 {
11910 const FIELDS: &[&str] = &[
11911 "fragment_id",
11912 "fragmentId",
11913 "node",
11914 "fragment_type_mask",
11915 "fragmentTypeMask",
11916 "requires_singleton",
11917 "requiresSingleton",
11918 ];
11919
11920 #[allow(clippy::enum_variant_names)]
11921 enum GeneratedField {
11922 FragmentId,
11923 Node,
11924 FragmentTypeMask,
11925 RequiresSingleton,
11926 }
11927 impl<'de> serde::Deserialize<'de> for GeneratedField {
11928 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11929 where
11930 D: serde::Deserializer<'de>,
11931 {
11932 struct GeneratedVisitor;
11933
11934 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11935 type Value = GeneratedField;
11936
11937 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11938 write!(formatter, "expected one of: {:?}", &FIELDS)
11939 }
11940
11941 #[allow(unused_variables)]
11942 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11943 where
11944 E: serde::de::Error,
11945 {
11946 match value {
11947 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
11948 "node" => Ok(GeneratedField::Node),
11949 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
11950 "requiresSingleton" | "requires_singleton" => Ok(GeneratedField::RequiresSingleton),
11951 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11952 }
11953 }
11954 }
11955 deserializer.deserialize_identifier(GeneratedVisitor)
11956 }
11957 }
11958 struct GeneratedVisitor;
11959 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11960 type Value = stream_fragment_graph::StreamFragment;
11961
11962 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11963 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragment")
11964 }
11965
11966 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragment, V::Error>
11967 where
11968 V: serde::de::MapAccess<'de>,
11969 {
11970 let mut fragment_id__ = None;
11971 let mut node__ = None;
11972 let mut fragment_type_mask__ = None;
11973 let mut requires_singleton__ = None;
11974 while let Some(k) = map_.next_key()? {
11975 match k {
11976 GeneratedField::FragmentId => {
11977 if fragment_id__.is_some() {
11978 return Err(serde::de::Error::duplicate_field("fragmentId"));
11979 }
11980 fragment_id__ =
11981 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11982 ;
11983 }
11984 GeneratedField::Node => {
11985 if node__.is_some() {
11986 return Err(serde::de::Error::duplicate_field("node"));
11987 }
11988 node__ = map_.next_value()?;
11989 }
11990 GeneratedField::FragmentTypeMask => {
11991 if fragment_type_mask__.is_some() {
11992 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
11993 }
11994 fragment_type_mask__ =
11995 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11996 ;
11997 }
11998 GeneratedField::RequiresSingleton => {
11999 if requires_singleton__.is_some() {
12000 return Err(serde::de::Error::duplicate_field("requiresSingleton"));
12001 }
12002 requires_singleton__ = Some(map_.next_value()?);
12003 }
12004 }
12005 }
12006 Ok(stream_fragment_graph::StreamFragment {
12007 fragment_id: fragment_id__.unwrap_or_default(),
12008 node: node__,
12009 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
12010 requires_singleton: requires_singleton__.unwrap_or_default(),
12011 })
12012 }
12013 }
12014 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", FIELDS, GeneratedVisitor)
12015 }
12016}
12017impl serde::Serialize for stream_fragment_graph::StreamFragmentEdge {
12018 #[allow(deprecated)]
12019 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12020 where
12021 S: serde::Serializer,
12022 {
12023 use serde::ser::SerializeStruct;
12024 let mut len = 0;
12025 if self.dispatch_strategy.is_some() {
12026 len += 1;
12027 }
12028 if self.link_id != 0 {
12029 len += 1;
12030 }
12031 if self.upstream_id != 0 {
12032 len += 1;
12033 }
12034 if self.downstream_id != 0 {
12035 len += 1;
12036 }
12037 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", len)?;
12038 if let Some(v) = self.dispatch_strategy.as_ref() {
12039 struct_ser.serialize_field("dispatchStrategy", v)?;
12040 }
12041 if self.link_id != 0 {
12042 #[allow(clippy::needless_borrow)]
12043 #[allow(clippy::needless_borrows_for_generic_args)]
12044 struct_ser.serialize_field("linkId", ToString::to_string(&self.link_id).as_str())?;
12045 }
12046 if self.upstream_id != 0 {
12047 struct_ser.serialize_field("upstreamId", &self.upstream_id)?;
12048 }
12049 if self.downstream_id != 0 {
12050 struct_ser.serialize_field("downstreamId", &self.downstream_id)?;
12051 }
12052 struct_ser.end()
12053 }
12054}
12055impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragmentEdge {
12056 #[allow(deprecated)]
12057 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12058 where
12059 D: serde::Deserializer<'de>,
12060 {
12061 const FIELDS: &[&str] = &[
12062 "dispatch_strategy",
12063 "dispatchStrategy",
12064 "link_id",
12065 "linkId",
12066 "upstream_id",
12067 "upstreamId",
12068 "downstream_id",
12069 "downstreamId",
12070 ];
12071
12072 #[allow(clippy::enum_variant_names)]
12073 enum GeneratedField {
12074 DispatchStrategy,
12075 LinkId,
12076 UpstreamId,
12077 DownstreamId,
12078 }
12079 impl<'de> serde::Deserialize<'de> for GeneratedField {
12080 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12081 where
12082 D: serde::Deserializer<'de>,
12083 {
12084 struct GeneratedVisitor;
12085
12086 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12087 type Value = GeneratedField;
12088
12089 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12090 write!(formatter, "expected one of: {:?}", &FIELDS)
12091 }
12092
12093 #[allow(unused_variables)]
12094 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12095 where
12096 E: serde::de::Error,
12097 {
12098 match value {
12099 "dispatchStrategy" | "dispatch_strategy" => Ok(GeneratedField::DispatchStrategy),
12100 "linkId" | "link_id" => Ok(GeneratedField::LinkId),
12101 "upstreamId" | "upstream_id" => Ok(GeneratedField::UpstreamId),
12102 "downstreamId" | "downstream_id" => Ok(GeneratedField::DownstreamId),
12103 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12104 }
12105 }
12106 }
12107 deserializer.deserialize_identifier(GeneratedVisitor)
12108 }
12109 }
12110 struct GeneratedVisitor;
12111 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12112 type Value = stream_fragment_graph::StreamFragmentEdge;
12113
12114 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12115 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragmentEdge")
12116 }
12117
12118 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragmentEdge, V::Error>
12119 where
12120 V: serde::de::MapAccess<'de>,
12121 {
12122 let mut dispatch_strategy__ = None;
12123 let mut link_id__ = None;
12124 let mut upstream_id__ = None;
12125 let mut downstream_id__ = None;
12126 while let Some(k) = map_.next_key()? {
12127 match k {
12128 GeneratedField::DispatchStrategy => {
12129 if dispatch_strategy__.is_some() {
12130 return Err(serde::de::Error::duplicate_field("dispatchStrategy"));
12131 }
12132 dispatch_strategy__ = map_.next_value()?;
12133 }
12134 GeneratedField::LinkId => {
12135 if link_id__.is_some() {
12136 return Err(serde::de::Error::duplicate_field("linkId"));
12137 }
12138 link_id__ =
12139 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12140 ;
12141 }
12142 GeneratedField::UpstreamId => {
12143 if upstream_id__.is_some() {
12144 return Err(serde::de::Error::duplicate_field("upstreamId"));
12145 }
12146 upstream_id__ =
12147 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12148 ;
12149 }
12150 GeneratedField::DownstreamId => {
12151 if downstream_id__.is_some() {
12152 return Err(serde::de::Error::duplicate_field("downstreamId"));
12153 }
12154 downstream_id__ =
12155 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12156 ;
12157 }
12158 }
12159 }
12160 Ok(stream_fragment_graph::StreamFragmentEdge {
12161 dispatch_strategy: dispatch_strategy__,
12162 link_id: link_id__.unwrap_or_default(),
12163 upstream_id: upstream_id__.unwrap_or_default(),
12164 downstream_id: downstream_id__.unwrap_or_default(),
12165 })
12166 }
12167 }
12168 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", FIELDS, GeneratedVisitor)
12169 }
12170}
12171impl serde::Serialize for StreamFsFetch {
12172 #[allow(deprecated)]
12173 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12174 where
12175 S: serde::Serializer,
12176 {
12177 use serde::ser::SerializeStruct;
12178 let mut len = 0;
12179 if self.source_id != 0 {
12180 len += 1;
12181 }
12182 if self.state_table.is_some() {
12183 len += 1;
12184 }
12185 if self.row_id_index.is_some() {
12186 len += 1;
12187 }
12188 if !self.columns.is_empty() {
12189 len += 1;
12190 }
12191 if !self.with_properties.is_empty() {
12192 len += 1;
12193 }
12194 if self.info.is_some() {
12195 len += 1;
12196 }
12197 if !self.source_name.is_empty() {
12198 len += 1;
12199 }
12200 if self.rate_limit.is_some() {
12201 len += 1;
12202 }
12203 if !self.secret_refs.is_empty() {
12204 len += 1;
12205 }
12206 if self.refresh_mode.is_some() {
12207 len += 1;
12208 }
12209 if self.associated_table_id.is_some() {
12210 len += 1;
12211 }
12212 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetch", len)?;
12213 if self.source_id != 0 {
12214 struct_ser.serialize_field("sourceId", &self.source_id)?;
12215 }
12216 if let Some(v) = self.state_table.as_ref() {
12217 struct_ser.serialize_field("stateTable", v)?;
12218 }
12219 if let Some(v) = self.row_id_index.as_ref() {
12220 struct_ser.serialize_field("rowIdIndex", v)?;
12221 }
12222 if !self.columns.is_empty() {
12223 struct_ser.serialize_field("columns", &self.columns)?;
12224 }
12225 if !self.with_properties.is_empty() {
12226 struct_ser.serialize_field("withProperties", &self.with_properties)?;
12227 }
12228 if let Some(v) = self.info.as_ref() {
12229 struct_ser.serialize_field("info", v)?;
12230 }
12231 if !self.source_name.is_empty() {
12232 struct_ser.serialize_field("sourceName", &self.source_name)?;
12233 }
12234 if let Some(v) = self.rate_limit.as_ref() {
12235 struct_ser.serialize_field("rateLimit", v)?;
12236 }
12237 if !self.secret_refs.is_empty() {
12238 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
12239 }
12240 if let Some(v) = self.refresh_mode.as_ref() {
12241 struct_ser.serialize_field("refreshMode", v)?;
12242 }
12243 if let Some(v) = self.associated_table_id.as_ref() {
12244 struct_ser.serialize_field("associatedTableId", v)?;
12245 }
12246 struct_ser.end()
12247 }
12248}
12249impl<'de> serde::Deserialize<'de> for StreamFsFetch {
12250 #[allow(deprecated)]
12251 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12252 where
12253 D: serde::Deserializer<'de>,
12254 {
12255 const FIELDS: &[&str] = &[
12256 "source_id",
12257 "sourceId",
12258 "state_table",
12259 "stateTable",
12260 "row_id_index",
12261 "rowIdIndex",
12262 "columns",
12263 "with_properties",
12264 "withProperties",
12265 "info",
12266 "source_name",
12267 "sourceName",
12268 "rate_limit",
12269 "rateLimit",
12270 "secret_refs",
12271 "secretRefs",
12272 "refresh_mode",
12273 "refreshMode",
12274 "associated_table_id",
12275 "associatedTableId",
12276 ];
12277
12278 #[allow(clippy::enum_variant_names)]
12279 enum GeneratedField {
12280 SourceId,
12281 StateTable,
12282 RowIdIndex,
12283 Columns,
12284 WithProperties,
12285 Info,
12286 SourceName,
12287 RateLimit,
12288 SecretRefs,
12289 RefreshMode,
12290 AssociatedTableId,
12291 }
12292 impl<'de> serde::Deserialize<'de> for GeneratedField {
12293 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12294 where
12295 D: serde::Deserializer<'de>,
12296 {
12297 struct GeneratedVisitor;
12298
12299 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12300 type Value = GeneratedField;
12301
12302 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12303 write!(formatter, "expected one of: {:?}", &FIELDS)
12304 }
12305
12306 #[allow(unused_variables)]
12307 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12308 where
12309 E: serde::de::Error,
12310 {
12311 match value {
12312 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
12313 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
12314 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
12315 "columns" => Ok(GeneratedField::Columns),
12316 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
12317 "info" => Ok(GeneratedField::Info),
12318 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
12319 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
12320 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
12321 "refreshMode" | "refresh_mode" => Ok(GeneratedField::RefreshMode),
12322 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
12323 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12324 }
12325 }
12326 }
12327 deserializer.deserialize_identifier(GeneratedVisitor)
12328 }
12329 }
12330 struct GeneratedVisitor;
12331 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12332 type Value = StreamFsFetch;
12333
12334 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12335 formatter.write_str("struct stream_plan.StreamFsFetch")
12336 }
12337
12338 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetch, V::Error>
12339 where
12340 V: serde::de::MapAccess<'de>,
12341 {
12342 let mut source_id__ = None;
12343 let mut state_table__ = None;
12344 let mut row_id_index__ = None;
12345 let mut columns__ = None;
12346 let mut with_properties__ = None;
12347 let mut info__ = None;
12348 let mut source_name__ = None;
12349 let mut rate_limit__ = None;
12350 let mut secret_refs__ = None;
12351 let mut refresh_mode__ = None;
12352 let mut associated_table_id__ = None;
12353 while let Some(k) = map_.next_key()? {
12354 match k {
12355 GeneratedField::SourceId => {
12356 if source_id__.is_some() {
12357 return Err(serde::de::Error::duplicate_field("sourceId"));
12358 }
12359 source_id__ =
12360 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12361 ;
12362 }
12363 GeneratedField::StateTable => {
12364 if state_table__.is_some() {
12365 return Err(serde::de::Error::duplicate_field("stateTable"));
12366 }
12367 state_table__ = map_.next_value()?;
12368 }
12369 GeneratedField::RowIdIndex => {
12370 if row_id_index__.is_some() {
12371 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
12372 }
12373 row_id_index__ =
12374 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12375 ;
12376 }
12377 GeneratedField::Columns => {
12378 if columns__.is_some() {
12379 return Err(serde::de::Error::duplicate_field("columns"));
12380 }
12381 columns__ = Some(map_.next_value()?);
12382 }
12383 GeneratedField::WithProperties => {
12384 if with_properties__.is_some() {
12385 return Err(serde::de::Error::duplicate_field("withProperties"));
12386 }
12387 with_properties__ = Some(
12388 map_.next_value::<std::collections::BTreeMap<_, _>>()?
12389 );
12390 }
12391 GeneratedField::Info => {
12392 if info__.is_some() {
12393 return Err(serde::de::Error::duplicate_field("info"));
12394 }
12395 info__ = map_.next_value()?;
12396 }
12397 GeneratedField::SourceName => {
12398 if source_name__.is_some() {
12399 return Err(serde::de::Error::duplicate_field("sourceName"));
12400 }
12401 source_name__ = Some(map_.next_value()?);
12402 }
12403 GeneratedField::RateLimit => {
12404 if rate_limit__.is_some() {
12405 return Err(serde::de::Error::duplicate_field("rateLimit"));
12406 }
12407 rate_limit__ =
12408 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12409 ;
12410 }
12411 GeneratedField::SecretRefs => {
12412 if secret_refs__.is_some() {
12413 return Err(serde::de::Error::duplicate_field("secretRefs"));
12414 }
12415 secret_refs__ = Some(
12416 map_.next_value::<std::collections::BTreeMap<_, _>>()?
12417 );
12418 }
12419 GeneratedField::RefreshMode => {
12420 if refresh_mode__.is_some() {
12421 return Err(serde::de::Error::duplicate_field("refreshMode"));
12422 }
12423 refresh_mode__ = map_.next_value()?;
12424 }
12425 GeneratedField::AssociatedTableId => {
12426 if associated_table_id__.is_some() {
12427 return Err(serde::de::Error::duplicate_field("associatedTableId"));
12428 }
12429 associated_table_id__ =
12430 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12431 ;
12432 }
12433 }
12434 }
12435 Ok(StreamFsFetch {
12436 source_id: source_id__.unwrap_or_default(),
12437 state_table: state_table__,
12438 row_id_index: row_id_index__,
12439 columns: columns__.unwrap_or_default(),
12440 with_properties: with_properties__.unwrap_or_default(),
12441 info: info__,
12442 source_name: source_name__.unwrap_or_default(),
12443 rate_limit: rate_limit__,
12444 secret_refs: secret_refs__.unwrap_or_default(),
12445 refresh_mode: refresh_mode__,
12446 associated_table_id: associated_table_id__,
12447 })
12448 }
12449 }
12450 deserializer.deserialize_struct("stream_plan.StreamFsFetch", FIELDS, GeneratedVisitor)
12451 }
12452}
12453impl serde::Serialize for StreamFsFetchNode {
12454 #[allow(deprecated)]
12455 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12456 where
12457 S: serde::Serializer,
12458 {
12459 use serde::ser::SerializeStruct;
12460 let mut len = 0;
12461 if self.node_inner.is_some() {
12462 len += 1;
12463 }
12464 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetchNode", len)?;
12465 if let Some(v) = self.node_inner.as_ref() {
12466 struct_ser.serialize_field("nodeInner", v)?;
12467 }
12468 struct_ser.end()
12469 }
12470}
12471impl<'de> serde::Deserialize<'de> for StreamFsFetchNode {
12472 #[allow(deprecated)]
12473 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12474 where
12475 D: serde::Deserializer<'de>,
12476 {
12477 const FIELDS: &[&str] = &[
12478 "node_inner",
12479 "nodeInner",
12480 ];
12481
12482 #[allow(clippy::enum_variant_names)]
12483 enum GeneratedField {
12484 NodeInner,
12485 }
12486 impl<'de> serde::Deserialize<'de> for GeneratedField {
12487 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12488 where
12489 D: serde::Deserializer<'de>,
12490 {
12491 struct GeneratedVisitor;
12492
12493 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12494 type Value = GeneratedField;
12495
12496 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12497 write!(formatter, "expected one of: {:?}", &FIELDS)
12498 }
12499
12500 #[allow(unused_variables)]
12501 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12502 where
12503 E: serde::de::Error,
12504 {
12505 match value {
12506 "nodeInner" | "node_inner" => Ok(GeneratedField::NodeInner),
12507 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12508 }
12509 }
12510 }
12511 deserializer.deserialize_identifier(GeneratedVisitor)
12512 }
12513 }
12514 struct GeneratedVisitor;
12515 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12516 type Value = StreamFsFetchNode;
12517
12518 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12519 formatter.write_str("struct stream_plan.StreamFsFetchNode")
12520 }
12521
12522 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetchNode, V::Error>
12523 where
12524 V: serde::de::MapAccess<'de>,
12525 {
12526 let mut node_inner__ = None;
12527 while let Some(k) = map_.next_key()? {
12528 match k {
12529 GeneratedField::NodeInner => {
12530 if node_inner__.is_some() {
12531 return Err(serde::de::Error::duplicate_field("nodeInner"));
12532 }
12533 node_inner__ = map_.next_value()?;
12534 }
12535 }
12536 }
12537 Ok(StreamFsFetchNode {
12538 node_inner: node_inner__,
12539 })
12540 }
12541 }
12542 deserializer.deserialize_struct("stream_plan.StreamFsFetchNode", FIELDS, GeneratedVisitor)
12543 }
12544}
12545impl serde::Serialize for StreamMessage {
12546 #[allow(deprecated)]
12547 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12548 where
12549 S: serde::Serializer,
12550 {
12551 use serde::ser::SerializeStruct;
12552 let mut len = 0;
12553 if self.stream_message.is_some() {
12554 len += 1;
12555 }
12556 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessage", len)?;
12557 if let Some(v) = self.stream_message.as_ref() {
12558 match v {
12559 stream_message::StreamMessage::StreamChunk(v) => {
12560 struct_ser.serialize_field("streamChunk", v)?;
12561 }
12562 stream_message::StreamMessage::Barrier(v) => {
12563 struct_ser.serialize_field("barrier", v)?;
12564 }
12565 stream_message::StreamMessage::Watermark(v) => {
12566 struct_ser.serialize_field("watermark", v)?;
12567 }
12568 }
12569 }
12570 struct_ser.end()
12571 }
12572}
12573impl<'de> serde::Deserialize<'de> for StreamMessage {
12574 #[allow(deprecated)]
12575 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12576 where
12577 D: serde::Deserializer<'de>,
12578 {
12579 const FIELDS: &[&str] = &[
12580 "stream_chunk",
12581 "streamChunk",
12582 "barrier",
12583 "watermark",
12584 ];
12585
12586 #[allow(clippy::enum_variant_names)]
12587 enum GeneratedField {
12588 StreamChunk,
12589 Barrier,
12590 Watermark,
12591 }
12592 impl<'de> serde::Deserialize<'de> for GeneratedField {
12593 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12594 where
12595 D: serde::Deserializer<'de>,
12596 {
12597 struct GeneratedVisitor;
12598
12599 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12600 type Value = GeneratedField;
12601
12602 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12603 write!(formatter, "expected one of: {:?}", &FIELDS)
12604 }
12605
12606 #[allow(unused_variables)]
12607 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12608 where
12609 E: serde::de::Error,
12610 {
12611 match value {
12612 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
12613 "barrier" => Ok(GeneratedField::Barrier),
12614 "watermark" => Ok(GeneratedField::Watermark),
12615 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12616 }
12617 }
12618 }
12619 deserializer.deserialize_identifier(GeneratedVisitor)
12620 }
12621 }
12622 struct GeneratedVisitor;
12623 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12624 type Value = StreamMessage;
12625
12626 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12627 formatter.write_str("struct stream_plan.StreamMessage")
12628 }
12629
12630 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessage, V::Error>
12631 where
12632 V: serde::de::MapAccess<'de>,
12633 {
12634 let mut stream_message__ = None;
12635 while let Some(k) = map_.next_key()? {
12636 match k {
12637 GeneratedField::StreamChunk => {
12638 if stream_message__.is_some() {
12639 return Err(serde::de::Error::duplicate_field("streamChunk"));
12640 }
12641 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::StreamChunk)
12642;
12643 }
12644 GeneratedField::Barrier => {
12645 if stream_message__.is_some() {
12646 return Err(serde::de::Error::duplicate_field("barrier"));
12647 }
12648 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Barrier)
12649;
12650 }
12651 GeneratedField::Watermark => {
12652 if stream_message__.is_some() {
12653 return Err(serde::de::Error::duplicate_field("watermark"));
12654 }
12655 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Watermark)
12656;
12657 }
12658 }
12659 }
12660 Ok(StreamMessage {
12661 stream_message: stream_message__,
12662 })
12663 }
12664 }
12665 deserializer.deserialize_struct("stream_plan.StreamMessage", FIELDS, GeneratedVisitor)
12666 }
12667}
12668impl serde::Serialize for StreamMessageBatch {
12669 #[allow(deprecated)]
12670 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12671 where
12672 S: serde::Serializer,
12673 {
12674 use serde::ser::SerializeStruct;
12675 let mut len = 0;
12676 if self.stream_message_batch.is_some() {
12677 len += 1;
12678 }
12679 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch", len)?;
12680 if let Some(v) = self.stream_message_batch.as_ref() {
12681 match v {
12682 stream_message_batch::StreamMessageBatch::StreamChunk(v) => {
12683 struct_ser.serialize_field("streamChunk", v)?;
12684 }
12685 stream_message_batch::StreamMessageBatch::BarrierBatch(v) => {
12686 struct_ser.serialize_field("barrierBatch", v)?;
12687 }
12688 stream_message_batch::StreamMessageBatch::Watermark(v) => {
12689 struct_ser.serialize_field("watermark", v)?;
12690 }
12691 }
12692 }
12693 struct_ser.end()
12694 }
12695}
12696impl<'de> serde::Deserialize<'de> for StreamMessageBatch {
12697 #[allow(deprecated)]
12698 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12699 where
12700 D: serde::Deserializer<'de>,
12701 {
12702 const FIELDS: &[&str] = &[
12703 "stream_chunk",
12704 "streamChunk",
12705 "barrier_batch",
12706 "barrierBatch",
12707 "watermark",
12708 ];
12709
12710 #[allow(clippy::enum_variant_names)]
12711 enum GeneratedField {
12712 StreamChunk,
12713 BarrierBatch,
12714 Watermark,
12715 }
12716 impl<'de> serde::Deserialize<'de> for GeneratedField {
12717 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12718 where
12719 D: serde::Deserializer<'de>,
12720 {
12721 struct GeneratedVisitor;
12722
12723 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12724 type Value = GeneratedField;
12725
12726 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12727 write!(formatter, "expected one of: {:?}", &FIELDS)
12728 }
12729
12730 #[allow(unused_variables)]
12731 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12732 where
12733 E: serde::de::Error,
12734 {
12735 match value {
12736 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
12737 "barrierBatch" | "barrier_batch" => Ok(GeneratedField::BarrierBatch),
12738 "watermark" => Ok(GeneratedField::Watermark),
12739 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12740 }
12741 }
12742 }
12743 deserializer.deserialize_identifier(GeneratedVisitor)
12744 }
12745 }
12746 struct GeneratedVisitor;
12747 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12748 type Value = StreamMessageBatch;
12749
12750 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12751 formatter.write_str("struct stream_plan.StreamMessageBatch")
12752 }
12753
12754 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessageBatch, V::Error>
12755 where
12756 V: serde::de::MapAccess<'de>,
12757 {
12758 let mut stream_message_batch__ = None;
12759 while let Some(k) = map_.next_key()? {
12760 match k {
12761 GeneratedField::StreamChunk => {
12762 if stream_message_batch__.is_some() {
12763 return Err(serde::de::Error::duplicate_field("streamChunk"));
12764 }
12765 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::StreamChunk)
12766;
12767 }
12768 GeneratedField::BarrierBatch => {
12769 if stream_message_batch__.is_some() {
12770 return Err(serde::de::Error::duplicate_field("barrierBatch"));
12771 }
12772 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::BarrierBatch)
12773;
12774 }
12775 GeneratedField::Watermark => {
12776 if stream_message_batch__.is_some() {
12777 return Err(serde::de::Error::duplicate_field("watermark"));
12778 }
12779 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::Watermark)
12780;
12781 }
12782 }
12783 }
12784 Ok(StreamMessageBatch {
12785 stream_message_batch: stream_message_batch__,
12786 })
12787 }
12788 }
12789 deserializer.deserialize_struct("stream_plan.StreamMessageBatch", FIELDS, GeneratedVisitor)
12790 }
12791}
12792impl serde::Serialize for stream_message_batch::BarrierBatch {
12793 #[allow(deprecated)]
12794 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12795 where
12796 S: serde::Serializer,
12797 {
12798 use serde::ser::SerializeStruct;
12799 let mut len = 0;
12800 if !self.barriers.is_empty() {
12801 len += 1;
12802 }
12803 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", len)?;
12804 if !self.barriers.is_empty() {
12805 struct_ser.serialize_field("barriers", &self.barriers)?;
12806 }
12807 struct_ser.end()
12808 }
12809}
12810impl<'de> serde::Deserialize<'de> for stream_message_batch::BarrierBatch {
12811 #[allow(deprecated)]
12812 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12813 where
12814 D: serde::Deserializer<'de>,
12815 {
12816 const FIELDS: &[&str] = &[
12817 "barriers",
12818 ];
12819
12820 #[allow(clippy::enum_variant_names)]
12821 enum GeneratedField {
12822 Barriers,
12823 }
12824 impl<'de> serde::Deserialize<'de> for GeneratedField {
12825 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12826 where
12827 D: serde::Deserializer<'de>,
12828 {
12829 struct GeneratedVisitor;
12830
12831 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12832 type Value = GeneratedField;
12833
12834 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12835 write!(formatter, "expected one of: {:?}", &FIELDS)
12836 }
12837
12838 #[allow(unused_variables)]
12839 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12840 where
12841 E: serde::de::Error,
12842 {
12843 match value {
12844 "barriers" => Ok(GeneratedField::Barriers),
12845 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12846 }
12847 }
12848 }
12849 deserializer.deserialize_identifier(GeneratedVisitor)
12850 }
12851 }
12852 struct GeneratedVisitor;
12853 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12854 type Value = stream_message_batch::BarrierBatch;
12855
12856 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12857 formatter.write_str("struct stream_plan.StreamMessageBatch.BarrierBatch")
12858 }
12859
12860 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_message_batch::BarrierBatch, V::Error>
12861 where
12862 V: serde::de::MapAccess<'de>,
12863 {
12864 let mut barriers__ = None;
12865 while let Some(k) = map_.next_key()? {
12866 match k {
12867 GeneratedField::Barriers => {
12868 if barriers__.is_some() {
12869 return Err(serde::de::Error::duplicate_field("barriers"));
12870 }
12871 barriers__ = Some(map_.next_value()?);
12872 }
12873 }
12874 }
12875 Ok(stream_message_batch::BarrierBatch {
12876 barriers: barriers__.unwrap_or_default(),
12877 })
12878 }
12879 }
12880 deserializer.deserialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", FIELDS, GeneratedVisitor)
12881 }
12882}
12883impl serde::Serialize for StreamNode {
12884 #[allow(deprecated)]
12885 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12886 where
12887 S: serde::Serializer,
12888 {
12889 use serde::ser::SerializeStruct;
12890 let mut len = 0;
12891 if self.operator_id != 0 {
12892 len += 1;
12893 }
12894 if !self.input.is_empty() {
12895 len += 1;
12896 }
12897 if !self.stream_key.is_empty() {
12898 len += 1;
12899 }
12900 if self.stream_kind != 0 {
12901 len += 1;
12902 }
12903 if !self.identity.is_empty() {
12904 len += 1;
12905 }
12906 if !self.fields.is_empty() {
12907 len += 1;
12908 }
12909 if self.node_body.is_some() {
12910 len += 1;
12911 }
12912 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamNode", len)?;
12913 if self.operator_id != 0 {
12914 #[allow(clippy::needless_borrow)]
12915 #[allow(clippy::needless_borrows_for_generic_args)]
12916 struct_ser.serialize_field("operatorId", ToString::to_string(&self.operator_id).as_str())?;
12917 }
12918 if !self.input.is_empty() {
12919 struct_ser.serialize_field("input", &self.input)?;
12920 }
12921 if !self.stream_key.is_empty() {
12922 struct_ser.serialize_field("streamKey", &self.stream_key)?;
12923 }
12924 if self.stream_kind != 0 {
12925 let v = stream_node::StreamKind::try_from(self.stream_kind)
12926 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_kind)))?;
12927 struct_ser.serialize_field("streamKind", &v)?;
12928 }
12929 if !self.identity.is_empty() {
12930 struct_ser.serialize_field("identity", &self.identity)?;
12931 }
12932 if !self.fields.is_empty() {
12933 struct_ser.serialize_field("fields", &self.fields)?;
12934 }
12935 if let Some(v) = self.node_body.as_ref() {
12936 match v {
12937 stream_node::NodeBody::Source(v) => {
12938 struct_ser.serialize_field("source", v)?;
12939 }
12940 stream_node::NodeBody::Project(v) => {
12941 struct_ser.serialize_field("project", v)?;
12942 }
12943 stream_node::NodeBody::Filter(v) => {
12944 struct_ser.serialize_field("filter", v)?;
12945 }
12946 stream_node::NodeBody::Materialize(v) => {
12947 struct_ser.serialize_field("materialize", v)?;
12948 }
12949 stream_node::NodeBody::StatelessSimpleAgg(v) => {
12950 struct_ser.serialize_field("statelessSimpleAgg", v)?;
12951 }
12952 stream_node::NodeBody::SimpleAgg(v) => {
12953 struct_ser.serialize_field("simpleAgg", v)?;
12954 }
12955 stream_node::NodeBody::HashAgg(v) => {
12956 struct_ser.serialize_field("hashAgg", v)?;
12957 }
12958 stream_node::NodeBody::AppendOnlyTopN(v) => {
12959 struct_ser.serialize_field("appendOnlyTopN", v)?;
12960 }
12961 stream_node::NodeBody::HashJoin(v) => {
12962 struct_ser.serialize_field("hashJoin", v)?;
12963 }
12964 stream_node::NodeBody::TopN(v) => {
12965 struct_ser.serialize_field("topN", v)?;
12966 }
12967 stream_node::NodeBody::HopWindow(v) => {
12968 struct_ser.serialize_field("hopWindow", v)?;
12969 }
12970 stream_node::NodeBody::Merge(v) => {
12971 struct_ser.serialize_field("merge", v)?;
12972 }
12973 stream_node::NodeBody::Exchange(v) => {
12974 struct_ser.serialize_field("exchange", v)?;
12975 }
12976 stream_node::NodeBody::StreamScan(v) => {
12977 struct_ser.serialize_field("streamScan", v)?;
12978 }
12979 stream_node::NodeBody::BatchPlan(v) => {
12980 struct_ser.serialize_field("batchPlan", v)?;
12981 }
12982 stream_node::NodeBody::Lookup(v) => {
12983 struct_ser.serialize_field("lookup", v)?;
12984 }
12985 stream_node::NodeBody::Arrange(v) => {
12986 struct_ser.serialize_field("arrange", v)?;
12987 }
12988 stream_node::NodeBody::LookupUnion(v) => {
12989 struct_ser.serialize_field("lookupUnion", v)?;
12990 }
12991 stream_node::NodeBody::Union(v) => {
12992 struct_ser.serialize_field("union", v)?;
12993 }
12994 stream_node::NodeBody::DeltaIndexJoin(v) => {
12995 struct_ser.serialize_field("deltaIndexJoin", v)?;
12996 }
12997 stream_node::NodeBody::Sink(v) => {
12998 struct_ser.serialize_field("sink", v)?;
12999 }
13000 stream_node::NodeBody::Expand(v) => {
13001 struct_ser.serialize_field("expand", v)?;
13002 }
13003 stream_node::NodeBody::DynamicFilter(v) => {
13004 struct_ser.serialize_field("dynamicFilter", v)?;
13005 }
13006 stream_node::NodeBody::ProjectSet(v) => {
13007 struct_ser.serialize_field("projectSet", v)?;
13008 }
13009 stream_node::NodeBody::GroupTopN(v) => {
13010 struct_ser.serialize_field("groupTopN", v)?;
13011 }
13012 stream_node::NodeBody::Sort(v) => {
13013 struct_ser.serialize_field("sort", v)?;
13014 }
13015 stream_node::NodeBody::WatermarkFilter(v) => {
13016 struct_ser.serialize_field("watermarkFilter", v)?;
13017 }
13018 stream_node::NodeBody::Dml(v) => {
13019 struct_ser.serialize_field("dml", v)?;
13020 }
13021 stream_node::NodeBody::RowIdGen(v) => {
13022 struct_ser.serialize_field("rowIdGen", v)?;
13023 }
13024 stream_node::NodeBody::Now(v) => {
13025 struct_ser.serialize_field("now", v)?;
13026 }
13027 stream_node::NodeBody::AppendOnlyGroupTopN(v) => {
13028 struct_ser.serialize_field("appendOnlyGroupTopN", v)?;
13029 }
13030 stream_node::NodeBody::TemporalJoin(v) => {
13031 struct_ser.serialize_field("temporalJoin", v)?;
13032 }
13033 stream_node::NodeBody::BarrierRecv(v) => {
13034 struct_ser.serialize_field("barrierRecv", v)?;
13035 }
13036 stream_node::NodeBody::Values(v) => {
13037 struct_ser.serialize_field("values", v)?;
13038 }
13039 stream_node::NodeBody::AppendOnlyDedup(v) => {
13040 struct_ser.serialize_field("appendOnlyDedup", v)?;
13041 }
13042 stream_node::NodeBody::NoOp(v) => {
13043 struct_ser.serialize_field("noOp", v)?;
13044 }
13045 stream_node::NodeBody::EowcOverWindow(v) => {
13046 struct_ser.serialize_field("eowcOverWindow", v)?;
13047 }
13048 stream_node::NodeBody::OverWindow(v) => {
13049 struct_ser.serialize_field("overWindow", v)?;
13050 }
13051 stream_node::NodeBody::StreamFsFetch(v) => {
13052 struct_ser.serialize_field("streamFsFetch", v)?;
13053 }
13054 stream_node::NodeBody::StreamCdcScan(v) => {
13055 struct_ser.serialize_field("streamCdcScan", v)?;
13056 }
13057 stream_node::NodeBody::CdcFilter(v) => {
13058 struct_ser.serialize_field("cdcFilter", v)?;
13059 }
13060 stream_node::NodeBody::SourceBackfill(v) => {
13061 struct_ser.serialize_field("sourceBackfill", v)?;
13062 }
13063 stream_node::NodeBody::Changelog(v) => {
13064 struct_ser.serialize_field("changelog", v)?;
13065 }
13066 stream_node::NodeBody::LocalApproxPercentile(v) => {
13067 struct_ser.serialize_field("localApproxPercentile", v)?;
13068 }
13069 stream_node::NodeBody::GlobalApproxPercentile(v) => {
13070 struct_ser.serialize_field("globalApproxPercentile", v)?;
13071 }
13072 stream_node::NodeBody::RowMerge(v) => {
13073 struct_ser.serialize_field("rowMerge", v)?;
13074 }
13075 stream_node::NodeBody::AsOfJoin(v) => {
13076 struct_ser.serialize_field("asOfJoin", v)?;
13077 }
13078 stream_node::NodeBody::SyncLogStore(v) => {
13079 struct_ser.serialize_field("syncLogStore", v)?;
13080 }
13081 stream_node::NodeBody::MaterializedExprs(v) => {
13082 struct_ser.serialize_field("materializedExprs", v)?;
13083 }
13084 stream_node::NodeBody::VectorIndexWrite(v) => {
13085 struct_ser.serialize_field("vectorIndexWrite", v)?;
13086 }
13087 stream_node::NodeBody::UpstreamSinkUnion(v) => {
13088 struct_ser.serialize_field("upstreamSinkUnion", v)?;
13089 }
13090 stream_node::NodeBody::LocalityProvider(v) => {
13091 struct_ser.serialize_field("localityProvider", v)?;
13092 }
13093 stream_node::NodeBody::EowcGapFill(v) => {
13094 struct_ser.serialize_field("eowcGapFill", v)?;
13095 }
13096 stream_node::NodeBody::GapFill(v) => {
13097 struct_ser.serialize_field("gapFill", v)?;
13098 }
13099 stream_node::NodeBody::VectorIndexLookupJoin(v) => {
13100 struct_ser.serialize_field("vectorIndexLookupJoin", v)?;
13101 }
13102 }
13103 }
13104 struct_ser.end()
13105 }
13106}
13107impl<'de> serde::Deserialize<'de> for StreamNode {
13108 #[allow(deprecated)]
13109 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13110 where
13111 D: serde::Deserializer<'de>,
13112 {
13113 const FIELDS: &[&str] = &[
13114 "operator_id",
13115 "operatorId",
13116 "input",
13117 "stream_key",
13118 "streamKey",
13119 "stream_kind",
13120 "streamKind",
13121 "identity",
13122 "fields",
13123 "source",
13124 "project",
13125 "filter",
13126 "materialize",
13127 "stateless_simple_agg",
13128 "statelessSimpleAgg",
13129 "simple_agg",
13130 "simpleAgg",
13131 "hash_agg",
13132 "hashAgg",
13133 "append_only_top_n",
13134 "appendOnlyTopN",
13135 "hash_join",
13136 "hashJoin",
13137 "top_n",
13138 "topN",
13139 "hop_window",
13140 "hopWindow",
13141 "merge",
13142 "exchange",
13143 "stream_scan",
13144 "streamScan",
13145 "batch_plan",
13146 "batchPlan",
13147 "lookup",
13148 "arrange",
13149 "lookup_union",
13150 "lookupUnion",
13151 "union",
13152 "delta_index_join",
13153 "deltaIndexJoin",
13154 "sink",
13155 "expand",
13156 "dynamic_filter",
13157 "dynamicFilter",
13158 "project_set",
13159 "projectSet",
13160 "group_top_n",
13161 "groupTopN",
13162 "sort",
13163 "watermark_filter",
13164 "watermarkFilter",
13165 "dml",
13166 "row_id_gen",
13167 "rowIdGen",
13168 "now",
13169 "append_only_group_top_n",
13170 "appendOnlyGroupTopN",
13171 "temporal_join",
13172 "temporalJoin",
13173 "barrier_recv",
13174 "barrierRecv",
13175 "values",
13176 "append_only_dedup",
13177 "appendOnlyDedup",
13178 "no_op",
13179 "noOp",
13180 "eowc_over_window",
13181 "eowcOverWindow",
13182 "over_window",
13183 "overWindow",
13184 "stream_fs_fetch",
13185 "streamFsFetch",
13186 "stream_cdc_scan",
13187 "streamCdcScan",
13188 "cdc_filter",
13189 "cdcFilter",
13190 "source_backfill",
13191 "sourceBackfill",
13192 "changelog",
13193 "local_approx_percentile",
13194 "localApproxPercentile",
13195 "global_approx_percentile",
13196 "globalApproxPercentile",
13197 "row_merge",
13198 "rowMerge",
13199 "as_of_join",
13200 "asOfJoin",
13201 "sync_log_store",
13202 "syncLogStore",
13203 "materialized_exprs",
13204 "materializedExprs",
13205 "vector_index_write",
13206 "vectorIndexWrite",
13207 "upstream_sink_union",
13208 "upstreamSinkUnion",
13209 "locality_provider",
13210 "localityProvider",
13211 "eowc_gap_fill",
13212 "eowcGapFill",
13213 "gap_fill",
13214 "gapFill",
13215 "vector_index_lookup_join",
13216 "vectorIndexLookupJoin",
13217 ];
13218
13219 #[allow(clippy::enum_variant_names)]
13220 enum GeneratedField {
13221 OperatorId,
13222 Input,
13223 StreamKey,
13224 StreamKind,
13225 Identity,
13226 Fields,
13227 Source,
13228 Project,
13229 Filter,
13230 Materialize,
13231 StatelessSimpleAgg,
13232 SimpleAgg,
13233 HashAgg,
13234 AppendOnlyTopN,
13235 HashJoin,
13236 TopN,
13237 HopWindow,
13238 Merge,
13239 Exchange,
13240 StreamScan,
13241 BatchPlan,
13242 Lookup,
13243 Arrange,
13244 LookupUnion,
13245 Union,
13246 DeltaIndexJoin,
13247 Sink,
13248 Expand,
13249 DynamicFilter,
13250 ProjectSet,
13251 GroupTopN,
13252 Sort,
13253 WatermarkFilter,
13254 Dml,
13255 RowIdGen,
13256 Now,
13257 AppendOnlyGroupTopN,
13258 TemporalJoin,
13259 BarrierRecv,
13260 Values,
13261 AppendOnlyDedup,
13262 NoOp,
13263 EowcOverWindow,
13264 OverWindow,
13265 StreamFsFetch,
13266 StreamCdcScan,
13267 CdcFilter,
13268 SourceBackfill,
13269 Changelog,
13270 LocalApproxPercentile,
13271 GlobalApproxPercentile,
13272 RowMerge,
13273 AsOfJoin,
13274 SyncLogStore,
13275 MaterializedExprs,
13276 VectorIndexWrite,
13277 UpstreamSinkUnion,
13278 LocalityProvider,
13279 EowcGapFill,
13280 GapFill,
13281 VectorIndexLookupJoin,
13282 }
13283 impl<'de> serde::Deserialize<'de> for GeneratedField {
13284 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13285 where
13286 D: serde::Deserializer<'de>,
13287 {
13288 struct GeneratedVisitor;
13289
13290 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13291 type Value = GeneratedField;
13292
13293 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13294 write!(formatter, "expected one of: {:?}", &FIELDS)
13295 }
13296
13297 #[allow(unused_variables)]
13298 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13299 where
13300 E: serde::de::Error,
13301 {
13302 match value {
13303 "operatorId" | "operator_id" => Ok(GeneratedField::OperatorId),
13304 "input" => Ok(GeneratedField::Input),
13305 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
13306 "streamKind" | "stream_kind" => Ok(GeneratedField::StreamKind),
13307 "identity" => Ok(GeneratedField::Identity),
13308 "fields" => Ok(GeneratedField::Fields),
13309 "source" => Ok(GeneratedField::Source),
13310 "project" => Ok(GeneratedField::Project),
13311 "filter" => Ok(GeneratedField::Filter),
13312 "materialize" => Ok(GeneratedField::Materialize),
13313 "statelessSimpleAgg" | "stateless_simple_agg" => Ok(GeneratedField::StatelessSimpleAgg),
13314 "simpleAgg" | "simple_agg" => Ok(GeneratedField::SimpleAgg),
13315 "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
13316 "appendOnlyTopN" | "append_only_top_n" => Ok(GeneratedField::AppendOnlyTopN),
13317 "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
13318 "topN" | "top_n" => Ok(GeneratedField::TopN),
13319 "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
13320 "merge" => Ok(GeneratedField::Merge),
13321 "exchange" => Ok(GeneratedField::Exchange),
13322 "streamScan" | "stream_scan" => Ok(GeneratedField::StreamScan),
13323 "batchPlan" | "batch_plan" => Ok(GeneratedField::BatchPlan),
13324 "lookup" => Ok(GeneratedField::Lookup),
13325 "arrange" => Ok(GeneratedField::Arrange),
13326 "lookupUnion" | "lookup_union" => Ok(GeneratedField::LookupUnion),
13327 "union" => Ok(GeneratedField::Union),
13328 "deltaIndexJoin" | "delta_index_join" => Ok(GeneratedField::DeltaIndexJoin),
13329 "sink" => Ok(GeneratedField::Sink),
13330 "expand" => Ok(GeneratedField::Expand),
13331 "dynamicFilter" | "dynamic_filter" => Ok(GeneratedField::DynamicFilter),
13332 "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
13333 "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
13334 "sort" => Ok(GeneratedField::Sort),
13335 "watermarkFilter" | "watermark_filter" => Ok(GeneratedField::WatermarkFilter),
13336 "dml" => Ok(GeneratedField::Dml),
13337 "rowIdGen" | "row_id_gen" => Ok(GeneratedField::RowIdGen),
13338 "now" => Ok(GeneratedField::Now),
13339 "appendOnlyGroupTopN" | "append_only_group_top_n" => Ok(GeneratedField::AppendOnlyGroupTopN),
13340 "temporalJoin" | "temporal_join" => Ok(GeneratedField::TemporalJoin),
13341 "barrierRecv" | "barrier_recv" => Ok(GeneratedField::BarrierRecv),
13342 "values" => Ok(GeneratedField::Values),
13343 "appendOnlyDedup" | "append_only_dedup" => Ok(GeneratedField::AppendOnlyDedup),
13344 "noOp" | "no_op" => Ok(GeneratedField::NoOp),
13345 "eowcOverWindow" | "eowc_over_window" => Ok(GeneratedField::EowcOverWindow),
13346 "overWindow" | "over_window" => Ok(GeneratedField::OverWindow),
13347 "streamFsFetch" | "stream_fs_fetch" => Ok(GeneratedField::StreamFsFetch),
13348 "streamCdcScan" | "stream_cdc_scan" => Ok(GeneratedField::StreamCdcScan),
13349 "cdcFilter" | "cdc_filter" => Ok(GeneratedField::CdcFilter),
13350 "sourceBackfill" | "source_backfill" => Ok(GeneratedField::SourceBackfill),
13351 "changelog" => Ok(GeneratedField::Changelog),
13352 "localApproxPercentile" | "local_approx_percentile" => Ok(GeneratedField::LocalApproxPercentile),
13353 "globalApproxPercentile" | "global_approx_percentile" => Ok(GeneratedField::GlobalApproxPercentile),
13354 "rowMerge" | "row_merge" => Ok(GeneratedField::RowMerge),
13355 "asOfJoin" | "as_of_join" => Ok(GeneratedField::AsOfJoin),
13356 "syncLogStore" | "sync_log_store" => Ok(GeneratedField::SyncLogStore),
13357 "materializedExprs" | "materialized_exprs" => Ok(GeneratedField::MaterializedExprs),
13358 "vectorIndexWrite" | "vector_index_write" => Ok(GeneratedField::VectorIndexWrite),
13359 "upstreamSinkUnion" | "upstream_sink_union" => Ok(GeneratedField::UpstreamSinkUnion),
13360 "localityProvider" | "locality_provider" => Ok(GeneratedField::LocalityProvider),
13361 "eowcGapFill" | "eowc_gap_fill" => Ok(GeneratedField::EowcGapFill),
13362 "gapFill" | "gap_fill" => Ok(GeneratedField::GapFill),
13363 "vectorIndexLookupJoin" | "vector_index_lookup_join" => Ok(GeneratedField::VectorIndexLookupJoin),
13364 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13365 }
13366 }
13367 }
13368 deserializer.deserialize_identifier(GeneratedVisitor)
13369 }
13370 }
13371 struct GeneratedVisitor;
13372 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13373 type Value = StreamNode;
13374
13375 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13376 formatter.write_str("struct stream_plan.StreamNode")
13377 }
13378
13379 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamNode, V::Error>
13380 where
13381 V: serde::de::MapAccess<'de>,
13382 {
13383 let mut operator_id__ = None;
13384 let mut input__ = None;
13385 let mut stream_key__ = None;
13386 let mut stream_kind__ = None;
13387 let mut identity__ = None;
13388 let mut fields__ = None;
13389 let mut node_body__ = None;
13390 while let Some(k) = map_.next_key()? {
13391 match k {
13392 GeneratedField::OperatorId => {
13393 if operator_id__.is_some() {
13394 return Err(serde::de::Error::duplicate_field("operatorId"));
13395 }
13396 operator_id__ =
13397 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13398 ;
13399 }
13400 GeneratedField::Input => {
13401 if input__.is_some() {
13402 return Err(serde::de::Error::duplicate_field("input"));
13403 }
13404 input__ = Some(map_.next_value()?);
13405 }
13406 GeneratedField::StreamKey => {
13407 if stream_key__.is_some() {
13408 return Err(serde::de::Error::duplicate_field("streamKey"));
13409 }
13410 stream_key__ =
13411 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13412 .into_iter().map(|x| x.0).collect())
13413 ;
13414 }
13415 GeneratedField::StreamKind => {
13416 if stream_kind__.is_some() {
13417 return Err(serde::de::Error::duplicate_field("streamKind"));
13418 }
13419 stream_kind__ = Some(map_.next_value::<stream_node::StreamKind>()? as i32);
13420 }
13421 GeneratedField::Identity => {
13422 if identity__.is_some() {
13423 return Err(serde::de::Error::duplicate_field("identity"));
13424 }
13425 identity__ = Some(map_.next_value()?);
13426 }
13427 GeneratedField::Fields => {
13428 if fields__.is_some() {
13429 return Err(serde::de::Error::duplicate_field("fields"));
13430 }
13431 fields__ = Some(map_.next_value()?);
13432 }
13433 GeneratedField::Source => {
13434 if node_body__.is_some() {
13435 return Err(serde::de::Error::duplicate_field("source"));
13436 }
13437 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Source)
13438;
13439 }
13440 GeneratedField::Project => {
13441 if node_body__.is_some() {
13442 return Err(serde::de::Error::duplicate_field("project"));
13443 }
13444 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Project)
13445;
13446 }
13447 GeneratedField::Filter => {
13448 if node_body__.is_some() {
13449 return Err(serde::de::Error::duplicate_field("filter"));
13450 }
13451 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Filter)
13452;
13453 }
13454 GeneratedField::Materialize => {
13455 if node_body__.is_some() {
13456 return Err(serde::de::Error::duplicate_field("materialize"));
13457 }
13458 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Materialize)
13459;
13460 }
13461 GeneratedField::StatelessSimpleAgg => {
13462 if node_body__.is_some() {
13463 return Err(serde::de::Error::duplicate_field("statelessSimpleAgg"));
13464 }
13465 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StatelessSimpleAgg)
13466;
13467 }
13468 GeneratedField::SimpleAgg => {
13469 if node_body__.is_some() {
13470 return Err(serde::de::Error::duplicate_field("simpleAgg"));
13471 }
13472 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SimpleAgg)
13473;
13474 }
13475 GeneratedField::HashAgg => {
13476 if node_body__.is_some() {
13477 return Err(serde::de::Error::duplicate_field("hashAgg"));
13478 }
13479 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashAgg)
13480;
13481 }
13482 GeneratedField::AppendOnlyTopN => {
13483 if node_body__.is_some() {
13484 return Err(serde::de::Error::duplicate_field("appendOnlyTopN"));
13485 }
13486 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyTopN)
13487;
13488 }
13489 GeneratedField::HashJoin => {
13490 if node_body__.is_some() {
13491 return Err(serde::de::Error::duplicate_field("hashJoin"));
13492 }
13493 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashJoin)
13494;
13495 }
13496 GeneratedField::TopN => {
13497 if node_body__.is_some() {
13498 return Err(serde::de::Error::duplicate_field("topN"));
13499 }
13500 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TopN)
13501;
13502 }
13503 GeneratedField::HopWindow => {
13504 if node_body__.is_some() {
13505 return Err(serde::de::Error::duplicate_field("hopWindow"));
13506 }
13507 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HopWindow)
13508;
13509 }
13510 GeneratedField::Merge => {
13511 if node_body__.is_some() {
13512 return Err(serde::de::Error::duplicate_field("merge"));
13513 }
13514 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Merge)
13515;
13516 }
13517 GeneratedField::Exchange => {
13518 if node_body__.is_some() {
13519 return Err(serde::de::Error::duplicate_field("exchange"));
13520 }
13521 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Exchange)
13522;
13523 }
13524 GeneratedField::StreamScan => {
13525 if node_body__.is_some() {
13526 return Err(serde::de::Error::duplicate_field("streamScan"));
13527 }
13528 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamScan)
13529;
13530 }
13531 GeneratedField::BatchPlan => {
13532 if node_body__.is_some() {
13533 return Err(serde::de::Error::duplicate_field("batchPlan"));
13534 }
13535 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BatchPlan)
13536;
13537 }
13538 GeneratedField::Lookup => {
13539 if node_body__.is_some() {
13540 return Err(serde::de::Error::duplicate_field("lookup"));
13541 }
13542 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Lookup)
13543;
13544 }
13545 GeneratedField::Arrange => {
13546 if node_body__.is_some() {
13547 return Err(serde::de::Error::duplicate_field("arrange"));
13548 }
13549 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Arrange)
13550;
13551 }
13552 GeneratedField::LookupUnion => {
13553 if node_body__.is_some() {
13554 return Err(serde::de::Error::duplicate_field("lookupUnion"));
13555 }
13556 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LookupUnion)
13557;
13558 }
13559 GeneratedField::Union => {
13560 if node_body__.is_some() {
13561 return Err(serde::de::Error::duplicate_field("union"));
13562 }
13563 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Union)
13564;
13565 }
13566 GeneratedField::DeltaIndexJoin => {
13567 if node_body__.is_some() {
13568 return Err(serde::de::Error::duplicate_field("deltaIndexJoin"));
13569 }
13570 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DeltaIndexJoin)
13571;
13572 }
13573 GeneratedField::Sink => {
13574 if node_body__.is_some() {
13575 return Err(serde::de::Error::duplicate_field("sink"));
13576 }
13577 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sink)
13578;
13579 }
13580 GeneratedField::Expand => {
13581 if node_body__.is_some() {
13582 return Err(serde::de::Error::duplicate_field("expand"));
13583 }
13584 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Expand)
13585;
13586 }
13587 GeneratedField::DynamicFilter => {
13588 if node_body__.is_some() {
13589 return Err(serde::de::Error::duplicate_field("dynamicFilter"));
13590 }
13591 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DynamicFilter)
13592;
13593 }
13594 GeneratedField::ProjectSet => {
13595 if node_body__.is_some() {
13596 return Err(serde::de::Error::duplicate_field("projectSet"));
13597 }
13598 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::ProjectSet)
13599;
13600 }
13601 GeneratedField::GroupTopN => {
13602 if node_body__.is_some() {
13603 return Err(serde::de::Error::duplicate_field("groupTopN"));
13604 }
13605 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GroupTopN)
13606;
13607 }
13608 GeneratedField::Sort => {
13609 if node_body__.is_some() {
13610 return Err(serde::de::Error::duplicate_field("sort"));
13611 }
13612 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sort)
13613;
13614 }
13615 GeneratedField::WatermarkFilter => {
13616 if node_body__.is_some() {
13617 return Err(serde::de::Error::duplicate_field("watermarkFilter"));
13618 }
13619 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::WatermarkFilter)
13620;
13621 }
13622 GeneratedField::Dml => {
13623 if node_body__.is_some() {
13624 return Err(serde::de::Error::duplicate_field("dml"));
13625 }
13626 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Dml)
13627;
13628 }
13629 GeneratedField::RowIdGen => {
13630 if node_body__.is_some() {
13631 return Err(serde::de::Error::duplicate_field("rowIdGen"));
13632 }
13633 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowIdGen)
13634;
13635 }
13636 GeneratedField::Now => {
13637 if node_body__.is_some() {
13638 return Err(serde::de::Error::duplicate_field("now"));
13639 }
13640 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Now)
13641;
13642 }
13643 GeneratedField::AppendOnlyGroupTopN => {
13644 if node_body__.is_some() {
13645 return Err(serde::de::Error::duplicate_field("appendOnlyGroupTopN"));
13646 }
13647 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyGroupTopN)
13648;
13649 }
13650 GeneratedField::TemporalJoin => {
13651 if node_body__.is_some() {
13652 return Err(serde::de::Error::duplicate_field("temporalJoin"));
13653 }
13654 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TemporalJoin)
13655;
13656 }
13657 GeneratedField::BarrierRecv => {
13658 if node_body__.is_some() {
13659 return Err(serde::de::Error::duplicate_field("barrierRecv"));
13660 }
13661 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BarrierRecv)
13662;
13663 }
13664 GeneratedField::Values => {
13665 if node_body__.is_some() {
13666 return Err(serde::de::Error::duplicate_field("values"));
13667 }
13668 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Values)
13669;
13670 }
13671 GeneratedField::AppendOnlyDedup => {
13672 if node_body__.is_some() {
13673 return Err(serde::de::Error::duplicate_field("appendOnlyDedup"));
13674 }
13675 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyDedup)
13676;
13677 }
13678 GeneratedField::NoOp => {
13679 if node_body__.is_some() {
13680 return Err(serde::de::Error::duplicate_field("noOp"));
13681 }
13682 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::NoOp)
13683;
13684 }
13685 GeneratedField::EowcOverWindow => {
13686 if node_body__.is_some() {
13687 return Err(serde::de::Error::duplicate_field("eowcOverWindow"));
13688 }
13689 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcOverWindow)
13690;
13691 }
13692 GeneratedField::OverWindow => {
13693 if node_body__.is_some() {
13694 return Err(serde::de::Error::duplicate_field("overWindow"));
13695 }
13696 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::OverWindow)
13697;
13698 }
13699 GeneratedField::StreamFsFetch => {
13700 if node_body__.is_some() {
13701 return Err(serde::de::Error::duplicate_field("streamFsFetch"));
13702 }
13703 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamFsFetch)
13704;
13705 }
13706 GeneratedField::StreamCdcScan => {
13707 if node_body__.is_some() {
13708 return Err(serde::de::Error::duplicate_field("streamCdcScan"));
13709 }
13710 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamCdcScan)
13711;
13712 }
13713 GeneratedField::CdcFilter => {
13714 if node_body__.is_some() {
13715 return Err(serde::de::Error::duplicate_field("cdcFilter"));
13716 }
13717 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CdcFilter)
13718;
13719 }
13720 GeneratedField::SourceBackfill => {
13721 if node_body__.is_some() {
13722 return Err(serde::de::Error::duplicate_field("sourceBackfill"));
13723 }
13724 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SourceBackfill)
13725;
13726 }
13727 GeneratedField::Changelog => {
13728 if node_body__.is_some() {
13729 return Err(serde::de::Error::duplicate_field("changelog"));
13730 }
13731 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Changelog)
13732;
13733 }
13734 GeneratedField::LocalApproxPercentile => {
13735 if node_body__.is_some() {
13736 return Err(serde::de::Error::duplicate_field("localApproxPercentile"));
13737 }
13738 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalApproxPercentile)
13739;
13740 }
13741 GeneratedField::GlobalApproxPercentile => {
13742 if node_body__.is_some() {
13743 return Err(serde::de::Error::duplicate_field("globalApproxPercentile"));
13744 }
13745 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GlobalApproxPercentile)
13746;
13747 }
13748 GeneratedField::RowMerge => {
13749 if node_body__.is_some() {
13750 return Err(serde::de::Error::duplicate_field("rowMerge"));
13751 }
13752 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowMerge)
13753;
13754 }
13755 GeneratedField::AsOfJoin => {
13756 if node_body__.is_some() {
13757 return Err(serde::de::Error::duplicate_field("asOfJoin"));
13758 }
13759 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AsOfJoin)
13760;
13761 }
13762 GeneratedField::SyncLogStore => {
13763 if node_body__.is_some() {
13764 return Err(serde::de::Error::duplicate_field("syncLogStore"));
13765 }
13766 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SyncLogStore)
13767;
13768 }
13769 GeneratedField::MaterializedExprs => {
13770 if node_body__.is_some() {
13771 return Err(serde::de::Error::duplicate_field("materializedExprs"));
13772 }
13773 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MaterializedExprs)
13774;
13775 }
13776 GeneratedField::VectorIndexWrite => {
13777 if node_body__.is_some() {
13778 return Err(serde::de::Error::duplicate_field("vectorIndexWrite"));
13779 }
13780 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexWrite)
13781;
13782 }
13783 GeneratedField::UpstreamSinkUnion => {
13784 if node_body__.is_some() {
13785 return Err(serde::de::Error::duplicate_field("upstreamSinkUnion"));
13786 }
13787 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::UpstreamSinkUnion)
13788;
13789 }
13790 GeneratedField::LocalityProvider => {
13791 if node_body__.is_some() {
13792 return Err(serde::de::Error::duplicate_field("localityProvider"));
13793 }
13794 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalityProvider)
13795;
13796 }
13797 GeneratedField::EowcGapFill => {
13798 if node_body__.is_some() {
13799 return Err(serde::de::Error::duplicate_field("eowcGapFill"));
13800 }
13801 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcGapFill)
13802;
13803 }
13804 GeneratedField::GapFill => {
13805 if node_body__.is_some() {
13806 return Err(serde::de::Error::duplicate_field("gapFill"));
13807 }
13808 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GapFill)
13809;
13810 }
13811 GeneratedField::VectorIndexLookupJoin => {
13812 if node_body__.is_some() {
13813 return Err(serde::de::Error::duplicate_field("vectorIndexLookupJoin"));
13814 }
13815 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexLookupJoin)
13816;
13817 }
13818 }
13819 }
13820 Ok(StreamNode {
13821 operator_id: operator_id__.unwrap_or_default(),
13822 input: input__.unwrap_or_default(),
13823 stream_key: stream_key__.unwrap_or_default(),
13824 stream_kind: stream_kind__.unwrap_or_default(),
13825 identity: identity__.unwrap_or_default(),
13826 fields: fields__.unwrap_or_default(),
13827 node_body: node_body__,
13828 })
13829 }
13830 }
13831 deserializer.deserialize_struct("stream_plan.StreamNode", FIELDS, GeneratedVisitor)
13832 }
13833}
13834impl serde::Serialize for stream_node::StreamKind {
13835 #[allow(deprecated)]
13836 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13837 where
13838 S: serde::Serializer,
13839 {
13840 let variant = match self {
13841 Self::Retract => "STREAM_KIND_RETRACT",
13842 Self::AppendOnly => "STREAM_KIND_APPEND_ONLY",
13843 Self::Upsert => "STREAM_KIND_UPSERT",
13844 };
13845 serializer.serialize_str(variant)
13846 }
13847}
13848impl<'de> serde::Deserialize<'de> for stream_node::StreamKind {
13849 #[allow(deprecated)]
13850 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13851 where
13852 D: serde::Deserializer<'de>,
13853 {
13854 const FIELDS: &[&str] = &[
13855 "STREAM_KIND_RETRACT",
13856 "STREAM_KIND_APPEND_ONLY",
13857 "STREAM_KIND_UPSERT",
13858 ];
13859
13860 struct GeneratedVisitor;
13861
13862 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13863 type Value = stream_node::StreamKind;
13864
13865 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13866 write!(formatter, "expected one of: {:?}", &FIELDS)
13867 }
13868
13869 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13870 where
13871 E: serde::de::Error,
13872 {
13873 i32::try_from(v)
13874 .ok()
13875 .and_then(|x| x.try_into().ok())
13876 .ok_or_else(|| {
13877 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13878 })
13879 }
13880
13881 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13882 where
13883 E: serde::de::Error,
13884 {
13885 i32::try_from(v)
13886 .ok()
13887 .and_then(|x| x.try_into().ok())
13888 .ok_or_else(|| {
13889 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13890 })
13891 }
13892
13893 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13894 where
13895 E: serde::de::Error,
13896 {
13897 match value {
13898 "STREAM_KIND_RETRACT" => Ok(stream_node::StreamKind::Retract),
13899 "STREAM_KIND_APPEND_ONLY" => Ok(stream_node::StreamKind::AppendOnly),
13900 "STREAM_KIND_UPSERT" => Ok(stream_node::StreamKind::Upsert),
13901 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13902 }
13903 }
13904 }
13905 deserializer.deserialize_any(GeneratedVisitor)
13906 }
13907}
13908impl serde::Serialize for StreamScanNode {
13909 #[allow(deprecated)]
13910 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13911 where
13912 S: serde::Serializer,
13913 {
13914 use serde::ser::SerializeStruct;
13915 let mut len = 0;
13916 if self.table_id != 0 {
13917 len += 1;
13918 }
13919 if !self.upstream_column_ids.is_empty() {
13920 len += 1;
13921 }
13922 if !self.output_indices.is_empty() {
13923 len += 1;
13924 }
13925 if self.stream_scan_type != 0 {
13926 len += 1;
13927 }
13928 if self.state_table.is_some() {
13929 len += 1;
13930 }
13931 if self.table_desc.is_some() {
13932 len += 1;
13933 }
13934 if self.rate_limit.is_some() {
13935 len += 1;
13936 }
13937 if self.snapshot_read_barrier_interval != 0 {
13938 len += 1;
13939 }
13940 if self.arrangement_table.is_some() {
13941 len += 1;
13942 }
13943 if self.snapshot_backfill_epoch.is_some() {
13944 len += 1;
13945 }
13946 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamScanNode", len)?;
13947 if self.table_id != 0 {
13948 struct_ser.serialize_field("tableId", &self.table_id)?;
13949 }
13950 if !self.upstream_column_ids.is_empty() {
13951 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
13952 }
13953 if !self.output_indices.is_empty() {
13954 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
13955 }
13956 if self.stream_scan_type != 0 {
13957 let v = StreamScanType::try_from(self.stream_scan_type)
13958 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_scan_type)))?;
13959 struct_ser.serialize_field("streamScanType", &v)?;
13960 }
13961 if let Some(v) = self.state_table.as_ref() {
13962 struct_ser.serialize_field("stateTable", v)?;
13963 }
13964 if let Some(v) = self.table_desc.as_ref() {
13965 struct_ser.serialize_field("tableDesc", v)?;
13966 }
13967 if let Some(v) = self.rate_limit.as_ref() {
13968 struct_ser.serialize_field("rateLimit", v)?;
13969 }
13970 if self.snapshot_read_barrier_interval != 0 {
13971 struct_ser.serialize_field("snapshotReadBarrierInterval", &self.snapshot_read_barrier_interval)?;
13972 }
13973 if let Some(v) = self.arrangement_table.as_ref() {
13974 struct_ser.serialize_field("arrangementTable", v)?;
13975 }
13976 if let Some(v) = self.snapshot_backfill_epoch.as_ref() {
13977 #[allow(clippy::needless_borrow)]
13978 #[allow(clippy::needless_borrows_for_generic_args)]
13979 struct_ser.serialize_field("snapshotBackfillEpoch", ToString::to_string(&v).as_str())?;
13980 }
13981 struct_ser.end()
13982 }
13983}
13984impl<'de> serde::Deserialize<'de> for StreamScanNode {
13985 #[allow(deprecated)]
13986 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13987 where
13988 D: serde::Deserializer<'de>,
13989 {
13990 const FIELDS: &[&str] = &[
13991 "table_id",
13992 "tableId",
13993 "upstream_column_ids",
13994 "upstreamColumnIds",
13995 "output_indices",
13996 "outputIndices",
13997 "stream_scan_type",
13998 "streamScanType",
13999 "state_table",
14000 "stateTable",
14001 "table_desc",
14002 "tableDesc",
14003 "rate_limit",
14004 "rateLimit",
14005 "snapshot_read_barrier_interval",
14006 "snapshotReadBarrierInterval",
14007 "arrangement_table",
14008 "arrangementTable",
14009 "snapshot_backfill_epoch",
14010 "snapshotBackfillEpoch",
14011 ];
14012
14013 #[allow(clippy::enum_variant_names)]
14014 enum GeneratedField {
14015 TableId,
14016 UpstreamColumnIds,
14017 OutputIndices,
14018 StreamScanType,
14019 StateTable,
14020 TableDesc,
14021 RateLimit,
14022 SnapshotReadBarrierInterval,
14023 ArrangementTable,
14024 SnapshotBackfillEpoch,
14025 }
14026 impl<'de> serde::Deserialize<'de> for GeneratedField {
14027 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14028 where
14029 D: serde::Deserializer<'de>,
14030 {
14031 struct GeneratedVisitor;
14032
14033 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14034 type Value = GeneratedField;
14035
14036 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14037 write!(formatter, "expected one of: {:?}", &FIELDS)
14038 }
14039
14040 #[allow(unused_variables)]
14041 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14042 where
14043 E: serde::de::Error,
14044 {
14045 match value {
14046 "tableId" | "table_id" => Ok(GeneratedField::TableId),
14047 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
14048 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
14049 "streamScanType" | "stream_scan_type" => Ok(GeneratedField::StreamScanType),
14050 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
14051 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
14052 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
14053 "snapshotReadBarrierInterval" | "snapshot_read_barrier_interval" => Ok(GeneratedField::SnapshotReadBarrierInterval),
14054 "arrangementTable" | "arrangement_table" => Ok(GeneratedField::ArrangementTable),
14055 "snapshotBackfillEpoch" | "snapshot_backfill_epoch" => Ok(GeneratedField::SnapshotBackfillEpoch),
14056 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14057 }
14058 }
14059 }
14060 deserializer.deserialize_identifier(GeneratedVisitor)
14061 }
14062 }
14063 struct GeneratedVisitor;
14064 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14065 type Value = StreamScanNode;
14066
14067 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14068 formatter.write_str("struct stream_plan.StreamScanNode")
14069 }
14070
14071 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamScanNode, V::Error>
14072 where
14073 V: serde::de::MapAccess<'de>,
14074 {
14075 let mut table_id__ = None;
14076 let mut upstream_column_ids__ = None;
14077 let mut output_indices__ = None;
14078 let mut stream_scan_type__ = None;
14079 let mut state_table__ = None;
14080 let mut table_desc__ = None;
14081 let mut rate_limit__ = None;
14082 let mut snapshot_read_barrier_interval__ = None;
14083 let mut arrangement_table__ = None;
14084 let mut snapshot_backfill_epoch__ = None;
14085 while let Some(k) = map_.next_key()? {
14086 match k {
14087 GeneratedField::TableId => {
14088 if table_id__.is_some() {
14089 return Err(serde::de::Error::duplicate_field("tableId"));
14090 }
14091 table_id__ =
14092 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14093 ;
14094 }
14095 GeneratedField::UpstreamColumnIds => {
14096 if upstream_column_ids__.is_some() {
14097 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
14098 }
14099 upstream_column_ids__ =
14100 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14101 .into_iter().map(|x| x.0).collect())
14102 ;
14103 }
14104 GeneratedField::OutputIndices => {
14105 if output_indices__.is_some() {
14106 return Err(serde::de::Error::duplicate_field("outputIndices"));
14107 }
14108 output_indices__ =
14109 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14110 .into_iter().map(|x| x.0).collect())
14111 ;
14112 }
14113 GeneratedField::StreamScanType => {
14114 if stream_scan_type__.is_some() {
14115 return Err(serde::de::Error::duplicate_field("streamScanType"));
14116 }
14117 stream_scan_type__ = Some(map_.next_value::<StreamScanType>()? as i32);
14118 }
14119 GeneratedField::StateTable => {
14120 if state_table__.is_some() {
14121 return Err(serde::de::Error::duplicate_field("stateTable"));
14122 }
14123 state_table__ = map_.next_value()?;
14124 }
14125 GeneratedField::TableDesc => {
14126 if table_desc__.is_some() {
14127 return Err(serde::de::Error::duplicate_field("tableDesc"));
14128 }
14129 table_desc__ = map_.next_value()?;
14130 }
14131 GeneratedField::RateLimit => {
14132 if rate_limit__.is_some() {
14133 return Err(serde::de::Error::duplicate_field("rateLimit"));
14134 }
14135 rate_limit__ =
14136 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14137 ;
14138 }
14139 GeneratedField::SnapshotReadBarrierInterval => {
14140 if snapshot_read_barrier_interval__.is_some() {
14141 return Err(serde::de::Error::duplicate_field("snapshotReadBarrierInterval"));
14142 }
14143 snapshot_read_barrier_interval__ =
14144 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14145 ;
14146 }
14147 GeneratedField::ArrangementTable => {
14148 if arrangement_table__.is_some() {
14149 return Err(serde::de::Error::duplicate_field("arrangementTable"));
14150 }
14151 arrangement_table__ = map_.next_value()?;
14152 }
14153 GeneratedField::SnapshotBackfillEpoch => {
14154 if snapshot_backfill_epoch__.is_some() {
14155 return Err(serde::de::Error::duplicate_field("snapshotBackfillEpoch"));
14156 }
14157 snapshot_backfill_epoch__ =
14158 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14159 ;
14160 }
14161 }
14162 }
14163 Ok(StreamScanNode {
14164 table_id: table_id__.unwrap_or_default(),
14165 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
14166 output_indices: output_indices__.unwrap_or_default(),
14167 stream_scan_type: stream_scan_type__.unwrap_or_default(),
14168 state_table: state_table__,
14169 table_desc: table_desc__,
14170 rate_limit: rate_limit__,
14171 snapshot_read_barrier_interval: snapshot_read_barrier_interval__.unwrap_or_default(),
14172 arrangement_table: arrangement_table__,
14173 snapshot_backfill_epoch: snapshot_backfill_epoch__,
14174 })
14175 }
14176 }
14177 deserializer.deserialize_struct("stream_plan.StreamScanNode", FIELDS, GeneratedVisitor)
14178 }
14179}
14180impl serde::Serialize for StreamScanType {
14181 #[allow(deprecated)]
14182 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14183 where
14184 S: serde::Serializer,
14185 {
14186 let variant = match self {
14187 Self::Unspecified => "STREAM_SCAN_TYPE_UNSPECIFIED",
14188 Self::Chain => "STREAM_SCAN_TYPE_CHAIN",
14189 Self::Rearrange => "STREAM_SCAN_TYPE_REARRANGE",
14190 Self::Backfill => "STREAM_SCAN_TYPE_BACKFILL",
14191 Self::UpstreamOnly => "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
14192 Self::ArrangementBackfill => "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
14193 Self::SnapshotBackfill => "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
14194 Self::CrossDbSnapshotBackfill => "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
14195 };
14196 serializer.serialize_str(variant)
14197 }
14198}
14199impl<'de> serde::Deserialize<'de> for StreamScanType {
14200 #[allow(deprecated)]
14201 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14202 where
14203 D: serde::Deserializer<'de>,
14204 {
14205 const FIELDS: &[&str] = &[
14206 "STREAM_SCAN_TYPE_UNSPECIFIED",
14207 "STREAM_SCAN_TYPE_CHAIN",
14208 "STREAM_SCAN_TYPE_REARRANGE",
14209 "STREAM_SCAN_TYPE_BACKFILL",
14210 "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
14211 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
14212 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
14213 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
14214 ];
14215
14216 struct GeneratedVisitor;
14217
14218 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14219 type Value = StreamScanType;
14220
14221 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14222 write!(formatter, "expected one of: {:?}", &FIELDS)
14223 }
14224
14225 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14226 where
14227 E: serde::de::Error,
14228 {
14229 i32::try_from(v)
14230 .ok()
14231 .and_then(|x| x.try_into().ok())
14232 .ok_or_else(|| {
14233 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14234 })
14235 }
14236
14237 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14238 where
14239 E: serde::de::Error,
14240 {
14241 i32::try_from(v)
14242 .ok()
14243 .and_then(|x| x.try_into().ok())
14244 .ok_or_else(|| {
14245 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14246 })
14247 }
14248
14249 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14250 where
14251 E: serde::de::Error,
14252 {
14253 match value {
14254 "STREAM_SCAN_TYPE_UNSPECIFIED" => Ok(StreamScanType::Unspecified),
14255 "STREAM_SCAN_TYPE_CHAIN" => Ok(StreamScanType::Chain),
14256 "STREAM_SCAN_TYPE_REARRANGE" => Ok(StreamScanType::Rearrange),
14257 "STREAM_SCAN_TYPE_BACKFILL" => Ok(StreamScanType::Backfill),
14258 "STREAM_SCAN_TYPE_UPSTREAM_ONLY" => Ok(StreamScanType::UpstreamOnly),
14259 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL" => Ok(StreamScanType::ArrangementBackfill),
14260 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL" => Ok(StreamScanType::SnapshotBackfill),
14261 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL" => Ok(StreamScanType::CrossDbSnapshotBackfill),
14262 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14263 }
14264 }
14265 }
14266 deserializer.deserialize_any(GeneratedVisitor)
14267 }
14268}
14269impl serde::Serialize for StreamSource {
14270 #[allow(deprecated)]
14271 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14272 where
14273 S: serde::Serializer,
14274 {
14275 use serde::ser::SerializeStruct;
14276 let mut len = 0;
14277 if self.source_id != 0 {
14278 len += 1;
14279 }
14280 if self.state_table.is_some() {
14281 len += 1;
14282 }
14283 if self.row_id_index.is_some() {
14284 len += 1;
14285 }
14286 if !self.columns.is_empty() {
14287 len += 1;
14288 }
14289 if !self.with_properties.is_empty() {
14290 len += 1;
14291 }
14292 if self.info.is_some() {
14293 len += 1;
14294 }
14295 if !self.source_name.is_empty() {
14296 len += 1;
14297 }
14298 if self.rate_limit.is_some() {
14299 len += 1;
14300 }
14301 if !self.secret_refs.is_empty() {
14302 len += 1;
14303 }
14304 if self.downstream_columns.is_some() {
14305 len += 1;
14306 }
14307 if self.refresh_mode.is_some() {
14308 len += 1;
14309 }
14310 if self.associated_table_id.is_some() {
14311 len += 1;
14312 }
14313 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamSource", len)?;
14314 if self.source_id != 0 {
14315 struct_ser.serialize_field("sourceId", &self.source_id)?;
14316 }
14317 if let Some(v) = self.state_table.as_ref() {
14318 struct_ser.serialize_field("stateTable", v)?;
14319 }
14320 if let Some(v) = self.row_id_index.as_ref() {
14321 struct_ser.serialize_field("rowIdIndex", v)?;
14322 }
14323 if !self.columns.is_empty() {
14324 struct_ser.serialize_field("columns", &self.columns)?;
14325 }
14326 if !self.with_properties.is_empty() {
14327 struct_ser.serialize_field("withProperties", &self.with_properties)?;
14328 }
14329 if let Some(v) = self.info.as_ref() {
14330 struct_ser.serialize_field("info", v)?;
14331 }
14332 if !self.source_name.is_empty() {
14333 struct_ser.serialize_field("sourceName", &self.source_name)?;
14334 }
14335 if let Some(v) = self.rate_limit.as_ref() {
14336 struct_ser.serialize_field("rateLimit", v)?;
14337 }
14338 if !self.secret_refs.is_empty() {
14339 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
14340 }
14341 if let Some(v) = self.downstream_columns.as_ref() {
14342 struct_ser.serialize_field("downstreamColumns", v)?;
14343 }
14344 if let Some(v) = self.refresh_mode.as_ref() {
14345 struct_ser.serialize_field("refreshMode", v)?;
14346 }
14347 if let Some(v) = self.associated_table_id.as_ref() {
14348 struct_ser.serialize_field("associatedTableId", v)?;
14349 }
14350 struct_ser.end()
14351 }
14352}
14353impl<'de> serde::Deserialize<'de> for StreamSource {
14354 #[allow(deprecated)]
14355 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14356 where
14357 D: serde::Deserializer<'de>,
14358 {
14359 const FIELDS: &[&str] = &[
14360 "source_id",
14361 "sourceId",
14362 "state_table",
14363 "stateTable",
14364 "row_id_index",
14365 "rowIdIndex",
14366 "columns",
14367 "with_properties",
14368 "withProperties",
14369 "info",
14370 "source_name",
14371 "sourceName",
14372 "rate_limit",
14373 "rateLimit",
14374 "secret_refs",
14375 "secretRefs",
14376 "downstream_columns",
14377 "downstreamColumns",
14378 "refresh_mode",
14379 "refreshMode",
14380 "associated_table_id",
14381 "associatedTableId",
14382 ];
14383
14384 #[allow(clippy::enum_variant_names)]
14385 enum GeneratedField {
14386 SourceId,
14387 StateTable,
14388 RowIdIndex,
14389 Columns,
14390 WithProperties,
14391 Info,
14392 SourceName,
14393 RateLimit,
14394 SecretRefs,
14395 DownstreamColumns,
14396 RefreshMode,
14397 AssociatedTableId,
14398 }
14399 impl<'de> serde::Deserialize<'de> for GeneratedField {
14400 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14401 where
14402 D: serde::Deserializer<'de>,
14403 {
14404 struct GeneratedVisitor;
14405
14406 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14407 type Value = GeneratedField;
14408
14409 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14410 write!(formatter, "expected one of: {:?}", &FIELDS)
14411 }
14412
14413 #[allow(unused_variables)]
14414 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14415 where
14416 E: serde::de::Error,
14417 {
14418 match value {
14419 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
14420 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
14421 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
14422 "columns" => Ok(GeneratedField::Columns),
14423 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
14424 "info" => Ok(GeneratedField::Info),
14425 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
14426 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
14427 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
14428 "downstreamColumns" | "downstream_columns" => Ok(GeneratedField::DownstreamColumns),
14429 "refreshMode" | "refresh_mode" => Ok(GeneratedField::RefreshMode),
14430 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
14431 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14432 }
14433 }
14434 }
14435 deserializer.deserialize_identifier(GeneratedVisitor)
14436 }
14437 }
14438 struct GeneratedVisitor;
14439 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14440 type Value = StreamSource;
14441
14442 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14443 formatter.write_str("struct stream_plan.StreamSource")
14444 }
14445
14446 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSource, V::Error>
14447 where
14448 V: serde::de::MapAccess<'de>,
14449 {
14450 let mut source_id__ = None;
14451 let mut state_table__ = None;
14452 let mut row_id_index__ = None;
14453 let mut columns__ = None;
14454 let mut with_properties__ = None;
14455 let mut info__ = None;
14456 let mut source_name__ = None;
14457 let mut rate_limit__ = None;
14458 let mut secret_refs__ = None;
14459 let mut downstream_columns__ = None;
14460 let mut refresh_mode__ = None;
14461 let mut associated_table_id__ = None;
14462 while let Some(k) = map_.next_key()? {
14463 match k {
14464 GeneratedField::SourceId => {
14465 if source_id__.is_some() {
14466 return Err(serde::de::Error::duplicate_field("sourceId"));
14467 }
14468 source_id__ =
14469 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14470 ;
14471 }
14472 GeneratedField::StateTable => {
14473 if state_table__.is_some() {
14474 return Err(serde::de::Error::duplicate_field("stateTable"));
14475 }
14476 state_table__ = map_.next_value()?;
14477 }
14478 GeneratedField::RowIdIndex => {
14479 if row_id_index__.is_some() {
14480 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
14481 }
14482 row_id_index__ =
14483 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14484 ;
14485 }
14486 GeneratedField::Columns => {
14487 if columns__.is_some() {
14488 return Err(serde::de::Error::duplicate_field("columns"));
14489 }
14490 columns__ = Some(map_.next_value()?);
14491 }
14492 GeneratedField::WithProperties => {
14493 if with_properties__.is_some() {
14494 return Err(serde::de::Error::duplicate_field("withProperties"));
14495 }
14496 with_properties__ = Some(
14497 map_.next_value::<std::collections::BTreeMap<_, _>>()?
14498 );
14499 }
14500 GeneratedField::Info => {
14501 if info__.is_some() {
14502 return Err(serde::de::Error::duplicate_field("info"));
14503 }
14504 info__ = map_.next_value()?;
14505 }
14506 GeneratedField::SourceName => {
14507 if source_name__.is_some() {
14508 return Err(serde::de::Error::duplicate_field("sourceName"));
14509 }
14510 source_name__ = Some(map_.next_value()?);
14511 }
14512 GeneratedField::RateLimit => {
14513 if rate_limit__.is_some() {
14514 return Err(serde::de::Error::duplicate_field("rateLimit"));
14515 }
14516 rate_limit__ =
14517 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14518 ;
14519 }
14520 GeneratedField::SecretRefs => {
14521 if secret_refs__.is_some() {
14522 return Err(serde::de::Error::duplicate_field("secretRefs"));
14523 }
14524 secret_refs__ = Some(
14525 map_.next_value::<std::collections::BTreeMap<_, _>>()?
14526 );
14527 }
14528 GeneratedField::DownstreamColumns => {
14529 if downstream_columns__.is_some() {
14530 return Err(serde::de::Error::duplicate_field("downstreamColumns"));
14531 }
14532 downstream_columns__ = map_.next_value()?;
14533 }
14534 GeneratedField::RefreshMode => {
14535 if refresh_mode__.is_some() {
14536 return Err(serde::de::Error::duplicate_field("refreshMode"));
14537 }
14538 refresh_mode__ = map_.next_value()?;
14539 }
14540 GeneratedField::AssociatedTableId => {
14541 if associated_table_id__.is_some() {
14542 return Err(serde::de::Error::duplicate_field("associatedTableId"));
14543 }
14544 associated_table_id__ =
14545 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14546 ;
14547 }
14548 }
14549 }
14550 Ok(StreamSource {
14551 source_id: source_id__.unwrap_or_default(),
14552 state_table: state_table__,
14553 row_id_index: row_id_index__,
14554 columns: columns__.unwrap_or_default(),
14555 with_properties: with_properties__.unwrap_or_default(),
14556 info: info__,
14557 source_name: source_name__.unwrap_or_default(),
14558 rate_limit: rate_limit__,
14559 secret_refs: secret_refs__.unwrap_or_default(),
14560 downstream_columns: downstream_columns__,
14561 refresh_mode: refresh_mode__,
14562 associated_table_id: associated_table_id__,
14563 })
14564 }
14565 }
14566 deserializer.deserialize_struct("stream_plan.StreamSource", FIELDS, GeneratedVisitor)
14567 }
14568}
14569impl serde::Serialize for SubscriptionUpstreamInfo {
14570 #[allow(deprecated)]
14571 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14572 where
14573 S: serde::Serializer,
14574 {
14575 use serde::ser::SerializeStruct;
14576 let mut len = 0;
14577 if self.subscriber_id != 0 {
14578 len += 1;
14579 }
14580 if self.upstream_mv_table_id != 0 {
14581 len += 1;
14582 }
14583 let mut struct_ser = serializer.serialize_struct("stream_plan.SubscriptionUpstreamInfo", len)?;
14584 if self.subscriber_id != 0 {
14585 struct_ser.serialize_field("subscriberId", &self.subscriber_id)?;
14586 }
14587 if self.upstream_mv_table_id != 0 {
14588 struct_ser.serialize_field("upstreamMvTableId", &self.upstream_mv_table_id)?;
14589 }
14590 struct_ser.end()
14591 }
14592}
14593impl<'de> serde::Deserialize<'de> for SubscriptionUpstreamInfo {
14594 #[allow(deprecated)]
14595 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14596 where
14597 D: serde::Deserializer<'de>,
14598 {
14599 const FIELDS: &[&str] = &[
14600 "subscriber_id",
14601 "subscriberId",
14602 "upstream_mv_table_id",
14603 "upstreamMvTableId",
14604 ];
14605
14606 #[allow(clippy::enum_variant_names)]
14607 enum GeneratedField {
14608 SubscriberId,
14609 UpstreamMvTableId,
14610 }
14611 impl<'de> serde::Deserialize<'de> for GeneratedField {
14612 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14613 where
14614 D: serde::Deserializer<'de>,
14615 {
14616 struct GeneratedVisitor;
14617
14618 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14619 type Value = GeneratedField;
14620
14621 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14622 write!(formatter, "expected one of: {:?}", &FIELDS)
14623 }
14624
14625 #[allow(unused_variables)]
14626 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14627 where
14628 E: serde::de::Error,
14629 {
14630 match value {
14631 "subscriberId" | "subscriber_id" => Ok(GeneratedField::SubscriberId),
14632 "upstreamMvTableId" | "upstream_mv_table_id" => Ok(GeneratedField::UpstreamMvTableId),
14633 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14634 }
14635 }
14636 }
14637 deserializer.deserialize_identifier(GeneratedVisitor)
14638 }
14639 }
14640 struct GeneratedVisitor;
14641 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14642 type Value = SubscriptionUpstreamInfo;
14643
14644 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14645 formatter.write_str("struct stream_plan.SubscriptionUpstreamInfo")
14646 }
14647
14648 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscriptionUpstreamInfo, V::Error>
14649 where
14650 V: serde::de::MapAccess<'de>,
14651 {
14652 let mut subscriber_id__ = None;
14653 let mut upstream_mv_table_id__ = None;
14654 while let Some(k) = map_.next_key()? {
14655 match k {
14656 GeneratedField::SubscriberId => {
14657 if subscriber_id__.is_some() {
14658 return Err(serde::de::Error::duplicate_field("subscriberId"));
14659 }
14660 subscriber_id__ =
14661 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14662 ;
14663 }
14664 GeneratedField::UpstreamMvTableId => {
14665 if upstream_mv_table_id__.is_some() {
14666 return Err(serde::de::Error::duplicate_field("upstreamMvTableId"));
14667 }
14668 upstream_mv_table_id__ =
14669 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14670 ;
14671 }
14672 }
14673 }
14674 Ok(SubscriptionUpstreamInfo {
14675 subscriber_id: subscriber_id__.unwrap_or_default(),
14676 upstream_mv_table_id: upstream_mv_table_id__.unwrap_or_default(),
14677 })
14678 }
14679 }
14680 deserializer.deserialize_struct("stream_plan.SubscriptionUpstreamInfo", FIELDS, GeneratedVisitor)
14681 }
14682}
14683impl serde::Serialize for SyncLogStoreNode {
14684 #[allow(deprecated)]
14685 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14686 where
14687 S: serde::Serializer,
14688 {
14689 use serde::ser::SerializeStruct;
14690 let mut len = 0;
14691 if self.log_store_table.is_some() {
14692 len += 1;
14693 }
14694 if self.pause_duration_ms != 0 {
14695 len += 1;
14696 }
14697 if self.buffer_size != 0 {
14698 len += 1;
14699 }
14700 if self.aligned {
14701 len += 1;
14702 }
14703 let mut struct_ser = serializer.serialize_struct("stream_plan.SyncLogStoreNode", len)?;
14704 if let Some(v) = self.log_store_table.as_ref() {
14705 struct_ser.serialize_field("logStoreTable", v)?;
14706 }
14707 if self.pause_duration_ms != 0 {
14708 struct_ser.serialize_field("pauseDurationMs", &self.pause_duration_ms)?;
14709 }
14710 if self.buffer_size != 0 {
14711 struct_ser.serialize_field("bufferSize", &self.buffer_size)?;
14712 }
14713 if self.aligned {
14714 struct_ser.serialize_field("aligned", &self.aligned)?;
14715 }
14716 struct_ser.end()
14717 }
14718}
14719impl<'de> serde::Deserialize<'de> for SyncLogStoreNode {
14720 #[allow(deprecated)]
14721 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14722 where
14723 D: serde::Deserializer<'de>,
14724 {
14725 const FIELDS: &[&str] = &[
14726 "log_store_table",
14727 "logStoreTable",
14728 "pause_duration_ms",
14729 "pauseDurationMs",
14730 "buffer_size",
14731 "bufferSize",
14732 "aligned",
14733 ];
14734
14735 #[allow(clippy::enum_variant_names)]
14736 enum GeneratedField {
14737 LogStoreTable,
14738 PauseDurationMs,
14739 BufferSize,
14740 Aligned,
14741 }
14742 impl<'de> serde::Deserialize<'de> for GeneratedField {
14743 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14744 where
14745 D: serde::Deserializer<'de>,
14746 {
14747 struct GeneratedVisitor;
14748
14749 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14750 type Value = GeneratedField;
14751
14752 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14753 write!(formatter, "expected one of: {:?}", &FIELDS)
14754 }
14755
14756 #[allow(unused_variables)]
14757 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14758 where
14759 E: serde::de::Error,
14760 {
14761 match value {
14762 "logStoreTable" | "log_store_table" => Ok(GeneratedField::LogStoreTable),
14763 "pauseDurationMs" | "pause_duration_ms" => Ok(GeneratedField::PauseDurationMs),
14764 "bufferSize" | "buffer_size" => Ok(GeneratedField::BufferSize),
14765 "aligned" => Ok(GeneratedField::Aligned),
14766 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14767 }
14768 }
14769 }
14770 deserializer.deserialize_identifier(GeneratedVisitor)
14771 }
14772 }
14773 struct GeneratedVisitor;
14774 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14775 type Value = SyncLogStoreNode;
14776
14777 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14778 formatter.write_str("struct stream_plan.SyncLogStoreNode")
14779 }
14780
14781 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SyncLogStoreNode, V::Error>
14782 where
14783 V: serde::de::MapAccess<'de>,
14784 {
14785 let mut log_store_table__ = None;
14786 let mut pause_duration_ms__ = None;
14787 let mut buffer_size__ = None;
14788 let mut aligned__ = None;
14789 while let Some(k) = map_.next_key()? {
14790 match k {
14791 GeneratedField::LogStoreTable => {
14792 if log_store_table__.is_some() {
14793 return Err(serde::de::Error::duplicate_field("logStoreTable"));
14794 }
14795 log_store_table__ = map_.next_value()?;
14796 }
14797 GeneratedField::PauseDurationMs => {
14798 if pause_duration_ms__.is_some() {
14799 return Err(serde::de::Error::duplicate_field("pauseDurationMs"));
14800 }
14801 pause_duration_ms__ =
14802 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14803 ;
14804 }
14805 GeneratedField::BufferSize => {
14806 if buffer_size__.is_some() {
14807 return Err(serde::de::Error::duplicate_field("bufferSize"));
14808 }
14809 buffer_size__ =
14810 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14811 ;
14812 }
14813 GeneratedField::Aligned => {
14814 if aligned__.is_some() {
14815 return Err(serde::de::Error::duplicate_field("aligned"));
14816 }
14817 aligned__ = Some(map_.next_value()?);
14818 }
14819 }
14820 }
14821 Ok(SyncLogStoreNode {
14822 log_store_table: log_store_table__,
14823 pause_duration_ms: pause_duration_ms__.unwrap_or_default(),
14824 buffer_size: buffer_size__.unwrap_or_default(),
14825 aligned: aligned__.unwrap_or_default(),
14826 })
14827 }
14828 }
14829 deserializer.deserialize_struct("stream_plan.SyncLogStoreNode", FIELDS, GeneratedVisitor)
14830 }
14831}
14832impl serde::Serialize for TemporalJoinNode {
14833 #[allow(deprecated)]
14834 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14835 where
14836 S: serde::Serializer,
14837 {
14838 use serde::ser::SerializeStruct;
14839 let mut len = 0;
14840 if self.join_type != 0 {
14841 len += 1;
14842 }
14843 if !self.left_key.is_empty() {
14844 len += 1;
14845 }
14846 if !self.right_key.is_empty() {
14847 len += 1;
14848 }
14849 if !self.null_safe.is_empty() {
14850 len += 1;
14851 }
14852 if self.condition.is_some() {
14853 len += 1;
14854 }
14855 if !self.output_indices.is_empty() {
14856 len += 1;
14857 }
14858 if self.table_desc.is_some() {
14859 len += 1;
14860 }
14861 if !self.table_output_indices.is_empty() {
14862 len += 1;
14863 }
14864 if self.memo_table.is_some() {
14865 len += 1;
14866 }
14867 if self.is_nested_loop {
14868 len += 1;
14869 }
14870 let mut struct_ser = serializer.serialize_struct("stream_plan.TemporalJoinNode", len)?;
14871 if self.join_type != 0 {
14872 let v = super::plan_common::JoinType::try_from(self.join_type)
14873 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
14874 struct_ser.serialize_field("joinType", &v)?;
14875 }
14876 if !self.left_key.is_empty() {
14877 struct_ser.serialize_field("leftKey", &self.left_key)?;
14878 }
14879 if !self.right_key.is_empty() {
14880 struct_ser.serialize_field("rightKey", &self.right_key)?;
14881 }
14882 if !self.null_safe.is_empty() {
14883 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
14884 }
14885 if let Some(v) = self.condition.as_ref() {
14886 struct_ser.serialize_field("condition", v)?;
14887 }
14888 if !self.output_indices.is_empty() {
14889 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
14890 }
14891 if let Some(v) = self.table_desc.as_ref() {
14892 struct_ser.serialize_field("tableDesc", v)?;
14893 }
14894 if !self.table_output_indices.is_empty() {
14895 struct_ser.serialize_field("tableOutputIndices", &self.table_output_indices)?;
14896 }
14897 if let Some(v) = self.memo_table.as_ref() {
14898 struct_ser.serialize_field("memoTable", v)?;
14899 }
14900 if self.is_nested_loop {
14901 struct_ser.serialize_field("isNestedLoop", &self.is_nested_loop)?;
14902 }
14903 struct_ser.end()
14904 }
14905}
14906impl<'de> serde::Deserialize<'de> for TemporalJoinNode {
14907 #[allow(deprecated)]
14908 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14909 where
14910 D: serde::Deserializer<'de>,
14911 {
14912 const FIELDS: &[&str] = &[
14913 "join_type",
14914 "joinType",
14915 "left_key",
14916 "leftKey",
14917 "right_key",
14918 "rightKey",
14919 "null_safe",
14920 "nullSafe",
14921 "condition",
14922 "output_indices",
14923 "outputIndices",
14924 "table_desc",
14925 "tableDesc",
14926 "table_output_indices",
14927 "tableOutputIndices",
14928 "memo_table",
14929 "memoTable",
14930 "is_nested_loop",
14931 "isNestedLoop",
14932 ];
14933
14934 #[allow(clippy::enum_variant_names)]
14935 enum GeneratedField {
14936 JoinType,
14937 LeftKey,
14938 RightKey,
14939 NullSafe,
14940 Condition,
14941 OutputIndices,
14942 TableDesc,
14943 TableOutputIndices,
14944 MemoTable,
14945 IsNestedLoop,
14946 }
14947 impl<'de> serde::Deserialize<'de> for GeneratedField {
14948 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14949 where
14950 D: serde::Deserializer<'de>,
14951 {
14952 struct GeneratedVisitor;
14953
14954 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14955 type Value = GeneratedField;
14956
14957 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14958 write!(formatter, "expected one of: {:?}", &FIELDS)
14959 }
14960
14961 #[allow(unused_variables)]
14962 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14963 where
14964 E: serde::de::Error,
14965 {
14966 match value {
14967 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
14968 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
14969 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
14970 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
14971 "condition" => Ok(GeneratedField::Condition),
14972 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
14973 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
14974 "tableOutputIndices" | "table_output_indices" => Ok(GeneratedField::TableOutputIndices),
14975 "memoTable" | "memo_table" => Ok(GeneratedField::MemoTable),
14976 "isNestedLoop" | "is_nested_loop" => Ok(GeneratedField::IsNestedLoop),
14977 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14978 }
14979 }
14980 }
14981 deserializer.deserialize_identifier(GeneratedVisitor)
14982 }
14983 }
14984 struct GeneratedVisitor;
14985 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14986 type Value = TemporalJoinNode;
14987
14988 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14989 formatter.write_str("struct stream_plan.TemporalJoinNode")
14990 }
14991
14992 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TemporalJoinNode, V::Error>
14993 where
14994 V: serde::de::MapAccess<'de>,
14995 {
14996 let mut join_type__ = None;
14997 let mut left_key__ = None;
14998 let mut right_key__ = None;
14999 let mut null_safe__ = None;
15000 let mut condition__ = None;
15001 let mut output_indices__ = None;
15002 let mut table_desc__ = None;
15003 let mut table_output_indices__ = None;
15004 let mut memo_table__ = None;
15005 let mut is_nested_loop__ = None;
15006 while let Some(k) = map_.next_key()? {
15007 match k {
15008 GeneratedField::JoinType => {
15009 if join_type__.is_some() {
15010 return Err(serde::de::Error::duplicate_field("joinType"));
15011 }
15012 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
15013 }
15014 GeneratedField::LeftKey => {
15015 if left_key__.is_some() {
15016 return Err(serde::de::Error::duplicate_field("leftKey"));
15017 }
15018 left_key__ =
15019 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15020 .into_iter().map(|x| x.0).collect())
15021 ;
15022 }
15023 GeneratedField::RightKey => {
15024 if right_key__.is_some() {
15025 return Err(serde::de::Error::duplicate_field("rightKey"));
15026 }
15027 right_key__ =
15028 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15029 .into_iter().map(|x| x.0).collect())
15030 ;
15031 }
15032 GeneratedField::NullSafe => {
15033 if null_safe__.is_some() {
15034 return Err(serde::de::Error::duplicate_field("nullSafe"));
15035 }
15036 null_safe__ = Some(map_.next_value()?);
15037 }
15038 GeneratedField::Condition => {
15039 if condition__.is_some() {
15040 return Err(serde::de::Error::duplicate_field("condition"));
15041 }
15042 condition__ = map_.next_value()?;
15043 }
15044 GeneratedField::OutputIndices => {
15045 if output_indices__.is_some() {
15046 return Err(serde::de::Error::duplicate_field("outputIndices"));
15047 }
15048 output_indices__ =
15049 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15050 .into_iter().map(|x| x.0).collect())
15051 ;
15052 }
15053 GeneratedField::TableDesc => {
15054 if table_desc__.is_some() {
15055 return Err(serde::de::Error::duplicate_field("tableDesc"));
15056 }
15057 table_desc__ = map_.next_value()?;
15058 }
15059 GeneratedField::TableOutputIndices => {
15060 if table_output_indices__.is_some() {
15061 return Err(serde::de::Error::duplicate_field("tableOutputIndices"));
15062 }
15063 table_output_indices__ =
15064 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15065 .into_iter().map(|x| x.0).collect())
15066 ;
15067 }
15068 GeneratedField::MemoTable => {
15069 if memo_table__.is_some() {
15070 return Err(serde::de::Error::duplicate_field("memoTable"));
15071 }
15072 memo_table__ = map_.next_value()?;
15073 }
15074 GeneratedField::IsNestedLoop => {
15075 if is_nested_loop__.is_some() {
15076 return Err(serde::de::Error::duplicate_field("isNestedLoop"));
15077 }
15078 is_nested_loop__ = Some(map_.next_value()?);
15079 }
15080 }
15081 }
15082 Ok(TemporalJoinNode {
15083 join_type: join_type__.unwrap_or_default(),
15084 left_key: left_key__.unwrap_or_default(),
15085 right_key: right_key__.unwrap_or_default(),
15086 null_safe: null_safe__.unwrap_or_default(),
15087 condition: condition__,
15088 output_indices: output_indices__.unwrap_or_default(),
15089 table_desc: table_desc__,
15090 table_output_indices: table_output_indices__.unwrap_or_default(),
15091 memo_table: memo_table__,
15092 is_nested_loop: is_nested_loop__.unwrap_or_default(),
15093 })
15094 }
15095 }
15096 deserializer.deserialize_struct("stream_plan.TemporalJoinNode", FIELDS, GeneratedVisitor)
15097 }
15098}
15099impl serde::Serialize for ThrottleMutation {
15100 #[allow(deprecated)]
15101 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15102 where
15103 S: serde::Serializer,
15104 {
15105 use serde::ser::SerializeStruct;
15106 let mut len = 0;
15107 if !self.actor_throttle.is_empty() {
15108 len += 1;
15109 }
15110 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation", len)?;
15111 if !self.actor_throttle.is_empty() {
15112 struct_ser.serialize_field("actorThrottle", &self.actor_throttle)?;
15113 }
15114 struct_ser.end()
15115 }
15116}
15117impl<'de> serde::Deserialize<'de> for ThrottleMutation {
15118 #[allow(deprecated)]
15119 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15120 where
15121 D: serde::Deserializer<'de>,
15122 {
15123 const FIELDS: &[&str] = &[
15124 "actor_throttle",
15125 "actorThrottle",
15126 ];
15127
15128 #[allow(clippy::enum_variant_names)]
15129 enum GeneratedField {
15130 ActorThrottle,
15131 }
15132 impl<'de> serde::Deserialize<'de> for GeneratedField {
15133 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15134 where
15135 D: serde::Deserializer<'de>,
15136 {
15137 struct GeneratedVisitor;
15138
15139 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15140 type Value = GeneratedField;
15141
15142 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15143 write!(formatter, "expected one of: {:?}", &FIELDS)
15144 }
15145
15146 #[allow(unused_variables)]
15147 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15148 where
15149 E: serde::de::Error,
15150 {
15151 match value {
15152 "actorThrottle" | "actor_throttle" => Ok(GeneratedField::ActorThrottle),
15153 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15154 }
15155 }
15156 }
15157 deserializer.deserialize_identifier(GeneratedVisitor)
15158 }
15159 }
15160 struct GeneratedVisitor;
15161 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15162 type Value = ThrottleMutation;
15163
15164 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15165 formatter.write_str("struct stream_plan.ThrottleMutation")
15166 }
15167
15168 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ThrottleMutation, V::Error>
15169 where
15170 V: serde::de::MapAccess<'de>,
15171 {
15172 let mut actor_throttle__ = None;
15173 while let Some(k) = map_.next_key()? {
15174 match k {
15175 GeneratedField::ActorThrottle => {
15176 if actor_throttle__.is_some() {
15177 return Err(serde::de::Error::duplicate_field("actorThrottle"));
15178 }
15179 actor_throttle__ = Some(
15180 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15181 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15182 );
15183 }
15184 }
15185 }
15186 Ok(ThrottleMutation {
15187 actor_throttle: actor_throttle__.unwrap_or_default(),
15188 })
15189 }
15190 }
15191 deserializer.deserialize_struct("stream_plan.ThrottleMutation", FIELDS, GeneratedVisitor)
15192 }
15193}
15194impl serde::Serialize for throttle_mutation::RateLimit {
15195 #[allow(deprecated)]
15196 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15197 where
15198 S: serde::Serializer,
15199 {
15200 use serde::ser::SerializeStruct;
15201 let mut len = 0;
15202 if self.rate_limit.is_some() {
15203 len += 1;
15204 }
15205 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation.RateLimit", len)?;
15206 if let Some(v) = self.rate_limit.as_ref() {
15207 struct_ser.serialize_field("rateLimit", v)?;
15208 }
15209 struct_ser.end()
15210 }
15211}
15212impl<'de> serde::Deserialize<'de> for throttle_mutation::RateLimit {
15213 #[allow(deprecated)]
15214 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15215 where
15216 D: serde::Deserializer<'de>,
15217 {
15218 const FIELDS: &[&str] = &[
15219 "rate_limit",
15220 "rateLimit",
15221 ];
15222
15223 #[allow(clippy::enum_variant_names)]
15224 enum GeneratedField {
15225 RateLimit,
15226 }
15227 impl<'de> serde::Deserialize<'de> for GeneratedField {
15228 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15229 where
15230 D: serde::Deserializer<'de>,
15231 {
15232 struct GeneratedVisitor;
15233
15234 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15235 type Value = GeneratedField;
15236
15237 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15238 write!(formatter, "expected one of: {:?}", &FIELDS)
15239 }
15240
15241 #[allow(unused_variables)]
15242 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15243 where
15244 E: serde::de::Error,
15245 {
15246 match value {
15247 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
15248 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15249 }
15250 }
15251 }
15252 deserializer.deserialize_identifier(GeneratedVisitor)
15253 }
15254 }
15255 struct GeneratedVisitor;
15256 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15257 type Value = throttle_mutation::RateLimit;
15258
15259 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15260 formatter.write_str("struct stream_plan.ThrottleMutation.RateLimit")
15261 }
15262
15263 fn visit_map<V>(self, mut map_: V) -> std::result::Result<throttle_mutation::RateLimit, V::Error>
15264 where
15265 V: serde::de::MapAccess<'de>,
15266 {
15267 let mut rate_limit__ = None;
15268 while let Some(k) = map_.next_key()? {
15269 match k {
15270 GeneratedField::RateLimit => {
15271 if rate_limit__.is_some() {
15272 return Err(serde::de::Error::duplicate_field("rateLimit"));
15273 }
15274 rate_limit__ =
15275 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15276 ;
15277 }
15278 }
15279 }
15280 Ok(throttle_mutation::RateLimit {
15281 rate_limit: rate_limit__,
15282 })
15283 }
15284 }
15285 deserializer.deserialize_struct("stream_plan.ThrottleMutation.RateLimit", FIELDS, GeneratedVisitor)
15286 }
15287}
15288impl serde::Serialize for TopNNode {
15289 #[allow(deprecated)]
15290 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15291 where
15292 S: serde::Serializer,
15293 {
15294 use serde::ser::SerializeStruct;
15295 let mut len = 0;
15296 if self.limit != 0 {
15297 len += 1;
15298 }
15299 if self.offset != 0 {
15300 len += 1;
15301 }
15302 if self.table.is_some() {
15303 len += 1;
15304 }
15305 if !self.order_by.is_empty() {
15306 len += 1;
15307 }
15308 if self.with_ties {
15309 len += 1;
15310 }
15311 let mut struct_ser = serializer.serialize_struct("stream_plan.TopNNode", len)?;
15312 if self.limit != 0 {
15313 #[allow(clippy::needless_borrow)]
15314 #[allow(clippy::needless_borrows_for_generic_args)]
15315 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
15316 }
15317 if self.offset != 0 {
15318 #[allow(clippy::needless_borrow)]
15319 #[allow(clippy::needless_borrows_for_generic_args)]
15320 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
15321 }
15322 if let Some(v) = self.table.as_ref() {
15323 struct_ser.serialize_field("table", v)?;
15324 }
15325 if !self.order_by.is_empty() {
15326 struct_ser.serialize_field("orderBy", &self.order_by)?;
15327 }
15328 if self.with_ties {
15329 struct_ser.serialize_field("withTies", &self.with_ties)?;
15330 }
15331 struct_ser.end()
15332 }
15333}
15334impl<'de> serde::Deserialize<'de> for TopNNode {
15335 #[allow(deprecated)]
15336 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15337 where
15338 D: serde::Deserializer<'de>,
15339 {
15340 const FIELDS: &[&str] = &[
15341 "limit",
15342 "offset",
15343 "table",
15344 "order_by",
15345 "orderBy",
15346 "with_ties",
15347 "withTies",
15348 ];
15349
15350 #[allow(clippy::enum_variant_names)]
15351 enum GeneratedField {
15352 Limit,
15353 Offset,
15354 Table,
15355 OrderBy,
15356 WithTies,
15357 }
15358 impl<'de> serde::Deserialize<'de> for GeneratedField {
15359 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15360 where
15361 D: serde::Deserializer<'de>,
15362 {
15363 struct GeneratedVisitor;
15364
15365 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15366 type Value = GeneratedField;
15367
15368 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15369 write!(formatter, "expected one of: {:?}", &FIELDS)
15370 }
15371
15372 #[allow(unused_variables)]
15373 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15374 where
15375 E: serde::de::Error,
15376 {
15377 match value {
15378 "limit" => Ok(GeneratedField::Limit),
15379 "offset" => Ok(GeneratedField::Offset),
15380 "table" => Ok(GeneratedField::Table),
15381 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
15382 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
15383 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15384 }
15385 }
15386 }
15387 deserializer.deserialize_identifier(GeneratedVisitor)
15388 }
15389 }
15390 struct GeneratedVisitor;
15391 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15392 type Value = TopNNode;
15393
15394 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15395 formatter.write_str("struct stream_plan.TopNNode")
15396 }
15397
15398 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
15399 where
15400 V: serde::de::MapAccess<'de>,
15401 {
15402 let mut limit__ = None;
15403 let mut offset__ = None;
15404 let mut table__ = None;
15405 let mut order_by__ = None;
15406 let mut with_ties__ = None;
15407 while let Some(k) = map_.next_key()? {
15408 match k {
15409 GeneratedField::Limit => {
15410 if limit__.is_some() {
15411 return Err(serde::de::Error::duplicate_field("limit"));
15412 }
15413 limit__ =
15414 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15415 ;
15416 }
15417 GeneratedField::Offset => {
15418 if offset__.is_some() {
15419 return Err(serde::de::Error::duplicate_field("offset"));
15420 }
15421 offset__ =
15422 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15423 ;
15424 }
15425 GeneratedField::Table => {
15426 if table__.is_some() {
15427 return Err(serde::de::Error::duplicate_field("table"));
15428 }
15429 table__ = map_.next_value()?;
15430 }
15431 GeneratedField::OrderBy => {
15432 if order_by__.is_some() {
15433 return Err(serde::de::Error::duplicate_field("orderBy"));
15434 }
15435 order_by__ = Some(map_.next_value()?);
15436 }
15437 GeneratedField::WithTies => {
15438 if with_ties__.is_some() {
15439 return Err(serde::de::Error::duplicate_field("withTies"));
15440 }
15441 with_ties__ = Some(map_.next_value()?);
15442 }
15443 }
15444 }
15445 Ok(TopNNode {
15446 limit: limit__.unwrap_or_default(),
15447 offset: offset__.unwrap_or_default(),
15448 table: table__,
15449 order_by: order_by__.unwrap_or_default(),
15450 with_ties: with_ties__.unwrap_or_default(),
15451 })
15452 }
15453 }
15454 deserializer.deserialize_struct("stream_plan.TopNNode", FIELDS, GeneratedVisitor)
15455 }
15456}
15457impl serde::Serialize for UnionNode {
15458 #[allow(deprecated)]
15459 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15460 where
15461 S: serde::Serializer,
15462 {
15463 use serde::ser::SerializeStruct;
15464 let len = 0;
15465 let struct_ser = serializer.serialize_struct("stream_plan.UnionNode", len)?;
15466 struct_ser.end()
15467 }
15468}
15469impl<'de> serde::Deserialize<'de> for UnionNode {
15470 #[allow(deprecated)]
15471 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15472 where
15473 D: serde::Deserializer<'de>,
15474 {
15475 const FIELDS: &[&str] = &[
15476 ];
15477
15478 #[allow(clippy::enum_variant_names)]
15479 enum GeneratedField {
15480 }
15481 impl<'de> serde::Deserialize<'de> for GeneratedField {
15482 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15483 where
15484 D: serde::Deserializer<'de>,
15485 {
15486 struct GeneratedVisitor;
15487
15488 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15489 type Value = GeneratedField;
15490
15491 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15492 write!(formatter, "expected one of: {:?}", &FIELDS)
15493 }
15494
15495 #[allow(unused_variables)]
15496 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15497 where
15498 E: serde::de::Error,
15499 {
15500 Err(serde::de::Error::unknown_field(value, FIELDS))
15501 }
15502 }
15503 deserializer.deserialize_identifier(GeneratedVisitor)
15504 }
15505 }
15506 struct GeneratedVisitor;
15507 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15508 type Value = UnionNode;
15509
15510 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15511 formatter.write_str("struct stream_plan.UnionNode")
15512 }
15513
15514 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
15515 where
15516 V: serde::de::MapAccess<'de>,
15517 {
15518 while map_.next_key::<GeneratedField>()?.is_some() {
15519 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15520 }
15521 Ok(UnionNode {
15522 })
15523 }
15524 }
15525 deserializer.deserialize_struct("stream_plan.UnionNode", FIELDS, GeneratedVisitor)
15526 }
15527}
15528impl serde::Serialize for UpdateMutation {
15529 #[allow(deprecated)]
15530 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15531 where
15532 S: serde::Serializer,
15533 {
15534 use serde::ser::SerializeStruct;
15535 let mut len = 0;
15536 if !self.dispatcher_update.is_empty() {
15537 len += 1;
15538 }
15539 if !self.merge_update.is_empty() {
15540 len += 1;
15541 }
15542 if !self.actor_vnode_bitmap_update.is_empty() {
15543 len += 1;
15544 }
15545 if !self.dropped_actors.is_empty() {
15546 len += 1;
15547 }
15548 if !self.actor_splits.is_empty() {
15549 len += 1;
15550 }
15551 if !self.actor_new_dispatchers.is_empty() {
15552 len += 1;
15553 }
15554 if self.actor_cdc_table_snapshot_splits.is_some() {
15555 len += 1;
15556 }
15557 if !self.sink_add_columns.is_empty() {
15558 len += 1;
15559 }
15560 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation", len)?;
15561 if !self.dispatcher_update.is_empty() {
15562 struct_ser.serialize_field("dispatcherUpdate", &self.dispatcher_update)?;
15563 }
15564 if !self.merge_update.is_empty() {
15565 struct_ser.serialize_field("mergeUpdate", &self.merge_update)?;
15566 }
15567 if !self.actor_vnode_bitmap_update.is_empty() {
15568 struct_ser.serialize_field("actorVnodeBitmapUpdate", &self.actor_vnode_bitmap_update)?;
15569 }
15570 if !self.dropped_actors.is_empty() {
15571 struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
15572 }
15573 if !self.actor_splits.is_empty() {
15574 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
15575 }
15576 if !self.actor_new_dispatchers.is_empty() {
15577 struct_ser.serialize_field("actorNewDispatchers", &self.actor_new_dispatchers)?;
15578 }
15579 if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
15580 struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
15581 }
15582 if !self.sink_add_columns.is_empty() {
15583 struct_ser.serialize_field("sinkAddColumns", &self.sink_add_columns)?;
15584 }
15585 struct_ser.end()
15586 }
15587}
15588impl<'de> serde::Deserialize<'de> for UpdateMutation {
15589 #[allow(deprecated)]
15590 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15591 where
15592 D: serde::Deserializer<'de>,
15593 {
15594 const FIELDS: &[&str] = &[
15595 "dispatcher_update",
15596 "dispatcherUpdate",
15597 "merge_update",
15598 "mergeUpdate",
15599 "actor_vnode_bitmap_update",
15600 "actorVnodeBitmapUpdate",
15601 "dropped_actors",
15602 "droppedActors",
15603 "actor_splits",
15604 "actorSplits",
15605 "actor_new_dispatchers",
15606 "actorNewDispatchers",
15607 "actor_cdc_table_snapshot_splits",
15608 "actorCdcTableSnapshotSplits",
15609 "sink_add_columns",
15610 "sinkAddColumns",
15611 ];
15612
15613 #[allow(clippy::enum_variant_names)]
15614 enum GeneratedField {
15615 DispatcherUpdate,
15616 MergeUpdate,
15617 ActorVnodeBitmapUpdate,
15618 DroppedActors,
15619 ActorSplits,
15620 ActorNewDispatchers,
15621 ActorCdcTableSnapshotSplits,
15622 SinkAddColumns,
15623 }
15624 impl<'de> serde::Deserialize<'de> for GeneratedField {
15625 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15626 where
15627 D: serde::Deserializer<'de>,
15628 {
15629 struct GeneratedVisitor;
15630
15631 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15632 type Value = GeneratedField;
15633
15634 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15635 write!(formatter, "expected one of: {:?}", &FIELDS)
15636 }
15637
15638 #[allow(unused_variables)]
15639 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15640 where
15641 E: serde::de::Error,
15642 {
15643 match value {
15644 "dispatcherUpdate" | "dispatcher_update" => Ok(GeneratedField::DispatcherUpdate),
15645 "mergeUpdate" | "merge_update" => Ok(GeneratedField::MergeUpdate),
15646 "actorVnodeBitmapUpdate" | "actor_vnode_bitmap_update" => Ok(GeneratedField::ActorVnodeBitmapUpdate),
15647 "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
15648 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
15649 "actorNewDispatchers" | "actor_new_dispatchers" => Ok(GeneratedField::ActorNewDispatchers),
15650 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
15651 "sinkAddColumns" | "sink_add_columns" => Ok(GeneratedField::SinkAddColumns),
15652 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15653 }
15654 }
15655 }
15656 deserializer.deserialize_identifier(GeneratedVisitor)
15657 }
15658 }
15659 struct GeneratedVisitor;
15660 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15661 type Value = UpdateMutation;
15662
15663 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15664 formatter.write_str("struct stream_plan.UpdateMutation")
15665 }
15666
15667 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateMutation, V::Error>
15668 where
15669 V: serde::de::MapAccess<'de>,
15670 {
15671 let mut dispatcher_update__ = None;
15672 let mut merge_update__ = None;
15673 let mut actor_vnode_bitmap_update__ = None;
15674 let mut dropped_actors__ = None;
15675 let mut actor_splits__ = None;
15676 let mut actor_new_dispatchers__ = None;
15677 let mut actor_cdc_table_snapshot_splits__ = None;
15678 let mut sink_add_columns__ = None;
15679 while let Some(k) = map_.next_key()? {
15680 match k {
15681 GeneratedField::DispatcherUpdate => {
15682 if dispatcher_update__.is_some() {
15683 return Err(serde::de::Error::duplicate_field("dispatcherUpdate"));
15684 }
15685 dispatcher_update__ = Some(map_.next_value()?);
15686 }
15687 GeneratedField::MergeUpdate => {
15688 if merge_update__.is_some() {
15689 return Err(serde::de::Error::duplicate_field("mergeUpdate"));
15690 }
15691 merge_update__ = Some(map_.next_value()?);
15692 }
15693 GeneratedField::ActorVnodeBitmapUpdate => {
15694 if actor_vnode_bitmap_update__.is_some() {
15695 return Err(serde::de::Error::duplicate_field("actorVnodeBitmapUpdate"));
15696 }
15697 actor_vnode_bitmap_update__ = Some(
15698 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15699 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15700 );
15701 }
15702 GeneratedField::DroppedActors => {
15703 if dropped_actors__.is_some() {
15704 return Err(serde::de::Error::duplicate_field("droppedActors"));
15705 }
15706 dropped_actors__ =
15707 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15708 .into_iter().map(|x| x.0).collect())
15709 ;
15710 }
15711 GeneratedField::ActorSplits => {
15712 if actor_splits__.is_some() {
15713 return Err(serde::de::Error::duplicate_field("actorSplits"));
15714 }
15715 actor_splits__ = Some(
15716 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15717 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15718 );
15719 }
15720 GeneratedField::ActorNewDispatchers => {
15721 if actor_new_dispatchers__.is_some() {
15722 return Err(serde::de::Error::duplicate_field("actorNewDispatchers"));
15723 }
15724 actor_new_dispatchers__ = Some(
15725 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15726 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15727 );
15728 }
15729 GeneratedField::ActorCdcTableSnapshotSplits => {
15730 if actor_cdc_table_snapshot_splits__.is_some() {
15731 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
15732 }
15733 actor_cdc_table_snapshot_splits__ = map_.next_value()?;
15734 }
15735 GeneratedField::SinkAddColumns => {
15736 if sink_add_columns__.is_some() {
15737 return Err(serde::de::Error::duplicate_field("sinkAddColumns"));
15738 }
15739 sink_add_columns__ = Some(
15740 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15741 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15742 );
15743 }
15744 }
15745 }
15746 Ok(UpdateMutation {
15747 dispatcher_update: dispatcher_update__.unwrap_or_default(),
15748 merge_update: merge_update__.unwrap_or_default(),
15749 actor_vnode_bitmap_update: actor_vnode_bitmap_update__.unwrap_or_default(),
15750 dropped_actors: dropped_actors__.unwrap_or_default(),
15751 actor_splits: actor_splits__.unwrap_or_default(),
15752 actor_new_dispatchers: actor_new_dispatchers__.unwrap_or_default(),
15753 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
15754 sink_add_columns: sink_add_columns__.unwrap_or_default(),
15755 })
15756 }
15757 }
15758 deserializer.deserialize_struct("stream_plan.UpdateMutation", FIELDS, GeneratedVisitor)
15759 }
15760}
15761impl serde::Serialize for update_mutation::DispatcherUpdate {
15762 #[allow(deprecated)]
15763 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15764 where
15765 S: serde::Serializer,
15766 {
15767 use serde::ser::SerializeStruct;
15768 let mut len = 0;
15769 if self.actor_id != 0 {
15770 len += 1;
15771 }
15772 if self.dispatcher_id != 0 {
15773 len += 1;
15774 }
15775 if self.hash_mapping.is_some() {
15776 len += 1;
15777 }
15778 if !self.added_downstream_actor_id.is_empty() {
15779 len += 1;
15780 }
15781 if !self.removed_downstream_actor_id.is_empty() {
15782 len += 1;
15783 }
15784 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", len)?;
15785 if self.actor_id != 0 {
15786 struct_ser.serialize_field("actorId", &self.actor_id)?;
15787 }
15788 if self.dispatcher_id != 0 {
15789 #[allow(clippy::needless_borrow)]
15790 #[allow(clippy::needless_borrows_for_generic_args)]
15791 struct_ser.serialize_field("dispatcherId", ToString::to_string(&self.dispatcher_id).as_str())?;
15792 }
15793 if let Some(v) = self.hash_mapping.as_ref() {
15794 struct_ser.serialize_field("hashMapping", v)?;
15795 }
15796 if !self.added_downstream_actor_id.is_empty() {
15797 struct_ser.serialize_field("addedDownstreamActorId", &self.added_downstream_actor_id)?;
15798 }
15799 if !self.removed_downstream_actor_id.is_empty() {
15800 struct_ser.serialize_field("removedDownstreamActorId", &self.removed_downstream_actor_id)?;
15801 }
15802 struct_ser.end()
15803 }
15804}
15805impl<'de> serde::Deserialize<'de> for update_mutation::DispatcherUpdate {
15806 #[allow(deprecated)]
15807 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15808 where
15809 D: serde::Deserializer<'de>,
15810 {
15811 const FIELDS: &[&str] = &[
15812 "actor_id",
15813 "actorId",
15814 "dispatcher_id",
15815 "dispatcherId",
15816 "hash_mapping",
15817 "hashMapping",
15818 "added_downstream_actor_id",
15819 "addedDownstreamActorId",
15820 "removed_downstream_actor_id",
15821 "removedDownstreamActorId",
15822 ];
15823
15824 #[allow(clippy::enum_variant_names)]
15825 enum GeneratedField {
15826 ActorId,
15827 DispatcherId,
15828 HashMapping,
15829 AddedDownstreamActorId,
15830 RemovedDownstreamActorId,
15831 }
15832 impl<'de> serde::Deserialize<'de> for GeneratedField {
15833 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15834 where
15835 D: serde::Deserializer<'de>,
15836 {
15837 struct GeneratedVisitor;
15838
15839 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15840 type Value = GeneratedField;
15841
15842 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15843 write!(formatter, "expected one of: {:?}", &FIELDS)
15844 }
15845
15846 #[allow(unused_variables)]
15847 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15848 where
15849 E: serde::de::Error,
15850 {
15851 match value {
15852 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
15853 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
15854 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
15855 "addedDownstreamActorId" | "added_downstream_actor_id" => Ok(GeneratedField::AddedDownstreamActorId),
15856 "removedDownstreamActorId" | "removed_downstream_actor_id" => Ok(GeneratedField::RemovedDownstreamActorId),
15857 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15858 }
15859 }
15860 }
15861 deserializer.deserialize_identifier(GeneratedVisitor)
15862 }
15863 }
15864 struct GeneratedVisitor;
15865 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15866 type Value = update_mutation::DispatcherUpdate;
15867
15868 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15869 formatter.write_str("struct stream_plan.UpdateMutation.DispatcherUpdate")
15870 }
15871
15872 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::DispatcherUpdate, V::Error>
15873 where
15874 V: serde::de::MapAccess<'de>,
15875 {
15876 let mut actor_id__ = None;
15877 let mut dispatcher_id__ = None;
15878 let mut hash_mapping__ = None;
15879 let mut added_downstream_actor_id__ = None;
15880 let mut removed_downstream_actor_id__ = None;
15881 while let Some(k) = map_.next_key()? {
15882 match k {
15883 GeneratedField::ActorId => {
15884 if actor_id__.is_some() {
15885 return Err(serde::de::Error::duplicate_field("actorId"));
15886 }
15887 actor_id__ =
15888 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15889 ;
15890 }
15891 GeneratedField::DispatcherId => {
15892 if dispatcher_id__.is_some() {
15893 return Err(serde::de::Error::duplicate_field("dispatcherId"));
15894 }
15895 dispatcher_id__ =
15896 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15897 ;
15898 }
15899 GeneratedField::HashMapping => {
15900 if hash_mapping__.is_some() {
15901 return Err(serde::de::Error::duplicate_field("hashMapping"));
15902 }
15903 hash_mapping__ = map_.next_value()?;
15904 }
15905 GeneratedField::AddedDownstreamActorId => {
15906 if added_downstream_actor_id__.is_some() {
15907 return Err(serde::de::Error::duplicate_field("addedDownstreamActorId"));
15908 }
15909 added_downstream_actor_id__ =
15910 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15911 .into_iter().map(|x| x.0).collect())
15912 ;
15913 }
15914 GeneratedField::RemovedDownstreamActorId => {
15915 if removed_downstream_actor_id__.is_some() {
15916 return Err(serde::de::Error::duplicate_field("removedDownstreamActorId"));
15917 }
15918 removed_downstream_actor_id__ =
15919 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15920 .into_iter().map(|x| x.0).collect())
15921 ;
15922 }
15923 }
15924 }
15925 Ok(update_mutation::DispatcherUpdate {
15926 actor_id: actor_id__.unwrap_or_default(),
15927 dispatcher_id: dispatcher_id__.unwrap_or_default(),
15928 hash_mapping: hash_mapping__,
15929 added_downstream_actor_id: added_downstream_actor_id__.unwrap_or_default(),
15930 removed_downstream_actor_id: removed_downstream_actor_id__.unwrap_or_default(),
15931 })
15932 }
15933 }
15934 deserializer.deserialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", FIELDS, GeneratedVisitor)
15935 }
15936}
15937impl serde::Serialize for update_mutation::MergeUpdate {
15938 #[allow(deprecated)]
15939 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15940 where
15941 S: serde::Serializer,
15942 {
15943 use serde::ser::SerializeStruct;
15944 let mut len = 0;
15945 if self.actor_id != 0 {
15946 len += 1;
15947 }
15948 if self.upstream_fragment_id != 0 {
15949 len += 1;
15950 }
15951 if self.new_upstream_fragment_id.is_some() {
15952 len += 1;
15953 }
15954 if !self.added_upstream_actors.is_empty() {
15955 len += 1;
15956 }
15957 if !self.removed_upstream_actor_id.is_empty() {
15958 len += 1;
15959 }
15960 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.MergeUpdate", len)?;
15961 if self.actor_id != 0 {
15962 struct_ser.serialize_field("actorId", &self.actor_id)?;
15963 }
15964 if self.upstream_fragment_id != 0 {
15965 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
15966 }
15967 if let Some(v) = self.new_upstream_fragment_id.as_ref() {
15968 struct_ser.serialize_field("newUpstreamFragmentId", v)?;
15969 }
15970 if !self.added_upstream_actors.is_empty() {
15971 struct_ser.serialize_field("addedUpstreamActors", &self.added_upstream_actors)?;
15972 }
15973 if !self.removed_upstream_actor_id.is_empty() {
15974 struct_ser.serialize_field("removedUpstreamActorId", &self.removed_upstream_actor_id)?;
15975 }
15976 struct_ser.end()
15977 }
15978}
15979impl<'de> serde::Deserialize<'de> for update_mutation::MergeUpdate {
15980 #[allow(deprecated)]
15981 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15982 where
15983 D: serde::Deserializer<'de>,
15984 {
15985 const FIELDS: &[&str] = &[
15986 "actor_id",
15987 "actorId",
15988 "upstream_fragment_id",
15989 "upstreamFragmentId",
15990 "new_upstream_fragment_id",
15991 "newUpstreamFragmentId",
15992 "added_upstream_actors",
15993 "addedUpstreamActors",
15994 "removed_upstream_actor_id",
15995 "removedUpstreamActorId",
15996 ];
15997
15998 #[allow(clippy::enum_variant_names)]
15999 enum GeneratedField {
16000 ActorId,
16001 UpstreamFragmentId,
16002 NewUpstreamFragmentId,
16003 AddedUpstreamActors,
16004 RemovedUpstreamActorId,
16005 }
16006 impl<'de> serde::Deserialize<'de> for GeneratedField {
16007 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16008 where
16009 D: serde::Deserializer<'de>,
16010 {
16011 struct GeneratedVisitor;
16012
16013 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16014 type Value = GeneratedField;
16015
16016 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16017 write!(formatter, "expected one of: {:?}", &FIELDS)
16018 }
16019
16020 #[allow(unused_variables)]
16021 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16022 where
16023 E: serde::de::Error,
16024 {
16025 match value {
16026 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
16027 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
16028 "newUpstreamFragmentId" | "new_upstream_fragment_id" => Ok(GeneratedField::NewUpstreamFragmentId),
16029 "addedUpstreamActors" | "added_upstream_actors" => Ok(GeneratedField::AddedUpstreamActors),
16030 "removedUpstreamActorId" | "removed_upstream_actor_id" => Ok(GeneratedField::RemovedUpstreamActorId),
16031 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16032 }
16033 }
16034 }
16035 deserializer.deserialize_identifier(GeneratedVisitor)
16036 }
16037 }
16038 struct GeneratedVisitor;
16039 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16040 type Value = update_mutation::MergeUpdate;
16041
16042 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16043 formatter.write_str("struct stream_plan.UpdateMutation.MergeUpdate")
16044 }
16045
16046 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::MergeUpdate, V::Error>
16047 where
16048 V: serde::de::MapAccess<'de>,
16049 {
16050 let mut actor_id__ = None;
16051 let mut upstream_fragment_id__ = None;
16052 let mut new_upstream_fragment_id__ = None;
16053 let mut added_upstream_actors__ = None;
16054 let mut removed_upstream_actor_id__ = None;
16055 while let Some(k) = map_.next_key()? {
16056 match k {
16057 GeneratedField::ActorId => {
16058 if actor_id__.is_some() {
16059 return Err(serde::de::Error::duplicate_field("actorId"));
16060 }
16061 actor_id__ =
16062 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16063 ;
16064 }
16065 GeneratedField::UpstreamFragmentId => {
16066 if upstream_fragment_id__.is_some() {
16067 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
16068 }
16069 upstream_fragment_id__ =
16070 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16071 ;
16072 }
16073 GeneratedField::NewUpstreamFragmentId => {
16074 if new_upstream_fragment_id__.is_some() {
16075 return Err(serde::de::Error::duplicate_field("newUpstreamFragmentId"));
16076 }
16077 new_upstream_fragment_id__ =
16078 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16079 ;
16080 }
16081 GeneratedField::AddedUpstreamActors => {
16082 if added_upstream_actors__.is_some() {
16083 return Err(serde::de::Error::duplicate_field("addedUpstreamActors"));
16084 }
16085 added_upstream_actors__ = Some(map_.next_value()?);
16086 }
16087 GeneratedField::RemovedUpstreamActorId => {
16088 if removed_upstream_actor_id__.is_some() {
16089 return Err(serde::de::Error::duplicate_field("removedUpstreamActorId"));
16090 }
16091 removed_upstream_actor_id__ =
16092 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16093 .into_iter().map(|x| x.0).collect())
16094 ;
16095 }
16096 }
16097 }
16098 Ok(update_mutation::MergeUpdate {
16099 actor_id: actor_id__.unwrap_or_default(),
16100 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
16101 new_upstream_fragment_id: new_upstream_fragment_id__,
16102 added_upstream_actors: added_upstream_actors__.unwrap_or_default(),
16103 removed_upstream_actor_id: removed_upstream_actor_id__.unwrap_or_default(),
16104 })
16105 }
16106 }
16107 deserializer.deserialize_struct("stream_plan.UpdateMutation.MergeUpdate", FIELDS, GeneratedVisitor)
16108 }
16109}
16110impl serde::Serialize for UpstreamSinkInfo {
16111 #[allow(deprecated)]
16112 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16113 where
16114 S: serde::Serializer,
16115 {
16116 use serde::ser::SerializeStruct;
16117 let mut len = 0;
16118 if self.upstream_fragment_id != 0 {
16119 len += 1;
16120 }
16121 if !self.sink_output_schema.is_empty() {
16122 len += 1;
16123 }
16124 if !self.project_exprs.is_empty() {
16125 len += 1;
16126 }
16127 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkInfo", len)?;
16128 if self.upstream_fragment_id != 0 {
16129 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
16130 }
16131 if !self.sink_output_schema.is_empty() {
16132 struct_ser.serialize_field("sinkOutputSchema", &self.sink_output_schema)?;
16133 }
16134 if !self.project_exprs.is_empty() {
16135 struct_ser.serialize_field("projectExprs", &self.project_exprs)?;
16136 }
16137 struct_ser.end()
16138 }
16139}
16140impl<'de> serde::Deserialize<'de> for UpstreamSinkInfo {
16141 #[allow(deprecated)]
16142 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16143 where
16144 D: serde::Deserializer<'de>,
16145 {
16146 const FIELDS: &[&str] = &[
16147 "upstream_fragment_id",
16148 "upstreamFragmentId",
16149 "sink_output_schema",
16150 "sinkOutputSchema",
16151 "project_exprs",
16152 "projectExprs",
16153 ];
16154
16155 #[allow(clippy::enum_variant_names)]
16156 enum GeneratedField {
16157 UpstreamFragmentId,
16158 SinkOutputSchema,
16159 ProjectExprs,
16160 }
16161 impl<'de> serde::Deserialize<'de> for GeneratedField {
16162 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16163 where
16164 D: serde::Deserializer<'de>,
16165 {
16166 struct GeneratedVisitor;
16167
16168 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16169 type Value = GeneratedField;
16170
16171 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16172 write!(formatter, "expected one of: {:?}", &FIELDS)
16173 }
16174
16175 #[allow(unused_variables)]
16176 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16177 where
16178 E: serde::de::Error,
16179 {
16180 match value {
16181 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
16182 "sinkOutputSchema" | "sink_output_schema" => Ok(GeneratedField::SinkOutputSchema),
16183 "projectExprs" | "project_exprs" => Ok(GeneratedField::ProjectExprs),
16184 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16185 }
16186 }
16187 }
16188 deserializer.deserialize_identifier(GeneratedVisitor)
16189 }
16190 }
16191 struct GeneratedVisitor;
16192 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16193 type Value = UpstreamSinkInfo;
16194
16195 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16196 formatter.write_str("struct stream_plan.UpstreamSinkInfo")
16197 }
16198
16199 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkInfo, V::Error>
16200 where
16201 V: serde::de::MapAccess<'de>,
16202 {
16203 let mut upstream_fragment_id__ = None;
16204 let mut sink_output_schema__ = None;
16205 let mut project_exprs__ = None;
16206 while let Some(k) = map_.next_key()? {
16207 match k {
16208 GeneratedField::UpstreamFragmentId => {
16209 if upstream_fragment_id__.is_some() {
16210 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
16211 }
16212 upstream_fragment_id__ =
16213 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16214 ;
16215 }
16216 GeneratedField::SinkOutputSchema => {
16217 if sink_output_schema__.is_some() {
16218 return Err(serde::de::Error::duplicate_field("sinkOutputSchema"));
16219 }
16220 sink_output_schema__ = Some(map_.next_value()?);
16221 }
16222 GeneratedField::ProjectExprs => {
16223 if project_exprs__.is_some() {
16224 return Err(serde::de::Error::duplicate_field("projectExprs"));
16225 }
16226 project_exprs__ = Some(map_.next_value()?);
16227 }
16228 }
16229 }
16230 Ok(UpstreamSinkInfo {
16231 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
16232 sink_output_schema: sink_output_schema__.unwrap_or_default(),
16233 project_exprs: project_exprs__.unwrap_or_default(),
16234 })
16235 }
16236 }
16237 deserializer.deserialize_struct("stream_plan.UpstreamSinkInfo", FIELDS, GeneratedVisitor)
16238 }
16239}
16240impl serde::Serialize for UpstreamSinkUnionNode {
16241 #[allow(deprecated)]
16242 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16243 where
16244 S: serde::Serializer,
16245 {
16246 use serde::ser::SerializeStruct;
16247 let mut len = 0;
16248 if !self.init_upstreams.is_empty() {
16249 len += 1;
16250 }
16251 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkUnionNode", len)?;
16252 if !self.init_upstreams.is_empty() {
16253 struct_ser.serialize_field("initUpstreams", &self.init_upstreams)?;
16254 }
16255 struct_ser.end()
16256 }
16257}
16258impl<'de> serde::Deserialize<'de> for UpstreamSinkUnionNode {
16259 #[allow(deprecated)]
16260 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16261 where
16262 D: serde::Deserializer<'de>,
16263 {
16264 const FIELDS: &[&str] = &[
16265 "init_upstreams",
16266 "initUpstreams",
16267 ];
16268
16269 #[allow(clippy::enum_variant_names)]
16270 enum GeneratedField {
16271 InitUpstreams,
16272 }
16273 impl<'de> serde::Deserialize<'de> for GeneratedField {
16274 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16275 where
16276 D: serde::Deserializer<'de>,
16277 {
16278 struct GeneratedVisitor;
16279
16280 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16281 type Value = GeneratedField;
16282
16283 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16284 write!(formatter, "expected one of: {:?}", &FIELDS)
16285 }
16286
16287 #[allow(unused_variables)]
16288 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16289 where
16290 E: serde::de::Error,
16291 {
16292 match value {
16293 "initUpstreams" | "init_upstreams" => Ok(GeneratedField::InitUpstreams),
16294 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16295 }
16296 }
16297 }
16298 deserializer.deserialize_identifier(GeneratedVisitor)
16299 }
16300 }
16301 struct GeneratedVisitor;
16302 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16303 type Value = UpstreamSinkUnionNode;
16304
16305 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16306 formatter.write_str("struct stream_plan.UpstreamSinkUnionNode")
16307 }
16308
16309 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkUnionNode, V::Error>
16310 where
16311 V: serde::de::MapAccess<'de>,
16312 {
16313 let mut init_upstreams__ = None;
16314 while let Some(k) = map_.next_key()? {
16315 match k {
16316 GeneratedField::InitUpstreams => {
16317 if init_upstreams__.is_some() {
16318 return Err(serde::de::Error::duplicate_field("initUpstreams"));
16319 }
16320 init_upstreams__ = Some(map_.next_value()?);
16321 }
16322 }
16323 }
16324 Ok(UpstreamSinkUnionNode {
16325 init_upstreams: init_upstreams__.unwrap_or_default(),
16326 })
16327 }
16328 }
16329 deserializer.deserialize_struct("stream_plan.UpstreamSinkUnionNode", FIELDS, GeneratedVisitor)
16330 }
16331}
16332impl serde::Serialize for ValuesNode {
16333 #[allow(deprecated)]
16334 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16335 where
16336 S: serde::Serializer,
16337 {
16338 use serde::ser::SerializeStruct;
16339 let mut len = 0;
16340 if !self.tuples.is_empty() {
16341 len += 1;
16342 }
16343 if !self.fields.is_empty() {
16344 len += 1;
16345 }
16346 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode", len)?;
16347 if !self.tuples.is_empty() {
16348 struct_ser.serialize_field("tuples", &self.tuples)?;
16349 }
16350 if !self.fields.is_empty() {
16351 struct_ser.serialize_field("fields", &self.fields)?;
16352 }
16353 struct_ser.end()
16354 }
16355}
16356impl<'de> serde::Deserialize<'de> for ValuesNode {
16357 #[allow(deprecated)]
16358 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16359 where
16360 D: serde::Deserializer<'de>,
16361 {
16362 const FIELDS: &[&str] = &[
16363 "tuples",
16364 "fields",
16365 ];
16366
16367 #[allow(clippy::enum_variant_names)]
16368 enum GeneratedField {
16369 Tuples,
16370 Fields,
16371 }
16372 impl<'de> serde::Deserialize<'de> for GeneratedField {
16373 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16374 where
16375 D: serde::Deserializer<'de>,
16376 {
16377 struct GeneratedVisitor;
16378
16379 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16380 type Value = GeneratedField;
16381
16382 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16383 write!(formatter, "expected one of: {:?}", &FIELDS)
16384 }
16385
16386 #[allow(unused_variables)]
16387 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16388 where
16389 E: serde::de::Error,
16390 {
16391 match value {
16392 "tuples" => Ok(GeneratedField::Tuples),
16393 "fields" => Ok(GeneratedField::Fields),
16394 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16395 }
16396 }
16397 }
16398 deserializer.deserialize_identifier(GeneratedVisitor)
16399 }
16400 }
16401 struct GeneratedVisitor;
16402 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16403 type Value = ValuesNode;
16404
16405 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16406 formatter.write_str("struct stream_plan.ValuesNode")
16407 }
16408
16409 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
16410 where
16411 V: serde::de::MapAccess<'de>,
16412 {
16413 let mut tuples__ = None;
16414 let mut fields__ = None;
16415 while let Some(k) = map_.next_key()? {
16416 match k {
16417 GeneratedField::Tuples => {
16418 if tuples__.is_some() {
16419 return Err(serde::de::Error::duplicate_field("tuples"));
16420 }
16421 tuples__ = Some(map_.next_value()?);
16422 }
16423 GeneratedField::Fields => {
16424 if fields__.is_some() {
16425 return Err(serde::de::Error::duplicate_field("fields"));
16426 }
16427 fields__ = Some(map_.next_value()?);
16428 }
16429 }
16430 }
16431 Ok(ValuesNode {
16432 tuples: tuples__.unwrap_or_default(),
16433 fields: fields__.unwrap_or_default(),
16434 })
16435 }
16436 }
16437 deserializer.deserialize_struct("stream_plan.ValuesNode", FIELDS, GeneratedVisitor)
16438 }
16439}
16440impl serde::Serialize for values_node::ExprTuple {
16441 #[allow(deprecated)]
16442 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16443 where
16444 S: serde::Serializer,
16445 {
16446 use serde::ser::SerializeStruct;
16447 let mut len = 0;
16448 if !self.cells.is_empty() {
16449 len += 1;
16450 }
16451 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode.ExprTuple", len)?;
16452 if !self.cells.is_empty() {
16453 struct_ser.serialize_field("cells", &self.cells)?;
16454 }
16455 struct_ser.end()
16456 }
16457}
16458impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
16459 #[allow(deprecated)]
16460 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16461 where
16462 D: serde::Deserializer<'de>,
16463 {
16464 const FIELDS: &[&str] = &[
16465 "cells",
16466 ];
16467
16468 #[allow(clippy::enum_variant_names)]
16469 enum GeneratedField {
16470 Cells,
16471 }
16472 impl<'de> serde::Deserialize<'de> for GeneratedField {
16473 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16474 where
16475 D: serde::Deserializer<'de>,
16476 {
16477 struct GeneratedVisitor;
16478
16479 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16480 type Value = GeneratedField;
16481
16482 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16483 write!(formatter, "expected one of: {:?}", &FIELDS)
16484 }
16485
16486 #[allow(unused_variables)]
16487 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16488 where
16489 E: serde::de::Error,
16490 {
16491 match value {
16492 "cells" => Ok(GeneratedField::Cells),
16493 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16494 }
16495 }
16496 }
16497 deserializer.deserialize_identifier(GeneratedVisitor)
16498 }
16499 }
16500 struct GeneratedVisitor;
16501 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16502 type Value = values_node::ExprTuple;
16503
16504 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16505 formatter.write_str("struct stream_plan.ValuesNode.ExprTuple")
16506 }
16507
16508 fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
16509 where
16510 V: serde::de::MapAccess<'de>,
16511 {
16512 let mut cells__ = None;
16513 while let Some(k) = map_.next_key()? {
16514 match k {
16515 GeneratedField::Cells => {
16516 if cells__.is_some() {
16517 return Err(serde::de::Error::duplicate_field("cells"));
16518 }
16519 cells__ = Some(map_.next_value()?);
16520 }
16521 }
16522 }
16523 Ok(values_node::ExprTuple {
16524 cells: cells__.unwrap_or_default(),
16525 })
16526 }
16527 }
16528 deserializer.deserialize_struct("stream_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
16529 }
16530}
16531impl serde::Serialize for VectorIndexLookupJoinNode {
16532 #[allow(deprecated)]
16533 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16534 where
16535 S: serde::Serializer,
16536 {
16537 use serde::ser::SerializeStruct;
16538 let mut len = 0;
16539 if self.reader_desc.is_some() {
16540 len += 1;
16541 }
16542 if self.vector_column_idx != 0 {
16543 len += 1;
16544 }
16545 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexLookupJoinNode", len)?;
16546 if let Some(v) = self.reader_desc.as_ref() {
16547 struct_ser.serialize_field("readerDesc", v)?;
16548 }
16549 if self.vector_column_idx != 0 {
16550 struct_ser.serialize_field("vectorColumnIdx", &self.vector_column_idx)?;
16551 }
16552 struct_ser.end()
16553 }
16554}
16555impl<'de> serde::Deserialize<'de> for VectorIndexLookupJoinNode {
16556 #[allow(deprecated)]
16557 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16558 where
16559 D: serde::Deserializer<'de>,
16560 {
16561 const FIELDS: &[&str] = &[
16562 "reader_desc",
16563 "readerDesc",
16564 "vector_column_idx",
16565 "vectorColumnIdx",
16566 ];
16567
16568 #[allow(clippy::enum_variant_names)]
16569 enum GeneratedField {
16570 ReaderDesc,
16571 VectorColumnIdx,
16572 }
16573 impl<'de> serde::Deserialize<'de> for GeneratedField {
16574 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16575 where
16576 D: serde::Deserializer<'de>,
16577 {
16578 struct GeneratedVisitor;
16579
16580 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16581 type Value = GeneratedField;
16582
16583 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16584 write!(formatter, "expected one of: {:?}", &FIELDS)
16585 }
16586
16587 #[allow(unused_variables)]
16588 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16589 where
16590 E: serde::de::Error,
16591 {
16592 match value {
16593 "readerDesc" | "reader_desc" => Ok(GeneratedField::ReaderDesc),
16594 "vectorColumnIdx" | "vector_column_idx" => Ok(GeneratedField::VectorColumnIdx),
16595 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16596 }
16597 }
16598 }
16599 deserializer.deserialize_identifier(GeneratedVisitor)
16600 }
16601 }
16602 struct GeneratedVisitor;
16603 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16604 type Value = VectorIndexLookupJoinNode;
16605
16606 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16607 formatter.write_str("struct stream_plan.VectorIndexLookupJoinNode")
16608 }
16609
16610 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexLookupJoinNode, V::Error>
16611 where
16612 V: serde::de::MapAccess<'de>,
16613 {
16614 let mut reader_desc__ = None;
16615 let mut vector_column_idx__ = None;
16616 while let Some(k) = map_.next_key()? {
16617 match k {
16618 GeneratedField::ReaderDesc => {
16619 if reader_desc__.is_some() {
16620 return Err(serde::de::Error::duplicate_field("readerDesc"));
16621 }
16622 reader_desc__ = map_.next_value()?;
16623 }
16624 GeneratedField::VectorColumnIdx => {
16625 if vector_column_idx__.is_some() {
16626 return Err(serde::de::Error::duplicate_field("vectorColumnIdx"));
16627 }
16628 vector_column_idx__ =
16629 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16630 ;
16631 }
16632 }
16633 }
16634 Ok(VectorIndexLookupJoinNode {
16635 reader_desc: reader_desc__,
16636 vector_column_idx: vector_column_idx__.unwrap_or_default(),
16637 })
16638 }
16639 }
16640 deserializer.deserialize_struct("stream_plan.VectorIndexLookupJoinNode", FIELDS, GeneratedVisitor)
16641 }
16642}
16643impl serde::Serialize for VectorIndexWriteNode {
16644 #[allow(deprecated)]
16645 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16646 where
16647 S: serde::Serializer,
16648 {
16649 use serde::ser::SerializeStruct;
16650 let mut len = 0;
16651 if self.table.is_some() {
16652 len += 1;
16653 }
16654 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexWriteNode", len)?;
16655 if let Some(v) = self.table.as_ref() {
16656 struct_ser.serialize_field("table", v)?;
16657 }
16658 struct_ser.end()
16659 }
16660}
16661impl<'de> serde::Deserialize<'de> for VectorIndexWriteNode {
16662 #[allow(deprecated)]
16663 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16664 where
16665 D: serde::Deserializer<'de>,
16666 {
16667 const FIELDS: &[&str] = &[
16668 "table",
16669 ];
16670
16671 #[allow(clippy::enum_variant_names)]
16672 enum GeneratedField {
16673 Table,
16674 }
16675 impl<'de> serde::Deserialize<'de> for GeneratedField {
16676 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16677 where
16678 D: serde::Deserializer<'de>,
16679 {
16680 struct GeneratedVisitor;
16681
16682 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16683 type Value = GeneratedField;
16684
16685 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16686 write!(formatter, "expected one of: {:?}", &FIELDS)
16687 }
16688
16689 #[allow(unused_variables)]
16690 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16691 where
16692 E: serde::de::Error,
16693 {
16694 match value {
16695 "table" => Ok(GeneratedField::Table),
16696 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16697 }
16698 }
16699 }
16700 deserializer.deserialize_identifier(GeneratedVisitor)
16701 }
16702 }
16703 struct GeneratedVisitor;
16704 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16705 type Value = VectorIndexWriteNode;
16706
16707 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16708 formatter.write_str("struct stream_plan.VectorIndexWriteNode")
16709 }
16710
16711 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexWriteNode, V::Error>
16712 where
16713 V: serde::de::MapAccess<'de>,
16714 {
16715 let mut table__ = None;
16716 while let Some(k) = map_.next_key()? {
16717 match k {
16718 GeneratedField::Table => {
16719 if table__.is_some() {
16720 return Err(serde::de::Error::duplicate_field("table"));
16721 }
16722 table__ = map_.next_value()?;
16723 }
16724 }
16725 }
16726 Ok(VectorIndexWriteNode {
16727 table: table__,
16728 })
16729 }
16730 }
16731 deserializer.deserialize_struct("stream_plan.VectorIndexWriteNode", FIELDS, GeneratedVisitor)
16732 }
16733}
16734impl serde::Serialize for Watermark {
16735 #[allow(deprecated)]
16736 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16737 where
16738 S: serde::Serializer,
16739 {
16740 use serde::ser::SerializeStruct;
16741 let mut len = 0;
16742 if self.column.is_some() {
16743 len += 1;
16744 }
16745 if self.val.is_some() {
16746 len += 1;
16747 }
16748 let mut struct_ser = serializer.serialize_struct("stream_plan.Watermark", len)?;
16749 if let Some(v) = self.column.as_ref() {
16750 struct_ser.serialize_field("column", v)?;
16751 }
16752 if let Some(v) = self.val.as_ref() {
16753 struct_ser.serialize_field("val", v)?;
16754 }
16755 struct_ser.end()
16756 }
16757}
16758impl<'de> serde::Deserialize<'de> for Watermark {
16759 #[allow(deprecated)]
16760 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16761 where
16762 D: serde::Deserializer<'de>,
16763 {
16764 const FIELDS: &[&str] = &[
16765 "column",
16766 "val",
16767 ];
16768
16769 #[allow(clippy::enum_variant_names)]
16770 enum GeneratedField {
16771 Column,
16772 Val,
16773 }
16774 impl<'de> serde::Deserialize<'de> for GeneratedField {
16775 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16776 where
16777 D: serde::Deserializer<'de>,
16778 {
16779 struct GeneratedVisitor;
16780
16781 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16782 type Value = GeneratedField;
16783
16784 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16785 write!(formatter, "expected one of: {:?}", &FIELDS)
16786 }
16787
16788 #[allow(unused_variables)]
16789 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16790 where
16791 E: serde::de::Error,
16792 {
16793 match value {
16794 "column" => Ok(GeneratedField::Column),
16795 "val" => Ok(GeneratedField::Val),
16796 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16797 }
16798 }
16799 }
16800 deserializer.deserialize_identifier(GeneratedVisitor)
16801 }
16802 }
16803 struct GeneratedVisitor;
16804 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16805 type Value = Watermark;
16806
16807 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16808 formatter.write_str("struct stream_plan.Watermark")
16809 }
16810
16811 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Watermark, V::Error>
16812 where
16813 V: serde::de::MapAccess<'de>,
16814 {
16815 let mut column__ = None;
16816 let mut val__ = None;
16817 while let Some(k) = map_.next_key()? {
16818 match k {
16819 GeneratedField::Column => {
16820 if column__.is_some() {
16821 return Err(serde::de::Error::duplicate_field("column"));
16822 }
16823 column__ = map_.next_value()?;
16824 }
16825 GeneratedField::Val => {
16826 if val__.is_some() {
16827 return Err(serde::de::Error::duplicate_field("val"));
16828 }
16829 val__ = map_.next_value()?;
16830 }
16831 }
16832 }
16833 Ok(Watermark {
16834 column: column__,
16835 val: val__,
16836 })
16837 }
16838 }
16839 deserializer.deserialize_struct("stream_plan.Watermark", FIELDS, GeneratedVisitor)
16840 }
16841}
16842impl serde::Serialize for WatermarkFilterNode {
16843 #[allow(deprecated)]
16844 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16845 where
16846 S: serde::Serializer,
16847 {
16848 use serde::ser::SerializeStruct;
16849 let mut len = 0;
16850 if !self.watermark_descs.is_empty() {
16851 len += 1;
16852 }
16853 if !self.tables.is_empty() {
16854 len += 1;
16855 }
16856 let mut struct_ser = serializer.serialize_struct("stream_plan.WatermarkFilterNode", len)?;
16857 if !self.watermark_descs.is_empty() {
16858 struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
16859 }
16860 if !self.tables.is_empty() {
16861 struct_ser.serialize_field("tables", &self.tables)?;
16862 }
16863 struct_ser.end()
16864 }
16865}
16866impl<'de> serde::Deserialize<'de> for WatermarkFilterNode {
16867 #[allow(deprecated)]
16868 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16869 where
16870 D: serde::Deserializer<'de>,
16871 {
16872 const FIELDS: &[&str] = &[
16873 "watermark_descs",
16874 "watermarkDescs",
16875 "tables",
16876 ];
16877
16878 #[allow(clippy::enum_variant_names)]
16879 enum GeneratedField {
16880 WatermarkDescs,
16881 Tables,
16882 }
16883 impl<'de> serde::Deserialize<'de> for GeneratedField {
16884 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16885 where
16886 D: serde::Deserializer<'de>,
16887 {
16888 struct GeneratedVisitor;
16889
16890 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16891 type Value = GeneratedField;
16892
16893 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16894 write!(formatter, "expected one of: {:?}", &FIELDS)
16895 }
16896
16897 #[allow(unused_variables)]
16898 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16899 where
16900 E: serde::de::Error,
16901 {
16902 match value {
16903 "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
16904 "tables" => Ok(GeneratedField::Tables),
16905 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16906 }
16907 }
16908 }
16909 deserializer.deserialize_identifier(GeneratedVisitor)
16910 }
16911 }
16912 struct GeneratedVisitor;
16913 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16914 type Value = WatermarkFilterNode;
16915
16916 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16917 formatter.write_str("struct stream_plan.WatermarkFilterNode")
16918 }
16919
16920 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkFilterNode, V::Error>
16921 where
16922 V: serde::de::MapAccess<'de>,
16923 {
16924 let mut watermark_descs__ = None;
16925 let mut tables__ = None;
16926 while let Some(k) = map_.next_key()? {
16927 match k {
16928 GeneratedField::WatermarkDescs => {
16929 if watermark_descs__.is_some() {
16930 return Err(serde::de::Error::duplicate_field("watermarkDescs"));
16931 }
16932 watermark_descs__ = Some(map_.next_value()?);
16933 }
16934 GeneratedField::Tables => {
16935 if tables__.is_some() {
16936 return Err(serde::de::Error::duplicate_field("tables"));
16937 }
16938 tables__ = Some(map_.next_value()?);
16939 }
16940 }
16941 }
16942 Ok(WatermarkFilterNode {
16943 watermark_descs: watermark_descs__.unwrap_or_default(),
16944 tables: tables__.unwrap_or_default(),
16945 })
16946 }
16947 }
16948 deserializer.deserialize_struct("stream_plan.WatermarkFilterNode", FIELDS, GeneratedVisitor)
16949 }
16950}