1#![allow(clippy::useless_conversion)]
2use crate::stream_plan::*;
3impl serde::Serialize for ActorMapping {
4 #[allow(deprecated)]
5 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6 where
7 S: serde::Serializer,
8 {
9 use serde::ser::SerializeStruct;
10 let mut len = 0;
11 if !self.original_indices.is_empty() {
12 len += 1;
13 }
14 if !self.data.is_empty() {
15 len += 1;
16 }
17 let mut struct_ser = serializer.serialize_struct("stream_plan.ActorMapping", len)?;
18 if !self.original_indices.is_empty() {
19 struct_ser.serialize_field("originalIndices", &self.original_indices)?;
20 }
21 if !self.data.is_empty() {
22 struct_ser.serialize_field("data", &self.data)?;
23 }
24 struct_ser.end()
25 }
26}
27impl<'de> serde::Deserialize<'de> for ActorMapping {
28 #[allow(deprecated)]
29 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
30 where
31 D: serde::Deserializer<'de>,
32 {
33 const FIELDS: &[&str] = &[
34 "original_indices",
35 "originalIndices",
36 "data",
37 ];
38
39 #[allow(clippy::enum_variant_names)]
40 enum GeneratedField {
41 OriginalIndices,
42 Data,
43 }
44 impl<'de> serde::Deserialize<'de> for GeneratedField {
45 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
46 where
47 D: serde::Deserializer<'de>,
48 {
49 struct GeneratedVisitor;
50
51 impl serde::de::Visitor<'_> for GeneratedVisitor {
52 type Value = GeneratedField;
53
54 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
55 write!(formatter, "expected one of: {:?}", &FIELDS)
56 }
57
58 #[allow(unused_variables)]
59 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
60 where
61 E: serde::de::Error,
62 {
63 match value {
64 "originalIndices" | "original_indices" => Ok(GeneratedField::OriginalIndices),
65 "data" => Ok(GeneratedField::Data),
66 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
67 }
68 }
69 }
70 deserializer.deserialize_identifier(GeneratedVisitor)
71 }
72 }
73 struct GeneratedVisitor;
74 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
75 type Value = ActorMapping;
76
77 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
78 formatter.write_str("struct stream_plan.ActorMapping")
79 }
80
81 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorMapping, V::Error>
82 where
83 V: serde::de::MapAccess<'de>,
84 {
85 let mut original_indices__ = None;
86 let mut data__ = None;
87 while let Some(k) = map_.next_key()? {
88 match k {
89 GeneratedField::OriginalIndices => {
90 if original_indices__.is_some() {
91 return Err(serde::de::Error::duplicate_field("originalIndices"));
92 }
93 original_indices__ =
94 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
95 .into_iter().map(|x| x.0).collect())
96 ;
97 }
98 GeneratedField::Data => {
99 if data__.is_some() {
100 return Err(serde::de::Error::duplicate_field("data"));
101 }
102 data__ =
103 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
104 .into_iter().map(|x| x.0).collect())
105 ;
106 }
107 }
108 }
109 Ok(ActorMapping {
110 original_indices: original_indices__.unwrap_or_default(),
111 data: data__.unwrap_or_default(),
112 })
113 }
114 }
115 deserializer.deserialize_struct("stream_plan.ActorMapping", FIELDS, GeneratedVisitor)
116 }
117}
118impl serde::Serialize for AddMutation {
119 #[allow(deprecated)]
120 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
121 where
122 S: serde::Serializer,
123 {
124 use serde::ser::SerializeStruct;
125 let mut len = 0;
126 if !self.actor_dispatchers.is_empty() {
127 len += 1;
128 }
129 if !self.added_actors.is_empty() {
130 len += 1;
131 }
132 if !self.actor_splits.is_empty() {
133 len += 1;
134 }
135 if self.pause {
136 len += 1;
137 }
138 if !self.subscriptions_to_add.is_empty() {
139 len += 1;
140 }
141 if !self.backfill_nodes_to_pause.is_empty() {
142 len += 1;
143 }
144 if self.actor_cdc_table_snapshot_splits.is_some() {
145 len += 1;
146 }
147 if !self.new_upstream_sinks.is_empty() {
148 len += 1;
149 }
150 let mut struct_ser = serializer.serialize_struct("stream_plan.AddMutation", len)?;
151 if !self.actor_dispatchers.is_empty() {
152 struct_ser.serialize_field("actorDispatchers", &self.actor_dispatchers)?;
153 }
154 if !self.added_actors.is_empty() {
155 struct_ser.serialize_field("addedActors", &self.added_actors)?;
156 }
157 if !self.actor_splits.is_empty() {
158 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
159 }
160 if self.pause {
161 struct_ser.serialize_field("pause", &self.pause)?;
162 }
163 if !self.subscriptions_to_add.is_empty() {
164 struct_ser.serialize_field("subscriptionsToAdd", &self.subscriptions_to_add)?;
165 }
166 if !self.backfill_nodes_to_pause.is_empty() {
167 struct_ser.serialize_field("backfillNodesToPause", &self.backfill_nodes_to_pause)?;
168 }
169 if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
170 struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
171 }
172 if !self.new_upstream_sinks.is_empty() {
173 struct_ser.serialize_field("newUpstreamSinks", &self.new_upstream_sinks)?;
174 }
175 struct_ser.end()
176 }
177}
178impl<'de> serde::Deserialize<'de> for AddMutation {
179 #[allow(deprecated)]
180 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
181 where
182 D: serde::Deserializer<'de>,
183 {
184 const FIELDS: &[&str] = &[
185 "actor_dispatchers",
186 "actorDispatchers",
187 "added_actors",
188 "addedActors",
189 "actor_splits",
190 "actorSplits",
191 "pause",
192 "subscriptions_to_add",
193 "subscriptionsToAdd",
194 "backfill_nodes_to_pause",
195 "backfillNodesToPause",
196 "actor_cdc_table_snapshot_splits",
197 "actorCdcTableSnapshotSplits",
198 "new_upstream_sinks",
199 "newUpstreamSinks",
200 ];
201
202 #[allow(clippy::enum_variant_names)]
203 enum GeneratedField {
204 ActorDispatchers,
205 AddedActors,
206 ActorSplits,
207 Pause,
208 SubscriptionsToAdd,
209 BackfillNodesToPause,
210 ActorCdcTableSnapshotSplits,
211 NewUpstreamSinks,
212 }
213 impl<'de> serde::Deserialize<'de> for GeneratedField {
214 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
215 where
216 D: serde::Deserializer<'de>,
217 {
218 struct GeneratedVisitor;
219
220 impl serde::de::Visitor<'_> for GeneratedVisitor {
221 type Value = GeneratedField;
222
223 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
224 write!(formatter, "expected one of: {:?}", &FIELDS)
225 }
226
227 #[allow(unused_variables)]
228 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
229 where
230 E: serde::de::Error,
231 {
232 match value {
233 "actorDispatchers" | "actor_dispatchers" => Ok(GeneratedField::ActorDispatchers),
234 "addedActors" | "added_actors" => Ok(GeneratedField::AddedActors),
235 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
236 "pause" => Ok(GeneratedField::Pause),
237 "subscriptionsToAdd" | "subscriptions_to_add" => Ok(GeneratedField::SubscriptionsToAdd),
238 "backfillNodesToPause" | "backfill_nodes_to_pause" => Ok(GeneratedField::BackfillNodesToPause),
239 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
240 "newUpstreamSinks" | "new_upstream_sinks" => Ok(GeneratedField::NewUpstreamSinks),
241 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
242 }
243 }
244 }
245 deserializer.deserialize_identifier(GeneratedVisitor)
246 }
247 }
248 struct GeneratedVisitor;
249 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
250 type Value = AddMutation;
251
252 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
253 formatter.write_str("struct stream_plan.AddMutation")
254 }
255
256 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddMutation, V::Error>
257 where
258 V: serde::de::MapAccess<'de>,
259 {
260 let mut actor_dispatchers__ = None;
261 let mut added_actors__ = None;
262 let mut actor_splits__ = None;
263 let mut pause__ = None;
264 let mut subscriptions_to_add__ = None;
265 let mut backfill_nodes_to_pause__ = None;
266 let mut actor_cdc_table_snapshot_splits__ = None;
267 let mut new_upstream_sinks__ = None;
268 while let Some(k) = map_.next_key()? {
269 match k {
270 GeneratedField::ActorDispatchers => {
271 if actor_dispatchers__.is_some() {
272 return Err(serde::de::Error::duplicate_field("actorDispatchers"));
273 }
274 actor_dispatchers__ = Some(
275 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
276 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
277 );
278 }
279 GeneratedField::AddedActors => {
280 if added_actors__.is_some() {
281 return Err(serde::de::Error::duplicate_field("addedActors"));
282 }
283 added_actors__ =
284 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
285 .into_iter().map(|x| x.0).collect())
286 ;
287 }
288 GeneratedField::ActorSplits => {
289 if actor_splits__.is_some() {
290 return Err(serde::de::Error::duplicate_field("actorSplits"));
291 }
292 actor_splits__ = Some(
293 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
294 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
295 );
296 }
297 GeneratedField::Pause => {
298 if pause__.is_some() {
299 return Err(serde::de::Error::duplicate_field("pause"));
300 }
301 pause__ = Some(map_.next_value()?);
302 }
303 GeneratedField::SubscriptionsToAdd => {
304 if subscriptions_to_add__.is_some() {
305 return Err(serde::de::Error::duplicate_field("subscriptionsToAdd"));
306 }
307 subscriptions_to_add__ = Some(map_.next_value()?);
308 }
309 GeneratedField::BackfillNodesToPause => {
310 if backfill_nodes_to_pause__.is_some() {
311 return Err(serde::de::Error::duplicate_field("backfillNodesToPause"));
312 }
313 backfill_nodes_to_pause__ =
314 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
315 .into_iter().map(|x| x.0).collect())
316 ;
317 }
318 GeneratedField::ActorCdcTableSnapshotSplits => {
319 if actor_cdc_table_snapshot_splits__.is_some() {
320 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
321 }
322 actor_cdc_table_snapshot_splits__ = map_.next_value()?;
323 }
324 GeneratedField::NewUpstreamSinks => {
325 if new_upstream_sinks__.is_some() {
326 return Err(serde::de::Error::duplicate_field("newUpstreamSinks"));
327 }
328 new_upstream_sinks__ = Some(
329 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
330 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
331 );
332 }
333 }
334 }
335 Ok(AddMutation {
336 actor_dispatchers: actor_dispatchers__.unwrap_or_default(),
337 added_actors: added_actors__.unwrap_or_default(),
338 actor_splits: actor_splits__.unwrap_or_default(),
339 pause: pause__.unwrap_or_default(),
340 subscriptions_to_add: subscriptions_to_add__.unwrap_or_default(),
341 backfill_nodes_to_pause: backfill_nodes_to_pause__.unwrap_or_default(),
342 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
343 new_upstream_sinks: new_upstream_sinks__.unwrap_or_default(),
344 })
345 }
346 }
347 deserializer.deserialize_struct("stream_plan.AddMutation", FIELDS, GeneratedVisitor)
348 }
349}
350impl serde::Serialize for add_mutation::NewUpstreamSink {
351 #[allow(deprecated)]
352 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
353 where
354 S: serde::Serializer,
355 {
356 use serde::ser::SerializeStruct;
357 let mut len = 0;
358 if self.info.is_some() {
359 len += 1;
360 }
361 if !self.upstream_actors.is_empty() {
362 len += 1;
363 }
364 let mut struct_ser = serializer.serialize_struct("stream_plan.AddMutation.NewUpstreamSink", len)?;
365 if let Some(v) = self.info.as_ref() {
366 struct_ser.serialize_field("info", v)?;
367 }
368 if !self.upstream_actors.is_empty() {
369 struct_ser.serialize_field("upstreamActors", &self.upstream_actors)?;
370 }
371 struct_ser.end()
372 }
373}
374impl<'de> serde::Deserialize<'de> for add_mutation::NewUpstreamSink {
375 #[allow(deprecated)]
376 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
377 where
378 D: serde::Deserializer<'de>,
379 {
380 const FIELDS: &[&str] = &[
381 "info",
382 "upstream_actors",
383 "upstreamActors",
384 ];
385
386 #[allow(clippy::enum_variant_names)]
387 enum GeneratedField {
388 Info,
389 UpstreamActors,
390 }
391 impl<'de> serde::Deserialize<'de> for GeneratedField {
392 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
393 where
394 D: serde::Deserializer<'de>,
395 {
396 struct GeneratedVisitor;
397
398 impl serde::de::Visitor<'_> for GeneratedVisitor {
399 type Value = GeneratedField;
400
401 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
402 write!(formatter, "expected one of: {:?}", &FIELDS)
403 }
404
405 #[allow(unused_variables)]
406 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
407 where
408 E: serde::de::Error,
409 {
410 match value {
411 "info" => Ok(GeneratedField::Info),
412 "upstreamActors" | "upstream_actors" => Ok(GeneratedField::UpstreamActors),
413 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
414 }
415 }
416 }
417 deserializer.deserialize_identifier(GeneratedVisitor)
418 }
419 }
420 struct GeneratedVisitor;
421 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
422 type Value = add_mutation::NewUpstreamSink;
423
424 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
425 formatter.write_str("struct stream_plan.AddMutation.NewUpstreamSink")
426 }
427
428 fn visit_map<V>(self, mut map_: V) -> std::result::Result<add_mutation::NewUpstreamSink, V::Error>
429 where
430 V: serde::de::MapAccess<'de>,
431 {
432 let mut info__ = None;
433 let mut upstream_actors__ = None;
434 while let Some(k) = map_.next_key()? {
435 match k {
436 GeneratedField::Info => {
437 if info__.is_some() {
438 return Err(serde::de::Error::duplicate_field("info"));
439 }
440 info__ = map_.next_value()?;
441 }
442 GeneratedField::UpstreamActors => {
443 if upstream_actors__.is_some() {
444 return Err(serde::de::Error::duplicate_field("upstreamActors"));
445 }
446 upstream_actors__ = Some(map_.next_value()?);
447 }
448 }
449 }
450 Ok(add_mutation::NewUpstreamSink {
451 info: info__,
452 upstream_actors: upstream_actors__.unwrap_or_default(),
453 })
454 }
455 }
456 deserializer.deserialize_struct("stream_plan.AddMutation.NewUpstreamSink", FIELDS, GeneratedVisitor)
457 }
458}
459impl serde::Serialize for AggCallState {
460 #[allow(deprecated)]
461 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
462 where
463 S: serde::Serializer,
464 {
465 use serde::ser::SerializeStruct;
466 let mut len = 0;
467 if self.inner.is_some() {
468 len += 1;
469 }
470 let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState", len)?;
471 if let Some(v) = self.inner.as_ref() {
472 match v {
473 agg_call_state::Inner::ValueState(v) => {
474 struct_ser.serialize_field("valueState", v)?;
475 }
476 agg_call_state::Inner::MaterializedInputState(v) => {
477 struct_ser.serialize_field("materializedInputState", v)?;
478 }
479 }
480 }
481 struct_ser.end()
482 }
483}
484impl<'de> serde::Deserialize<'de> for AggCallState {
485 #[allow(deprecated)]
486 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
487 where
488 D: serde::Deserializer<'de>,
489 {
490 const FIELDS: &[&str] = &[
491 "value_state",
492 "valueState",
493 "materialized_input_state",
494 "materializedInputState",
495 ];
496
497 #[allow(clippy::enum_variant_names)]
498 enum GeneratedField {
499 ValueState,
500 MaterializedInputState,
501 }
502 impl<'de> serde::Deserialize<'de> for GeneratedField {
503 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
504 where
505 D: serde::Deserializer<'de>,
506 {
507 struct GeneratedVisitor;
508
509 impl serde::de::Visitor<'_> for GeneratedVisitor {
510 type Value = GeneratedField;
511
512 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
513 write!(formatter, "expected one of: {:?}", &FIELDS)
514 }
515
516 #[allow(unused_variables)]
517 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
518 where
519 E: serde::de::Error,
520 {
521 match value {
522 "valueState" | "value_state" => Ok(GeneratedField::ValueState),
523 "materializedInputState" | "materialized_input_state" => Ok(GeneratedField::MaterializedInputState),
524 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
525 }
526 }
527 }
528 deserializer.deserialize_identifier(GeneratedVisitor)
529 }
530 }
531 struct GeneratedVisitor;
532 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
533 type Value = AggCallState;
534
535 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
536 formatter.write_str("struct stream_plan.AggCallState")
537 }
538
539 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AggCallState, V::Error>
540 where
541 V: serde::de::MapAccess<'de>,
542 {
543 let mut inner__ = None;
544 while let Some(k) = map_.next_key()? {
545 match k {
546 GeneratedField::ValueState => {
547 if inner__.is_some() {
548 return Err(serde::de::Error::duplicate_field("valueState"));
549 }
550 inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::ValueState)
551;
552 }
553 GeneratedField::MaterializedInputState => {
554 if inner__.is_some() {
555 return Err(serde::de::Error::duplicate_field("materializedInputState"));
556 }
557 inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::MaterializedInputState)
558;
559 }
560 }
561 }
562 Ok(AggCallState {
563 inner: inner__,
564 })
565 }
566 }
567 deserializer.deserialize_struct("stream_plan.AggCallState", FIELDS, GeneratedVisitor)
568 }
569}
570impl serde::Serialize for agg_call_state::MaterializedInputState {
571 #[allow(deprecated)]
572 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
573 where
574 S: serde::Serializer,
575 {
576 use serde::ser::SerializeStruct;
577 let mut len = 0;
578 if self.table.is_some() {
579 len += 1;
580 }
581 if !self.included_upstream_indices.is_empty() {
582 len += 1;
583 }
584 if !self.table_value_indices.is_empty() {
585 len += 1;
586 }
587 if !self.order_columns.is_empty() {
588 len += 1;
589 }
590 let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState.MaterializedInputState", len)?;
591 if let Some(v) = self.table.as_ref() {
592 struct_ser.serialize_field("table", v)?;
593 }
594 if !self.included_upstream_indices.is_empty() {
595 struct_ser.serialize_field("includedUpstreamIndices", &self.included_upstream_indices)?;
596 }
597 if !self.table_value_indices.is_empty() {
598 struct_ser.serialize_field("tableValueIndices", &self.table_value_indices)?;
599 }
600 if !self.order_columns.is_empty() {
601 struct_ser.serialize_field("orderColumns", &self.order_columns)?;
602 }
603 struct_ser.end()
604 }
605}
606impl<'de> serde::Deserialize<'de> for agg_call_state::MaterializedInputState {
607 #[allow(deprecated)]
608 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
609 where
610 D: serde::Deserializer<'de>,
611 {
612 const FIELDS: &[&str] = &[
613 "table",
614 "included_upstream_indices",
615 "includedUpstreamIndices",
616 "table_value_indices",
617 "tableValueIndices",
618 "order_columns",
619 "orderColumns",
620 ];
621
622 #[allow(clippy::enum_variant_names)]
623 enum GeneratedField {
624 Table,
625 IncludedUpstreamIndices,
626 TableValueIndices,
627 OrderColumns,
628 }
629 impl<'de> serde::Deserialize<'de> for GeneratedField {
630 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
631 where
632 D: serde::Deserializer<'de>,
633 {
634 struct GeneratedVisitor;
635
636 impl serde::de::Visitor<'_> for GeneratedVisitor {
637 type Value = GeneratedField;
638
639 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
640 write!(formatter, "expected one of: {:?}", &FIELDS)
641 }
642
643 #[allow(unused_variables)]
644 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
645 where
646 E: serde::de::Error,
647 {
648 match value {
649 "table" => Ok(GeneratedField::Table),
650 "includedUpstreamIndices" | "included_upstream_indices" => Ok(GeneratedField::IncludedUpstreamIndices),
651 "tableValueIndices" | "table_value_indices" => Ok(GeneratedField::TableValueIndices),
652 "orderColumns" | "order_columns" => Ok(GeneratedField::OrderColumns),
653 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
654 }
655 }
656 }
657 deserializer.deserialize_identifier(GeneratedVisitor)
658 }
659 }
660 struct GeneratedVisitor;
661 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
662 type Value = agg_call_state::MaterializedInputState;
663
664 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
665 formatter.write_str("struct stream_plan.AggCallState.MaterializedInputState")
666 }
667
668 fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::MaterializedInputState, V::Error>
669 where
670 V: serde::de::MapAccess<'de>,
671 {
672 let mut table__ = None;
673 let mut included_upstream_indices__ = None;
674 let mut table_value_indices__ = None;
675 let mut order_columns__ = None;
676 while let Some(k) = map_.next_key()? {
677 match k {
678 GeneratedField::Table => {
679 if table__.is_some() {
680 return Err(serde::de::Error::duplicate_field("table"));
681 }
682 table__ = map_.next_value()?;
683 }
684 GeneratedField::IncludedUpstreamIndices => {
685 if included_upstream_indices__.is_some() {
686 return Err(serde::de::Error::duplicate_field("includedUpstreamIndices"));
687 }
688 included_upstream_indices__ =
689 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
690 .into_iter().map(|x| x.0).collect())
691 ;
692 }
693 GeneratedField::TableValueIndices => {
694 if table_value_indices__.is_some() {
695 return Err(serde::de::Error::duplicate_field("tableValueIndices"));
696 }
697 table_value_indices__ =
698 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
699 .into_iter().map(|x| x.0).collect())
700 ;
701 }
702 GeneratedField::OrderColumns => {
703 if order_columns__.is_some() {
704 return Err(serde::de::Error::duplicate_field("orderColumns"));
705 }
706 order_columns__ = Some(map_.next_value()?);
707 }
708 }
709 }
710 Ok(agg_call_state::MaterializedInputState {
711 table: table__,
712 included_upstream_indices: included_upstream_indices__.unwrap_or_default(),
713 table_value_indices: table_value_indices__.unwrap_or_default(),
714 order_columns: order_columns__.unwrap_or_default(),
715 })
716 }
717 }
718 deserializer.deserialize_struct("stream_plan.AggCallState.MaterializedInputState", FIELDS, GeneratedVisitor)
719 }
720}
721impl serde::Serialize for agg_call_state::ValueState {
722 #[allow(deprecated)]
723 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
724 where
725 S: serde::Serializer,
726 {
727 use serde::ser::SerializeStruct;
728 let len = 0;
729 let struct_ser = serializer.serialize_struct("stream_plan.AggCallState.ValueState", len)?;
730 struct_ser.end()
731 }
732}
733impl<'de> serde::Deserialize<'de> for agg_call_state::ValueState {
734 #[allow(deprecated)]
735 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
736 where
737 D: serde::Deserializer<'de>,
738 {
739 const FIELDS: &[&str] = &[
740 ];
741
742 #[allow(clippy::enum_variant_names)]
743 enum GeneratedField {
744 }
745 impl<'de> serde::Deserialize<'de> for GeneratedField {
746 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
747 where
748 D: serde::Deserializer<'de>,
749 {
750 struct GeneratedVisitor;
751
752 impl serde::de::Visitor<'_> for GeneratedVisitor {
753 type Value = GeneratedField;
754
755 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
756 write!(formatter, "expected one of: {:?}", &FIELDS)
757 }
758
759 #[allow(unused_variables)]
760 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
761 where
762 E: serde::de::Error,
763 {
764 Err(serde::de::Error::unknown_field(value, FIELDS))
765 }
766 }
767 deserializer.deserialize_identifier(GeneratedVisitor)
768 }
769 }
770 struct GeneratedVisitor;
771 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
772 type Value = agg_call_state::ValueState;
773
774 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
775 formatter.write_str("struct stream_plan.AggCallState.ValueState")
776 }
777
778 fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::ValueState, V::Error>
779 where
780 V: serde::de::MapAccess<'de>,
781 {
782 while map_.next_key::<GeneratedField>()?.is_some() {
783 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
784 }
785 Ok(agg_call_state::ValueState {
786 })
787 }
788 }
789 deserializer.deserialize_struct("stream_plan.AggCallState.ValueState", FIELDS, GeneratedVisitor)
790 }
791}
792impl serde::Serialize for AggNodeVersion {
793 #[allow(deprecated)]
794 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
795 where
796 S: serde::Serializer,
797 {
798 let variant = match self {
799 Self::Unspecified => "AGG_NODE_VERSION_UNSPECIFIED",
800 Self::Issue12140 => "AGG_NODE_VERSION_ISSUE_12140",
801 Self::Issue13465 => "AGG_NODE_VERSION_ISSUE_13465",
802 };
803 serializer.serialize_str(variant)
804 }
805}
806impl<'de> serde::Deserialize<'de> for AggNodeVersion {
807 #[allow(deprecated)]
808 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
809 where
810 D: serde::Deserializer<'de>,
811 {
812 const FIELDS: &[&str] = &[
813 "AGG_NODE_VERSION_UNSPECIFIED",
814 "AGG_NODE_VERSION_ISSUE_12140",
815 "AGG_NODE_VERSION_ISSUE_13465",
816 ];
817
818 struct GeneratedVisitor;
819
820 impl serde::de::Visitor<'_> for GeneratedVisitor {
821 type Value = AggNodeVersion;
822
823 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
824 write!(formatter, "expected one of: {:?}", &FIELDS)
825 }
826
827 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
828 where
829 E: serde::de::Error,
830 {
831 i32::try_from(v)
832 .ok()
833 .and_then(|x| x.try_into().ok())
834 .ok_or_else(|| {
835 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
836 })
837 }
838
839 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
840 where
841 E: serde::de::Error,
842 {
843 i32::try_from(v)
844 .ok()
845 .and_then(|x| x.try_into().ok())
846 .ok_or_else(|| {
847 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
848 })
849 }
850
851 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
852 where
853 E: serde::de::Error,
854 {
855 match value {
856 "AGG_NODE_VERSION_UNSPECIFIED" => Ok(AggNodeVersion::Unspecified),
857 "AGG_NODE_VERSION_ISSUE_12140" => Ok(AggNodeVersion::Issue12140),
858 "AGG_NODE_VERSION_ISSUE_13465" => Ok(AggNodeVersion::Issue13465),
859 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
860 }
861 }
862 }
863 deserializer.deserialize_any(GeneratedVisitor)
864 }
865}
866impl serde::Serialize for ArrangeNode {
867 #[allow(deprecated)]
868 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
869 where
870 S: serde::Serializer,
871 {
872 use serde::ser::SerializeStruct;
873 let mut len = 0;
874 if self.table_info.is_some() {
875 len += 1;
876 }
877 if !self.distribution_key.is_empty() {
878 len += 1;
879 }
880 if self.table.is_some() {
881 len += 1;
882 }
883 let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangeNode", len)?;
884 if let Some(v) = self.table_info.as_ref() {
885 struct_ser.serialize_field("tableInfo", v)?;
886 }
887 if !self.distribution_key.is_empty() {
888 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
889 }
890 if let Some(v) = self.table.as_ref() {
891 struct_ser.serialize_field("table", v)?;
892 }
893 struct_ser.end()
894 }
895}
896impl<'de> serde::Deserialize<'de> for ArrangeNode {
897 #[allow(deprecated)]
898 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
899 where
900 D: serde::Deserializer<'de>,
901 {
902 const FIELDS: &[&str] = &[
903 "table_info",
904 "tableInfo",
905 "distribution_key",
906 "distributionKey",
907 "table",
908 ];
909
910 #[allow(clippy::enum_variant_names)]
911 enum GeneratedField {
912 TableInfo,
913 DistributionKey,
914 Table,
915 }
916 impl<'de> serde::Deserialize<'de> for GeneratedField {
917 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
918 where
919 D: serde::Deserializer<'de>,
920 {
921 struct GeneratedVisitor;
922
923 impl serde::de::Visitor<'_> for GeneratedVisitor {
924 type Value = GeneratedField;
925
926 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
927 write!(formatter, "expected one of: {:?}", &FIELDS)
928 }
929
930 #[allow(unused_variables)]
931 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
932 where
933 E: serde::de::Error,
934 {
935 match value {
936 "tableInfo" | "table_info" => Ok(GeneratedField::TableInfo),
937 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
938 "table" => Ok(GeneratedField::Table),
939 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
940 }
941 }
942 }
943 deserializer.deserialize_identifier(GeneratedVisitor)
944 }
945 }
946 struct GeneratedVisitor;
947 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
948 type Value = ArrangeNode;
949
950 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
951 formatter.write_str("struct stream_plan.ArrangeNode")
952 }
953
954 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangeNode, V::Error>
955 where
956 V: serde::de::MapAccess<'de>,
957 {
958 let mut table_info__ = None;
959 let mut distribution_key__ = None;
960 let mut table__ = None;
961 while let Some(k) = map_.next_key()? {
962 match k {
963 GeneratedField::TableInfo => {
964 if table_info__.is_some() {
965 return Err(serde::de::Error::duplicate_field("tableInfo"));
966 }
967 table_info__ = map_.next_value()?;
968 }
969 GeneratedField::DistributionKey => {
970 if distribution_key__.is_some() {
971 return Err(serde::de::Error::duplicate_field("distributionKey"));
972 }
973 distribution_key__ =
974 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
975 .into_iter().map(|x| x.0).collect())
976 ;
977 }
978 GeneratedField::Table => {
979 if table__.is_some() {
980 return Err(serde::de::Error::duplicate_field("table"));
981 }
982 table__ = map_.next_value()?;
983 }
984 }
985 }
986 Ok(ArrangeNode {
987 table_info: table_info__,
988 distribution_key: distribution_key__.unwrap_or_default(),
989 table: table__,
990 })
991 }
992 }
993 deserializer.deserialize_struct("stream_plan.ArrangeNode", FIELDS, GeneratedVisitor)
994 }
995}
996impl serde::Serialize for ArrangementInfo {
997 #[allow(deprecated)]
998 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
999 where
1000 S: serde::Serializer,
1001 {
1002 use serde::ser::SerializeStruct;
1003 let mut len = 0;
1004 if !self.arrange_key_orders.is_empty() {
1005 len += 1;
1006 }
1007 if !self.column_descs.is_empty() {
1008 len += 1;
1009 }
1010 if self.table_desc.is_some() {
1011 len += 1;
1012 }
1013 if !self.output_col_idx.is_empty() {
1014 len += 1;
1015 }
1016 let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangementInfo", len)?;
1017 if !self.arrange_key_orders.is_empty() {
1018 struct_ser.serialize_field("arrangeKeyOrders", &self.arrange_key_orders)?;
1019 }
1020 if !self.column_descs.is_empty() {
1021 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
1022 }
1023 if let Some(v) = self.table_desc.as_ref() {
1024 struct_ser.serialize_field("tableDesc", v)?;
1025 }
1026 if !self.output_col_idx.is_empty() {
1027 struct_ser.serialize_field("outputColIdx", &self.output_col_idx)?;
1028 }
1029 struct_ser.end()
1030 }
1031}
1032impl<'de> serde::Deserialize<'de> for ArrangementInfo {
1033 #[allow(deprecated)]
1034 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1035 where
1036 D: serde::Deserializer<'de>,
1037 {
1038 const FIELDS: &[&str] = &[
1039 "arrange_key_orders",
1040 "arrangeKeyOrders",
1041 "column_descs",
1042 "columnDescs",
1043 "table_desc",
1044 "tableDesc",
1045 "output_col_idx",
1046 "outputColIdx",
1047 ];
1048
1049 #[allow(clippy::enum_variant_names)]
1050 enum GeneratedField {
1051 ArrangeKeyOrders,
1052 ColumnDescs,
1053 TableDesc,
1054 OutputColIdx,
1055 }
1056 impl<'de> serde::Deserialize<'de> for GeneratedField {
1057 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1058 where
1059 D: serde::Deserializer<'de>,
1060 {
1061 struct GeneratedVisitor;
1062
1063 impl serde::de::Visitor<'_> for GeneratedVisitor {
1064 type Value = GeneratedField;
1065
1066 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1067 write!(formatter, "expected one of: {:?}", &FIELDS)
1068 }
1069
1070 #[allow(unused_variables)]
1071 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1072 where
1073 E: serde::de::Error,
1074 {
1075 match value {
1076 "arrangeKeyOrders" | "arrange_key_orders" => Ok(GeneratedField::ArrangeKeyOrders),
1077 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
1078 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
1079 "outputColIdx" | "output_col_idx" => Ok(GeneratedField::OutputColIdx),
1080 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1081 }
1082 }
1083 }
1084 deserializer.deserialize_identifier(GeneratedVisitor)
1085 }
1086 }
1087 struct GeneratedVisitor;
1088 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1089 type Value = ArrangementInfo;
1090
1091 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1092 formatter.write_str("struct stream_plan.ArrangementInfo")
1093 }
1094
1095 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangementInfo, V::Error>
1096 where
1097 V: serde::de::MapAccess<'de>,
1098 {
1099 let mut arrange_key_orders__ = None;
1100 let mut column_descs__ = None;
1101 let mut table_desc__ = None;
1102 let mut output_col_idx__ = None;
1103 while let Some(k) = map_.next_key()? {
1104 match k {
1105 GeneratedField::ArrangeKeyOrders => {
1106 if arrange_key_orders__.is_some() {
1107 return Err(serde::de::Error::duplicate_field("arrangeKeyOrders"));
1108 }
1109 arrange_key_orders__ = Some(map_.next_value()?);
1110 }
1111 GeneratedField::ColumnDescs => {
1112 if column_descs__.is_some() {
1113 return Err(serde::de::Error::duplicate_field("columnDescs"));
1114 }
1115 column_descs__ = Some(map_.next_value()?);
1116 }
1117 GeneratedField::TableDesc => {
1118 if table_desc__.is_some() {
1119 return Err(serde::de::Error::duplicate_field("tableDesc"));
1120 }
1121 table_desc__ = map_.next_value()?;
1122 }
1123 GeneratedField::OutputColIdx => {
1124 if output_col_idx__.is_some() {
1125 return Err(serde::de::Error::duplicate_field("outputColIdx"));
1126 }
1127 output_col_idx__ =
1128 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1129 .into_iter().map(|x| x.0).collect())
1130 ;
1131 }
1132 }
1133 }
1134 Ok(ArrangementInfo {
1135 arrange_key_orders: arrange_key_orders__.unwrap_or_default(),
1136 column_descs: column_descs__.unwrap_or_default(),
1137 table_desc: table_desc__,
1138 output_col_idx: output_col_idx__.unwrap_or_default(),
1139 })
1140 }
1141 }
1142 deserializer.deserialize_struct("stream_plan.ArrangementInfo", FIELDS, GeneratedVisitor)
1143 }
1144}
1145impl serde::Serialize for AsOfJoinNode {
1146 #[allow(deprecated)]
1147 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1148 where
1149 S: serde::Serializer,
1150 {
1151 use serde::ser::SerializeStruct;
1152 let mut len = 0;
1153 if self.join_type != 0 {
1154 len += 1;
1155 }
1156 if !self.left_key.is_empty() {
1157 len += 1;
1158 }
1159 if !self.right_key.is_empty() {
1160 len += 1;
1161 }
1162 if self.left_table.is_some() {
1163 len += 1;
1164 }
1165 if self.right_table.is_some() {
1166 len += 1;
1167 }
1168 if !self.output_indices.is_empty() {
1169 len += 1;
1170 }
1171 if !self.left_deduped_input_pk_indices.is_empty() {
1172 len += 1;
1173 }
1174 if !self.right_deduped_input_pk_indices.is_empty() {
1175 len += 1;
1176 }
1177 if !self.null_safe.is_empty() {
1178 len += 1;
1179 }
1180 if self.asof_desc.is_some() {
1181 len += 1;
1182 }
1183 if self.join_encoding_type != 0 {
1184 len += 1;
1185 }
1186 if self.use_cache.is_some() {
1187 len += 1;
1188 }
1189 let mut struct_ser = serializer.serialize_struct("stream_plan.AsOfJoinNode", len)?;
1190 if self.join_type != 0 {
1191 let v = super::plan_common::AsOfJoinType::try_from(self.join_type)
1192 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
1193 struct_ser.serialize_field("joinType", &v)?;
1194 }
1195 if !self.left_key.is_empty() {
1196 struct_ser.serialize_field("leftKey", &self.left_key)?;
1197 }
1198 if !self.right_key.is_empty() {
1199 struct_ser.serialize_field("rightKey", &self.right_key)?;
1200 }
1201 if let Some(v) = self.left_table.as_ref() {
1202 struct_ser.serialize_field("leftTable", v)?;
1203 }
1204 if let Some(v) = self.right_table.as_ref() {
1205 struct_ser.serialize_field("rightTable", v)?;
1206 }
1207 if !self.output_indices.is_empty() {
1208 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
1209 }
1210 if !self.left_deduped_input_pk_indices.is_empty() {
1211 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
1212 }
1213 if !self.right_deduped_input_pk_indices.is_empty() {
1214 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
1215 }
1216 if !self.null_safe.is_empty() {
1217 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
1218 }
1219 if let Some(v) = self.asof_desc.as_ref() {
1220 struct_ser.serialize_field("asofDesc", v)?;
1221 }
1222 if self.join_encoding_type != 0 {
1223 let v = JoinEncodingType::try_from(self.join_encoding_type)
1224 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
1225 struct_ser.serialize_field("joinEncodingType", &v)?;
1226 }
1227 if let Some(v) = self.use_cache.as_ref() {
1228 struct_ser.serialize_field("useCache", v)?;
1229 }
1230 struct_ser.end()
1231 }
1232}
1233impl<'de> serde::Deserialize<'de> for AsOfJoinNode {
1234 #[allow(deprecated)]
1235 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1236 where
1237 D: serde::Deserializer<'de>,
1238 {
1239 const FIELDS: &[&str] = &[
1240 "join_type",
1241 "joinType",
1242 "left_key",
1243 "leftKey",
1244 "right_key",
1245 "rightKey",
1246 "left_table",
1247 "leftTable",
1248 "right_table",
1249 "rightTable",
1250 "output_indices",
1251 "outputIndices",
1252 "left_deduped_input_pk_indices",
1253 "leftDedupedInputPkIndices",
1254 "right_deduped_input_pk_indices",
1255 "rightDedupedInputPkIndices",
1256 "null_safe",
1257 "nullSafe",
1258 "asof_desc",
1259 "asofDesc",
1260 "join_encoding_type",
1261 "joinEncodingType",
1262 "use_cache",
1263 "useCache",
1264 ];
1265
1266 #[allow(clippy::enum_variant_names)]
1267 enum GeneratedField {
1268 JoinType,
1269 LeftKey,
1270 RightKey,
1271 LeftTable,
1272 RightTable,
1273 OutputIndices,
1274 LeftDedupedInputPkIndices,
1275 RightDedupedInputPkIndices,
1276 NullSafe,
1277 AsofDesc,
1278 JoinEncodingType,
1279 UseCache,
1280 }
1281 impl<'de> serde::Deserialize<'de> for GeneratedField {
1282 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1283 where
1284 D: serde::Deserializer<'de>,
1285 {
1286 struct GeneratedVisitor;
1287
1288 impl serde::de::Visitor<'_> for GeneratedVisitor {
1289 type Value = GeneratedField;
1290
1291 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1292 write!(formatter, "expected one of: {:?}", &FIELDS)
1293 }
1294
1295 #[allow(unused_variables)]
1296 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1297 where
1298 E: serde::de::Error,
1299 {
1300 match value {
1301 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
1302 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
1303 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
1304 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
1305 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
1306 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
1307 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
1308 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
1309 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
1310 "asofDesc" | "asof_desc" => Ok(GeneratedField::AsofDesc),
1311 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
1312 "useCache" | "use_cache" => Ok(GeneratedField::UseCache),
1313 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1314 }
1315 }
1316 }
1317 deserializer.deserialize_identifier(GeneratedVisitor)
1318 }
1319 }
1320 struct GeneratedVisitor;
1321 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1322 type Value = AsOfJoinNode;
1323
1324 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1325 formatter.write_str("struct stream_plan.AsOfJoinNode")
1326 }
1327
1328 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AsOfJoinNode, V::Error>
1329 where
1330 V: serde::de::MapAccess<'de>,
1331 {
1332 let mut join_type__ = None;
1333 let mut left_key__ = None;
1334 let mut right_key__ = None;
1335 let mut left_table__ = None;
1336 let mut right_table__ = None;
1337 let mut output_indices__ = None;
1338 let mut left_deduped_input_pk_indices__ = None;
1339 let mut right_deduped_input_pk_indices__ = None;
1340 let mut null_safe__ = None;
1341 let mut asof_desc__ = None;
1342 let mut join_encoding_type__ = None;
1343 let mut use_cache__ = None;
1344 while let Some(k) = map_.next_key()? {
1345 match k {
1346 GeneratedField::JoinType => {
1347 if join_type__.is_some() {
1348 return Err(serde::de::Error::duplicate_field("joinType"));
1349 }
1350 join_type__ = Some(map_.next_value::<super::plan_common::AsOfJoinType>()? as i32);
1351 }
1352 GeneratedField::LeftKey => {
1353 if left_key__.is_some() {
1354 return Err(serde::de::Error::duplicate_field("leftKey"));
1355 }
1356 left_key__ =
1357 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1358 .into_iter().map(|x| x.0).collect())
1359 ;
1360 }
1361 GeneratedField::RightKey => {
1362 if right_key__.is_some() {
1363 return Err(serde::de::Error::duplicate_field("rightKey"));
1364 }
1365 right_key__ =
1366 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1367 .into_iter().map(|x| x.0).collect())
1368 ;
1369 }
1370 GeneratedField::LeftTable => {
1371 if left_table__.is_some() {
1372 return Err(serde::de::Error::duplicate_field("leftTable"));
1373 }
1374 left_table__ = map_.next_value()?;
1375 }
1376 GeneratedField::RightTable => {
1377 if right_table__.is_some() {
1378 return Err(serde::de::Error::duplicate_field("rightTable"));
1379 }
1380 right_table__ = map_.next_value()?;
1381 }
1382 GeneratedField::OutputIndices => {
1383 if output_indices__.is_some() {
1384 return Err(serde::de::Error::duplicate_field("outputIndices"));
1385 }
1386 output_indices__ =
1387 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1388 .into_iter().map(|x| x.0).collect())
1389 ;
1390 }
1391 GeneratedField::LeftDedupedInputPkIndices => {
1392 if left_deduped_input_pk_indices__.is_some() {
1393 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
1394 }
1395 left_deduped_input_pk_indices__ =
1396 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1397 .into_iter().map(|x| x.0).collect())
1398 ;
1399 }
1400 GeneratedField::RightDedupedInputPkIndices => {
1401 if right_deduped_input_pk_indices__.is_some() {
1402 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
1403 }
1404 right_deduped_input_pk_indices__ =
1405 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1406 .into_iter().map(|x| x.0).collect())
1407 ;
1408 }
1409 GeneratedField::NullSafe => {
1410 if null_safe__.is_some() {
1411 return Err(serde::de::Error::duplicate_field("nullSafe"));
1412 }
1413 null_safe__ = Some(map_.next_value()?);
1414 }
1415 GeneratedField::AsofDesc => {
1416 if asof_desc__.is_some() {
1417 return Err(serde::de::Error::duplicate_field("asofDesc"));
1418 }
1419 asof_desc__ = map_.next_value()?;
1420 }
1421 GeneratedField::JoinEncodingType => {
1422 if join_encoding_type__.is_some() {
1423 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
1424 }
1425 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
1426 }
1427 GeneratedField::UseCache => {
1428 if use_cache__.is_some() {
1429 return Err(serde::de::Error::duplicate_field("useCache"));
1430 }
1431 use_cache__ = map_.next_value()?;
1432 }
1433 }
1434 }
1435 Ok(AsOfJoinNode {
1436 join_type: join_type__.unwrap_or_default(),
1437 left_key: left_key__.unwrap_or_default(),
1438 right_key: right_key__.unwrap_or_default(),
1439 left_table: left_table__,
1440 right_table: right_table__,
1441 output_indices: output_indices__.unwrap_or_default(),
1442 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
1443 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
1444 null_safe: null_safe__.unwrap_or_default(),
1445 asof_desc: asof_desc__,
1446 join_encoding_type: join_encoding_type__.unwrap_or_default(),
1447 use_cache: use_cache__,
1448 })
1449 }
1450 }
1451 deserializer.deserialize_struct("stream_plan.AsOfJoinNode", FIELDS, GeneratedVisitor)
1452 }
1453}
1454impl serde::Serialize for BackfillOrder {
1455 #[allow(deprecated)]
1456 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1457 where
1458 S: serde::Serializer,
1459 {
1460 use serde::ser::SerializeStruct;
1461 let mut len = 0;
1462 if !self.order.is_empty() {
1463 len += 1;
1464 }
1465 let mut struct_ser = serializer.serialize_struct("stream_plan.BackfillOrder", len)?;
1466 if !self.order.is_empty() {
1467 struct_ser.serialize_field("order", &self.order)?;
1468 }
1469 struct_ser.end()
1470 }
1471}
1472impl<'de> serde::Deserialize<'de> for BackfillOrder {
1473 #[allow(deprecated)]
1474 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1475 where
1476 D: serde::Deserializer<'de>,
1477 {
1478 const FIELDS: &[&str] = &[
1479 "order",
1480 ];
1481
1482 #[allow(clippy::enum_variant_names)]
1483 enum GeneratedField {
1484 Order,
1485 }
1486 impl<'de> serde::Deserialize<'de> for GeneratedField {
1487 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1488 where
1489 D: serde::Deserializer<'de>,
1490 {
1491 struct GeneratedVisitor;
1492
1493 impl serde::de::Visitor<'_> for GeneratedVisitor {
1494 type Value = GeneratedField;
1495
1496 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1497 write!(formatter, "expected one of: {:?}", &FIELDS)
1498 }
1499
1500 #[allow(unused_variables)]
1501 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1502 where
1503 E: serde::de::Error,
1504 {
1505 match value {
1506 "order" => Ok(GeneratedField::Order),
1507 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1508 }
1509 }
1510 }
1511 deserializer.deserialize_identifier(GeneratedVisitor)
1512 }
1513 }
1514 struct GeneratedVisitor;
1515 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1516 type Value = BackfillOrder;
1517
1518 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1519 formatter.write_str("struct stream_plan.BackfillOrder")
1520 }
1521
1522 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BackfillOrder, V::Error>
1523 where
1524 V: serde::de::MapAccess<'de>,
1525 {
1526 let mut order__ = None;
1527 while let Some(k) = map_.next_key()? {
1528 match k {
1529 GeneratedField::Order => {
1530 if order__.is_some() {
1531 return Err(serde::de::Error::duplicate_field("order"));
1532 }
1533 order__ = Some(
1534 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1535 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1536 );
1537 }
1538 }
1539 }
1540 Ok(BackfillOrder {
1541 order: order__.unwrap_or_default(),
1542 })
1543 }
1544 }
1545 deserializer.deserialize_struct("stream_plan.BackfillOrder", FIELDS, GeneratedVisitor)
1546 }
1547}
1548impl serde::Serialize for Barrier {
1549 #[allow(deprecated)]
1550 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1551 where
1552 S: serde::Serializer,
1553 {
1554 use serde::ser::SerializeStruct;
1555 let mut len = 0;
1556 if self.epoch.is_some() {
1557 len += 1;
1558 }
1559 if self.mutation.is_some() {
1560 len += 1;
1561 }
1562 if !self.tracing_context.is_empty() {
1563 len += 1;
1564 }
1565 if self.kind != 0 {
1566 len += 1;
1567 }
1568 let mut struct_ser = serializer.serialize_struct("stream_plan.Barrier", len)?;
1569 if let Some(v) = self.epoch.as_ref() {
1570 struct_ser.serialize_field("epoch", v)?;
1571 }
1572 if let Some(v) = self.mutation.as_ref() {
1573 struct_ser.serialize_field("mutation", v)?;
1574 }
1575 if !self.tracing_context.is_empty() {
1576 struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
1577 }
1578 if self.kind != 0 {
1579 let v = barrier::BarrierKind::try_from(self.kind)
1580 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
1581 struct_ser.serialize_field("kind", &v)?;
1582 }
1583 struct_ser.end()
1584 }
1585}
1586impl<'de> serde::Deserialize<'de> for Barrier {
1587 #[allow(deprecated)]
1588 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1589 where
1590 D: serde::Deserializer<'de>,
1591 {
1592 const FIELDS: &[&str] = &[
1593 "epoch",
1594 "mutation",
1595 "tracing_context",
1596 "tracingContext",
1597 "kind",
1598 ];
1599
1600 #[allow(clippy::enum_variant_names)]
1601 enum GeneratedField {
1602 Epoch,
1603 Mutation,
1604 TracingContext,
1605 Kind,
1606 }
1607 impl<'de> serde::Deserialize<'de> for GeneratedField {
1608 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1609 where
1610 D: serde::Deserializer<'de>,
1611 {
1612 struct GeneratedVisitor;
1613
1614 impl serde::de::Visitor<'_> for GeneratedVisitor {
1615 type Value = GeneratedField;
1616
1617 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1618 write!(formatter, "expected one of: {:?}", &FIELDS)
1619 }
1620
1621 #[allow(unused_variables)]
1622 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1623 where
1624 E: serde::de::Error,
1625 {
1626 match value {
1627 "epoch" => Ok(GeneratedField::Epoch),
1628 "mutation" => Ok(GeneratedField::Mutation),
1629 "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
1630 "kind" => Ok(GeneratedField::Kind),
1631 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1632 }
1633 }
1634 }
1635 deserializer.deserialize_identifier(GeneratedVisitor)
1636 }
1637 }
1638 struct GeneratedVisitor;
1639 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1640 type Value = Barrier;
1641
1642 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1643 formatter.write_str("struct stream_plan.Barrier")
1644 }
1645
1646 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Barrier, V::Error>
1647 where
1648 V: serde::de::MapAccess<'de>,
1649 {
1650 let mut epoch__ = None;
1651 let mut mutation__ = None;
1652 let mut tracing_context__ = None;
1653 let mut kind__ = None;
1654 while let Some(k) = map_.next_key()? {
1655 match k {
1656 GeneratedField::Epoch => {
1657 if epoch__.is_some() {
1658 return Err(serde::de::Error::duplicate_field("epoch"));
1659 }
1660 epoch__ = map_.next_value()?;
1661 }
1662 GeneratedField::Mutation => {
1663 if mutation__.is_some() {
1664 return Err(serde::de::Error::duplicate_field("mutation"));
1665 }
1666 mutation__ = map_.next_value()?;
1667 }
1668 GeneratedField::TracingContext => {
1669 if tracing_context__.is_some() {
1670 return Err(serde::de::Error::duplicate_field("tracingContext"));
1671 }
1672 tracing_context__ = Some(
1673 map_.next_value::<std::collections::HashMap<_, _>>()?
1674 );
1675 }
1676 GeneratedField::Kind => {
1677 if kind__.is_some() {
1678 return Err(serde::de::Error::duplicate_field("kind"));
1679 }
1680 kind__ = Some(map_.next_value::<barrier::BarrierKind>()? as i32);
1681 }
1682 }
1683 }
1684 Ok(Barrier {
1685 epoch: epoch__,
1686 mutation: mutation__,
1687 tracing_context: tracing_context__.unwrap_or_default(),
1688 kind: kind__.unwrap_or_default(),
1689 })
1690 }
1691 }
1692 deserializer.deserialize_struct("stream_plan.Barrier", FIELDS, GeneratedVisitor)
1693 }
1694}
1695impl serde::Serialize for barrier::BarrierKind {
1696 #[allow(deprecated)]
1697 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1698 where
1699 S: serde::Serializer,
1700 {
1701 let variant = match self {
1702 Self::Unspecified => "BARRIER_KIND_UNSPECIFIED",
1703 Self::Initial => "BARRIER_KIND_INITIAL",
1704 Self::Barrier => "BARRIER_KIND_BARRIER",
1705 Self::Checkpoint => "BARRIER_KIND_CHECKPOINT",
1706 };
1707 serializer.serialize_str(variant)
1708 }
1709}
1710impl<'de> serde::Deserialize<'de> for barrier::BarrierKind {
1711 #[allow(deprecated)]
1712 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1713 where
1714 D: serde::Deserializer<'de>,
1715 {
1716 const FIELDS: &[&str] = &[
1717 "BARRIER_KIND_UNSPECIFIED",
1718 "BARRIER_KIND_INITIAL",
1719 "BARRIER_KIND_BARRIER",
1720 "BARRIER_KIND_CHECKPOINT",
1721 ];
1722
1723 struct GeneratedVisitor;
1724
1725 impl serde::de::Visitor<'_> for GeneratedVisitor {
1726 type Value = barrier::BarrierKind;
1727
1728 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1729 write!(formatter, "expected one of: {:?}", &FIELDS)
1730 }
1731
1732 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1733 where
1734 E: serde::de::Error,
1735 {
1736 i32::try_from(v)
1737 .ok()
1738 .and_then(|x| x.try_into().ok())
1739 .ok_or_else(|| {
1740 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1741 })
1742 }
1743
1744 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1745 where
1746 E: serde::de::Error,
1747 {
1748 i32::try_from(v)
1749 .ok()
1750 .and_then(|x| x.try_into().ok())
1751 .ok_or_else(|| {
1752 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1753 })
1754 }
1755
1756 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1757 where
1758 E: serde::de::Error,
1759 {
1760 match value {
1761 "BARRIER_KIND_UNSPECIFIED" => Ok(barrier::BarrierKind::Unspecified),
1762 "BARRIER_KIND_INITIAL" => Ok(barrier::BarrierKind::Initial),
1763 "BARRIER_KIND_BARRIER" => Ok(barrier::BarrierKind::Barrier),
1764 "BARRIER_KIND_CHECKPOINT" => Ok(barrier::BarrierKind::Checkpoint),
1765 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1766 }
1767 }
1768 }
1769 deserializer.deserialize_any(GeneratedVisitor)
1770 }
1771}
1772impl serde::Serialize for BarrierMutation {
1773 #[allow(deprecated)]
1774 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1775 where
1776 S: serde::Serializer,
1777 {
1778 use serde::ser::SerializeStruct;
1779 let mut len = 0;
1780 if self.mutation.is_some() {
1781 len += 1;
1782 }
1783 let mut struct_ser = serializer.serialize_struct("stream_plan.BarrierMutation", len)?;
1784 if let Some(v) = self.mutation.as_ref() {
1785 match v {
1786 barrier_mutation::Mutation::Add(v) => {
1787 struct_ser.serialize_field("add", v)?;
1788 }
1789 barrier_mutation::Mutation::Stop(v) => {
1790 struct_ser.serialize_field("stop", v)?;
1791 }
1792 barrier_mutation::Mutation::Update(v) => {
1793 struct_ser.serialize_field("update", v)?;
1794 }
1795 barrier_mutation::Mutation::Splits(v) => {
1796 struct_ser.serialize_field("splits", v)?;
1797 }
1798 barrier_mutation::Mutation::Pause(v) => {
1799 struct_ser.serialize_field("pause", v)?;
1800 }
1801 barrier_mutation::Mutation::Resume(v) => {
1802 struct_ser.serialize_field("resume", v)?;
1803 }
1804 barrier_mutation::Mutation::Throttle(v) => {
1805 struct_ser.serialize_field("throttle", v)?;
1806 }
1807 barrier_mutation::Mutation::DropSubscriptions(v) => {
1808 struct_ser.serialize_field("dropSubscriptions", v)?;
1809 }
1810 barrier_mutation::Mutation::ConnectorPropsChange(v) => {
1811 struct_ser.serialize_field("connectorPropsChange", v)?;
1812 }
1813 barrier_mutation::Mutation::StartFragmentBackfill(v) => {
1814 struct_ser.serialize_field("startFragmentBackfill", v)?;
1815 }
1816 barrier_mutation::Mutation::RefreshStart(v) => {
1817 struct_ser.serialize_field("refreshStart", v)?;
1818 }
1819 barrier_mutation::Mutation::LoadFinish(v) => {
1820 struct_ser.serialize_field("loadFinish", v)?;
1821 }
1822 barrier_mutation::Mutation::ListFinish(v) => {
1823 struct_ser.serialize_field("listFinish", v)?;
1824 }
1825 barrier_mutation::Mutation::ResetSource(v) => {
1826 struct_ser.serialize_field("resetSource", v)?;
1827 }
1828 barrier_mutation::Mutation::InjectSourceOffsets(v) => {
1829 struct_ser.serialize_field("injectSourceOffsets", v)?;
1830 }
1831 }
1832 }
1833 struct_ser.end()
1834 }
1835}
1836impl<'de> serde::Deserialize<'de> for BarrierMutation {
1837 #[allow(deprecated)]
1838 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1839 where
1840 D: serde::Deserializer<'de>,
1841 {
1842 const FIELDS: &[&str] = &[
1843 "add",
1844 "stop",
1845 "update",
1846 "splits",
1847 "pause",
1848 "resume",
1849 "throttle",
1850 "drop_subscriptions",
1851 "dropSubscriptions",
1852 "connector_props_change",
1853 "connectorPropsChange",
1854 "start_fragment_backfill",
1855 "startFragmentBackfill",
1856 "refresh_start",
1857 "refreshStart",
1858 "load_finish",
1859 "loadFinish",
1860 "list_finish",
1861 "listFinish",
1862 "reset_source",
1863 "resetSource",
1864 "inject_source_offsets",
1865 "injectSourceOffsets",
1866 ];
1867
1868 #[allow(clippy::enum_variant_names)]
1869 enum GeneratedField {
1870 Add,
1871 Stop,
1872 Update,
1873 Splits,
1874 Pause,
1875 Resume,
1876 Throttle,
1877 DropSubscriptions,
1878 ConnectorPropsChange,
1879 StartFragmentBackfill,
1880 RefreshStart,
1881 LoadFinish,
1882 ListFinish,
1883 ResetSource,
1884 InjectSourceOffsets,
1885 }
1886 impl<'de> serde::Deserialize<'de> for GeneratedField {
1887 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1888 where
1889 D: serde::Deserializer<'de>,
1890 {
1891 struct GeneratedVisitor;
1892
1893 impl serde::de::Visitor<'_> for GeneratedVisitor {
1894 type Value = GeneratedField;
1895
1896 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1897 write!(formatter, "expected one of: {:?}", &FIELDS)
1898 }
1899
1900 #[allow(unused_variables)]
1901 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1902 where
1903 E: serde::de::Error,
1904 {
1905 match value {
1906 "add" => Ok(GeneratedField::Add),
1907 "stop" => Ok(GeneratedField::Stop),
1908 "update" => Ok(GeneratedField::Update),
1909 "splits" => Ok(GeneratedField::Splits),
1910 "pause" => Ok(GeneratedField::Pause),
1911 "resume" => Ok(GeneratedField::Resume),
1912 "throttle" => Ok(GeneratedField::Throttle),
1913 "dropSubscriptions" | "drop_subscriptions" => Ok(GeneratedField::DropSubscriptions),
1914 "connectorPropsChange" | "connector_props_change" => Ok(GeneratedField::ConnectorPropsChange),
1915 "startFragmentBackfill" | "start_fragment_backfill" => Ok(GeneratedField::StartFragmentBackfill),
1916 "refreshStart" | "refresh_start" => Ok(GeneratedField::RefreshStart),
1917 "loadFinish" | "load_finish" => Ok(GeneratedField::LoadFinish),
1918 "listFinish" | "list_finish" => Ok(GeneratedField::ListFinish),
1919 "resetSource" | "reset_source" => Ok(GeneratedField::ResetSource),
1920 "injectSourceOffsets" | "inject_source_offsets" => Ok(GeneratedField::InjectSourceOffsets),
1921 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1922 }
1923 }
1924 }
1925 deserializer.deserialize_identifier(GeneratedVisitor)
1926 }
1927 }
1928 struct GeneratedVisitor;
1929 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1930 type Value = BarrierMutation;
1931
1932 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1933 formatter.write_str("struct stream_plan.BarrierMutation")
1934 }
1935
1936 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierMutation, V::Error>
1937 where
1938 V: serde::de::MapAccess<'de>,
1939 {
1940 let mut mutation__ = None;
1941 while let Some(k) = map_.next_key()? {
1942 match k {
1943 GeneratedField::Add => {
1944 if mutation__.is_some() {
1945 return Err(serde::de::Error::duplicate_field("add"));
1946 }
1947 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Add)
1948;
1949 }
1950 GeneratedField::Stop => {
1951 if mutation__.is_some() {
1952 return Err(serde::de::Error::duplicate_field("stop"));
1953 }
1954 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Stop)
1955;
1956 }
1957 GeneratedField::Update => {
1958 if mutation__.is_some() {
1959 return Err(serde::de::Error::duplicate_field("update"));
1960 }
1961 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Update)
1962;
1963 }
1964 GeneratedField::Splits => {
1965 if mutation__.is_some() {
1966 return Err(serde::de::Error::duplicate_field("splits"));
1967 }
1968 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Splits)
1969;
1970 }
1971 GeneratedField::Pause => {
1972 if mutation__.is_some() {
1973 return Err(serde::de::Error::duplicate_field("pause"));
1974 }
1975 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Pause)
1976;
1977 }
1978 GeneratedField::Resume => {
1979 if mutation__.is_some() {
1980 return Err(serde::de::Error::duplicate_field("resume"));
1981 }
1982 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Resume)
1983;
1984 }
1985 GeneratedField::Throttle => {
1986 if mutation__.is_some() {
1987 return Err(serde::de::Error::duplicate_field("throttle"));
1988 }
1989 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Throttle)
1990;
1991 }
1992 GeneratedField::DropSubscriptions => {
1993 if mutation__.is_some() {
1994 return Err(serde::de::Error::duplicate_field("dropSubscriptions"));
1995 }
1996 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::DropSubscriptions)
1997;
1998 }
1999 GeneratedField::ConnectorPropsChange => {
2000 if mutation__.is_some() {
2001 return Err(serde::de::Error::duplicate_field("connectorPropsChange"));
2002 }
2003 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ConnectorPropsChange)
2004;
2005 }
2006 GeneratedField::StartFragmentBackfill => {
2007 if mutation__.is_some() {
2008 return Err(serde::de::Error::duplicate_field("startFragmentBackfill"));
2009 }
2010 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::StartFragmentBackfill)
2011;
2012 }
2013 GeneratedField::RefreshStart => {
2014 if mutation__.is_some() {
2015 return Err(serde::de::Error::duplicate_field("refreshStart"));
2016 }
2017 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::RefreshStart)
2018;
2019 }
2020 GeneratedField::LoadFinish => {
2021 if mutation__.is_some() {
2022 return Err(serde::de::Error::duplicate_field("loadFinish"));
2023 }
2024 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::LoadFinish)
2025;
2026 }
2027 GeneratedField::ListFinish => {
2028 if mutation__.is_some() {
2029 return Err(serde::de::Error::duplicate_field("listFinish"));
2030 }
2031 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ListFinish)
2032;
2033 }
2034 GeneratedField::ResetSource => {
2035 if mutation__.is_some() {
2036 return Err(serde::de::Error::duplicate_field("resetSource"));
2037 }
2038 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ResetSource)
2039;
2040 }
2041 GeneratedField::InjectSourceOffsets => {
2042 if mutation__.is_some() {
2043 return Err(serde::de::Error::duplicate_field("injectSourceOffsets"));
2044 }
2045 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::InjectSourceOffsets)
2046;
2047 }
2048 }
2049 }
2050 Ok(BarrierMutation {
2051 mutation: mutation__,
2052 })
2053 }
2054 }
2055 deserializer.deserialize_struct("stream_plan.BarrierMutation", FIELDS, GeneratedVisitor)
2056 }
2057}
2058impl serde::Serialize for BarrierRecvNode {
2059 #[allow(deprecated)]
2060 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2061 where
2062 S: serde::Serializer,
2063 {
2064 use serde::ser::SerializeStruct;
2065 let len = 0;
2066 let struct_ser = serializer.serialize_struct("stream_plan.BarrierRecvNode", len)?;
2067 struct_ser.end()
2068 }
2069}
2070impl<'de> serde::Deserialize<'de> for BarrierRecvNode {
2071 #[allow(deprecated)]
2072 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2073 where
2074 D: serde::Deserializer<'de>,
2075 {
2076 const FIELDS: &[&str] = &[
2077 ];
2078
2079 #[allow(clippy::enum_variant_names)]
2080 enum GeneratedField {
2081 }
2082 impl<'de> serde::Deserialize<'de> for GeneratedField {
2083 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2084 where
2085 D: serde::Deserializer<'de>,
2086 {
2087 struct GeneratedVisitor;
2088
2089 impl serde::de::Visitor<'_> for GeneratedVisitor {
2090 type Value = GeneratedField;
2091
2092 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2093 write!(formatter, "expected one of: {:?}", &FIELDS)
2094 }
2095
2096 #[allow(unused_variables)]
2097 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2098 where
2099 E: serde::de::Error,
2100 {
2101 Err(serde::de::Error::unknown_field(value, FIELDS))
2102 }
2103 }
2104 deserializer.deserialize_identifier(GeneratedVisitor)
2105 }
2106 }
2107 struct GeneratedVisitor;
2108 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2109 type Value = BarrierRecvNode;
2110
2111 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2112 formatter.write_str("struct stream_plan.BarrierRecvNode")
2113 }
2114
2115 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierRecvNode, V::Error>
2116 where
2117 V: serde::de::MapAccess<'de>,
2118 {
2119 while map_.next_key::<GeneratedField>()?.is_some() {
2120 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2121 }
2122 Ok(BarrierRecvNode {
2123 })
2124 }
2125 }
2126 deserializer.deserialize_struct("stream_plan.BarrierRecvNode", FIELDS, GeneratedVisitor)
2127 }
2128}
2129impl serde::Serialize for BatchPlanNode {
2130 #[allow(deprecated)]
2131 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2132 where
2133 S: serde::Serializer,
2134 {
2135 use serde::ser::SerializeStruct;
2136 let mut len = 0;
2137 if self.table_desc.is_some() {
2138 len += 1;
2139 }
2140 if !self.column_ids.is_empty() {
2141 len += 1;
2142 }
2143 let mut struct_ser = serializer.serialize_struct("stream_plan.BatchPlanNode", len)?;
2144 if let Some(v) = self.table_desc.as_ref() {
2145 struct_ser.serialize_field("tableDesc", v)?;
2146 }
2147 if !self.column_ids.is_empty() {
2148 struct_ser.serialize_field("columnIds", &self.column_ids)?;
2149 }
2150 struct_ser.end()
2151 }
2152}
2153impl<'de> serde::Deserialize<'de> for BatchPlanNode {
2154 #[allow(deprecated)]
2155 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2156 where
2157 D: serde::Deserializer<'de>,
2158 {
2159 const FIELDS: &[&str] = &[
2160 "table_desc",
2161 "tableDesc",
2162 "column_ids",
2163 "columnIds",
2164 ];
2165
2166 #[allow(clippy::enum_variant_names)]
2167 enum GeneratedField {
2168 TableDesc,
2169 ColumnIds,
2170 }
2171 impl<'de> serde::Deserialize<'de> for GeneratedField {
2172 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2173 where
2174 D: serde::Deserializer<'de>,
2175 {
2176 struct GeneratedVisitor;
2177
2178 impl serde::de::Visitor<'_> for GeneratedVisitor {
2179 type Value = GeneratedField;
2180
2181 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2182 write!(formatter, "expected one of: {:?}", &FIELDS)
2183 }
2184
2185 #[allow(unused_variables)]
2186 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2187 where
2188 E: serde::de::Error,
2189 {
2190 match value {
2191 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
2192 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
2193 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2194 }
2195 }
2196 }
2197 deserializer.deserialize_identifier(GeneratedVisitor)
2198 }
2199 }
2200 struct GeneratedVisitor;
2201 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2202 type Value = BatchPlanNode;
2203
2204 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2205 formatter.write_str("struct stream_plan.BatchPlanNode")
2206 }
2207
2208 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BatchPlanNode, V::Error>
2209 where
2210 V: serde::de::MapAccess<'de>,
2211 {
2212 let mut table_desc__ = None;
2213 let mut column_ids__ = None;
2214 while let Some(k) = map_.next_key()? {
2215 match k {
2216 GeneratedField::TableDesc => {
2217 if table_desc__.is_some() {
2218 return Err(serde::de::Error::duplicate_field("tableDesc"));
2219 }
2220 table_desc__ = map_.next_value()?;
2221 }
2222 GeneratedField::ColumnIds => {
2223 if column_ids__.is_some() {
2224 return Err(serde::de::Error::duplicate_field("columnIds"));
2225 }
2226 column_ids__ =
2227 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2228 .into_iter().map(|x| x.0).collect())
2229 ;
2230 }
2231 }
2232 }
2233 Ok(BatchPlanNode {
2234 table_desc: table_desc__,
2235 column_ids: column_ids__.unwrap_or_default(),
2236 })
2237 }
2238 }
2239 deserializer.deserialize_struct("stream_plan.BatchPlanNode", FIELDS, GeneratedVisitor)
2240 }
2241}
2242impl serde::Serialize for CdcFilterNode {
2243 #[allow(deprecated)]
2244 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2245 where
2246 S: serde::Serializer,
2247 {
2248 use serde::ser::SerializeStruct;
2249 let mut len = 0;
2250 if self.search_condition.is_some() {
2251 len += 1;
2252 }
2253 if self.upstream_source_id != 0 {
2254 len += 1;
2255 }
2256 let mut struct_ser = serializer.serialize_struct("stream_plan.CdcFilterNode", len)?;
2257 if let Some(v) = self.search_condition.as_ref() {
2258 struct_ser.serialize_field("searchCondition", v)?;
2259 }
2260 if self.upstream_source_id != 0 {
2261 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
2262 }
2263 struct_ser.end()
2264 }
2265}
2266impl<'de> serde::Deserialize<'de> for CdcFilterNode {
2267 #[allow(deprecated)]
2268 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2269 where
2270 D: serde::Deserializer<'de>,
2271 {
2272 const FIELDS: &[&str] = &[
2273 "search_condition",
2274 "searchCondition",
2275 "upstream_source_id",
2276 "upstreamSourceId",
2277 ];
2278
2279 #[allow(clippy::enum_variant_names)]
2280 enum GeneratedField {
2281 SearchCondition,
2282 UpstreamSourceId,
2283 }
2284 impl<'de> serde::Deserialize<'de> for GeneratedField {
2285 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2286 where
2287 D: serde::Deserializer<'de>,
2288 {
2289 struct GeneratedVisitor;
2290
2291 impl serde::de::Visitor<'_> for GeneratedVisitor {
2292 type Value = GeneratedField;
2293
2294 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2295 write!(formatter, "expected one of: {:?}", &FIELDS)
2296 }
2297
2298 #[allow(unused_variables)]
2299 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2300 where
2301 E: serde::de::Error,
2302 {
2303 match value {
2304 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
2305 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
2306 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2307 }
2308 }
2309 }
2310 deserializer.deserialize_identifier(GeneratedVisitor)
2311 }
2312 }
2313 struct GeneratedVisitor;
2314 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2315 type Value = CdcFilterNode;
2316
2317 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2318 formatter.write_str("struct stream_plan.CdcFilterNode")
2319 }
2320
2321 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcFilterNode, V::Error>
2322 where
2323 V: serde::de::MapAccess<'de>,
2324 {
2325 let mut search_condition__ = None;
2326 let mut upstream_source_id__ = None;
2327 while let Some(k) = map_.next_key()? {
2328 match k {
2329 GeneratedField::SearchCondition => {
2330 if search_condition__.is_some() {
2331 return Err(serde::de::Error::duplicate_field("searchCondition"));
2332 }
2333 search_condition__ = map_.next_value()?;
2334 }
2335 GeneratedField::UpstreamSourceId => {
2336 if upstream_source_id__.is_some() {
2337 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
2338 }
2339 upstream_source_id__ =
2340 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2341 ;
2342 }
2343 }
2344 }
2345 Ok(CdcFilterNode {
2346 search_condition: search_condition__,
2347 upstream_source_id: upstream_source_id__.unwrap_or_default(),
2348 })
2349 }
2350 }
2351 deserializer.deserialize_struct("stream_plan.CdcFilterNode", FIELDS, GeneratedVisitor)
2352 }
2353}
2354impl serde::Serialize for ChangeLogNode {
2355 #[allow(deprecated)]
2356 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2357 where
2358 S: serde::Serializer,
2359 {
2360 use serde::ser::SerializeStruct;
2361 let mut len = 0;
2362 if self.need_op {
2363 len += 1;
2364 }
2365 if !self.distribution_keys.is_empty() {
2366 len += 1;
2367 }
2368 let mut struct_ser = serializer.serialize_struct("stream_plan.ChangeLogNode", len)?;
2369 if self.need_op {
2370 struct_ser.serialize_field("needOp", &self.need_op)?;
2371 }
2372 if !self.distribution_keys.is_empty() {
2373 struct_ser.serialize_field("distributionKeys", &self.distribution_keys)?;
2374 }
2375 struct_ser.end()
2376 }
2377}
2378impl<'de> serde::Deserialize<'de> for ChangeLogNode {
2379 #[allow(deprecated)]
2380 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2381 where
2382 D: serde::Deserializer<'de>,
2383 {
2384 const FIELDS: &[&str] = &[
2385 "need_op",
2386 "needOp",
2387 "distribution_keys",
2388 "distributionKeys",
2389 ];
2390
2391 #[allow(clippy::enum_variant_names)]
2392 enum GeneratedField {
2393 NeedOp,
2394 DistributionKeys,
2395 }
2396 impl<'de> serde::Deserialize<'de> for GeneratedField {
2397 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2398 where
2399 D: serde::Deserializer<'de>,
2400 {
2401 struct GeneratedVisitor;
2402
2403 impl serde::de::Visitor<'_> for GeneratedVisitor {
2404 type Value = GeneratedField;
2405
2406 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2407 write!(formatter, "expected one of: {:?}", &FIELDS)
2408 }
2409
2410 #[allow(unused_variables)]
2411 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2412 where
2413 E: serde::de::Error,
2414 {
2415 match value {
2416 "needOp" | "need_op" => Ok(GeneratedField::NeedOp),
2417 "distributionKeys" | "distribution_keys" => Ok(GeneratedField::DistributionKeys),
2418 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2419 }
2420 }
2421 }
2422 deserializer.deserialize_identifier(GeneratedVisitor)
2423 }
2424 }
2425 struct GeneratedVisitor;
2426 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2427 type Value = ChangeLogNode;
2428
2429 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2430 formatter.write_str("struct stream_plan.ChangeLogNode")
2431 }
2432
2433 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ChangeLogNode, V::Error>
2434 where
2435 V: serde::de::MapAccess<'de>,
2436 {
2437 let mut need_op__ = None;
2438 let mut distribution_keys__ = None;
2439 while let Some(k) = map_.next_key()? {
2440 match k {
2441 GeneratedField::NeedOp => {
2442 if need_op__.is_some() {
2443 return Err(serde::de::Error::duplicate_field("needOp"));
2444 }
2445 need_op__ = Some(map_.next_value()?);
2446 }
2447 GeneratedField::DistributionKeys => {
2448 if distribution_keys__.is_some() {
2449 return Err(serde::de::Error::duplicate_field("distributionKeys"));
2450 }
2451 distribution_keys__ =
2452 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2453 .into_iter().map(|x| x.0).collect())
2454 ;
2455 }
2456 }
2457 }
2458 Ok(ChangeLogNode {
2459 need_op: need_op__.unwrap_or_default(),
2460 distribution_keys: distribution_keys__.unwrap_or_default(),
2461 })
2462 }
2463 }
2464 deserializer.deserialize_struct("stream_plan.ChangeLogNode", FIELDS, GeneratedVisitor)
2465 }
2466}
2467impl serde::Serialize for Columns {
2468 #[allow(deprecated)]
2469 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2470 where
2471 S: serde::Serializer,
2472 {
2473 use serde::ser::SerializeStruct;
2474 let mut len = 0;
2475 if !self.columns.is_empty() {
2476 len += 1;
2477 }
2478 let mut struct_ser = serializer.serialize_struct("stream_plan.Columns", len)?;
2479 if !self.columns.is_empty() {
2480 struct_ser.serialize_field("columns", &self.columns)?;
2481 }
2482 struct_ser.end()
2483 }
2484}
2485impl<'de> serde::Deserialize<'de> for Columns {
2486 #[allow(deprecated)]
2487 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2488 where
2489 D: serde::Deserializer<'de>,
2490 {
2491 const FIELDS: &[&str] = &[
2492 "columns",
2493 ];
2494
2495 #[allow(clippy::enum_variant_names)]
2496 enum GeneratedField {
2497 Columns,
2498 }
2499 impl<'de> serde::Deserialize<'de> for GeneratedField {
2500 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2501 where
2502 D: serde::Deserializer<'de>,
2503 {
2504 struct GeneratedVisitor;
2505
2506 impl serde::de::Visitor<'_> for GeneratedVisitor {
2507 type Value = GeneratedField;
2508
2509 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2510 write!(formatter, "expected one of: {:?}", &FIELDS)
2511 }
2512
2513 #[allow(unused_variables)]
2514 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2515 where
2516 E: serde::de::Error,
2517 {
2518 match value {
2519 "columns" => Ok(GeneratedField::Columns),
2520 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2521 }
2522 }
2523 }
2524 deserializer.deserialize_identifier(GeneratedVisitor)
2525 }
2526 }
2527 struct GeneratedVisitor;
2528 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2529 type Value = Columns;
2530
2531 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2532 formatter.write_str("struct stream_plan.Columns")
2533 }
2534
2535 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Columns, V::Error>
2536 where
2537 V: serde::de::MapAccess<'de>,
2538 {
2539 let mut columns__ = None;
2540 while let Some(k) = map_.next_key()? {
2541 match k {
2542 GeneratedField::Columns => {
2543 if columns__.is_some() {
2544 return Err(serde::de::Error::duplicate_field("columns"));
2545 }
2546 columns__ = Some(map_.next_value()?);
2547 }
2548 }
2549 }
2550 Ok(Columns {
2551 columns: columns__.unwrap_or_default(),
2552 })
2553 }
2554 }
2555 deserializer.deserialize_struct("stream_plan.Columns", FIELDS, GeneratedVisitor)
2556 }
2557}
2558impl serde::Serialize for ConnectorPropsChangeMutation {
2559 #[allow(deprecated)]
2560 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2561 where
2562 S: serde::Serializer,
2563 {
2564 use serde::ser::SerializeStruct;
2565 let mut len = 0;
2566 if !self.connector_props_infos.is_empty() {
2567 len += 1;
2568 }
2569 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation", len)?;
2570 if !self.connector_props_infos.is_empty() {
2571 struct_ser.serialize_field("connectorPropsInfos", &self.connector_props_infos)?;
2572 }
2573 struct_ser.end()
2574 }
2575}
2576impl<'de> serde::Deserialize<'de> for ConnectorPropsChangeMutation {
2577 #[allow(deprecated)]
2578 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2579 where
2580 D: serde::Deserializer<'de>,
2581 {
2582 const FIELDS: &[&str] = &[
2583 "connector_props_infos",
2584 "connectorPropsInfos",
2585 ];
2586
2587 #[allow(clippy::enum_variant_names)]
2588 enum GeneratedField {
2589 ConnectorPropsInfos,
2590 }
2591 impl<'de> serde::Deserialize<'de> for GeneratedField {
2592 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2593 where
2594 D: serde::Deserializer<'de>,
2595 {
2596 struct GeneratedVisitor;
2597
2598 impl serde::de::Visitor<'_> for GeneratedVisitor {
2599 type Value = GeneratedField;
2600
2601 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2602 write!(formatter, "expected one of: {:?}", &FIELDS)
2603 }
2604
2605 #[allow(unused_variables)]
2606 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2607 where
2608 E: serde::de::Error,
2609 {
2610 match value {
2611 "connectorPropsInfos" | "connector_props_infos" => Ok(GeneratedField::ConnectorPropsInfos),
2612 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2613 }
2614 }
2615 }
2616 deserializer.deserialize_identifier(GeneratedVisitor)
2617 }
2618 }
2619 struct GeneratedVisitor;
2620 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2621 type Value = ConnectorPropsChangeMutation;
2622
2623 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2624 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation")
2625 }
2626
2627 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectorPropsChangeMutation, V::Error>
2628 where
2629 V: serde::de::MapAccess<'de>,
2630 {
2631 let mut connector_props_infos__ = None;
2632 while let Some(k) = map_.next_key()? {
2633 match k {
2634 GeneratedField::ConnectorPropsInfos => {
2635 if connector_props_infos__.is_some() {
2636 return Err(serde::de::Error::duplicate_field("connectorPropsInfos"));
2637 }
2638 connector_props_infos__ = Some(
2639 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
2640 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
2641 );
2642 }
2643 }
2644 }
2645 Ok(ConnectorPropsChangeMutation {
2646 connector_props_infos: connector_props_infos__.unwrap_or_default(),
2647 })
2648 }
2649 }
2650 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation", FIELDS, GeneratedVisitor)
2651 }
2652}
2653impl serde::Serialize for connector_props_change_mutation::ConnectorPropsInfo {
2654 #[allow(deprecated)]
2655 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2656 where
2657 S: serde::Serializer,
2658 {
2659 use serde::ser::SerializeStruct;
2660 let mut len = 0;
2661 if !self.connector_props_info.is_empty() {
2662 len += 1;
2663 }
2664 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", len)?;
2665 if !self.connector_props_info.is_empty() {
2666 struct_ser.serialize_field("connectorPropsInfo", &self.connector_props_info)?;
2667 }
2668 struct_ser.end()
2669 }
2670}
2671impl<'de> serde::Deserialize<'de> for connector_props_change_mutation::ConnectorPropsInfo {
2672 #[allow(deprecated)]
2673 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2674 where
2675 D: serde::Deserializer<'de>,
2676 {
2677 const FIELDS: &[&str] = &[
2678 "connector_props_info",
2679 "connectorPropsInfo",
2680 ];
2681
2682 #[allow(clippy::enum_variant_names)]
2683 enum GeneratedField {
2684 ConnectorPropsInfo,
2685 }
2686 impl<'de> serde::Deserialize<'de> for GeneratedField {
2687 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2688 where
2689 D: serde::Deserializer<'de>,
2690 {
2691 struct GeneratedVisitor;
2692
2693 impl serde::de::Visitor<'_> for GeneratedVisitor {
2694 type Value = GeneratedField;
2695
2696 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2697 write!(formatter, "expected one of: {:?}", &FIELDS)
2698 }
2699
2700 #[allow(unused_variables)]
2701 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2702 where
2703 E: serde::de::Error,
2704 {
2705 match value {
2706 "connectorPropsInfo" | "connector_props_info" => Ok(GeneratedField::ConnectorPropsInfo),
2707 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2708 }
2709 }
2710 }
2711 deserializer.deserialize_identifier(GeneratedVisitor)
2712 }
2713 }
2714 struct GeneratedVisitor;
2715 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2716 type Value = connector_props_change_mutation::ConnectorPropsInfo;
2717
2718 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2719 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo")
2720 }
2721
2722 fn visit_map<V>(self, mut map_: V) -> std::result::Result<connector_props_change_mutation::ConnectorPropsInfo, V::Error>
2723 where
2724 V: serde::de::MapAccess<'de>,
2725 {
2726 let mut connector_props_info__ = None;
2727 while let Some(k) = map_.next_key()? {
2728 match k {
2729 GeneratedField::ConnectorPropsInfo => {
2730 if connector_props_info__.is_some() {
2731 return Err(serde::de::Error::duplicate_field("connectorPropsInfo"));
2732 }
2733 connector_props_info__ = Some(
2734 map_.next_value::<std::collections::HashMap<_, _>>()?
2735 );
2736 }
2737 }
2738 }
2739 Ok(connector_props_change_mutation::ConnectorPropsInfo {
2740 connector_props_info: connector_props_info__.unwrap_or_default(),
2741 })
2742 }
2743 }
2744 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", FIELDS, GeneratedVisitor)
2745 }
2746}
2747impl serde::Serialize for DedupNode {
2748 #[allow(deprecated)]
2749 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2750 where
2751 S: serde::Serializer,
2752 {
2753 use serde::ser::SerializeStruct;
2754 let mut len = 0;
2755 if self.state_table.is_some() {
2756 len += 1;
2757 }
2758 if !self.dedup_column_indices.is_empty() {
2759 len += 1;
2760 }
2761 let mut struct_ser = serializer.serialize_struct("stream_plan.DedupNode", len)?;
2762 if let Some(v) = self.state_table.as_ref() {
2763 struct_ser.serialize_field("stateTable", v)?;
2764 }
2765 if !self.dedup_column_indices.is_empty() {
2766 struct_ser.serialize_field("dedupColumnIndices", &self.dedup_column_indices)?;
2767 }
2768 struct_ser.end()
2769 }
2770}
2771impl<'de> serde::Deserialize<'de> for DedupNode {
2772 #[allow(deprecated)]
2773 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2774 where
2775 D: serde::Deserializer<'de>,
2776 {
2777 const FIELDS: &[&str] = &[
2778 "state_table",
2779 "stateTable",
2780 "dedup_column_indices",
2781 "dedupColumnIndices",
2782 ];
2783
2784 #[allow(clippy::enum_variant_names)]
2785 enum GeneratedField {
2786 StateTable,
2787 DedupColumnIndices,
2788 }
2789 impl<'de> serde::Deserialize<'de> for GeneratedField {
2790 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2791 where
2792 D: serde::Deserializer<'de>,
2793 {
2794 struct GeneratedVisitor;
2795
2796 impl serde::de::Visitor<'_> for GeneratedVisitor {
2797 type Value = GeneratedField;
2798
2799 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2800 write!(formatter, "expected one of: {:?}", &FIELDS)
2801 }
2802
2803 #[allow(unused_variables)]
2804 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2805 where
2806 E: serde::de::Error,
2807 {
2808 match value {
2809 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
2810 "dedupColumnIndices" | "dedup_column_indices" => Ok(GeneratedField::DedupColumnIndices),
2811 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2812 }
2813 }
2814 }
2815 deserializer.deserialize_identifier(GeneratedVisitor)
2816 }
2817 }
2818 struct GeneratedVisitor;
2819 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2820 type Value = DedupNode;
2821
2822 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2823 formatter.write_str("struct stream_plan.DedupNode")
2824 }
2825
2826 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DedupNode, V::Error>
2827 where
2828 V: serde::de::MapAccess<'de>,
2829 {
2830 let mut state_table__ = None;
2831 let mut dedup_column_indices__ = None;
2832 while let Some(k) = map_.next_key()? {
2833 match k {
2834 GeneratedField::StateTable => {
2835 if state_table__.is_some() {
2836 return Err(serde::de::Error::duplicate_field("stateTable"));
2837 }
2838 state_table__ = map_.next_value()?;
2839 }
2840 GeneratedField::DedupColumnIndices => {
2841 if dedup_column_indices__.is_some() {
2842 return Err(serde::de::Error::duplicate_field("dedupColumnIndices"));
2843 }
2844 dedup_column_indices__ =
2845 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2846 .into_iter().map(|x| x.0).collect())
2847 ;
2848 }
2849 }
2850 }
2851 Ok(DedupNode {
2852 state_table: state_table__,
2853 dedup_column_indices: dedup_column_indices__.unwrap_or_default(),
2854 })
2855 }
2856 }
2857 deserializer.deserialize_struct("stream_plan.DedupNode", FIELDS, GeneratedVisitor)
2858 }
2859}
2860impl serde::Serialize for DeltaExpression {
2861 #[allow(deprecated)]
2862 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2863 where
2864 S: serde::Serializer,
2865 {
2866 use serde::ser::SerializeStruct;
2867 let mut len = 0;
2868 if self.delta_type != 0 {
2869 len += 1;
2870 }
2871 if self.delta.is_some() {
2872 len += 1;
2873 }
2874 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaExpression", len)?;
2875 if self.delta_type != 0 {
2876 let v = super::expr::expr_node::Type::try_from(self.delta_type)
2877 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.delta_type)))?;
2878 struct_ser.serialize_field("deltaType", &v)?;
2879 }
2880 if let Some(v) = self.delta.as_ref() {
2881 struct_ser.serialize_field("delta", v)?;
2882 }
2883 struct_ser.end()
2884 }
2885}
2886impl<'de> serde::Deserialize<'de> for DeltaExpression {
2887 #[allow(deprecated)]
2888 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2889 where
2890 D: serde::Deserializer<'de>,
2891 {
2892 const FIELDS: &[&str] = &[
2893 "delta_type",
2894 "deltaType",
2895 "delta",
2896 ];
2897
2898 #[allow(clippy::enum_variant_names)]
2899 enum GeneratedField {
2900 DeltaType,
2901 Delta,
2902 }
2903 impl<'de> serde::Deserialize<'de> for GeneratedField {
2904 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2905 where
2906 D: serde::Deserializer<'de>,
2907 {
2908 struct GeneratedVisitor;
2909
2910 impl serde::de::Visitor<'_> for GeneratedVisitor {
2911 type Value = GeneratedField;
2912
2913 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2914 write!(formatter, "expected one of: {:?}", &FIELDS)
2915 }
2916
2917 #[allow(unused_variables)]
2918 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2919 where
2920 E: serde::de::Error,
2921 {
2922 match value {
2923 "deltaType" | "delta_type" => Ok(GeneratedField::DeltaType),
2924 "delta" => Ok(GeneratedField::Delta),
2925 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2926 }
2927 }
2928 }
2929 deserializer.deserialize_identifier(GeneratedVisitor)
2930 }
2931 }
2932 struct GeneratedVisitor;
2933 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2934 type Value = DeltaExpression;
2935
2936 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2937 formatter.write_str("struct stream_plan.DeltaExpression")
2938 }
2939
2940 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaExpression, V::Error>
2941 where
2942 V: serde::de::MapAccess<'de>,
2943 {
2944 let mut delta_type__ = None;
2945 let mut delta__ = None;
2946 while let Some(k) = map_.next_key()? {
2947 match k {
2948 GeneratedField::DeltaType => {
2949 if delta_type__.is_some() {
2950 return Err(serde::de::Error::duplicate_field("deltaType"));
2951 }
2952 delta_type__ = Some(map_.next_value::<super::expr::expr_node::Type>()? as i32);
2953 }
2954 GeneratedField::Delta => {
2955 if delta__.is_some() {
2956 return Err(serde::de::Error::duplicate_field("delta"));
2957 }
2958 delta__ = map_.next_value()?;
2959 }
2960 }
2961 }
2962 Ok(DeltaExpression {
2963 delta_type: delta_type__.unwrap_or_default(),
2964 delta: delta__,
2965 })
2966 }
2967 }
2968 deserializer.deserialize_struct("stream_plan.DeltaExpression", FIELDS, GeneratedVisitor)
2969 }
2970}
2971impl serde::Serialize for DeltaIndexJoinNode {
2972 #[allow(deprecated)]
2973 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2974 where
2975 S: serde::Serializer,
2976 {
2977 use serde::ser::SerializeStruct;
2978 let mut len = 0;
2979 if self.join_type != 0 {
2980 len += 1;
2981 }
2982 if !self.left_key.is_empty() {
2983 len += 1;
2984 }
2985 if !self.right_key.is_empty() {
2986 len += 1;
2987 }
2988 if self.condition.is_some() {
2989 len += 1;
2990 }
2991 if self.left_table_id != 0 {
2992 len += 1;
2993 }
2994 if self.right_table_id != 0 {
2995 len += 1;
2996 }
2997 if self.left_info.is_some() {
2998 len += 1;
2999 }
3000 if self.right_info.is_some() {
3001 len += 1;
3002 }
3003 if !self.output_indices.is_empty() {
3004 len += 1;
3005 }
3006 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaIndexJoinNode", len)?;
3007 if self.join_type != 0 {
3008 let v = super::plan_common::JoinType::try_from(self.join_type)
3009 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
3010 struct_ser.serialize_field("joinType", &v)?;
3011 }
3012 if !self.left_key.is_empty() {
3013 struct_ser.serialize_field("leftKey", &self.left_key)?;
3014 }
3015 if !self.right_key.is_empty() {
3016 struct_ser.serialize_field("rightKey", &self.right_key)?;
3017 }
3018 if let Some(v) = self.condition.as_ref() {
3019 struct_ser.serialize_field("condition", v)?;
3020 }
3021 if self.left_table_id != 0 {
3022 struct_ser.serialize_field("leftTableId", &self.left_table_id)?;
3023 }
3024 if self.right_table_id != 0 {
3025 struct_ser.serialize_field("rightTableId", &self.right_table_id)?;
3026 }
3027 if let Some(v) = self.left_info.as_ref() {
3028 struct_ser.serialize_field("leftInfo", v)?;
3029 }
3030 if let Some(v) = self.right_info.as_ref() {
3031 struct_ser.serialize_field("rightInfo", v)?;
3032 }
3033 if !self.output_indices.is_empty() {
3034 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
3035 }
3036 struct_ser.end()
3037 }
3038}
3039impl<'de> serde::Deserialize<'de> for DeltaIndexJoinNode {
3040 #[allow(deprecated)]
3041 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3042 where
3043 D: serde::Deserializer<'de>,
3044 {
3045 const FIELDS: &[&str] = &[
3046 "join_type",
3047 "joinType",
3048 "left_key",
3049 "leftKey",
3050 "right_key",
3051 "rightKey",
3052 "condition",
3053 "left_table_id",
3054 "leftTableId",
3055 "right_table_id",
3056 "rightTableId",
3057 "left_info",
3058 "leftInfo",
3059 "right_info",
3060 "rightInfo",
3061 "output_indices",
3062 "outputIndices",
3063 ];
3064
3065 #[allow(clippy::enum_variant_names)]
3066 enum GeneratedField {
3067 JoinType,
3068 LeftKey,
3069 RightKey,
3070 Condition,
3071 LeftTableId,
3072 RightTableId,
3073 LeftInfo,
3074 RightInfo,
3075 OutputIndices,
3076 }
3077 impl<'de> serde::Deserialize<'de> for GeneratedField {
3078 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3079 where
3080 D: serde::Deserializer<'de>,
3081 {
3082 struct GeneratedVisitor;
3083
3084 impl serde::de::Visitor<'_> for GeneratedVisitor {
3085 type Value = GeneratedField;
3086
3087 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3088 write!(formatter, "expected one of: {:?}", &FIELDS)
3089 }
3090
3091 #[allow(unused_variables)]
3092 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3093 where
3094 E: serde::de::Error,
3095 {
3096 match value {
3097 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
3098 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
3099 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
3100 "condition" => Ok(GeneratedField::Condition),
3101 "leftTableId" | "left_table_id" => Ok(GeneratedField::LeftTableId),
3102 "rightTableId" | "right_table_id" => Ok(GeneratedField::RightTableId),
3103 "leftInfo" | "left_info" => Ok(GeneratedField::LeftInfo),
3104 "rightInfo" | "right_info" => Ok(GeneratedField::RightInfo),
3105 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
3106 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3107 }
3108 }
3109 }
3110 deserializer.deserialize_identifier(GeneratedVisitor)
3111 }
3112 }
3113 struct GeneratedVisitor;
3114 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3115 type Value = DeltaIndexJoinNode;
3116
3117 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3118 formatter.write_str("struct stream_plan.DeltaIndexJoinNode")
3119 }
3120
3121 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaIndexJoinNode, V::Error>
3122 where
3123 V: serde::de::MapAccess<'de>,
3124 {
3125 let mut join_type__ = None;
3126 let mut left_key__ = None;
3127 let mut right_key__ = None;
3128 let mut condition__ = None;
3129 let mut left_table_id__ = None;
3130 let mut right_table_id__ = None;
3131 let mut left_info__ = None;
3132 let mut right_info__ = None;
3133 let mut output_indices__ = None;
3134 while let Some(k) = map_.next_key()? {
3135 match k {
3136 GeneratedField::JoinType => {
3137 if join_type__.is_some() {
3138 return Err(serde::de::Error::duplicate_field("joinType"));
3139 }
3140 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
3141 }
3142 GeneratedField::LeftKey => {
3143 if left_key__.is_some() {
3144 return Err(serde::de::Error::duplicate_field("leftKey"));
3145 }
3146 left_key__ =
3147 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3148 .into_iter().map(|x| x.0).collect())
3149 ;
3150 }
3151 GeneratedField::RightKey => {
3152 if right_key__.is_some() {
3153 return Err(serde::de::Error::duplicate_field("rightKey"));
3154 }
3155 right_key__ =
3156 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3157 .into_iter().map(|x| x.0).collect())
3158 ;
3159 }
3160 GeneratedField::Condition => {
3161 if condition__.is_some() {
3162 return Err(serde::de::Error::duplicate_field("condition"));
3163 }
3164 condition__ = map_.next_value()?;
3165 }
3166 GeneratedField::LeftTableId => {
3167 if left_table_id__.is_some() {
3168 return Err(serde::de::Error::duplicate_field("leftTableId"));
3169 }
3170 left_table_id__ =
3171 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3172 ;
3173 }
3174 GeneratedField::RightTableId => {
3175 if right_table_id__.is_some() {
3176 return Err(serde::de::Error::duplicate_field("rightTableId"));
3177 }
3178 right_table_id__ =
3179 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3180 ;
3181 }
3182 GeneratedField::LeftInfo => {
3183 if left_info__.is_some() {
3184 return Err(serde::de::Error::duplicate_field("leftInfo"));
3185 }
3186 left_info__ = map_.next_value()?;
3187 }
3188 GeneratedField::RightInfo => {
3189 if right_info__.is_some() {
3190 return Err(serde::de::Error::duplicate_field("rightInfo"));
3191 }
3192 right_info__ = map_.next_value()?;
3193 }
3194 GeneratedField::OutputIndices => {
3195 if output_indices__.is_some() {
3196 return Err(serde::de::Error::duplicate_field("outputIndices"));
3197 }
3198 output_indices__ =
3199 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3200 .into_iter().map(|x| x.0).collect())
3201 ;
3202 }
3203 }
3204 }
3205 Ok(DeltaIndexJoinNode {
3206 join_type: join_type__.unwrap_or_default(),
3207 left_key: left_key__.unwrap_or_default(),
3208 right_key: right_key__.unwrap_or_default(),
3209 condition: condition__,
3210 left_table_id: left_table_id__.unwrap_or_default(),
3211 right_table_id: right_table_id__.unwrap_or_default(),
3212 left_info: left_info__,
3213 right_info: right_info__,
3214 output_indices: output_indices__.unwrap_or_default(),
3215 })
3216 }
3217 }
3218 deserializer.deserialize_struct("stream_plan.DeltaIndexJoinNode", FIELDS, GeneratedVisitor)
3219 }
3220}
3221impl serde::Serialize for DispatchOutputMapping {
3222 #[allow(deprecated)]
3223 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3224 where
3225 S: serde::Serializer,
3226 {
3227 use serde::ser::SerializeStruct;
3228 let mut len = 0;
3229 if !self.indices.is_empty() {
3230 len += 1;
3231 }
3232 if !self.types.is_empty() {
3233 len += 1;
3234 }
3235 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping", len)?;
3236 if !self.indices.is_empty() {
3237 struct_ser.serialize_field("indices", &self.indices)?;
3238 }
3239 if !self.types.is_empty() {
3240 struct_ser.serialize_field("types", &self.types)?;
3241 }
3242 struct_ser.end()
3243 }
3244}
3245impl<'de> serde::Deserialize<'de> for DispatchOutputMapping {
3246 #[allow(deprecated)]
3247 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3248 where
3249 D: serde::Deserializer<'de>,
3250 {
3251 const FIELDS: &[&str] = &[
3252 "indices",
3253 "types",
3254 ];
3255
3256 #[allow(clippy::enum_variant_names)]
3257 enum GeneratedField {
3258 Indices,
3259 Types,
3260 }
3261 impl<'de> serde::Deserialize<'de> for GeneratedField {
3262 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3263 where
3264 D: serde::Deserializer<'de>,
3265 {
3266 struct GeneratedVisitor;
3267
3268 impl serde::de::Visitor<'_> for GeneratedVisitor {
3269 type Value = GeneratedField;
3270
3271 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3272 write!(formatter, "expected one of: {:?}", &FIELDS)
3273 }
3274
3275 #[allow(unused_variables)]
3276 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3277 where
3278 E: serde::de::Error,
3279 {
3280 match value {
3281 "indices" => Ok(GeneratedField::Indices),
3282 "types" => Ok(GeneratedField::Types),
3283 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3284 }
3285 }
3286 }
3287 deserializer.deserialize_identifier(GeneratedVisitor)
3288 }
3289 }
3290 struct GeneratedVisitor;
3291 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3292 type Value = DispatchOutputMapping;
3293
3294 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3295 formatter.write_str("struct stream_plan.DispatchOutputMapping")
3296 }
3297
3298 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchOutputMapping, V::Error>
3299 where
3300 V: serde::de::MapAccess<'de>,
3301 {
3302 let mut indices__ = None;
3303 let mut types__ = None;
3304 while let Some(k) = map_.next_key()? {
3305 match k {
3306 GeneratedField::Indices => {
3307 if indices__.is_some() {
3308 return Err(serde::de::Error::duplicate_field("indices"));
3309 }
3310 indices__ =
3311 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3312 .into_iter().map(|x| x.0).collect())
3313 ;
3314 }
3315 GeneratedField::Types => {
3316 if types__.is_some() {
3317 return Err(serde::de::Error::duplicate_field("types"));
3318 }
3319 types__ = Some(map_.next_value()?);
3320 }
3321 }
3322 }
3323 Ok(DispatchOutputMapping {
3324 indices: indices__.unwrap_or_default(),
3325 types: types__.unwrap_or_default(),
3326 })
3327 }
3328 }
3329 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping", FIELDS, GeneratedVisitor)
3330 }
3331}
3332impl serde::Serialize for dispatch_output_mapping::TypePair {
3333 #[allow(deprecated)]
3334 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3335 where
3336 S: serde::Serializer,
3337 {
3338 use serde::ser::SerializeStruct;
3339 let mut len = 0;
3340 if self.upstream.is_some() {
3341 len += 1;
3342 }
3343 if self.downstream.is_some() {
3344 len += 1;
3345 }
3346 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping.TypePair", len)?;
3347 if let Some(v) = self.upstream.as_ref() {
3348 struct_ser.serialize_field("upstream", v)?;
3349 }
3350 if let Some(v) = self.downstream.as_ref() {
3351 struct_ser.serialize_field("downstream", v)?;
3352 }
3353 struct_ser.end()
3354 }
3355}
3356impl<'de> serde::Deserialize<'de> for dispatch_output_mapping::TypePair {
3357 #[allow(deprecated)]
3358 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3359 where
3360 D: serde::Deserializer<'de>,
3361 {
3362 const FIELDS: &[&str] = &[
3363 "upstream",
3364 "downstream",
3365 ];
3366
3367 #[allow(clippy::enum_variant_names)]
3368 enum GeneratedField {
3369 Upstream,
3370 Downstream,
3371 }
3372 impl<'de> serde::Deserialize<'de> for GeneratedField {
3373 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3374 where
3375 D: serde::Deserializer<'de>,
3376 {
3377 struct GeneratedVisitor;
3378
3379 impl serde::de::Visitor<'_> for GeneratedVisitor {
3380 type Value = GeneratedField;
3381
3382 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3383 write!(formatter, "expected one of: {:?}", &FIELDS)
3384 }
3385
3386 #[allow(unused_variables)]
3387 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3388 where
3389 E: serde::de::Error,
3390 {
3391 match value {
3392 "upstream" => Ok(GeneratedField::Upstream),
3393 "downstream" => Ok(GeneratedField::Downstream),
3394 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3395 }
3396 }
3397 }
3398 deserializer.deserialize_identifier(GeneratedVisitor)
3399 }
3400 }
3401 struct GeneratedVisitor;
3402 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3403 type Value = dispatch_output_mapping::TypePair;
3404
3405 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3406 formatter.write_str("struct stream_plan.DispatchOutputMapping.TypePair")
3407 }
3408
3409 fn visit_map<V>(self, mut map_: V) -> std::result::Result<dispatch_output_mapping::TypePair, V::Error>
3410 where
3411 V: serde::de::MapAccess<'de>,
3412 {
3413 let mut upstream__ = None;
3414 let mut downstream__ = None;
3415 while let Some(k) = map_.next_key()? {
3416 match k {
3417 GeneratedField::Upstream => {
3418 if upstream__.is_some() {
3419 return Err(serde::de::Error::duplicate_field("upstream"));
3420 }
3421 upstream__ = map_.next_value()?;
3422 }
3423 GeneratedField::Downstream => {
3424 if downstream__.is_some() {
3425 return Err(serde::de::Error::duplicate_field("downstream"));
3426 }
3427 downstream__ = map_.next_value()?;
3428 }
3429 }
3430 }
3431 Ok(dispatch_output_mapping::TypePair {
3432 upstream: upstream__,
3433 downstream: downstream__,
3434 })
3435 }
3436 }
3437 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping.TypePair", FIELDS, GeneratedVisitor)
3438 }
3439}
3440impl serde::Serialize for DispatchStrategy {
3441 #[allow(deprecated)]
3442 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3443 where
3444 S: serde::Serializer,
3445 {
3446 use serde::ser::SerializeStruct;
3447 let mut len = 0;
3448 if self.r#type != 0 {
3449 len += 1;
3450 }
3451 if !self.dist_key_indices.is_empty() {
3452 len += 1;
3453 }
3454 if self.output_mapping.is_some() {
3455 len += 1;
3456 }
3457 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchStrategy", len)?;
3458 if self.r#type != 0 {
3459 let v = DispatcherType::try_from(self.r#type)
3460 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3461 struct_ser.serialize_field("type", &v)?;
3462 }
3463 if !self.dist_key_indices.is_empty() {
3464 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3465 }
3466 if let Some(v) = self.output_mapping.as_ref() {
3467 struct_ser.serialize_field("outputMapping", v)?;
3468 }
3469 struct_ser.end()
3470 }
3471}
3472impl<'de> serde::Deserialize<'de> for DispatchStrategy {
3473 #[allow(deprecated)]
3474 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3475 where
3476 D: serde::Deserializer<'de>,
3477 {
3478 const FIELDS: &[&str] = &[
3479 "type",
3480 "dist_key_indices",
3481 "distKeyIndices",
3482 "output_mapping",
3483 "outputMapping",
3484 ];
3485
3486 #[allow(clippy::enum_variant_names)]
3487 enum GeneratedField {
3488 Type,
3489 DistKeyIndices,
3490 OutputMapping,
3491 }
3492 impl<'de> serde::Deserialize<'de> for GeneratedField {
3493 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3494 where
3495 D: serde::Deserializer<'de>,
3496 {
3497 struct GeneratedVisitor;
3498
3499 impl serde::de::Visitor<'_> for GeneratedVisitor {
3500 type Value = GeneratedField;
3501
3502 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3503 write!(formatter, "expected one of: {:?}", &FIELDS)
3504 }
3505
3506 #[allow(unused_variables)]
3507 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3508 where
3509 E: serde::de::Error,
3510 {
3511 match value {
3512 "type" => Ok(GeneratedField::Type),
3513 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3514 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3515 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3516 }
3517 }
3518 }
3519 deserializer.deserialize_identifier(GeneratedVisitor)
3520 }
3521 }
3522 struct GeneratedVisitor;
3523 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3524 type Value = DispatchStrategy;
3525
3526 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3527 formatter.write_str("struct stream_plan.DispatchStrategy")
3528 }
3529
3530 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchStrategy, V::Error>
3531 where
3532 V: serde::de::MapAccess<'de>,
3533 {
3534 let mut r#type__ = None;
3535 let mut dist_key_indices__ = None;
3536 let mut output_mapping__ = None;
3537 while let Some(k) = map_.next_key()? {
3538 match k {
3539 GeneratedField::Type => {
3540 if r#type__.is_some() {
3541 return Err(serde::de::Error::duplicate_field("type"));
3542 }
3543 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3544 }
3545 GeneratedField::DistKeyIndices => {
3546 if dist_key_indices__.is_some() {
3547 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3548 }
3549 dist_key_indices__ =
3550 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3551 .into_iter().map(|x| x.0).collect())
3552 ;
3553 }
3554 GeneratedField::OutputMapping => {
3555 if output_mapping__.is_some() {
3556 return Err(serde::de::Error::duplicate_field("outputMapping"));
3557 }
3558 output_mapping__ = map_.next_value()?;
3559 }
3560 }
3561 }
3562 Ok(DispatchStrategy {
3563 r#type: r#type__.unwrap_or_default(),
3564 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3565 output_mapping: output_mapping__,
3566 })
3567 }
3568 }
3569 deserializer.deserialize_struct("stream_plan.DispatchStrategy", FIELDS, GeneratedVisitor)
3570 }
3571}
3572impl serde::Serialize for Dispatcher {
3573 #[allow(deprecated)]
3574 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3575 where
3576 S: serde::Serializer,
3577 {
3578 use serde::ser::SerializeStruct;
3579 let mut len = 0;
3580 if self.r#type != 0 {
3581 len += 1;
3582 }
3583 if !self.dist_key_indices.is_empty() {
3584 len += 1;
3585 }
3586 if self.output_mapping.is_some() {
3587 len += 1;
3588 }
3589 if self.hash_mapping.is_some() {
3590 len += 1;
3591 }
3592 if self.dispatcher_id != 0 {
3593 len += 1;
3594 }
3595 if !self.downstream_actor_id.is_empty() {
3596 len += 1;
3597 }
3598 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatcher", len)?;
3599 if self.r#type != 0 {
3600 let v = DispatcherType::try_from(self.r#type)
3601 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3602 struct_ser.serialize_field("type", &v)?;
3603 }
3604 if !self.dist_key_indices.is_empty() {
3605 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3606 }
3607 if let Some(v) = self.output_mapping.as_ref() {
3608 struct_ser.serialize_field("outputMapping", v)?;
3609 }
3610 if let Some(v) = self.hash_mapping.as_ref() {
3611 struct_ser.serialize_field("hashMapping", v)?;
3612 }
3613 if self.dispatcher_id != 0 {
3614 struct_ser.serialize_field("dispatcherId", &self.dispatcher_id)?;
3615 }
3616 if !self.downstream_actor_id.is_empty() {
3617 struct_ser.serialize_field("downstreamActorId", &self.downstream_actor_id)?;
3618 }
3619 struct_ser.end()
3620 }
3621}
3622impl<'de> serde::Deserialize<'de> for Dispatcher {
3623 #[allow(deprecated)]
3624 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3625 where
3626 D: serde::Deserializer<'de>,
3627 {
3628 const FIELDS: &[&str] = &[
3629 "type",
3630 "dist_key_indices",
3631 "distKeyIndices",
3632 "output_mapping",
3633 "outputMapping",
3634 "hash_mapping",
3635 "hashMapping",
3636 "dispatcher_id",
3637 "dispatcherId",
3638 "downstream_actor_id",
3639 "downstreamActorId",
3640 ];
3641
3642 #[allow(clippy::enum_variant_names)]
3643 enum GeneratedField {
3644 Type,
3645 DistKeyIndices,
3646 OutputMapping,
3647 HashMapping,
3648 DispatcherId,
3649 DownstreamActorId,
3650 }
3651 impl<'de> serde::Deserialize<'de> for GeneratedField {
3652 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3653 where
3654 D: serde::Deserializer<'de>,
3655 {
3656 struct GeneratedVisitor;
3657
3658 impl serde::de::Visitor<'_> for GeneratedVisitor {
3659 type Value = GeneratedField;
3660
3661 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3662 write!(formatter, "expected one of: {:?}", &FIELDS)
3663 }
3664
3665 #[allow(unused_variables)]
3666 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3667 where
3668 E: serde::de::Error,
3669 {
3670 match value {
3671 "type" => Ok(GeneratedField::Type),
3672 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3673 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3674 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
3675 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
3676 "downstreamActorId" | "downstream_actor_id" => Ok(GeneratedField::DownstreamActorId),
3677 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3678 }
3679 }
3680 }
3681 deserializer.deserialize_identifier(GeneratedVisitor)
3682 }
3683 }
3684 struct GeneratedVisitor;
3685 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3686 type Value = Dispatcher;
3687
3688 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3689 formatter.write_str("struct stream_plan.Dispatcher")
3690 }
3691
3692 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatcher, V::Error>
3693 where
3694 V: serde::de::MapAccess<'de>,
3695 {
3696 let mut r#type__ = None;
3697 let mut dist_key_indices__ = None;
3698 let mut output_mapping__ = None;
3699 let mut hash_mapping__ = None;
3700 let mut dispatcher_id__ = None;
3701 let mut downstream_actor_id__ = None;
3702 while let Some(k) = map_.next_key()? {
3703 match k {
3704 GeneratedField::Type => {
3705 if r#type__.is_some() {
3706 return Err(serde::de::Error::duplicate_field("type"));
3707 }
3708 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3709 }
3710 GeneratedField::DistKeyIndices => {
3711 if dist_key_indices__.is_some() {
3712 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3713 }
3714 dist_key_indices__ =
3715 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3716 .into_iter().map(|x| x.0).collect())
3717 ;
3718 }
3719 GeneratedField::OutputMapping => {
3720 if output_mapping__.is_some() {
3721 return Err(serde::de::Error::duplicate_field("outputMapping"));
3722 }
3723 output_mapping__ = map_.next_value()?;
3724 }
3725 GeneratedField::HashMapping => {
3726 if hash_mapping__.is_some() {
3727 return Err(serde::de::Error::duplicate_field("hashMapping"));
3728 }
3729 hash_mapping__ = map_.next_value()?;
3730 }
3731 GeneratedField::DispatcherId => {
3732 if dispatcher_id__.is_some() {
3733 return Err(serde::de::Error::duplicate_field("dispatcherId"));
3734 }
3735 dispatcher_id__ =
3736 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3737 ;
3738 }
3739 GeneratedField::DownstreamActorId => {
3740 if downstream_actor_id__.is_some() {
3741 return Err(serde::de::Error::duplicate_field("downstreamActorId"));
3742 }
3743 downstream_actor_id__ =
3744 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3745 .into_iter().map(|x| x.0).collect())
3746 ;
3747 }
3748 }
3749 }
3750 Ok(Dispatcher {
3751 r#type: r#type__.unwrap_or_default(),
3752 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3753 output_mapping: output_mapping__,
3754 hash_mapping: hash_mapping__,
3755 dispatcher_id: dispatcher_id__.unwrap_or_default(),
3756 downstream_actor_id: downstream_actor_id__.unwrap_or_default(),
3757 })
3758 }
3759 }
3760 deserializer.deserialize_struct("stream_plan.Dispatcher", FIELDS, GeneratedVisitor)
3761 }
3762}
3763impl serde::Serialize for DispatcherType {
3764 #[allow(deprecated)]
3765 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3766 where
3767 S: serde::Serializer,
3768 {
3769 let variant = match self {
3770 Self::Unspecified => "DISPATCHER_TYPE_UNSPECIFIED",
3771 Self::Hash => "DISPATCHER_TYPE_HASH",
3772 Self::Broadcast => "DISPATCHER_TYPE_BROADCAST",
3773 Self::Simple => "DISPATCHER_TYPE_SIMPLE",
3774 Self::NoShuffle => "DISPATCHER_TYPE_NO_SHUFFLE",
3775 };
3776 serializer.serialize_str(variant)
3777 }
3778}
3779impl<'de> serde::Deserialize<'de> for DispatcherType {
3780 #[allow(deprecated)]
3781 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3782 where
3783 D: serde::Deserializer<'de>,
3784 {
3785 const FIELDS: &[&str] = &[
3786 "DISPATCHER_TYPE_UNSPECIFIED",
3787 "DISPATCHER_TYPE_HASH",
3788 "DISPATCHER_TYPE_BROADCAST",
3789 "DISPATCHER_TYPE_SIMPLE",
3790 "DISPATCHER_TYPE_NO_SHUFFLE",
3791 ];
3792
3793 struct GeneratedVisitor;
3794
3795 impl serde::de::Visitor<'_> for GeneratedVisitor {
3796 type Value = DispatcherType;
3797
3798 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3799 write!(formatter, "expected one of: {:?}", &FIELDS)
3800 }
3801
3802 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3803 where
3804 E: serde::de::Error,
3805 {
3806 i32::try_from(v)
3807 .ok()
3808 .and_then(|x| x.try_into().ok())
3809 .ok_or_else(|| {
3810 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3811 })
3812 }
3813
3814 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3815 where
3816 E: serde::de::Error,
3817 {
3818 i32::try_from(v)
3819 .ok()
3820 .and_then(|x| x.try_into().ok())
3821 .ok_or_else(|| {
3822 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3823 })
3824 }
3825
3826 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3827 where
3828 E: serde::de::Error,
3829 {
3830 match value {
3831 "DISPATCHER_TYPE_UNSPECIFIED" => Ok(DispatcherType::Unspecified),
3832 "DISPATCHER_TYPE_HASH" => Ok(DispatcherType::Hash),
3833 "DISPATCHER_TYPE_BROADCAST" => Ok(DispatcherType::Broadcast),
3834 "DISPATCHER_TYPE_SIMPLE" => Ok(DispatcherType::Simple),
3835 "DISPATCHER_TYPE_NO_SHUFFLE" => Ok(DispatcherType::NoShuffle),
3836 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3837 }
3838 }
3839 }
3840 deserializer.deserialize_any(GeneratedVisitor)
3841 }
3842}
3843impl serde::Serialize for Dispatchers {
3844 #[allow(deprecated)]
3845 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3846 where
3847 S: serde::Serializer,
3848 {
3849 use serde::ser::SerializeStruct;
3850 let mut len = 0;
3851 if !self.dispatchers.is_empty() {
3852 len += 1;
3853 }
3854 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatchers", len)?;
3855 if !self.dispatchers.is_empty() {
3856 struct_ser.serialize_field("dispatchers", &self.dispatchers)?;
3857 }
3858 struct_ser.end()
3859 }
3860}
3861impl<'de> serde::Deserialize<'de> for Dispatchers {
3862 #[allow(deprecated)]
3863 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3864 where
3865 D: serde::Deserializer<'de>,
3866 {
3867 const FIELDS: &[&str] = &[
3868 "dispatchers",
3869 ];
3870
3871 #[allow(clippy::enum_variant_names)]
3872 enum GeneratedField {
3873 Dispatchers,
3874 }
3875 impl<'de> serde::Deserialize<'de> for GeneratedField {
3876 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3877 where
3878 D: serde::Deserializer<'de>,
3879 {
3880 struct GeneratedVisitor;
3881
3882 impl serde::de::Visitor<'_> for GeneratedVisitor {
3883 type Value = GeneratedField;
3884
3885 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3886 write!(formatter, "expected one of: {:?}", &FIELDS)
3887 }
3888
3889 #[allow(unused_variables)]
3890 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3891 where
3892 E: serde::de::Error,
3893 {
3894 match value {
3895 "dispatchers" => Ok(GeneratedField::Dispatchers),
3896 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3897 }
3898 }
3899 }
3900 deserializer.deserialize_identifier(GeneratedVisitor)
3901 }
3902 }
3903 struct GeneratedVisitor;
3904 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3905 type Value = Dispatchers;
3906
3907 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3908 formatter.write_str("struct stream_plan.Dispatchers")
3909 }
3910
3911 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatchers, V::Error>
3912 where
3913 V: serde::de::MapAccess<'de>,
3914 {
3915 let mut dispatchers__ = None;
3916 while let Some(k) = map_.next_key()? {
3917 match k {
3918 GeneratedField::Dispatchers => {
3919 if dispatchers__.is_some() {
3920 return Err(serde::de::Error::duplicate_field("dispatchers"));
3921 }
3922 dispatchers__ = Some(map_.next_value()?);
3923 }
3924 }
3925 }
3926 Ok(Dispatchers {
3927 dispatchers: dispatchers__.unwrap_or_default(),
3928 })
3929 }
3930 }
3931 deserializer.deserialize_struct("stream_plan.Dispatchers", FIELDS, GeneratedVisitor)
3932 }
3933}
3934impl serde::Serialize for DmlNode {
3935 #[allow(deprecated)]
3936 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3937 where
3938 S: serde::Serializer,
3939 {
3940 use serde::ser::SerializeStruct;
3941 let mut len = 0;
3942 if self.table_id != 0 {
3943 len += 1;
3944 }
3945 if self.table_version_id != 0 {
3946 len += 1;
3947 }
3948 if !self.column_descs.is_empty() {
3949 len += 1;
3950 }
3951 if self.rate_limit.is_some() {
3952 len += 1;
3953 }
3954 let mut struct_ser = serializer.serialize_struct("stream_plan.DmlNode", len)?;
3955 if self.table_id != 0 {
3956 struct_ser.serialize_field("tableId", &self.table_id)?;
3957 }
3958 if self.table_version_id != 0 {
3959 #[allow(clippy::needless_borrow)]
3960 #[allow(clippy::needless_borrows_for_generic_args)]
3961 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
3962 }
3963 if !self.column_descs.is_empty() {
3964 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
3965 }
3966 if let Some(v) = self.rate_limit.as_ref() {
3967 struct_ser.serialize_field("rateLimit", v)?;
3968 }
3969 struct_ser.end()
3970 }
3971}
3972impl<'de> serde::Deserialize<'de> for DmlNode {
3973 #[allow(deprecated)]
3974 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3975 where
3976 D: serde::Deserializer<'de>,
3977 {
3978 const FIELDS: &[&str] = &[
3979 "table_id",
3980 "tableId",
3981 "table_version_id",
3982 "tableVersionId",
3983 "column_descs",
3984 "columnDescs",
3985 "rate_limit",
3986 "rateLimit",
3987 ];
3988
3989 #[allow(clippy::enum_variant_names)]
3990 enum GeneratedField {
3991 TableId,
3992 TableVersionId,
3993 ColumnDescs,
3994 RateLimit,
3995 }
3996 impl<'de> serde::Deserialize<'de> for GeneratedField {
3997 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3998 where
3999 D: serde::Deserializer<'de>,
4000 {
4001 struct GeneratedVisitor;
4002
4003 impl serde::de::Visitor<'_> for GeneratedVisitor {
4004 type Value = GeneratedField;
4005
4006 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4007 write!(formatter, "expected one of: {:?}", &FIELDS)
4008 }
4009
4010 #[allow(unused_variables)]
4011 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4012 where
4013 E: serde::de::Error,
4014 {
4015 match value {
4016 "tableId" | "table_id" => Ok(GeneratedField::TableId),
4017 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
4018 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
4019 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
4020 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4021 }
4022 }
4023 }
4024 deserializer.deserialize_identifier(GeneratedVisitor)
4025 }
4026 }
4027 struct GeneratedVisitor;
4028 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4029 type Value = DmlNode;
4030
4031 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4032 formatter.write_str("struct stream_plan.DmlNode")
4033 }
4034
4035 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DmlNode, V::Error>
4036 where
4037 V: serde::de::MapAccess<'de>,
4038 {
4039 let mut table_id__ = None;
4040 let mut table_version_id__ = None;
4041 let mut column_descs__ = None;
4042 let mut rate_limit__ = None;
4043 while let Some(k) = map_.next_key()? {
4044 match k {
4045 GeneratedField::TableId => {
4046 if table_id__.is_some() {
4047 return Err(serde::de::Error::duplicate_field("tableId"));
4048 }
4049 table_id__ =
4050 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4051 ;
4052 }
4053 GeneratedField::TableVersionId => {
4054 if table_version_id__.is_some() {
4055 return Err(serde::de::Error::duplicate_field("tableVersionId"));
4056 }
4057 table_version_id__ =
4058 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4059 ;
4060 }
4061 GeneratedField::ColumnDescs => {
4062 if column_descs__.is_some() {
4063 return Err(serde::de::Error::duplicate_field("columnDescs"));
4064 }
4065 column_descs__ = Some(map_.next_value()?);
4066 }
4067 GeneratedField::RateLimit => {
4068 if rate_limit__.is_some() {
4069 return Err(serde::de::Error::duplicate_field("rateLimit"));
4070 }
4071 rate_limit__ =
4072 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4073 ;
4074 }
4075 }
4076 }
4077 Ok(DmlNode {
4078 table_id: table_id__.unwrap_or_default(),
4079 table_version_id: table_version_id__.unwrap_or_default(),
4080 column_descs: column_descs__.unwrap_or_default(),
4081 rate_limit: rate_limit__,
4082 })
4083 }
4084 }
4085 deserializer.deserialize_struct("stream_plan.DmlNode", FIELDS, GeneratedVisitor)
4086 }
4087}
4088impl serde::Serialize for DropSubscriptionsMutation {
4089 #[allow(deprecated)]
4090 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4091 where
4092 S: serde::Serializer,
4093 {
4094 use serde::ser::SerializeStruct;
4095 let mut len = 0;
4096 if !self.info.is_empty() {
4097 len += 1;
4098 }
4099 let mut struct_ser = serializer.serialize_struct("stream_plan.DropSubscriptionsMutation", len)?;
4100 if !self.info.is_empty() {
4101 struct_ser.serialize_field("info", &self.info)?;
4102 }
4103 struct_ser.end()
4104 }
4105}
4106impl<'de> serde::Deserialize<'de> for DropSubscriptionsMutation {
4107 #[allow(deprecated)]
4108 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4109 where
4110 D: serde::Deserializer<'de>,
4111 {
4112 const FIELDS: &[&str] = &[
4113 "info",
4114 ];
4115
4116 #[allow(clippy::enum_variant_names)]
4117 enum GeneratedField {
4118 Info,
4119 }
4120 impl<'de> serde::Deserialize<'de> for GeneratedField {
4121 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4122 where
4123 D: serde::Deserializer<'de>,
4124 {
4125 struct GeneratedVisitor;
4126
4127 impl serde::de::Visitor<'_> for GeneratedVisitor {
4128 type Value = GeneratedField;
4129
4130 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4131 write!(formatter, "expected one of: {:?}", &FIELDS)
4132 }
4133
4134 #[allow(unused_variables)]
4135 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4136 where
4137 E: serde::de::Error,
4138 {
4139 match value {
4140 "info" => Ok(GeneratedField::Info),
4141 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4142 }
4143 }
4144 }
4145 deserializer.deserialize_identifier(GeneratedVisitor)
4146 }
4147 }
4148 struct GeneratedVisitor;
4149 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4150 type Value = DropSubscriptionsMutation;
4151
4152 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4153 formatter.write_str("struct stream_plan.DropSubscriptionsMutation")
4154 }
4155
4156 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionsMutation, V::Error>
4157 where
4158 V: serde::de::MapAccess<'de>,
4159 {
4160 let mut info__ = None;
4161 while let Some(k) = map_.next_key()? {
4162 match k {
4163 GeneratedField::Info => {
4164 if info__.is_some() {
4165 return Err(serde::de::Error::duplicate_field("info"));
4166 }
4167 info__ = Some(map_.next_value()?);
4168 }
4169 }
4170 }
4171 Ok(DropSubscriptionsMutation {
4172 info: info__.unwrap_or_default(),
4173 })
4174 }
4175 }
4176 deserializer.deserialize_struct("stream_plan.DropSubscriptionsMutation", FIELDS, GeneratedVisitor)
4177 }
4178}
4179impl serde::Serialize for DynamicFilterNode {
4180 #[allow(deprecated)]
4181 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4182 where
4183 S: serde::Serializer,
4184 {
4185 use serde::ser::SerializeStruct;
4186 let mut len = 0;
4187 if self.left_key != 0 {
4188 len += 1;
4189 }
4190 if self.condition.is_some() {
4191 len += 1;
4192 }
4193 if self.left_table.is_some() {
4194 len += 1;
4195 }
4196 if self.right_table.is_some() {
4197 len += 1;
4198 }
4199 if self.condition_always_relax {
4200 len += 1;
4201 }
4202 if self.cleaned_by_watermark {
4203 len += 1;
4204 }
4205 let mut struct_ser = serializer.serialize_struct("stream_plan.DynamicFilterNode", len)?;
4206 if self.left_key != 0 {
4207 struct_ser.serialize_field("leftKey", &self.left_key)?;
4208 }
4209 if let Some(v) = self.condition.as_ref() {
4210 struct_ser.serialize_field("condition", v)?;
4211 }
4212 if let Some(v) = self.left_table.as_ref() {
4213 struct_ser.serialize_field("leftTable", v)?;
4214 }
4215 if let Some(v) = self.right_table.as_ref() {
4216 struct_ser.serialize_field("rightTable", v)?;
4217 }
4218 if self.condition_always_relax {
4219 struct_ser.serialize_field("conditionAlwaysRelax", &self.condition_always_relax)?;
4220 }
4221 if self.cleaned_by_watermark {
4222 struct_ser.serialize_field("cleanedByWatermark", &self.cleaned_by_watermark)?;
4223 }
4224 struct_ser.end()
4225 }
4226}
4227impl<'de> serde::Deserialize<'de> for DynamicFilterNode {
4228 #[allow(deprecated)]
4229 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4230 where
4231 D: serde::Deserializer<'de>,
4232 {
4233 const FIELDS: &[&str] = &[
4234 "left_key",
4235 "leftKey",
4236 "condition",
4237 "left_table",
4238 "leftTable",
4239 "right_table",
4240 "rightTable",
4241 "condition_always_relax",
4242 "conditionAlwaysRelax",
4243 "cleaned_by_watermark",
4244 "cleanedByWatermark",
4245 ];
4246
4247 #[allow(clippy::enum_variant_names)]
4248 enum GeneratedField {
4249 LeftKey,
4250 Condition,
4251 LeftTable,
4252 RightTable,
4253 ConditionAlwaysRelax,
4254 CleanedByWatermark,
4255 }
4256 impl<'de> serde::Deserialize<'de> for GeneratedField {
4257 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4258 where
4259 D: serde::Deserializer<'de>,
4260 {
4261 struct GeneratedVisitor;
4262
4263 impl serde::de::Visitor<'_> for GeneratedVisitor {
4264 type Value = GeneratedField;
4265
4266 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4267 write!(formatter, "expected one of: {:?}", &FIELDS)
4268 }
4269
4270 #[allow(unused_variables)]
4271 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4272 where
4273 E: serde::de::Error,
4274 {
4275 match value {
4276 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
4277 "condition" => Ok(GeneratedField::Condition),
4278 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
4279 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
4280 "conditionAlwaysRelax" | "condition_always_relax" => Ok(GeneratedField::ConditionAlwaysRelax),
4281 "cleanedByWatermark" | "cleaned_by_watermark" => Ok(GeneratedField::CleanedByWatermark),
4282 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4283 }
4284 }
4285 }
4286 deserializer.deserialize_identifier(GeneratedVisitor)
4287 }
4288 }
4289 struct GeneratedVisitor;
4290 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4291 type Value = DynamicFilterNode;
4292
4293 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4294 formatter.write_str("struct stream_plan.DynamicFilterNode")
4295 }
4296
4297 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DynamicFilterNode, V::Error>
4298 where
4299 V: serde::de::MapAccess<'de>,
4300 {
4301 let mut left_key__ = None;
4302 let mut condition__ = None;
4303 let mut left_table__ = None;
4304 let mut right_table__ = None;
4305 let mut condition_always_relax__ = None;
4306 let mut cleaned_by_watermark__ = None;
4307 while let Some(k) = map_.next_key()? {
4308 match k {
4309 GeneratedField::LeftKey => {
4310 if left_key__.is_some() {
4311 return Err(serde::de::Error::duplicate_field("leftKey"));
4312 }
4313 left_key__ =
4314 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4315 ;
4316 }
4317 GeneratedField::Condition => {
4318 if condition__.is_some() {
4319 return Err(serde::de::Error::duplicate_field("condition"));
4320 }
4321 condition__ = map_.next_value()?;
4322 }
4323 GeneratedField::LeftTable => {
4324 if left_table__.is_some() {
4325 return Err(serde::de::Error::duplicate_field("leftTable"));
4326 }
4327 left_table__ = map_.next_value()?;
4328 }
4329 GeneratedField::RightTable => {
4330 if right_table__.is_some() {
4331 return Err(serde::de::Error::duplicate_field("rightTable"));
4332 }
4333 right_table__ = map_.next_value()?;
4334 }
4335 GeneratedField::ConditionAlwaysRelax => {
4336 if condition_always_relax__.is_some() {
4337 return Err(serde::de::Error::duplicate_field("conditionAlwaysRelax"));
4338 }
4339 condition_always_relax__ = Some(map_.next_value()?);
4340 }
4341 GeneratedField::CleanedByWatermark => {
4342 if cleaned_by_watermark__.is_some() {
4343 return Err(serde::de::Error::duplicate_field("cleanedByWatermark"));
4344 }
4345 cleaned_by_watermark__ = Some(map_.next_value()?);
4346 }
4347 }
4348 }
4349 Ok(DynamicFilterNode {
4350 left_key: left_key__.unwrap_or_default(),
4351 condition: condition__,
4352 left_table: left_table__,
4353 right_table: right_table__,
4354 condition_always_relax: condition_always_relax__.unwrap_or_default(),
4355 cleaned_by_watermark: cleaned_by_watermark__.unwrap_or_default(),
4356 })
4357 }
4358 }
4359 deserializer.deserialize_struct("stream_plan.DynamicFilterNode", FIELDS, GeneratedVisitor)
4360 }
4361}
4362impl serde::Serialize for EowcGapFillNode {
4363 #[allow(deprecated)]
4364 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4365 where
4366 S: serde::Serializer,
4367 {
4368 use serde::ser::SerializeStruct;
4369 let mut len = 0;
4370 if self.time_column_index != 0 {
4371 len += 1;
4372 }
4373 if self.interval.is_some() {
4374 len += 1;
4375 }
4376 if !self.fill_columns.is_empty() {
4377 len += 1;
4378 }
4379 if !self.fill_strategies.is_empty() {
4380 len += 1;
4381 }
4382 if self.buffer_table.is_some() {
4383 len += 1;
4384 }
4385 if self.prev_row_table.is_some() {
4386 len += 1;
4387 }
4388 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcGapFillNode", len)?;
4389 if self.time_column_index != 0 {
4390 struct_ser.serialize_field("timeColumnIndex", &self.time_column_index)?;
4391 }
4392 if let Some(v) = self.interval.as_ref() {
4393 struct_ser.serialize_field("interval", v)?;
4394 }
4395 if !self.fill_columns.is_empty() {
4396 struct_ser.serialize_field("fillColumns", &self.fill_columns)?;
4397 }
4398 if !self.fill_strategies.is_empty() {
4399 struct_ser.serialize_field("fillStrategies", &self.fill_strategies)?;
4400 }
4401 if let Some(v) = self.buffer_table.as_ref() {
4402 struct_ser.serialize_field("bufferTable", v)?;
4403 }
4404 if let Some(v) = self.prev_row_table.as_ref() {
4405 struct_ser.serialize_field("prevRowTable", v)?;
4406 }
4407 struct_ser.end()
4408 }
4409}
4410impl<'de> serde::Deserialize<'de> for EowcGapFillNode {
4411 #[allow(deprecated)]
4412 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4413 where
4414 D: serde::Deserializer<'de>,
4415 {
4416 const FIELDS: &[&str] = &[
4417 "time_column_index",
4418 "timeColumnIndex",
4419 "interval",
4420 "fill_columns",
4421 "fillColumns",
4422 "fill_strategies",
4423 "fillStrategies",
4424 "buffer_table",
4425 "bufferTable",
4426 "prev_row_table",
4427 "prevRowTable",
4428 ];
4429
4430 #[allow(clippy::enum_variant_names)]
4431 enum GeneratedField {
4432 TimeColumnIndex,
4433 Interval,
4434 FillColumns,
4435 FillStrategies,
4436 BufferTable,
4437 PrevRowTable,
4438 }
4439 impl<'de> serde::Deserialize<'de> for GeneratedField {
4440 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4441 where
4442 D: serde::Deserializer<'de>,
4443 {
4444 struct GeneratedVisitor;
4445
4446 impl serde::de::Visitor<'_> for GeneratedVisitor {
4447 type Value = GeneratedField;
4448
4449 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4450 write!(formatter, "expected one of: {:?}", &FIELDS)
4451 }
4452
4453 #[allow(unused_variables)]
4454 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4455 where
4456 E: serde::de::Error,
4457 {
4458 match value {
4459 "timeColumnIndex" | "time_column_index" => Ok(GeneratedField::TimeColumnIndex),
4460 "interval" => Ok(GeneratedField::Interval),
4461 "fillColumns" | "fill_columns" => Ok(GeneratedField::FillColumns),
4462 "fillStrategies" | "fill_strategies" => Ok(GeneratedField::FillStrategies),
4463 "bufferTable" | "buffer_table" => Ok(GeneratedField::BufferTable),
4464 "prevRowTable" | "prev_row_table" => Ok(GeneratedField::PrevRowTable),
4465 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4466 }
4467 }
4468 }
4469 deserializer.deserialize_identifier(GeneratedVisitor)
4470 }
4471 }
4472 struct GeneratedVisitor;
4473 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4474 type Value = EowcGapFillNode;
4475
4476 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4477 formatter.write_str("struct stream_plan.EowcGapFillNode")
4478 }
4479
4480 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcGapFillNode, V::Error>
4481 where
4482 V: serde::de::MapAccess<'de>,
4483 {
4484 let mut time_column_index__ = None;
4485 let mut interval__ = None;
4486 let mut fill_columns__ = None;
4487 let mut fill_strategies__ = None;
4488 let mut buffer_table__ = None;
4489 let mut prev_row_table__ = None;
4490 while let Some(k) = map_.next_key()? {
4491 match k {
4492 GeneratedField::TimeColumnIndex => {
4493 if time_column_index__.is_some() {
4494 return Err(serde::de::Error::duplicate_field("timeColumnIndex"));
4495 }
4496 time_column_index__ =
4497 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4498 ;
4499 }
4500 GeneratedField::Interval => {
4501 if interval__.is_some() {
4502 return Err(serde::de::Error::duplicate_field("interval"));
4503 }
4504 interval__ = map_.next_value()?;
4505 }
4506 GeneratedField::FillColumns => {
4507 if fill_columns__.is_some() {
4508 return Err(serde::de::Error::duplicate_field("fillColumns"));
4509 }
4510 fill_columns__ =
4511 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4512 .into_iter().map(|x| x.0).collect())
4513 ;
4514 }
4515 GeneratedField::FillStrategies => {
4516 if fill_strategies__.is_some() {
4517 return Err(serde::de::Error::duplicate_field("fillStrategies"));
4518 }
4519 fill_strategies__ = Some(map_.next_value()?);
4520 }
4521 GeneratedField::BufferTable => {
4522 if buffer_table__.is_some() {
4523 return Err(serde::de::Error::duplicate_field("bufferTable"));
4524 }
4525 buffer_table__ = map_.next_value()?;
4526 }
4527 GeneratedField::PrevRowTable => {
4528 if prev_row_table__.is_some() {
4529 return Err(serde::de::Error::duplicate_field("prevRowTable"));
4530 }
4531 prev_row_table__ = map_.next_value()?;
4532 }
4533 }
4534 }
4535 Ok(EowcGapFillNode {
4536 time_column_index: time_column_index__.unwrap_or_default(),
4537 interval: interval__,
4538 fill_columns: fill_columns__.unwrap_or_default(),
4539 fill_strategies: fill_strategies__.unwrap_or_default(),
4540 buffer_table: buffer_table__,
4541 prev_row_table: prev_row_table__,
4542 })
4543 }
4544 }
4545 deserializer.deserialize_struct("stream_plan.EowcGapFillNode", FIELDS, GeneratedVisitor)
4546 }
4547}
4548impl serde::Serialize for EowcOverWindowNode {
4549 #[allow(deprecated)]
4550 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4551 where
4552 S: serde::Serializer,
4553 {
4554 use serde::ser::SerializeStruct;
4555 let mut len = 0;
4556 if !self.calls.is_empty() {
4557 len += 1;
4558 }
4559 if !self.partition_by.is_empty() {
4560 len += 1;
4561 }
4562 if !self.order_by.is_empty() {
4563 len += 1;
4564 }
4565 if self.state_table.is_some() {
4566 len += 1;
4567 }
4568 if self.intermediate_state_table.is_some() {
4569 len += 1;
4570 }
4571 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcOverWindowNode", len)?;
4572 if !self.calls.is_empty() {
4573 struct_ser.serialize_field("calls", &self.calls)?;
4574 }
4575 if !self.partition_by.is_empty() {
4576 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
4577 }
4578 if !self.order_by.is_empty() {
4579 struct_ser.serialize_field("orderBy", &self.order_by)?;
4580 }
4581 if let Some(v) = self.state_table.as_ref() {
4582 struct_ser.serialize_field("stateTable", v)?;
4583 }
4584 if let Some(v) = self.intermediate_state_table.as_ref() {
4585 struct_ser.serialize_field("intermediateStateTable", v)?;
4586 }
4587 struct_ser.end()
4588 }
4589}
4590impl<'de> serde::Deserialize<'de> for EowcOverWindowNode {
4591 #[allow(deprecated)]
4592 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4593 where
4594 D: serde::Deserializer<'de>,
4595 {
4596 const FIELDS: &[&str] = &[
4597 "calls",
4598 "partition_by",
4599 "partitionBy",
4600 "order_by",
4601 "orderBy",
4602 "state_table",
4603 "stateTable",
4604 "intermediate_state_table",
4605 "intermediateStateTable",
4606 ];
4607
4608 #[allow(clippy::enum_variant_names)]
4609 enum GeneratedField {
4610 Calls,
4611 PartitionBy,
4612 OrderBy,
4613 StateTable,
4614 IntermediateStateTable,
4615 }
4616 impl<'de> serde::Deserialize<'de> for GeneratedField {
4617 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4618 where
4619 D: serde::Deserializer<'de>,
4620 {
4621 struct GeneratedVisitor;
4622
4623 impl serde::de::Visitor<'_> for GeneratedVisitor {
4624 type Value = GeneratedField;
4625
4626 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4627 write!(formatter, "expected one of: {:?}", &FIELDS)
4628 }
4629
4630 #[allow(unused_variables)]
4631 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4632 where
4633 E: serde::de::Error,
4634 {
4635 match value {
4636 "calls" => Ok(GeneratedField::Calls),
4637 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
4638 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
4639 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
4640 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
4641 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4642 }
4643 }
4644 }
4645 deserializer.deserialize_identifier(GeneratedVisitor)
4646 }
4647 }
4648 struct GeneratedVisitor;
4649 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4650 type Value = EowcOverWindowNode;
4651
4652 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4653 formatter.write_str("struct stream_plan.EowcOverWindowNode")
4654 }
4655
4656 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcOverWindowNode, V::Error>
4657 where
4658 V: serde::de::MapAccess<'de>,
4659 {
4660 let mut calls__ = None;
4661 let mut partition_by__ = None;
4662 let mut order_by__ = None;
4663 let mut state_table__ = None;
4664 let mut intermediate_state_table__ = None;
4665 while let Some(k) = map_.next_key()? {
4666 match k {
4667 GeneratedField::Calls => {
4668 if calls__.is_some() {
4669 return Err(serde::de::Error::duplicate_field("calls"));
4670 }
4671 calls__ = Some(map_.next_value()?);
4672 }
4673 GeneratedField::PartitionBy => {
4674 if partition_by__.is_some() {
4675 return Err(serde::de::Error::duplicate_field("partitionBy"));
4676 }
4677 partition_by__ =
4678 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4679 .into_iter().map(|x| x.0).collect())
4680 ;
4681 }
4682 GeneratedField::OrderBy => {
4683 if order_by__.is_some() {
4684 return Err(serde::de::Error::duplicate_field("orderBy"));
4685 }
4686 order_by__ = Some(map_.next_value()?);
4687 }
4688 GeneratedField::StateTable => {
4689 if state_table__.is_some() {
4690 return Err(serde::de::Error::duplicate_field("stateTable"));
4691 }
4692 state_table__ = map_.next_value()?;
4693 }
4694 GeneratedField::IntermediateStateTable => {
4695 if intermediate_state_table__.is_some() {
4696 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
4697 }
4698 intermediate_state_table__ = map_.next_value()?;
4699 }
4700 }
4701 }
4702 Ok(EowcOverWindowNode {
4703 calls: calls__.unwrap_or_default(),
4704 partition_by: partition_by__.unwrap_or_default(),
4705 order_by: order_by__.unwrap_or_default(),
4706 state_table: state_table__,
4707 intermediate_state_table: intermediate_state_table__,
4708 })
4709 }
4710 }
4711 deserializer.deserialize_struct("stream_plan.EowcOverWindowNode", FIELDS, GeneratedVisitor)
4712 }
4713}
4714impl serde::Serialize for ExchangeNode {
4715 #[allow(deprecated)]
4716 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4717 where
4718 S: serde::Serializer,
4719 {
4720 use serde::ser::SerializeStruct;
4721 let mut len = 0;
4722 if self.strategy.is_some() {
4723 len += 1;
4724 }
4725 let mut struct_ser = serializer.serialize_struct("stream_plan.ExchangeNode", len)?;
4726 if let Some(v) = self.strategy.as_ref() {
4727 struct_ser.serialize_field("strategy", v)?;
4728 }
4729 struct_ser.end()
4730 }
4731}
4732impl<'de> serde::Deserialize<'de> for ExchangeNode {
4733 #[allow(deprecated)]
4734 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4735 where
4736 D: serde::Deserializer<'de>,
4737 {
4738 const FIELDS: &[&str] = &[
4739 "strategy",
4740 ];
4741
4742 #[allow(clippy::enum_variant_names)]
4743 enum GeneratedField {
4744 Strategy,
4745 }
4746 impl<'de> serde::Deserialize<'de> for GeneratedField {
4747 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4748 where
4749 D: serde::Deserializer<'de>,
4750 {
4751 struct GeneratedVisitor;
4752
4753 impl serde::de::Visitor<'_> for GeneratedVisitor {
4754 type Value = GeneratedField;
4755
4756 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4757 write!(formatter, "expected one of: {:?}", &FIELDS)
4758 }
4759
4760 #[allow(unused_variables)]
4761 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4762 where
4763 E: serde::de::Error,
4764 {
4765 match value {
4766 "strategy" => Ok(GeneratedField::Strategy),
4767 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4768 }
4769 }
4770 }
4771 deserializer.deserialize_identifier(GeneratedVisitor)
4772 }
4773 }
4774 struct GeneratedVisitor;
4775 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4776 type Value = ExchangeNode;
4777
4778 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4779 formatter.write_str("struct stream_plan.ExchangeNode")
4780 }
4781
4782 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExchangeNode, V::Error>
4783 where
4784 V: serde::de::MapAccess<'de>,
4785 {
4786 let mut strategy__ = None;
4787 while let Some(k) = map_.next_key()? {
4788 match k {
4789 GeneratedField::Strategy => {
4790 if strategy__.is_some() {
4791 return Err(serde::de::Error::duplicate_field("strategy"));
4792 }
4793 strategy__ = map_.next_value()?;
4794 }
4795 }
4796 }
4797 Ok(ExchangeNode {
4798 strategy: strategy__,
4799 })
4800 }
4801 }
4802 deserializer.deserialize_struct("stream_plan.ExchangeNode", FIELDS, GeneratedVisitor)
4803 }
4804}
4805impl serde::Serialize for ExpandNode {
4806 #[allow(deprecated)]
4807 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4808 where
4809 S: serde::Serializer,
4810 {
4811 use serde::ser::SerializeStruct;
4812 let mut len = 0;
4813 if !self.column_subsets.is_empty() {
4814 len += 1;
4815 }
4816 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode", len)?;
4817 if !self.column_subsets.is_empty() {
4818 struct_ser.serialize_field("columnSubsets", &self.column_subsets)?;
4819 }
4820 struct_ser.end()
4821 }
4822}
4823impl<'de> serde::Deserialize<'de> for ExpandNode {
4824 #[allow(deprecated)]
4825 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4826 where
4827 D: serde::Deserializer<'de>,
4828 {
4829 const FIELDS: &[&str] = &[
4830 "column_subsets",
4831 "columnSubsets",
4832 ];
4833
4834 #[allow(clippy::enum_variant_names)]
4835 enum GeneratedField {
4836 ColumnSubsets,
4837 }
4838 impl<'de> serde::Deserialize<'de> for GeneratedField {
4839 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4840 where
4841 D: serde::Deserializer<'de>,
4842 {
4843 struct GeneratedVisitor;
4844
4845 impl serde::de::Visitor<'_> for GeneratedVisitor {
4846 type Value = GeneratedField;
4847
4848 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4849 write!(formatter, "expected one of: {:?}", &FIELDS)
4850 }
4851
4852 #[allow(unused_variables)]
4853 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4854 where
4855 E: serde::de::Error,
4856 {
4857 match value {
4858 "columnSubsets" | "column_subsets" => Ok(GeneratedField::ColumnSubsets),
4859 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4860 }
4861 }
4862 }
4863 deserializer.deserialize_identifier(GeneratedVisitor)
4864 }
4865 }
4866 struct GeneratedVisitor;
4867 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4868 type Value = ExpandNode;
4869
4870 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4871 formatter.write_str("struct stream_plan.ExpandNode")
4872 }
4873
4874 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpandNode, V::Error>
4875 where
4876 V: serde::de::MapAccess<'de>,
4877 {
4878 let mut column_subsets__ = None;
4879 while let Some(k) = map_.next_key()? {
4880 match k {
4881 GeneratedField::ColumnSubsets => {
4882 if column_subsets__.is_some() {
4883 return Err(serde::de::Error::duplicate_field("columnSubsets"));
4884 }
4885 column_subsets__ = Some(map_.next_value()?);
4886 }
4887 }
4888 }
4889 Ok(ExpandNode {
4890 column_subsets: column_subsets__.unwrap_or_default(),
4891 })
4892 }
4893 }
4894 deserializer.deserialize_struct("stream_plan.ExpandNode", FIELDS, GeneratedVisitor)
4895 }
4896}
4897impl serde::Serialize for expand_node::Subset {
4898 #[allow(deprecated)]
4899 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4900 where
4901 S: serde::Serializer,
4902 {
4903 use serde::ser::SerializeStruct;
4904 let mut len = 0;
4905 if !self.column_indices.is_empty() {
4906 len += 1;
4907 }
4908 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode.Subset", len)?;
4909 if !self.column_indices.is_empty() {
4910 struct_ser.serialize_field("columnIndices", &self.column_indices)?;
4911 }
4912 struct_ser.end()
4913 }
4914}
4915impl<'de> serde::Deserialize<'de> for expand_node::Subset {
4916 #[allow(deprecated)]
4917 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4918 where
4919 D: serde::Deserializer<'de>,
4920 {
4921 const FIELDS: &[&str] = &[
4922 "column_indices",
4923 "columnIndices",
4924 ];
4925
4926 #[allow(clippy::enum_variant_names)]
4927 enum GeneratedField {
4928 ColumnIndices,
4929 }
4930 impl<'de> serde::Deserialize<'de> for GeneratedField {
4931 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4932 where
4933 D: serde::Deserializer<'de>,
4934 {
4935 struct GeneratedVisitor;
4936
4937 impl serde::de::Visitor<'_> for GeneratedVisitor {
4938 type Value = GeneratedField;
4939
4940 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4941 write!(formatter, "expected one of: {:?}", &FIELDS)
4942 }
4943
4944 #[allow(unused_variables)]
4945 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4946 where
4947 E: serde::de::Error,
4948 {
4949 match value {
4950 "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
4951 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4952 }
4953 }
4954 }
4955 deserializer.deserialize_identifier(GeneratedVisitor)
4956 }
4957 }
4958 struct GeneratedVisitor;
4959 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4960 type Value = expand_node::Subset;
4961
4962 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4963 formatter.write_str("struct stream_plan.ExpandNode.Subset")
4964 }
4965
4966 fn visit_map<V>(self, mut map_: V) -> std::result::Result<expand_node::Subset, V::Error>
4967 where
4968 V: serde::de::MapAccess<'de>,
4969 {
4970 let mut column_indices__ = None;
4971 while let Some(k) = map_.next_key()? {
4972 match k {
4973 GeneratedField::ColumnIndices => {
4974 if column_indices__.is_some() {
4975 return Err(serde::de::Error::duplicate_field("columnIndices"));
4976 }
4977 column_indices__ =
4978 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4979 .into_iter().map(|x| x.0).collect())
4980 ;
4981 }
4982 }
4983 }
4984 Ok(expand_node::Subset {
4985 column_indices: column_indices__.unwrap_or_default(),
4986 })
4987 }
4988 }
4989 deserializer.deserialize_struct("stream_plan.ExpandNode.Subset", FIELDS, GeneratedVisitor)
4990 }
4991}
4992impl serde::Serialize for FilterNode {
4993 #[allow(deprecated)]
4994 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4995 where
4996 S: serde::Serializer,
4997 {
4998 use serde::ser::SerializeStruct;
4999 let mut len = 0;
5000 if self.search_condition.is_some() {
5001 len += 1;
5002 }
5003 let mut struct_ser = serializer.serialize_struct("stream_plan.FilterNode", len)?;
5004 if let Some(v) = self.search_condition.as_ref() {
5005 struct_ser.serialize_field("searchCondition", v)?;
5006 }
5007 struct_ser.end()
5008 }
5009}
5010impl<'de> serde::Deserialize<'de> for FilterNode {
5011 #[allow(deprecated)]
5012 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5013 where
5014 D: serde::Deserializer<'de>,
5015 {
5016 const FIELDS: &[&str] = &[
5017 "search_condition",
5018 "searchCondition",
5019 ];
5020
5021 #[allow(clippy::enum_variant_names)]
5022 enum GeneratedField {
5023 SearchCondition,
5024 }
5025 impl<'de> serde::Deserialize<'de> for GeneratedField {
5026 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5027 where
5028 D: serde::Deserializer<'de>,
5029 {
5030 struct GeneratedVisitor;
5031
5032 impl serde::de::Visitor<'_> for GeneratedVisitor {
5033 type Value = GeneratedField;
5034
5035 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5036 write!(formatter, "expected one of: {:?}", &FIELDS)
5037 }
5038
5039 #[allow(unused_variables)]
5040 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5041 where
5042 E: serde::de::Error,
5043 {
5044 match value {
5045 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
5046 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5047 }
5048 }
5049 }
5050 deserializer.deserialize_identifier(GeneratedVisitor)
5051 }
5052 }
5053 struct GeneratedVisitor;
5054 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5055 type Value = FilterNode;
5056
5057 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5058 formatter.write_str("struct stream_plan.FilterNode")
5059 }
5060
5061 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FilterNode, V::Error>
5062 where
5063 V: serde::de::MapAccess<'de>,
5064 {
5065 let mut search_condition__ = None;
5066 while let Some(k) = map_.next_key()? {
5067 match k {
5068 GeneratedField::SearchCondition => {
5069 if search_condition__.is_some() {
5070 return Err(serde::de::Error::duplicate_field("searchCondition"));
5071 }
5072 search_condition__ = map_.next_value()?;
5073 }
5074 }
5075 }
5076 Ok(FilterNode {
5077 search_condition: search_condition__,
5078 })
5079 }
5080 }
5081 deserializer.deserialize_struct("stream_plan.FilterNode", FIELDS, GeneratedVisitor)
5082 }
5083}
5084impl serde::Serialize for GapFillNode {
5085 #[allow(deprecated)]
5086 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5087 where
5088 S: serde::Serializer,
5089 {
5090 use serde::ser::SerializeStruct;
5091 let mut len = 0;
5092 if self.time_column_index != 0 {
5093 len += 1;
5094 }
5095 if self.interval.is_some() {
5096 len += 1;
5097 }
5098 if !self.fill_columns.is_empty() {
5099 len += 1;
5100 }
5101 if !self.fill_strategies.is_empty() {
5102 len += 1;
5103 }
5104 if self.state_table.is_some() {
5105 len += 1;
5106 }
5107 let mut struct_ser = serializer.serialize_struct("stream_plan.GapFillNode", len)?;
5108 if self.time_column_index != 0 {
5109 struct_ser.serialize_field("timeColumnIndex", &self.time_column_index)?;
5110 }
5111 if let Some(v) = self.interval.as_ref() {
5112 struct_ser.serialize_field("interval", v)?;
5113 }
5114 if !self.fill_columns.is_empty() {
5115 struct_ser.serialize_field("fillColumns", &self.fill_columns)?;
5116 }
5117 if !self.fill_strategies.is_empty() {
5118 struct_ser.serialize_field("fillStrategies", &self.fill_strategies)?;
5119 }
5120 if let Some(v) = self.state_table.as_ref() {
5121 struct_ser.serialize_field("stateTable", v)?;
5122 }
5123 struct_ser.end()
5124 }
5125}
5126impl<'de> serde::Deserialize<'de> for GapFillNode {
5127 #[allow(deprecated)]
5128 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5129 where
5130 D: serde::Deserializer<'de>,
5131 {
5132 const FIELDS: &[&str] = &[
5133 "time_column_index",
5134 "timeColumnIndex",
5135 "interval",
5136 "fill_columns",
5137 "fillColumns",
5138 "fill_strategies",
5139 "fillStrategies",
5140 "state_table",
5141 "stateTable",
5142 ];
5143
5144 #[allow(clippy::enum_variant_names)]
5145 enum GeneratedField {
5146 TimeColumnIndex,
5147 Interval,
5148 FillColumns,
5149 FillStrategies,
5150 StateTable,
5151 }
5152 impl<'de> serde::Deserialize<'de> for GeneratedField {
5153 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5154 where
5155 D: serde::Deserializer<'de>,
5156 {
5157 struct GeneratedVisitor;
5158
5159 impl serde::de::Visitor<'_> for GeneratedVisitor {
5160 type Value = GeneratedField;
5161
5162 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5163 write!(formatter, "expected one of: {:?}", &FIELDS)
5164 }
5165
5166 #[allow(unused_variables)]
5167 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5168 where
5169 E: serde::de::Error,
5170 {
5171 match value {
5172 "timeColumnIndex" | "time_column_index" => Ok(GeneratedField::TimeColumnIndex),
5173 "interval" => Ok(GeneratedField::Interval),
5174 "fillColumns" | "fill_columns" => Ok(GeneratedField::FillColumns),
5175 "fillStrategies" | "fill_strategies" => Ok(GeneratedField::FillStrategies),
5176 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
5177 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5178 }
5179 }
5180 }
5181 deserializer.deserialize_identifier(GeneratedVisitor)
5182 }
5183 }
5184 struct GeneratedVisitor;
5185 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5186 type Value = GapFillNode;
5187
5188 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5189 formatter.write_str("struct stream_plan.GapFillNode")
5190 }
5191
5192 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GapFillNode, V::Error>
5193 where
5194 V: serde::de::MapAccess<'de>,
5195 {
5196 let mut time_column_index__ = None;
5197 let mut interval__ = None;
5198 let mut fill_columns__ = None;
5199 let mut fill_strategies__ = None;
5200 let mut state_table__ = None;
5201 while let Some(k) = map_.next_key()? {
5202 match k {
5203 GeneratedField::TimeColumnIndex => {
5204 if time_column_index__.is_some() {
5205 return Err(serde::de::Error::duplicate_field("timeColumnIndex"));
5206 }
5207 time_column_index__ =
5208 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5209 ;
5210 }
5211 GeneratedField::Interval => {
5212 if interval__.is_some() {
5213 return Err(serde::de::Error::duplicate_field("interval"));
5214 }
5215 interval__ = map_.next_value()?;
5216 }
5217 GeneratedField::FillColumns => {
5218 if fill_columns__.is_some() {
5219 return Err(serde::de::Error::duplicate_field("fillColumns"));
5220 }
5221 fill_columns__ =
5222 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5223 .into_iter().map(|x| x.0).collect())
5224 ;
5225 }
5226 GeneratedField::FillStrategies => {
5227 if fill_strategies__.is_some() {
5228 return Err(serde::de::Error::duplicate_field("fillStrategies"));
5229 }
5230 fill_strategies__ = Some(map_.next_value()?);
5231 }
5232 GeneratedField::StateTable => {
5233 if state_table__.is_some() {
5234 return Err(serde::de::Error::duplicate_field("stateTable"));
5235 }
5236 state_table__ = map_.next_value()?;
5237 }
5238 }
5239 }
5240 Ok(GapFillNode {
5241 time_column_index: time_column_index__.unwrap_or_default(),
5242 interval: interval__,
5243 fill_columns: fill_columns__.unwrap_or_default(),
5244 fill_strategies: fill_strategies__.unwrap_or_default(),
5245 state_table: state_table__,
5246 })
5247 }
5248 }
5249 deserializer.deserialize_struct("stream_plan.GapFillNode", FIELDS, GeneratedVisitor)
5250 }
5251}
5252impl serde::Serialize for GlobalApproxPercentileNode {
5253 #[allow(deprecated)]
5254 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5255 where
5256 S: serde::Serializer,
5257 {
5258 use serde::ser::SerializeStruct;
5259 let mut len = 0;
5260 if self.base != 0. {
5261 len += 1;
5262 }
5263 if self.quantile != 0. {
5264 len += 1;
5265 }
5266 if self.bucket_state_table.is_some() {
5267 len += 1;
5268 }
5269 if self.count_state_table.is_some() {
5270 len += 1;
5271 }
5272 let mut struct_ser = serializer.serialize_struct("stream_plan.GlobalApproxPercentileNode", len)?;
5273 if self.base != 0. {
5274 struct_ser.serialize_field("base", &self.base)?;
5275 }
5276 if self.quantile != 0. {
5277 struct_ser.serialize_field("quantile", &self.quantile)?;
5278 }
5279 if let Some(v) = self.bucket_state_table.as_ref() {
5280 struct_ser.serialize_field("bucketStateTable", v)?;
5281 }
5282 if let Some(v) = self.count_state_table.as_ref() {
5283 struct_ser.serialize_field("countStateTable", v)?;
5284 }
5285 struct_ser.end()
5286 }
5287}
5288impl<'de> serde::Deserialize<'de> for GlobalApproxPercentileNode {
5289 #[allow(deprecated)]
5290 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5291 where
5292 D: serde::Deserializer<'de>,
5293 {
5294 const FIELDS: &[&str] = &[
5295 "base",
5296 "quantile",
5297 "bucket_state_table",
5298 "bucketStateTable",
5299 "count_state_table",
5300 "countStateTable",
5301 ];
5302
5303 #[allow(clippy::enum_variant_names)]
5304 enum GeneratedField {
5305 Base,
5306 Quantile,
5307 BucketStateTable,
5308 CountStateTable,
5309 }
5310 impl<'de> serde::Deserialize<'de> for GeneratedField {
5311 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5312 where
5313 D: serde::Deserializer<'de>,
5314 {
5315 struct GeneratedVisitor;
5316
5317 impl serde::de::Visitor<'_> for GeneratedVisitor {
5318 type Value = GeneratedField;
5319
5320 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5321 write!(formatter, "expected one of: {:?}", &FIELDS)
5322 }
5323
5324 #[allow(unused_variables)]
5325 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5326 where
5327 E: serde::de::Error,
5328 {
5329 match value {
5330 "base" => Ok(GeneratedField::Base),
5331 "quantile" => Ok(GeneratedField::Quantile),
5332 "bucketStateTable" | "bucket_state_table" => Ok(GeneratedField::BucketStateTable),
5333 "countStateTable" | "count_state_table" => Ok(GeneratedField::CountStateTable),
5334 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5335 }
5336 }
5337 }
5338 deserializer.deserialize_identifier(GeneratedVisitor)
5339 }
5340 }
5341 struct GeneratedVisitor;
5342 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5343 type Value = GlobalApproxPercentileNode;
5344
5345 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5346 formatter.write_str("struct stream_plan.GlobalApproxPercentileNode")
5347 }
5348
5349 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GlobalApproxPercentileNode, V::Error>
5350 where
5351 V: serde::de::MapAccess<'de>,
5352 {
5353 let mut base__ = None;
5354 let mut quantile__ = None;
5355 let mut bucket_state_table__ = None;
5356 let mut count_state_table__ = None;
5357 while let Some(k) = map_.next_key()? {
5358 match k {
5359 GeneratedField::Base => {
5360 if base__.is_some() {
5361 return Err(serde::de::Error::duplicate_field("base"));
5362 }
5363 base__ =
5364 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5365 ;
5366 }
5367 GeneratedField::Quantile => {
5368 if quantile__.is_some() {
5369 return Err(serde::de::Error::duplicate_field("quantile"));
5370 }
5371 quantile__ =
5372 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5373 ;
5374 }
5375 GeneratedField::BucketStateTable => {
5376 if bucket_state_table__.is_some() {
5377 return Err(serde::de::Error::duplicate_field("bucketStateTable"));
5378 }
5379 bucket_state_table__ = map_.next_value()?;
5380 }
5381 GeneratedField::CountStateTable => {
5382 if count_state_table__.is_some() {
5383 return Err(serde::de::Error::duplicate_field("countStateTable"));
5384 }
5385 count_state_table__ = map_.next_value()?;
5386 }
5387 }
5388 }
5389 Ok(GlobalApproxPercentileNode {
5390 base: base__.unwrap_or_default(),
5391 quantile: quantile__.unwrap_or_default(),
5392 bucket_state_table: bucket_state_table__,
5393 count_state_table: count_state_table__,
5394 })
5395 }
5396 }
5397 deserializer.deserialize_struct("stream_plan.GlobalApproxPercentileNode", FIELDS, GeneratedVisitor)
5398 }
5399}
5400impl serde::Serialize for GroupTopNNode {
5401 #[allow(deprecated)]
5402 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5403 where
5404 S: serde::Serializer,
5405 {
5406 use serde::ser::SerializeStruct;
5407 let mut len = 0;
5408 if self.limit != 0 {
5409 len += 1;
5410 }
5411 if self.offset != 0 {
5412 len += 1;
5413 }
5414 if !self.group_key.is_empty() {
5415 len += 1;
5416 }
5417 if self.table.is_some() {
5418 len += 1;
5419 }
5420 if !self.order_by.is_empty() {
5421 len += 1;
5422 }
5423 if self.with_ties {
5424 len += 1;
5425 }
5426 let mut struct_ser = serializer.serialize_struct("stream_plan.GroupTopNNode", len)?;
5427 if self.limit != 0 {
5428 #[allow(clippy::needless_borrow)]
5429 #[allow(clippy::needless_borrows_for_generic_args)]
5430 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
5431 }
5432 if self.offset != 0 {
5433 #[allow(clippy::needless_borrow)]
5434 #[allow(clippy::needless_borrows_for_generic_args)]
5435 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
5436 }
5437 if !self.group_key.is_empty() {
5438 struct_ser.serialize_field("groupKey", &self.group_key)?;
5439 }
5440 if let Some(v) = self.table.as_ref() {
5441 struct_ser.serialize_field("table", v)?;
5442 }
5443 if !self.order_by.is_empty() {
5444 struct_ser.serialize_field("orderBy", &self.order_by)?;
5445 }
5446 if self.with_ties {
5447 struct_ser.serialize_field("withTies", &self.with_ties)?;
5448 }
5449 struct_ser.end()
5450 }
5451}
5452impl<'de> serde::Deserialize<'de> for GroupTopNNode {
5453 #[allow(deprecated)]
5454 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5455 where
5456 D: serde::Deserializer<'de>,
5457 {
5458 const FIELDS: &[&str] = &[
5459 "limit",
5460 "offset",
5461 "group_key",
5462 "groupKey",
5463 "table",
5464 "order_by",
5465 "orderBy",
5466 "with_ties",
5467 "withTies",
5468 ];
5469
5470 #[allow(clippy::enum_variant_names)]
5471 enum GeneratedField {
5472 Limit,
5473 Offset,
5474 GroupKey,
5475 Table,
5476 OrderBy,
5477 WithTies,
5478 }
5479 impl<'de> serde::Deserialize<'de> for GeneratedField {
5480 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5481 where
5482 D: serde::Deserializer<'de>,
5483 {
5484 struct GeneratedVisitor;
5485
5486 impl serde::de::Visitor<'_> for GeneratedVisitor {
5487 type Value = GeneratedField;
5488
5489 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5490 write!(formatter, "expected one of: {:?}", &FIELDS)
5491 }
5492
5493 #[allow(unused_variables)]
5494 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5495 where
5496 E: serde::de::Error,
5497 {
5498 match value {
5499 "limit" => Ok(GeneratedField::Limit),
5500 "offset" => Ok(GeneratedField::Offset),
5501 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5502 "table" => Ok(GeneratedField::Table),
5503 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
5504 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
5505 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5506 }
5507 }
5508 }
5509 deserializer.deserialize_identifier(GeneratedVisitor)
5510 }
5511 }
5512 struct GeneratedVisitor;
5513 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5514 type Value = GroupTopNNode;
5515
5516 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5517 formatter.write_str("struct stream_plan.GroupTopNNode")
5518 }
5519
5520 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupTopNNode, V::Error>
5521 where
5522 V: serde::de::MapAccess<'de>,
5523 {
5524 let mut limit__ = None;
5525 let mut offset__ = None;
5526 let mut group_key__ = None;
5527 let mut table__ = None;
5528 let mut order_by__ = None;
5529 let mut with_ties__ = None;
5530 while let Some(k) = map_.next_key()? {
5531 match k {
5532 GeneratedField::Limit => {
5533 if limit__.is_some() {
5534 return Err(serde::de::Error::duplicate_field("limit"));
5535 }
5536 limit__ =
5537 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5538 ;
5539 }
5540 GeneratedField::Offset => {
5541 if offset__.is_some() {
5542 return Err(serde::de::Error::duplicate_field("offset"));
5543 }
5544 offset__ =
5545 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5546 ;
5547 }
5548 GeneratedField::GroupKey => {
5549 if group_key__.is_some() {
5550 return Err(serde::de::Error::duplicate_field("groupKey"));
5551 }
5552 group_key__ =
5553 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5554 .into_iter().map(|x| x.0).collect())
5555 ;
5556 }
5557 GeneratedField::Table => {
5558 if table__.is_some() {
5559 return Err(serde::de::Error::duplicate_field("table"));
5560 }
5561 table__ = map_.next_value()?;
5562 }
5563 GeneratedField::OrderBy => {
5564 if order_by__.is_some() {
5565 return Err(serde::de::Error::duplicate_field("orderBy"));
5566 }
5567 order_by__ = Some(map_.next_value()?);
5568 }
5569 GeneratedField::WithTies => {
5570 if with_ties__.is_some() {
5571 return Err(serde::de::Error::duplicate_field("withTies"));
5572 }
5573 with_ties__ = Some(map_.next_value()?);
5574 }
5575 }
5576 }
5577 Ok(GroupTopNNode {
5578 limit: limit__.unwrap_or_default(),
5579 offset: offset__.unwrap_or_default(),
5580 group_key: group_key__.unwrap_or_default(),
5581 table: table__,
5582 order_by: order_by__.unwrap_or_default(),
5583 with_ties: with_ties__.unwrap_or_default(),
5584 })
5585 }
5586 }
5587 deserializer.deserialize_struct("stream_plan.GroupTopNNode", FIELDS, GeneratedVisitor)
5588 }
5589}
5590impl serde::Serialize for HashAggNode {
5591 #[allow(deprecated)]
5592 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5593 where
5594 S: serde::Serializer,
5595 {
5596 use serde::ser::SerializeStruct;
5597 let mut len = 0;
5598 if !self.group_key.is_empty() {
5599 len += 1;
5600 }
5601 if !self.agg_calls.is_empty() {
5602 len += 1;
5603 }
5604 if !self.agg_call_states.is_empty() {
5605 len += 1;
5606 }
5607 if self.intermediate_state_table.is_some() {
5608 len += 1;
5609 }
5610 if self.is_append_only {
5611 len += 1;
5612 }
5613 if !self.distinct_dedup_tables.is_empty() {
5614 len += 1;
5615 }
5616 if self.row_count_index != 0 {
5617 len += 1;
5618 }
5619 if self.emit_on_window_close {
5620 len += 1;
5621 }
5622 if self.version != 0 {
5623 len += 1;
5624 }
5625 let mut struct_ser = serializer.serialize_struct("stream_plan.HashAggNode", len)?;
5626 if !self.group_key.is_empty() {
5627 struct_ser.serialize_field("groupKey", &self.group_key)?;
5628 }
5629 if !self.agg_calls.is_empty() {
5630 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
5631 }
5632 if !self.agg_call_states.is_empty() {
5633 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
5634 }
5635 if let Some(v) = self.intermediate_state_table.as_ref() {
5636 struct_ser.serialize_field("intermediateStateTable", v)?;
5637 }
5638 if self.is_append_only {
5639 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5640 }
5641 if !self.distinct_dedup_tables.is_empty() {
5642 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
5643 }
5644 if self.row_count_index != 0 {
5645 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
5646 }
5647 if self.emit_on_window_close {
5648 struct_ser.serialize_field("emitOnWindowClose", &self.emit_on_window_close)?;
5649 }
5650 if self.version != 0 {
5651 let v = AggNodeVersion::try_from(self.version)
5652 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
5653 struct_ser.serialize_field("version", &v)?;
5654 }
5655 struct_ser.end()
5656 }
5657}
5658impl<'de> serde::Deserialize<'de> for HashAggNode {
5659 #[allow(deprecated)]
5660 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5661 where
5662 D: serde::Deserializer<'de>,
5663 {
5664 const FIELDS: &[&str] = &[
5665 "group_key",
5666 "groupKey",
5667 "agg_calls",
5668 "aggCalls",
5669 "agg_call_states",
5670 "aggCallStates",
5671 "intermediate_state_table",
5672 "intermediateStateTable",
5673 "is_append_only",
5674 "isAppendOnly",
5675 "distinct_dedup_tables",
5676 "distinctDedupTables",
5677 "row_count_index",
5678 "rowCountIndex",
5679 "emit_on_window_close",
5680 "emitOnWindowClose",
5681 "version",
5682 ];
5683
5684 #[allow(clippy::enum_variant_names)]
5685 enum GeneratedField {
5686 GroupKey,
5687 AggCalls,
5688 AggCallStates,
5689 IntermediateStateTable,
5690 IsAppendOnly,
5691 DistinctDedupTables,
5692 RowCountIndex,
5693 EmitOnWindowClose,
5694 Version,
5695 }
5696 impl<'de> serde::Deserialize<'de> for GeneratedField {
5697 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5698 where
5699 D: serde::Deserializer<'de>,
5700 {
5701 struct GeneratedVisitor;
5702
5703 impl serde::de::Visitor<'_> for GeneratedVisitor {
5704 type Value = GeneratedField;
5705
5706 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5707 write!(formatter, "expected one of: {:?}", &FIELDS)
5708 }
5709
5710 #[allow(unused_variables)]
5711 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5712 where
5713 E: serde::de::Error,
5714 {
5715 match value {
5716 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5717 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
5718 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
5719 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
5720 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5721 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
5722 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
5723 "emitOnWindowClose" | "emit_on_window_close" => Ok(GeneratedField::EmitOnWindowClose),
5724 "version" => Ok(GeneratedField::Version),
5725 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5726 }
5727 }
5728 }
5729 deserializer.deserialize_identifier(GeneratedVisitor)
5730 }
5731 }
5732 struct GeneratedVisitor;
5733 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5734 type Value = HashAggNode;
5735
5736 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5737 formatter.write_str("struct stream_plan.HashAggNode")
5738 }
5739
5740 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashAggNode, V::Error>
5741 where
5742 V: serde::de::MapAccess<'de>,
5743 {
5744 let mut group_key__ = None;
5745 let mut agg_calls__ = None;
5746 let mut agg_call_states__ = None;
5747 let mut intermediate_state_table__ = None;
5748 let mut is_append_only__ = None;
5749 let mut distinct_dedup_tables__ = None;
5750 let mut row_count_index__ = None;
5751 let mut emit_on_window_close__ = None;
5752 let mut version__ = None;
5753 while let Some(k) = map_.next_key()? {
5754 match k {
5755 GeneratedField::GroupKey => {
5756 if group_key__.is_some() {
5757 return Err(serde::de::Error::duplicate_field("groupKey"));
5758 }
5759 group_key__ =
5760 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5761 .into_iter().map(|x| x.0).collect())
5762 ;
5763 }
5764 GeneratedField::AggCalls => {
5765 if agg_calls__.is_some() {
5766 return Err(serde::de::Error::duplicate_field("aggCalls"));
5767 }
5768 agg_calls__ = Some(map_.next_value()?);
5769 }
5770 GeneratedField::AggCallStates => {
5771 if agg_call_states__.is_some() {
5772 return Err(serde::de::Error::duplicate_field("aggCallStates"));
5773 }
5774 agg_call_states__ = Some(map_.next_value()?);
5775 }
5776 GeneratedField::IntermediateStateTable => {
5777 if intermediate_state_table__.is_some() {
5778 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
5779 }
5780 intermediate_state_table__ = map_.next_value()?;
5781 }
5782 GeneratedField::IsAppendOnly => {
5783 if is_append_only__.is_some() {
5784 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
5785 }
5786 is_append_only__ = Some(map_.next_value()?);
5787 }
5788 GeneratedField::DistinctDedupTables => {
5789 if distinct_dedup_tables__.is_some() {
5790 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
5791 }
5792 distinct_dedup_tables__ = Some(
5793 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5794 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
5795 );
5796 }
5797 GeneratedField::RowCountIndex => {
5798 if row_count_index__.is_some() {
5799 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
5800 }
5801 row_count_index__ =
5802 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5803 ;
5804 }
5805 GeneratedField::EmitOnWindowClose => {
5806 if emit_on_window_close__.is_some() {
5807 return Err(serde::de::Error::duplicate_field("emitOnWindowClose"));
5808 }
5809 emit_on_window_close__ = Some(map_.next_value()?);
5810 }
5811 GeneratedField::Version => {
5812 if version__.is_some() {
5813 return Err(serde::de::Error::duplicate_field("version"));
5814 }
5815 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
5816 }
5817 }
5818 }
5819 Ok(HashAggNode {
5820 group_key: group_key__.unwrap_or_default(),
5821 agg_calls: agg_calls__.unwrap_or_default(),
5822 agg_call_states: agg_call_states__.unwrap_or_default(),
5823 intermediate_state_table: intermediate_state_table__,
5824 is_append_only: is_append_only__.unwrap_or_default(),
5825 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
5826 row_count_index: row_count_index__.unwrap_or_default(),
5827 emit_on_window_close: emit_on_window_close__.unwrap_or_default(),
5828 version: version__.unwrap_or_default(),
5829 })
5830 }
5831 }
5832 deserializer.deserialize_struct("stream_plan.HashAggNode", FIELDS, GeneratedVisitor)
5833 }
5834}
5835impl serde::Serialize for HashJoinNode {
5836 #[allow(deprecated)]
5837 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5838 where
5839 S: serde::Serializer,
5840 {
5841 use serde::ser::SerializeStruct;
5842 let mut len = 0;
5843 if self.join_type != 0 {
5844 len += 1;
5845 }
5846 if !self.left_key.is_empty() {
5847 len += 1;
5848 }
5849 if !self.right_key.is_empty() {
5850 len += 1;
5851 }
5852 if self.condition.is_some() {
5853 len += 1;
5854 }
5855 if self.left_table.is_some() {
5856 len += 1;
5857 }
5858 if self.right_table.is_some() {
5859 len += 1;
5860 }
5861 if self.left_degree_table.is_some() {
5862 len += 1;
5863 }
5864 if self.right_degree_table.is_some() {
5865 len += 1;
5866 }
5867 if !self.output_indices.is_empty() {
5868 len += 1;
5869 }
5870 if !self.left_deduped_input_pk_indices.is_empty() {
5871 len += 1;
5872 }
5873 if !self.right_deduped_input_pk_indices.is_empty() {
5874 len += 1;
5875 }
5876 if !self.null_safe.is_empty() {
5877 len += 1;
5878 }
5879 if self.is_append_only {
5880 len += 1;
5881 }
5882 if self.join_encoding_type != 0 {
5883 len += 1;
5884 }
5885 if self.watermark_handle_desc.is_some() {
5886 len += 1;
5887 }
5888 let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinNode", len)?;
5889 if self.join_type != 0 {
5890 let v = super::plan_common::JoinType::try_from(self.join_type)
5891 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
5892 struct_ser.serialize_field("joinType", &v)?;
5893 }
5894 if !self.left_key.is_empty() {
5895 struct_ser.serialize_field("leftKey", &self.left_key)?;
5896 }
5897 if !self.right_key.is_empty() {
5898 struct_ser.serialize_field("rightKey", &self.right_key)?;
5899 }
5900 if let Some(v) = self.condition.as_ref() {
5901 struct_ser.serialize_field("condition", v)?;
5902 }
5903 if let Some(v) = self.left_table.as_ref() {
5904 struct_ser.serialize_field("leftTable", v)?;
5905 }
5906 if let Some(v) = self.right_table.as_ref() {
5907 struct_ser.serialize_field("rightTable", v)?;
5908 }
5909 if let Some(v) = self.left_degree_table.as_ref() {
5910 struct_ser.serialize_field("leftDegreeTable", v)?;
5911 }
5912 if let Some(v) = self.right_degree_table.as_ref() {
5913 struct_ser.serialize_field("rightDegreeTable", v)?;
5914 }
5915 if !self.output_indices.is_empty() {
5916 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
5917 }
5918 if !self.left_deduped_input_pk_indices.is_empty() {
5919 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
5920 }
5921 if !self.right_deduped_input_pk_indices.is_empty() {
5922 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
5923 }
5924 if !self.null_safe.is_empty() {
5925 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
5926 }
5927 if self.is_append_only {
5928 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5929 }
5930 if self.join_encoding_type != 0 {
5931 let v = JoinEncodingType::try_from(self.join_encoding_type)
5932 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
5933 struct_ser.serialize_field("joinEncodingType", &v)?;
5934 }
5935 if let Some(v) = self.watermark_handle_desc.as_ref() {
5936 struct_ser.serialize_field("watermarkHandleDesc", v)?;
5937 }
5938 struct_ser.end()
5939 }
5940}
5941impl<'de> serde::Deserialize<'de> for HashJoinNode {
5942 #[allow(deprecated)]
5943 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5944 where
5945 D: serde::Deserializer<'de>,
5946 {
5947 const FIELDS: &[&str] = &[
5948 "join_type",
5949 "joinType",
5950 "left_key",
5951 "leftKey",
5952 "right_key",
5953 "rightKey",
5954 "condition",
5955 "left_table",
5956 "leftTable",
5957 "right_table",
5958 "rightTable",
5959 "left_degree_table",
5960 "leftDegreeTable",
5961 "right_degree_table",
5962 "rightDegreeTable",
5963 "output_indices",
5964 "outputIndices",
5965 "left_deduped_input_pk_indices",
5966 "leftDedupedInputPkIndices",
5967 "right_deduped_input_pk_indices",
5968 "rightDedupedInputPkIndices",
5969 "null_safe",
5970 "nullSafe",
5971 "is_append_only",
5972 "isAppendOnly",
5973 "join_encoding_type",
5974 "joinEncodingType",
5975 "watermark_handle_desc",
5976 "watermarkHandleDesc",
5977 ];
5978
5979 #[allow(clippy::enum_variant_names)]
5980 enum GeneratedField {
5981 JoinType,
5982 LeftKey,
5983 RightKey,
5984 Condition,
5985 LeftTable,
5986 RightTable,
5987 LeftDegreeTable,
5988 RightDegreeTable,
5989 OutputIndices,
5990 LeftDedupedInputPkIndices,
5991 RightDedupedInputPkIndices,
5992 NullSafe,
5993 IsAppendOnly,
5994 JoinEncodingType,
5995 WatermarkHandleDesc,
5996 }
5997 impl<'de> serde::Deserialize<'de> for GeneratedField {
5998 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5999 where
6000 D: serde::Deserializer<'de>,
6001 {
6002 struct GeneratedVisitor;
6003
6004 impl serde::de::Visitor<'_> for GeneratedVisitor {
6005 type Value = GeneratedField;
6006
6007 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6008 write!(formatter, "expected one of: {:?}", &FIELDS)
6009 }
6010
6011 #[allow(unused_variables)]
6012 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6013 where
6014 E: serde::de::Error,
6015 {
6016 match value {
6017 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
6018 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
6019 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
6020 "condition" => Ok(GeneratedField::Condition),
6021 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
6022 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
6023 "leftDegreeTable" | "left_degree_table" => Ok(GeneratedField::LeftDegreeTable),
6024 "rightDegreeTable" | "right_degree_table" => Ok(GeneratedField::RightDegreeTable),
6025 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
6026 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
6027 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
6028 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
6029 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
6030 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
6031 "watermarkHandleDesc" | "watermark_handle_desc" => Ok(GeneratedField::WatermarkHandleDesc),
6032 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6033 }
6034 }
6035 }
6036 deserializer.deserialize_identifier(GeneratedVisitor)
6037 }
6038 }
6039 struct GeneratedVisitor;
6040 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6041 type Value = HashJoinNode;
6042
6043 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6044 formatter.write_str("struct stream_plan.HashJoinNode")
6045 }
6046
6047 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinNode, V::Error>
6048 where
6049 V: serde::de::MapAccess<'de>,
6050 {
6051 let mut join_type__ = None;
6052 let mut left_key__ = None;
6053 let mut right_key__ = None;
6054 let mut condition__ = None;
6055 let mut left_table__ = None;
6056 let mut right_table__ = None;
6057 let mut left_degree_table__ = None;
6058 let mut right_degree_table__ = None;
6059 let mut output_indices__ = None;
6060 let mut left_deduped_input_pk_indices__ = None;
6061 let mut right_deduped_input_pk_indices__ = None;
6062 let mut null_safe__ = None;
6063 let mut is_append_only__ = None;
6064 let mut join_encoding_type__ = None;
6065 let mut watermark_handle_desc__ = None;
6066 while let Some(k) = map_.next_key()? {
6067 match k {
6068 GeneratedField::JoinType => {
6069 if join_type__.is_some() {
6070 return Err(serde::de::Error::duplicate_field("joinType"));
6071 }
6072 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
6073 }
6074 GeneratedField::LeftKey => {
6075 if left_key__.is_some() {
6076 return Err(serde::de::Error::duplicate_field("leftKey"));
6077 }
6078 left_key__ =
6079 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6080 .into_iter().map(|x| x.0).collect())
6081 ;
6082 }
6083 GeneratedField::RightKey => {
6084 if right_key__.is_some() {
6085 return Err(serde::de::Error::duplicate_field("rightKey"));
6086 }
6087 right_key__ =
6088 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6089 .into_iter().map(|x| x.0).collect())
6090 ;
6091 }
6092 GeneratedField::Condition => {
6093 if condition__.is_some() {
6094 return Err(serde::de::Error::duplicate_field("condition"));
6095 }
6096 condition__ = map_.next_value()?;
6097 }
6098 GeneratedField::LeftTable => {
6099 if left_table__.is_some() {
6100 return Err(serde::de::Error::duplicate_field("leftTable"));
6101 }
6102 left_table__ = map_.next_value()?;
6103 }
6104 GeneratedField::RightTable => {
6105 if right_table__.is_some() {
6106 return Err(serde::de::Error::duplicate_field("rightTable"));
6107 }
6108 right_table__ = map_.next_value()?;
6109 }
6110 GeneratedField::LeftDegreeTable => {
6111 if left_degree_table__.is_some() {
6112 return Err(serde::de::Error::duplicate_field("leftDegreeTable"));
6113 }
6114 left_degree_table__ = map_.next_value()?;
6115 }
6116 GeneratedField::RightDegreeTable => {
6117 if right_degree_table__.is_some() {
6118 return Err(serde::de::Error::duplicate_field("rightDegreeTable"));
6119 }
6120 right_degree_table__ = map_.next_value()?;
6121 }
6122 GeneratedField::OutputIndices => {
6123 if output_indices__.is_some() {
6124 return Err(serde::de::Error::duplicate_field("outputIndices"));
6125 }
6126 output_indices__ =
6127 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6128 .into_iter().map(|x| x.0).collect())
6129 ;
6130 }
6131 GeneratedField::LeftDedupedInputPkIndices => {
6132 if left_deduped_input_pk_indices__.is_some() {
6133 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
6134 }
6135 left_deduped_input_pk_indices__ =
6136 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6137 .into_iter().map(|x| x.0).collect())
6138 ;
6139 }
6140 GeneratedField::RightDedupedInputPkIndices => {
6141 if right_deduped_input_pk_indices__.is_some() {
6142 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
6143 }
6144 right_deduped_input_pk_indices__ =
6145 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6146 .into_iter().map(|x| x.0).collect())
6147 ;
6148 }
6149 GeneratedField::NullSafe => {
6150 if null_safe__.is_some() {
6151 return Err(serde::de::Error::duplicate_field("nullSafe"));
6152 }
6153 null_safe__ = Some(map_.next_value()?);
6154 }
6155 GeneratedField::IsAppendOnly => {
6156 if is_append_only__.is_some() {
6157 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
6158 }
6159 is_append_only__ = Some(map_.next_value()?);
6160 }
6161 GeneratedField::JoinEncodingType => {
6162 if join_encoding_type__.is_some() {
6163 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
6164 }
6165 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
6166 }
6167 GeneratedField::WatermarkHandleDesc => {
6168 if watermark_handle_desc__.is_some() {
6169 return Err(serde::de::Error::duplicate_field("watermarkHandleDesc"));
6170 }
6171 watermark_handle_desc__ = map_.next_value()?;
6172 }
6173 }
6174 }
6175 Ok(HashJoinNode {
6176 join_type: join_type__.unwrap_or_default(),
6177 left_key: left_key__.unwrap_or_default(),
6178 right_key: right_key__.unwrap_or_default(),
6179 condition: condition__,
6180 left_table: left_table__,
6181 right_table: right_table__,
6182 left_degree_table: left_degree_table__,
6183 right_degree_table: right_degree_table__,
6184 output_indices: output_indices__.unwrap_or_default(),
6185 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
6186 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
6187 null_safe: null_safe__.unwrap_or_default(),
6188 is_append_only: is_append_only__.unwrap_or_default(),
6189 join_encoding_type: join_encoding_type__.unwrap_or_default(),
6190 watermark_handle_desc: watermark_handle_desc__,
6191 })
6192 }
6193 }
6194 deserializer.deserialize_struct("stream_plan.HashJoinNode", FIELDS, GeneratedVisitor)
6195 }
6196}
6197impl serde::Serialize for HashJoinWatermarkHandleDesc {
6198 #[allow(deprecated)]
6199 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6200 where
6201 S: serde::Serializer,
6202 {
6203 use serde::ser::SerializeStruct;
6204 let mut len = 0;
6205 if !self.watermark_indices_in_jk.is_empty() {
6206 len += 1;
6207 }
6208 if !self.inequality_pairs.is_empty() {
6209 len += 1;
6210 }
6211 let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinWatermarkHandleDesc", len)?;
6212 if !self.watermark_indices_in_jk.is_empty() {
6213 struct_ser.serialize_field("watermarkIndicesInJk", &self.watermark_indices_in_jk)?;
6214 }
6215 if !self.inequality_pairs.is_empty() {
6216 struct_ser.serialize_field("inequalityPairs", &self.inequality_pairs)?;
6217 }
6218 struct_ser.end()
6219 }
6220}
6221impl<'de> serde::Deserialize<'de> for HashJoinWatermarkHandleDesc {
6222 #[allow(deprecated)]
6223 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6224 where
6225 D: serde::Deserializer<'de>,
6226 {
6227 const FIELDS: &[&str] = &[
6228 "watermark_indices_in_jk",
6229 "watermarkIndicesInJk",
6230 "inequality_pairs",
6231 "inequalityPairs",
6232 ];
6233
6234 #[allow(clippy::enum_variant_names)]
6235 enum GeneratedField {
6236 WatermarkIndicesInJk,
6237 InequalityPairs,
6238 }
6239 impl<'de> serde::Deserialize<'de> for GeneratedField {
6240 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6241 where
6242 D: serde::Deserializer<'de>,
6243 {
6244 struct GeneratedVisitor;
6245
6246 impl serde::de::Visitor<'_> for GeneratedVisitor {
6247 type Value = GeneratedField;
6248
6249 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6250 write!(formatter, "expected one of: {:?}", &FIELDS)
6251 }
6252
6253 #[allow(unused_variables)]
6254 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6255 where
6256 E: serde::de::Error,
6257 {
6258 match value {
6259 "watermarkIndicesInJk" | "watermark_indices_in_jk" => Ok(GeneratedField::WatermarkIndicesInJk),
6260 "inequalityPairs" | "inequality_pairs" => Ok(GeneratedField::InequalityPairs),
6261 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6262 }
6263 }
6264 }
6265 deserializer.deserialize_identifier(GeneratedVisitor)
6266 }
6267 }
6268 struct GeneratedVisitor;
6269 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6270 type Value = HashJoinWatermarkHandleDesc;
6271
6272 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6273 formatter.write_str("struct stream_plan.HashJoinWatermarkHandleDesc")
6274 }
6275
6276 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinWatermarkHandleDesc, V::Error>
6277 where
6278 V: serde::de::MapAccess<'de>,
6279 {
6280 let mut watermark_indices_in_jk__ = None;
6281 let mut inequality_pairs__ = None;
6282 while let Some(k) = map_.next_key()? {
6283 match k {
6284 GeneratedField::WatermarkIndicesInJk => {
6285 if watermark_indices_in_jk__.is_some() {
6286 return Err(serde::de::Error::duplicate_field("watermarkIndicesInJk"));
6287 }
6288 watermark_indices_in_jk__ = Some(map_.next_value()?);
6289 }
6290 GeneratedField::InequalityPairs => {
6291 if inequality_pairs__.is_some() {
6292 return Err(serde::de::Error::duplicate_field("inequalityPairs"));
6293 }
6294 inequality_pairs__ = Some(map_.next_value()?);
6295 }
6296 }
6297 }
6298 Ok(HashJoinWatermarkHandleDesc {
6299 watermark_indices_in_jk: watermark_indices_in_jk__.unwrap_or_default(),
6300 inequality_pairs: inequality_pairs__.unwrap_or_default(),
6301 })
6302 }
6303 }
6304 deserializer.deserialize_struct("stream_plan.HashJoinWatermarkHandleDesc", FIELDS, GeneratedVisitor)
6305 }
6306}
6307impl serde::Serialize for HopWindowNode {
6308 #[allow(deprecated)]
6309 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6310 where
6311 S: serde::Serializer,
6312 {
6313 use serde::ser::SerializeStruct;
6314 let mut len = 0;
6315 if self.time_col != 0 {
6316 len += 1;
6317 }
6318 if self.window_slide.is_some() {
6319 len += 1;
6320 }
6321 if self.window_size.is_some() {
6322 len += 1;
6323 }
6324 if !self.output_indices.is_empty() {
6325 len += 1;
6326 }
6327 if !self.window_start_exprs.is_empty() {
6328 len += 1;
6329 }
6330 if !self.window_end_exprs.is_empty() {
6331 len += 1;
6332 }
6333 let mut struct_ser = serializer.serialize_struct("stream_plan.HopWindowNode", len)?;
6334 if self.time_col != 0 {
6335 struct_ser.serialize_field("timeCol", &self.time_col)?;
6336 }
6337 if let Some(v) = self.window_slide.as_ref() {
6338 struct_ser.serialize_field("windowSlide", v)?;
6339 }
6340 if let Some(v) = self.window_size.as_ref() {
6341 struct_ser.serialize_field("windowSize", v)?;
6342 }
6343 if !self.output_indices.is_empty() {
6344 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
6345 }
6346 if !self.window_start_exprs.is_empty() {
6347 struct_ser.serialize_field("windowStartExprs", &self.window_start_exprs)?;
6348 }
6349 if !self.window_end_exprs.is_empty() {
6350 struct_ser.serialize_field("windowEndExprs", &self.window_end_exprs)?;
6351 }
6352 struct_ser.end()
6353 }
6354}
6355impl<'de> serde::Deserialize<'de> for HopWindowNode {
6356 #[allow(deprecated)]
6357 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6358 where
6359 D: serde::Deserializer<'de>,
6360 {
6361 const FIELDS: &[&str] = &[
6362 "time_col",
6363 "timeCol",
6364 "window_slide",
6365 "windowSlide",
6366 "window_size",
6367 "windowSize",
6368 "output_indices",
6369 "outputIndices",
6370 "window_start_exprs",
6371 "windowStartExprs",
6372 "window_end_exprs",
6373 "windowEndExprs",
6374 ];
6375
6376 #[allow(clippy::enum_variant_names)]
6377 enum GeneratedField {
6378 TimeCol,
6379 WindowSlide,
6380 WindowSize,
6381 OutputIndices,
6382 WindowStartExprs,
6383 WindowEndExprs,
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 serde::de::Visitor<'_> 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 "timeCol" | "time_col" => Ok(GeneratedField::TimeCol),
6406 "windowSlide" | "window_slide" => Ok(GeneratedField::WindowSlide),
6407 "windowSize" | "window_size" => Ok(GeneratedField::WindowSize),
6408 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
6409 "windowStartExprs" | "window_start_exprs" => Ok(GeneratedField::WindowStartExprs),
6410 "windowEndExprs" | "window_end_exprs" => Ok(GeneratedField::WindowEndExprs),
6411 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6412 }
6413 }
6414 }
6415 deserializer.deserialize_identifier(GeneratedVisitor)
6416 }
6417 }
6418 struct GeneratedVisitor;
6419 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6420 type Value = HopWindowNode;
6421
6422 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6423 formatter.write_str("struct stream_plan.HopWindowNode")
6424 }
6425
6426 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HopWindowNode, V::Error>
6427 where
6428 V: serde::de::MapAccess<'de>,
6429 {
6430 let mut time_col__ = None;
6431 let mut window_slide__ = None;
6432 let mut window_size__ = None;
6433 let mut output_indices__ = None;
6434 let mut window_start_exprs__ = None;
6435 let mut window_end_exprs__ = None;
6436 while let Some(k) = map_.next_key()? {
6437 match k {
6438 GeneratedField::TimeCol => {
6439 if time_col__.is_some() {
6440 return Err(serde::de::Error::duplicate_field("timeCol"));
6441 }
6442 time_col__ =
6443 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6444 ;
6445 }
6446 GeneratedField::WindowSlide => {
6447 if window_slide__.is_some() {
6448 return Err(serde::de::Error::duplicate_field("windowSlide"));
6449 }
6450 window_slide__ = map_.next_value()?;
6451 }
6452 GeneratedField::WindowSize => {
6453 if window_size__.is_some() {
6454 return Err(serde::de::Error::duplicate_field("windowSize"));
6455 }
6456 window_size__ = map_.next_value()?;
6457 }
6458 GeneratedField::OutputIndices => {
6459 if output_indices__.is_some() {
6460 return Err(serde::de::Error::duplicate_field("outputIndices"));
6461 }
6462 output_indices__ =
6463 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6464 .into_iter().map(|x| x.0).collect())
6465 ;
6466 }
6467 GeneratedField::WindowStartExprs => {
6468 if window_start_exprs__.is_some() {
6469 return Err(serde::de::Error::duplicate_field("windowStartExprs"));
6470 }
6471 window_start_exprs__ = Some(map_.next_value()?);
6472 }
6473 GeneratedField::WindowEndExprs => {
6474 if window_end_exprs__.is_some() {
6475 return Err(serde::de::Error::duplicate_field("windowEndExprs"));
6476 }
6477 window_end_exprs__ = Some(map_.next_value()?);
6478 }
6479 }
6480 }
6481 Ok(HopWindowNode {
6482 time_col: time_col__.unwrap_or_default(),
6483 window_slide: window_slide__,
6484 window_size: window_size__,
6485 output_indices: output_indices__.unwrap_or_default(),
6486 window_start_exprs: window_start_exprs__.unwrap_or_default(),
6487 window_end_exprs: window_end_exprs__.unwrap_or_default(),
6488 })
6489 }
6490 }
6491 deserializer.deserialize_struct("stream_plan.HopWindowNode", FIELDS, GeneratedVisitor)
6492 }
6493}
6494impl serde::Serialize for IcebergWithPkIndexDvMergerNode {
6495 #[allow(deprecated)]
6496 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6497 where
6498 S: serde::Serializer,
6499 {
6500 use serde::ser::SerializeStruct;
6501 let mut len = 0;
6502 if self.sink_desc.is_some() {
6503 len += 1;
6504 }
6505 let mut struct_ser = serializer.serialize_struct("stream_plan.IcebergWithPkIndexDvMergerNode", len)?;
6506 if let Some(v) = self.sink_desc.as_ref() {
6507 struct_ser.serialize_field("sinkDesc", v)?;
6508 }
6509 struct_ser.end()
6510 }
6511}
6512impl<'de> serde::Deserialize<'de> for IcebergWithPkIndexDvMergerNode {
6513 #[allow(deprecated)]
6514 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6515 where
6516 D: serde::Deserializer<'de>,
6517 {
6518 const FIELDS: &[&str] = &[
6519 "sink_desc",
6520 "sinkDesc",
6521 ];
6522
6523 #[allow(clippy::enum_variant_names)]
6524 enum GeneratedField {
6525 SinkDesc,
6526 }
6527 impl<'de> serde::Deserialize<'de> for GeneratedField {
6528 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6529 where
6530 D: serde::Deserializer<'de>,
6531 {
6532 struct GeneratedVisitor;
6533
6534 impl serde::de::Visitor<'_> for GeneratedVisitor {
6535 type Value = GeneratedField;
6536
6537 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6538 write!(formatter, "expected one of: {:?}", &FIELDS)
6539 }
6540
6541 #[allow(unused_variables)]
6542 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6543 where
6544 E: serde::de::Error,
6545 {
6546 match value {
6547 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
6548 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6549 }
6550 }
6551 }
6552 deserializer.deserialize_identifier(GeneratedVisitor)
6553 }
6554 }
6555 struct GeneratedVisitor;
6556 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6557 type Value = IcebergWithPkIndexDvMergerNode;
6558
6559 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6560 formatter.write_str("struct stream_plan.IcebergWithPkIndexDvMergerNode")
6561 }
6562
6563 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IcebergWithPkIndexDvMergerNode, V::Error>
6564 where
6565 V: serde::de::MapAccess<'de>,
6566 {
6567 let mut sink_desc__ = None;
6568 while let Some(k) = map_.next_key()? {
6569 match k {
6570 GeneratedField::SinkDesc => {
6571 if sink_desc__.is_some() {
6572 return Err(serde::de::Error::duplicate_field("sinkDesc"));
6573 }
6574 sink_desc__ = map_.next_value()?;
6575 }
6576 }
6577 }
6578 Ok(IcebergWithPkIndexDvMergerNode {
6579 sink_desc: sink_desc__,
6580 })
6581 }
6582 }
6583 deserializer.deserialize_struct("stream_plan.IcebergWithPkIndexDvMergerNode", FIELDS, GeneratedVisitor)
6584 }
6585}
6586impl serde::Serialize for IcebergWithPkIndexWriterNode {
6587 #[allow(deprecated)]
6588 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6589 where
6590 S: serde::Serializer,
6591 {
6592 use serde::ser::SerializeStruct;
6593 let mut len = 0;
6594 if self.sink_desc.is_some() {
6595 len += 1;
6596 }
6597 if self.pk_index_table.is_some() {
6598 len += 1;
6599 }
6600 let mut struct_ser = serializer.serialize_struct("stream_plan.IcebergWithPkIndexWriterNode", len)?;
6601 if let Some(v) = self.sink_desc.as_ref() {
6602 struct_ser.serialize_field("sinkDesc", v)?;
6603 }
6604 if let Some(v) = self.pk_index_table.as_ref() {
6605 struct_ser.serialize_field("pkIndexTable", v)?;
6606 }
6607 struct_ser.end()
6608 }
6609}
6610impl<'de> serde::Deserialize<'de> for IcebergWithPkIndexWriterNode {
6611 #[allow(deprecated)]
6612 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6613 where
6614 D: serde::Deserializer<'de>,
6615 {
6616 const FIELDS: &[&str] = &[
6617 "sink_desc",
6618 "sinkDesc",
6619 "pk_index_table",
6620 "pkIndexTable",
6621 ];
6622
6623 #[allow(clippy::enum_variant_names)]
6624 enum GeneratedField {
6625 SinkDesc,
6626 PkIndexTable,
6627 }
6628 impl<'de> serde::Deserialize<'de> for GeneratedField {
6629 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6630 where
6631 D: serde::Deserializer<'de>,
6632 {
6633 struct GeneratedVisitor;
6634
6635 impl serde::de::Visitor<'_> for GeneratedVisitor {
6636 type Value = GeneratedField;
6637
6638 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6639 write!(formatter, "expected one of: {:?}", &FIELDS)
6640 }
6641
6642 #[allow(unused_variables)]
6643 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6644 where
6645 E: serde::de::Error,
6646 {
6647 match value {
6648 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
6649 "pkIndexTable" | "pk_index_table" => Ok(GeneratedField::PkIndexTable),
6650 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6651 }
6652 }
6653 }
6654 deserializer.deserialize_identifier(GeneratedVisitor)
6655 }
6656 }
6657 struct GeneratedVisitor;
6658 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6659 type Value = IcebergWithPkIndexWriterNode;
6660
6661 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6662 formatter.write_str("struct stream_plan.IcebergWithPkIndexWriterNode")
6663 }
6664
6665 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IcebergWithPkIndexWriterNode, V::Error>
6666 where
6667 V: serde::de::MapAccess<'de>,
6668 {
6669 let mut sink_desc__ = None;
6670 let mut pk_index_table__ = None;
6671 while let Some(k) = map_.next_key()? {
6672 match k {
6673 GeneratedField::SinkDesc => {
6674 if sink_desc__.is_some() {
6675 return Err(serde::de::Error::duplicate_field("sinkDesc"));
6676 }
6677 sink_desc__ = map_.next_value()?;
6678 }
6679 GeneratedField::PkIndexTable => {
6680 if pk_index_table__.is_some() {
6681 return Err(serde::de::Error::duplicate_field("pkIndexTable"));
6682 }
6683 pk_index_table__ = map_.next_value()?;
6684 }
6685 }
6686 }
6687 Ok(IcebergWithPkIndexWriterNode {
6688 sink_desc: sink_desc__,
6689 pk_index_table: pk_index_table__,
6690 })
6691 }
6692 }
6693 deserializer.deserialize_struct("stream_plan.IcebergWithPkIndexWriterNode", FIELDS, GeneratedVisitor)
6694 }
6695}
6696impl serde::Serialize for InequalityPair {
6697 #[allow(deprecated)]
6698 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6699 where
6700 S: serde::Serializer,
6701 {
6702 use serde::ser::SerializeStruct;
6703 let mut len = 0;
6704 if self.key_required_larger != 0 {
6705 len += 1;
6706 }
6707 if self.key_required_smaller != 0 {
6708 len += 1;
6709 }
6710 if self.clean_state {
6711 len += 1;
6712 }
6713 if self.delta_expression.is_some() {
6714 len += 1;
6715 }
6716 let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPair", len)?;
6717 if self.key_required_larger != 0 {
6718 struct_ser.serialize_field("keyRequiredLarger", &self.key_required_larger)?;
6719 }
6720 if self.key_required_smaller != 0 {
6721 struct_ser.serialize_field("keyRequiredSmaller", &self.key_required_smaller)?;
6722 }
6723 if self.clean_state {
6724 struct_ser.serialize_field("cleanState", &self.clean_state)?;
6725 }
6726 if let Some(v) = self.delta_expression.as_ref() {
6727 struct_ser.serialize_field("deltaExpression", v)?;
6728 }
6729 struct_ser.end()
6730 }
6731}
6732impl<'de> serde::Deserialize<'de> for InequalityPair {
6733 #[allow(deprecated)]
6734 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6735 where
6736 D: serde::Deserializer<'de>,
6737 {
6738 const FIELDS: &[&str] = &[
6739 "key_required_larger",
6740 "keyRequiredLarger",
6741 "key_required_smaller",
6742 "keyRequiredSmaller",
6743 "clean_state",
6744 "cleanState",
6745 "delta_expression",
6746 "deltaExpression",
6747 ];
6748
6749 #[allow(clippy::enum_variant_names)]
6750 enum GeneratedField {
6751 KeyRequiredLarger,
6752 KeyRequiredSmaller,
6753 CleanState,
6754 DeltaExpression,
6755 }
6756 impl<'de> serde::Deserialize<'de> for GeneratedField {
6757 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6758 where
6759 D: serde::Deserializer<'de>,
6760 {
6761 struct GeneratedVisitor;
6762
6763 impl serde::de::Visitor<'_> for GeneratedVisitor {
6764 type Value = GeneratedField;
6765
6766 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6767 write!(formatter, "expected one of: {:?}", &FIELDS)
6768 }
6769
6770 #[allow(unused_variables)]
6771 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6772 where
6773 E: serde::de::Error,
6774 {
6775 match value {
6776 "keyRequiredLarger" | "key_required_larger" => Ok(GeneratedField::KeyRequiredLarger),
6777 "keyRequiredSmaller" | "key_required_smaller" => Ok(GeneratedField::KeyRequiredSmaller),
6778 "cleanState" | "clean_state" => Ok(GeneratedField::CleanState),
6779 "deltaExpression" | "delta_expression" => Ok(GeneratedField::DeltaExpression),
6780 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6781 }
6782 }
6783 }
6784 deserializer.deserialize_identifier(GeneratedVisitor)
6785 }
6786 }
6787 struct GeneratedVisitor;
6788 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6789 type Value = InequalityPair;
6790
6791 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6792 formatter.write_str("struct stream_plan.InequalityPair")
6793 }
6794
6795 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPair, V::Error>
6796 where
6797 V: serde::de::MapAccess<'de>,
6798 {
6799 let mut key_required_larger__ = None;
6800 let mut key_required_smaller__ = None;
6801 let mut clean_state__ = None;
6802 let mut delta_expression__ = None;
6803 while let Some(k) = map_.next_key()? {
6804 match k {
6805 GeneratedField::KeyRequiredLarger => {
6806 if key_required_larger__.is_some() {
6807 return Err(serde::de::Error::duplicate_field("keyRequiredLarger"));
6808 }
6809 key_required_larger__ =
6810 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6811 ;
6812 }
6813 GeneratedField::KeyRequiredSmaller => {
6814 if key_required_smaller__.is_some() {
6815 return Err(serde::de::Error::duplicate_field("keyRequiredSmaller"));
6816 }
6817 key_required_smaller__ =
6818 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6819 ;
6820 }
6821 GeneratedField::CleanState => {
6822 if clean_state__.is_some() {
6823 return Err(serde::de::Error::duplicate_field("cleanState"));
6824 }
6825 clean_state__ = Some(map_.next_value()?);
6826 }
6827 GeneratedField::DeltaExpression => {
6828 if delta_expression__.is_some() {
6829 return Err(serde::de::Error::duplicate_field("deltaExpression"));
6830 }
6831 delta_expression__ = map_.next_value()?;
6832 }
6833 }
6834 }
6835 Ok(InequalityPair {
6836 key_required_larger: key_required_larger__.unwrap_or_default(),
6837 key_required_smaller: key_required_smaller__.unwrap_or_default(),
6838 clean_state: clean_state__.unwrap_or_default(),
6839 delta_expression: delta_expression__,
6840 })
6841 }
6842 }
6843 deserializer.deserialize_struct("stream_plan.InequalityPair", FIELDS, GeneratedVisitor)
6844 }
6845}
6846impl serde::Serialize for InequalityPairV2 {
6847 #[allow(deprecated)]
6848 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6849 where
6850 S: serde::Serializer,
6851 {
6852 use serde::ser::SerializeStruct;
6853 let mut len = 0;
6854 if self.left_idx != 0 {
6855 len += 1;
6856 }
6857 if self.right_idx != 0 {
6858 len += 1;
6859 }
6860 if self.clean_left_state {
6861 len += 1;
6862 }
6863 if self.clean_right_state {
6864 len += 1;
6865 }
6866 if self.op != 0 {
6867 len += 1;
6868 }
6869 let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPairV2", len)?;
6870 if self.left_idx != 0 {
6871 struct_ser.serialize_field("leftIdx", &self.left_idx)?;
6872 }
6873 if self.right_idx != 0 {
6874 struct_ser.serialize_field("rightIdx", &self.right_idx)?;
6875 }
6876 if self.clean_left_state {
6877 struct_ser.serialize_field("cleanLeftState", &self.clean_left_state)?;
6878 }
6879 if self.clean_right_state {
6880 struct_ser.serialize_field("cleanRightState", &self.clean_right_state)?;
6881 }
6882 if self.op != 0 {
6883 let v = InequalityType::try_from(self.op)
6884 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.op)))?;
6885 struct_ser.serialize_field("op", &v)?;
6886 }
6887 struct_ser.end()
6888 }
6889}
6890impl<'de> serde::Deserialize<'de> for InequalityPairV2 {
6891 #[allow(deprecated)]
6892 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6893 where
6894 D: serde::Deserializer<'de>,
6895 {
6896 const FIELDS: &[&str] = &[
6897 "left_idx",
6898 "leftIdx",
6899 "right_idx",
6900 "rightIdx",
6901 "clean_left_state",
6902 "cleanLeftState",
6903 "clean_right_state",
6904 "cleanRightState",
6905 "op",
6906 ];
6907
6908 #[allow(clippy::enum_variant_names)]
6909 enum GeneratedField {
6910 LeftIdx,
6911 RightIdx,
6912 CleanLeftState,
6913 CleanRightState,
6914 Op,
6915 }
6916 impl<'de> serde::Deserialize<'de> for GeneratedField {
6917 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6918 where
6919 D: serde::Deserializer<'de>,
6920 {
6921 struct GeneratedVisitor;
6922
6923 impl serde::de::Visitor<'_> for GeneratedVisitor {
6924 type Value = GeneratedField;
6925
6926 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6927 write!(formatter, "expected one of: {:?}", &FIELDS)
6928 }
6929
6930 #[allow(unused_variables)]
6931 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6932 where
6933 E: serde::de::Error,
6934 {
6935 match value {
6936 "leftIdx" | "left_idx" => Ok(GeneratedField::LeftIdx),
6937 "rightIdx" | "right_idx" => Ok(GeneratedField::RightIdx),
6938 "cleanLeftState" | "clean_left_state" => Ok(GeneratedField::CleanLeftState),
6939 "cleanRightState" | "clean_right_state" => Ok(GeneratedField::CleanRightState),
6940 "op" => Ok(GeneratedField::Op),
6941 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6942 }
6943 }
6944 }
6945 deserializer.deserialize_identifier(GeneratedVisitor)
6946 }
6947 }
6948 struct GeneratedVisitor;
6949 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6950 type Value = InequalityPairV2;
6951
6952 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6953 formatter.write_str("struct stream_plan.InequalityPairV2")
6954 }
6955
6956 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPairV2, V::Error>
6957 where
6958 V: serde::de::MapAccess<'de>,
6959 {
6960 let mut left_idx__ = None;
6961 let mut right_idx__ = None;
6962 let mut clean_left_state__ = None;
6963 let mut clean_right_state__ = None;
6964 let mut op__ = None;
6965 while let Some(k) = map_.next_key()? {
6966 match k {
6967 GeneratedField::LeftIdx => {
6968 if left_idx__.is_some() {
6969 return Err(serde::de::Error::duplicate_field("leftIdx"));
6970 }
6971 left_idx__ =
6972 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6973 ;
6974 }
6975 GeneratedField::RightIdx => {
6976 if right_idx__.is_some() {
6977 return Err(serde::de::Error::duplicate_field("rightIdx"));
6978 }
6979 right_idx__ =
6980 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6981 ;
6982 }
6983 GeneratedField::CleanLeftState => {
6984 if clean_left_state__.is_some() {
6985 return Err(serde::de::Error::duplicate_field("cleanLeftState"));
6986 }
6987 clean_left_state__ = Some(map_.next_value()?);
6988 }
6989 GeneratedField::CleanRightState => {
6990 if clean_right_state__.is_some() {
6991 return Err(serde::de::Error::duplicate_field("cleanRightState"));
6992 }
6993 clean_right_state__ = Some(map_.next_value()?);
6994 }
6995 GeneratedField::Op => {
6996 if op__.is_some() {
6997 return Err(serde::de::Error::duplicate_field("op"));
6998 }
6999 op__ = Some(map_.next_value::<InequalityType>()? as i32);
7000 }
7001 }
7002 }
7003 Ok(InequalityPairV2 {
7004 left_idx: left_idx__.unwrap_or_default(),
7005 right_idx: right_idx__.unwrap_or_default(),
7006 clean_left_state: clean_left_state__.unwrap_or_default(),
7007 clean_right_state: clean_right_state__.unwrap_or_default(),
7008 op: op__.unwrap_or_default(),
7009 })
7010 }
7011 }
7012 deserializer.deserialize_struct("stream_plan.InequalityPairV2", FIELDS, GeneratedVisitor)
7013 }
7014}
7015impl serde::Serialize for InequalityType {
7016 #[allow(deprecated)]
7017 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7018 where
7019 S: serde::Serializer,
7020 {
7021 let variant = match self {
7022 Self::Unspecified => "INEQUALITY_TYPE_UNSPECIFIED",
7023 Self::LessThan => "INEQUALITY_TYPE_LESS_THAN",
7024 Self::LessThanOrEqual => "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL",
7025 Self::GreaterThan => "INEQUALITY_TYPE_GREATER_THAN",
7026 Self::GreaterThanOrEqual => "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL",
7027 };
7028 serializer.serialize_str(variant)
7029 }
7030}
7031impl<'de> serde::Deserialize<'de> for InequalityType {
7032 #[allow(deprecated)]
7033 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7034 where
7035 D: serde::Deserializer<'de>,
7036 {
7037 const FIELDS: &[&str] = &[
7038 "INEQUALITY_TYPE_UNSPECIFIED",
7039 "INEQUALITY_TYPE_LESS_THAN",
7040 "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL",
7041 "INEQUALITY_TYPE_GREATER_THAN",
7042 "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL",
7043 ];
7044
7045 struct GeneratedVisitor;
7046
7047 impl serde::de::Visitor<'_> for GeneratedVisitor {
7048 type Value = InequalityType;
7049
7050 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7051 write!(formatter, "expected one of: {:?}", &FIELDS)
7052 }
7053
7054 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
7055 where
7056 E: serde::de::Error,
7057 {
7058 i32::try_from(v)
7059 .ok()
7060 .and_then(|x| x.try_into().ok())
7061 .ok_or_else(|| {
7062 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
7063 })
7064 }
7065
7066 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
7067 where
7068 E: serde::de::Error,
7069 {
7070 i32::try_from(v)
7071 .ok()
7072 .and_then(|x| x.try_into().ok())
7073 .ok_or_else(|| {
7074 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
7075 })
7076 }
7077
7078 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
7079 where
7080 E: serde::de::Error,
7081 {
7082 match value {
7083 "INEQUALITY_TYPE_UNSPECIFIED" => Ok(InequalityType::Unspecified),
7084 "INEQUALITY_TYPE_LESS_THAN" => Ok(InequalityType::LessThan),
7085 "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL" => Ok(InequalityType::LessThanOrEqual),
7086 "INEQUALITY_TYPE_GREATER_THAN" => Ok(InequalityType::GreaterThan),
7087 "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL" => Ok(InequalityType::GreaterThanOrEqual),
7088 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
7089 }
7090 }
7091 }
7092 deserializer.deserialize_any(GeneratedVisitor)
7093 }
7094}
7095impl serde::Serialize for InjectSourceOffsetsMutation {
7096 #[allow(deprecated)]
7097 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7098 where
7099 S: serde::Serializer,
7100 {
7101 use serde::ser::SerializeStruct;
7102 let mut len = 0;
7103 if self.source_id != 0 {
7104 len += 1;
7105 }
7106 if !self.split_offsets.is_empty() {
7107 len += 1;
7108 }
7109 let mut struct_ser = serializer.serialize_struct("stream_plan.InjectSourceOffsetsMutation", len)?;
7110 if self.source_id != 0 {
7111 struct_ser.serialize_field("sourceId", &self.source_id)?;
7112 }
7113 if !self.split_offsets.is_empty() {
7114 struct_ser.serialize_field("splitOffsets", &self.split_offsets)?;
7115 }
7116 struct_ser.end()
7117 }
7118}
7119impl<'de> serde::Deserialize<'de> for InjectSourceOffsetsMutation {
7120 #[allow(deprecated)]
7121 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7122 where
7123 D: serde::Deserializer<'de>,
7124 {
7125 const FIELDS: &[&str] = &[
7126 "source_id",
7127 "sourceId",
7128 "split_offsets",
7129 "splitOffsets",
7130 ];
7131
7132 #[allow(clippy::enum_variant_names)]
7133 enum GeneratedField {
7134 SourceId,
7135 SplitOffsets,
7136 }
7137 impl<'de> serde::Deserialize<'de> for GeneratedField {
7138 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7139 where
7140 D: serde::Deserializer<'de>,
7141 {
7142 struct GeneratedVisitor;
7143
7144 impl serde::de::Visitor<'_> for GeneratedVisitor {
7145 type Value = GeneratedField;
7146
7147 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7148 write!(formatter, "expected one of: {:?}", &FIELDS)
7149 }
7150
7151 #[allow(unused_variables)]
7152 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7153 where
7154 E: serde::de::Error,
7155 {
7156 match value {
7157 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
7158 "splitOffsets" | "split_offsets" => Ok(GeneratedField::SplitOffsets),
7159 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7160 }
7161 }
7162 }
7163 deserializer.deserialize_identifier(GeneratedVisitor)
7164 }
7165 }
7166 struct GeneratedVisitor;
7167 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7168 type Value = InjectSourceOffsetsMutation;
7169
7170 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7171 formatter.write_str("struct stream_plan.InjectSourceOffsetsMutation")
7172 }
7173
7174 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InjectSourceOffsetsMutation, V::Error>
7175 where
7176 V: serde::de::MapAccess<'de>,
7177 {
7178 let mut source_id__ = None;
7179 let mut split_offsets__ = None;
7180 while let Some(k) = map_.next_key()? {
7181 match k {
7182 GeneratedField::SourceId => {
7183 if source_id__.is_some() {
7184 return Err(serde::de::Error::duplicate_field("sourceId"));
7185 }
7186 source_id__ =
7187 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7188 ;
7189 }
7190 GeneratedField::SplitOffsets => {
7191 if split_offsets__.is_some() {
7192 return Err(serde::de::Error::duplicate_field("splitOffsets"));
7193 }
7194 split_offsets__ = Some(
7195 map_.next_value::<std::collections::HashMap<_, _>>()?
7196 );
7197 }
7198 }
7199 }
7200 Ok(InjectSourceOffsetsMutation {
7201 source_id: source_id__.unwrap_or_default(),
7202 split_offsets: split_offsets__.unwrap_or_default(),
7203 })
7204 }
7205 }
7206 deserializer.deserialize_struct("stream_plan.InjectSourceOffsetsMutation", FIELDS, GeneratedVisitor)
7207 }
7208}
7209impl serde::Serialize for JoinEncodingType {
7210 #[allow(deprecated)]
7211 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7212 where
7213 S: serde::Serializer,
7214 {
7215 let variant = match self {
7216 Self::Unspecified => "UNSPECIFIED",
7217 Self::MemoryOptimized => "MEMORY_OPTIMIZED",
7218 Self::CpuOptimized => "CPU_OPTIMIZED",
7219 };
7220 serializer.serialize_str(variant)
7221 }
7222}
7223impl<'de> serde::Deserialize<'de> for JoinEncodingType {
7224 #[allow(deprecated)]
7225 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7226 where
7227 D: serde::Deserializer<'de>,
7228 {
7229 const FIELDS: &[&str] = &[
7230 "UNSPECIFIED",
7231 "MEMORY_OPTIMIZED",
7232 "CPU_OPTIMIZED",
7233 ];
7234
7235 struct GeneratedVisitor;
7236
7237 impl serde::de::Visitor<'_> for GeneratedVisitor {
7238 type Value = JoinEncodingType;
7239
7240 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7241 write!(formatter, "expected one of: {:?}", &FIELDS)
7242 }
7243
7244 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
7245 where
7246 E: serde::de::Error,
7247 {
7248 i32::try_from(v)
7249 .ok()
7250 .and_then(|x| x.try_into().ok())
7251 .ok_or_else(|| {
7252 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
7253 })
7254 }
7255
7256 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
7257 where
7258 E: serde::de::Error,
7259 {
7260 i32::try_from(v)
7261 .ok()
7262 .and_then(|x| x.try_into().ok())
7263 .ok_or_else(|| {
7264 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
7265 })
7266 }
7267
7268 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
7269 where
7270 E: serde::de::Error,
7271 {
7272 match value {
7273 "UNSPECIFIED" => Ok(JoinEncodingType::Unspecified),
7274 "MEMORY_OPTIMIZED" => Ok(JoinEncodingType::MemoryOptimized),
7275 "CPU_OPTIMIZED" => Ok(JoinEncodingType::CpuOptimized),
7276 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
7277 }
7278 }
7279 }
7280 deserializer.deserialize_any(GeneratedVisitor)
7281 }
7282}
7283impl serde::Serialize for JoinKeyWatermarkIndex {
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.index != 0 {
7292 len += 1;
7293 }
7294 if self.do_state_cleaning {
7295 len += 1;
7296 }
7297 let mut struct_ser = serializer.serialize_struct("stream_plan.JoinKeyWatermarkIndex", len)?;
7298 if self.index != 0 {
7299 struct_ser.serialize_field("index", &self.index)?;
7300 }
7301 if self.do_state_cleaning {
7302 struct_ser.serialize_field("doStateCleaning", &self.do_state_cleaning)?;
7303 }
7304 struct_ser.end()
7305 }
7306}
7307impl<'de> serde::Deserialize<'de> for JoinKeyWatermarkIndex {
7308 #[allow(deprecated)]
7309 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7310 where
7311 D: serde::Deserializer<'de>,
7312 {
7313 const FIELDS: &[&str] = &[
7314 "index",
7315 "do_state_cleaning",
7316 "doStateCleaning",
7317 ];
7318
7319 #[allow(clippy::enum_variant_names)]
7320 enum GeneratedField {
7321 Index,
7322 DoStateCleaning,
7323 }
7324 impl<'de> serde::Deserialize<'de> for GeneratedField {
7325 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7326 where
7327 D: serde::Deserializer<'de>,
7328 {
7329 struct GeneratedVisitor;
7330
7331 impl serde::de::Visitor<'_> for GeneratedVisitor {
7332 type Value = GeneratedField;
7333
7334 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7335 write!(formatter, "expected one of: {:?}", &FIELDS)
7336 }
7337
7338 #[allow(unused_variables)]
7339 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7340 where
7341 E: serde::de::Error,
7342 {
7343 match value {
7344 "index" => Ok(GeneratedField::Index),
7345 "doStateCleaning" | "do_state_cleaning" => Ok(GeneratedField::DoStateCleaning),
7346 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7347 }
7348 }
7349 }
7350 deserializer.deserialize_identifier(GeneratedVisitor)
7351 }
7352 }
7353 struct GeneratedVisitor;
7354 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7355 type Value = JoinKeyWatermarkIndex;
7356
7357 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7358 formatter.write_str("struct stream_plan.JoinKeyWatermarkIndex")
7359 }
7360
7361 fn visit_map<V>(self, mut map_: V) -> std::result::Result<JoinKeyWatermarkIndex, V::Error>
7362 where
7363 V: serde::de::MapAccess<'de>,
7364 {
7365 let mut index__ = None;
7366 let mut do_state_cleaning__ = None;
7367 while let Some(k) = map_.next_key()? {
7368 match k {
7369 GeneratedField::Index => {
7370 if index__.is_some() {
7371 return Err(serde::de::Error::duplicate_field("index"));
7372 }
7373 index__ =
7374 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7375 ;
7376 }
7377 GeneratedField::DoStateCleaning => {
7378 if do_state_cleaning__.is_some() {
7379 return Err(serde::de::Error::duplicate_field("doStateCleaning"));
7380 }
7381 do_state_cleaning__ = Some(map_.next_value()?);
7382 }
7383 }
7384 }
7385 Ok(JoinKeyWatermarkIndex {
7386 index: index__.unwrap_or_default(),
7387 do_state_cleaning: do_state_cleaning__.unwrap_or_default(),
7388 })
7389 }
7390 }
7391 deserializer.deserialize_struct("stream_plan.JoinKeyWatermarkIndex", FIELDS, GeneratedVisitor)
7392 }
7393}
7394impl serde::Serialize for ListFinishMutation {
7395 #[allow(deprecated)]
7396 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7397 where
7398 S: serde::Serializer,
7399 {
7400 use serde::ser::SerializeStruct;
7401 let mut len = 0;
7402 if self.associated_source_id != 0 {
7403 len += 1;
7404 }
7405 let mut struct_ser = serializer.serialize_struct("stream_plan.ListFinishMutation", len)?;
7406 if self.associated_source_id != 0 {
7407 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
7408 }
7409 struct_ser.end()
7410 }
7411}
7412impl<'de> serde::Deserialize<'de> for ListFinishMutation {
7413 #[allow(deprecated)]
7414 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7415 where
7416 D: serde::Deserializer<'de>,
7417 {
7418 const FIELDS: &[&str] = &[
7419 "associated_source_id",
7420 "associatedSourceId",
7421 ];
7422
7423 #[allow(clippy::enum_variant_names)]
7424 enum GeneratedField {
7425 AssociatedSourceId,
7426 }
7427 impl<'de> serde::Deserialize<'de> for GeneratedField {
7428 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7429 where
7430 D: serde::Deserializer<'de>,
7431 {
7432 struct GeneratedVisitor;
7433
7434 impl serde::de::Visitor<'_> for GeneratedVisitor {
7435 type Value = GeneratedField;
7436
7437 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7438 write!(formatter, "expected one of: {:?}", &FIELDS)
7439 }
7440
7441 #[allow(unused_variables)]
7442 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7443 where
7444 E: serde::de::Error,
7445 {
7446 match value {
7447 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
7448 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7449 }
7450 }
7451 }
7452 deserializer.deserialize_identifier(GeneratedVisitor)
7453 }
7454 }
7455 struct GeneratedVisitor;
7456 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7457 type Value = ListFinishMutation;
7458
7459 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7460 formatter.write_str("struct stream_plan.ListFinishMutation")
7461 }
7462
7463 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFinishMutation, V::Error>
7464 where
7465 V: serde::de::MapAccess<'de>,
7466 {
7467 let mut associated_source_id__ = None;
7468 while let Some(k) = map_.next_key()? {
7469 match k {
7470 GeneratedField::AssociatedSourceId => {
7471 if associated_source_id__.is_some() {
7472 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
7473 }
7474 associated_source_id__ =
7475 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7476 ;
7477 }
7478 }
7479 }
7480 Ok(ListFinishMutation {
7481 associated_source_id: associated_source_id__.unwrap_or_default(),
7482 })
7483 }
7484 }
7485 deserializer.deserialize_struct("stream_plan.ListFinishMutation", FIELDS, GeneratedVisitor)
7486 }
7487}
7488impl serde::Serialize for LoadFinishMutation {
7489 #[allow(deprecated)]
7490 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7491 where
7492 S: serde::Serializer,
7493 {
7494 use serde::ser::SerializeStruct;
7495 let mut len = 0;
7496 if self.associated_source_id != 0 {
7497 len += 1;
7498 }
7499 let mut struct_ser = serializer.serialize_struct("stream_plan.LoadFinishMutation", len)?;
7500 if self.associated_source_id != 0 {
7501 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
7502 }
7503 struct_ser.end()
7504 }
7505}
7506impl<'de> serde::Deserialize<'de> for LoadFinishMutation {
7507 #[allow(deprecated)]
7508 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7509 where
7510 D: serde::Deserializer<'de>,
7511 {
7512 const FIELDS: &[&str] = &[
7513 "associated_source_id",
7514 "associatedSourceId",
7515 ];
7516
7517 #[allow(clippy::enum_variant_names)]
7518 enum GeneratedField {
7519 AssociatedSourceId,
7520 }
7521 impl<'de> serde::Deserialize<'de> for GeneratedField {
7522 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7523 where
7524 D: serde::Deserializer<'de>,
7525 {
7526 struct GeneratedVisitor;
7527
7528 impl serde::de::Visitor<'_> for GeneratedVisitor {
7529 type Value = GeneratedField;
7530
7531 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7532 write!(formatter, "expected one of: {:?}", &FIELDS)
7533 }
7534
7535 #[allow(unused_variables)]
7536 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7537 where
7538 E: serde::de::Error,
7539 {
7540 match value {
7541 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
7542 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7543 }
7544 }
7545 }
7546 deserializer.deserialize_identifier(GeneratedVisitor)
7547 }
7548 }
7549 struct GeneratedVisitor;
7550 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7551 type Value = LoadFinishMutation;
7552
7553 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7554 formatter.write_str("struct stream_plan.LoadFinishMutation")
7555 }
7556
7557 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LoadFinishMutation, V::Error>
7558 where
7559 V: serde::de::MapAccess<'de>,
7560 {
7561 let mut associated_source_id__ = None;
7562 while let Some(k) = map_.next_key()? {
7563 match k {
7564 GeneratedField::AssociatedSourceId => {
7565 if associated_source_id__.is_some() {
7566 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
7567 }
7568 associated_source_id__ =
7569 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7570 ;
7571 }
7572 }
7573 }
7574 Ok(LoadFinishMutation {
7575 associated_source_id: associated_source_id__.unwrap_or_default(),
7576 })
7577 }
7578 }
7579 deserializer.deserialize_struct("stream_plan.LoadFinishMutation", FIELDS, GeneratedVisitor)
7580 }
7581}
7582impl serde::Serialize for LocalApproxPercentileNode {
7583 #[allow(deprecated)]
7584 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7585 where
7586 S: serde::Serializer,
7587 {
7588 use serde::ser::SerializeStruct;
7589 let mut len = 0;
7590 if self.base != 0. {
7591 len += 1;
7592 }
7593 if self.percentile_index != 0 {
7594 len += 1;
7595 }
7596 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalApproxPercentileNode", len)?;
7597 if self.base != 0. {
7598 struct_ser.serialize_field("base", &self.base)?;
7599 }
7600 if self.percentile_index != 0 {
7601 struct_ser.serialize_field("percentileIndex", &self.percentile_index)?;
7602 }
7603 struct_ser.end()
7604 }
7605}
7606impl<'de> serde::Deserialize<'de> for LocalApproxPercentileNode {
7607 #[allow(deprecated)]
7608 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7609 where
7610 D: serde::Deserializer<'de>,
7611 {
7612 const FIELDS: &[&str] = &[
7613 "base",
7614 "percentile_index",
7615 "percentileIndex",
7616 ];
7617
7618 #[allow(clippy::enum_variant_names)]
7619 enum GeneratedField {
7620 Base,
7621 PercentileIndex,
7622 }
7623 impl<'de> serde::Deserialize<'de> for GeneratedField {
7624 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7625 where
7626 D: serde::Deserializer<'de>,
7627 {
7628 struct GeneratedVisitor;
7629
7630 impl serde::de::Visitor<'_> for GeneratedVisitor {
7631 type Value = GeneratedField;
7632
7633 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7634 write!(formatter, "expected one of: {:?}", &FIELDS)
7635 }
7636
7637 #[allow(unused_variables)]
7638 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7639 where
7640 E: serde::de::Error,
7641 {
7642 match value {
7643 "base" => Ok(GeneratedField::Base),
7644 "percentileIndex" | "percentile_index" => Ok(GeneratedField::PercentileIndex),
7645 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7646 }
7647 }
7648 }
7649 deserializer.deserialize_identifier(GeneratedVisitor)
7650 }
7651 }
7652 struct GeneratedVisitor;
7653 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7654 type Value = LocalApproxPercentileNode;
7655
7656 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7657 formatter.write_str("struct stream_plan.LocalApproxPercentileNode")
7658 }
7659
7660 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalApproxPercentileNode, V::Error>
7661 where
7662 V: serde::de::MapAccess<'de>,
7663 {
7664 let mut base__ = None;
7665 let mut percentile_index__ = None;
7666 while let Some(k) = map_.next_key()? {
7667 match k {
7668 GeneratedField::Base => {
7669 if base__.is_some() {
7670 return Err(serde::de::Error::duplicate_field("base"));
7671 }
7672 base__ =
7673 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7674 ;
7675 }
7676 GeneratedField::PercentileIndex => {
7677 if percentile_index__.is_some() {
7678 return Err(serde::de::Error::duplicate_field("percentileIndex"));
7679 }
7680 percentile_index__ =
7681 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7682 ;
7683 }
7684 }
7685 }
7686 Ok(LocalApproxPercentileNode {
7687 base: base__.unwrap_or_default(),
7688 percentile_index: percentile_index__.unwrap_or_default(),
7689 })
7690 }
7691 }
7692 deserializer.deserialize_struct("stream_plan.LocalApproxPercentileNode", FIELDS, GeneratedVisitor)
7693 }
7694}
7695impl serde::Serialize for LocalityProviderNode {
7696 #[allow(deprecated)]
7697 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7698 where
7699 S: serde::Serializer,
7700 {
7701 use serde::ser::SerializeStruct;
7702 let mut len = 0;
7703 if !self.locality_columns.is_empty() {
7704 len += 1;
7705 }
7706 if self.state_table.is_some() {
7707 len += 1;
7708 }
7709 if self.progress_table.is_some() {
7710 len += 1;
7711 }
7712 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalityProviderNode", len)?;
7713 if !self.locality_columns.is_empty() {
7714 struct_ser.serialize_field("localityColumns", &self.locality_columns)?;
7715 }
7716 if let Some(v) = self.state_table.as_ref() {
7717 struct_ser.serialize_field("stateTable", v)?;
7718 }
7719 if let Some(v) = self.progress_table.as_ref() {
7720 struct_ser.serialize_field("progressTable", v)?;
7721 }
7722 struct_ser.end()
7723 }
7724}
7725impl<'de> serde::Deserialize<'de> for LocalityProviderNode {
7726 #[allow(deprecated)]
7727 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7728 where
7729 D: serde::Deserializer<'de>,
7730 {
7731 const FIELDS: &[&str] = &[
7732 "locality_columns",
7733 "localityColumns",
7734 "state_table",
7735 "stateTable",
7736 "progress_table",
7737 "progressTable",
7738 ];
7739
7740 #[allow(clippy::enum_variant_names)]
7741 enum GeneratedField {
7742 LocalityColumns,
7743 StateTable,
7744 ProgressTable,
7745 }
7746 impl<'de> serde::Deserialize<'de> for GeneratedField {
7747 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7748 where
7749 D: serde::Deserializer<'de>,
7750 {
7751 struct GeneratedVisitor;
7752
7753 impl serde::de::Visitor<'_> for GeneratedVisitor {
7754 type Value = GeneratedField;
7755
7756 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7757 write!(formatter, "expected one of: {:?}", &FIELDS)
7758 }
7759
7760 #[allow(unused_variables)]
7761 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7762 where
7763 E: serde::de::Error,
7764 {
7765 match value {
7766 "localityColumns" | "locality_columns" => Ok(GeneratedField::LocalityColumns),
7767 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7768 "progressTable" | "progress_table" => Ok(GeneratedField::ProgressTable),
7769 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7770 }
7771 }
7772 }
7773 deserializer.deserialize_identifier(GeneratedVisitor)
7774 }
7775 }
7776 struct GeneratedVisitor;
7777 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7778 type Value = LocalityProviderNode;
7779
7780 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7781 formatter.write_str("struct stream_plan.LocalityProviderNode")
7782 }
7783
7784 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalityProviderNode, V::Error>
7785 where
7786 V: serde::de::MapAccess<'de>,
7787 {
7788 let mut locality_columns__ = None;
7789 let mut state_table__ = None;
7790 let mut progress_table__ = None;
7791 while let Some(k) = map_.next_key()? {
7792 match k {
7793 GeneratedField::LocalityColumns => {
7794 if locality_columns__.is_some() {
7795 return Err(serde::de::Error::duplicate_field("localityColumns"));
7796 }
7797 locality_columns__ =
7798 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7799 .into_iter().map(|x| x.0).collect())
7800 ;
7801 }
7802 GeneratedField::StateTable => {
7803 if state_table__.is_some() {
7804 return Err(serde::de::Error::duplicate_field("stateTable"));
7805 }
7806 state_table__ = map_.next_value()?;
7807 }
7808 GeneratedField::ProgressTable => {
7809 if progress_table__.is_some() {
7810 return Err(serde::de::Error::duplicate_field("progressTable"));
7811 }
7812 progress_table__ = map_.next_value()?;
7813 }
7814 }
7815 }
7816 Ok(LocalityProviderNode {
7817 locality_columns: locality_columns__.unwrap_or_default(),
7818 state_table: state_table__,
7819 progress_table: progress_table__,
7820 })
7821 }
7822 }
7823 deserializer.deserialize_struct("stream_plan.LocalityProviderNode", FIELDS, GeneratedVisitor)
7824 }
7825}
7826impl serde::Serialize for LookupNode {
7827 #[allow(deprecated)]
7828 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7829 where
7830 S: serde::Serializer,
7831 {
7832 use serde::ser::SerializeStruct;
7833 let mut len = 0;
7834 if !self.arrange_key.is_empty() {
7835 len += 1;
7836 }
7837 if !self.stream_key.is_empty() {
7838 len += 1;
7839 }
7840 if self.use_current_epoch {
7841 len += 1;
7842 }
7843 if !self.column_mapping.is_empty() {
7844 len += 1;
7845 }
7846 if self.arrangement_table_info.is_some() {
7847 len += 1;
7848 }
7849 if self.arrangement_table_id.is_some() {
7850 len += 1;
7851 }
7852 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupNode", len)?;
7853 if !self.arrange_key.is_empty() {
7854 struct_ser.serialize_field("arrangeKey", &self.arrange_key)?;
7855 }
7856 if !self.stream_key.is_empty() {
7857 struct_ser.serialize_field("streamKey", &self.stream_key)?;
7858 }
7859 if self.use_current_epoch {
7860 struct_ser.serialize_field("useCurrentEpoch", &self.use_current_epoch)?;
7861 }
7862 if !self.column_mapping.is_empty() {
7863 struct_ser.serialize_field("columnMapping", &self.column_mapping)?;
7864 }
7865 if let Some(v) = self.arrangement_table_info.as_ref() {
7866 struct_ser.serialize_field("arrangementTableInfo", v)?;
7867 }
7868 if let Some(v) = self.arrangement_table_id.as_ref() {
7869 match v {
7870 lookup_node::ArrangementTableId::TableId(v) => {
7871 struct_ser.serialize_field("tableId", v)?;
7872 }
7873 lookup_node::ArrangementTableId::IndexId(v) => {
7874 struct_ser.serialize_field("indexId", v)?;
7875 }
7876 }
7877 }
7878 struct_ser.end()
7879 }
7880}
7881impl<'de> serde::Deserialize<'de> for LookupNode {
7882 #[allow(deprecated)]
7883 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7884 where
7885 D: serde::Deserializer<'de>,
7886 {
7887 const FIELDS: &[&str] = &[
7888 "arrange_key",
7889 "arrangeKey",
7890 "stream_key",
7891 "streamKey",
7892 "use_current_epoch",
7893 "useCurrentEpoch",
7894 "column_mapping",
7895 "columnMapping",
7896 "arrangement_table_info",
7897 "arrangementTableInfo",
7898 "table_id",
7899 "tableId",
7900 "index_id",
7901 "indexId",
7902 ];
7903
7904 #[allow(clippy::enum_variant_names)]
7905 enum GeneratedField {
7906 ArrangeKey,
7907 StreamKey,
7908 UseCurrentEpoch,
7909 ColumnMapping,
7910 ArrangementTableInfo,
7911 TableId,
7912 IndexId,
7913 }
7914 impl<'de> serde::Deserialize<'de> for GeneratedField {
7915 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7916 where
7917 D: serde::Deserializer<'de>,
7918 {
7919 struct GeneratedVisitor;
7920
7921 impl serde::de::Visitor<'_> for GeneratedVisitor {
7922 type Value = GeneratedField;
7923
7924 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7925 write!(formatter, "expected one of: {:?}", &FIELDS)
7926 }
7927
7928 #[allow(unused_variables)]
7929 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7930 where
7931 E: serde::de::Error,
7932 {
7933 match value {
7934 "arrangeKey" | "arrange_key" => Ok(GeneratedField::ArrangeKey),
7935 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
7936 "useCurrentEpoch" | "use_current_epoch" => Ok(GeneratedField::UseCurrentEpoch),
7937 "columnMapping" | "column_mapping" => Ok(GeneratedField::ColumnMapping),
7938 "arrangementTableInfo" | "arrangement_table_info" => Ok(GeneratedField::ArrangementTableInfo),
7939 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7940 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
7941 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7942 }
7943 }
7944 }
7945 deserializer.deserialize_identifier(GeneratedVisitor)
7946 }
7947 }
7948 struct GeneratedVisitor;
7949 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7950 type Value = LookupNode;
7951
7952 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7953 formatter.write_str("struct stream_plan.LookupNode")
7954 }
7955
7956 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupNode, V::Error>
7957 where
7958 V: serde::de::MapAccess<'de>,
7959 {
7960 let mut arrange_key__ = None;
7961 let mut stream_key__ = None;
7962 let mut use_current_epoch__ = None;
7963 let mut column_mapping__ = None;
7964 let mut arrangement_table_info__ = None;
7965 let mut arrangement_table_id__ = None;
7966 while let Some(k) = map_.next_key()? {
7967 match k {
7968 GeneratedField::ArrangeKey => {
7969 if arrange_key__.is_some() {
7970 return Err(serde::de::Error::duplicate_field("arrangeKey"));
7971 }
7972 arrange_key__ =
7973 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7974 .into_iter().map(|x| x.0).collect())
7975 ;
7976 }
7977 GeneratedField::StreamKey => {
7978 if stream_key__.is_some() {
7979 return Err(serde::de::Error::duplicate_field("streamKey"));
7980 }
7981 stream_key__ =
7982 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7983 .into_iter().map(|x| x.0).collect())
7984 ;
7985 }
7986 GeneratedField::UseCurrentEpoch => {
7987 if use_current_epoch__.is_some() {
7988 return Err(serde::de::Error::duplicate_field("useCurrentEpoch"));
7989 }
7990 use_current_epoch__ = Some(map_.next_value()?);
7991 }
7992 GeneratedField::ColumnMapping => {
7993 if column_mapping__.is_some() {
7994 return Err(serde::de::Error::duplicate_field("columnMapping"));
7995 }
7996 column_mapping__ =
7997 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7998 .into_iter().map(|x| x.0).collect())
7999 ;
8000 }
8001 GeneratedField::ArrangementTableInfo => {
8002 if arrangement_table_info__.is_some() {
8003 return Err(serde::de::Error::duplicate_field("arrangementTableInfo"));
8004 }
8005 arrangement_table_info__ = map_.next_value()?;
8006 }
8007 GeneratedField::TableId => {
8008 if arrangement_table_id__.is_some() {
8009 return Err(serde::de::Error::duplicate_field("tableId"));
8010 }
8011 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::TableId(x.0));
8012 }
8013 GeneratedField::IndexId => {
8014 if arrangement_table_id__.is_some() {
8015 return Err(serde::de::Error::duplicate_field("indexId"));
8016 }
8017 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::IndexId(x.0));
8018 }
8019 }
8020 }
8021 Ok(LookupNode {
8022 arrange_key: arrange_key__.unwrap_or_default(),
8023 stream_key: stream_key__.unwrap_or_default(),
8024 use_current_epoch: use_current_epoch__.unwrap_or_default(),
8025 column_mapping: column_mapping__.unwrap_or_default(),
8026 arrangement_table_info: arrangement_table_info__,
8027 arrangement_table_id: arrangement_table_id__,
8028 })
8029 }
8030 }
8031 deserializer.deserialize_struct("stream_plan.LookupNode", FIELDS, GeneratedVisitor)
8032 }
8033}
8034impl serde::Serialize for LookupUnionNode {
8035 #[allow(deprecated)]
8036 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8037 where
8038 S: serde::Serializer,
8039 {
8040 use serde::ser::SerializeStruct;
8041 let mut len = 0;
8042 if !self.order.is_empty() {
8043 len += 1;
8044 }
8045 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupUnionNode", len)?;
8046 if !self.order.is_empty() {
8047 struct_ser.serialize_field("order", &self.order)?;
8048 }
8049 struct_ser.end()
8050 }
8051}
8052impl<'de> serde::Deserialize<'de> for LookupUnionNode {
8053 #[allow(deprecated)]
8054 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8055 where
8056 D: serde::Deserializer<'de>,
8057 {
8058 const FIELDS: &[&str] = &[
8059 "order",
8060 ];
8061
8062 #[allow(clippy::enum_variant_names)]
8063 enum GeneratedField {
8064 Order,
8065 }
8066 impl<'de> serde::Deserialize<'de> for GeneratedField {
8067 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8068 where
8069 D: serde::Deserializer<'de>,
8070 {
8071 struct GeneratedVisitor;
8072
8073 impl serde::de::Visitor<'_> for GeneratedVisitor {
8074 type Value = GeneratedField;
8075
8076 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8077 write!(formatter, "expected one of: {:?}", &FIELDS)
8078 }
8079
8080 #[allow(unused_variables)]
8081 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8082 where
8083 E: serde::de::Error,
8084 {
8085 match value {
8086 "order" => Ok(GeneratedField::Order),
8087 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8088 }
8089 }
8090 }
8091 deserializer.deserialize_identifier(GeneratedVisitor)
8092 }
8093 }
8094 struct GeneratedVisitor;
8095 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8096 type Value = LookupUnionNode;
8097
8098 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8099 formatter.write_str("struct stream_plan.LookupUnionNode")
8100 }
8101
8102 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupUnionNode, V::Error>
8103 where
8104 V: serde::de::MapAccess<'de>,
8105 {
8106 let mut order__ = None;
8107 while let Some(k) = map_.next_key()? {
8108 match k {
8109 GeneratedField::Order => {
8110 if order__.is_some() {
8111 return Err(serde::de::Error::duplicate_field("order"));
8112 }
8113 order__ =
8114 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8115 .into_iter().map(|x| x.0).collect())
8116 ;
8117 }
8118 }
8119 }
8120 Ok(LookupUnionNode {
8121 order: order__.unwrap_or_default(),
8122 })
8123 }
8124 }
8125 deserializer.deserialize_struct("stream_plan.LookupUnionNode", FIELDS, GeneratedVisitor)
8126 }
8127}
8128impl serde::Serialize for MaterializeNode {
8129 #[allow(deprecated)]
8130 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8131 where
8132 S: serde::Serializer,
8133 {
8134 use serde::ser::SerializeStruct;
8135 let mut len = 0;
8136 if self.table_id != 0 {
8137 len += 1;
8138 }
8139 if !self.column_orders.is_empty() {
8140 len += 1;
8141 }
8142 if self.table.is_some() {
8143 len += 1;
8144 }
8145 if self.staging_table.is_some() {
8146 len += 1;
8147 }
8148 if self.refresh_progress_table.is_some() {
8149 len += 1;
8150 }
8151 if self.cleaned_by_ttl_watermark {
8152 len += 1;
8153 }
8154 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializeNode", len)?;
8155 if self.table_id != 0 {
8156 struct_ser.serialize_field("tableId", &self.table_id)?;
8157 }
8158 if !self.column_orders.is_empty() {
8159 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
8160 }
8161 if let Some(v) = self.table.as_ref() {
8162 struct_ser.serialize_field("table", v)?;
8163 }
8164 if let Some(v) = self.staging_table.as_ref() {
8165 struct_ser.serialize_field("stagingTable", v)?;
8166 }
8167 if let Some(v) = self.refresh_progress_table.as_ref() {
8168 struct_ser.serialize_field("refreshProgressTable", v)?;
8169 }
8170 if self.cleaned_by_ttl_watermark {
8171 struct_ser.serialize_field("cleanedByTtlWatermark", &self.cleaned_by_ttl_watermark)?;
8172 }
8173 struct_ser.end()
8174 }
8175}
8176impl<'de> serde::Deserialize<'de> for MaterializeNode {
8177 #[allow(deprecated)]
8178 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8179 where
8180 D: serde::Deserializer<'de>,
8181 {
8182 const FIELDS: &[&str] = &[
8183 "table_id",
8184 "tableId",
8185 "column_orders",
8186 "columnOrders",
8187 "table",
8188 "staging_table",
8189 "stagingTable",
8190 "refresh_progress_table",
8191 "refreshProgressTable",
8192 "cleaned_by_ttl_watermark",
8193 "cleanedByTtlWatermark",
8194 ];
8195
8196 #[allow(clippy::enum_variant_names)]
8197 enum GeneratedField {
8198 TableId,
8199 ColumnOrders,
8200 Table,
8201 StagingTable,
8202 RefreshProgressTable,
8203 CleanedByTtlWatermark,
8204 }
8205 impl<'de> serde::Deserialize<'de> for GeneratedField {
8206 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8207 where
8208 D: serde::Deserializer<'de>,
8209 {
8210 struct GeneratedVisitor;
8211
8212 impl serde::de::Visitor<'_> for GeneratedVisitor {
8213 type Value = GeneratedField;
8214
8215 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8216 write!(formatter, "expected one of: {:?}", &FIELDS)
8217 }
8218
8219 #[allow(unused_variables)]
8220 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8221 where
8222 E: serde::de::Error,
8223 {
8224 match value {
8225 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8226 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
8227 "table" => Ok(GeneratedField::Table),
8228 "stagingTable" | "staging_table" => Ok(GeneratedField::StagingTable),
8229 "refreshProgressTable" | "refresh_progress_table" => Ok(GeneratedField::RefreshProgressTable),
8230 "cleanedByTtlWatermark" | "cleaned_by_ttl_watermark" => Ok(GeneratedField::CleanedByTtlWatermark),
8231 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8232 }
8233 }
8234 }
8235 deserializer.deserialize_identifier(GeneratedVisitor)
8236 }
8237 }
8238 struct GeneratedVisitor;
8239 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8240 type Value = MaterializeNode;
8241
8242 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8243 formatter.write_str("struct stream_plan.MaterializeNode")
8244 }
8245
8246 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializeNode, V::Error>
8247 where
8248 V: serde::de::MapAccess<'de>,
8249 {
8250 let mut table_id__ = None;
8251 let mut column_orders__ = None;
8252 let mut table__ = None;
8253 let mut staging_table__ = None;
8254 let mut refresh_progress_table__ = None;
8255 let mut cleaned_by_ttl_watermark__ = None;
8256 while let Some(k) = map_.next_key()? {
8257 match k {
8258 GeneratedField::TableId => {
8259 if table_id__.is_some() {
8260 return Err(serde::de::Error::duplicate_field("tableId"));
8261 }
8262 table_id__ =
8263 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8264 ;
8265 }
8266 GeneratedField::ColumnOrders => {
8267 if column_orders__.is_some() {
8268 return Err(serde::de::Error::duplicate_field("columnOrders"));
8269 }
8270 column_orders__ = Some(map_.next_value()?);
8271 }
8272 GeneratedField::Table => {
8273 if table__.is_some() {
8274 return Err(serde::de::Error::duplicate_field("table"));
8275 }
8276 table__ = map_.next_value()?;
8277 }
8278 GeneratedField::StagingTable => {
8279 if staging_table__.is_some() {
8280 return Err(serde::de::Error::duplicate_field("stagingTable"));
8281 }
8282 staging_table__ = map_.next_value()?;
8283 }
8284 GeneratedField::RefreshProgressTable => {
8285 if refresh_progress_table__.is_some() {
8286 return Err(serde::de::Error::duplicate_field("refreshProgressTable"));
8287 }
8288 refresh_progress_table__ = map_.next_value()?;
8289 }
8290 GeneratedField::CleanedByTtlWatermark => {
8291 if cleaned_by_ttl_watermark__.is_some() {
8292 return Err(serde::de::Error::duplicate_field("cleanedByTtlWatermark"));
8293 }
8294 cleaned_by_ttl_watermark__ = Some(map_.next_value()?);
8295 }
8296 }
8297 }
8298 Ok(MaterializeNode {
8299 table_id: table_id__.unwrap_or_default(),
8300 column_orders: column_orders__.unwrap_or_default(),
8301 table: table__,
8302 staging_table: staging_table__,
8303 refresh_progress_table: refresh_progress_table__,
8304 cleaned_by_ttl_watermark: cleaned_by_ttl_watermark__.unwrap_or_default(),
8305 })
8306 }
8307 }
8308 deserializer.deserialize_struct("stream_plan.MaterializeNode", FIELDS, GeneratedVisitor)
8309 }
8310}
8311impl serde::Serialize for MaterializedExprsNode {
8312 #[allow(deprecated)]
8313 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8314 where
8315 S: serde::Serializer,
8316 {
8317 use serde::ser::SerializeStruct;
8318 let mut len = 0;
8319 if !self.exprs.is_empty() {
8320 len += 1;
8321 }
8322 if self.state_table.is_some() {
8323 len += 1;
8324 }
8325 if self.state_clean_col_idx.is_some() {
8326 len += 1;
8327 }
8328 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializedExprsNode", len)?;
8329 if !self.exprs.is_empty() {
8330 struct_ser.serialize_field("exprs", &self.exprs)?;
8331 }
8332 if let Some(v) = self.state_table.as_ref() {
8333 struct_ser.serialize_field("stateTable", v)?;
8334 }
8335 if let Some(v) = self.state_clean_col_idx.as_ref() {
8336 struct_ser.serialize_field("stateCleanColIdx", v)?;
8337 }
8338 struct_ser.end()
8339 }
8340}
8341impl<'de> serde::Deserialize<'de> for MaterializedExprsNode {
8342 #[allow(deprecated)]
8343 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8344 where
8345 D: serde::Deserializer<'de>,
8346 {
8347 const FIELDS: &[&str] = &[
8348 "exprs",
8349 "state_table",
8350 "stateTable",
8351 "state_clean_col_idx",
8352 "stateCleanColIdx",
8353 ];
8354
8355 #[allow(clippy::enum_variant_names)]
8356 enum GeneratedField {
8357 Exprs,
8358 StateTable,
8359 StateCleanColIdx,
8360 }
8361 impl<'de> serde::Deserialize<'de> for GeneratedField {
8362 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8363 where
8364 D: serde::Deserializer<'de>,
8365 {
8366 struct GeneratedVisitor;
8367
8368 impl serde::de::Visitor<'_> for GeneratedVisitor {
8369 type Value = GeneratedField;
8370
8371 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8372 write!(formatter, "expected one of: {:?}", &FIELDS)
8373 }
8374
8375 #[allow(unused_variables)]
8376 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8377 where
8378 E: serde::de::Error,
8379 {
8380 match value {
8381 "exprs" => Ok(GeneratedField::Exprs),
8382 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
8383 "stateCleanColIdx" | "state_clean_col_idx" => Ok(GeneratedField::StateCleanColIdx),
8384 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8385 }
8386 }
8387 }
8388 deserializer.deserialize_identifier(GeneratedVisitor)
8389 }
8390 }
8391 struct GeneratedVisitor;
8392 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8393 type Value = MaterializedExprsNode;
8394
8395 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8396 formatter.write_str("struct stream_plan.MaterializedExprsNode")
8397 }
8398
8399 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializedExprsNode, V::Error>
8400 where
8401 V: serde::de::MapAccess<'de>,
8402 {
8403 let mut exprs__ = None;
8404 let mut state_table__ = None;
8405 let mut state_clean_col_idx__ = None;
8406 while let Some(k) = map_.next_key()? {
8407 match k {
8408 GeneratedField::Exprs => {
8409 if exprs__.is_some() {
8410 return Err(serde::de::Error::duplicate_field("exprs"));
8411 }
8412 exprs__ = Some(map_.next_value()?);
8413 }
8414 GeneratedField::StateTable => {
8415 if state_table__.is_some() {
8416 return Err(serde::de::Error::duplicate_field("stateTable"));
8417 }
8418 state_table__ = map_.next_value()?;
8419 }
8420 GeneratedField::StateCleanColIdx => {
8421 if state_clean_col_idx__.is_some() {
8422 return Err(serde::de::Error::duplicate_field("stateCleanColIdx"));
8423 }
8424 state_clean_col_idx__ =
8425 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
8426 ;
8427 }
8428 }
8429 }
8430 Ok(MaterializedExprsNode {
8431 exprs: exprs__.unwrap_or_default(),
8432 state_table: state_table__,
8433 state_clean_col_idx: state_clean_col_idx__,
8434 })
8435 }
8436 }
8437 deserializer.deserialize_struct("stream_plan.MaterializedExprsNode", FIELDS, GeneratedVisitor)
8438 }
8439}
8440impl serde::Serialize for MergeNode {
8441 #[allow(deprecated)]
8442 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8443 where
8444 S: serde::Serializer,
8445 {
8446 use serde::ser::SerializeStruct;
8447 let mut len = 0;
8448 if !self.upstream_actor_id.is_empty() {
8449 len += 1;
8450 }
8451 if self.upstream_fragment_id != 0 {
8452 len += 1;
8453 }
8454 if self.upstream_dispatcher_type != 0 {
8455 len += 1;
8456 }
8457 if !self.fields.is_empty() {
8458 len += 1;
8459 }
8460 let mut struct_ser = serializer.serialize_struct("stream_plan.MergeNode", len)?;
8461 if !self.upstream_actor_id.is_empty() {
8462 struct_ser.serialize_field("upstreamActorId", &self.upstream_actor_id)?;
8463 }
8464 if self.upstream_fragment_id != 0 {
8465 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
8466 }
8467 if self.upstream_dispatcher_type != 0 {
8468 let v = DispatcherType::try_from(self.upstream_dispatcher_type)
8469 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.upstream_dispatcher_type)))?;
8470 struct_ser.serialize_field("upstreamDispatcherType", &v)?;
8471 }
8472 if !self.fields.is_empty() {
8473 struct_ser.serialize_field("fields", &self.fields)?;
8474 }
8475 struct_ser.end()
8476 }
8477}
8478impl<'de> serde::Deserialize<'de> for MergeNode {
8479 #[allow(deprecated)]
8480 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8481 where
8482 D: serde::Deserializer<'de>,
8483 {
8484 const FIELDS: &[&str] = &[
8485 "upstream_actor_id",
8486 "upstreamActorId",
8487 "upstream_fragment_id",
8488 "upstreamFragmentId",
8489 "upstream_dispatcher_type",
8490 "upstreamDispatcherType",
8491 "fields",
8492 ];
8493
8494 #[allow(clippy::enum_variant_names)]
8495 enum GeneratedField {
8496 UpstreamActorId,
8497 UpstreamFragmentId,
8498 UpstreamDispatcherType,
8499 Fields,
8500 }
8501 impl<'de> serde::Deserialize<'de> for GeneratedField {
8502 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8503 where
8504 D: serde::Deserializer<'de>,
8505 {
8506 struct GeneratedVisitor;
8507
8508 impl serde::de::Visitor<'_> for GeneratedVisitor {
8509 type Value = GeneratedField;
8510
8511 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8512 write!(formatter, "expected one of: {:?}", &FIELDS)
8513 }
8514
8515 #[allow(unused_variables)]
8516 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8517 where
8518 E: serde::de::Error,
8519 {
8520 match value {
8521 "upstreamActorId" | "upstream_actor_id" => Ok(GeneratedField::UpstreamActorId),
8522 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
8523 "upstreamDispatcherType" | "upstream_dispatcher_type" => Ok(GeneratedField::UpstreamDispatcherType),
8524 "fields" => Ok(GeneratedField::Fields),
8525 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8526 }
8527 }
8528 }
8529 deserializer.deserialize_identifier(GeneratedVisitor)
8530 }
8531 }
8532 struct GeneratedVisitor;
8533 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8534 type Value = MergeNode;
8535
8536 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8537 formatter.write_str("struct stream_plan.MergeNode")
8538 }
8539
8540 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeNode, V::Error>
8541 where
8542 V: serde::de::MapAccess<'de>,
8543 {
8544 let mut upstream_actor_id__ = None;
8545 let mut upstream_fragment_id__ = None;
8546 let mut upstream_dispatcher_type__ = None;
8547 let mut fields__ = None;
8548 while let Some(k) = map_.next_key()? {
8549 match k {
8550 GeneratedField::UpstreamActorId => {
8551 if upstream_actor_id__.is_some() {
8552 return Err(serde::de::Error::duplicate_field("upstreamActorId"));
8553 }
8554 upstream_actor_id__ =
8555 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8556 .into_iter().map(|x| x.0).collect())
8557 ;
8558 }
8559 GeneratedField::UpstreamFragmentId => {
8560 if upstream_fragment_id__.is_some() {
8561 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
8562 }
8563 upstream_fragment_id__ =
8564 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8565 ;
8566 }
8567 GeneratedField::UpstreamDispatcherType => {
8568 if upstream_dispatcher_type__.is_some() {
8569 return Err(serde::de::Error::duplicate_field("upstreamDispatcherType"));
8570 }
8571 upstream_dispatcher_type__ = Some(map_.next_value::<DispatcherType>()? as i32);
8572 }
8573 GeneratedField::Fields => {
8574 if fields__.is_some() {
8575 return Err(serde::de::Error::duplicate_field("fields"));
8576 }
8577 fields__ = Some(map_.next_value()?);
8578 }
8579 }
8580 }
8581 Ok(MergeNode {
8582 upstream_actor_id: upstream_actor_id__.unwrap_or_default(),
8583 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
8584 upstream_dispatcher_type: upstream_dispatcher_type__.unwrap_or_default(),
8585 fields: fields__.unwrap_or_default(),
8586 })
8587 }
8588 }
8589 deserializer.deserialize_struct("stream_plan.MergeNode", FIELDS, GeneratedVisitor)
8590 }
8591}
8592impl serde::Serialize for NoOpNode {
8593 #[allow(deprecated)]
8594 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8595 where
8596 S: serde::Serializer,
8597 {
8598 use serde::ser::SerializeStruct;
8599 let len = 0;
8600 let struct_ser = serializer.serialize_struct("stream_plan.NoOpNode", len)?;
8601 struct_ser.end()
8602 }
8603}
8604impl<'de> serde::Deserialize<'de> for NoOpNode {
8605 #[allow(deprecated)]
8606 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8607 where
8608 D: serde::Deserializer<'de>,
8609 {
8610 const FIELDS: &[&str] = &[
8611 ];
8612
8613 #[allow(clippy::enum_variant_names)]
8614 enum GeneratedField {
8615 }
8616 impl<'de> serde::Deserialize<'de> for GeneratedField {
8617 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8618 where
8619 D: serde::Deserializer<'de>,
8620 {
8621 struct GeneratedVisitor;
8622
8623 impl serde::de::Visitor<'_> for GeneratedVisitor {
8624 type Value = GeneratedField;
8625
8626 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8627 write!(formatter, "expected one of: {:?}", &FIELDS)
8628 }
8629
8630 #[allow(unused_variables)]
8631 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8632 where
8633 E: serde::de::Error,
8634 {
8635 Err(serde::de::Error::unknown_field(value, FIELDS))
8636 }
8637 }
8638 deserializer.deserialize_identifier(GeneratedVisitor)
8639 }
8640 }
8641 struct GeneratedVisitor;
8642 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8643 type Value = NoOpNode;
8644
8645 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8646 formatter.write_str("struct stream_plan.NoOpNode")
8647 }
8648
8649 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NoOpNode, V::Error>
8650 where
8651 V: serde::de::MapAccess<'de>,
8652 {
8653 while map_.next_key::<GeneratedField>()?.is_some() {
8654 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8655 }
8656 Ok(NoOpNode {
8657 })
8658 }
8659 }
8660 deserializer.deserialize_struct("stream_plan.NoOpNode", FIELDS, GeneratedVisitor)
8661 }
8662}
8663impl serde::Serialize for NowModeGenerateSeries {
8664 #[allow(deprecated)]
8665 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8666 where
8667 S: serde::Serializer,
8668 {
8669 use serde::ser::SerializeStruct;
8670 let mut len = 0;
8671 if self.start_timestamp.is_some() {
8672 len += 1;
8673 }
8674 if self.interval.is_some() {
8675 len += 1;
8676 }
8677 let mut struct_ser = serializer.serialize_struct("stream_plan.NowModeGenerateSeries", len)?;
8678 if let Some(v) = self.start_timestamp.as_ref() {
8679 struct_ser.serialize_field("startTimestamp", v)?;
8680 }
8681 if let Some(v) = self.interval.as_ref() {
8682 struct_ser.serialize_field("interval", v)?;
8683 }
8684 struct_ser.end()
8685 }
8686}
8687impl<'de> serde::Deserialize<'de> for NowModeGenerateSeries {
8688 #[allow(deprecated)]
8689 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8690 where
8691 D: serde::Deserializer<'de>,
8692 {
8693 const FIELDS: &[&str] = &[
8694 "start_timestamp",
8695 "startTimestamp",
8696 "interval",
8697 ];
8698
8699 #[allow(clippy::enum_variant_names)]
8700 enum GeneratedField {
8701 StartTimestamp,
8702 Interval,
8703 }
8704 impl<'de> serde::Deserialize<'de> for GeneratedField {
8705 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8706 where
8707 D: serde::Deserializer<'de>,
8708 {
8709 struct GeneratedVisitor;
8710
8711 impl serde::de::Visitor<'_> for GeneratedVisitor {
8712 type Value = GeneratedField;
8713
8714 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8715 write!(formatter, "expected one of: {:?}", &FIELDS)
8716 }
8717
8718 #[allow(unused_variables)]
8719 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8720 where
8721 E: serde::de::Error,
8722 {
8723 match value {
8724 "startTimestamp" | "start_timestamp" => Ok(GeneratedField::StartTimestamp),
8725 "interval" => Ok(GeneratedField::Interval),
8726 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8727 }
8728 }
8729 }
8730 deserializer.deserialize_identifier(GeneratedVisitor)
8731 }
8732 }
8733 struct GeneratedVisitor;
8734 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8735 type Value = NowModeGenerateSeries;
8736
8737 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8738 formatter.write_str("struct stream_plan.NowModeGenerateSeries")
8739 }
8740
8741 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeGenerateSeries, V::Error>
8742 where
8743 V: serde::de::MapAccess<'de>,
8744 {
8745 let mut start_timestamp__ = None;
8746 let mut interval__ = None;
8747 while let Some(k) = map_.next_key()? {
8748 match k {
8749 GeneratedField::StartTimestamp => {
8750 if start_timestamp__.is_some() {
8751 return Err(serde::de::Error::duplicate_field("startTimestamp"));
8752 }
8753 start_timestamp__ = map_.next_value()?;
8754 }
8755 GeneratedField::Interval => {
8756 if interval__.is_some() {
8757 return Err(serde::de::Error::duplicate_field("interval"));
8758 }
8759 interval__ = map_.next_value()?;
8760 }
8761 }
8762 }
8763 Ok(NowModeGenerateSeries {
8764 start_timestamp: start_timestamp__,
8765 interval: interval__,
8766 })
8767 }
8768 }
8769 deserializer.deserialize_struct("stream_plan.NowModeGenerateSeries", FIELDS, GeneratedVisitor)
8770 }
8771}
8772impl serde::Serialize for NowModeUpdateCurrent {
8773 #[allow(deprecated)]
8774 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8775 where
8776 S: serde::Serializer,
8777 {
8778 use serde::ser::SerializeStruct;
8779 let len = 0;
8780 let struct_ser = serializer.serialize_struct("stream_plan.NowModeUpdateCurrent", len)?;
8781 struct_ser.end()
8782 }
8783}
8784impl<'de> serde::Deserialize<'de> for NowModeUpdateCurrent {
8785 #[allow(deprecated)]
8786 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8787 where
8788 D: serde::Deserializer<'de>,
8789 {
8790 const FIELDS: &[&str] = &[
8791 ];
8792
8793 #[allow(clippy::enum_variant_names)]
8794 enum GeneratedField {
8795 }
8796 impl<'de> serde::Deserialize<'de> for GeneratedField {
8797 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8798 where
8799 D: serde::Deserializer<'de>,
8800 {
8801 struct GeneratedVisitor;
8802
8803 impl serde::de::Visitor<'_> for GeneratedVisitor {
8804 type Value = GeneratedField;
8805
8806 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8807 write!(formatter, "expected one of: {:?}", &FIELDS)
8808 }
8809
8810 #[allow(unused_variables)]
8811 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8812 where
8813 E: serde::de::Error,
8814 {
8815 Err(serde::de::Error::unknown_field(value, FIELDS))
8816 }
8817 }
8818 deserializer.deserialize_identifier(GeneratedVisitor)
8819 }
8820 }
8821 struct GeneratedVisitor;
8822 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8823 type Value = NowModeUpdateCurrent;
8824
8825 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8826 formatter.write_str("struct stream_plan.NowModeUpdateCurrent")
8827 }
8828
8829 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeUpdateCurrent, V::Error>
8830 where
8831 V: serde::de::MapAccess<'de>,
8832 {
8833 while map_.next_key::<GeneratedField>()?.is_some() {
8834 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8835 }
8836 Ok(NowModeUpdateCurrent {
8837 })
8838 }
8839 }
8840 deserializer.deserialize_struct("stream_plan.NowModeUpdateCurrent", FIELDS, GeneratedVisitor)
8841 }
8842}
8843impl serde::Serialize for NowNode {
8844 #[allow(deprecated)]
8845 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8846 where
8847 S: serde::Serializer,
8848 {
8849 use serde::ser::SerializeStruct;
8850 let mut len = 0;
8851 if self.state_table.is_some() {
8852 len += 1;
8853 }
8854 if self.mode.is_some() {
8855 len += 1;
8856 }
8857 let mut struct_ser = serializer.serialize_struct("stream_plan.NowNode", len)?;
8858 if let Some(v) = self.state_table.as_ref() {
8859 struct_ser.serialize_field("stateTable", v)?;
8860 }
8861 if let Some(v) = self.mode.as_ref() {
8862 match v {
8863 now_node::Mode::UpdateCurrent(v) => {
8864 struct_ser.serialize_field("updateCurrent", v)?;
8865 }
8866 now_node::Mode::GenerateSeries(v) => {
8867 struct_ser.serialize_field("generateSeries", v)?;
8868 }
8869 }
8870 }
8871 struct_ser.end()
8872 }
8873}
8874impl<'de> serde::Deserialize<'de> for NowNode {
8875 #[allow(deprecated)]
8876 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8877 where
8878 D: serde::Deserializer<'de>,
8879 {
8880 const FIELDS: &[&str] = &[
8881 "state_table",
8882 "stateTable",
8883 "update_current",
8884 "updateCurrent",
8885 "generate_series",
8886 "generateSeries",
8887 ];
8888
8889 #[allow(clippy::enum_variant_names)]
8890 enum GeneratedField {
8891 StateTable,
8892 UpdateCurrent,
8893 GenerateSeries,
8894 }
8895 impl<'de> serde::Deserialize<'de> for GeneratedField {
8896 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8897 where
8898 D: serde::Deserializer<'de>,
8899 {
8900 struct GeneratedVisitor;
8901
8902 impl serde::de::Visitor<'_> for GeneratedVisitor {
8903 type Value = GeneratedField;
8904
8905 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8906 write!(formatter, "expected one of: {:?}", &FIELDS)
8907 }
8908
8909 #[allow(unused_variables)]
8910 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8911 where
8912 E: serde::de::Error,
8913 {
8914 match value {
8915 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
8916 "updateCurrent" | "update_current" => Ok(GeneratedField::UpdateCurrent),
8917 "generateSeries" | "generate_series" => Ok(GeneratedField::GenerateSeries),
8918 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8919 }
8920 }
8921 }
8922 deserializer.deserialize_identifier(GeneratedVisitor)
8923 }
8924 }
8925 struct GeneratedVisitor;
8926 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8927 type Value = NowNode;
8928
8929 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8930 formatter.write_str("struct stream_plan.NowNode")
8931 }
8932
8933 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowNode, V::Error>
8934 where
8935 V: serde::de::MapAccess<'de>,
8936 {
8937 let mut state_table__ = None;
8938 let mut mode__ = None;
8939 while let Some(k) = map_.next_key()? {
8940 match k {
8941 GeneratedField::StateTable => {
8942 if state_table__.is_some() {
8943 return Err(serde::de::Error::duplicate_field("stateTable"));
8944 }
8945 state_table__ = map_.next_value()?;
8946 }
8947 GeneratedField::UpdateCurrent => {
8948 if mode__.is_some() {
8949 return Err(serde::de::Error::duplicate_field("updateCurrent"));
8950 }
8951 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::UpdateCurrent)
8952;
8953 }
8954 GeneratedField::GenerateSeries => {
8955 if mode__.is_some() {
8956 return Err(serde::de::Error::duplicate_field("generateSeries"));
8957 }
8958 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::GenerateSeries)
8959;
8960 }
8961 }
8962 }
8963 Ok(NowNode {
8964 state_table: state_table__,
8965 mode: mode__,
8966 })
8967 }
8968 }
8969 deserializer.deserialize_struct("stream_plan.NowNode", FIELDS, GeneratedVisitor)
8970 }
8971}
8972impl serde::Serialize for OverWindowCachePolicy {
8973 #[allow(deprecated)]
8974 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8975 where
8976 S: serde::Serializer,
8977 {
8978 let variant = match self {
8979 Self::Unspecified => "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
8980 Self::Full => "OVER_WINDOW_CACHE_POLICY_FULL",
8981 Self::Recent => "OVER_WINDOW_CACHE_POLICY_RECENT",
8982 Self::RecentFirstN => "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
8983 Self::RecentLastN => "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
8984 };
8985 serializer.serialize_str(variant)
8986 }
8987}
8988impl<'de> serde::Deserialize<'de> for OverWindowCachePolicy {
8989 #[allow(deprecated)]
8990 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8991 where
8992 D: serde::Deserializer<'de>,
8993 {
8994 const FIELDS: &[&str] = &[
8995 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
8996 "OVER_WINDOW_CACHE_POLICY_FULL",
8997 "OVER_WINDOW_CACHE_POLICY_RECENT",
8998 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
8999 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
9000 ];
9001
9002 struct GeneratedVisitor;
9003
9004 impl serde::de::Visitor<'_> for GeneratedVisitor {
9005 type Value = OverWindowCachePolicy;
9006
9007 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9008 write!(formatter, "expected one of: {:?}", &FIELDS)
9009 }
9010
9011 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9012 where
9013 E: serde::de::Error,
9014 {
9015 i32::try_from(v)
9016 .ok()
9017 .and_then(|x| x.try_into().ok())
9018 .ok_or_else(|| {
9019 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9020 })
9021 }
9022
9023 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9024 where
9025 E: serde::de::Error,
9026 {
9027 i32::try_from(v)
9028 .ok()
9029 .and_then(|x| x.try_into().ok())
9030 .ok_or_else(|| {
9031 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9032 })
9033 }
9034
9035 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9036 where
9037 E: serde::de::Error,
9038 {
9039 match value {
9040 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED" => Ok(OverWindowCachePolicy::Unspecified),
9041 "OVER_WINDOW_CACHE_POLICY_FULL" => Ok(OverWindowCachePolicy::Full),
9042 "OVER_WINDOW_CACHE_POLICY_RECENT" => Ok(OverWindowCachePolicy::Recent),
9043 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N" => Ok(OverWindowCachePolicy::RecentFirstN),
9044 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N" => Ok(OverWindowCachePolicy::RecentLastN),
9045 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9046 }
9047 }
9048 }
9049 deserializer.deserialize_any(GeneratedVisitor)
9050 }
9051}
9052impl serde::Serialize for OverWindowNode {
9053 #[allow(deprecated)]
9054 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9055 where
9056 S: serde::Serializer,
9057 {
9058 use serde::ser::SerializeStruct;
9059 let mut len = 0;
9060 if !self.calls.is_empty() {
9061 len += 1;
9062 }
9063 if !self.partition_by.is_empty() {
9064 len += 1;
9065 }
9066 if !self.order_by.is_empty() {
9067 len += 1;
9068 }
9069 if self.state_table.is_some() {
9070 len += 1;
9071 }
9072 if self.cache_policy != 0 {
9073 len += 1;
9074 }
9075 let mut struct_ser = serializer.serialize_struct("stream_plan.OverWindowNode", len)?;
9076 if !self.calls.is_empty() {
9077 struct_ser.serialize_field("calls", &self.calls)?;
9078 }
9079 if !self.partition_by.is_empty() {
9080 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
9081 }
9082 if !self.order_by.is_empty() {
9083 struct_ser.serialize_field("orderBy", &self.order_by)?;
9084 }
9085 if let Some(v) = self.state_table.as_ref() {
9086 struct_ser.serialize_field("stateTable", v)?;
9087 }
9088 if self.cache_policy != 0 {
9089 let v = OverWindowCachePolicy::try_from(self.cache_policy)
9090 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cache_policy)))?;
9091 struct_ser.serialize_field("cachePolicy", &v)?;
9092 }
9093 struct_ser.end()
9094 }
9095}
9096impl<'de> serde::Deserialize<'de> for OverWindowNode {
9097 #[allow(deprecated)]
9098 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9099 where
9100 D: serde::Deserializer<'de>,
9101 {
9102 const FIELDS: &[&str] = &[
9103 "calls",
9104 "partition_by",
9105 "partitionBy",
9106 "order_by",
9107 "orderBy",
9108 "state_table",
9109 "stateTable",
9110 "cache_policy",
9111 "cachePolicy",
9112 ];
9113
9114 #[allow(clippy::enum_variant_names)]
9115 enum GeneratedField {
9116 Calls,
9117 PartitionBy,
9118 OrderBy,
9119 StateTable,
9120 CachePolicy,
9121 }
9122 impl<'de> serde::Deserialize<'de> for GeneratedField {
9123 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9124 where
9125 D: serde::Deserializer<'de>,
9126 {
9127 struct GeneratedVisitor;
9128
9129 impl serde::de::Visitor<'_> for GeneratedVisitor {
9130 type Value = GeneratedField;
9131
9132 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9133 write!(formatter, "expected one of: {:?}", &FIELDS)
9134 }
9135
9136 #[allow(unused_variables)]
9137 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9138 where
9139 E: serde::de::Error,
9140 {
9141 match value {
9142 "calls" => Ok(GeneratedField::Calls),
9143 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
9144 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
9145 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9146 "cachePolicy" | "cache_policy" => Ok(GeneratedField::CachePolicy),
9147 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9148 }
9149 }
9150 }
9151 deserializer.deserialize_identifier(GeneratedVisitor)
9152 }
9153 }
9154 struct GeneratedVisitor;
9155 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9156 type Value = OverWindowNode;
9157
9158 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9159 formatter.write_str("struct stream_plan.OverWindowNode")
9160 }
9161
9162 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverWindowNode, V::Error>
9163 where
9164 V: serde::de::MapAccess<'de>,
9165 {
9166 let mut calls__ = None;
9167 let mut partition_by__ = None;
9168 let mut order_by__ = None;
9169 let mut state_table__ = None;
9170 let mut cache_policy__ = None;
9171 while let Some(k) = map_.next_key()? {
9172 match k {
9173 GeneratedField::Calls => {
9174 if calls__.is_some() {
9175 return Err(serde::de::Error::duplicate_field("calls"));
9176 }
9177 calls__ = Some(map_.next_value()?);
9178 }
9179 GeneratedField::PartitionBy => {
9180 if partition_by__.is_some() {
9181 return Err(serde::de::Error::duplicate_field("partitionBy"));
9182 }
9183 partition_by__ =
9184 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9185 .into_iter().map(|x| x.0).collect())
9186 ;
9187 }
9188 GeneratedField::OrderBy => {
9189 if order_by__.is_some() {
9190 return Err(serde::de::Error::duplicate_field("orderBy"));
9191 }
9192 order_by__ = Some(map_.next_value()?);
9193 }
9194 GeneratedField::StateTable => {
9195 if state_table__.is_some() {
9196 return Err(serde::de::Error::duplicate_field("stateTable"));
9197 }
9198 state_table__ = map_.next_value()?;
9199 }
9200 GeneratedField::CachePolicy => {
9201 if cache_policy__.is_some() {
9202 return Err(serde::de::Error::duplicate_field("cachePolicy"));
9203 }
9204 cache_policy__ = Some(map_.next_value::<OverWindowCachePolicy>()? as i32);
9205 }
9206 }
9207 }
9208 Ok(OverWindowNode {
9209 calls: calls__.unwrap_or_default(),
9210 partition_by: partition_by__.unwrap_or_default(),
9211 order_by: order_by__.unwrap_or_default(),
9212 state_table: state_table__,
9213 cache_policy: cache_policy__.unwrap_or_default(),
9214 })
9215 }
9216 }
9217 deserializer.deserialize_struct("stream_plan.OverWindowNode", FIELDS, GeneratedVisitor)
9218 }
9219}
9220impl serde::Serialize for PauseMutation {
9221 #[allow(deprecated)]
9222 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9223 where
9224 S: serde::Serializer,
9225 {
9226 use serde::ser::SerializeStruct;
9227 let len = 0;
9228 let struct_ser = serializer.serialize_struct("stream_plan.PauseMutation", len)?;
9229 struct_ser.end()
9230 }
9231}
9232impl<'de> serde::Deserialize<'de> for PauseMutation {
9233 #[allow(deprecated)]
9234 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9235 where
9236 D: serde::Deserializer<'de>,
9237 {
9238 const FIELDS: &[&str] = &[
9239 ];
9240
9241 #[allow(clippy::enum_variant_names)]
9242 enum GeneratedField {
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 serde::de::Visitor<'_> 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 Err(serde::de::Error::unknown_field(value, FIELDS))
9264 }
9265 }
9266 deserializer.deserialize_identifier(GeneratedVisitor)
9267 }
9268 }
9269 struct GeneratedVisitor;
9270 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9271 type Value = PauseMutation;
9272
9273 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9274 formatter.write_str("struct stream_plan.PauseMutation")
9275 }
9276
9277 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseMutation, V::Error>
9278 where
9279 V: serde::de::MapAccess<'de>,
9280 {
9281 while map_.next_key::<GeneratedField>()?.is_some() {
9282 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9283 }
9284 Ok(PauseMutation {
9285 })
9286 }
9287 }
9288 deserializer.deserialize_struct("stream_plan.PauseMutation", FIELDS, GeneratedVisitor)
9289 }
9290}
9291impl serde::Serialize for ProjectNode {
9292 #[allow(deprecated)]
9293 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9294 where
9295 S: serde::Serializer,
9296 {
9297 use serde::ser::SerializeStruct;
9298 let mut len = 0;
9299 if !self.select_list.is_empty() {
9300 len += 1;
9301 }
9302 if !self.watermark_input_cols.is_empty() {
9303 len += 1;
9304 }
9305 if !self.watermark_output_cols.is_empty() {
9306 len += 1;
9307 }
9308 if !self.nondecreasing_exprs.is_empty() {
9309 len += 1;
9310 }
9311 if self.noop_update_hint {
9312 len += 1;
9313 }
9314 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectNode", len)?;
9315 if !self.select_list.is_empty() {
9316 struct_ser.serialize_field("selectList", &self.select_list)?;
9317 }
9318 if !self.watermark_input_cols.is_empty() {
9319 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
9320 }
9321 if !self.watermark_output_cols.is_empty() {
9322 struct_ser.serialize_field("watermarkOutputCols", &self.watermark_output_cols)?;
9323 }
9324 if !self.nondecreasing_exprs.is_empty() {
9325 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
9326 }
9327 if self.noop_update_hint {
9328 struct_ser.serialize_field("noopUpdateHint", &self.noop_update_hint)?;
9329 }
9330 struct_ser.end()
9331 }
9332}
9333impl<'de> serde::Deserialize<'de> for ProjectNode {
9334 #[allow(deprecated)]
9335 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9336 where
9337 D: serde::Deserializer<'de>,
9338 {
9339 const FIELDS: &[&str] = &[
9340 "select_list",
9341 "selectList",
9342 "watermark_input_cols",
9343 "watermarkInputCols",
9344 "watermark_output_cols",
9345 "watermarkOutputCols",
9346 "nondecreasing_exprs",
9347 "nondecreasingExprs",
9348 "noop_update_hint",
9349 "noopUpdateHint",
9350 ];
9351
9352 #[allow(clippy::enum_variant_names)]
9353 enum GeneratedField {
9354 SelectList,
9355 WatermarkInputCols,
9356 WatermarkOutputCols,
9357 NondecreasingExprs,
9358 NoopUpdateHint,
9359 }
9360 impl<'de> serde::Deserialize<'de> for GeneratedField {
9361 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9362 where
9363 D: serde::Deserializer<'de>,
9364 {
9365 struct GeneratedVisitor;
9366
9367 impl serde::de::Visitor<'_> for GeneratedVisitor {
9368 type Value = GeneratedField;
9369
9370 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9371 write!(formatter, "expected one of: {:?}", &FIELDS)
9372 }
9373
9374 #[allow(unused_variables)]
9375 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9376 where
9377 E: serde::de::Error,
9378 {
9379 match value {
9380 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
9381 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
9382 "watermarkOutputCols" | "watermark_output_cols" => Ok(GeneratedField::WatermarkOutputCols),
9383 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
9384 "noopUpdateHint" | "noop_update_hint" => Ok(GeneratedField::NoopUpdateHint),
9385 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9386 }
9387 }
9388 }
9389 deserializer.deserialize_identifier(GeneratedVisitor)
9390 }
9391 }
9392 struct GeneratedVisitor;
9393 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9394 type Value = ProjectNode;
9395
9396 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9397 formatter.write_str("struct stream_plan.ProjectNode")
9398 }
9399
9400 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
9401 where
9402 V: serde::de::MapAccess<'de>,
9403 {
9404 let mut select_list__ = None;
9405 let mut watermark_input_cols__ = None;
9406 let mut watermark_output_cols__ = None;
9407 let mut nondecreasing_exprs__ = None;
9408 let mut noop_update_hint__ = None;
9409 while let Some(k) = map_.next_key()? {
9410 match k {
9411 GeneratedField::SelectList => {
9412 if select_list__.is_some() {
9413 return Err(serde::de::Error::duplicate_field("selectList"));
9414 }
9415 select_list__ = Some(map_.next_value()?);
9416 }
9417 GeneratedField::WatermarkInputCols => {
9418 if watermark_input_cols__.is_some() {
9419 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
9420 }
9421 watermark_input_cols__ =
9422 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9423 .into_iter().map(|x| x.0).collect())
9424 ;
9425 }
9426 GeneratedField::WatermarkOutputCols => {
9427 if watermark_output_cols__.is_some() {
9428 return Err(serde::de::Error::duplicate_field("watermarkOutputCols"));
9429 }
9430 watermark_output_cols__ =
9431 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9432 .into_iter().map(|x| x.0).collect())
9433 ;
9434 }
9435 GeneratedField::NondecreasingExprs => {
9436 if nondecreasing_exprs__.is_some() {
9437 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
9438 }
9439 nondecreasing_exprs__ =
9440 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9441 .into_iter().map(|x| x.0).collect())
9442 ;
9443 }
9444 GeneratedField::NoopUpdateHint => {
9445 if noop_update_hint__.is_some() {
9446 return Err(serde::de::Error::duplicate_field("noopUpdateHint"));
9447 }
9448 noop_update_hint__ = Some(map_.next_value()?);
9449 }
9450 }
9451 }
9452 Ok(ProjectNode {
9453 select_list: select_list__.unwrap_or_default(),
9454 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
9455 watermark_output_cols: watermark_output_cols__.unwrap_or_default(),
9456 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
9457 noop_update_hint: noop_update_hint__.unwrap_or_default(),
9458 })
9459 }
9460 }
9461 deserializer.deserialize_struct("stream_plan.ProjectNode", FIELDS, GeneratedVisitor)
9462 }
9463}
9464impl serde::Serialize for ProjectSetNode {
9465 #[allow(deprecated)]
9466 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9467 where
9468 S: serde::Serializer,
9469 {
9470 use serde::ser::SerializeStruct;
9471 let mut len = 0;
9472 if !self.select_list.is_empty() {
9473 len += 1;
9474 }
9475 if !self.watermark_input_cols.is_empty() {
9476 len += 1;
9477 }
9478 if !self.watermark_expr_indices.is_empty() {
9479 len += 1;
9480 }
9481 if !self.nondecreasing_exprs.is_empty() {
9482 len += 1;
9483 }
9484 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectSetNode", len)?;
9485 if !self.select_list.is_empty() {
9486 struct_ser.serialize_field("selectList", &self.select_list)?;
9487 }
9488 if !self.watermark_input_cols.is_empty() {
9489 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
9490 }
9491 if !self.watermark_expr_indices.is_empty() {
9492 struct_ser.serialize_field("watermarkExprIndices", &self.watermark_expr_indices)?;
9493 }
9494 if !self.nondecreasing_exprs.is_empty() {
9495 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
9496 }
9497 struct_ser.end()
9498 }
9499}
9500impl<'de> serde::Deserialize<'de> for ProjectSetNode {
9501 #[allow(deprecated)]
9502 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9503 where
9504 D: serde::Deserializer<'de>,
9505 {
9506 const FIELDS: &[&str] = &[
9507 "select_list",
9508 "selectList",
9509 "watermark_input_cols",
9510 "watermarkInputCols",
9511 "watermark_expr_indices",
9512 "watermarkExprIndices",
9513 "nondecreasing_exprs",
9514 "nondecreasingExprs",
9515 ];
9516
9517 #[allow(clippy::enum_variant_names)]
9518 enum GeneratedField {
9519 SelectList,
9520 WatermarkInputCols,
9521 WatermarkExprIndices,
9522 NondecreasingExprs,
9523 }
9524 impl<'de> serde::Deserialize<'de> for GeneratedField {
9525 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9526 where
9527 D: serde::Deserializer<'de>,
9528 {
9529 struct GeneratedVisitor;
9530
9531 impl serde::de::Visitor<'_> for GeneratedVisitor {
9532 type Value = GeneratedField;
9533
9534 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9535 write!(formatter, "expected one of: {:?}", &FIELDS)
9536 }
9537
9538 #[allow(unused_variables)]
9539 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9540 where
9541 E: serde::de::Error,
9542 {
9543 match value {
9544 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
9545 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
9546 "watermarkExprIndices" | "watermark_expr_indices" => Ok(GeneratedField::WatermarkExprIndices),
9547 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
9548 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9549 }
9550 }
9551 }
9552 deserializer.deserialize_identifier(GeneratedVisitor)
9553 }
9554 }
9555 struct GeneratedVisitor;
9556 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9557 type Value = ProjectSetNode;
9558
9559 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9560 formatter.write_str("struct stream_plan.ProjectSetNode")
9561 }
9562
9563 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
9564 where
9565 V: serde::de::MapAccess<'de>,
9566 {
9567 let mut select_list__ = None;
9568 let mut watermark_input_cols__ = None;
9569 let mut watermark_expr_indices__ = None;
9570 let mut nondecreasing_exprs__ = None;
9571 while let Some(k) = map_.next_key()? {
9572 match k {
9573 GeneratedField::SelectList => {
9574 if select_list__.is_some() {
9575 return Err(serde::de::Error::duplicate_field("selectList"));
9576 }
9577 select_list__ = Some(map_.next_value()?);
9578 }
9579 GeneratedField::WatermarkInputCols => {
9580 if watermark_input_cols__.is_some() {
9581 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
9582 }
9583 watermark_input_cols__ =
9584 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9585 .into_iter().map(|x| x.0).collect())
9586 ;
9587 }
9588 GeneratedField::WatermarkExprIndices => {
9589 if watermark_expr_indices__.is_some() {
9590 return Err(serde::de::Error::duplicate_field("watermarkExprIndices"));
9591 }
9592 watermark_expr_indices__ =
9593 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9594 .into_iter().map(|x| x.0).collect())
9595 ;
9596 }
9597 GeneratedField::NondecreasingExprs => {
9598 if nondecreasing_exprs__.is_some() {
9599 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
9600 }
9601 nondecreasing_exprs__ =
9602 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9603 .into_iter().map(|x| x.0).collect())
9604 ;
9605 }
9606 }
9607 }
9608 Ok(ProjectSetNode {
9609 select_list: select_list__.unwrap_or_default(),
9610 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
9611 watermark_expr_indices: watermark_expr_indices__.unwrap_or_default(),
9612 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
9613 })
9614 }
9615 }
9616 deserializer.deserialize_struct("stream_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
9617 }
9618}
9619impl serde::Serialize for RefreshStartMutation {
9620 #[allow(deprecated)]
9621 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9622 where
9623 S: serde::Serializer,
9624 {
9625 use serde::ser::SerializeStruct;
9626 let mut len = 0;
9627 if self.table_id != 0 {
9628 len += 1;
9629 }
9630 if self.associated_source_id != 0 {
9631 len += 1;
9632 }
9633 let mut struct_ser = serializer.serialize_struct("stream_plan.RefreshStartMutation", len)?;
9634 if self.table_id != 0 {
9635 struct_ser.serialize_field("tableId", &self.table_id)?;
9636 }
9637 if self.associated_source_id != 0 {
9638 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
9639 }
9640 struct_ser.end()
9641 }
9642}
9643impl<'de> serde::Deserialize<'de> for RefreshStartMutation {
9644 #[allow(deprecated)]
9645 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9646 where
9647 D: serde::Deserializer<'de>,
9648 {
9649 const FIELDS: &[&str] = &[
9650 "table_id",
9651 "tableId",
9652 "associated_source_id",
9653 "associatedSourceId",
9654 ];
9655
9656 #[allow(clippy::enum_variant_names)]
9657 enum GeneratedField {
9658 TableId,
9659 AssociatedSourceId,
9660 }
9661 impl<'de> serde::Deserialize<'de> for GeneratedField {
9662 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9663 where
9664 D: serde::Deserializer<'de>,
9665 {
9666 struct GeneratedVisitor;
9667
9668 impl serde::de::Visitor<'_> for GeneratedVisitor {
9669 type Value = GeneratedField;
9670
9671 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9672 write!(formatter, "expected one of: {:?}", &FIELDS)
9673 }
9674
9675 #[allow(unused_variables)]
9676 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9677 where
9678 E: serde::de::Error,
9679 {
9680 match value {
9681 "tableId" | "table_id" => Ok(GeneratedField::TableId),
9682 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
9683 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9684 }
9685 }
9686 }
9687 deserializer.deserialize_identifier(GeneratedVisitor)
9688 }
9689 }
9690 struct GeneratedVisitor;
9691 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9692 type Value = RefreshStartMutation;
9693
9694 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9695 formatter.write_str("struct stream_plan.RefreshStartMutation")
9696 }
9697
9698 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshStartMutation, V::Error>
9699 where
9700 V: serde::de::MapAccess<'de>,
9701 {
9702 let mut table_id__ = None;
9703 let mut associated_source_id__ = None;
9704 while let Some(k) = map_.next_key()? {
9705 match k {
9706 GeneratedField::TableId => {
9707 if table_id__.is_some() {
9708 return Err(serde::de::Error::duplicate_field("tableId"));
9709 }
9710 table_id__ =
9711 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9712 ;
9713 }
9714 GeneratedField::AssociatedSourceId => {
9715 if associated_source_id__.is_some() {
9716 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
9717 }
9718 associated_source_id__ =
9719 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9720 ;
9721 }
9722 }
9723 }
9724 Ok(RefreshStartMutation {
9725 table_id: table_id__.unwrap_or_default(),
9726 associated_source_id: associated_source_id__.unwrap_or_default(),
9727 })
9728 }
9729 }
9730 deserializer.deserialize_struct("stream_plan.RefreshStartMutation", FIELDS, GeneratedVisitor)
9731 }
9732}
9733impl serde::Serialize for ResetSourceMutation {
9734 #[allow(deprecated)]
9735 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9736 where
9737 S: serde::Serializer,
9738 {
9739 use serde::ser::SerializeStruct;
9740 let mut len = 0;
9741 if self.source_id != 0 {
9742 len += 1;
9743 }
9744 let mut struct_ser = serializer.serialize_struct("stream_plan.ResetSourceMutation", len)?;
9745 if self.source_id != 0 {
9746 struct_ser.serialize_field("sourceId", &self.source_id)?;
9747 }
9748 struct_ser.end()
9749 }
9750}
9751impl<'de> serde::Deserialize<'de> for ResetSourceMutation {
9752 #[allow(deprecated)]
9753 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9754 where
9755 D: serde::Deserializer<'de>,
9756 {
9757 const FIELDS: &[&str] = &[
9758 "source_id",
9759 "sourceId",
9760 ];
9761
9762 #[allow(clippy::enum_variant_names)]
9763 enum GeneratedField {
9764 SourceId,
9765 }
9766 impl<'de> serde::Deserialize<'de> for GeneratedField {
9767 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9768 where
9769 D: serde::Deserializer<'de>,
9770 {
9771 struct GeneratedVisitor;
9772
9773 impl serde::de::Visitor<'_> for GeneratedVisitor {
9774 type Value = GeneratedField;
9775
9776 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9777 write!(formatter, "expected one of: {:?}", &FIELDS)
9778 }
9779
9780 #[allow(unused_variables)]
9781 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9782 where
9783 E: serde::de::Error,
9784 {
9785 match value {
9786 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
9787 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9788 }
9789 }
9790 }
9791 deserializer.deserialize_identifier(GeneratedVisitor)
9792 }
9793 }
9794 struct GeneratedVisitor;
9795 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9796 type Value = ResetSourceMutation;
9797
9798 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9799 formatter.write_str("struct stream_plan.ResetSourceMutation")
9800 }
9801
9802 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceMutation, V::Error>
9803 where
9804 V: serde::de::MapAccess<'de>,
9805 {
9806 let mut source_id__ = None;
9807 while let Some(k) = map_.next_key()? {
9808 match k {
9809 GeneratedField::SourceId => {
9810 if source_id__.is_some() {
9811 return Err(serde::de::Error::duplicate_field("sourceId"));
9812 }
9813 source_id__ =
9814 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9815 ;
9816 }
9817 }
9818 }
9819 Ok(ResetSourceMutation {
9820 source_id: source_id__.unwrap_or_default(),
9821 })
9822 }
9823 }
9824 deserializer.deserialize_struct("stream_plan.ResetSourceMutation", FIELDS, GeneratedVisitor)
9825 }
9826}
9827impl serde::Serialize for ResumeMutation {
9828 #[allow(deprecated)]
9829 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9830 where
9831 S: serde::Serializer,
9832 {
9833 use serde::ser::SerializeStruct;
9834 let len = 0;
9835 let struct_ser = serializer.serialize_struct("stream_plan.ResumeMutation", len)?;
9836 struct_ser.end()
9837 }
9838}
9839impl<'de> serde::Deserialize<'de> for ResumeMutation {
9840 #[allow(deprecated)]
9841 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9842 where
9843 D: serde::Deserializer<'de>,
9844 {
9845 const FIELDS: &[&str] = &[
9846 ];
9847
9848 #[allow(clippy::enum_variant_names)]
9849 enum GeneratedField {
9850 }
9851 impl<'de> serde::Deserialize<'de> for GeneratedField {
9852 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9853 where
9854 D: serde::Deserializer<'de>,
9855 {
9856 struct GeneratedVisitor;
9857
9858 impl serde::de::Visitor<'_> for GeneratedVisitor {
9859 type Value = GeneratedField;
9860
9861 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9862 write!(formatter, "expected one of: {:?}", &FIELDS)
9863 }
9864
9865 #[allow(unused_variables)]
9866 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9867 where
9868 E: serde::de::Error,
9869 {
9870 Err(serde::de::Error::unknown_field(value, FIELDS))
9871 }
9872 }
9873 deserializer.deserialize_identifier(GeneratedVisitor)
9874 }
9875 }
9876 struct GeneratedVisitor;
9877 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9878 type Value = ResumeMutation;
9879
9880 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9881 formatter.write_str("struct stream_plan.ResumeMutation")
9882 }
9883
9884 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeMutation, V::Error>
9885 where
9886 V: serde::de::MapAccess<'de>,
9887 {
9888 while map_.next_key::<GeneratedField>()?.is_some() {
9889 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9890 }
9891 Ok(ResumeMutation {
9892 })
9893 }
9894 }
9895 deserializer.deserialize_struct("stream_plan.ResumeMutation", FIELDS, GeneratedVisitor)
9896 }
9897}
9898impl serde::Serialize for RowIdGenNode {
9899 #[allow(deprecated)]
9900 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9901 where
9902 S: serde::Serializer,
9903 {
9904 use serde::ser::SerializeStruct;
9905 let mut len = 0;
9906 if self.row_id_index != 0 {
9907 len += 1;
9908 }
9909 let mut struct_ser = serializer.serialize_struct("stream_plan.RowIdGenNode", len)?;
9910 if self.row_id_index != 0 {
9911 #[allow(clippy::needless_borrow)]
9912 #[allow(clippy::needless_borrows_for_generic_args)]
9913 struct_ser.serialize_field("rowIdIndex", ToString::to_string(&self.row_id_index).as_str())?;
9914 }
9915 struct_ser.end()
9916 }
9917}
9918impl<'de> serde::Deserialize<'de> for RowIdGenNode {
9919 #[allow(deprecated)]
9920 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9921 where
9922 D: serde::Deserializer<'de>,
9923 {
9924 const FIELDS: &[&str] = &[
9925 "row_id_index",
9926 "rowIdIndex",
9927 ];
9928
9929 #[allow(clippy::enum_variant_names)]
9930 enum GeneratedField {
9931 RowIdIndex,
9932 }
9933 impl<'de> serde::Deserialize<'de> for GeneratedField {
9934 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9935 where
9936 D: serde::Deserializer<'de>,
9937 {
9938 struct GeneratedVisitor;
9939
9940 impl serde::de::Visitor<'_> for GeneratedVisitor {
9941 type Value = GeneratedField;
9942
9943 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9944 write!(formatter, "expected one of: {:?}", &FIELDS)
9945 }
9946
9947 #[allow(unused_variables)]
9948 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9949 where
9950 E: serde::de::Error,
9951 {
9952 match value {
9953 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
9954 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9955 }
9956 }
9957 }
9958 deserializer.deserialize_identifier(GeneratedVisitor)
9959 }
9960 }
9961 struct GeneratedVisitor;
9962 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9963 type Value = RowIdGenNode;
9964
9965 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9966 formatter.write_str("struct stream_plan.RowIdGenNode")
9967 }
9968
9969 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowIdGenNode, V::Error>
9970 where
9971 V: serde::de::MapAccess<'de>,
9972 {
9973 let mut row_id_index__ = None;
9974 while let Some(k) = map_.next_key()? {
9975 match k {
9976 GeneratedField::RowIdIndex => {
9977 if row_id_index__.is_some() {
9978 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
9979 }
9980 row_id_index__ =
9981 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9982 ;
9983 }
9984 }
9985 }
9986 Ok(RowIdGenNode {
9987 row_id_index: row_id_index__.unwrap_or_default(),
9988 })
9989 }
9990 }
9991 deserializer.deserialize_struct("stream_plan.RowIdGenNode", FIELDS, GeneratedVisitor)
9992 }
9993}
9994impl serde::Serialize for RowMergeNode {
9995 #[allow(deprecated)]
9996 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9997 where
9998 S: serde::Serializer,
9999 {
10000 use serde::ser::SerializeStruct;
10001 let mut len = 0;
10002 if self.lhs_mapping.is_some() {
10003 len += 1;
10004 }
10005 if self.rhs_mapping.is_some() {
10006 len += 1;
10007 }
10008 let mut struct_ser = serializer.serialize_struct("stream_plan.RowMergeNode", len)?;
10009 if let Some(v) = self.lhs_mapping.as_ref() {
10010 struct_ser.serialize_field("lhsMapping", v)?;
10011 }
10012 if let Some(v) = self.rhs_mapping.as_ref() {
10013 struct_ser.serialize_field("rhsMapping", v)?;
10014 }
10015 struct_ser.end()
10016 }
10017}
10018impl<'de> serde::Deserialize<'de> for RowMergeNode {
10019 #[allow(deprecated)]
10020 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10021 where
10022 D: serde::Deserializer<'de>,
10023 {
10024 const FIELDS: &[&str] = &[
10025 "lhs_mapping",
10026 "lhsMapping",
10027 "rhs_mapping",
10028 "rhsMapping",
10029 ];
10030
10031 #[allow(clippy::enum_variant_names)]
10032 enum GeneratedField {
10033 LhsMapping,
10034 RhsMapping,
10035 }
10036 impl<'de> serde::Deserialize<'de> for GeneratedField {
10037 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10038 where
10039 D: serde::Deserializer<'de>,
10040 {
10041 struct GeneratedVisitor;
10042
10043 impl serde::de::Visitor<'_> for GeneratedVisitor {
10044 type Value = GeneratedField;
10045
10046 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10047 write!(formatter, "expected one of: {:?}", &FIELDS)
10048 }
10049
10050 #[allow(unused_variables)]
10051 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10052 where
10053 E: serde::de::Error,
10054 {
10055 match value {
10056 "lhsMapping" | "lhs_mapping" => Ok(GeneratedField::LhsMapping),
10057 "rhsMapping" | "rhs_mapping" => Ok(GeneratedField::RhsMapping),
10058 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10059 }
10060 }
10061 }
10062 deserializer.deserialize_identifier(GeneratedVisitor)
10063 }
10064 }
10065 struct GeneratedVisitor;
10066 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10067 type Value = RowMergeNode;
10068
10069 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10070 formatter.write_str("struct stream_plan.RowMergeNode")
10071 }
10072
10073 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowMergeNode, V::Error>
10074 where
10075 V: serde::de::MapAccess<'de>,
10076 {
10077 let mut lhs_mapping__ = None;
10078 let mut rhs_mapping__ = None;
10079 while let Some(k) = map_.next_key()? {
10080 match k {
10081 GeneratedField::LhsMapping => {
10082 if lhs_mapping__.is_some() {
10083 return Err(serde::de::Error::duplicate_field("lhsMapping"));
10084 }
10085 lhs_mapping__ = map_.next_value()?;
10086 }
10087 GeneratedField::RhsMapping => {
10088 if rhs_mapping__.is_some() {
10089 return Err(serde::de::Error::duplicate_field("rhsMapping"));
10090 }
10091 rhs_mapping__ = map_.next_value()?;
10092 }
10093 }
10094 }
10095 Ok(RowMergeNode {
10096 lhs_mapping: lhs_mapping__,
10097 rhs_mapping: rhs_mapping__,
10098 })
10099 }
10100 }
10101 deserializer.deserialize_struct("stream_plan.RowMergeNode", FIELDS, GeneratedVisitor)
10102 }
10103}
10104impl serde::Serialize for SimpleAggNode {
10105 #[allow(deprecated)]
10106 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10107 where
10108 S: serde::Serializer,
10109 {
10110 use serde::ser::SerializeStruct;
10111 let mut len = 0;
10112 if !self.agg_calls.is_empty() {
10113 len += 1;
10114 }
10115 if !self.agg_call_states.is_empty() {
10116 len += 1;
10117 }
10118 if self.intermediate_state_table.is_some() {
10119 len += 1;
10120 }
10121 if self.is_append_only {
10122 len += 1;
10123 }
10124 if !self.distinct_dedup_tables.is_empty() {
10125 len += 1;
10126 }
10127 if self.row_count_index != 0 {
10128 len += 1;
10129 }
10130 if self.version != 0 {
10131 len += 1;
10132 }
10133 if self.must_output_per_barrier {
10134 len += 1;
10135 }
10136 let mut struct_ser = serializer.serialize_struct("stream_plan.SimpleAggNode", len)?;
10137 if !self.agg_calls.is_empty() {
10138 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
10139 }
10140 if !self.agg_call_states.is_empty() {
10141 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
10142 }
10143 if let Some(v) = self.intermediate_state_table.as_ref() {
10144 struct_ser.serialize_field("intermediateStateTable", v)?;
10145 }
10146 if self.is_append_only {
10147 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
10148 }
10149 if !self.distinct_dedup_tables.is_empty() {
10150 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
10151 }
10152 if self.row_count_index != 0 {
10153 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
10154 }
10155 if self.version != 0 {
10156 let v = AggNodeVersion::try_from(self.version)
10157 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
10158 struct_ser.serialize_field("version", &v)?;
10159 }
10160 if self.must_output_per_barrier {
10161 struct_ser.serialize_field("mustOutputPerBarrier", &self.must_output_per_barrier)?;
10162 }
10163 struct_ser.end()
10164 }
10165}
10166impl<'de> serde::Deserialize<'de> for SimpleAggNode {
10167 #[allow(deprecated)]
10168 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10169 where
10170 D: serde::Deserializer<'de>,
10171 {
10172 const FIELDS: &[&str] = &[
10173 "agg_calls",
10174 "aggCalls",
10175 "agg_call_states",
10176 "aggCallStates",
10177 "intermediate_state_table",
10178 "intermediateStateTable",
10179 "is_append_only",
10180 "isAppendOnly",
10181 "distinct_dedup_tables",
10182 "distinctDedupTables",
10183 "row_count_index",
10184 "rowCountIndex",
10185 "version",
10186 "must_output_per_barrier",
10187 "mustOutputPerBarrier",
10188 ];
10189
10190 #[allow(clippy::enum_variant_names)]
10191 enum GeneratedField {
10192 AggCalls,
10193 AggCallStates,
10194 IntermediateStateTable,
10195 IsAppendOnly,
10196 DistinctDedupTables,
10197 RowCountIndex,
10198 Version,
10199 MustOutputPerBarrier,
10200 }
10201 impl<'de> serde::Deserialize<'de> for GeneratedField {
10202 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10203 where
10204 D: serde::Deserializer<'de>,
10205 {
10206 struct GeneratedVisitor;
10207
10208 impl serde::de::Visitor<'_> for GeneratedVisitor {
10209 type Value = GeneratedField;
10210
10211 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10212 write!(formatter, "expected one of: {:?}", &FIELDS)
10213 }
10214
10215 #[allow(unused_variables)]
10216 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10217 where
10218 E: serde::de::Error,
10219 {
10220 match value {
10221 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
10222 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
10223 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
10224 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
10225 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
10226 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
10227 "version" => Ok(GeneratedField::Version),
10228 "mustOutputPerBarrier" | "must_output_per_barrier" => Ok(GeneratedField::MustOutputPerBarrier),
10229 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10230 }
10231 }
10232 }
10233 deserializer.deserialize_identifier(GeneratedVisitor)
10234 }
10235 }
10236 struct GeneratedVisitor;
10237 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10238 type Value = SimpleAggNode;
10239
10240 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10241 formatter.write_str("struct stream_plan.SimpleAggNode")
10242 }
10243
10244 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SimpleAggNode, V::Error>
10245 where
10246 V: serde::de::MapAccess<'de>,
10247 {
10248 let mut agg_calls__ = None;
10249 let mut agg_call_states__ = None;
10250 let mut intermediate_state_table__ = None;
10251 let mut is_append_only__ = None;
10252 let mut distinct_dedup_tables__ = None;
10253 let mut row_count_index__ = None;
10254 let mut version__ = None;
10255 let mut must_output_per_barrier__ = None;
10256 while let Some(k) = map_.next_key()? {
10257 match k {
10258 GeneratedField::AggCalls => {
10259 if agg_calls__.is_some() {
10260 return Err(serde::de::Error::duplicate_field("aggCalls"));
10261 }
10262 agg_calls__ = Some(map_.next_value()?);
10263 }
10264 GeneratedField::AggCallStates => {
10265 if agg_call_states__.is_some() {
10266 return Err(serde::de::Error::duplicate_field("aggCallStates"));
10267 }
10268 agg_call_states__ = Some(map_.next_value()?);
10269 }
10270 GeneratedField::IntermediateStateTable => {
10271 if intermediate_state_table__.is_some() {
10272 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
10273 }
10274 intermediate_state_table__ = map_.next_value()?;
10275 }
10276 GeneratedField::IsAppendOnly => {
10277 if is_append_only__.is_some() {
10278 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
10279 }
10280 is_append_only__ = Some(map_.next_value()?);
10281 }
10282 GeneratedField::DistinctDedupTables => {
10283 if distinct_dedup_tables__.is_some() {
10284 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
10285 }
10286 distinct_dedup_tables__ = Some(
10287 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10288 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
10289 );
10290 }
10291 GeneratedField::RowCountIndex => {
10292 if row_count_index__.is_some() {
10293 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
10294 }
10295 row_count_index__ =
10296 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10297 ;
10298 }
10299 GeneratedField::Version => {
10300 if version__.is_some() {
10301 return Err(serde::de::Error::duplicate_field("version"));
10302 }
10303 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
10304 }
10305 GeneratedField::MustOutputPerBarrier => {
10306 if must_output_per_barrier__.is_some() {
10307 return Err(serde::de::Error::duplicate_field("mustOutputPerBarrier"));
10308 }
10309 must_output_per_barrier__ = Some(map_.next_value()?);
10310 }
10311 }
10312 }
10313 Ok(SimpleAggNode {
10314 agg_calls: agg_calls__.unwrap_or_default(),
10315 agg_call_states: agg_call_states__.unwrap_or_default(),
10316 intermediate_state_table: intermediate_state_table__,
10317 is_append_only: is_append_only__.unwrap_or_default(),
10318 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
10319 row_count_index: row_count_index__.unwrap_or_default(),
10320 version: version__.unwrap_or_default(),
10321 must_output_per_barrier: must_output_per_barrier__.unwrap_or_default(),
10322 })
10323 }
10324 }
10325 deserializer.deserialize_struct("stream_plan.SimpleAggNode", FIELDS, GeneratedVisitor)
10326 }
10327}
10328impl serde::Serialize for SinkAddColumnsOp {
10329 #[allow(deprecated)]
10330 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10331 where
10332 S: serde::Serializer,
10333 {
10334 use serde::ser::SerializeStruct;
10335 let mut len = 0;
10336 if !self.fields.is_empty() {
10337 len += 1;
10338 }
10339 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkAddColumnsOp", len)?;
10340 if !self.fields.is_empty() {
10341 struct_ser.serialize_field("fields", &self.fields)?;
10342 }
10343 struct_ser.end()
10344 }
10345}
10346impl<'de> serde::Deserialize<'de> for SinkAddColumnsOp {
10347 #[allow(deprecated)]
10348 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10349 where
10350 D: serde::Deserializer<'de>,
10351 {
10352 const FIELDS: &[&str] = &[
10353 "fields",
10354 ];
10355
10356 #[allow(clippy::enum_variant_names)]
10357 enum GeneratedField {
10358 Fields,
10359 }
10360 impl<'de> serde::Deserialize<'de> for GeneratedField {
10361 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10362 where
10363 D: serde::Deserializer<'de>,
10364 {
10365 struct GeneratedVisitor;
10366
10367 impl serde::de::Visitor<'_> for GeneratedVisitor {
10368 type Value = GeneratedField;
10369
10370 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10371 write!(formatter, "expected one of: {:?}", &FIELDS)
10372 }
10373
10374 #[allow(unused_variables)]
10375 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10376 where
10377 E: serde::de::Error,
10378 {
10379 match value {
10380 "fields" => Ok(GeneratedField::Fields),
10381 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10382 }
10383 }
10384 }
10385 deserializer.deserialize_identifier(GeneratedVisitor)
10386 }
10387 }
10388 struct GeneratedVisitor;
10389 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10390 type Value = SinkAddColumnsOp;
10391
10392 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10393 formatter.write_str("struct stream_plan.SinkAddColumnsOp")
10394 }
10395
10396 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkAddColumnsOp, V::Error>
10397 where
10398 V: serde::de::MapAccess<'de>,
10399 {
10400 let mut fields__ = None;
10401 while let Some(k) = map_.next_key()? {
10402 match k {
10403 GeneratedField::Fields => {
10404 if fields__.is_some() {
10405 return Err(serde::de::Error::duplicate_field("fields"));
10406 }
10407 fields__ = Some(map_.next_value()?);
10408 }
10409 }
10410 }
10411 Ok(SinkAddColumnsOp {
10412 fields: fields__.unwrap_or_default(),
10413 })
10414 }
10415 }
10416 deserializer.deserialize_struct("stream_plan.SinkAddColumnsOp", FIELDS, GeneratedVisitor)
10417 }
10418}
10419impl serde::Serialize for SinkDesc {
10420 #[allow(deprecated)]
10421 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10422 where
10423 S: serde::Serializer,
10424 {
10425 use serde::ser::SerializeStruct;
10426 let mut len = 0;
10427 if self.id != 0 {
10428 len += 1;
10429 }
10430 if !self.name.is_empty() {
10431 len += 1;
10432 }
10433 if !self.definition.is_empty() {
10434 len += 1;
10435 }
10436 if !self.plan_pk.is_empty() {
10437 len += 1;
10438 }
10439 if !self.downstream_pk.is_empty() {
10440 len += 1;
10441 }
10442 if !self.distribution_key.is_empty() {
10443 len += 1;
10444 }
10445 if !self.properties.is_empty() {
10446 len += 1;
10447 }
10448 if self.sink_type != 0 {
10449 len += 1;
10450 }
10451 if !self.column_catalogs.is_empty() {
10452 len += 1;
10453 }
10454 if !self.db_name.is_empty() {
10455 len += 1;
10456 }
10457 if !self.sink_from_name.is_empty() {
10458 len += 1;
10459 }
10460 if self.format_desc.is_some() {
10461 len += 1;
10462 }
10463 if self.target_table.is_some() {
10464 len += 1;
10465 }
10466 if self.extra_partition_col_idx.is_some() {
10467 len += 1;
10468 }
10469 if !self.secret_refs.is_empty() {
10470 len += 1;
10471 }
10472 if self.raw_ignore_delete {
10473 len += 1;
10474 }
10475 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDesc", len)?;
10476 if self.id != 0 {
10477 struct_ser.serialize_field("id", &self.id)?;
10478 }
10479 if !self.name.is_empty() {
10480 struct_ser.serialize_field("name", &self.name)?;
10481 }
10482 if !self.definition.is_empty() {
10483 struct_ser.serialize_field("definition", &self.definition)?;
10484 }
10485 if !self.plan_pk.is_empty() {
10486 struct_ser.serialize_field("planPk", &self.plan_pk)?;
10487 }
10488 if !self.downstream_pk.is_empty() {
10489 struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
10490 }
10491 if !self.distribution_key.is_empty() {
10492 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
10493 }
10494 if !self.properties.is_empty() {
10495 struct_ser.serialize_field("properties", &self.properties)?;
10496 }
10497 if self.sink_type != 0 {
10498 let v = super::catalog::SinkType::try_from(self.sink_type)
10499 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
10500 struct_ser.serialize_field("sinkType", &v)?;
10501 }
10502 if !self.column_catalogs.is_empty() {
10503 struct_ser.serialize_field("columnCatalogs", &self.column_catalogs)?;
10504 }
10505 if !self.db_name.is_empty() {
10506 struct_ser.serialize_field("dbName", &self.db_name)?;
10507 }
10508 if !self.sink_from_name.is_empty() {
10509 struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
10510 }
10511 if let Some(v) = self.format_desc.as_ref() {
10512 struct_ser.serialize_field("formatDesc", v)?;
10513 }
10514 if let Some(v) = self.target_table.as_ref() {
10515 struct_ser.serialize_field("targetTable", v)?;
10516 }
10517 if let Some(v) = self.extra_partition_col_idx.as_ref() {
10518 #[allow(clippy::needless_borrow)]
10519 #[allow(clippy::needless_borrows_for_generic_args)]
10520 struct_ser.serialize_field("extraPartitionColIdx", ToString::to_string(&v).as_str())?;
10521 }
10522 if !self.secret_refs.is_empty() {
10523 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
10524 }
10525 if self.raw_ignore_delete {
10526 struct_ser.serialize_field("rawIgnoreDelete", &self.raw_ignore_delete)?;
10527 }
10528 struct_ser.end()
10529 }
10530}
10531impl<'de> serde::Deserialize<'de> for SinkDesc {
10532 #[allow(deprecated)]
10533 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10534 where
10535 D: serde::Deserializer<'de>,
10536 {
10537 const FIELDS: &[&str] = &[
10538 "id",
10539 "name",
10540 "definition",
10541 "plan_pk",
10542 "planPk",
10543 "downstream_pk",
10544 "downstreamPk",
10545 "distribution_key",
10546 "distributionKey",
10547 "properties",
10548 "sink_type",
10549 "sinkType",
10550 "column_catalogs",
10551 "columnCatalogs",
10552 "db_name",
10553 "dbName",
10554 "sink_from_name",
10555 "sinkFromName",
10556 "format_desc",
10557 "formatDesc",
10558 "target_table",
10559 "targetTable",
10560 "extra_partition_col_idx",
10561 "extraPartitionColIdx",
10562 "secret_refs",
10563 "secretRefs",
10564 "raw_ignore_delete",
10565 "rawIgnoreDelete",
10566 ];
10567
10568 #[allow(clippy::enum_variant_names)]
10569 enum GeneratedField {
10570 Id,
10571 Name,
10572 Definition,
10573 PlanPk,
10574 DownstreamPk,
10575 DistributionKey,
10576 Properties,
10577 SinkType,
10578 ColumnCatalogs,
10579 DbName,
10580 SinkFromName,
10581 FormatDesc,
10582 TargetTable,
10583 ExtraPartitionColIdx,
10584 SecretRefs,
10585 RawIgnoreDelete,
10586 }
10587 impl<'de> serde::Deserialize<'de> for GeneratedField {
10588 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10589 where
10590 D: serde::Deserializer<'de>,
10591 {
10592 struct GeneratedVisitor;
10593
10594 impl serde::de::Visitor<'_> for GeneratedVisitor {
10595 type Value = GeneratedField;
10596
10597 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10598 write!(formatter, "expected one of: {:?}", &FIELDS)
10599 }
10600
10601 #[allow(unused_variables)]
10602 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10603 where
10604 E: serde::de::Error,
10605 {
10606 match value {
10607 "id" => Ok(GeneratedField::Id),
10608 "name" => Ok(GeneratedField::Name),
10609 "definition" => Ok(GeneratedField::Definition),
10610 "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
10611 "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
10612 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
10613 "properties" => Ok(GeneratedField::Properties),
10614 "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
10615 "columnCatalogs" | "column_catalogs" => Ok(GeneratedField::ColumnCatalogs),
10616 "dbName" | "db_name" => Ok(GeneratedField::DbName),
10617 "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
10618 "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
10619 "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
10620 "extraPartitionColIdx" | "extra_partition_col_idx" => Ok(GeneratedField::ExtraPartitionColIdx),
10621 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
10622 "rawIgnoreDelete" | "raw_ignore_delete" => Ok(GeneratedField::RawIgnoreDelete),
10623 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10624 }
10625 }
10626 }
10627 deserializer.deserialize_identifier(GeneratedVisitor)
10628 }
10629 }
10630 struct GeneratedVisitor;
10631 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10632 type Value = SinkDesc;
10633
10634 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10635 formatter.write_str("struct stream_plan.SinkDesc")
10636 }
10637
10638 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDesc, V::Error>
10639 where
10640 V: serde::de::MapAccess<'de>,
10641 {
10642 let mut id__ = None;
10643 let mut name__ = None;
10644 let mut definition__ = None;
10645 let mut plan_pk__ = None;
10646 let mut downstream_pk__ = None;
10647 let mut distribution_key__ = None;
10648 let mut properties__ = None;
10649 let mut sink_type__ = None;
10650 let mut column_catalogs__ = None;
10651 let mut db_name__ = None;
10652 let mut sink_from_name__ = None;
10653 let mut format_desc__ = None;
10654 let mut target_table__ = None;
10655 let mut extra_partition_col_idx__ = None;
10656 let mut secret_refs__ = None;
10657 let mut raw_ignore_delete__ = None;
10658 while let Some(k) = map_.next_key()? {
10659 match k {
10660 GeneratedField::Id => {
10661 if id__.is_some() {
10662 return Err(serde::de::Error::duplicate_field("id"));
10663 }
10664 id__ =
10665 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10666 ;
10667 }
10668 GeneratedField::Name => {
10669 if name__.is_some() {
10670 return Err(serde::de::Error::duplicate_field("name"));
10671 }
10672 name__ = Some(map_.next_value()?);
10673 }
10674 GeneratedField::Definition => {
10675 if definition__.is_some() {
10676 return Err(serde::de::Error::duplicate_field("definition"));
10677 }
10678 definition__ = Some(map_.next_value()?);
10679 }
10680 GeneratedField::PlanPk => {
10681 if plan_pk__.is_some() {
10682 return Err(serde::de::Error::duplicate_field("planPk"));
10683 }
10684 plan_pk__ = Some(map_.next_value()?);
10685 }
10686 GeneratedField::DownstreamPk => {
10687 if downstream_pk__.is_some() {
10688 return Err(serde::de::Error::duplicate_field("downstreamPk"));
10689 }
10690 downstream_pk__ =
10691 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10692 .into_iter().map(|x| x.0).collect())
10693 ;
10694 }
10695 GeneratedField::DistributionKey => {
10696 if distribution_key__.is_some() {
10697 return Err(serde::de::Error::duplicate_field("distributionKey"));
10698 }
10699 distribution_key__ =
10700 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10701 .into_iter().map(|x| x.0).collect())
10702 ;
10703 }
10704 GeneratedField::Properties => {
10705 if properties__.is_some() {
10706 return Err(serde::de::Error::duplicate_field("properties"));
10707 }
10708 properties__ = Some(
10709 map_.next_value::<std::collections::BTreeMap<_, _>>()?
10710 );
10711 }
10712 GeneratedField::SinkType => {
10713 if sink_type__.is_some() {
10714 return Err(serde::de::Error::duplicate_field("sinkType"));
10715 }
10716 sink_type__ = Some(map_.next_value::<super::catalog::SinkType>()? as i32);
10717 }
10718 GeneratedField::ColumnCatalogs => {
10719 if column_catalogs__.is_some() {
10720 return Err(serde::de::Error::duplicate_field("columnCatalogs"));
10721 }
10722 column_catalogs__ = Some(map_.next_value()?);
10723 }
10724 GeneratedField::DbName => {
10725 if db_name__.is_some() {
10726 return Err(serde::de::Error::duplicate_field("dbName"));
10727 }
10728 db_name__ = Some(map_.next_value()?);
10729 }
10730 GeneratedField::SinkFromName => {
10731 if sink_from_name__.is_some() {
10732 return Err(serde::de::Error::duplicate_field("sinkFromName"));
10733 }
10734 sink_from_name__ = Some(map_.next_value()?);
10735 }
10736 GeneratedField::FormatDesc => {
10737 if format_desc__.is_some() {
10738 return Err(serde::de::Error::duplicate_field("formatDesc"));
10739 }
10740 format_desc__ = map_.next_value()?;
10741 }
10742 GeneratedField::TargetTable => {
10743 if target_table__.is_some() {
10744 return Err(serde::de::Error::duplicate_field("targetTable"));
10745 }
10746 target_table__ =
10747 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10748 ;
10749 }
10750 GeneratedField::ExtraPartitionColIdx => {
10751 if extra_partition_col_idx__.is_some() {
10752 return Err(serde::de::Error::duplicate_field("extraPartitionColIdx"));
10753 }
10754 extra_partition_col_idx__ =
10755 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10756 ;
10757 }
10758 GeneratedField::SecretRefs => {
10759 if secret_refs__.is_some() {
10760 return Err(serde::de::Error::duplicate_field("secretRefs"));
10761 }
10762 secret_refs__ = Some(
10763 map_.next_value::<std::collections::BTreeMap<_, _>>()?
10764 );
10765 }
10766 GeneratedField::RawIgnoreDelete => {
10767 if raw_ignore_delete__.is_some() {
10768 return Err(serde::de::Error::duplicate_field("rawIgnoreDelete"));
10769 }
10770 raw_ignore_delete__ = Some(map_.next_value()?);
10771 }
10772 }
10773 }
10774 Ok(SinkDesc {
10775 id: id__.unwrap_or_default(),
10776 name: name__.unwrap_or_default(),
10777 definition: definition__.unwrap_or_default(),
10778 plan_pk: plan_pk__.unwrap_or_default(),
10779 downstream_pk: downstream_pk__.unwrap_or_default(),
10780 distribution_key: distribution_key__.unwrap_or_default(),
10781 properties: properties__.unwrap_or_default(),
10782 sink_type: sink_type__.unwrap_or_default(),
10783 column_catalogs: column_catalogs__.unwrap_or_default(),
10784 db_name: db_name__.unwrap_or_default(),
10785 sink_from_name: sink_from_name__.unwrap_or_default(),
10786 format_desc: format_desc__,
10787 target_table: target_table__,
10788 extra_partition_col_idx: extra_partition_col_idx__,
10789 secret_refs: secret_refs__.unwrap_or_default(),
10790 raw_ignore_delete: raw_ignore_delete__.unwrap_or_default(),
10791 })
10792 }
10793 }
10794 deserializer.deserialize_struct("stream_plan.SinkDesc", FIELDS, GeneratedVisitor)
10795 }
10796}
10797impl serde::Serialize for SinkDropColumnsOp {
10798 #[allow(deprecated)]
10799 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10800 where
10801 S: serde::Serializer,
10802 {
10803 use serde::ser::SerializeStruct;
10804 let mut len = 0;
10805 if !self.column_names.is_empty() {
10806 len += 1;
10807 }
10808 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDropColumnsOp", len)?;
10809 if !self.column_names.is_empty() {
10810 struct_ser.serialize_field("columnNames", &self.column_names)?;
10811 }
10812 struct_ser.end()
10813 }
10814}
10815impl<'de> serde::Deserialize<'de> for SinkDropColumnsOp {
10816 #[allow(deprecated)]
10817 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10818 where
10819 D: serde::Deserializer<'de>,
10820 {
10821 const FIELDS: &[&str] = &[
10822 "column_names",
10823 "columnNames",
10824 ];
10825
10826 #[allow(clippy::enum_variant_names)]
10827 enum GeneratedField {
10828 ColumnNames,
10829 }
10830 impl<'de> serde::Deserialize<'de> for GeneratedField {
10831 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10832 where
10833 D: serde::Deserializer<'de>,
10834 {
10835 struct GeneratedVisitor;
10836
10837 impl serde::de::Visitor<'_> for GeneratedVisitor {
10838 type Value = GeneratedField;
10839
10840 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10841 write!(formatter, "expected one of: {:?}", &FIELDS)
10842 }
10843
10844 #[allow(unused_variables)]
10845 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10846 where
10847 E: serde::de::Error,
10848 {
10849 match value {
10850 "columnNames" | "column_names" => Ok(GeneratedField::ColumnNames),
10851 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10852 }
10853 }
10854 }
10855 deserializer.deserialize_identifier(GeneratedVisitor)
10856 }
10857 }
10858 struct GeneratedVisitor;
10859 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10860 type Value = SinkDropColumnsOp;
10861
10862 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10863 formatter.write_str("struct stream_plan.SinkDropColumnsOp")
10864 }
10865
10866 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDropColumnsOp, V::Error>
10867 where
10868 V: serde::de::MapAccess<'de>,
10869 {
10870 let mut column_names__ = None;
10871 while let Some(k) = map_.next_key()? {
10872 match k {
10873 GeneratedField::ColumnNames => {
10874 if column_names__.is_some() {
10875 return Err(serde::de::Error::duplicate_field("columnNames"));
10876 }
10877 column_names__ = Some(map_.next_value()?);
10878 }
10879 }
10880 }
10881 Ok(SinkDropColumnsOp {
10882 column_names: column_names__.unwrap_or_default(),
10883 })
10884 }
10885 }
10886 deserializer.deserialize_struct("stream_plan.SinkDropColumnsOp", FIELDS, GeneratedVisitor)
10887 }
10888}
10889impl serde::Serialize for SinkLogStoreType {
10890 #[allow(deprecated)]
10891 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10892 where
10893 S: serde::Serializer,
10894 {
10895 let variant = match self {
10896 Self::Unspecified => "SINK_LOG_STORE_TYPE_UNSPECIFIED",
10897 Self::KvLogStore => "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
10898 Self::InMemoryLogStore => "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
10899 };
10900 serializer.serialize_str(variant)
10901 }
10902}
10903impl<'de> serde::Deserialize<'de> for SinkLogStoreType {
10904 #[allow(deprecated)]
10905 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10906 where
10907 D: serde::Deserializer<'de>,
10908 {
10909 const FIELDS: &[&str] = &[
10910 "SINK_LOG_STORE_TYPE_UNSPECIFIED",
10911 "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
10912 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
10913 ];
10914
10915 struct GeneratedVisitor;
10916
10917 impl serde::de::Visitor<'_> for GeneratedVisitor {
10918 type Value = SinkLogStoreType;
10919
10920 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10921 write!(formatter, "expected one of: {:?}", &FIELDS)
10922 }
10923
10924 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
10925 where
10926 E: serde::de::Error,
10927 {
10928 i32::try_from(v)
10929 .ok()
10930 .and_then(|x| x.try_into().ok())
10931 .ok_or_else(|| {
10932 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
10933 })
10934 }
10935
10936 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
10937 where
10938 E: serde::de::Error,
10939 {
10940 i32::try_from(v)
10941 .ok()
10942 .and_then(|x| x.try_into().ok())
10943 .ok_or_else(|| {
10944 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
10945 })
10946 }
10947
10948 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
10949 where
10950 E: serde::de::Error,
10951 {
10952 match value {
10953 "SINK_LOG_STORE_TYPE_UNSPECIFIED" => Ok(SinkLogStoreType::Unspecified),
10954 "SINK_LOG_STORE_TYPE_KV_LOG_STORE" => Ok(SinkLogStoreType::KvLogStore),
10955 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE" => Ok(SinkLogStoreType::InMemoryLogStore),
10956 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
10957 }
10958 }
10959 }
10960 deserializer.deserialize_any(GeneratedVisitor)
10961 }
10962}
10963impl serde::Serialize for SinkNode {
10964 #[allow(deprecated)]
10965 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10966 where
10967 S: serde::Serializer,
10968 {
10969 use serde::ser::SerializeStruct;
10970 let mut len = 0;
10971 if self.sink_desc.is_some() {
10972 len += 1;
10973 }
10974 if self.table.is_some() {
10975 len += 1;
10976 }
10977 if self.log_store_type != 0 {
10978 len += 1;
10979 }
10980 if self.rate_limit.is_some() {
10981 len += 1;
10982 }
10983 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkNode", len)?;
10984 if let Some(v) = self.sink_desc.as_ref() {
10985 struct_ser.serialize_field("sinkDesc", v)?;
10986 }
10987 if let Some(v) = self.table.as_ref() {
10988 struct_ser.serialize_field("table", v)?;
10989 }
10990 if self.log_store_type != 0 {
10991 let v = SinkLogStoreType::try_from(self.log_store_type)
10992 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.log_store_type)))?;
10993 struct_ser.serialize_field("logStoreType", &v)?;
10994 }
10995 if let Some(v) = self.rate_limit.as_ref() {
10996 struct_ser.serialize_field("rateLimit", v)?;
10997 }
10998 struct_ser.end()
10999 }
11000}
11001impl<'de> serde::Deserialize<'de> for SinkNode {
11002 #[allow(deprecated)]
11003 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11004 where
11005 D: serde::Deserializer<'de>,
11006 {
11007 const FIELDS: &[&str] = &[
11008 "sink_desc",
11009 "sinkDesc",
11010 "table",
11011 "log_store_type",
11012 "logStoreType",
11013 "rate_limit",
11014 "rateLimit",
11015 ];
11016
11017 #[allow(clippy::enum_variant_names)]
11018 enum GeneratedField {
11019 SinkDesc,
11020 Table,
11021 LogStoreType,
11022 RateLimit,
11023 }
11024 impl<'de> serde::Deserialize<'de> for GeneratedField {
11025 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11026 where
11027 D: serde::Deserializer<'de>,
11028 {
11029 struct GeneratedVisitor;
11030
11031 impl serde::de::Visitor<'_> for GeneratedVisitor {
11032 type Value = GeneratedField;
11033
11034 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11035 write!(formatter, "expected one of: {:?}", &FIELDS)
11036 }
11037
11038 #[allow(unused_variables)]
11039 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11040 where
11041 E: serde::de::Error,
11042 {
11043 match value {
11044 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
11045 "table" => Ok(GeneratedField::Table),
11046 "logStoreType" | "log_store_type" => Ok(GeneratedField::LogStoreType),
11047 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11048 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11049 }
11050 }
11051 }
11052 deserializer.deserialize_identifier(GeneratedVisitor)
11053 }
11054 }
11055 struct GeneratedVisitor;
11056 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11057 type Value = SinkNode;
11058
11059 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11060 formatter.write_str("struct stream_plan.SinkNode")
11061 }
11062
11063 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkNode, V::Error>
11064 where
11065 V: serde::de::MapAccess<'de>,
11066 {
11067 let mut sink_desc__ = None;
11068 let mut table__ = None;
11069 let mut log_store_type__ = None;
11070 let mut rate_limit__ = None;
11071 while let Some(k) = map_.next_key()? {
11072 match k {
11073 GeneratedField::SinkDesc => {
11074 if sink_desc__.is_some() {
11075 return Err(serde::de::Error::duplicate_field("sinkDesc"));
11076 }
11077 sink_desc__ = map_.next_value()?;
11078 }
11079 GeneratedField::Table => {
11080 if table__.is_some() {
11081 return Err(serde::de::Error::duplicate_field("table"));
11082 }
11083 table__ = map_.next_value()?;
11084 }
11085 GeneratedField::LogStoreType => {
11086 if log_store_type__.is_some() {
11087 return Err(serde::de::Error::duplicate_field("logStoreType"));
11088 }
11089 log_store_type__ = Some(map_.next_value::<SinkLogStoreType>()? as i32);
11090 }
11091 GeneratedField::RateLimit => {
11092 if rate_limit__.is_some() {
11093 return Err(serde::de::Error::duplicate_field("rateLimit"));
11094 }
11095 rate_limit__ =
11096 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11097 ;
11098 }
11099 }
11100 }
11101 Ok(SinkNode {
11102 sink_desc: sink_desc__,
11103 table: table__,
11104 log_store_type: log_store_type__.unwrap_or_default(),
11105 rate_limit: rate_limit__,
11106 })
11107 }
11108 }
11109 deserializer.deserialize_struct("stream_plan.SinkNode", FIELDS, GeneratedVisitor)
11110 }
11111}
11112impl serde::Serialize for SinkSchemaChange {
11113 #[allow(deprecated)]
11114 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11115 where
11116 S: serde::Serializer,
11117 {
11118 use serde::ser::SerializeStruct;
11119 let mut len = 0;
11120 if !self.original_schema.is_empty() {
11121 len += 1;
11122 }
11123 if self.op.is_some() {
11124 len += 1;
11125 }
11126 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkSchemaChange", len)?;
11127 if !self.original_schema.is_empty() {
11128 struct_ser.serialize_field("originalSchema", &self.original_schema)?;
11129 }
11130 if let Some(v) = self.op.as_ref() {
11131 match v {
11132 sink_schema_change::Op::AddColumns(v) => {
11133 struct_ser.serialize_field("addColumns", v)?;
11134 }
11135 sink_schema_change::Op::DropColumns(v) => {
11136 struct_ser.serialize_field("dropColumns", v)?;
11137 }
11138 }
11139 }
11140 struct_ser.end()
11141 }
11142}
11143impl<'de> serde::Deserialize<'de> for SinkSchemaChange {
11144 #[allow(deprecated)]
11145 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11146 where
11147 D: serde::Deserializer<'de>,
11148 {
11149 const FIELDS: &[&str] = &[
11150 "original_schema",
11151 "originalSchema",
11152 "add_columns",
11153 "addColumns",
11154 "drop_columns",
11155 "dropColumns",
11156 ];
11157
11158 #[allow(clippy::enum_variant_names)]
11159 enum GeneratedField {
11160 OriginalSchema,
11161 AddColumns,
11162 DropColumns,
11163 }
11164 impl<'de> serde::Deserialize<'de> for GeneratedField {
11165 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11166 where
11167 D: serde::Deserializer<'de>,
11168 {
11169 struct GeneratedVisitor;
11170
11171 impl serde::de::Visitor<'_> for GeneratedVisitor {
11172 type Value = GeneratedField;
11173
11174 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11175 write!(formatter, "expected one of: {:?}", &FIELDS)
11176 }
11177
11178 #[allow(unused_variables)]
11179 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11180 where
11181 E: serde::de::Error,
11182 {
11183 match value {
11184 "originalSchema" | "original_schema" => Ok(GeneratedField::OriginalSchema),
11185 "addColumns" | "add_columns" => Ok(GeneratedField::AddColumns),
11186 "dropColumns" | "drop_columns" => Ok(GeneratedField::DropColumns),
11187 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11188 }
11189 }
11190 }
11191 deserializer.deserialize_identifier(GeneratedVisitor)
11192 }
11193 }
11194 struct GeneratedVisitor;
11195 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11196 type Value = SinkSchemaChange;
11197
11198 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11199 formatter.write_str("struct stream_plan.SinkSchemaChange")
11200 }
11201
11202 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkSchemaChange, V::Error>
11203 where
11204 V: serde::de::MapAccess<'de>,
11205 {
11206 let mut original_schema__ = None;
11207 let mut op__ = None;
11208 while let Some(k) = map_.next_key()? {
11209 match k {
11210 GeneratedField::OriginalSchema => {
11211 if original_schema__.is_some() {
11212 return Err(serde::de::Error::duplicate_field("originalSchema"));
11213 }
11214 original_schema__ = Some(map_.next_value()?);
11215 }
11216 GeneratedField::AddColumns => {
11217 if op__.is_some() {
11218 return Err(serde::de::Error::duplicate_field("addColumns"));
11219 }
11220 op__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_schema_change::Op::AddColumns)
11221;
11222 }
11223 GeneratedField::DropColumns => {
11224 if op__.is_some() {
11225 return Err(serde::de::Error::duplicate_field("dropColumns"));
11226 }
11227 op__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_schema_change::Op::DropColumns)
11228;
11229 }
11230 }
11231 }
11232 Ok(SinkSchemaChange {
11233 original_schema: original_schema__.unwrap_or_default(),
11234 op: op__,
11235 })
11236 }
11237 }
11238 deserializer.deserialize_struct("stream_plan.SinkSchemaChange", FIELDS, GeneratedVisitor)
11239 }
11240}
11241impl serde::Serialize for SortNode {
11242 #[allow(deprecated)]
11243 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11244 where
11245 S: serde::Serializer,
11246 {
11247 use serde::ser::SerializeStruct;
11248 let mut len = 0;
11249 if self.state_table.is_some() {
11250 len += 1;
11251 }
11252 if self.sort_column_index != 0 {
11253 len += 1;
11254 }
11255 let mut struct_ser = serializer.serialize_struct("stream_plan.SortNode", len)?;
11256 if let Some(v) = self.state_table.as_ref() {
11257 struct_ser.serialize_field("stateTable", v)?;
11258 }
11259 if self.sort_column_index != 0 {
11260 struct_ser.serialize_field("sortColumnIndex", &self.sort_column_index)?;
11261 }
11262 struct_ser.end()
11263 }
11264}
11265impl<'de> serde::Deserialize<'de> for SortNode {
11266 #[allow(deprecated)]
11267 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11268 where
11269 D: serde::Deserializer<'de>,
11270 {
11271 const FIELDS: &[&str] = &[
11272 "state_table",
11273 "stateTable",
11274 "sort_column_index",
11275 "sortColumnIndex",
11276 ];
11277
11278 #[allow(clippy::enum_variant_names)]
11279 enum GeneratedField {
11280 StateTable,
11281 SortColumnIndex,
11282 }
11283 impl<'de> serde::Deserialize<'de> for GeneratedField {
11284 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11285 where
11286 D: serde::Deserializer<'de>,
11287 {
11288 struct GeneratedVisitor;
11289
11290 impl serde::de::Visitor<'_> for GeneratedVisitor {
11291 type Value = GeneratedField;
11292
11293 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11294 write!(formatter, "expected one of: {:?}", &FIELDS)
11295 }
11296
11297 #[allow(unused_variables)]
11298 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11299 where
11300 E: serde::de::Error,
11301 {
11302 match value {
11303 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11304 "sortColumnIndex" | "sort_column_index" => Ok(GeneratedField::SortColumnIndex),
11305 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11306 }
11307 }
11308 }
11309 deserializer.deserialize_identifier(GeneratedVisitor)
11310 }
11311 }
11312 struct GeneratedVisitor;
11313 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11314 type Value = SortNode;
11315
11316 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11317 formatter.write_str("struct stream_plan.SortNode")
11318 }
11319
11320 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
11321 where
11322 V: serde::de::MapAccess<'de>,
11323 {
11324 let mut state_table__ = None;
11325 let mut sort_column_index__ = None;
11326 while let Some(k) = map_.next_key()? {
11327 match k {
11328 GeneratedField::StateTable => {
11329 if state_table__.is_some() {
11330 return Err(serde::de::Error::duplicate_field("stateTable"));
11331 }
11332 state_table__ = map_.next_value()?;
11333 }
11334 GeneratedField::SortColumnIndex => {
11335 if sort_column_index__.is_some() {
11336 return Err(serde::de::Error::duplicate_field("sortColumnIndex"));
11337 }
11338 sort_column_index__ =
11339 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11340 ;
11341 }
11342 }
11343 }
11344 Ok(SortNode {
11345 state_table: state_table__,
11346 sort_column_index: sort_column_index__.unwrap_or_default(),
11347 })
11348 }
11349 }
11350 deserializer.deserialize_struct("stream_plan.SortNode", FIELDS, GeneratedVisitor)
11351 }
11352}
11353impl serde::Serialize for SourceBackfillNode {
11354 #[allow(deprecated)]
11355 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11356 where
11357 S: serde::Serializer,
11358 {
11359 use serde::ser::SerializeStruct;
11360 let mut len = 0;
11361 if self.upstream_source_id != 0 {
11362 len += 1;
11363 }
11364 if self.row_id_index.is_some() {
11365 len += 1;
11366 }
11367 if !self.columns.is_empty() {
11368 len += 1;
11369 }
11370 if self.info.is_some() {
11371 len += 1;
11372 }
11373 if !self.source_name.is_empty() {
11374 len += 1;
11375 }
11376 if !self.with_properties.is_empty() {
11377 len += 1;
11378 }
11379 if self.rate_limit.is_some() {
11380 len += 1;
11381 }
11382 if self.state_table.is_some() {
11383 len += 1;
11384 }
11385 if !self.secret_refs.is_empty() {
11386 len += 1;
11387 }
11388 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceBackfillNode", len)?;
11389 if self.upstream_source_id != 0 {
11390 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
11391 }
11392 if let Some(v) = self.row_id_index.as_ref() {
11393 struct_ser.serialize_field("rowIdIndex", v)?;
11394 }
11395 if !self.columns.is_empty() {
11396 struct_ser.serialize_field("columns", &self.columns)?;
11397 }
11398 if let Some(v) = self.info.as_ref() {
11399 struct_ser.serialize_field("info", v)?;
11400 }
11401 if !self.source_name.is_empty() {
11402 struct_ser.serialize_field("sourceName", &self.source_name)?;
11403 }
11404 if !self.with_properties.is_empty() {
11405 struct_ser.serialize_field("withProperties", &self.with_properties)?;
11406 }
11407 if let Some(v) = self.rate_limit.as_ref() {
11408 struct_ser.serialize_field("rateLimit", v)?;
11409 }
11410 if let Some(v) = self.state_table.as_ref() {
11411 struct_ser.serialize_field("stateTable", v)?;
11412 }
11413 if !self.secret_refs.is_empty() {
11414 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
11415 }
11416 struct_ser.end()
11417 }
11418}
11419impl<'de> serde::Deserialize<'de> for SourceBackfillNode {
11420 #[allow(deprecated)]
11421 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11422 where
11423 D: serde::Deserializer<'de>,
11424 {
11425 const FIELDS: &[&str] = &[
11426 "upstream_source_id",
11427 "upstreamSourceId",
11428 "row_id_index",
11429 "rowIdIndex",
11430 "columns",
11431 "info",
11432 "source_name",
11433 "sourceName",
11434 "with_properties",
11435 "withProperties",
11436 "rate_limit",
11437 "rateLimit",
11438 "state_table",
11439 "stateTable",
11440 "secret_refs",
11441 "secretRefs",
11442 ];
11443
11444 #[allow(clippy::enum_variant_names)]
11445 enum GeneratedField {
11446 UpstreamSourceId,
11447 RowIdIndex,
11448 Columns,
11449 Info,
11450 SourceName,
11451 WithProperties,
11452 RateLimit,
11453 StateTable,
11454 SecretRefs,
11455 }
11456 impl<'de> serde::Deserialize<'de> for GeneratedField {
11457 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11458 where
11459 D: serde::Deserializer<'de>,
11460 {
11461 struct GeneratedVisitor;
11462
11463 impl serde::de::Visitor<'_> for GeneratedVisitor {
11464 type Value = GeneratedField;
11465
11466 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11467 write!(formatter, "expected one of: {:?}", &FIELDS)
11468 }
11469
11470 #[allow(unused_variables)]
11471 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11472 where
11473 E: serde::de::Error,
11474 {
11475 match value {
11476 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
11477 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
11478 "columns" => Ok(GeneratedField::Columns),
11479 "info" => Ok(GeneratedField::Info),
11480 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
11481 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
11482 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11483 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11484 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
11485 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11486 }
11487 }
11488 }
11489 deserializer.deserialize_identifier(GeneratedVisitor)
11490 }
11491 }
11492 struct GeneratedVisitor;
11493 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11494 type Value = SourceBackfillNode;
11495
11496 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11497 formatter.write_str("struct stream_plan.SourceBackfillNode")
11498 }
11499
11500 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceBackfillNode, V::Error>
11501 where
11502 V: serde::de::MapAccess<'de>,
11503 {
11504 let mut upstream_source_id__ = None;
11505 let mut row_id_index__ = None;
11506 let mut columns__ = None;
11507 let mut info__ = None;
11508 let mut source_name__ = None;
11509 let mut with_properties__ = None;
11510 let mut rate_limit__ = None;
11511 let mut state_table__ = None;
11512 let mut secret_refs__ = None;
11513 while let Some(k) = map_.next_key()? {
11514 match k {
11515 GeneratedField::UpstreamSourceId => {
11516 if upstream_source_id__.is_some() {
11517 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
11518 }
11519 upstream_source_id__ =
11520 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11521 ;
11522 }
11523 GeneratedField::RowIdIndex => {
11524 if row_id_index__.is_some() {
11525 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
11526 }
11527 row_id_index__ =
11528 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11529 ;
11530 }
11531 GeneratedField::Columns => {
11532 if columns__.is_some() {
11533 return Err(serde::de::Error::duplicate_field("columns"));
11534 }
11535 columns__ = Some(map_.next_value()?);
11536 }
11537 GeneratedField::Info => {
11538 if info__.is_some() {
11539 return Err(serde::de::Error::duplicate_field("info"));
11540 }
11541 info__ = map_.next_value()?;
11542 }
11543 GeneratedField::SourceName => {
11544 if source_name__.is_some() {
11545 return Err(serde::de::Error::duplicate_field("sourceName"));
11546 }
11547 source_name__ = Some(map_.next_value()?);
11548 }
11549 GeneratedField::WithProperties => {
11550 if with_properties__.is_some() {
11551 return Err(serde::de::Error::duplicate_field("withProperties"));
11552 }
11553 with_properties__ = Some(
11554 map_.next_value::<std::collections::BTreeMap<_, _>>()?
11555 );
11556 }
11557 GeneratedField::RateLimit => {
11558 if rate_limit__.is_some() {
11559 return Err(serde::de::Error::duplicate_field("rateLimit"));
11560 }
11561 rate_limit__ =
11562 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11563 ;
11564 }
11565 GeneratedField::StateTable => {
11566 if state_table__.is_some() {
11567 return Err(serde::de::Error::duplicate_field("stateTable"));
11568 }
11569 state_table__ = map_.next_value()?;
11570 }
11571 GeneratedField::SecretRefs => {
11572 if secret_refs__.is_some() {
11573 return Err(serde::de::Error::duplicate_field("secretRefs"));
11574 }
11575 secret_refs__ = Some(
11576 map_.next_value::<std::collections::BTreeMap<_, _>>()?
11577 );
11578 }
11579 }
11580 }
11581 Ok(SourceBackfillNode {
11582 upstream_source_id: upstream_source_id__.unwrap_or_default(),
11583 row_id_index: row_id_index__,
11584 columns: columns__.unwrap_or_default(),
11585 info: info__,
11586 source_name: source_name__.unwrap_or_default(),
11587 with_properties: with_properties__.unwrap_or_default(),
11588 rate_limit: rate_limit__,
11589 state_table: state_table__,
11590 secret_refs: secret_refs__.unwrap_or_default(),
11591 })
11592 }
11593 }
11594 deserializer.deserialize_struct("stream_plan.SourceBackfillNode", FIELDS, GeneratedVisitor)
11595 }
11596}
11597impl serde::Serialize for SourceChangeSplitMutation {
11598 #[allow(deprecated)]
11599 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11600 where
11601 S: serde::Serializer,
11602 {
11603 use serde::ser::SerializeStruct;
11604 let mut len = 0;
11605 if !self.actor_splits.is_empty() {
11606 len += 1;
11607 }
11608 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceChangeSplitMutation", len)?;
11609 if !self.actor_splits.is_empty() {
11610 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
11611 }
11612 struct_ser.end()
11613 }
11614}
11615impl<'de> serde::Deserialize<'de> for SourceChangeSplitMutation {
11616 #[allow(deprecated)]
11617 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11618 where
11619 D: serde::Deserializer<'de>,
11620 {
11621 const FIELDS: &[&str] = &[
11622 "actor_splits",
11623 "actorSplits",
11624 ];
11625
11626 #[allow(clippy::enum_variant_names)]
11627 enum GeneratedField {
11628 ActorSplits,
11629 }
11630 impl<'de> serde::Deserialize<'de> for GeneratedField {
11631 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11632 where
11633 D: serde::Deserializer<'de>,
11634 {
11635 struct GeneratedVisitor;
11636
11637 impl serde::de::Visitor<'_> for GeneratedVisitor {
11638 type Value = GeneratedField;
11639
11640 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11641 write!(formatter, "expected one of: {:?}", &FIELDS)
11642 }
11643
11644 #[allow(unused_variables)]
11645 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11646 where
11647 E: serde::de::Error,
11648 {
11649 match value {
11650 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
11651 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11652 }
11653 }
11654 }
11655 deserializer.deserialize_identifier(GeneratedVisitor)
11656 }
11657 }
11658 struct GeneratedVisitor;
11659 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11660 type Value = SourceChangeSplitMutation;
11661
11662 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11663 formatter.write_str("struct stream_plan.SourceChangeSplitMutation")
11664 }
11665
11666 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceChangeSplitMutation, V::Error>
11667 where
11668 V: serde::de::MapAccess<'de>,
11669 {
11670 let mut actor_splits__ = None;
11671 while let Some(k) = map_.next_key()? {
11672 match k {
11673 GeneratedField::ActorSplits => {
11674 if actor_splits__.is_some() {
11675 return Err(serde::de::Error::duplicate_field("actorSplits"));
11676 }
11677 actor_splits__ = Some(
11678 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11679 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
11680 );
11681 }
11682 }
11683 }
11684 Ok(SourceChangeSplitMutation {
11685 actor_splits: actor_splits__.unwrap_or_default(),
11686 })
11687 }
11688 }
11689 deserializer.deserialize_struct("stream_plan.SourceChangeSplitMutation", FIELDS, GeneratedVisitor)
11690 }
11691}
11692impl serde::Serialize for SourceNode {
11693 #[allow(deprecated)]
11694 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11695 where
11696 S: serde::Serializer,
11697 {
11698 use serde::ser::SerializeStruct;
11699 let mut len = 0;
11700 if self.source_inner.is_some() {
11701 len += 1;
11702 }
11703 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceNode", len)?;
11704 if let Some(v) = self.source_inner.as_ref() {
11705 struct_ser.serialize_field("sourceInner", v)?;
11706 }
11707 struct_ser.end()
11708 }
11709}
11710impl<'de> serde::Deserialize<'de> for SourceNode {
11711 #[allow(deprecated)]
11712 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11713 where
11714 D: serde::Deserializer<'de>,
11715 {
11716 const FIELDS: &[&str] = &[
11717 "source_inner",
11718 "sourceInner",
11719 ];
11720
11721 #[allow(clippy::enum_variant_names)]
11722 enum GeneratedField {
11723 SourceInner,
11724 }
11725 impl<'de> serde::Deserialize<'de> for GeneratedField {
11726 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11727 where
11728 D: serde::Deserializer<'de>,
11729 {
11730 struct GeneratedVisitor;
11731
11732 impl serde::de::Visitor<'_> for GeneratedVisitor {
11733 type Value = GeneratedField;
11734
11735 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11736 write!(formatter, "expected one of: {:?}", &FIELDS)
11737 }
11738
11739 #[allow(unused_variables)]
11740 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11741 where
11742 E: serde::de::Error,
11743 {
11744 match value {
11745 "sourceInner" | "source_inner" => Ok(GeneratedField::SourceInner),
11746 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11747 }
11748 }
11749 }
11750 deserializer.deserialize_identifier(GeneratedVisitor)
11751 }
11752 }
11753 struct GeneratedVisitor;
11754 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11755 type Value = SourceNode;
11756
11757 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11758 formatter.write_str("struct stream_plan.SourceNode")
11759 }
11760
11761 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
11762 where
11763 V: serde::de::MapAccess<'de>,
11764 {
11765 let mut source_inner__ = None;
11766 while let Some(k) = map_.next_key()? {
11767 match k {
11768 GeneratedField::SourceInner => {
11769 if source_inner__.is_some() {
11770 return Err(serde::de::Error::duplicate_field("sourceInner"));
11771 }
11772 source_inner__ = map_.next_value()?;
11773 }
11774 }
11775 }
11776 Ok(SourceNode {
11777 source_inner: source_inner__,
11778 })
11779 }
11780 }
11781 deserializer.deserialize_struct("stream_plan.SourceNode", FIELDS, GeneratedVisitor)
11782 }
11783}
11784impl serde::Serialize for StartFragmentBackfillMutation {
11785 #[allow(deprecated)]
11786 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11787 where
11788 S: serde::Serializer,
11789 {
11790 use serde::ser::SerializeStruct;
11791 let mut len = 0;
11792 if !self.fragment_ids.is_empty() {
11793 len += 1;
11794 }
11795 let mut struct_ser = serializer.serialize_struct("stream_plan.StartFragmentBackfillMutation", len)?;
11796 if !self.fragment_ids.is_empty() {
11797 struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
11798 }
11799 struct_ser.end()
11800 }
11801}
11802impl<'de> serde::Deserialize<'de> for StartFragmentBackfillMutation {
11803 #[allow(deprecated)]
11804 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11805 where
11806 D: serde::Deserializer<'de>,
11807 {
11808 const FIELDS: &[&str] = &[
11809 "fragment_ids",
11810 "fragmentIds",
11811 ];
11812
11813 #[allow(clippy::enum_variant_names)]
11814 enum GeneratedField {
11815 FragmentIds,
11816 }
11817 impl<'de> serde::Deserialize<'de> for GeneratedField {
11818 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11819 where
11820 D: serde::Deserializer<'de>,
11821 {
11822 struct GeneratedVisitor;
11823
11824 impl serde::de::Visitor<'_> for GeneratedVisitor {
11825 type Value = GeneratedField;
11826
11827 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11828 write!(formatter, "expected one of: {:?}", &FIELDS)
11829 }
11830
11831 #[allow(unused_variables)]
11832 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11833 where
11834 E: serde::de::Error,
11835 {
11836 match value {
11837 "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
11838 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11839 }
11840 }
11841 }
11842 deserializer.deserialize_identifier(GeneratedVisitor)
11843 }
11844 }
11845 struct GeneratedVisitor;
11846 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11847 type Value = StartFragmentBackfillMutation;
11848
11849 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11850 formatter.write_str("struct stream_plan.StartFragmentBackfillMutation")
11851 }
11852
11853 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StartFragmentBackfillMutation, V::Error>
11854 where
11855 V: serde::de::MapAccess<'de>,
11856 {
11857 let mut fragment_ids__ = None;
11858 while let Some(k) = map_.next_key()? {
11859 match k {
11860 GeneratedField::FragmentIds => {
11861 if fragment_ids__.is_some() {
11862 return Err(serde::de::Error::duplicate_field("fragmentIds"));
11863 }
11864 fragment_ids__ =
11865 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11866 .into_iter().map(|x| x.0).collect())
11867 ;
11868 }
11869 }
11870 }
11871 Ok(StartFragmentBackfillMutation {
11872 fragment_ids: fragment_ids__.unwrap_or_default(),
11873 })
11874 }
11875 }
11876 deserializer.deserialize_struct("stream_plan.StartFragmentBackfillMutation", FIELDS, GeneratedVisitor)
11877 }
11878}
11879impl serde::Serialize for StopMutation {
11880 #[allow(deprecated)]
11881 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11882 where
11883 S: serde::Serializer,
11884 {
11885 use serde::ser::SerializeStruct;
11886 let mut len = 0;
11887 if !self.actors.is_empty() {
11888 len += 1;
11889 }
11890 if !self.dropped_sink_fragments.is_empty() {
11891 len += 1;
11892 }
11893 let mut struct_ser = serializer.serialize_struct("stream_plan.StopMutation", len)?;
11894 if !self.actors.is_empty() {
11895 struct_ser.serialize_field("actors", &self.actors)?;
11896 }
11897 if !self.dropped_sink_fragments.is_empty() {
11898 struct_ser.serialize_field("droppedSinkFragments", &self.dropped_sink_fragments)?;
11899 }
11900 struct_ser.end()
11901 }
11902}
11903impl<'de> serde::Deserialize<'de> for StopMutation {
11904 #[allow(deprecated)]
11905 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11906 where
11907 D: serde::Deserializer<'de>,
11908 {
11909 const FIELDS: &[&str] = &[
11910 "actors",
11911 "dropped_sink_fragments",
11912 "droppedSinkFragments",
11913 ];
11914
11915 #[allow(clippy::enum_variant_names)]
11916 enum GeneratedField {
11917 Actors,
11918 DroppedSinkFragments,
11919 }
11920 impl<'de> serde::Deserialize<'de> for GeneratedField {
11921 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11922 where
11923 D: serde::Deserializer<'de>,
11924 {
11925 struct GeneratedVisitor;
11926
11927 impl serde::de::Visitor<'_> for GeneratedVisitor {
11928 type Value = GeneratedField;
11929
11930 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11931 write!(formatter, "expected one of: {:?}", &FIELDS)
11932 }
11933
11934 #[allow(unused_variables)]
11935 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11936 where
11937 E: serde::de::Error,
11938 {
11939 match value {
11940 "actors" => Ok(GeneratedField::Actors),
11941 "droppedSinkFragments" | "dropped_sink_fragments" => Ok(GeneratedField::DroppedSinkFragments),
11942 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11943 }
11944 }
11945 }
11946 deserializer.deserialize_identifier(GeneratedVisitor)
11947 }
11948 }
11949 struct GeneratedVisitor;
11950 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11951 type Value = StopMutation;
11952
11953 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11954 formatter.write_str("struct stream_plan.StopMutation")
11955 }
11956
11957 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopMutation, V::Error>
11958 where
11959 V: serde::de::MapAccess<'de>,
11960 {
11961 let mut actors__ = None;
11962 let mut dropped_sink_fragments__ = None;
11963 while let Some(k) = map_.next_key()? {
11964 match k {
11965 GeneratedField::Actors => {
11966 if actors__.is_some() {
11967 return Err(serde::de::Error::duplicate_field("actors"));
11968 }
11969 actors__ =
11970 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11971 .into_iter().map(|x| x.0).collect())
11972 ;
11973 }
11974 GeneratedField::DroppedSinkFragments => {
11975 if dropped_sink_fragments__.is_some() {
11976 return Err(serde::de::Error::duplicate_field("droppedSinkFragments"));
11977 }
11978 dropped_sink_fragments__ =
11979 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11980 .into_iter().map(|x| x.0).collect())
11981 ;
11982 }
11983 }
11984 }
11985 Ok(StopMutation {
11986 actors: actors__.unwrap_or_default(),
11987 dropped_sink_fragments: dropped_sink_fragments__.unwrap_or_default(),
11988 })
11989 }
11990 }
11991 deserializer.deserialize_struct("stream_plan.StopMutation", FIELDS, GeneratedVisitor)
11992 }
11993}
11994impl serde::Serialize for StreamActor {
11995 #[allow(deprecated)]
11996 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11997 where
11998 S: serde::Serializer,
11999 {
12000 use serde::ser::SerializeStruct;
12001 let mut len = 0;
12002 if self.actor_id != 0 {
12003 len += 1;
12004 }
12005 if self.fragment_id != 0 {
12006 len += 1;
12007 }
12008 if !self.dispatcher.is_empty() {
12009 len += 1;
12010 }
12011 if self.vnode_bitmap.is_some() {
12012 len += 1;
12013 }
12014 if !self.mview_definition.is_empty() {
12015 len += 1;
12016 }
12017 if self.expr_context.is_some() {
12018 len += 1;
12019 }
12020 if !self.config_override.is_empty() {
12021 len += 1;
12022 }
12023 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamActor", len)?;
12024 if self.actor_id != 0 {
12025 struct_ser.serialize_field("actorId", &self.actor_id)?;
12026 }
12027 if self.fragment_id != 0 {
12028 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
12029 }
12030 if !self.dispatcher.is_empty() {
12031 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
12032 }
12033 if let Some(v) = self.vnode_bitmap.as_ref() {
12034 struct_ser.serialize_field("vnodeBitmap", v)?;
12035 }
12036 if !self.mview_definition.is_empty() {
12037 struct_ser.serialize_field("mviewDefinition", &self.mview_definition)?;
12038 }
12039 if let Some(v) = self.expr_context.as_ref() {
12040 struct_ser.serialize_field("exprContext", v)?;
12041 }
12042 if !self.config_override.is_empty() {
12043 struct_ser.serialize_field("configOverride", &self.config_override)?;
12044 }
12045 struct_ser.end()
12046 }
12047}
12048impl<'de> serde::Deserialize<'de> for StreamActor {
12049 #[allow(deprecated)]
12050 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12051 where
12052 D: serde::Deserializer<'de>,
12053 {
12054 const FIELDS: &[&str] = &[
12055 "actor_id",
12056 "actorId",
12057 "fragment_id",
12058 "fragmentId",
12059 "dispatcher",
12060 "vnode_bitmap",
12061 "vnodeBitmap",
12062 "mview_definition",
12063 "mviewDefinition",
12064 "expr_context",
12065 "exprContext",
12066 "config_override",
12067 "configOverride",
12068 ];
12069
12070 #[allow(clippy::enum_variant_names)]
12071 enum GeneratedField {
12072 ActorId,
12073 FragmentId,
12074 Dispatcher,
12075 VnodeBitmap,
12076 MviewDefinition,
12077 ExprContext,
12078 ConfigOverride,
12079 }
12080 impl<'de> serde::Deserialize<'de> for GeneratedField {
12081 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12082 where
12083 D: serde::Deserializer<'de>,
12084 {
12085 struct GeneratedVisitor;
12086
12087 impl serde::de::Visitor<'_> for GeneratedVisitor {
12088 type Value = GeneratedField;
12089
12090 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12091 write!(formatter, "expected one of: {:?}", &FIELDS)
12092 }
12093
12094 #[allow(unused_variables)]
12095 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12096 where
12097 E: serde::de::Error,
12098 {
12099 match value {
12100 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
12101 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
12102 "dispatcher" => Ok(GeneratedField::Dispatcher),
12103 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
12104 "mviewDefinition" | "mview_definition" => Ok(GeneratedField::MviewDefinition),
12105 "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
12106 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
12107 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12108 }
12109 }
12110 }
12111 deserializer.deserialize_identifier(GeneratedVisitor)
12112 }
12113 }
12114 struct GeneratedVisitor;
12115 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12116 type Value = StreamActor;
12117
12118 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12119 formatter.write_str("struct stream_plan.StreamActor")
12120 }
12121
12122 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamActor, V::Error>
12123 where
12124 V: serde::de::MapAccess<'de>,
12125 {
12126 let mut actor_id__ = None;
12127 let mut fragment_id__ = None;
12128 let mut dispatcher__ = None;
12129 let mut vnode_bitmap__ = None;
12130 let mut mview_definition__ = None;
12131 let mut expr_context__ = None;
12132 let mut config_override__ = None;
12133 while let Some(k) = map_.next_key()? {
12134 match k {
12135 GeneratedField::ActorId => {
12136 if actor_id__.is_some() {
12137 return Err(serde::de::Error::duplicate_field("actorId"));
12138 }
12139 actor_id__ =
12140 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12141 ;
12142 }
12143 GeneratedField::FragmentId => {
12144 if fragment_id__.is_some() {
12145 return Err(serde::de::Error::duplicate_field("fragmentId"));
12146 }
12147 fragment_id__ =
12148 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12149 ;
12150 }
12151 GeneratedField::Dispatcher => {
12152 if dispatcher__.is_some() {
12153 return Err(serde::de::Error::duplicate_field("dispatcher"));
12154 }
12155 dispatcher__ = Some(map_.next_value()?);
12156 }
12157 GeneratedField::VnodeBitmap => {
12158 if vnode_bitmap__.is_some() {
12159 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
12160 }
12161 vnode_bitmap__ = map_.next_value()?;
12162 }
12163 GeneratedField::MviewDefinition => {
12164 if mview_definition__.is_some() {
12165 return Err(serde::de::Error::duplicate_field("mviewDefinition"));
12166 }
12167 mview_definition__ = Some(map_.next_value()?);
12168 }
12169 GeneratedField::ExprContext => {
12170 if expr_context__.is_some() {
12171 return Err(serde::de::Error::duplicate_field("exprContext"));
12172 }
12173 expr_context__ = map_.next_value()?;
12174 }
12175 GeneratedField::ConfigOverride => {
12176 if config_override__.is_some() {
12177 return Err(serde::de::Error::duplicate_field("configOverride"));
12178 }
12179 config_override__ = Some(map_.next_value()?);
12180 }
12181 }
12182 }
12183 Ok(StreamActor {
12184 actor_id: actor_id__.unwrap_or_default(),
12185 fragment_id: fragment_id__.unwrap_or_default(),
12186 dispatcher: dispatcher__.unwrap_or_default(),
12187 vnode_bitmap: vnode_bitmap__,
12188 mview_definition: mview_definition__.unwrap_or_default(),
12189 expr_context: expr_context__,
12190 config_override: config_override__.unwrap_or_default(),
12191 })
12192 }
12193 }
12194 deserializer.deserialize_struct("stream_plan.StreamActor", FIELDS, GeneratedVisitor)
12195 }
12196}
12197impl serde::Serialize for StreamCdcScanNode {
12198 #[allow(deprecated)]
12199 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12200 where
12201 S: serde::Serializer,
12202 {
12203 use serde::ser::SerializeStruct;
12204 let mut len = 0;
12205 if self.table_id != 0 {
12206 len += 1;
12207 }
12208 if !self.upstream_column_ids.is_empty() {
12209 len += 1;
12210 }
12211 if !self.output_indices.is_empty() {
12212 len += 1;
12213 }
12214 if self.state_table.is_some() {
12215 len += 1;
12216 }
12217 if self.cdc_table_desc.is_some() {
12218 len += 1;
12219 }
12220 if self.rate_limit.is_some() {
12221 len += 1;
12222 }
12223 if self.disable_backfill {
12224 len += 1;
12225 }
12226 if self.options.is_some() {
12227 len += 1;
12228 }
12229 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanNode", len)?;
12230 if self.table_id != 0 {
12231 struct_ser.serialize_field("tableId", &self.table_id)?;
12232 }
12233 if !self.upstream_column_ids.is_empty() {
12234 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
12235 }
12236 if !self.output_indices.is_empty() {
12237 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
12238 }
12239 if let Some(v) = self.state_table.as_ref() {
12240 struct_ser.serialize_field("stateTable", v)?;
12241 }
12242 if let Some(v) = self.cdc_table_desc.as_ref() {
12243 struct_ser.serialize_field("cdcTableDesc", v)?;
12244 }
12245 if let Some(v) = self.rate_limit.as_ref() {
12246 struct_ser.serialize_field("rateLimit", v)?;
12247 }
12248 if self.disable_backfill {
12249 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
12250 }
12251 if let Some(v) = self.options.as_ref() {
12252 struct_ser.serialize_field("options", v)?;
12253 }
12254 struct_ser.end()
12255 }
12256}
12257impl<'de> serde::Deserialize<'de> for StreamCdcScanNode {
12258 #[allow(deprecated)]
12259 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12260 where
12261 D: serde::Deserializer<'de>,
12262 {
12263 const FIELDS: &[&str] = &[
12264 "table_id",
12265 "tableId",
12266 "upstream_column_ids",
12267 "upstreamColumnIds",
12268 "output_indices",
12269 "outputIndices",
12270 "state_table",
12271 "stateTable",
12272 "cdc_table_desc",
12273 "cdcTableDesc",
12274 "rate_limit",
12275 "rateLimit",
12276 "disable_backfill",
12277 "disableBackfill",
12278 "options",
12279 ];
12280
12281 #[allow(clippy::enum_variant_names)]
12282 enum GeneratedField {
12283 TableId,
12284 UpstreamColumnIds,
12285 OutputIndices,
12286 StateTable,
12287 CdcTableDesc,
12288 RateLimit,
12289 DisableBackfill,
12290 Options,
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 serde::de::Visitor<'_> 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 "tableId" | "table_id" => Ok(GeneratedField::TableId),
12313 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
12314 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
12315 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
12316 "cdcTableDesc" | "cdc_table_desc" => Ok(GeneratedField::CdcTableDesc),
12317 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
12318 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
12319 "options" => Ok(GeneratedField::Options),
12320 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12321 }
12322 }
12323 }
12324 deserializer.deserialize_identifier(GeneratedVisitor)
12325 }
12326 }
12327 struct GeneratedVisitor;
12328 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12329 type Value = StreamCdcScanNode;
12330
12331 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12332 formatter.write_str("struct stream_plan.StreamCdcScanNode")
12333 }
12334
12335 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanNode, V::Error>
12336 where
12337 V: serde::de::MapAccess<'de>,
12338 {
12339 let mut table_id__ = None;
12340 let mut upstream_column_ids__ = None;
12341 let mut output_indices__ = None;
12342 let mut state_table__ = None;
12343 let mut cdc_table_desc__ = None;
12344 let mut rate_limit__ = None;
12345 let mut disable_backfill__ = None;
12346 let mut options__ = None;
12347 while let Some(k) = map_.next_key()? {
12348 match k {
12349 GeneratedField::TableId => {
12350 if table_id__.is_some() {
12351 return Err(serde::de::Error::duplicate_field("tableId"));
12352 }
12353 table_id__ =
12354 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12355 ;
12356 }
12357 GeneratedField::UpstreamColumnIds => {
12358 if upstream_column_ids__.is_some() {
12359 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
12360 }
12361 upstream_column_ids__ =
12362 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12363 .into_iter().map(|x| x.0).collect())
12364 ;
12365 }
12366 GeneratedField::OutputIndices => {
12367 if output_indices__.is_some() {
12368 return Err(serde::de::Error::duplicate_field("outputIndices"));
12369 }
12370 output_indices__ =
12371 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12372 .into_iter().map(|x| x.0).collect())
12373 ;
12374 }
12375 GeneratedField::StateTable => {
12376 if state_table__.is_some() {
12377 return Err(serde::de::Error::duplicate_field("stateTable"));
12378 }
12379 state_table__ = map_.next_value()?;
12380 }
12381 GeneratedField::CdcTableDesc => {
12382 if cdc_table_desc__.is_some() {
12383 return Err(serde::de::Error::duplicate_field("cdcTableDesc"));
12384 }
12385 cdc_table_desc__ = map_.next_value()?;
12386 }
12387 GeneratedField::RateLimit => {
12388 if rate_limit__.is_some() {
12389 return Err(serde::de::Error::duplicate_field("rateLimit"));
12390 }
12391 rate_limit__ =
12392 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12393 ;
12394 }
12395 GeneratedField::DisableBackfill => {
12396 if disable_backfill__.is_some() {
12397 return Err(serde::de::Error::duplicate_field("disableBackfill"));
12398 }
12399 disable_backfill__ = Some(map_.next_value()?);
12400 }
12401 GeneratedField::Options => {
12402 if options__.is_some() {
12403 return Err(serde::de::Error::duplicate_field("options"));
12404 }
12405 options__ = map_.next_value()?;
12406 }
12407 }
12408 }
12409 Ok(StreamCdcScanNode {
12410 table_id: table_id__.unwrap_or_default(),
12411 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
12412 output_indices: output_indices__.unwrap_or_default(),
12413 state_table: state_table__,
12414 cdc_table_desc: cdc_table_desc__,
12415 rate_limit: rate_limit__,
12416 disable_backfill: disable_backfill__.unwrap_or_default(),
12417 options: options__,
12418 })
12419 }
12420 }
12421 deserializer.deserialize_struct("stream_plan.StreamCdcScanNode", FIELDS, GeneratedVisitor)
12422 }
12423}
12424impl serde::Serialize for StreamCdcScanOptions {
12425 #[allow(deprecated)]
12426 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12427 where
12428 S: serde::Serializer,
12429 {
12430 use serde::ser::SerializeStruct;
12431 let mut len = 0;
12432 if self.disable_backfill {
12433 len += 1;
12434 }
12435 if self.snapshot_barrier_interval != 0 {
12436 len += 1;
12437 }
12438 if self.snapshot_batch_size != 0 {
12439 len += 1;
12440 }
12441 if self.backfill_parallelism != 0 {
12442 len += 1;
12443 }
12444 if self.backfill_num_rows_per_split != 0 {
12445 len += 1;
12446 }
12447 if self.backfill_as_even_splits {
12448 len += 1;
12449 }
12450 if self.backfill_split_pk_column_index != 0 {
12451 len += 1;
12452 }
12453 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanOptions", len)?;
12454 if self.disable_backfill {
12455 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
12456 }
12457 if self.snapshot_barrier_interval != 0 {
12458 struct_ser.serialize_field("snapshotBarrierInterval", &self.snapshot_barrier_interval)?;
12459 }
12460 if self.snapshot_batch_size != 0 {
12461 struct_ser.serialize_field("snapshotBatchSize", &self.snapshot_batch_size)?;
12462 }
12463 if self.backfill_parallelism != 0 {
12464 struct_ser.serialize_field("backfillParallelism", &self.backfill_parallelism)?;
12465 }
12466 if self.backfill_num_rows_per_split != 0 {
12467 #[allow(clippy::needless_borrow)]
12468 #[allow(clippy::needless_borrows_for_generic_args)]
12469 struct_ser.serialize_field("backfillNumRowsPerSplit", ToString::to_string(&self.backfill_num_rows_per_split).as_str())?;
12470 }
12471 if self.backfill_as_even_splits {
12472 struct_ser.serialize_field("backfillAsEvenSplits", &self.backfill_as_even_splits)?;
12473 }
12474 if self.backfill_split_pk_column_index != 0 {
12475 struct_ser.serialize_field("backfillSplitPkColumnIndex", &self.backfill_split_pk_column_index)?;
12476 }
12477 struct_ser.end()
12478 }
12479}
12480impl<'de> serde::Deserialize<'de> for StreamCdcScanOptions {
12481 #[allow(deprecated)]
12482 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12483 where
12484 D: serde::Deserializer<'de>,
12485 {
12486 const FIELDS: &[&str] = &[
12487 "disable_backfill",
12488 "disableBackfill",
12489 "snapshot_barrier_interval",
12490 "snapshotBarrierInterval",
12491 "snapshot_batch_size",
12492 "snapshotBatchSize",
12493 "backfill_parallelism",
12494 "backfillParallelism",
12495 "backfill_num_rows_per_split",
12496 "backfillNumRowsPerSplit",
12497 "backfill_as_even_splits",
12498 "backfillAsEvenSplits",
12499 "backfill_split_pk_column_index",
12500 "backfillSplitPkColumnIndex",
12501 ];
12502
12503 #[allow(clippy::enum_variant_names)]
12504 enum GeneratedField {
12505 DisableBackfill,
12506 SnapshotBarrierInterval,
12507 SnapshotBatchSize,
12508 BackfillParallelism,
12509 BackfillNumRowsPerSplit,
12510 BackfillAsEvenSplits,
12511 BackfillSplitPkColumnIndex,
12512 }
12513 impl<'de> serde::Deserialize<'de> for GeneratedField {
12514 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12515 where
12516 D: serde::Deserializer<'de>,
12517 {
12518 struct GeneratedVisitor;
12519
12520 impl serde::de::Visitor<'_> for GeneratedVisitor {
12521 type Value = GeneratedField;
12522
12523 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12524 write!(formatter, "expected one of: {:?}", &FIELDS)
12525 }
12526
12527 #[allow(unused_variables)]
12528 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12529 where
12530 E: serde::de::Error,
12531 {
12532 match value {
12533 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
12534 "snapshotBarrierInterval" | "snapshot_barrier_interval" => Ok(GeneratedField::SnapshotBarrierInterval),
12535 "snapshotBatchSize" | "snapshot_batch_size" => Ok(GeneratedField::SnapshotBatchSize),
12536 "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
12537 "backfillNumRowsPerSplit" | "backfill_num_rows_per_split" => Ok(GeneratedField::BackfillNumRowsPerSplit),
12538 "backfillAsEvenSplits" | "backfill_as_even_splits" => Ok(GeneratedField::BackfillAsEvenSplits),
12539 "backfillSplitPkColumnIndex" | "backfill_split_pk_column_index" => Ok(GeneratedField::BackfillSplitPkColumnIndex),
12540 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12541 }
12542 }
12543 }
12544 deserializer.deserialize_identifier(GeneratedVisitor)
12545 }
12546 }
12547 struct GeneratedVisitor;
12548 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12549 type Value = StreamCdcScanOptions;
12550
12551 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12552 formatter.write_str("struct stream_plan.StreamCdcScanOptions")
12553 }
12554
12555 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanOptions, V::Error>
12556 where
12557 V: serde::de::MapAccess<'de>,
12558 {
12559 let mut disable_backfill__ = None;
12560 let mut snapshot_barrier_interval__ = None;
12561 let mut snapshot_batch_size__ = None;
12562 let mut backfill_parallelism__ = None;
12563 let mut backfill_num_rows_per_split__ = None;
12564 let mut backfill_as_even_splits__ = None;
12565 let mut backfill_split_pk_column_index__ = None;
12566 while let Some(k) = map_.next_key()? {
12567 match k {
12568 GeneratedField::DisableBackfill => {
12569 if disable_backfill__.is_some() {
12570 return Err(serde::de::Error::duplicate_field("disableBackfill"));
12571 }
12572 disable_backfill__ = Some(map_.next_value()?);
12573 }
12574 GeneratedField::SnapshotBarrierInterval => {
12575 if snapshot_barrier_interval__.is_some() {
12576 return Err(serde::de::Error::duplicate_field("snapshotBarrierInterval"));
12577 }
12578 snapshot_barrier_interval__ =
12579 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12580 ;
12581 }
12582 GeneratedField::SnapshotBatchSize => {
12583 if snapshot_batch_size__.is_some() {
12584 return Err(serde::de::Error::duplicate_field("snapshotBatchSize"));
12585 }
12586 snapshot_batch_size__ =
12587 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12588 ;
12589 }
12590 GeneratedField::BackfillParallelism => {
12591 if backfill_parallelism__.is_some() {
12592 return Err(serde::de::Error::duplicate_field("backfillParallelism"));
12593 }
12594 backfill_parallelism__ =
12595 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12596 ;
12597 }
12598 GeneratedField::BackfillNumRowsPerSplit => {
12599 if backfill_num_rows_per_split__.is_some() {
12600 return Err(serde::de::Error::duplicate_field("backfillNumRowsPerSplit"));
12601 }
12602 backfill_num_rows_per_split__ =
12603 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12604 ;
12605 }
12606 GeneratedField::BackfillAsEvenSplits => {
12607 if backfill_as_even_splits__.is_some() {
12608 return Err(serde::de::Error::duplicate_field("backfillAsEvenSplits"));
12609 }
12610 backfill_as_even_splits__ = Some(map_.next_value()?);
12611 }
12612 GeneratedField::BackfillSplitPkColumnIndex => {
12613 if backfill_split_pk_column_index__.is_some() {
12614 return Err(serde::de::Error::duplicate_field("backfillSplitPkColumnIndex"));
12615 }
12616 backfill_split_pk_column_index__ =
12617 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12618 ;
12619 }
12620 }
12621 }
12622 Ok(StreamCdcScanOptions {
12623 disable_backfill: disable_backfill__.unwrap_or_default(),
12624 snapshot_barrier_interval: snapshot_barrier_interval__.unwrap_or_default(),
12625 snapshot_batch_size: snapshot_batch_size__.unwrap_or_default(),
12626 backfill_parallelism: backfill_parallelism__.unwrap_or_default(),
12627 backfill_num_rows_per_split: backfill_num_rows_per_split__.unwrap_or_default(),
12628 backfill_as_even_splits: backfill_as_even_splits__.unwrap_or_default(),
12629 backfill_split_pk_column_index: backfill_split_pk_column_index__.unwrap_or_default(),
12630 })
12631 }
12632 }
12633 deserializer.deserialize_struct("stream_plan.StreamCdcScanOptions", FIELDS, GeneratedVisitor)
12634 }
12635}
12636impl serde::Serialize for StreamContext {
12637 #[allow(deprecated)]
12638 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12639 where
12640 S: serde::Serializer,
12641 {
12642 use serde::ser::SerializeStruct;
12643 let mut len = 0;
12644 if !self.timezone.is_empty() {
12645 len += 1;
12646 }
12647 if !self.config_override.is_empty() {
12648 len += 1;
12649 }
12650 if !self.adaptive_parallelism_strategy.is_empty() {
12651 len += 1;
12652 }
12653 if !self.backfill_adaptive_parallelism_strategy.is_empty() {
12654 len += 1;
12655 }
12656 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamContext", len)?;
12657 if !self.timezone.is_empty() {
12658 struct_ser.serialize_field("timezone", &self.timezone)?;
12659 }
12660 if !self.config_override.is_empty() {
12661 struct_ser.serialize_field("configOverride", &self.config_override)?;
12662 }
12663 if !self.adaptive_parallelism_strategy.is_empty() {
12664 struct_ser.serialize_field("adaptiveParallelismStrategy", &self.adaptive_parallelism_strategy)?;
12665 }
12666 if !self.backfill_adaptive_parallelism_strategy.is_empty() {
12667 struct_ser.serialize_field("backfillAdaptiveParallelismStrategy", &self.backfill_adaptive_parallelism_strategy)?;
12668 }
12669 struct_ser.end()
12670 }
12671}
12672impl<'de> serde::Deserialize<'de> for StreamContext {
12673 #[allow(deprecated)]
12674 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12675 where
12676 D: serde::Deserializer<'de>,
12677 {
12678 const FIELDS: &[&str] = &[
12679 "timezone",
12680 "config_override",
12681 "configOverride",
12682 "adaptive_parallelism_strategy",
12683 "adaptiveParallelismStrategy",
12684 "backfill_adaptive_parallelism_strategy",
12685 "backfillAdaptiveParallelismStrategy",
12686 ];
12687
12688 #[allow(clippy::enum_variant_names)]
12689 enum GeneratedField {
12690 Timezone,
12691 ConfigOverride,
12692 AdaptiveParallelismStrategy,
12693 BackfillAdaptiveParallelismStrategy,
12694 }
12695 impl<'de> serde::Deserialize<'de> for GeneratedField {
12696 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12697 where
12698 D: serde::Deserializer<'de>,
12699 {
12700 struct GeneratedVisitor;
12701
12702 impl serde::de::Visitor<'_> for GeneratedVisitor {
12703 type Value = GeneratedField;
12704
12705 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12706 write!(formatter, "expected one of: {:?}", &FIELDS)
12707 }
12708
12709 #[allow(unused_variables)]
12710 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12711 where
12712 E: serde::de::Error,
12713 {
12714 match value {
12715 "timezone" => Ok(GeneratedField::Timezone),
12716 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
12717 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
12718 "backfillAdaptiveParallelismStrategy" | "backfill_adaptive_parallelism_strategy" => Ok(GeneratedField::BackfillAdaptiveParallelismStrategy),
12719 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12720 }
12721 }
12722 }
12723 deserializer.deserialize_identifier(GeneratedVisitor)
12724 }
12725 }
12726 struct GeneratedVisitor;
12727 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12728 type Value = StreamContext;
12729
12730 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12731 formatter.write_str("struct stream_plan.StreamContext")
12732 }
12733
12734 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamContext, V::Error>
12735 where
12736 V: serde::de::MapAccess<'de>,
12737 {
12738 let mut timezone__ = None;
12739 let mut config_override__ = None;
12740 let mut adaptive_parallelism_strategy__ = None;
12741 let mut backfill_adaptive_parallelism_strategy__ = None;
12742 while let Some(k) = map_.next_key()? {
12743 match k {
12744 GeneratedField::Timezone => {
12745 if timezone__.is_some() {
12746 return Err(serde::de::Error::duplicate_field("timezone"));
12747 }
12748 timezone__ = Some(map_.next_value()?);
12749 }
12750 GeneratedField::ConfigOverride => {
12751 if config_override__.is_some() {
12752 return Err(serde::de::Error::duplicate_field("configOverride"));
12753 }
12754 config_override__ = Some(map_.next_value()?);
12755 }
12756 GeneratedField::AdaptiveParallelismStrategy => {
12757 if adaptive_parallelism_strategy__.is_some() {
12758 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
12759 }
12760 adaptive_parallelism_strategy__ = Some(map_.next_value()?);
12761 }
12762 GeneratedField::BackfillAdaptiveParallelismStrategy => {
12763 if backfill_adaptive_parallelism_strategy__.is_some() {
12764 return Err(serde::de::Error::duplicate_field("backfillAdaptiveParallelismStrategy"));
12765 }
12766 backfill_adaptive_parallelism_strategy__ = Some(map_.next_value()?);
12767 }
12768 }
12769 }
12770 Ok(StreamContext {
12771 timezone: timezone__.unwrap_or_default(),
12772 config_override: config_override__.unwrap_or_default(),
12773 adaptive_parallelism_strategy: adaptive_parallelism_strategy__.unwrap_or_default(),
12774 backfill_adaptive_parallelism_strategy: backfill_adaptive_parallelism_strategy__.unwrap_or_default(),
12775 })
12776 }
12777 }
12778 deserializer.deserialize_struct("stream_plan.StreamContext", FIELDS, GeneratedVisitor)
12779 }
12780}
12781impl serde::Serialize for StreamFragmentGraph {
12782 #[allow(deprecated)]
12783 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12784 where
12785 S: serde::Serializer,
12786 {
12787 use serde::ser::SerializeStruct;
12788 let mut len = 0;
12789 if !self.fragments.is_empty() {
12790 len += 1;
12791 }
12792 if !self.edges.is_empty() {
12793 len += 1;
12794 }
12795 if !self.dependent_table_ids.is_empty() {
12796 len += 1;
12797 }
12798 if self.table_ids_cnt != 0 {
12799 len += 1;
12800 }
12801 if self.ctx.is_some() {
12802 len += 1;
12803 }
12804 if self.parallelism.is_some() {
12805 len += 1;
12806 }
12807 if self.backfill_parallelism.is_some() {
12808 len += 1;
12809 }
12810 if self.max_parallelism != 0 {
12811 len += 1;
12812 }
12813 if self.backfill_order.is_some() {
12814 len += 1;
12815 }
12816 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph", len)?;
12817 if !self.fragments.is_empty() {
12818 struct_ser.serialize_field("fragments", &self.fragments)?;
12819 }
12820 if !self.edges.is_empty() {
12821 struct_ser.serialize_field("edges", &self.edges)?;
12822 }
12823 if !self.dependent_table_ids.is_empty() {
12824 struct_ser.serialize_field("dependentTableIds", &self.dependent_table_ids)?;
12825 }
12826 if self.table_ids_cnt != 0 {
12827 struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
12828 }
12829 if let Some(v) = self.ctx.as_ref() {
12830 struct_ser.serialize_field("ctx", v)?;
12831 }
12832 if let Some(v) = self.parallelism.as_ref() {
12833 struct_ser.serialize_field("parallelism", v)?;
12834 }
12835 if let Some(v) = self.backfill_parallelism.as_ref() {
12836 struct_ser.serialize_field("backfillParallelism", v)?;
12837 }
12838 if self.max_parallelism != 0 {
12839 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
12840 }
12841 if let Some(v) = self.backfill_order.as_ref() {
12842 struct_ser.serialize_field("backfillOrder", v)?;
12843 }
12844 struct_ser.end()
12845 }
12846}
12847impl<'de> serde::Deserialize<'de> for StreamFragmentGraph {
12848 #[allow(deprecated)]
12849 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12850 where
12851 D: serde::Deserializer<'de>,
12852 {
12853 const FIELDS: &[&str] = &[
12854 "fragments",
12855 "edges",
12856 "dependent_table_ids",
12857 "dependentTableIds",
12858 "table_ids_cnt",
12859 "tableIdsCnt",
12860 "ctx",
12861 "parallelism",
12862 "backfill_parallelism",
12863 "backfillParallelism",
12864 "max_parallelism",
12865 "maxParallelism",
12866 "backfill_order",
12867 "backfillOrder",
12868 ];
12869
12870 #[allow(clippy::enum_variant_names)]
12871 enum GeneratedField {
12872 Fragments,
12873 Edges,
12874 DependentTableIds,
12875 TableIdsCnt,
12876 Ctx,
12877 Parallelism,
12878 BackfillParallelism,
12879 MaxParallelism,
12880 BackfillOrder,
12881 }
12882 impl<'de> serde::Deserialize<'de> for GeneratedField {
12883 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12884 where
12885 D: serde::Deserializer<'de>,
12886 {
12887 struct GeneratedVisitor;
12888
12889 impl serde::de::Visitor<'_> for GeneratedVisitor {
12890 type Value = GeneratedField;
12891
12892 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12893 write!(formatter, "expected one of: {:?}", &FIELDS)
12894 }
12895
12896 #[allow(unused_variables)]
12897 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12898 where
12899 E: serde::de::Error,
12900 {
12901 match value {
12902 "fragments" => Ok(GeneratedField::Fragments),
12903 "edges" => Ok(GeneratedField::Edges),
12904 "dependentTableIds" | "dependent_table_ids" => Ok(GeneratedField::DependentTableIds),
12905 "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
12906 "ctx" => Ok(GeneratedField::Ctx),
12907 "parallelism" => Ok(GeneratedField::Parallelism),
12908 "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
12909 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
12910 "backfillOrder" | "backfill_order" => Ok(GeneratedField::BackfillOrder),
12911 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12912 }
12913 }
12914 }
12915 deserializer.deserialize_identifier(GeneratedVisitor)
12916 }
12917 }
12918 struct GeneratedVisitor;
12919 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12920 type Value = StreamFragmentGraph;
12921
12922 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12923 formatter.write_str("struct stream_plan.StreamFragmentGraph")
12924 }
12925
12926 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFragmentGraph, V::Error>
12927 where
12928 V: serde::de::MapAccess<'de>,
12929 {
12930 let mut fragments__ = None;
12931 let mut edges__ = None;
12932 let mut dependent_table_ids__ = None;
12933 let mut table_ids_cnt__ = None;
12934 let mut ctx__ = None;
12935 let mut parallelism__ = None;
12936 let mut backfill_parallelism__ = None;
12937 let mut max_parallelism__ = None;
12938 let mut backfill_order__ = None;
12939 while let Some(k) = map_.next_key()? {
12940 match k {
12941 GeneratedField::Fragments => {
12942 if fragments__.is_some() {
12943 return Err(serde::de::Error::duplicate_field("fragments"));
12944 }
12945 fragments__ = Some(
12946 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
12947 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
12948 );
12949 }
12950 GeneratedField::Edges => {
12951 if edges__.is_some() {
12952 return Err(serde::de::Error::duplicate_field("edges"));
12953 }
12954 edges__ = Some(map_.next_value()?);
12955 }
12956 GeneratedField::DependentTableIds => {
12957 if dependent_table_ids__.is_some() {
12958 return Err(serde::de::Error::duplicate_field("dependentTableIds"));
12959 }
12960 dependent_table_ids__ =
12961 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12962 .into_iter().map(|x| x.0).collect())
12963 ;
12964 }
12965 GeneratedField::TableIdsCnt => {
12966 if table_ids_cnt__.is_some() {
12967 return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
12968 }
12969 table_ids_cnt__ =
12970 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12971 ;
12972 }
12973 GeneratedField::Ctx => {
12974 if ctx__.is_some() {
12975 return Err(serde::de::Error::duplicate_field("ctx"));
12976 }
12977 ctx__ = map_.next_value()?;
12978 }
12979 GeneratedField::Parallelism => {
12980 if parallelism__.is_some() {
12981 return Err(serde::de::Error::duplicate_field("parallelism"));
12982 }
12983 parallelism__ = map_.next_value()?;
12984 }
12985 GeneratedField::BackfillParallelism => {
12986 if backfill_parallelism__.is_some() {
12987 return Err(serde::de::Error::duplicate_field("backfillParallelism"));
12988 }
12989 backfill_parallelism__ = map_.next_value()?;
12990 }
12991 GeneratedField::MaxParallelism => {
12992 if max_parallelism__.is_some() {
12993 return Err(serde::de::Error::duplicate_field("maxParallelism"));
12994 }
12995 max_parallelism__ =
12996 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12997 ;
12998 }
12999 GeneratedField::BackfillOrder => {
13000 if backfill_order__.is_some() {
13001 return Err(serde::de::Error::duplicate_field("backfillOrder"));
13002 }
13003 backfill_order__ = map_.next_value()?;
13004 }
13005 }
13006 }
13007 Ok(StreamFragmentGraph {
13008 fragments: fragments__.unwrap_or_default(),
13009 edges: edges__.unwrap_or_default(),
13010 dependent_table_ids: dependent_table_ids__.unwrap_or_default(),
13011 table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
13012 ctx: ctx__,
13013 parallelism: parallelism__,
13014 backfill_parallelism: backfill_parallelism__,
13015 max_parallelism: max_parallelism__.unwrap_or_default(),
13016 backfill_order: backfill_order__,
13017 })
13018 }
13019 }
13020 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph", FIELDS, GeneratedVisitor)
13021 }
13022}
13023impl serde::Serialize for stream_fragment_graph::Parallelism {
13024 #[allow(deprecated)]
13025 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13026 where
13027 S: serde::Serializer,
13028 {
13029 use serde::ser::SerializeStruct;
13030 let mut len = 0;
13031 if self.parallelism != 0 {
13032 len += 1;
13033 }
13034 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.Parallelism", len)?;
13035 if self.parallelism != 0 {
13036 #[allow(clippy::needless_borrow)]
13037 #[allow(clippy::needless_borrows_for_generic_args)]
13038 struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
13039 }
13040 struct_ser.end()
13041 }
13042}
13043impl<'de> serde::Deserialize<'de> for stream_fragment_graph::Parallelism {
13044 #[allow(deprecated)]
13045 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13046 where
13047 D: serde::Deserializer<'de>,
13048 {
13049 const FIELDS: &[&str] = &[
13050 "parallelism",
13051 ];
13052
13053 #[allow(clippy::enum_variant_names)]
13054 enum GeneratedField {
13055 Parallelism,
13056 }
13057 impl<'de> serde::Deserialize<'de> for GeneratedField {
13058 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13059 where
13060 D: serde::Deserializer<'de>,
13061 {
13062 struct GeneratedVisitor;
13063
13064 impl serde::de::Visitor<'_> for GeneratedVisitor {
13065 type Value = GeneratedField;
13066
13067 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13068 write!(formatter, "expected one of: {:?}", &FIELDS)
13069 }
13070
13071 #[allow(unused_variables)]
13072 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13073 where
13074 E: serde::de::Error,
13075 {
13076 match value {
13077 "parallelism" => Ok(GeneratedField::Parallelism),
13078 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13079 }
13080 }
13081 }
13082 deserializer.deserialize_identifier(GeneratedVisitor)
13083 }
13084 }
13085 struct GeneratedVisitor;
13086 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13087 type Value = stream_fragment_graph::Parallelism;
13088
13089 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13090 formatter.write_str("struct stream_plan.StreamFragmentGraph.Parallelism")
13091 }
13092
13093 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::Parallelism, V::Error>
13094 where
13095 V: serde::de::MapAccess<'de>,
13096 {
13097 let mut parallelism__ = None;
13098 while let Some(k) = map_.next_key()? {
13099 match k {
13100 GeneratedField::Parallelism => {
13101 if parallelism__.is_some() {
13102 return Err(serde::de::Error::duplicate_field("parallelism"));
13103 }
13104 parallelism__ =
13105 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13106 ;
13107 }
13108 }
13109 }
13110 Ok(stream_fragment_graph::Parallelism {
13111 parallelism: parallelism__.unwrap_or_default(),
13112 })
13113 }
13114 }
13115 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.Parallelism", FIELDS, GeneratedVisitor)
13116 }
13117}
13118impl serde::Serialize for stream_fragment_graph::StreamFragment {
13119 #[allow(deprecated)]
13120 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13121 where
13122 S: serde::Serializer,
13123 {
13124 use serde::ser::SerializeStruct;
13125 let mut len = 0;
13126 if self.fragment_id != 0 {
13127 len += 1;
13128 }
13129 if self.node.is_some() {
13130 len += 1;
13131 }
13132 if self.fragment_type_mask != 0 {
13133 len += 1;
13134 }
13135 if self.requires_singleton {
13136 len += 1;
13137 }
13138 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", len)?;
13139 if self.fragment_id != 0 {
13140 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
13141 }
13142 if let Some(v) = self.node.as_ref() {
13143 struct_ser.serialize_field("node", v)?;
13144 }
13145 if self.fragment_type_mask != 0 {
13146 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
13147 }
13148 if self.requires_singleton {
13149 struct_ser.serialize_field("requiresSingleton", &self.requires_singleton)?;
13150 }
13151 struct_ser.end()
13152 }
13153}
13154impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragment {
13155 #[allow(deprecated)]
13156 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13157 where
13158 D: serde::Deserializer<'de>,
13159 {
13160 const FIELDS: &[&str] = &[
13161 "fragment_id",
13162 "fragmentId",
13163 "node",
13164 "fragment_type_mask",
13165 "fragmentTypeMask",
13166 "requires_singleton",
13167 "requiresSingleton",
13168 ];
13169
13170 #[allow(clippy::enum_variant_names)]
13171 enum GeneratedField {
13172 FragmentId,
13173 Node,
13174 FragmentTypeMask,
13175 RequiresSingleton,
13176 }
13177 impl<'de> serde::Deserialize<'de> for GeneratedField {
13178 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13179 where
13180 D: serde::Deserializer<'de>,
13181 {
13182 struct GeneratedVisitor;
13183
13184 impl serde::de::Visitor<'_> for GeneratedVisitor {
13185 type Value = GeneratedField;
13186
13187 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13188 write!(formatter, "expected one of: {:?}", &FIELDS)
13189 }
13190
13191 #[allow(unused_variables)]
13192 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13193 where
13194 E: serde::de::Error,
13195 {
13196 match value {
13197 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
13198 "node" => Ok(GeneratedField::Node),
13199 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
13200 "requiresSingleton" | "requires_singleton" => Ok(GeneratedField::RequiresSingleton),
13201 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13202 }
13203 }
13204 }
13205 deserializer.deserialize_identifier(GeneratedVisitor)
13206 }
13207 }
13208 struct GeneratedVisitor;
13209 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13210 type Value = stream_fragment_graph::StreamFragment;
13211
13212 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13213 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragment")
13214 }
13215
13216 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragment, V::Error>
13217 where
13218 V: serde::de::MapAccess<'de>,
13219 {
13220 let mut fragment_id__ = None;
13221 let mut node__ = None;
13222 let mut fragment_type_mask__ = None;
13223 let mut requires_singleton__ = None;
13224 while let Some(k) = map_.next_key()? {
13225 match k {
13226 GeneratedField::FragmentId => {
13227 if fragment_id__.is_some() {
13228 return Err(serde::de::Error::duplicate_field("fragmentId"));
13229 }
13230 fragment_id__ =
13231 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13232 ;
13233 }
13234 GeneratedField::Node => {
13235 if node__.is_some() {
13236 return Err(serde::de::Error::duplicate_field("node"));
13237 }
13238 node__ = map_.next_value()?;
13239 }
13240 GeneratedField::FragmentTypeMask => {
13241 if fragment_type_mask__.is_some() {
13242 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
13243 }
13244 fragment_type_mask__ =
13245 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13246 ;
13247 }
13248 GeneratedField::RequiresSingleton => {
13249 if requires_singleton__.is_some() {
13250 return Err(serde::de::Error::duplicate_field("requiresSingleton"));
13251 }
13252 requires_singleton__ = Some(map_.next_value()?);
13253 }
13254 }
13255 }
13256 Ok(stream_fragment_graph::StreamFragment {
13257 fragment_id: fragment_id__.unwrap_or_default(),
13258 node: node__,
13259 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
13260 requires_singleton: requires_singleton__.unwrap_or_default(),
13261 })
13262 }
13263 }
13264 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", FIELDS, GeneratedVisitor)
13265 }
13266}
13267impl serde::Serialize for stream_fragment_graph::StreamFragmentEdge {
13268 #[allow(deprecated)]
13269 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13270 where
13271 S: serde::Serializer,
13272 {
13273 use serde::ser::SerializeStruct;
13274 let mut len = 0;
13275 if self.dispatch_strategy.is_some() {
13276 len += 1;
13277 }
13278 if self.link_id != 0 {
13279 len += 1;
13280 }
13281 if self.upstream_id != 0 {
13282 len += 1;
13283 }
13284 if self.downstream_id != 0 {
13285 len += 1;
13286 }
13287 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", len)?;
13288 if let Some(v) = self.dispatch_strategy.as_ref() {
13289 struct_ser.serialize_field("dispatchStrategy", v)?;
13290 }
13291 if self.link_id != 0 {
13292 #[allow(clippy::needless_borrow)]
13293 #[allow(clippy::needless_borrows_for_generic_args)]
13294 struct_ser.serialize_field("linkId", ToString::to_string(&self.link_id).as_str())?;
13295 }
13296 if self.upstream_id != 0 {
13297 struct_ser.serialize_field("upstreamId", &self.upstream_id)?;
13298 }
13299 if self.downstream_id != 0 {
13300 struct_ser.serialize_field("downstreamId", &self.downstream_id)?;
13301 }
13302 struct_ser.end()
13303 }
13304}
13305impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragmentEdge {
13306 #[allow(deprecated)]
13307 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13308 where
13309 D: serde::Deserializer<'de>,
13310 {
13311 const FIELDS: &[&str] = &[
13312 "dispatch_strategy",
13313 "dispatchStrategy",
13314 "link_id",
13315 "linkId",
13316 "upstream_id",
13317 "upstreamId",
13318 "downstream_id",
13319 "downstreamId",
13320 ];
13321
13322 #[allow(clippy::enum_variant_names)]
13323 enum GeneratedField {
13324 DispatchStrategy,
13325 LinkId,
13326 UpstreamId,
13327 DownstreamId,
13328 }
13329 impl<'de> serde::Deserialize<'de> for GeneratedField {
13330 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13331 where
13332 D: serde::Deserializer<'de>,
13333 {
13334 struct GeneratedVisitor;
13335
13336 impl serde::de::Visitor<'_> for GeneratedVisitor {
13337 type Value = GeneratedField;
13338
13339 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13340 write!(formatter, "expected one of: {:?}", &FIELDS)
13341 }
13342
13343 #[allow(unused_variables)]
13344 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13345 where
13346 E: serde::de::Error,
13347 {
13348 match value {
13349 "dispatchStrategy" | "dispatch_strategy" => Ok(GeneratedField::DispatchStrategy),
13350 "linkId" | "link_id" => Ok(GeneratedField::LinkId),
13351 "upstreamId" | "upstream_id" => Ok(GeneratedField::UpstreamId),
13352 "downstreamId" | "downstream_id" => Ok(GeneratedField::DownstreamId),
13353 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13354 }
13355 }
13356 }
13357 deserializer.deserialize_identifier(GeneratedVisitor)
13358 }
13359 }
13360 struct GeneratedVisitor;
13361 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13362 type Value = stream_fragment_graph::StreamFragmentEdge;
13363
13364 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13365 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragmentEdge")
13366 }
13367
13368 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragmentEdge, V::Error>
13369 where
13370 V: serde::de::MapAccess<'de>,
13371 {
13372 let mut dispatch_strategy__ = None;
13373 let mut link_id__ = None;
13374 let mut upstream_id__ = None;
13375 let mut downstream_id__ = None;
13376 while let Some(k) = map_.next_key()? {
13377 match k {
13378 GeneratedField::DispatchStrategy => {
13379 if dispatch_strategy__.is_some() {
13380 return Err(serde::de::Error::duplicate_field("dispatchStrategy"));
13381 }
13382 dispatch_strategy__ = map_.next_value()?;
13383 }
13384 GeneratedField::LinkId => {
13385 if link_id__.is_some() {
13386 return Err(serde::de::Error::duplicate_field("linkId"));
13387 }
13388 link_id__ =
13389 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13390 ;
13391 }
13392 GeneratedField::UpstreamId => {
13393 if upstream_id__.is_some() {
13394 return Err(serde::de::Error::duplicate_field("upstreamId"));
13395 }
13396 upstream_id__ =
13397 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13398 ;
13399 }
13400 GeneratedField::DownstreamId => {
13401 if downstream_id__.is_some() {
13402 return Err(serde::de::Error::duplicate_field("downstreamId"));
13403 }
13404 downstream_id__ =
13405 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13406 ;
13407 }
13408 }
13409 }
13410 Ok(stream_fragment_graph::StreamFragmentEdge {
13411 dispatch_strategy: dispatch_strategy__,
13412 link_id: link_id__.unwrap_or_default(),
13413 upstream_id: upstream_id__.unwrap_or_default(),
13414 downstream_id: downstream_id__.unwrap_or_default(),
13415 })
13416 }
13417 }
13418 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", FIELDS, GeneratedVisitor)
13419 }
13420}
13421impl serde::Serialize for StreamFsFetch {
13422 #[allow(deprecated)]
13423 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13424 where
13425 S: serde::Serializer,
13426 {
13427 use serde::ser::SerializeStruct;
13428 let mut len = 0;
13429 if self.source_id != 0 {
13430 len += 1;
13431 }
13432 if self.state_table.is_some() {
13433 len += 1;
13434 }
13435 if self.row_id_index.is_some() {
13436 len += 1;
13437 }
13438 if !self.columns.is_empty() {
13439 len += 1;
13440 }
13441 if !self.with_properties.is_empty() {
13442 len += 1;
13443 }
13444 if self.info.is_some() {
13445 len += 1;
13446 }
13447 if !self.source_name.is_empty() {
13448 len += 1;
13449 }
13450 if self.rate_limit.is_some() {
13451 len += 1;
13452 }
13453 if !self.secret_refs.is_empty() {
13454 len += 1;
13455 }
13456 if self.refresh_mode.is_some() {
13457 len += 1;
13458 }
13459 if self.associated_table_id.is_some() {
13460 len += 1;
13461 }
13462 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetch", len)?;
13463 if self.source_id != 0 {
13464 struct_ser.serialize_field("sourceId", &self.source_id)?;
13465 }
13466 if let Some(v) = self.state_table.as_ref() {
13467 struct_ser.serialize_field("stateTable", v)?;
13468 }
13469 if let Some(v) = self.row_id_index.as_ref() {
13470 struct_ser.serialize_field("rowIdIndex", v)?;
13471 }
13472 if !self.columns.is_empty() {
13473 struct_ser.serialize_field("columns", &self.columns)?;
13474 }
13475 if !self.with_properties.is_empty() {
13476 struct_ser.serialize_field("withProperties", &self.with_properties)?;
13477 }
13478 if let Some(v) = self.info.as_ref() {
13479 struct_ser.serialize_field("info", v)?;
13480 }
13481 if !self.source_name.is_empty() {
13482 struct_ser.serialize_field("sourceName", &self.source_name)?;
13483 }
13484 if let Some(v) = self.rate_limit.as_ref() {
13485 struct_ser.serialize_field("rateLimit", v)?;
13486 }
13487 if !self.secret_refs.is_empty() {
13488 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
13489 }
13490 if let Some(v) = self.refresh_mode.as_ref() {
13491 struct_ser.serialize_field("refreshMode", v)?;
13492 }
13493 if let Some(v) = self.associated_table_id.as_ref() {
13494 struct_ser.serialize_field("associatedTableId", v)?;
13495 }
13496 struct_ser.end()
13497 }
13498}
13499impl<'de> serde::Deserialize<'de> for StreamFsFetch {
13500 #[allow(deprecated)]
13501 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13502 where
13503 D: serde::Deserializer<'de>,
13504 {
13505 const FIELDS: &[&str] = &[
13506 "source_id",
13507 "sourceId",
13508 "state_table",
13509 "stateTable",
13510 "row_id_index",
13511 "rowIdIndex",
13512 "columns",
13513 "with_properties",
13514 "withProperties",
13515 "info",
13516 "source_name",
13517 "sourceName",
13518 "rate_limit",
13519 "rateLimit",
13520 "secret_refs",
13521 "secretRefs",
13522 "refresh_mode",
13523 "refreshMode",
13524 "associated_table_id",
13525 "associatedTableId",
13526 ];
13527
13528 #[allow(clippy::enum_variant_names)]
13529 enum GeneratedField {
13530 SourceId,
13531 StateTable,
13532 RowIdIndex,
13533 Columns,
13534 WithProperties,
13535 Info,
13536 SourceName,
13537 RateLimit,
13538 SecretRefs,
13539 RefreshMode,
13540 AssociatedTableId,
13541 }
13542 impl<'de> serde::Deserialize<'de> for GeneratedField {
13543 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13544 where
13545 D: serde::Deserializer<'de>,
13546 {
13547 struct GeneratedVisitor;
13548
13549 impl serde::de::Visitor<'_> for GeneratedVisitor {
13550 type Value = GeneratedField;
13551
13552 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13553 write!(formatter, "expected one of: {:?}", &FIELDS)
13554 }
13555
13556 #[allow(unused_variables)]
13557 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13558 where
13559 E: serde::de::Error,
13560 {
13561 match value {
13562 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
13563 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
13564 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
13565 "columns" => Ok(GeneratedField::Columns),
13566 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
13567 "info" => Ok(GeneratedField::Info),
13568 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
13569 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
13570 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
13571 "refreshMode" | "refresh_mode" => Ok(GeneratedField::RefreshMode),
13572 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
13573 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13574 }
13575 }
13576 }
13577 deserializer.deserialize_identifier(GeneratedVisitor)
13578 }
13579 }
13580 struct GeneratedVisitor;
13581 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13582 type Value = StreamFsFetch;
13583
13584 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13585 formatter.write_str("struct stream_plan.StreamFsFetch")
13586 }
13587
13588 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetch, V::Error>
13589 where
13590 V: serde::de::MapAccess<'de>,
13591 {
13592 let mut source_id__ = None;
13593 let mut state_table__ = None;
13594 let mut row_id_index__ = None;
13595 let mut columns__ = None;
13596 let mut with_properties__ = None;
13597 let mut info__ = None;
13598 let mut source_name__ = None;
13599 let mut rate_limit__ = None;
13600 let mut secret_refs__ = None;
13601 let mut refresh_mode__ = None;
13602 let mut associated_table_id__ = None;
13603 while let Some(k) = map_.next_key()? {
13604 match k {
13605 GeneratedField::SourceId => {
13606 if source_id__.is_some() {
13607 return Err(serde::de::Error::duplicate_field("sourceId"));
13608 }
13609 source_id__ =
13610 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13611 ;
13612 }
13613 GeneratedField::StateTable => {
13614 if state_table__.is_some() {
13615 return Err(serde::de::Error::duplicate_field("stateTable"));
13616 }
13617 state_table__ = map_.next_value()?;
13618 }
13619 GeneratedField::RowIdIndex => {
13620 if row_id_index__.is_some() {
13621 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
13622 }
13623 row_id_index__ =
13624 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13625 ;
13626 }
13627 GeneratedField::Columns => {
13628 if columns__.is_some() {
13629 return Err(serde::de::Error::duplicate_field("columns"));
13630 }
13631 columns__ = Some(map_.next_value()?);
13632 }
13633 GeneratedField::WithProperties => {
13634 if with_properties__.is_some() {
13635 return Err(serde::de::Error::duplicate_field("withProperties"));
13636 }
13637 with_properties__ = Some(
13638 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13639 );
13640 }
13641 GeneratedField::Info => {
13642 if info__.is_some() {
13643 return Err(serde::de::Error::duplicate_field("info"));
13644 }
13645 info__ = map_.next_value()?;
13646 }
13647 GeneratedField::SourceName => {
13648 if source_name__.is_some() {
13649 return Err(serde::de::Error::duplicate_field("sourceName"));
13650 }
13651 source_name__ = Some(map_.next_value()?);
13652 }
13653 GeneratedField::RateLimit => {
13654 if rate_limit__.is_some() {
13655 return Err(serde::de::Error::duplicate_field("rateLimit"));
13656 }
13657 rate_limit__ =
13658 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13659 ;
13660 }
13661 GeneratedField::SecretRefs => {
13662 if secret_refs__.is_some() {
13663 return Err(serde::de::Error::duplicate_field("secretRefs"));
13664 }
13665 secret_refs__ = Some(
13666 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13667 );
13668 }
13669 GeneratedField::RefreshMode => {
13670 if refresh_mode__.is_some() {
13671 return Err(serde::de::Error::duplicate_field("refreshMode"));
13672 }
13673 refresh_mode__ = map_.next_value()?;
13674 }
13675 GeneratedField::AssociatedTableId => {
13676 if associated_table_id__.is_some() {
13677 return Err(serde::de::Error::duplicate_field("associatedTableId"));
13678 }
13679 associated_table_id__ =
13680 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13681 ;
13682 }
13683 }
13684 }
13685 Ok(StreamFsFetch {
13686 source_id: source_id__.unwrap_or_default(),
13687 state_table: state_table__,
13688 row_id_index: row_id_index__,
13689 columns: columns__.unwrap_or_default(),
13690 with_properties: with_properties__.unwrap_or_default(),
13691 info: info__,
13692 source_name: source_name__.unwrap_or_default(),
13693 rate_limit: rate_limit__,
13694 secret_refs: secret_refs__.unwrap_or_default(),
13695 refresh_mode: refresh_mode__,
13696 associated_table_id: associated_table_id__,
13697 })
13698 }
13699 }
13700 deserializer.deserialize_struct("stream_plan.StreamFsFetch", FIELDS, GeneratedVisitor)
13701 }
13702}
13703impl serde::Serialize for StreamFsFetchNode {
13704 #[allow(deprecated)]
13705 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13706 where
13707 S: serde::Serializer,
13708 {
13709 use serde::ser::SerializeStruct;
13710 let mut len = 0;
13711 if self.node_inner.is_some() {
13712 len += 1;
13713 }
13714 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetchNode", len)?;
13715 if let Some(v) = self.node_inner.as_ref() {
13716 struct_ser.serialize_field("nodeInner", v)?;
13717 }
13718 struct_ser.end()
13719 }
13720}
13721impl<'de> serde::Deserialize<'de> for StreamFsFetchNode {
13722 #[allow(deprecated)]
13723 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13724 where
13725 D: serde::Deserializer<'de>,
13726 {
13727 const FIELDS: &[&str] = &[
13728 "node_inner",
13729 "nodeInner",
13730 ];
13731
13732 #[allow(clippy::enum_variant_names)]
13733 enum GeneratedField {
13734 NodeInner,
13735 }
13736 impl<'de> serde::Deserialize<'de> for GeneratedField {
13737 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13738 where
13739 D: serde::Deserializer<'de>,
13740 {
13741 struct GeneratedVisitor;
13742
13743 impl serde::de::Visitor<'_> for GeneratedVisitor {
13744 type Value = GeneratedField;
13745
13746 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13747 write!(formatter, "expected one of: {:?}", &FIELDS)
13748 }
13749
13750 #[allow(unused_variables)]
13751 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13752 where
13753 E: serde::de::Error,
13754 {
13755 match value {
13756 "nodeInner" | "node_inner" => Ok(GeneratedField::NodeInner),
13757 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13758 }
13759 }
13760 }
13761 deserializer.deserialize_identifier(GeneratedVisitor)
13762 }
13763 }
13764 struct GeneratedVisitor;
13765 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13766 type Value = StreamFsFetchNode;
13767
13768 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13769 formatter.write_str("struct stream_plan.StreamFsFetchNode")
13770 }
13771
13772 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetchNode, V::Error>
13773 where
13774 V: serde::de::MapAccess<'de>,
13775 {
13776 let mut node_inner__ = None;
13777 while let Some(k) = map_.next_key()? {
13778 match k {
13779 GeneratedField::NodeInner => {
13780 if node_inner__.is_some() {
13781 return Err(serde::de::Error::duplicate_field("nodeInner"));
13782 }
13783 node_inner__ = map_.next_value()?;
13784 }
13785 }
13786 }
13787 Ok(StreamFsFetchNode {
13788 node_inner: node_inner__,
13789 })
13790 }
13791 }
13792 deserializer.deserialize_struct("stream_plan.StreamFsFetchNode", FIELDS, GeneratedVisitor)
13793 }
13794}
13795impl serde::Serialize for StreamMessage {
13796 #[allow(deprecated)]
13797 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13798 where
13799 S: serde::Serializer,
13800 {
13801 use serde::ser::SerializeStruct;
13802 let mut len = 0;
13803 if self.stream_message.is_some() {
13804 len += 1;
13805 }
13806 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessage", len)?;
13807 if let Some(v) = self.stream_message.as_ref() {
13808 match v {
13809 stream_message::StreamMessage::StreamChunk(v) => {
13810 struct_ser.serialize_field("streamChunk", v)?;
13811 }
13812 stream_message::StreamMessage::Barrier(v) => {
13813 struct_ser.serialize_field("barrier", v)?;
13814 }
13815 stream_message::StreamMessage::Watermark(v) => {
13816 struct_ser.serialize_field("watermark", v)?;
13817 }
13818 }
13819 }
13820 struct_ser.end()
13821 }
13822}
13823impl<'de> serde::Deserialize<'de> for StreamMessage {
13824 #[allow(deprecated)]
13825 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13826 where
13827 D: serde::Deserializer<'de>,
13828 {
13829 const FIELDS: &[&str] = &[
13830 "stream_chunk",
13831 "streamChunk",
13832 "barrier",
13833 "watermark",
13834 ];
13835
13836 #[allow(clippy::enum_variant_names)]
13837 enum GeneratedField {
13838 StreamChunk,
13839 Barrier,
13840 Watermark,
13841 }
13842 impl<'de> serde::Deserialize<'de> for GeneratedField {
13843 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13844 where
13845 D: serde::Deserializer<'de>,
13846 {
13847 struct GeneratedVisitor;
13848
13849 impl serde::de::Visitor<'_> for GeneratedVisitor {
13850 type Value = GeneratedField;
13851
13852 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13853 write!(formatter, "expected one of: {:?}", &FIELDS)
13854 }
13855
13856 #[allow(unused_variables)]
13857 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13858 where
13859 E: serde::de::Error,
13860 {
13861 match value {
13862 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
13863 "barrier" => Ok(GeneratedField::Barrier),
13864 "watermark" => Ok(GeneratedField::Watermark),
13865 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13866 }
13867 }
13868 }
13869 deserializer.deserialize_identifier(GeneratedVisitor)
13870 }
13871 }
13872 struct GeneratedVisitor;
13873 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13874 type Value = StreamMessage;
13875
13876 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13877 formatter.write_str("struct stream_plan.StreamMessage")
13878 }
13879
13880 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessage, V::Error>
13881 where
13882 V: serde::de::MapAccess<'de>,
13883 {
13884 let mut stream_message__ = None;
13885 while let Some(k) = map_.next_key()? {
13886 match k {
13887 GeneratedField::StreamChunk => {
13888 if stream_message__.is_some() {
13889 return Err(serde::de::Error::duplicate_field("streamChunk"));
13890 }
13891 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::StreamChunk)
13892;
13893 }
13894 GeneratedField::Barrier => {
13895 if stream_message__.is_some() {
13896 return Err(serde::de::Error::duplicate_field("barrier"));
13897 }
13898 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Barrier)
13899;
13900 }
13901 GeneratedField::Watermark => {
13902 if stream_message__.is_some() {
13903 return Err(serde::de::Error::duplicate_field("watermark"));
13904 }
13905 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Watermark)
13906;
13907 }
13908 }
13909 }
13910 Ok(StreamMessage {
13911 stream_message: stream_message__,
13912 })
13913 }
13914 }
13915 deserializer.deserialize_struct("stream_plan.StreamMessage", FIELDS, GeneratedVisitor)
13916 }
13917}
13918impl serde::Serialize for StreamMessageBatch {
13919 #[allow(deprecated)]
13920 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13921 where
13922 S: serde::Serializer,
13923 {
13924 use serde::ser::SerializeStruct;
13925 let mut len = 0;
13926 if self.stream_message_batch.is_some() {
13927 len += 1;
13928 }
13929 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch", len)?;
13930 if let Some(v) = self.stream_message_batch.as_ref() {
13931 match v {
13932 stream_message_batch::StreamMessageBatch::StreamChunk(v) => {
13933 struct_ser.serialize_field("streamChunk", v)?;
13934 }
13935 stream_message_batch::StreamMessageBatch::BarrierBatch(v) => {
13936 struct_ser.serialize_field("barrierBatch", v)?;
13937 }
13938 stream_message_batch::StreamMessageBatch::Watermark(v) => {
13939 struct_ser.serialize_field("watermark", v)?;
13940 }
13941 }
13942 }
13943 struct_ser.end()
13944 }
13945}
13946impl<'de> serde::Deserialize<'de> for StreamMessageBatch {
13947 #[allow(deprecated)]
13948 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13949 where
13950 D: serde::Deserializer<'de>,
13951 {
13952 const FIELDS: &[&str] = &[
13953 "stream_chunk",
13954 "streamChunk",
13955 "barrier_batch",
13956 "barrierBatch",
13957 "watermark",
13958 ];
13959
13960 #[allow(clippy::enum_variant_names)]
13961 enum GeneratedField {
13962 StreamChunk,
13963 BarrierBatch,
13964 Watermark,
13965 }
13966 impl<'de> serde::Deserialize<'de> for GeneratedField {
13967 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13968 where
13969 D: serde::Deserializer<'de>,
13970 {
13971 struct GeneratedVisitor;
13972
13973 impl serde::de::Visitor<'_> for GeneratedVisitor {
13974 type Value = GeneratedField;
13975
13976 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13977 write!(formatter, "expected one of: {:?}", &FIELDS)
13978 }
13979
13980 #[allow(unused_variables)]
13981 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13982 where
13983 E: serde::de::Error,
13984 {
13985 match value {
13986 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
13987 "barrierBatch" | "barrier_batch" => Ok(GeneratedField::BarrierBatch),
13988 "watermark" => Ok(GeneratedField::Watermark),
13989 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13990 }
13991 }
13992 }
13993 deserializer.deserialize_identifier(GeneratedVisitor)
13994 }
13995 }
13996 struct GeneratedVisitor;
13997 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13998 type Value = StreamMessageBatch;
13999
14000 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14001 formatter.write_str("struct stream_plan.StreamMessageBatch")
14002 }
14003
14004 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessageBatch, V::Error>
14005 where
14006 V: serde::de::MapAccess<'de>,
14007 {
14008 let mut stream_message_batch__ = None;
14009 while let Some(k) = map_.next_key()? {
14010 match k {
14011 GeneratedField::StreamChunk => {
14012 if stream_message_batch__.is_some() {
14013 return Err(serde::de::Error::duplicate_field("streamChunk"));
14014 }
14015 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::StreamChunk)
14016;
14017 }
14018 GeneratedField::BarrierBatch => {
14019 if stream_message_batch__.is_some() {
14020 return Err(serde::de::Error::duplicate_field("barrierBatch"));
14021 }
14022 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::BarrierBatch)
14023;
14024 }
14025 GeneratedField::Watermark => {
14026 if stream_message_batch__.is_some() {
14027 return Err(serde::de::Error::duplicate_field("watermark"));
14028 }
14029 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::Watermark)
14030;
14031 }
14032 }
14033 }
14034 Ok(StreamMessageBatch {
14035 stream_message_batch: stream_message_batch__,
14036 })
14037 }
14038 }
14039 deserializer.deserialize_struct("stream_plan.StreamMessageBatch", FIELDS, GeneratedVisitor)
14040 }
14041}
14042impl serde::Serialize for stream_message_batch::BarrierBatch {
14043 #[allow(deprecated)]
14044 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14045 where
14046 S: serde::Serializer,
14047 {
14048 use serde::ser::SerializeStruct;
14049 let mut len = 0;
14050 if !self.barriers.is_empty() {
14051 len += 1;
14052 }
14053 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", len)?;
14054 if !self.barriers.is_empty() {
14055 struct_ser.serialize_field("barriers", &self.barriers)?;
14056 }
14057 struct_ser.end()
14058 }
14059}
14060impl<'de> serde::Deserialize<'de> for stream_message_batch::BarrierBatch {
14061 #[allow(deprecated)]
14062 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14063 where
14064 D: serde::Deserializer<'de>,
14065 {
14066 const FIELDS: &[&str] = &[
14067 "barriers",
14068 ];
14069
14070 #[allow(clippy::enum_variant_names)]
14071 enum GeneratedField {
14072 Barriers,
14073 }
14074 impl<'de> serde::Deserialize<'de> for GeneratedField {
14075 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14076 where
14077 D: serde::Deserializer<'de>,
14078 {
14079 struct GeneratedVisitor;
14080
14081 impl serde::de::Visitor<'_> for GeneratedVisitor {
14082 type Value = GeneratedField;
14083
14084 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14085 write!(formatter, "expected one of: {:?}", &FIELDS)
14086 }
14087
14088 #[allow(unused_variables)]
14089 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14090 where
14091 E: serde::de::Error,
14092 {
14093 match value {
14094 "barriers" => Ok(GeneratedField::Barriers),
14095 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14096 }
14097 }
14098 }
14099 deserializer.deserialize_identifier(GeneratedVisitor)
14100 }
14101 }
14102 struct GeneratedVisitor;
14103 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14104 type Value = stream_message_batch::BarrierBatch;
14105
14106 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14107 formatter.write_str("struct stream_plan.StreamMessageBatch.BarrierBatch")
14108 }
14109
14110 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_message_batch::BarrierBatch, V::Error>
14111 where
14112 V: serde::de::MapAccess<'de>,
14113 {
14114 let mut barriers__ = None;
14115 while let Some(k) = map_.next_key()? {
14116 match k {
14117 GeneratedField::Barriers => {
14118 if barriers__.is_some() {
14119 return Err(serde::de::Error::duplicate_field("barriers"));
14120 }
14121 barriers__ = Some(map_.next_value()?);
14122 }
14123 }
14124 }
14125 Ok(stream_message_batch::BarrierBatch {
14126 barriers: barriers__.unwrap_or_default(),
14127 })
14128 }
14129 }
14130 deserializer.deserialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", FIELDS, GeneratedVisitor)
14131 }
14132}
14133impl serde::Serialize for StreamNode {
14134 #[allow(deprecated)]
14135 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14136 where
14137 S: serde::Serializer,
14138 {
14139 use serde::ser::SerializeStruct;
14140 let mut len = 0;
14141 if self.operator_id != 0 {
14142 len += 1;
14143 }
14144 if !self.input.is_empty() {
14145 len += 1;
14146 }
14147 if !self.stream_key.is_empty() {
14148 len += 1;
14149 }
14150 if self.stream_kind != 0 {
14151 len += 1;
14152 }
14153 if !self.identity.is_empty() {
14154 len += 1;
14155 }
14156 if !self.fields.is_empty() {
14157 len += 1;
14158 }
14159 if self.node_body.is_some() {
14160 len += 1;
14161 }
14162 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamNode", len)?;
14163 if self.operator_id != 0 {
14164 #[allow(clippy::needless_borrow)]
14165 #[allow(clippy::needless_borrows_for_generic_args)]
14166 struct_ser.serialize_field("operatorId", ToString::to_string(&self.operator_id).as_str())?;
14167 }
14168 if !self.input.is_empty() {
14169 struct_ser.serialize_field("input", &self.input)?;
14170 }
14171 if !self.stream_key.is_empty() {
14172 struct_ser.serialize_field("streamKey", &self.stream_key)?;
14173 }
14174 if self.stream_kind != 0 {
14175 let v = stream_node::StreamKind::try_from(self.stream_kind)
14176 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_kind)))?;
14177 struct_ser.serialize_field("streamKind", &v)?;
14178 }
14179 if !self.identity.is_empty() {
14180 struct_ser.serialize_field("identity", &self.identity)?;
14181 }
14182 if !self.fields.is_empty() {
14183 struct_ser.serialize_field("fields", &self.fields)?;
14184 }
14185 if let Some(v) = self.node_body.as_ref() {
14186 match v {
14187 stream_node::NodeBody::Source(v) => {
14188 struct_ser.serialize_field("source", v)?;
14189 }
14190 stream_node::NodeBody::Project(v) => {
14191 struct_ser.serialize_field("project", v)?;
14192 }
14193 stream_node::NodeBody::Filter(v) => {
14194 struct_ser.serialize_field("filter", v)?;
14195 }
14196 stream_node::NodeBody::Materialize(v) => {
14197 struct_ser.serialize_field("materialize", v)?;
14198 }
14199 stream_node::NodeBody::StatelessSimpleAgg(v) => {
14200 struct_ser.serialize_field("statelessSimpleAgg", v)?;
14201 }
14202 stream_node::NodeBody::SimpleAgg(v) => {
14203 struct_ser.serialize_field("simpleAgg", v)?;
14204 }
14205 stream_node::NodeBody::HashAgg(v) => {
14206 struct_ser.serialize_field("hashAgg", v)?;
14207 }
14208 stream_node::NodeBody::AppendOnlyTopN(v) => {
14209 struct_ser.serialize_field("appendOnlyTopN", v)?;
14210 }
14211 stream_node::NodeBody::HashJoin(v) => {
14212 struct_ser.serialize_field("hashJoin", v)?;
14213 }
14214 stream_node::NodeBody::TopN(v) => {
14215 struct_ser.serialize_field("topN", v)?;
14216 }
14217 stream_node::NodeBody::HopWindow(v) => {
14218 struct_ser.serialize_field("hopWindow", v)?;
14219 }
14220 stream_node::NodeBody::Merge(v) => {
14221 struct_ser.serialize_field("merge", v)?;
14222 }
14223 stream_node::NodeBody::Exchange(v) => {
14224 struct_ser.serialize_field("exchange", v)?;
14225 }
14226 stream_node::NodeBody::StreamScan(v) => {
14227 struct_ser.serialize_field("streamScan", v)?;
14228 }
14229 stream_node::NodeBody::BatchPlan(v) => {
14230 struct_ser.serialize_field("batchPlan", v)?;
14231 }
14232 stream_node::NodeBody::Lookup(v) => {
14233 struct_ser.serialize_field("lookup", v)?;
14234 }
14235 stream_node::NodeBody::Arrange(v) => {
14236 struct_ser.serialize_field("arrange", v)?;
14237 }
14238 stream_node::NodeBody::LookupUnion(v) => {
14239 struct_ser.serialize_field("lookupUnion", v)?;
14240 }
14241 stream_node::NodeBody::Union(v) => {
14242 struct_ser.serialize_field("union", v)?;
14243 }
14244 stream_node::NodeBody::DeltaIndexJoin(v) => {
14245 struct_ser.serialize_field("deltaIndexJoin", v)?;
14246 }
14247 stream_node::NodeBody::Sink(v) => {
14248 struct_ser.serialize_field("sink", v)?;
14249 }
14250 stream_node::NodeBody::Expand(v) => {
14251 struct_ser.serialize_field("expand", v)?;
14252 }
14253 stream_node::NodeBody::DynamicFilter(v) => {
14254 struct_ser.serialize_field("dynamicFilter", v)?;
14255 }
14256 stream_node::NodeBody::ProjectSet(v) => {
14257 struct_ser.serialize_field("projectSet", v)?;
14258 }
14259 stream_node::NodeBody::GroupTopN(v) => {
14260 struct_ser.serialize_field("groupTopN", v)?;
14261 }
14262 stream_node::NodeBody::Sort(v) => {
14263 struct_ser.serialize_field("sort", v)?;
14264 }
14265 stream_node::NodeBody::WatermarkFilter(v) => {
14266 struct_ser.serialize_field("watermarkFilter", v)?;
14267 }
14268 stream_node::NodeBody::Dml(v) => {
14269 struct_ser.serialize_field("dml", v)?;
14270 }
14271 stream_node::NodeBody::RowIdGen(v) => {
14272 struct_ser.serialize_field("rowIdGen", v)?;
14273 }
14274 stream_node::NodeBody::Now(v) => {
14275 struct_ser.serialize_field("now", v)?;
14276 }
14277 stream_node::NodeBody::AppendOnlyGroupTopN(v) => {
14278 struct_ser.serialize_field("appendOnlyGroupTopN", v)?;
14279 }
14280 stream_node::NodeBody::TemporalJoin(v) => {
14281 struct_ser.serialize_field("temporalJoin", v)?;
14282 }
14283 stream_node::NodeBody::BarrierRecv(v) => {
14284 struct_ser.serialize_field("barrierRecv", v)?;
14285 }
14286 stream_node::NodeBody::Values(v) => {
14287 struct_ser.serialize_field("values", v)?;
14288 }
14289 stream_node::NodeBody::AppendOnlyDedup(v) => {
14290 struct_ser.serialize_field("appendOnlyDedup", v)?;
14291 }
14292 stream_node::NodeBody::NoOp(v) => {
14293 struct_ser.serialize_field("noOp", v)?;
14294 }
14295 stream_node::NodeBody::EowcOverWindow(v) => {
14296 struct_ser.serialize_field("eowcOverWindow", v)?;
14297 }
14298 stream_node::NodeBody::OverWindow(v) => {
14299 struct_ser.serialize_field("overWindow", v)?;
14300 }
14301 stream_node::NodeBody::StreamFsFetch(v) => {
14302 struct_ser.serialize_field("streamFsFetch", v)?;
14303 }
14304 stream_node::NodeBody::StreamCdcScan(v) => {
14305 struct_ser.serialize_field("streamCdcScan", v)?;
14306 }
14307 stream_node::NodeBody::CdcFilter(v) => {
14308 struct_ser.serialize_field("cdcFilter", v)?;
14309 }
14310 stream_node::NodeBody::SourceBackfill(v) => {
14311 struct_ser.serialize_field("sourceBackfill", v)?;
14312 }
14313 stream_node::NodeBody::Changelog(v) => {
14314 struct_ser.serialize_field("changelog", v)?;
14315 }
14316 stream_node::NodeBody::LocalApproxPercentile(v) => {
14317 struct_ser.serialize_field("localApproxPercentile", v)?;
14318 }
14319 stream_node::NodeBody::GlobalApproxPercentile(v) => {
14320 struct_ser.serialize_field("globalApproxPercentile", v)?;
14321 }
14322 stream_node::NodeBody::RowMerge(v) => {
14323 struct_ser.serialize_field("rowMerge", v)?;
14324 }
14325 stream_node::NodeBody::AsOfJoin(v) => {
14326 struct_ser.serialize_field("asOfJoin", v)?;
14327 }
14328 stream_node::NodeBody::SyncLogStore(v) => {
14329 struct_ser.serialize_field("syncLogStore", v)?;
14330 }
14331 stream_node::NodeBody::MaterializedExprs(v) => {
14332 struct_ser.serialize_field("materializedExprs", v)?;
14333 }
14334 stream_node::NodeBody::VectorIndexWrite(v) => {
14335 struct_ser.serialize_field("vectorIndexWrite", v)?;
14336 }
14337 stream_node::NodeBody::UpstreamSinkUnion(v) => {
14338 struct_ser.serialize_field("upstreamSinkUnion", v)?;
14339 }
14340 stream_node::NodeBody::LocalityProvider(v) => {
14341 struct_ser.serialize_field("localityProvider", v)?;
14342 }
14343 stream_node::NodeBody::EowcGapFill(v) => {
14344 struct_ser.serialize_field("eowcGapFill", v)?;
14345 }
14346 stream_node::NodeBody::GapFill(v) => {
14347 struct_ser.serialize_field("gapFill", v)?;
14348 }
14349 stream_node::NodeBody::VectorIndexLookupJoin(v) => {
14350 struct_ser.serialize_field("vectorIndexLookupJoin", v)?;
14351 }
14352 stream_node::NodeBody::IcebergWithPkIndexWriter(v) => {
14353 struct_ser.serialize_field("icebergWithPkIndexWriter", v)?;
14354 }
14355 stream_node::NodeBody::IcebergWithPkIndexDvMerger(v) => {
14356 struct_ser.serialize_field("icebergWithPkIndexDvMerger", v)?;
14357 }
14358 }
14359 }
14360 struct_ser.end()
14361 }
14362}
14363impl<'de> serde::Deserialize<'de> for StreamNode {
14364 #[allow(deprecated)]
14365 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14366 where
14367 D: serde::Deserializer<'de>,
14368 {
14369 const FIELDS: &[&str] = &[
14370 "operator_id",
14371 "operatorId",
14372 "input",
14373 "stream_key",
14374 "streamKey",
14375 "stream_kind",
14376 "streamKind",
14377 "identity",
14378 "fields",
14379 "source",
14380 "project",
14381 "filter",
14382 "materialize",
14383 "stateless_simple_agg",
14384 "statelessSimpleAgg",
14385 "simple_agg",
14386 "simpleAgg",
14387 "hash_agg",
14388 "hashAgg",
14389 "append_only_top_n",
14390 "appendOnlyTopN",
14391 "hash_join",
14392 "hashJoin",
14393 "top_n",
14394 "topN",
14395 "hop_window",
14396 "hopWindow",
14397 "merge",
14398 "exchange",
14399 "stream_scan",
14400 "streamScan",
14401 "batch_plan",
14402 "batchPlan",
14403 "lookup",
14404 "arrange",
14405 "lookup_union",
14406 "lookupUnion",
14407 "union",
14408 "delta_index_join",
14409 "deltaIndexJoin",
14410 "sink",
14411 "expand",
14412 "dynamic_filter",
14413 "dynamicFilter",
14414 "project_set",
14415 "projectSet",
14416 "group_top_n",
14417 "groupTopN",
14418 "sort",
14419 "watermark_filter",
14420 "watermarkFilter",
14421 "dml",
14422 "row_id_gen",
14423 "rowIdGen",
14424 "now",
14425 "append_only_group_top_n",
14426 "appendOnlyGroupTopN",
14427 "temporal_join",
14428 "temporalJoin",
14429 "barrier_recv",
14430 "barrierRecv",
14431 "values",
14432 "append_only_dedup",
14433 "appendOnlyDedup",
14434 "no_op",
14435 "noOp",
14436 "eowc_over_window",
14437 "eowcOverWindow",
14438 "over_window",
14439 "overWindow",
14440 "stream_fs_fetch",
14441 "streamFsFetch",
14442 "stream_cdc_scan",
14443 "streamCdcScan",
14444 "cdc_filter",
14445 "cdcFilter",
14446 "source_backfill",
14447 "sourceBackfill",
14448 "changelog",
14449 "local_approx_percentile",
14450 "localApproxPercentile",
14451 "global_approx_percentile",
14452 "globalApproxPercentile",
14453 "row_merge",
14454 "rowMerge",
14455 "as_of_join",
14456 "asOfJoin",
14457 "sync_log_store",
14458 "syncLogStore",
14459 "materialized_exprs",
14460 "materializedExprs",
14461 "vector_index_write",
14462 "vectorIndexWrite",
14463 "upstream_sink_union",
14464 "upstreamSinkUnion",
14465 "locality_provider",
14466 "localityProvider",
14467 "eowc_gap_fill",
14468 "eowcGapFill",
14469 "gap_fill",
14470 "gapFill",
14471 "vector_index_lookup_join",
14472 "vectorIndexLookupJoin",
14473 "iceberg_with_pk_index_writer",
14474 "icebergWithPkIndexWriter",
14475 "iceberg_with_pk_index_dv_merger",
14476 "icebergWithPkIndexDvMerger",
14477 ];
14478
14479 #[allow(clippy::enum_variant_names)]
14480 enum GeneratedField {
14481 OperatorId,
14482 Input,
14483 StreamKey,
14484 StreamKind,
14485 Identity,
14486 Fields,
14487 Source,
14488 Project,
14489 Filter,
14490 Materialize,
14491 StatelessSimpleAgg,
14492 SimpleAgg,
14493 HashAgg,
14494 AppendOnlyTopN,
14495 HashJoin,
14496 TopN,
14497 HopWindow,
14498 Merge,
14499 Exchange,
14500 StreamScan,
14501 BatchPlan,
14502 Lookup,
14503 Arrange,
14504 LookupUnion,
14505 Union,
14506 DeltaIndexJoin,
14507 Sink,
14508 Expand,
14509 DynamicFilter,
14510 ProjectSet,
14511 GroupTopN,
14512 Sort,
14513 WatermarkFilter,
14514 Dml,
14515 RowIdGen,
14516 Now,
14517 AppendOnlyGroupTopN,
14518 TemporalJoin,
14519 BarrierRecv,
14520 Values,
14521 AppendOnlyDedup,
14522 NoOp,
14523 EowcOverWindow,
14524 OverWindow,
14525 StreamFsFetch,
14526 StreamCdcScan,
14527 CdcFilter,
14528 SourceBackfill,
14529 Changelog,
14530 LocalApproxPercentile,
14531 GlobalApproxPercentile,
14532 RowMerge,
14533 AsOfJoin,
14534 SyncLogStore,
14535 MaterializedExprs,
14536 VectorIndexWrite,
14537 UpstreamSinkUnion,
14538 LocalityProvider,
14539 EowcGapFill,
14540 GapFill,
14541 VectorIndexLookupJoin,
14542 IcebergWithPkIndexWriter,
14543 IcebergWithPkIndexDvMerger,
14544 }
14545 impl<'de> serde::Deserialize<'de> for GeneratedField {
14546 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14547 where
14548 D: serde::Deserializer<'de>,
14549 {
14550 struct GeneratedVisitor;
14551
14552 impl serde::de::Visitor<'_> for GeneratedVisitor {
14553 type Value = GeneratedField;
14554
14555 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14556 write!(formatter, "expected one of: {:?}", &FIELDS)
14557 }
14558
14559 #[allow(unused_variables)]
14560 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14561 where
14562 E: serde::de::Error,
14563 {
14564 match value {
14565 "operatorId" | "operator_id" => Ok(GeneratedField::OperatorId),
14566 "input" => Ok(GeneratedField::Input),
14567 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
14568 "streamKind" | "stream_kind" => Ok(GeneratedField::StreamKind),
14569 "identity" => Ok(GeneratedField::Identity),
14570 "fields" => Ok(GeneratedField::Fields),
14571 "source" => Ok(GeneratedField::Source),
14572 "project" => Ok(GeneratedField::Project),
14573 "filter" => Ok(GeneratedField::Filter),
14574 "materialize" => Ok(GeneratedField::Materialize),
14575 "statelessSimpleAgg" | "stateless_simple_agg" => Ok(GeneratedField::StatelessSimpleAgg),
14576 "simpleAgg" | "simple_agg" => Ok(GeneratedField::SimpleAgg),
14577 "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
14578 "appendOnlyTopN" | "append_only_top_n" => Ok(GeneratedField::AppendOnlyTopN),
14579 "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
14580 "topN" | "top_n" => Ok(GeneratedField::TopN),
14581 "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
14582 "merge" => Ok(GeneratedField::Merge),
14583 "exchange" => Ok(GeneratedField::Exchange),
14584 "streamScan" | "stream_scan" => Ok(GeneratedField::StreamScan),
14585 "batchPlan" | "batch_plan" => Ok(GeneratedField::BatchPlan),
14586 "lookup" => Ok(GeneratedField::Lookup),
14587 "arrange" => Ok(GeneratedField::Arrange),
14588 "lookupUnion" | "lookup_union" => Ok(GeneratedField::LookupUnion),
14589 "union" => Ok(GeneratedField::Union),
14590 "deltaIndexJoin" | "delta_index_join" => Ok(GeneratedField::DeltaIndexJoin),
14591 "sink" => Ok(GeneratedField::Sink),
14592 "expand" => Ok(GeneratedField::Expand),
14593 "dynamicFilter" | "dynamic_filter" => Ok(GeneratedField::DynamicFilter),
14594 "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
14595 "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
14596 "sort" => Ok(GeneratedField::Sort),
14597 "watermarkFilter" | "watermark_filter" => Ok(GeneratedField::WatermarkFilter),
14598 "dml" => Ok(GeneratedField::Dml),
14599 "rowIdGen" | "row_id_gen" => Ok(GeneratedField::RowIdGen),
14600 "now" => Ok(GeneratedField::Now),
14601 "appendOnlyGroupTopN" | "append_only_group_top_n" => Ok(GeneratedField::AppendOnlyGroupTopN),
14602 "temporalJoin" | "temporal_join" => Ok(GeneratedField::TemporalJoin),
14603 "barrierRecv" | "barrier_recv" => Ok(GeneratedField::BarrierRecv),
14604 "values" => Ok(GeneratedField::Values),
14605 "appendOnlyDedup" | "append_only_dedup" => Ok(GeneratedField::AppendOnlyDedup),
14606 "noOp" | "no_op" => Ok(GeneratedField::NoOp),
14607 "eowcOverWindow" | "eowc_over_window" => Ok(GeneratedField::EowcOverWindow),
14608 "overWindow" | "over_window" => Ok(GeneratedField::OverWindow),
14609 "streamFsFetch" | "stream_fs_fetch" => Ok(GeneratedField::StreamFsFetch),
14610 "streamCdcScan" | "stream_cdc_scan" => Ok(GeneratedField::StreamCdcScan),
14611 "cdcFilter" | "cdc_filter" => Ok(GeneratedField::CdcFilter),
14612 "sourceBackfill" | "source_backfill" => Ok(GeneratedField::SourceBackfill),
14613 "changelog" => Ok(GeneratedField::Changelog),
14614 "localApproxPercentile" | "local_approx_percentile" => Ok(GeneratedField::LocalApproxPercentile),
14615 "globalApproxPercentile" | "global_approx_percentile" => Ok(GeneratedField::GlobalApproxPercentile),
14616 "rowMerge" | "row_merge" => Ok(GeneratedField::RowMerge),
14617 "asOfJoin" | "as_of_join" => Ok(GeneratedField::AsOfJoin),
14618 "syncLogStore" | "sync_log_store" => Ok(GeneratedField::SyncLogStore),
14619 "materializedExprs" | "materialized_exprs" => Ok(GeneratedField::MaterializedExprs),
14620 "vectorIndexWrite" | "vector_index_write" => Ok(GeneratedField::VectorIndexWrite),
14621 "upstreamSinkUnion" | "upstream_sink_union" => Ok(GeneratedField::UpstreamSinkUnion),
14622 "localityProvider" | "locality_provider" => Ok(GeneratedField::LocalityProvider),
14623 "eowcGapFill" | "eowc_gap_fill" => Ok(GeneratedField::EowcGapFill),
14624 "gapFill" | "gap_fill" => Ok(GeneratedField::GapFill),
14625 "vectorIndexLookupJoin" | "vector_index_lookup_join" => Ok(GeneratedField::VectorIndexLookupJoin),
14626 "icebergWithPkIndexWriter" | "iceberg_with_pk_index_writer" => Ok(GeneratedField::IcebergWithPkIndexWriter),
14627 "icebergWithPkIndexDvMerger" | "iceberg_with_pk_index_dv_merger" => Ok(GeneratedField::IcebergWithPkIndexDvMerger),
14628 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14629 }
14630 }
14631 }
14632 deserializer.deserialize_identifier(GeneratedVisitor)
14633 }
14634 }
14635 struct GeneratedVisitor;
14636 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14637 type Value = StreamNode;
14638
14639 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14640 formatter.write_str("struct stream_plan.StreamNode")
14641 }
14642
14643 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamNode, V::Error>
14644 where
14645 V: serde::de::MapAccess<'de>,
14646 {
14647 let mut operator_id__ = None;
14648 let mut input__ = None;
14649 let mut stream_key__ = None;
14650 let mut stream_kind__ = None;
14651 let mut identity__ = None;
14652 let mut fields__ = None;
14653 let mut node_body__ = None;
14654 while let Some(k) = map_.next_key()? {
14655 match k {
14656 GeneratedField::OperatorId => {
14657 if operator_id__.is_some() {
14658 return Err(serde::de::Error::duplicate_field("operatorId"));
14659 }
14660 operator_id__ =
14661 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14662 ;
14663 }
14664 GeneratedField::Input => {
14665 if input__.is_some() {
14666 return Err(serde::de::Error::duplicate_field("input"));
14667 }
14668 input__ = Some(map_.next_value()?);
14669 }
14670 GeneratedField::StreamKey => {
14671 if stream_key__.is_some() {
14672 return Err(serde::de::Error::duplicate_field("streamKey"));
14673 }
14674 stream_key__ =
14675 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14676 .into_iter().map(|x| x.0).collect())
14677 ;
14678 }
14679 GeneratedField::StreamKind => {
14680 if stream_kind__.is_some() {
14681 return Err(serde::de::Error::duplicate_field("streamKind"));
14682 }
14683 stream_kind__ = Some(map_.next_value::<stream_node::StreamKind>()? as i32);
14684 }
14685 GeneratedField::Identity => {
14686 if identity__.is_some() {
14687 return Err(serde::de::Error::duplicate_field("identity"));
14688 }
14689 identity__ = Some(map_.next_value()?);
14690 }
14691 GeneratedField::Fields => {
14692 if fields__.is_some() {
14693 return Err(serde::de::Error::duplicate_field("fields"));
14694 }
14695 fields__ = Some(map_.next_value()?);
14696 }
14697 GeneratedField::Source => {
14698 if node_body__.is_some() {
14699 return Err(serde::de::Error::duplicate_field("source"));
14700 }
14701 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Source)
14702;
14703 }
14704 GeneratedField::Project => {
14705 if node_body__.is_some() {
14706 return Err(serde::de::Error::duplicate_field("project"));
14707 }
14708 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Project)
14709;
14710 }
14711 GeneratedField::Filter => {
14712 if node_body__.is_some() {
14713 return Err(serde::de::Error::duplicate_field("filter"));
14714 }
14715 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Filter)
14716;
14717 }
14718 GeneratedField::Materialize => {
14719 if node_body__.is_some() {
14720 return Err(serde::de::Error::duplicate_field("materialize"));
14721 }
14722 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Materialize)
14723;
14724 }
14725 GeneratedField::StatelessSimpleAgg => {
14726 if node_body__.is_some() {
14727 return Err(serde::de::Error::duplicate_field("statelessSimpleAgg"));
14728 }
14729 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StatelessSimpleAgg)
14730;
14731 }
14732 GeneratedField::SimpleAgg => {
14733 if node_body__.is_some() {
14734 return Err(serde::de::Error::duplicate_field("simpleAgg"));
14735 }
14736 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SimpleAgg)
14737;
14738 }
14739 GeneratedField::HashAgg => {
14740 if node_body__.is_some() {
14741 return Err(serde::de::Error::duplicate_field("hashAgg"));
14742 }
14743 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashAgg)
14744;
14745 }
14746 GeneratedField::AppendOnlyTopN => {
14747 if node_body__.is_some() {
14748 return Err(serde::de::Error::duplicate_field("appendOnlyTopN"));
14749 }
14750 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyTopN)
14751;
14752 }
14753 GeneratedField::HashJoin => {
14754 if node_body__.is_some() {
14755 return Err(serde::de::Error::duplicate_field("hashJoin"));
14756 }
14757 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashJoin)
14758;
14759 }
14760 GeneratedField::TopN => {
14761 if node_body__.is_some() {
14762 return Err(serde::de::Error::duplicate_field("topN"));
14763 }
14764 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TopN)
14765;
14766 }
14767 GeneratedField::HopWindow => {
14768 if node_body__.is_some() {
14769 return Err(serde::de::Error::duplicate_field("hopWindow"));
14770 }
14771 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HopWindow)
14772;
14773 }
14774 GeneratedField::Merge => {
14775 if node_body__.is_some() {
14776 return Err(serde::de::Error::duplicate_field("merge"));
14777 }
14778 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Merge)
14779;
14780 }
14781 GeneratedField::Exchange => {
14782 if node_body__.is_some() {
14783 return Err(serde::de::Error::duplicate_field("exchange"));
14784 }
14785 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Exchange)
14786;
14787 }
14788 GeneratedField::StreamScan => {
14789 if node_body__.is_some() {
14790 return Err(serde::de::Error::duplicate_field("streamScan"));
14791 }
14792 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamScan)
14793;
14794 }
14795 GeneratedField::BatchPlan => {
14796 if node_body__.is_some() {
14797 return Err(serde::de::Error::duplicate_field("batchPlan"));
14798 }
14799 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BatchPlan)
14800;
14801 }
14802 GeneratedField::Lookup => {
14803 if node_body__.is_some() {
14804 return Err(serde::de::Error::duplicate_field("lookup"));
14805 }
14806 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Lookup)
14807;
14808 }
14809 GeneratedField::Arrange => {
14810 if node_body__.is_some() {
14811 return Err(serde::de::Error::duplicate_field("arrange"));
14812 }
14813 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Arrange)
14814;
14815 }
14816 GeneratedField::LookupUnion => {
14817 if node_body__.is_some() {
14818 return Err(serde::de::Error::duplicate_field("lookupUnion"));
14819 }
14820 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LookupUnion)
14821;
14822 }
14823 GeneratedField::Union => {
14824 if node_body__.is_some() {
14825 return Err(serde::de::Error::duplicate_field("union"));
14826 }
14827 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Union)
14828;
14829 }
14830 GeneratedField::DeltaIndexJoin => {
14831 if node_body__.is_some() {
14832 return Err(serde::de::Error::duplicate_field("deltaIndexJoin"));
14833 }
14834 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DeltaIndexJoin)
14835;
14836 }
14837 GeneratedField::Sink => {
14838 if node_body__.is_some() {
14839 return Err(serde::de::Error::duplicate_field("sink"));
14840 }
14841 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sink)
14842;
14843 }
14844 GeneratedField::Expand => {
14845 if node_body__.is_some() {
14846 return Err(serde::de::Error::duplicate_field("expand"));
14847 }
14848 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Expand)
14849;
14850 }
14851 GeneratedField::DynamicFilter => {
14852 if node_body__.is_some() {
14853 return Err(serde::de::Error::duplicate_field("dynamicFilter"));
14854 }
14855 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DynamicFilter)
14856;
14857 }
14858 GeneratedField::ProjectSet => {
14859 if node_body__.is_some() {
14860 return Err(serde::de::Error::duplicate_field("projectSet"));
14861 }
14862 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::ProjectSet)
14863;
14864 }
14865 GeneratedField::GroupTopN => {
14866 if node_body__.is_some() {
14867 return Err(serde::de::Error::duplicate_field("groupTopN"));
14868 }
14869 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GroupTopN)
14870;
14871 }
14872 GeneratedField::Sort => {
14873 if node_body__.is_some() {
14874 return Err(serde::de::Error::duplicate_field("sort"));
14875 }
14876 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sort)
14877;
14878 }
14879 GeneratedField::WatermarkFilter => {
14880 if node_body__.is_some() {
14881 return Err(serde::de::Error::duplicate_field("watermarkFilter"));
14882 }
14883 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::WatermarkFilter)
14884;
14885 }
14886 GeneratedField::Dml => {
14887 if node_body__.is_some() {
14888 return Err(serde::de::Error::duplicate_field("dml"));
14889 }
14890 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Dml)
14891;
14892 }
14893 GeneratedField::RowIdGen => {
14894 if node_body__.is_some() {
14895 return Err(serde::de::Error::duplicate_field("rowIdGen"));
14896 }
14897 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowIdGen)
14898;
14899 }
14900 GeneratedField::Now => {
14901 if node_body__.is_some() {
14902 return Err(serde::de::Error::duplicate_field("now"));
14903 }
14904 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Now)
14905;
14906 }
14907 GeneratedField::AppendOnlyGroupTopN => {
14908 if node_body__.is_some() {
14909 return Err(serde::de::Error::duplicate_field("appendOnlyGroupTopN"));
14910 }
14911 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyGroupTopN)
14912;
14913 }
14914 GeneratedField::TemporalJoin => {
14915 if node_body__.is_some() {
14916 return Err(serde::de::Error::duplicate_field("temporalJoin"));
14917 }
14918 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TemporalJoin)
14919;
14920 }
14921 GeneratedField::BarrierRecv => {
14922 if node_body__.is_some() {
14923 return Err(serde::de::Error::duplicate_field("barrierRecv"));
14924 }
14925 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BarrierRecv)
14926;
14927 }
14928 GeneratedField::Values => {
14929 if node_body__.is_some() {
14930 return Err(serde::de::Error::duplicate_field("values"));
14931 }
14932 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Values)
14933;
14934 }
14935 GeneratedField::AppendOnlyDedup => {
14936 if node_body__.is_some() {
14937 return Err(serde::de::Error::duplicate_field("appendOnlyDedup"));
14938 }
14939 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyDedup)
14940;
14941 }
14942 GeneratedField::NoOp => {
14943 if node_body__.is_some() {
14944 return Err(serde::de::Error::duplicate_field("noOp"));
14945 }
14946 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::NoOp)
14947;
14948 }
14949 GeneratedField::EowcOverWindow => {
14950 if node_body__.is_some() {
14951 return Err(serde::de::Error::duplicate_field("eowcOverWindow"));
14952 }
14953 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcOverWindow)
14954;
14955 }
14956 GeneratedField::OverWindow => {
14957 if node_body__.is_some() {
14958 return Err(serde::de::Error::duplicate_field("overWindow"));
14959 }
14960 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::OverWindow)
14961;
14962 }
14963 GeneratedField::StreamFsFetch => {
14964 if node_body__.is_some() {
14965 return Err(serde::de::Error::duplicate_field("streamFsFetch"));
14966 }
14967 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamFsFetch)
14968;
14969 }
14970 GeneratedField::StreamCdcScan => {
14971 if node_body__.is_some() {
14972 return Err(serde::de::Error::duplicate_field("streamCdcScan"));
14973 }
14974 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamCdcScan)
14975;
14976 }
14977 GeneratedField::CdcFilter => {
14978 if node_body__.is_some() {
14979 return Err(serde::de::Error::duplicate_field("cdcFilter"));
14980 }
14981 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CdcFilter)
14982;
14983 }
14984 GeneratedField::SourceBackfill => {
14985 if node_body__.is_some() {
14986 return Err(serde::de::Error::duplicate_field("sourceBackfill"));
14987 }
14988 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SourceBackfill)
14989;
14990 }
14991 GeneratedField::Changelog => {
14992 if node_body__.is_some() {
14993 return Err(serde::de::Error::duplicate_field("changelog"));
14994 }
14995 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Changelog)
14996;
14997 }
14998 GeneratedField::LocalApproxPercentile => {
14999 if node_body__.is_some() {
15000 return Err(serde::de::Error::duplicate_field("localApproxPercentile"));
15001 }
15002 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalApproxPercentile)
15003;
15004 }
15005 GeneratedField::GlobalApproxPercentile => {
15006 if node_body__.is_some() {
15007 return Err(serde::de::Error::duplicate_field("globalApproxPercentile"));
15008 }
15009 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GlobalApproxPercentile)
15010;
15011 }
15012 GeneratedField::RowMerge => {
15013 if node_body__.is_some() {
15014 return Err(serde::de::Error::duplicate_field("rowMerge"));
15015 }
15016 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowMerge)
15017;
15018 }
15019 GeneratedField::AsOfJoin => {
15020 if node_body__.is_some() {
15021 return Err(serde::de::Error::duplicate_field("asOfJoin"));
15022 }
15023 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AsOfJoin)
15024;
15025 }
15026 GeneratedField::SyncLogStore => {
15027 if node_body__.is_some() {
15028 return Err(serde::de::Error::duplicate_field("syncLogStore"));
15029 }
15030 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SyncLogStore)
15031;
15032 }
15033 GeneratedField::MaterializedExprs => {
15034 if node_body__.is_some() {
15035 return Err(serde::de::Error::duplicate_field("materializedExprs"));
15036 }
15037 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MaterializedExprs)
15038;
15039 }
15040 GeneratedField::VectorIndexWrite => {
15041 if node_body__.is_some() {
15042 return Err(serde::de::Error::duplicate_field("vectorIndexWrite"));
15043 }
15044 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexWrite)
15045;
15046 }
15047 GeneratedField::UpstreamSinkUnion => {
15048 if node_body__.is_some() {
15049 return Err(serde::de::Error::duplicate_field("upstreamSinkUnion"));
15050 }
15051 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::UpstreamSinkUnion)
15052;
15053 }
15054 GeneratedField::LocalityProvider => {
15055 if node_body__.is_some() {
15056 return Err(serde::de::Error::duplicate_field("localityProvider"));
15057 }
15058 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalityProvider)
15059;
15060 }
15061 GeneratedField::EowcGapFill => {
15062 if node_body__.is_some() {
15063 return Err(serde::de::Error::duplicate_field("eowcGapFill"));
15064 }
15065 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcGapFill)
15066;
15067 }
15068 GeneratedField::GapFill => {
15069 if node_body__.is_some() {
15070 return Err(serde::de::Error::duplicate_field("gapFill"));
15071 }
15072 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GapFill)
15073;
15074 }
15075 GeneratedField::VectorIndexLookupJoin => {
15076 if node_body__.is_some() {
15077 return Err(serde::de::Error::duplicate_field("vectorIndexLookupJoin"));
15078 }
15079 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexLookupJoin)
15080;
15081 }
15082 GeneratedField::IcebergWithPkIndexWriter => {
15083 if node_body__.is_some() {
15084 return Err(serde::de::Error::duplicate_field("icebergWithPkIndexWriter"));
15085 }
15086 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::IcebergWithPkIndexWriter)
15087;
15088 }
15089 GeneratedField::IcebergWithPkIndexDvMerger => {
15090 if node_body__.is_some() {
15091 return Err(serde::de::Error::duplicate_field("icebergWithPkIndexDvMerger"));
15092 }
15093 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::IcebergWithPkIndexDvMerger)
15094;
15095 }
15096 }
15097 }
15098 Ok(StreamNode {
15099 operator_id: operator_id__.unwrap_or_default(),
15100 input: input__.unwrap_or_default(),
15101 stream_key: stream_key__.unwrap_or_default(),
15102 stream_kind: stream_kind__.unwrap_or_default(),
15103 identity: identity__.unwrap_or_default(),
15104 fields: fields__.unwrap_or_default(),
15105 node_body: node_body__,
15106 })
15107 }
15108 }
15109 deserializer.deserialize_struct("stream_plan.StreamNode", FIELDS, GeneratedVisitor)
15110 }
15111}
15112impl serde::Serialize for stream_node::StreamKind {
15113 #[allow(deprecated)]
15114 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15115 where
15116 S: serde::Serializer,
15117 {
15118 let variant = match self {
15119 Self::Retract => "STREAM_KIND_RETRACT",
15120 Self::AppendOnly => "STREAM_KIND_APPEND_ONLY",
15121 Self::Upsert => "STREAM_KIND_UPSERT",
15122 };
15123 serializer.serialize_str(variant)
15124 }
15125}
15126impl<'de> serde::Deserialize<'de> for stream_node::StreamKind {
15127 #[allow(deprecated)]
15128 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15129 where
15130 D: serde::Deserializer<'de>,
15131 {
15132 const FIELDS: &[&str] = &[
15133 "STREAM_KIND_RETRACT",
15134 "STREAM_KIND_APPEND_ONLY",
15135 "STREAM_KIND_UPSERT",
15136 ];
15137
15138 struct GeneratedVisitor;
15139
15140 impl serde::de::Visitor<'_> for GeneratedVisitor {
15141 type Value = stream_node::StreamKind;
15142
15143 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15144 write!(formatter, "expected one of: {:?}", &FIELDS)
15145 }
15146
15147 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15148 where
15149 E: serde::de::Error,
15150 {
15151 i32::try_from(v)
15152 .ok()
15153 .and_then(|x| x.try_into().ok())
15154 .ok_or_else(|| {
15155 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15156 })
15157 }
15158
15159 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15160 where
15161 E: serde::de::Error,
15162 {
15163 i32::try_from(v)
15164 .ok()
15165 .and_then(|x| x.try_into().ok())
15166 .ok_or_else(|| {
15167 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15168 })
15169 }
15170
15171 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15172 where
15173 E: serde::de::Error,
15174 {
15175 match value {
15176 "STREAM_KIND_RETRACT" => Ok(stream_node::StreamKind::Retract),
15177 "STREAM_KIND_APPEND_ONLY" => Ok(stream_node::StreamKind::AppendOnly),
15178 "STREAM_KIND_UPSERT" => Ok(stream_node::StreamKind::Upsert),
15179 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15180 }
15181 }
15182 }
15183 deserializer.deserialize_any(GeneratedVisitor)
15184 }
15185}
15186impl serde::Serialize for StreamScanNode {
15187 #[allow(deprecated)]
15188 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15189 where
15190 S: serde::Serializer,
15191 {
15192 use serde::ser::SerializeStruct;
15193 let mut len = 0;
15194 if self.table_id != 0 {
15195 len += 1;
15196 }
15197 if !self.upstream_column_ids.is_empty() {
15198 len += 1;
15199 }
15200 if !self.output_indices.is_empty() {
15201 len += 1;
15202 }
15203 if self.stream_scan_type != 0 {
15204 len += 1;
15205 }
15206 if self.state_table.is_some() {
15207 len += 1;
15208 }
15209 if self.table_desc.is_some() {
15210 len += 1;
15211 }
15212 if self.rate_limit.is_some() {
15213 len += 1;
15214 }
15215 if self.snapshot_read_barrier_interval != 0 {
15216 len += 1;
15217 }
15218 if self.arrangement_table.is_some() {
15219 len += 1;
15220 }
15221 if self.snapshot_backfill_epoch.is_some() {
15222 len += 1;
15223 }
15224 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamScanNode", len)?;
15225 if self.table_id != 0 {
15226 struct_ser.serialize_field("tableId", &self.table_id)?;
15227 }
15228 if !self.upstream_column_ids.is_empty() {
15229 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
15230 }
15231 if !self.output_indices.is_empty() {
15232 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
15233 }
15234 if self.stream_scan_type != 0 {
15235 let v = StreamScanType::try_from(self.stream_scan_type)
15236 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_scan_type)))?;
15237 struct_ser.serialize_field("streamScanType", &v)?;
15238 }
15239 if let Some(v) = self.state_table.as_ref() {
15240 struct_ser.serialize_field("stateTable", v)?;
15241 }
15242 if let Some(v) = self.table_desc.as_ref() {
15243 struct_ser.serialize_field("tableDesc", v)?;
15244 }
15245 if let Some(v) = self.rate_limit.as_ref() {
15246 struct_ser.serialize_field("rateLimit", v)?;
15247 }
15248 if self.snapshot_read_barrier_interval != 0 {
15249 struct_ser.serialize_field("snapshotReadBarrierInterval", &self.snapshot_read_barrier_interval)?;
15250 }
15251 if let Some(v) = self.arrangement_table.as_ref() {
15252 struct_ser.serialize_field("arrangementTable", v)?;
15253 }
15254 if let Some(v) = self.snapshot_backfill_epoch.as_ref() {
15255 #[allow(clippy::needless_borrow)]
15256 #[allow(clippy::needless_borrows_for_generic_args)]
15257 struct_ser.serialize_field("snapshotBackfillEpoch", ToString::to_string(&v).as_str())?;
15258 }
15259 struct_ser.end()
15260 }
15261}
15262impl<'de> serde::Deserialize<'de> for StreamScanNode {
15263 #[allow(deprecated)]
15264 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15265 where
15266 D: serde::Deserializer<'de>,
15267 {
15268 const FIELDS: &[&str] = &[
15269 "table_id",
15270 "tableId",
15271 "upstream_column_ids",
15272 "upstreamColumnIds",
15273 "output_indices",
15274 "outputIndices",
15275 "stream_scan_type",
15276 "streamScanType",
15277 "state_table",
15278 "stateTable",
15279 "table_desc",
15280 "tableDesc",
15281 "rate_limit",
15282 "rateLimit",
15283 "snapshot_read_barrier_interval",
15284 "snapshotReadBarrierInterval",
15285 "arrangement_table",
15286 "arrangementTable",
15287 "snapshot_backfill_epoch",
15288 "snapshotBackfillEpoch",
15289 ];
15290
15291 #[allow(clippy::enum_variant_names)]
15292 enum GeneratedField {
15293 TableId,
15294 UpstreamColumnIds,
15295 OutputIndices,
15296 StreamScanType,
15297 StateTable,
15298 TableDesc,
15299 RateLimit,
15300 SnapshotReadBarrierInterval,
15301 ArrangementTable,
15302 SnapshotBackfillEpoch,
15303 }
15304 impl<'de> serde::Deserialize<'de> for GeneratedField {
15305 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15306 where
15307 D: serde::Deserializer<'de>,
15308 {
15309 struct GeneratedVisitor;
15310
15311 impl serde::de::Visitor<'_> for GeneratedVisitor {
15312 type Value = GeneratedField;
15313
15314 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15315 write!(formatter, "expected one of: {:?}", &FIELDS)
15316 }
15317
15318 #[allow(unused_variables)]
15319 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15320 where
15321 E: serde::de::Error,
15322 {
15323 match value {
15324 "tableId" | "table_id" => Ok(GeneratedField::TableId),
15325 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
15326 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
15327 "streamScanType" | "stream_scan_type" => Ok(GeneratedField::StreamScanType),
15328 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
15329 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
15330 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
15331 "snapshotReadBarrierInterval" | "snapshot_read_barrier_interval" => Ok(GeneratedField::SnapshotReadBarrierInterval),
15332 "arrangementTable" | "arrangement_table" => Ok(GeneratedField::ArrangementTable),
15333 "snapshotBackfillEpoch" | "snapshot_backfill_epoch" => Ok(GeneratedField::SnapshotBackfillEpoch),
15334 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15335 }
15336 }
15337 }
15338 deserializer.deserialize_identifier(GeneratedVisitor)
15339 }
15340 }
15341 struct GeneratedVisitor;
15342 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15343 type Value = StreamScanNode;
15344
15345 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15346 formatter.write_str("struct stream_plan.StreamScanNode")
15347 }
15348
15349 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamScanNode, V::Error>
15350 where
15351 V: serde::de::MapAccess<'de>,
15352 {
15353 let mut table_id__ = None;
15354 let mut upstream_column_ids__ = None;
15355 let mut output_indices__ = None;
15356 let mut stream_scan_type__ = None;
15357 let mut state_table__ = None;
15358 let mut table_desc__ = None;
15359 let mut rate_limit__ = None;
15360 let mut snapshot_read_barrier_interval__ = None;
15361 let mut arrangement_table__ = None;
15362 let mut snapshot_backfill_epoch__ = None;
15363 while let Some(k) = map_.next_key()? {
15364 match k {
15365 GeneratedField::TableId => {
15366 if table_id__.is_some() {
15367 return Err(serde::de::Error::duplicate_field("tableId"));
15368 }
15369 table_id__ =
15370 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15371 ;
15372 }
15373 GeneratedField::UpstreamColumnIds => {
15374 if upstream_column_ids__.is_some() {
15375 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
15376 }
15377 upstream_column_ids__ =
15378 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15379 .into_iter().map(|x| x.0).collect())
15380 ;
15381 }
15382 GeneratedField::OutputIndices => {
15383 if output_indices__.is_some() {
15384 return Err(serde::de::Error::duplicate_field("outputIndices"));
15385 }
15386 output_indices__ =
15387 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15388 .into_iter().map(|x| x.0).collect())
15389 ;
15390 }
15391 GeneratedField::StreamScanType => {
15392 if stream_scan_type__.is_some() {
15393 return Err(serde::de::Error::duplicate_field("streamScanType"));
15394 }
15395 stream_scan_type__ = Some(map_.next_value::<StreamScanType>()? as i32);
15396 }
15397 GeneratedField::StateTable => {
15398 if state_table__.is_some() {
15399 return Err(serde::de::Error::duplicate_field("stateTable"));
15400 }
15401 state_table__ = map_.next_value()?;
15402 }
15403 GeneratedField::TableDesc => {
15404 if table_desc__.is_some() {
15405 return Err(serde::de::Error::duplicate_field("tableDesc"));
15406 }
15407 table_desc__ = map_.next_value()?;
15408 }
15409 GeneratedField::RateLimit => {
15410 if rate_limit__.is_some() {
15411 return Err(serde::de::Error::duplicate_field("rateLimit"));
15412 }
15413 rate_limit__ =
15414 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15415 ;
15416 }
15417 GeneratedField::SnapshotReadBarrierInterval => {
15418 if snapshot_read_barrier_interval__.is_some() {
15419 return Err(serde::de::Error::duplicate_field("snapshotReadBarrierInterval"));
15420 }
15421 snapshot_read_barrier_interval__ =
15422 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15423 ;
15424 }
15425 GeneratedField::ArrangementTable => {
15426 if arrangement_table__.is_some() {
15427 return Err(serde::de::Error::duplicate_field("arrangementTable"));
15428 }
15429 arrangement_table__ = map_.next_value()?;
15430 }
15431 GeneratedField::SnapshotBackfillEpoch => {
15432 if snapshot_backfill_epoch__.is_some() {
15433 return Err(serde::de::Error::duplicate_field("snapshotBackfillEpoch"));
15434 }
15435 snapshot_backfill_epoch__ =
15436 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15437 ;
15438 }
15439 }
15440 }
15441 Ok(StreamScanNode {
15442 table_id: table_id__.unwrap_or_default(),
15443 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
15444 output_indices: output_indices__.unwrap_or_default(),
15445 stream_scan_type: stream_scan_type__.unwrap_or_default(),
15446 state_table: state_table__,
15447 table_desc: table_desc__,
15448 rate_limit: rate_limit__,
15449 snapshot_read_barrier_interval: snapshot_read_barrier_interval__.unwrap_or_default(),
15450 arrangement_table: arrangement_table__,
15451 snapshot_backfill_epoch: snapshot_backfill_epoch__,
15452 })
15453 }
15454 }
15455 deserializer.deserialize_struct("stream_plan.StreamScanNode", FIELDS, GeneratedVisitor)
15456 }
15457}
15458impl serde::Serialize for StreamScanType {
15459 #[allow(deprecated)]
15460 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15461 where
15462 S: serde::Serializer,
15463 {
15464 let variant = match self {
15465 Self::Unspecified => "STREAM_SCAN_TYPE_UNSPECIFIED",
15466 Self::Chain => "STREAM_SCAN_TYPE_CHAIN",
15467 Self::Rearrange => "STREAM_SCAN_TYPE_REARRANGE",
15468 Self::Backfill => "STREAM_SCAN_TYPE_BACKFILL",
15469 Self::UpstreamOnly => "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
15470 Self::ArrangementBackfill => "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
15471 Self::SnapshotBackfill => "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
15472 Self::CrossDbSnapshotBackfill => "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
15473 };
15474 serializer.serialize_str(variant)
15475 }
15476}
15477impl<'de> serde::Deserialize<'de> for StreamScanType {
15478 #[allow(deprecated)]
15479 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15480 where
15481 D: serde::Deserializer<'de>,
15482 {
15483 const FIELDS: &[&str] = &[
15484 "STREAM_SCAN_TYPE_UNSPECIFIED",
15485 "STREAM_SCAN_TYPE_CHAIN",
15486 "STREAM_SCAN_TYPE_REARRANGE",
15487 "STREAM_SCAN_TYPE_BACKFILL",
15488 "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
15489 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
15490 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
15491 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
15492 ];
15493
15494 struct GeneratedVisitor;
15495
15496 impl serde::de::Visitor<'_> for GeneratedVisitor {
15497 type Value = StreamScanType;
15498
15499 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15500 write!(formatter, "expected one of: {:?}", &FIELDS)
15501 }
15502
15503 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15504 where
15505 E: serde::de::Error,
15506 {
15507 i32::try_from(v)
15508 .ok()
15509 .and_then(|x| x.try_into().ok())
15510 .ok_or_else(|| {
15511 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15512 })
15513 }
15514
15515 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15516 where
15517 E: serde::de::Error,
15518 {
15519 i32::try_from(v)
15520 .ok()
15521 .and_then(|x| x.try_into().ok())
15522 .ok_or_else(|| {
15523 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15524 })
15525 }
15526
15527 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15528 where
15529 E: serde::de::Error,
15530 {
15531 match value {
15532 "STREAM_SCAN_TYPE_UNSPECIFIED" => Ok(StreamScanType::Unspecified),
15533 "STREAM_SCAN_TYPE_CHAIN" => Ok(StreamScanType::Chain),
15534 "STREAM_SCAN_TYPE_REARRANGE" => Ok(StreamScanType::Rearrange),
15535 "STREAM_SCAN_TYPE_BACKFILL" => Ok(StreamScanType::Backfill),
15536 "STREAM_SCAN_TYPE_UPSTREAM_ONLY" => Ok(StreamScanType::UpstreamOnly),
15537 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL" => Ok(StreamScanType::ArrangementBackfill),
15538 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL" => Ok(StreamScanType::SnapshotBackfill),
15539 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL" => Ok(StreamScanType::CrossDbSnapshotBackfill),
15540 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15541 }
15542 }
15543 }
15544 deserializer.deserialize_any(GeneratedVisitor)
15545 }
15546}
15547impl serde::Serialize for StreamSource {
15548 #[allow(deprecated)]
15549 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15550 where
15551 S: serde::Serializer,
15552 {
15553 use serde::ser::SerializeStruct;
15554 let mut len = 0;
15555 if self.source_id != 0 {
15556 len += 1;
15557 }
15558 if self.state_table.is_some() {
15559 len += 1;
15560 }
15561 if self.row_id_index.is_some() {
15562 len += 1;
15563 }
15564 if !self.columns.is_empty() {
15565 len += 1;
15566 }
15567 if !self.with_properties.is_empty() {
15568 len += 1;
15569 }
15570 if self.info.is_some() {
15571 len += 1;
15572 }
15573 if !self.source_name.is_empty() {
15574 len += 1;
15575 }
15576 if self.rate_limit.is_some() {
15577 len += 1;
15578 }
15579 if !self.secret_refs.is_empty() {
15580 len += 1;
15581 }
15582 if self.downstream_columns.is_some() {
15583 len += 1;
15584 }
15585 if self.refresh_mode.is_some() {
15586 len += 1;
15587 }
15588 if self.associated_table_id.is_some() {
15589 len += 1;
15590 }
15591 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamSource", len)?;
15592 if self.source_id != 0 {
15593 struct_ser.serialize_field("sourceId", &self.source_id)?;
15594 }
15595 if let Some(v) = self.state_table.as_ref() {
15596 struct_ser.serialize_field("stateTable", v)?;
15597 }
15598 if let Some(v) = self.row_id_index.as_ref() {
15599 struct_ser.serialize_field("rowIdIndex", v)?;
15600 }
15601 if !self.columns.is_empty() {
15602 struct_ser.serialize_field("columns", &self.columns)?;
15603 }
15604 if !self.with_properties.is_empty() {
15605 struct_ser.serialize_field("withProperties", &self.with_properties)?;
15606 }
15607 if let Some(v) = self.info.as_ref() {
15608 struct_ser.serialize_field("info", v)?;
15609 }
15610 if !self.source_name.is_empty() {
15611 struct_ser.serialize_field("sourceName", &self.source_name)?;
15612 }
15613 if let Some(v) = self.rate_limit.as_ref() {
15614 struct_ser.serialize_field("rateLimit", v)?;
15615 }
15616 if !self.secret_refs.is_empty() {
15617 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
15618 }
15619 if let Some(v) = self.downstream_columns.as_ref() {
15620 struct_ser.serialize_field("downstreamColumns", v)?;
15621 }
15622 if let Some(v) = self.refresh_mode.as_ref() {
15623 struct_ser.serialize_field("refreshMode", v)?;
15624 }
15625 if let Some(v) = self.associated_table_id.as_ref() {
15626 struct_ser.serialize_field("associatedTableId", v)?;
15627 }
15628 struct_ser.end()
15629 }
15630}
15631impl<'de> serde::Deserialize<'de> for StreamSource {
15632 #[allow(deprecated)]
15633 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15634 where
15635 D: serde::Deserializer<'de>,
15636 {
15637 const FIELDS: &[&str] = &[
15638 "source_id",
15639 "sourceId",
15640 "state_table",
15641 "stateTable",
15642 "row_id_index",
15643 "rowIdIndex",
15644 "columns",
15645 "with_properties",
15646 "withProperties",
15647 "info",
15648 "source_name",
15649 "sourceName",
15650 "rate_limit",
15651 "rateLimit",
15652 "secret_refs",
15653 "secretRefs",
15654 "downstream_columns",
15655 "downstreamColumns",
15656 "refresh_mode",
15657 "refreshMode",
15658 "associated_table_id",
15659 "associatedTableId",
15660 ];
15661
15662 #[allow(clippy::enum_variant_names)]
15663 enum GeneratedField {
15664 SourceId,
15665 StateTable,
15666 RowIdIndex,
15667 Columns,
15668 WithProperties,
15669 Info,
15670 SourceName,
15671 RateLimit,
15672 SecretRefs,
15673 DownstreamColumns,
15674 RefreshMode,
15675 AssociatedTableId,
15676 }
15677 impl<'de> serde::Deserialize<'de> for GeneratedField {
15678 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15679 where
15680 D: serde::Deserializer<'de>,
15681 {
15682 struct GeneratedVisitor;
15683
15684 impl serde::de::Visitor<'_> for GeneratedVisitor {
15685 type Value = GeneratedField;
15686
15687 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15688 write!(formatter, "expected one of: {:?}", &FIELDS)
15689 }
15690
15691 #[allow(unused_variables)]
15692 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15693 where
15694 E: serde::de::Error,
15695 {
15696 match value {
15697 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
15698 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
15699 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
15700 "columns" => Ok(GeneratedField::Columns),
15701 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
15702 "info" => Ok(GeneratedField::Info),
15703 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
15704 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
15705 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
15706 "downstreamColumns" | "downstream_columns" => Ok(GeneratedField::DownstreamColumns),
15707 "refreshMode" | "refresh_mode" => Ok(GeneratedField::RefreshMode),
15708 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
15709 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15710 }
15711 }
15712 }
15713 deserializer.deserialize_identifier(GeneratedVisitor)
15714 }
15715 }
15716 struct GeneratedVisitor;
15717 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15718 type Value = StreamSource;
15719
15720 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15721 formatter.write_str("struct stream_plan.StreamSource")
15722 }
15723
15724 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSource, V::Error>
15725 where
15726 V: serde::de::MapAccess<'de>,
15727 {
15728 let mut source_id__ = None;
15729 let mut state_table__ = None;
15730 let mut row_id_index__ = None;
15731 let mut columns__ = None;
15732 let mut with_properties__ = None;
15733 let mut info__ = None;
15734 let mut source_name__ = None;
15735 let mut rate_limit__ = None;
15736 let mut secret_refs__ = None;
15737 let mut downstream_columns__ = None;
15738 let mut refresh_mode__ = None;
15739 let mut associated_table_id__ = None;
15740 while let Some(k) = map_.next_key()? {
15741 match k {
15742 GeneratedField::SourceId => {
15743 if source_id__.is_some() {
15744 return Err(serde::de::Error::duplicate_field("sourceId"));
15745 }
15746 source_id__ =
15747 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15748 ;
15749 }
15750 GeneratedField::StateTable => {
15751 if state_table__.is_some() {
15752 return Err(serde::de::Error::duplicate_field("stateTable"));
15753 }
15754 state_table__ = map_.next_value()?;
15755 }
15756 GeneratedField::RowIdIndex => {
15757 if row_id_index__.is_some() {
15758 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
15759 }
15760 row_id_index__ =
15761 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15762 ;
15763 }
15764 GeneratedField::Columns => {
15765 if columns__.is_some() {
15766 return Err(serde::de::Error::duplicate_field("columns"));
15767 }
15768 columns__ = Some(map_.next_value()?);
15769 }
15770 GeneratedField::WithProperties => {
15771 if with_properties__.is_some() {
15772 return Err(serde::de::Error::duplicate_field("withProperties"));
15773 }
15774 with_properties__ = Some(
15775 map_.next_value::<std::collections::BTreeMap<_, _>>()?
15776 );
15777 }
15778 GeneratedField::Info => {
15779 if info__.is_some() {
15780 return Err(serde::de::Error::duplicate_field("info"));
15781 }
15782 info__ = map_.next_value()?;
15783 }
15784 GeneratedField::SourceName => {
15785 if source_name__.is_some() {
15786 return Err(serde::de::Error::duplicate_field("sourceName"));
15787 }
15788 source_name__ = Some(map_.next_value()?);
15789 }
15790 GeneratedField::RateLimit => {
15791 if rate_limit__.is_some() {
15792 return Err(serde::de::Error::duplicate_field("rateLimit"));
15793 }
15794 rate_limit__ =
15795 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15796 ;
15797 }
15798 GeneratedField::SecretRefs => {
15799 if secret_refs__.is_some() {
15800 return Err(serde::de::Error::duplicate_field("secretRefs"));
15801 }
15802 secret_refs__ = Some(
15803 map_.next_value::<std::collections::BTreeMap<_, _>>()?
15804 );
15805 }
15806 GeneratedField::DownstreamColumns => {
15807 if downstream_columns__.is_some() {
15808 return Err(serde::de::Error::duplicate_field("downstreamColumns"));
15809 }
15810 downstream_columns__ = map_.next_value()?;
15811 }
15812 GeneratedField::RefreshMode => {
15813 if refresh_mode__.is_some() {
15814 return Err(serde::de::Error::duplicate_field("refreshMode"));
15815 }
15816 refresh_mode__ = map_.next_value()?;
15817 }
15818 GeneratedField::AssociatedTableId => {
15819 if associated_table_id__.is_some() {
15820 return Err(serde::de::Error::duplicate_field("associatedTableId"));
15821 }
15822 associated_table_id__ =
15823 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15824 ;
15825 }
15826 }
15827 }
15828 Ok(StreamSource {
15829 source_id: source_id__.unwrap_or_default(),
15830 state_table: state_table__,
15831 row_id_index: row_id_index__,
15832 columns: columns__.unwrap_or_default(),
15833 with_properties: with_properties__.unwrap_or_default(),
15834 info: info__,
15835 source_name: source_name__.unwrap_or_default(),
15836 rate_limit: rate_limit__,
15837 secret_refs: secret_refs__.unwrap_or_default(),
15838 downstream_columns: downstream_columns__,
15839 refresh_mode: refresh_mode__,
15840 associated_table_id: associated_table_id__,
15841 })
15842 }
15843 }
15844 deserializer.deserialize_struct("stream_plan.StreamSource", FIELDS, GeneratedVisitor)
15845 }
15846}
15847impl serde::Serialize for SubscriptionUpstreamInfo {
15848 #[allow(deprecated)]
15849 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15850 where
15851 S: serde::Serializer,
15852 {
15853 use serde::ser::SerializeStruct;
15854 let mut len = 0;
15855 if self.subscriber_id != 0 {
15856 len += 1;
15857 }
15858 if self.upstream_mv_table_id != 0 {
15859 len += 1;
15860 }
15861 let mut struct_ser = serializer.serialize_struct("stream_plan.SubscriptionUpstreamInfo", len)?;
15862 if self.subscriber_id != 0 {
15863 struct_ser.serialize_field("subscriberId", &self.subscriber_id)?;
15864 }
15865 if self.upstream_mv_table_id != 0 {
15866 struct_ser.serialize_field("upstreamMvTableId", &self.upstream_mv_table_id)?;
15867 }
15868 struct_ser.end()
15869 }
15870}
15871impl<'de> serde::Deserialize<'de> for SubscriptionUpstreamInfo {
15872 #[allow(deprecated)]
15873 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15874 where
15875 D: serde::Deserializer<'de>,
15876 {
15877 const FIELDS: &[&str] = &[
15878 "subscriber_id",
15879 "subscriberId",
15880 "upstream_mv_table_id",
15881 "upstreamMvTableId",
15882 ];
15883
15884 #[allow(clippy::enum_variant_names)]
15885 enum GeneratedField {
15886 SubscriberId,
15887 UpstreamMvTableId,
15888 }
15889 impl<'de> serde::Deserialize<'de> for GeneratedField {
15890 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15891 where
15892 D: serde::Deserializer<'de>,
15893 {
15894 struct GeneratedVisitor;
15895
15896 impl serde::de::Visitor<'_> for GeneratedVisitor {
15897 type Value = GeneratedField;
15898
15899 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15900 write!(formatter, "expected one of: {:?}", &FIELDS)
15901 }
15902
15903 #[allow(unused_variables)]
15904 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15905 where
15906 E: serde::de::Error,
15907 {
15908 match value {
15909 "subscriberId" | "subscriber_id" => Ok(GeneratedField::SubscriberId),
15910 "upstreamMvTableId" | "upstream_mv_table_id" => Ok(GeneratedField::UpstreamMvTableId),
15911 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15912 }
15913 }
15914 }
15915 deserializer.deserialize_identifier(GeneratedVisitor)
15916 }
15917 }
15918 struct GeneratedVisitor;
15919 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15920 type Value = SubscriptionUpstreamInfo;
15921
15922 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15923 formatter.write_str("struct stream_plan.SubscriptionUpstreamInfo")
15924 }
15925
15926 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscriptionUpstreamInfo, V::Error>
15927 where
15928 V: serde::de::MapAccess<'de>,
15929 {
15930 let mut subscriber_id__ = None;
15931 let mut upstream_mv_table_id__ = None;
15932 while let Some(k) = map_.next_key()? {
15933 match k {
15934 GeneratedField::SubscriberId => {
15935 if subscriber_id__.is_some() {
15936 return Err(serde::de::Error::duplicate_field("subscriberId"));
15937 }
15938 subscriber_id__ =
15939 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15940 ;
15941 }
15942 GeneratedField::UpstreamMvTableId => {
15943 if upstream_mv_table_id__.is_some() {
15944 return Err(serde::de::Error::duplicate_field("upstreamMvTableId"));
15945 }
15946 upstream_mv_table_id__ =
15947 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15948 ;
15949 }
15950 }
15951 }
15952 Ok(SubscriptionUpstreamInfo {
15953 subscriber_id: subscriber_id__.unwrap_or_default(),
15954 upstream_mv_table_id: upstream_mv_table_id__.unwrap_or_default(),
15955 })
15956 }
15957 }
15958 deserializer.deserialize_struct("stream_plan.SubscriptionUpstreamInfo", FIELDS, GeneratedVisitor)
15959 }
15960}
15961impl serde::Serialize for SyncLogStoreNode {
15962 #[allow(deprecated)]
15963 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15964 where
15965 S: serde::Serializer,
15966 {
15967 use serde::ser::SerializeStruct;
15968 let mut len = 0;
15969 if self.log_store_table.is_some() {
15970 len += 1;
15971 }
15972 if self.pause_duration_ms.is_some() {
15973 len += 1;
15974 }
15975 if self.buffer_size.is_some() {
15976 len += 1;
15977 }
15978 if self.aligned {
15979 len += 1;
15980 }
15981 let mut struct_ser = serializer.serialize_struct("stream_plan.SyncLogStoreNode", len)?;
15982 if let Some(v) = self.log_store_table.as_ref() {
15983 struct_ser.serialize_field("logStoreTable", v)?;
15984 }
15985 if let Some(v) = self.pause_duration_ms.as_ref() {
15986 struct_ser.serialize_field("pauseDurationMs", v)?;
15987 }
15988 if let Some(v) = self.buffer_size.as_ref() {
15989 struct_ser.serialize_field("bufferSize", v)?;
15990 }
15991 if self.aligned {
15992 struct_ser.serialize_field("aligned", &self.aligned)?;
15993 }
15994 struct_ser.end()
15995 }
15996}
15997impl<'de> serde::Deserialize<'de> for SyncLogStoreNode {
15998 #[allow(deprecated)]
15999 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16000 where
16001 D: serde::Deserializer<'de>,
16002 {
16003 const FIELDS: &[&str] = &[
16004 "log_store_table",
16005 "logStoreTable",
16006 "pause_duration_ms",
16007 "pauseDurationMs",
16008 "buffer_size",
16009 "bufferSize",
16010 "aligned",
16011 ];
16012
16013 #[allow(clippy::enum_variant_names)]
16014 enum GeneratedField {
16015 LogStoreTable,
16016 PauseDurationMs,
16017 BufferSize,
16018 Aligned,
16019 }
16020 impl<'de> serde::Deserialize<'de> for GeneratedField {
16021 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16022 where
16023 D: serde::Deserializer<'de>,
16024 {
16025 struct GeneratedVisitor;
16026
16027 impl serde::de::Visitor<'_> for GeneratedVisitor {
16028 type Value = GeneratedField;
16029
16030 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16031 write!(formatter, "expected one of: {:?}", &FIELDS)
16032 }
16033
16034 #[allow(unused_variables)]
16035 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16036 where
16037 E: serde::de::Error,
16038 {
16039 match value {
16040 "logStoreTable" | "log_store_table" => Ok(GeneratedField::LogStoreTable),
16041 "pauseDurationMs" | "pause_duration_ms" => Ok(GeneratedField::PauseDurationMs),
16042 "bufferSize" | "buffer_size" => Ok(GeneratedField::BufferSize),
16043 "aligned" => Ok(GeneratedField::Aligned),
16044 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16045 }
16046 }
16047 }
16048 deserializer.deserialize_identifier(GeneratedVisitor)
16049 }
16050 }
16051 struct GeneratedVisitor;
16052 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16053 type Value = SyncLogStoreNode;
16054
16055 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16056 formatter.write_str("struct stream_plan.SyncLogStoreNode")
16057 }
16058
16059 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SyncLogStoreNode, V::Error>
16060 where
16061 V: serde::de::MapAccess<'de>,
16062 {
16063 let mut log_store_table__ = None;
16064 let mut pause_duration_ms__ = None;
16065 let mut buffer_size__ = None;
16066 let mut aligned__ = None;
16067 while let Some(k) = map_.next_key()? {
16068 match k {
16069 GeneratedField::LogStoreTable => {
16070 if log_store_table__.is_some() {
16071 return Err(serde::de::Error::duplicate_field("logStoreTable"));
16072 }
16073 log_store_table__ = map_.next_value()?;
16074 }
16075 GeneratedField::PauseDurationMs => {
16076 if pause_duration_ms__.is_some() {
16077 return Err(serde::de::Error::duplicate_field("pauseDurationMs"));
16078 }
16079 pause_duration_ms__ =
16080 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16081 ;
16082 }
16083 GeneratedField::BufferSize => {
16084 if buffer_size__.is_some() {
16085 return Err(serde::de::Error::duplicate_field("bufferSize"));
16086 }
16087 buffer_size__ =
16088 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16089 ;
16090 }
16091 GeneratedField::Aligned => {
16092 if aligned__.is_some() {
16093 return Err(serde::de::Error::duplicate_field("aligned"));
16094 }
16095 aligned__ = Some(map_.next_value()?);
16096 }
16097 }
16098 }
16099 Ok(SyncLogStoreNode {
16100 log_store_table: log_store_table__,
16101 pause_duration_ms: pause_duration_ms__,
16102 buffer_size: buffer_size__,
16103 aligned: aligned__.unwrap_or_default(),
16104 })
16105 }
16106 }
16107 deserializer.deserialize_struct("stream_plan.SyncLogStoreNode", FIELDS, GeneratedVisitor)
16108 }
16109}
16110impl serde::Serialize for TemporalJoinNode {
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.join_type != 0 {
16119 len += 1;
16120 }
16121 if !self.left_key.is_empty() {
16122 len += 1;
16123 }
16124 if !self.right_key.is_empty() {
16125 len += 1;
16126 }
16127 if !self.null_safe.is_empty() {
16128 len += 1;
16129 }
16130 if self.condition.is_some() {
16131 len += 1;
16132 }
16133 if !self.output_indices.is_empty() {
16134 len += 1;
16135 }
16136 if self.table_desc.is_some() {
16137 len += 1;
16138 }
16139 if !self.table_output_indices.is_empty() {
16140 len += 1;
16141 }
16142 if self.memo_table.is_some() {
16143 len += 1;
16144 }
16145 if self.is_nested_loop {
16146 len += 1;
16147 }
16148 let mut struct_ser = serializer.serialize_struct("stream_plan.TemporalJoinNode", len)?;
16149 if self.join_type != 0 {
16150 let v = super::plan_common::JoinType::try_from(self.join_type)
16151 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
16152 struct_ser.serialize_field("joinType", &v)?;
16153 }
16154 if !self.left_key.is_empty() {
16155 struct_ser.serialize_field("leftKey", &self.left_key)?;
16156 }
16157 if !self.right_key.is_empty() {
16158 struct_ser.serialize_field("rightKey", &self.right_key)?;
16159 }
16160 if !self.null_safe.is_empty() {
16161 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
16162 }
16163 if let Some(v) = self.condition.as_ref() {
16164 struct_ser.serialize_field("condition", v)?;
16165 }
16166 if !self.output_indices.is_empty() {
16167 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
16168 }
16169 if let Some(v) = self.table_desc.as_ref() {
16170 struct_ser.serialize_field("tableDesc", v)?;
16171 }
16172 if !self.table_output_indices.is_empty() {
16173 struct_ser.serialize_field("tableOutputIndices", &self.table_output_indices)?;
16174 }
16175 if let Some(v) = self.memo_table.as_ref() {
16176 struct_ser.serialize_field("memoTable", v)?;
16177 }
16178 if self.is_nested_loop {
16179 struct_ser.serialize_field("isNestedLoop", &self.is_nested_loop)?;
16180 }
16181 struct_ser.end()
16182 }
16183}
16184impl<'de> serde::Deserialize<'de> for TemporalJoinNode {
16185 #[allow(deprecated)]
16186 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16187 where
16188 D: serde::Deserializer<'de>,
16189 {
16190 const FIELDS: &[&str] = &[
16191 "join_type",
16192 "joinType",
16193 "left_key",
16194 "leftKey",
16195 "right_key",
16196 "rightKey",
16197 "null_safe",
16198 "nullSafe",
16199 "condition",
16200 "output_indices",
16201 "outputIndices",
16202 "table_desc",
16203 "tableDesc",
16204 "table_output_indices",
16205 "tableOutputIndices",
16206 "memo_table",
16207 "memoTable",
16208 "is_nested_loop",
16209 "isNestedLoop",
16210 ];
16211
16212 #[allow(clippy::enum_variant_names)]
16213 enum GeneratedField {
16214 JoinType,
16215 LeftKey,
16216 RightKey,
16217 NullSafe,
16218 Condition,
16219 OutputIndices,
16220 TableDesc,
16221 TableOutputIndices,
16222 MemoTable,
16223 IsNestedLoop,
16224 }
16225 impl<'de> serde::Deserialize<'de> for GeneratedField {
16226 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16227 where
16228 D: serde::Deserializer<'de>,
16229 {
16230 struct GeneratedVisitor;
16231
16232 impl serde::de::Visitor<'_> for GeneratedVisitor {
16233 type Value = GeneratedField;
16234
16235 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16236 write!(formatter, "expected one of: {:?}", &FIELDS)
16237 }
16238
16239 #[allow(unused_variables)]
16240 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16241 where
16242 E: serde::de::Error,
16243 {
16244 match value {
16245 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
16246 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
16247 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
16248 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
16249 "condition" => Ok(GeneratedField::Condition),
16250 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
16251 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
16252 "tableOutputIndices" | "table_output_indices" => Ok(GeneratedField::TableOutputIndices),
16253 "memoTable" | "memo_table" => Ok(GeneratedField::MemoTable),
16254 "isNestedLoop" | "is_nested_loop" => Ok(GeneratedField::IsNestedLoop),
16255 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16256 }
16257 }
16258 }
16259 deserializer.deserialize_identifier(GeneratedVisitor)
16260 }
16261 }
16262 struct GeneratedVisitor;
16263 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16264 type Value = TemporalJoinNode;
16265
16266 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16267 formatter.write_str("struct stream_plan.TemporalJoinNode")
16268 }
16269
16270 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TemporalJoinNode, V::Error>
16271 where
16272 V: serde::de::MapAccess<'de>,
16273 {
16274 let mut join_type__ = None;
16275 let mut left_key__ = None;
16276 let mut right_key__ = None;
16277 let mut null_safe__ = None;
16278 let mut condition__ = None;
16279 let mut output_indices__ = None;
16280 let mut table_desc__ = None;
16281 let mut table_output_indices__ = None;
16282 let mut memo_table__ = None;
16283 let mut is_nested_loop__ = None;
16284 while let Some(k) = map_.next_key()? {
16285 match k {
16286 GeneratedField::JoinType => {
16287 if join_type__.is_some() {
16288 return Err(serde::de::Error::duplicate_field("joinType"));
16289 }
16290 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
16291 }
16292 GeneratedField::LeftKey => {
16293 if left_key__.is_some() {
16294 return Err(serde::de::Error::duplicate_field("leftKey"));
16295 }
16296 left_key__ =
16297 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16298 .into_iter().map(|x| x.0).collect())
16299 ;
16300 }
16301 GeneratedField::RightKey => {
16302 if right_key__.is_some() {
16303 return Err(serde::de::Error::duplicate_field("rightKey"));
16304 }
16305 right_key__ =
16306 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16307 .into_iter().map(|x| x.0).collect())
16308 ;
16309 }
16310 GeneratedField::NullSafe => {
16311 if null_safe__.is_some() {
16312 return Err(serde::de::Error::duplicate_field("nullSafe"));
16313 }
16314 null_safe__ = Some(map_.next_value()?);
16315 }
16316 GeneratedField::Condition => {
16317 if condition__.is_some() {
16318 return Err(serde::de::Error::duplicate_field("condition"));
16319 }
16320 condition__ = map_.next_value()?;
16321 }
16322 GeneratedField::OutputIndices => {
16323 if output_indices__.is_some() {
16324 return Err(serde::de::Error::duplicate_field("outputIndices"));
16325 }
16326 output_indices__ =
16327 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16328 .into_iter().map(|x| x.0).collect())
16329 ;
16330 }
16331 GeneratedField::TableDesc => {
16332 if table_desc__.is_some() {
16333 return Err(serde::de::Error::duplicate_field("tableDesc"));
16334 }
16335 table_desc__ = map_.next_value()?;
16336 }
16337 GeneratedField::TableOutputIndices => {
16338 if table_output_indices__.is_some() {
16339 return Err(serde::de::Error::duplicate_field("tableOutputIndices"));
16340 }
16341 table_output_indices__ =
16342 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16343 .into_iter().map(|x| x.0).collect())
16344 ;
16345 }
16346 GeneratedField::MemoTable => {
16347 if memo_table__.is_some() {
16348 return Err(serde::de::Error::duplicate_field("memoTable"));
16349 }
16350 memo_table__ = map_.next_value()?;
16351 }
16352 GeneratedField::IsNestedLoop => {
16353 if is_nested_loop__.is_some() {
16354 return Err(serde::de::Error::duplicate_field("isNestedLoop"));
16355 }
16356 is_nested_loop__ = Some(map_.next_value()?);
16357 }
16358 }
16359 }
16360 Ok(TemporalJoinNode {
16361 join_type: join_type__.unwrap_or_default(),
16362 left_key: left_key__.unwrap_or_default(),
16363 right_key: right_key__.unwrap_or_default(),
16364 null_safe: null_safe__.unwrap_or_default(),
16365 condition: condition__,
16366 output_indices: output_indices__.unwrap_or_default(),
16367 table_desc: table_desc__,
16368 table_output_indices: table_output_indices__.unwrap_or_default(),
16369 memo_table: memo_table__,
16370 is_nested_loop: is_nested_loop__.unwrap_or_default(),
16371 })
16372 }
16373 }
16374 deserializer.deserialize_struct("stream_plan.TemporalJoinNode", FIELDS, GeneratedVisitor)
16375 }
16376}
16377impl serde::Serialize for ThrottleMutation {
16378 #[allow(deprecated)]
16379 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16380 where
16381 S: serde::Serializer,
16382 {
16383 use serde::ser::SerializeStruct;
16384 let mut len = 0;
16385 if !self.fragment_throttle.is_empty() {
16386 len += 1;
16387 }
16388 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation", len)?;
16389 if !self.fragment_throttle.is_empty() {
16390 struct_ser.serialize_field("fragmentThrottle", &self.fragment_throttle)?;
16391 }
16392 struct_ser.end()
16393 }
16394}
16395impl<'de> serde::Deserialize<'de> for ThrottleMutation {
16396 #[allow(deprecated)]
16397 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16398 where
16399 D: serde::Deserializer<'de>,
16400 {
16401 const FIELDS: &[&str] = &[
16402 "fragment_throttle",
16403 "fragmentThrottle",
16404 ];
16405
16406 #[allow(clippy::enum_variant_names)]
16407 enum GeneratedField {
16408 FragmentThrottle,
16409 }
16410 impl<'de> serde::Deserialize<'de> for GeneratedField {
16411 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16412 where
16413 D: serde::Deserializer<'de>,
16414 {
16415 struct GeneratedVisitor;
16416
16417 impl serde::de::Visitor<'_> for GeneratedVisitor {
16418 type Value = GeneratedField;
16419
16420 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16421 write!(formatter, "expected one of: {:?}", &FIELDS)
16422 }
16423
16424 #[allow(unused_variables)]
16425 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16426 where
16427 E: serde::de::Error,
16428 {
16429 match value {
16430 "fragmentThrottle" | "fragment_throttle" => Ok(GeneratedField::FragmentThrottle),
16431 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16432 }
16433 }
16434 }
16435 deserializer.deserialize_identifier(GeneratedVisitor)
16436 }
16437 }
16438 struct GeneratedVisitor;
16439 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16440 type Value = ThrottleMutation;
16441
16442 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16443 formatter.write_str("struct stream_plan.ThrottleMutation")
16444 }
16445
16446 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ThrottleMutation, V::Error>
16447 where
16448 V: serde::de::MapAccess<'de>,
16449 {
16450 let mut fragment_throttle__ = None;
16451 while let Some(k) = map_.next_key()? {
16452 match k {
16453 GeneratedField::FragmentThrottle => {
16454 if fragment_throttle__.is_some() {
16455 return Err(serde::de::Error::duplicate_field("fragmentThrottle"));
16456 }
16457 fragment_throttle__ = Some(
16458 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
16459 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
16460 );
16461 }
16462 }
16463 }
16464 Ok(ThrottleMutation {
16465 fragment_throttle: fragment_throttle__.unwrap_or_default(),
16466 })
16467 }
16468 }
16469 deserializer.deserialize_struct("stream_plan.ThrottleMutation", FIELDS, GeneratedVisitor)
16470 }
16471}
16472impl serde::Serialize for throttle_mutation::ThrottleConfig {
16473 #[allow(deprecated)]
16474 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16475 where
16476 S: serde::Serializer,
16477 {
16478 use serde::ser::SerializeStruct;
16479 let mut len = 0;
16480 if self.rate_limit.is_some() {
16481 len += 1;
16482 }
16483 if self.throttle_type != 0 {
16484 len += 1;
16485 }
16486 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation.ThrottleConfig", len)?;
16487 if let Some(v) = self.rate_limit.as_ref() {
16488 struct_ser.serialize_field("rateLimit", v)?;
16489 }
16490 if self.throttle_type != 0 {
16491 let v = super::common::ThrottleType::try_from(self.throttle_type)
16492 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.throttle_type)))?;
16493 struct_ser.serialize_field("throttleType", &v)?;
16494 }
16495 struct_ser.end()
16496 }
16497}
16498impl<'de> serde::Deserialize<'de> for throttle_mutation::ThrottleConfig {
16499 #[allow(deprecated)]
16500 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16501 where
16502 D: serde::Deserializer<'de>,
16503 {
16504 const FIELDS: &[&str] = &[
16505 "rate_limit",
16506 "rateLimit",
16507 "throttle_type",
16508 "throttleType",
16509 ];
16510
16511 #[allow(clippy::enum_variant_names)]
16512 enum GeneratedField {
16513 RateLimit,
16514 ThrottleType,
16515 }
16516 impl<'de> serde::Deserialize<'de> for GeneratedField {
16517 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16518 where
16519 D: serde::Deserializer<'de>,
16520 {
16521 struct GeneratedVisitor;
16522
16523 impl serde::de::Visitor<'_> for GeneratedVisitor {
16524 type Value = GeneratedField;
16525
16526 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16527 write!(formatter, "expected one of: {:?}", &FIELDS)
16528 }
16529
16530 #[allow(unused_variables)]
16531 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16532 where
16533 E: serde::de::Error,
16534 {
16535 match value {
16536 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
16537 "throttleType" | "throttle_type" => Ok(GeneratedField::ThrottleType),
16538 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16539 }
16540 }
16541 }
16542 deserializer.deserialize_identifier(GeneratedVisitor)
16543 }
16544 }
16545 struct GeneratedVisitor;
16546 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16547 type Value = throttle_mutation::ThrottleConfig;
16548
16549 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16550 formatter.write_str("struct stream_plan.ThrottleMutation.ThrottleConfig")
16551 }
16552
16553 fn visit_map<V>(self, mut map_: V) -> std::result::Result<throttle_mutation::ThrottleConfig, V::Error>
16554 where
16555 V: serde::de::MapAccess<'de>,
16556 {
16557 let mut rate_limit__ = None;
16558 let mut throttle_type__ = None;
16559 while let Some(k) = map_.next_key()? {
16560 match k {
16561 GeneratedField::RateLimit => {
16562 if rate_limit__.is_some() {
16563 return Err(serde::de::Error::duplicate_field("rateLimit"));
16564 }
16565 rate_limit__ =
16566 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16567 ;
16568 }
16569 GeneratedField::ThrottleType => {
16570 if throttle_type__.is_some() {
16571 return Err(serde::de::Error::duplicate_field("throttleType"));
16572 }
16573 throttle_type__ = Some(map_.next_value::<super::common::ThrottleType>()? as i32);
16574 }
16575 }
16576 }
16577 Ok(throttle_mutation::ThrottleConfig {
16578 rate_limit: rate_limit__,
16579 throttle_type: throttle_type__.unwrap_or_default(),
16580 })
16581 }
16582 }
16583 deserializer.deserialize_struct("stream_plan.ThrottleMutation.ThrottleConfig", FIELDS, GeneratedVisitor)
16584 }
16585}
16586impl serde::Serialize for TopNNode {
16587 #[allow(deprecated)]
16588 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16589 where
16590 S: serde::Serializer,
16591 {
16592 use serde::ser::SerializeStruct;
16593 let mut len = 0;
16594 if self.limit != 0 {
16595 len += 1;
16596 }
16597 if self.offset != 0 {
16598 len += 1;
16599 }
16600 if self.table.is_some() {
16601 len += 1;
16602 }
16603 if !self.order_by.is_empty() {
16604 len += 1;
16605 }
16606 if self.with_ties {
16607 len += 1;
16608 }
16609 let mut struct_ser = serializer.serialize_struct("stream_plan.TopNNode", len)?;
16610 if self.limit != 0 {
16611 #[allow(clippy::needless_borrow)]
16612 #[allow(clippy::needless_borrows_for_generic_args)]
16613 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
16614 }
16615 if self.offset != 0 {
16616 #[allow(clippy::needless_borrow)]
16617 #[allow(clippy::needless_borrows_for_generic_args)]
16618 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
16619 }
16620 if let Some(v) = self.table.as_ref() {
16621 struct_ser.serialize_field("table", v)?;
16622 }
16623 if !self.order_by.is_empty() {
16624 struct_ser.serialize_field("orderBy", &self.order_by)?;
16625 }
16626 if self.with_ties {
16627 struct_ser.serialize_field("withTies", &self.with_ties)?;
16628 }
16629 struct_ser.end()
16630 }
16631}
16632impl<'de> serde::Deserialize<'de> for TopNNode {
16633 #[allow(deprecated)]
16634 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16635 where
16636 D: serde::Deserializer<'de>,
16637 {
16638 const FIELDS: &[&str] = &[
16639 "limit",
16640 "offset",
16641 "table",
16642 "order_by",
16643 "orderBy",
16644 "with_ties",
16645 "withTies",
16646 ];
16647
16648 #[allow(clippy::enum_variant_names)]
16649 enum GeneratedField {
16650 Limit,
16651 Offset,
16652 Table,
16653 OrderBy,
16654 WithTies,
16655 }
16656 impl<'de> serde::Deserialize<'de> for GeneratedField {
16657 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16658 where
16659 D: serde::Deserializer<'de>,
16660 {
16661 struct GeneratedVisitor;
16662
16663 impl serde::de::Visitor<'_> for GeneratedVisitor {
16664 type Value = GeneratedField;
16665
16666 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16667 write!(formatter, "expected one of: {:?}", &FIELDS)
16668 }
16669
16670 #[allow(unused_variables)]
16671 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16672 where
16673 E: serde::de::Error,
16674 {
16675 match value {
16676 "limit" => Ok(GeneratedField::Limit),
16677 "offset" => Ok(GeneratedField::Offset),
16678 "table" => Ok(GeneratedField::Table),
16679 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
16680 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
16681 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16682 }
16683 }
16684 }
16685 deserializer.deserialize_identifier(GeneratedVisitor)
16686 }
16687 }
16688 struct GeneratedVisitor;
16689 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16690 type Value = TopNNode;
16691
16692 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16693 formatter.write_str("struct stream_plan.TopNNode")
16694 }
16695
16696 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
16697 where
16698 V: serde::de::MapAccess<'de>,
16699 {
16700 let mut limit__ = None;
16701 let mut offset__ = None;
16702 let mut table__ = None;
16703 let mut order_by__ = None;
16704 let mut with_ties__ = None;
16705 while let Some(k) = map_.next_key()? {
16706 match k {
16707 GeneratedField::Limit => {
16708 if limit__.is_some() {
16709 return Err(serde::de::Error::duplicate_field("limit"));
16710 }
16711 limit__ =
16712 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16713 ;
16714 }
16715 GeneratedField::Offset => {
16716 if offset__.is_some() {
16717 return Err(serde::de::Error::duplicate_field("offset"));
16718 }
16719 offset__ =
16720 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16721 ;
16722 }
16723 GeneratedField::Table => {
16724 if table__.is_some() {
16725 return Err(serde::de::Error::duplicate_field("table"));
16726 }
16727 table__ = map_.next_value()?;
16728 }
16729 GeneratedField::OrderBy => {
16730 if order_by__.is_some() {
16731 return Err(serde::de::Error::duplicate_field("orderBy"));
16732 }
16733 order_by__ = Some(map_.next_value()?);
16734 }
16735 GeneratedField::WithTies => {
16736 if with_ties__.is_some() {
16737 return Err(serde::de::Error::duplicate_field("withTies"));
16738 }
16739 with_ties__ = Some(map_.next_value()?);
16740 }
16741 }
16742 }
16743 Ok(TopNNode {
16744 limit: limit__.unwrap_or_default(),
16745 offset: offset__.unwrap_or_default(),
16746 table: table__,
16747 order_by: order_by__.unwrap_or_default(),
16748 with_ties: with_ties__.unwrap_or_default(),
16749 })
16750 }
16751 }
16752 deserializer.deserialize_struct("stream_plan.TopNNode", FIELDS, GeneratedVisitor)
16753 }
16754}
16755impl serde::Serialize for UnionNode {
16756 #[allow(deprecated)]
16757 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16758 where
16759 S: serde::Serializer,
16760 {
16761 use serde::ser::SerializeStruct;
16762 let len = 0;
16763 let struct_ser = serializer.serialize_struct("stream_plan.UnionNode", len)?;
16764 struct_ser.end()
16765 }
16766}
16767impl<'de> serde::Deserialize<'de> for UnionNode {
16768 #[allow(deprecated)]
16769 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16770 where
16771 D: serde::Deserializer<'de>,
16772 {
16773 const FIELDS: &[&str] = &[
16774 ];
16775
16776 #[allow(clippy::enum_variant_names)]
16777 enum GeneratedField {
16778 }
16779 impl<'de> serde::Deserialize<'de> for GeneratedField {
16780 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16781 where
16782 D: serde::Deserializer<'de>,
16783 {
16784 struct GeneratedVisitor;
16785
16786 impl serde::de::Visitor<'_> for GeneratedVisitor {
16787 type Value = GeneratedField;
16788
16789 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16790 write!(formatter, "expected one of: {:?}", &FIELDS)
16791 }
16792
16793 #[allow(unused_variables)]
16794 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16795 where
16796 E: serde::de::Error,
16797 {
16798 Err(serde::de::Error::unknown_field(value, FIELDS))
16799 }
16800 }
16801 deserializer.deserialize_identifier(GeneratedVisitor)
16802 }
16803 }
16804 struct GeneratedVisitor;
16805 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16806 type Value = UnionNode;
16807
16808 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16809 formatter.write_str("struct stream_plan.UnionNode")
16810 }
16811
16812 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
16813 where
16814 V: serde::de::MapAccess<'de>,
16815 {
16816 while map_.next_key::<GeneratedField>()?.is_some() {
16817 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16818 }
16819 Ok(UnionNode {
16820 })
16821 }
16822 }
16823 deserializer.deserialize_struct("stream_plan.UnionNode", FIELDS, GeneratedVisitor)
16824 }
16825}
16826impl serde::Serialize for UpdateMutation {
16827 #[allow(deprecated)]
16828 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16829 where
16830 S: serde::Serializer,
16831 {
16832 use serde::ser::SerializeStruct;
16833 let mut len = 0;
16834 if !self.dispatcher_update.is_empty() {
16835 len += 1;
16836 }
16837 if !self.merge_update.is_empty() {
16838 len += 1;
16839 }
16840 if !self.actor_vnode_bitmap_update.is_empty() {
16841 len += 1;
16842 }
16843 if !self.dropped_actors.is_empty() {
16844 len += 1;
16845 }
16846 if !self.actor_splits.is_empty() {
16847 len += 1;
16848 }
16849 if !self.actor_new_dispatchers.is_empty() {
16850 len += 1;
16851 }
16852 if self.actor_cdc_table_snapshot_splits.is_some() {
16853 len += 1;
16854 }
16855 if !self.sink_schema_change.is_empty() {
16856 len += 1;
16857 }
16858 if !self.subscriptions_to_drop.is_empty() {
16859 len += 1;
16860 }
16861 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation", len)?;
16862 if !self.dispatcher_update.is_empty() {
16863 struct_ser.serialize_field("dispatcherUpdate", &self.dispatcher_update)?;
16864 }
16865 if !self.merge_update.is_empty() {
16866 struct_ser.serialize_field("mergeUpdate", &self.merge_update)?;
16867 }
16868 if !self.actor_vnode_bitmap_update.is_empty() {
16869 struct_ser.serialize_field("actorVnodeBitmapUpdate", &self.actor_vnode_bitmap_update)?;
16870 }
16871 if !self.dropped_actors.is_empty() {
16872 struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
16873 }
16874 if !self.actor_splits.is_empty() {
16875 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
16876 }
16877 if !self.actor_new_dispatchers.is_empty() {
16878 struct_ser.serialize_field("actorNewDispatchers", &self.actor_new_dispatchers)?;
16879 }
16880 if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
16881 struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
16882 }
16883 if !self.sink_schema_change.is_empty() {
16884 struct_ser.serialize_field("sinkSchemaChange", &self.sink_schema_change)?;
16885 }
16886 if !self.subscriptions_to_drop.is_empty() {
16887 struct_ser.serialize_field("subscriptionsToDrop", &self.subscriptions_to_drop)?;
16888 }
16889 struct_ser.end()
16890 }
16891}
16892impl<'de> serde::Deserialize<'de> for UpdateMutation {
16893 #[allow(deprecated)]
16894 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16895 where
16896 D: serde::Deserializer<'de>,
16897 {
16898 const FIELDS: &[&str] = &[
16899 "dispatcher_update",
16900 "dispatcherUpdate",
16901 "merge_update",
16902 "mergeUpdate",
16903 "actor_vnode_bitmap_update",
16904 "actorVnodeBitmapUpdate",
16905 "dropped_actors",
16906 "droppedActors",
16907 "actor_splits",
16908 "actorSplits",
16909 "actor_new_dispatchers",
16910 "actorNewDispatchers",
16911 "actor_cdc_table_snapshot_splits",
16912 "actorCdcTableSnapshotSplits",
16913 "sink_schema_change",
16914 "sinkSchemaChange",
16915 "subscriptions_to_drop",
16916 "subscriptionsToDrop",
16917 ];
16918
16919 #[allow(clippy::enum_variant_names)]
16920 enum GeneratedField {
16921 DispatcherUpdate,
16922 MergeUpdate,
16923 ActorVnodeBitmapUpdate,
16924 DroppedActors,
16925 ActorSplits,
16926 ActorNewDispatchers,
16927 ActorCdcTableSnapshotSplits,
16928 SinkSchemaChange,
16929 SubscriptionsToDrop,
16930 }
16931 impl<'de> serde::Deserialize<'de> for GeneratedField {
16932 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16933 where
16934 D: serde::Deserializer<'de>,
16935 {
16936 struct GeneratedVisitor;
16937
16938 impl serde::de::Visitor<'_> for GeneratedVisitor {
16939 type Value = GeneratedField;
16940
16941 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16942 write!(formatter, "expected one of: {:?}", &FIELDS)
16943 }
16944
16945 #[allow(unused_variables)]
16946 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16947 where
16948 E: serde::de::Error,
16949 {
16950 match value {
16951 "dispatcherUpdate" | "dispatcher_update" => Ok(GeneratedField::DispatcherUpdate),
16952 "mergeUpdate" | "merge_update" => Ok(GeneratedField::MergeUpdate),
16953 "actorVnodeBitmapUpdate" | "actor_vnode_bitmap_update" => Ok(GeneratedField::ActorVnodeBitmapUpdate),
16954 "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
16955 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
16956 "actorNewDispatchers" | "actor_new_dispatchers" => Ok(GeneratedField::ActorNewDispatchers),
16957 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
16958 "sinkSchemaChange" | "sink_schema_change" => Ok(GeneratedField::SinkSchemaChange),
16959 "subscriptionsToDrop" | "subscriptions_to_drop" => Ok(GeneratedField::SubscriptionsToDrop),
16960 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16961 }
16962 }
16963 }
16964 deserializer.deserialize_identifier(GeneratedVisitor)
16965 }
16966 }
16967 struct GeneratedVisitor;
16968 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16969 type Value = UpdateMutation;
16970
16971 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16972 formatter.write_str("struct stream_plan.UpdateMutation")
16973 }
16974
16975 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateMutation, V::Error>
16976 where
16977 V: serde::de::MapAccess<'de>,
16978 {
16979 let mut dispatcher_update__ = None;
16980 let mut merge_update__ = None;
16981 let mut actor_vnode_bitmap_update__ = None;
16982 let mut dropped_actors__ = None;
16983 let mut actor_splits__ = None;
16984 let mut actor_new_dispatchers__ = None;
16985 let mut actor_cdc_table_snapshot_splits__ = None;
16986 let mut sink_schema_change__ = None;
16987 let mut subscriptions_to_drop__ = None;
16988 while let Some(k) = map_.next_key()? {
16989 match k {
16990 GeneratedField::DispatcherUpdate => {
16991 if dispatcher_update__.is_some() {
16992 return Err(serde::de::Error::duplicate_field("dispatcherUpdate"));
16993 }
16994 dispatcher_update__ = Some(map_.next_value()?);
16995 }
16996 GeneratedField::MergeUpdate => {
16997 if merge_update__.is_some() {
16998 return Err(serde::de::Error::duplicate_field("mergeUpdate"));
16999 }
17000 merge_update__ = Some(map_.next_value()?);
17001 }
17002 GeneratedField::ActorVnodeBitmapUpdate => {
17003 if actor_vnode_bitmap_update__.is_some() {
17004 return Err(serde::de::Error::duplicate_field("actorVnodeBitmapUpdate"));
17005 }
17006 actor_vnode_bitmap_update__ = Some(
17007 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
17008 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
17009 );
17010 }
17011 GeneratedField::DroppedActors => {
17012 if dropped_actors__.is_some() {
17013 return Err(serde::de::Error::duplicate_field("droppedActors"));
17014 }
17015 dropped_actors__ =
17016 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17017 .into_iter().map(|x| x.0).collect())
17018 ;
17019 }
17020 GeneratedField::ActorSplits => {
17021 if actor_splits__.is_some() {
17022 return Err(serde::de::Error::duplicate_field("actorSplits"));
17023 }
17024 actor_splits__ = Some(
17025 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
17026 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
17027 );
17028 }
17029 GeneratedField::ActorNewDispatchers => {
17030 if actor_new_dispatchers__.is_some() {
17031 return Err(serde::de::Error::duplicate_field("actorNewDispatchers"));
17032 }
17033 actor_new_dispatchers__ = Some(
17034 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
17035 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
17036 );
17037 }
17038 GeneratedField::ActorCdcTableSnapshotSplits => {
17039 if actor_cdc_table_snapshot_splits__.is_some() {
17040 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
17041 }
17042 actor_cdc_table_snapshot_splits__ = map_.next_value()?;
17043 }
17044 GeneratedField::SinkSchemaChange => {
17045 if sink_schema_change__.is_some() {
17046 return Err(serde::de::Error::duplicate_field("sinkSchemaChange"));
17047 }
17048 sink_schema_change__ = Some(
17049 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
17050 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
17051 );
17052 }
17053 GeneratedField::SubscriptionsToDrop => {
17054 if subscriptions_to_drop__.is_some() {
17055 return Err(serde::de::Error::duplicate_field("subscriptionsToDrop"));
17056 }
17057 subscriptions_to_drop__ = Some(map_.next_value()?);
17058 }
17059 }
17060 }
17061 Ok(UpdateMutation {
17062 dispatcher_update: dispatcher_update__.unwrap_or_default(),
17063 merge_update: merge_update__.unwrap_or_default(),
17064 actor_vnode_bitmap_update: actor_vnode_bitmap_update__.unwrap_or_default(),
17065 dropped_actors: dropped_actors__.unwrap_or_default(),
17066 actor_splits: actor_splits__.unwrap_or_default(),
17067 actor_new_dispatchers: actor_new_dispatchers__.unwrap_or_default(),
17068 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
17069 sink_schema_change: sink_schema_change__.unwrap_or_default(),
17070 subscriptions_to_drop: subscriptions_to_drop__.unwrap_or_default(),
17071 })
17072 }
17073 }
17074 deserializer.deserialize_struct("stream_plan.UpdateMutation", FIELDS, GeneratedVisitor)
17075 }
17076}
17077impl serde::Serialize for update_mutation::DispatcherUpdate {
17078 #[allow(deprecated)]
17079 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17080 where
17081 S: serde::Serializer,
17082 {
17083 use serde::ser::SerializeStruct;
17084 let mut len = 0;
17085 if self.actor_id != 0 {
17086 len += 1;
17087 }
17088 if self.dispatcher_id != 0 {
17089 len += 1;
17090 }
17091 if self.hash_mapping.is_some() {
17092 len += 1;
17093 }
17094 if !self.added_downstream_actor_id.is_empty() {
17095 len += 1;
17096 }
17097 if !self.removed_downstream_actor_id.is_empty() {
17098 len += 1;
17099 }
17100 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", len)?;
17101 if self.actor_id != 0 {
17102 struct_ser.serialize_field("actorId", &self.actor_id)?;
17103 }
17104 if self.dispatcher_id != 0 {
17105 struct_ser.serialize_field("dispatcherId", &self.dispatcher_id)?;
17106 }
17107 if let Some(v) = self.hash_mapping.as_ref() {
17108 struct_ser.serialize_field("hashMapping", v)?;
17109 }
17110 if !self.added_downstream_actor_id.is_empty() {
17111 struct_ser.serialize_field("addedDownstreamActorId", &self.added_downstream_actor_id)?;
17112 }
17113 if !self.removed_downstream_actor_id.is_empty() {
17114 struct_ser.serialize_field("removedDownstreamActorId", &self.removed_downstream_actor_id)?;
17115 }
17116 struct_ser.end()
17117 }
17118}
17119impl<'de> serde::Deserialize<'de> for update_mutation::DispatcherUpdate {
17120 #[allow(deprecated)]
17121 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17122 where
17123 D: serde::Deserializer<'de>,
17124 {
17125 const FIELDS: &[&str] = &[
17126 "actor_id",
17127 "actorId",
17128 "dispatcher_id",
17129 "dispatcherId",
17130 "hash_mapping",
17131 "hashMapping",
17132 "added_downstream_actor_id",
17133 "addedDownstreamActorId",
17134 "removed_downstream_actor_id",
17135 "removedDownstreamActorId",
17136 ];
17137
17138 #[allow(clippy::enum_variant_names)]
17139 enum GeneratedField {
17140 ActorId,
17141 DispatcherId,
17142 HashMapping,
17143 AddedDownstreamActorId,
17144 RemovedDownstreamActorId,
17145 }
17146 impl<'de> serde::Deserialize<'de> for GeneratedField {
17147 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17148 where
17149 D: serde::Deserializer<'de>,
17150 {
17151 struct GeneratedVisitor;
17152
17153 impl serde::de::Visitor<'_> for GeneratedVisitor {
17154 type Value = GeneratedField;
17155
17156 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17157 write!(formatter, "expected one of: {:?}", &FIELDS)
17158 }
17159
17160 #[allow(unused_variables)]
17161 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17162 where
17163 E: serde::de::Error,
17164 {
17165 match value {
17166 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
17167 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
17168 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
17169 "addedDownstreamActorId" | "added_downstream_actor_id" => Ok(GeneratedField::AddedDownstreamActorId),
17170 "removedDownstreamActorId" | "removed_downstream_actor_id" => Ok(GeneratedField::RemovedDownstreamActorId),
17171 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17172 }
17173 }
17174 }
17175 deserializer.deserialize_identifier(GeneratedVisitor)
17176 }
17177 }
17178 struct GeneratedVisitor;
17179 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17180 type Value = update_mutation::DispatcherUpdate;
17181
17182 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17183 formatter.write_str("struct stream_plan.UpdateMutation.DispatcherUpdate")
17184 }
17185
17186 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::DispatcherUpdate, V::Error>
17187 where
17188 V: serde::de::MapAccess<'de>,
17189 {
17190 let mut actor_id__ = None;
17191 let mut dispatcher_id__ = None;
17192 let mut hash_mapping__ = None;
17193 let mut added_downstream_actor_id__ = None;
17194 let mut removed_downstream_actor_id__ = None;
17195 while let Some(k) = map_.next_key()? {
17196 match k {
17197 GeneratedField::ActorId => {
17198 if actor_id__.is_some() {
17199 return Err(serde::de::Error::duplicate_field("actorId"));
17200 }
17201 actor_id__ =
17202 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17203 ;
17204 }
17205 GeneratedField::DispatcherId => {
17206 if dispatcher_id__.is_some() {
17207 return Err(serde::de::Error::duplicate_field("dispatcherId"));
17208 }
17209 dispatcher_id__ =
17210 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17211 ;
17212 }
17213 GeneratedField::HashMapping => {
17214 if hash_mapping__.is_some() {
17215 return Err(serde::de::Error::duplicate_field("hashMapping"));
17216 }
17217 hash_mapping__ = map_.next_value()?;
17218 }
17219 GeneratedField::AddedDownstreamActorId => {
17220 if added_downstream_actor_id__.is_some() {
17221 return Err(serde::de::Error::duplicate_field("addedDownstreamActorId"));
17222 }
17223 added_downstream_actor_id__ =
17224 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17225 .into_iter().map(|x| x.0).collect())
17226 ;
17227 }
17228 GeneratedField::RemovedDownstreamActorId => {
17229 if removed_downstream_actor_id__.is_some() {
17230 return Err(serde::de::Error::duplicate_field("removedDownstreamActorId"));
17231 }
17232 removed_downstream_actor_id__ =
17233 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17234 .into_iter().map(|x| x.0).collect())
17235 ;
17236 }
17237 }
17238 }
17239 Ok(update_mutation::DispatcherUpdate {
17240 actor_id: actor_id__.unwrap_or_default(),
17241 dispatcher_id: dispatcher_id__.unwrap_or_default(),
17242 hash_mapping: hash_mapping__,
17243 added_downstream_actor_id: added_downstream_actor_id__.unwrap_or_default(),
17244 removed_downstream_actor_id: removed_downstream_actor_id__.unwrap_or_default(),
17245 })
17246 }
17247 }
17248 deserializer.deserialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", FIELDS, GeneratedVisitor)
17249 }
17250}
17251impl serde::Serialize for update_mutation::MergeUpdate {
17252 #[allow(deprecated)]
17253 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17254 where
17255 S: serde::Serializer,
17256 {
17257 use serde::ser::SerializeStruct;
17258 let mut len = 0;
17259 if self.actor_id != 0 {
17260 len += 1;
17261 }
17262 if self.upstream_fragment_id != 0 {
17263 len += 1;
17264 }
17265 if self.new_upstream_fragment_id.is_some() {
17266 len += 1;
17267 }
17268 if !self.added_upstream_actors.is_empty() {
17269 len += 1;
17270 }
17271 if !self.removed_upstream_actor_id.is_empty() {
17272 len += 1;
17273 }
17274 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.MergeUpdate", len)?;
17275 if self.actor_id != 0 {
17276 struct_ser.serialize_field("actorId", &self.actor_id)?;
17277 }
17278 if self.upstream_fragment_id != 0 {
17279 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
17280 }
17281 if let Some(v) = self.new_upstream_fragment_id.as_ref() {
17282 struct_ser.serialize_field("newUpstreamFragmentId", v)?;
17283 }
17284 if !self.added_upstream_actors.is_empty() {
17285 struct_ser.serialize_field("addedUpstreamActors", &self.added_upstream_actors)?;
17286 }
17287 if !self.removed_upstream_actor_id.is_empty() {
17288 struct_ser.serialize_field("removedUpstreamActorId", &self.removed_upstream_actor_id)?;
17289 }
17290 struct_ser.end()
17291 }
17292}
17293impl<'de> serde::Deserialize<'de> for update_mutation::MergeUpdate {
17294 #[allow(deprecated)]
17295 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17296 where
17297 D: serde::Deserializer<'de>,
17298 {
17299 const FIELDS: &[&str] = &[
17300 "actor_id",
17301 "actorId",
17302 "upstream_fragment_id",
17303 "upstreamFragmentId",
17304 "new_upstream_fragment_id",
17305 "newUpstreamFragmentId",
17306 "added_upstream_actors",
17307 "addedUpstreamActors",
17308 "removed_upstream_actor_id",
17309 "removedUpstreamActorId",
17310 ];
17311
17312 #[allow(clippy::enum_variant_names)]
17313 enum GeneratedField {
17314 ActorId,
17315 UpstreamFragmentId,
17316 NewUpstreamFragmentId,
17317 AddedUpstreamActors,
17318 RemovedUpstreamActorId,
17319 }
17320 impl<'de> serde::Deserialize<'de> for GeneratedField {
17321 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17322 where
17323 D: serde::Deserializer<'de>,
17324 {
17325 struct GeneratedVisitor;
17326
17327 impl serde::de::Visitor<'_> for GeneratedVisitor {
17328 type Value = GeneratedField;
17329
17330 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17331 write!(formatter, "expected one of: {:?}", &FIELDS)
17332 }
17333
17334 #[allow(unused_variables)]
17335 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17336 where
17337 E: serde::de::Error,
17338 {
17339 match value {
17340 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
17341 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
17342 "newUpstreamFragmentId" | "new_upstream_fragment_id" => Ok(GeneratedField::NewUpstreamFragmentId),
17343 "addedUpstreamActors" | "added_upstream_actors" => Ok(GeneratedField::AddedUpstreamActors),
17344 "removedUpstreamActorId" | "removed_upstream_actor_id" => Ok(GeneratedField::RemovedUpstreamActorId),
17345 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17346 }
17347 }
17348 }
17349 deserializer.deserialize_identifier(GeneratedVisitor)
17350 }
17351 }
17352 struct GeneratedVisitor;
17353 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17354 type Value = update_mutation::MergeUpdate;
17355
17356 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17357 formatter.write_str("struct stream_plan.UpdateMutation.MergeUpdate")
17358 }
17359
17360 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::MergeUpdate, V::Error>
17361 where
17362 V: serde::de::MapAccess<'de>,
17363 {
17364 let mut actor_id__ = None;
17365 let mut upstream_fragment_id__ = None;
17366 let mut new_upstream_fragment_id__ = None;
17367 let mut added_upstream_actors__ = None;
17368 let mut removed_upstream_actor_id__ = None;
17369 while let Some(k) = map_.next_key()? {
17370 match k {
17371 GeneratedField::ActorId => {
17372 if actor_id__.is_some() {
17373 return Err(serde::de::Error::duplicate_field("actorId"));
17374 }
17375 actor_id__ =
17376 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17377 ;
17378 }
17379 GeneratedField::UpstreamFragmentId => {
17380 if upstream_fragment_id__.is_some() {
17381 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
17382 }
17383 upstream_fragment_id__ =
17384 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17385 ;
17386 }
17387 GeneratedField::NewUpstreamFragmentId => {
17388 if new_upstream_fragment_id__.is_some() {
17389 return Err(serde::de::Error::duplicate_field("newUpstreamFragmentId"));
17390 }
17391 new_upstream_fragment_id__ =
17392 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17393 ;
17394 }
17395 GeneratedField::AddedUpstreamActors => {
17396 if added_upstream_actors__.is_some() {
17397 return Err(serde::de::Error::duplicate_field("addedUpstreamActors"));
17398 }
17399 added_upstream_actors__ = Some(map_.next_value()?);
17400 }
17401 GeneratedField::RemovedUpstreamActorId => {
17402 if removed_upstream_actor_id__.is_some() {
17403 return Err(serde::de::Error::duplicate_field("removedUpstreamActorId"));
17404 }
17405 removed_upstream_actor_id__ =
17406 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17407 .into_iter().map(|x| x.0).collect())
17408 ;
17409 }
17410 }
17411 }
17412 Ok(update_mutation::MergeUpdate {
17413 actor_id: actor_id__.unwrap_or_default(),
17414 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
17415 new_upstream_fragment_id: new_upstream_fragment_id__,
17416 added_upstream_actors: added_upstream_actors__.unwrap_or_default(),
17417 removed_upstream_actor_id: removed_upstream_actor_id__.unwrap_or_default(),
17418 })
17419 }
17420 }
17421 deserializer.deserialize_struct("stream_plan.UpdateMutation.MergeUpdate", FIELDS, GeneratedVisitor)
17422 }
17423}
17424impl serde::Serialize for UpstreamSinkInfo {
17425 #[allow(deprecated)]
17426 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17427 where
17428 S: serde::Serializer,
17429 {
17430 use serde::ser::SerializeStruct;
17431 let mut len = 0;
17432 if self.upstream_fragment_id != 0 {
17433 len += 1;
17434 }
17435 if !self.sink_output_schema.is_empty() {
17436 len += 1;
17437 }
17438 if !self.project_exprs.is_empty() {
17439 len += 1;
17440 }
17441 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkInfo", len)?;
17442 if self.upstream_fragment_id != 0 {
17443 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
17444 }
17445 if !self.sink_output_schema.is_empty() {
17446 struct_ser.serialize_field("sinkOutputSchema", &self.sink_output_schema)?;
17447 }
17448 if !self.project_exprs.is_empty() {
17449 struct_ser.serialize_field("projectExprs", &self.project_exprs)?;
17450 }
17451 struct_ser.end()
17452 }
17453}
17454impl<'de> serde::Deserialize<'de> for UpstreamSinkInfo {
17455 #[allow(deprecated)]
17456 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17457 where
17458 D: serde::Deserializer<'de>,
17459 {
17460 const FIELDS: &[&str] = &[
17461 "upstream_fragment_id",
17462 "upstreamFragmentId",
17463 "sink_output_schema",
17464 "sinkOutputSchema",
17465 "project_exprs",
17466 "projectExprs",
17467 ];
17468
17469 #[allow(clippy::enum_variant_names)]
17470 enum GeneratedField {
17471 UpstreamFragmentId,
17472 SinkOutputSchema,
17473 ProjectExprs,
17474 }
17475 impl<'de> serde::Deserialize<'de> for GeneratedField {
17476 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17477 where
17478 D: serde::Deserializer<'de>,
17479 {
17480 struct GeneratedVisitor;
17481
17482 impl serde::de::Visitor<'_> for GeneratedVisitor {
17483 type Value = GeneratedField;
17484
17485 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17486 write!(formatter, "expected one of: {:?}", &FIELDS)
17487 }
17488
17489 #[allow(unused_variables)]
17490 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17491 where
17492 E: serde::de::Error,
17493 {
17494 match value {
17495 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
17496 "sinkOutputSchema" | "sink_output_schema" => Ok(GeneratedField::SinkOutputSchema),
17497 "projectExprs" | "project_exprs" => Ok(GeneratedField::ProjectExprs),
17498 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17499 }
17500 }
17501 }
17502 deserializer.deserialize_identifier(GeneratedVisitor)
17503 }
17504 }
17505 struct GeneratedVisitor;
17506 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17507 type Value = UpstreamSinkInfo;
17508
17509 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17510 formatter.write_str("struct stream_plan.UpstreamSinkInfo")
17511 }
17512
17513 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkInfo, V::Error>
17514 where
17515 V: serde::de::MapAccess<'de>,
17516 {
17517 let mut upstream_fragment_id__ = None;
17518 let mut sink_output_schema__ = None;
17519 let mut project_exprs__ = None;
17520 while let Some(k) = map_.next_key()? {
17521 match k {
17522 GeneratedField::UpstreamFragmentId => {
17523 if upstream_fragment_id__.is_some() {
17524 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
17525 }
17526 upstream_fragment_id__ =
17527 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17528 ;
17529 }
17530 GeneratedField::SinkOutputSchema => {
17531 if sink_output_schema__.is_some() {
17532 return Err(serde::de::Error::duplicate_field("sinkOutputSchema"));
17533 }
17534 sink_output_schema__ = Some(map_.next_value()?);
17535 }
17536 GeneratedField::ProjectExprs => {
17537 if project_exprs__.is_some() {
17538 return Err(serde::de::Error::duplicate_field("projectExprs"));
17539 }
17540 project_exprs__ = Some(map_.next_value()?);
17541 }
17542 }
17543 }
17544 Ok(UpstreamSinkInfo {
17545 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
17546 sink_output_schema: sink_output_schema__.unwrap_or_default(),
17547 project_exprs: project_exprs__.unwrap_or_default(),
17548 })
17549 }
17550 }
17551 deserializer.deserialize_struct("stream_plan.UpstreamSinkInfo", FIELDS, GeneratedVisitor)
17552 }
17553}
17554impl serde::Serialize for UpstreamSinkUnionNode {
17555 #[allow(deprecated)]
17556 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17557 where
17558 S: serde::Serializer,
17559 {
17560 use serde::ser::SerializeStruct;
17561 let mut len = 0;
17562 if !self.init_upstreams.is_empty() {
17563 len += 1;
17564 }
17565 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkUnionNode", len)?;
17566 if !self.init_upstreams.is_empty() {
17567 struct_ser.serialize_field("initUpstreams", &self.init_upstreams)?;
17568 }
17569 struct_ser.end()
17570 }
17571}
17572impl<'de> serde::Deserialize<'de> for UpstreamSinkUnionNode {
17573 #[allow(deprecated)]
17574 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17575 where
17576 D: serde::Deserializer<'de>,
17577 {
17578 const FIELDS: &[&str] = &[
17579 "init_upstreams",
17580 "initUpstreams",
17581 ];
17582
17583 #[allow(clippy::enum_variant_names)]
17584 enum GeneratedField {
17585 InitUpstreams,
17586 }
17587 impl<'de> serde::Deserialize<'de> for GeneratedField {
17588 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17589 where
17590 D: serde::Deserializer<'de>,
17591 {
17592 struct GeneratedVisitor;
17593
17594 impl serde::de::Visitor<'_> for GeneratedVisitor {
17595 type Value = GeneratedField;
17596
17597 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17598 write!(formatter, "expected one of: {:?}", &FIELDS)
17599 }
17600
17601 #[allow(unused_variables)]
17602 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17603 where
17604 E: serde::de::Error,
17605 {
17606 match value {
17607 "initUpstreams" | "init_upstreams" => Ok(GeneratedField::InitUpstreams),
17608 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17609 }
17610 }
17611 }
17612 deserializer.deserialize_identifier(GeneratedVisitor)
17613 }
17614 }
17615 struct GeneratedVisitor;
17616 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17617 type Value = UpstreamSinkUnionNode;
17618
17619 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17620 formatter.write_str("struct stream_plan.UpstreamSinkUnionNode")
17621 }
17622
17623 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkUnionNode, V::Error>
17624 where
17625 V: serde::de::MapAccess<'de>,
17626 {
17627 let mut init_upstreams__ = None;
17628 while let Some(k) = map_.next_key()? {
17629 match k {
17630 GeneratedField::InitUpstreams => {
17631 if init_upstreams__.is_some() {
17632 return Err(serde::de::Error::duplicate_field("initUpstreams"));
17633 }
17634 init_upstreams__ = Some(map_.next_value()?);
17635 }
17636 }
17637 }
17638 Ok(UpstreamSinkUnionNode {
17639 init_upstreams: init_upstreams__.unwrap_or_default(),
17640 })
17641 }
17642 }
17643 deserializer.deserialize_struct("stream_plan.UpstreamSinkUnionNode", FIELDS, GeneratedVisitor)
17644 }
17645}
17646impl serde::Serialize for ValuesNode {
17647 #[allow(deprecated)]
17648 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17649 where
17650 S: serde::Serializer,
17651 {
17652 use serde::ser::SerializeStruct;
17653 let mut len = 0;
17654 if !self.tuples.is_empty() {
17655 len += 1;
17656 }
17657 if !self.fields.is_empty() {
17658 len += 1;
17659 }
17660 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode", len)?;
17661 if !self.tuples.is_empty() {
17662 struct_ser.serialize_field("tuples", &self.tuples)?;
17663 }
17664 if !self.fields.is_empty() {
17665 struct_ser.serialize_field("fields", &self.fields)?;
17666 }
17667 struct_ser.end()
17668 }
17669}
17670impl<'de> serde::Deserialize<'de> for ValuesNode {
17671 #[allow(deprecated)]
17672 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17673 where
17674 D: serde::Deserializer<'de>,
17675 {
17676 const FIELDS: &[&str] = &[
17677 "tuples",
17678 "fields",
17679 ];
17680
17681 #[allow(clippy::enum_variant_names)]
17682 enum GeneratedField {
17683 Tuples,
17684 Fields,
17685 }
17686 impl<'de> serde::Deserialize<'de> for GeneratedField {
17687 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17688 where
17689 D: serde::Deserializer<'de>,
17690 {
17691 struct GeneratedVisitor;
17692
17693 impl serde::de::Visitor<'_> for GeneratedVisitor {
17694 type Value = GeneratedField;
17695
17696 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17697 write!(formatter, "expected one of: {:?}", &FIELDS)
17698 }
17699
17700 #[allow(unused_variables)]
17701 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17702 where
17703 E: serde::de::Error,
17704 {
17705 match value {
17706 "tuples" => Ok(GeneratedField::Tuples),
17707 "fields" => Ok(GeneratedField::Fields),
17708 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17709 }
17710 }
17711 }
17712 deserializer.deserialize_identifier(GeneratedVisitor)
17713 }
17714 }
17715 struct GeneratedVisitor;
17716 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17717 type Value = ValuesNode;
17718
17719 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17720 formatter.write_str("struct stream_plan.ValuesNode")
17721 }
17722
17723 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
17724 where
17725 V: serde::de::MapAccess<'de>,
17726 {
17727 let mut tuples__ = None;
17728 let mut fields__ = None;
17729 while let Some(k) = map_.next_key()? {
17730 match k {
17731 GeneratedField::Tuples => {
17732 if tuples__.is_some() {
17733 return Err(serde::de::Error::duplicate_field("tuples"));
17734 }
17735 tuples__ = Some(map_.next_value()?);
17736 }
17737 GeneratedField::Fields => {
17738 if fields__.is_some() {
17739 return Err(serde::de::Error::duplicate_field("fields"));
17740 }
17741 fields__ = Some(map_.next_value()?);
17742 }
17743 }
17744 }
17745 Ok(ValuesNode {
17746 tuples: tuples__.unwrap_or_default(),
17747 fields: fields__.unwrap_or_default(),
17748 })
17749 }
17750 }
17751 deserializer.deserialize_struct("stream_plan.ValuesNode", FIELDS, GeneratedVisitor)
17752 }
17753}
17754impl serde::Serialize for values_node::ExprTuple {
17755 #[allow(deprecated)]
17756 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17757 where
17758 S: serde::Serializer,
17759 {
17760 use serde::ser::SerializeStruct;
17761 let mut len = 0;
17762 if !self.cells.is_empty() {
17763 len += 1;
17764 }
17765 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode.ExprTuple", len)?;
17766 if !self.cells.is_empty() {
17767 struct_ser.serialize_field("cells", &self.cells)?;
17768 }
17769 struct_ser.end()
17770 }
17771}
17772impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
17773 #[allow(deprecated)]
17774 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17775 where
17776 D: serde::Deserializer<'de>,
17777 {
17778 const FIELDS: &[&str] = &[
17779 "cells",
17780 ];
17781
17782 #[allow(clippy::enum_variant_names)]
17783 enum GeneratedField {
17784 Cells,
17785 }
17786 impl<'de> serde::Deserialize<'de> for GeneratedField {
17787 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17788 where
17789 D: serde::Deserializer<'de>,
17790 {
17791 struct GeneratedVisitor;
17792
17793 impl serde::de::Visitor<'_> for GeneratedVisitor {
17794 type Value = GeneratedField;
17795
17796 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17797 write!(formatter, "expected one of: {:?}", &FIELDS)
17798 }
17799
17800 #[allow(unused_variables)]
17801 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17802 where
17803 E: serde::de::Error,
17804 {
17805 match value {
17806 "cells" => Ok(GeneratedField::Cells),
17807 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17808 }
17809 }
17810 }
17811 deserializer.deserialize_identifier(GeneratedVisitor)
17812 }
17813 }
17814 struct GeneratedVisitor;
17815 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17816 type Value = values_node::ExprTuple;
17817
17818 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17819 formatter.write_str("struct stream_plan.ValuesNode.ExprTuple")
17820 }
17821
17822 fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
17823 where
17824 V: serde::de::MapAccess<'de>,
17825 {
17826 let mut cells__ = None;
17827 while let Some(k) = map_.next_key()? {
17828 match k {
17829 GeneratedField::Cells => {
17830 if cells__.is_some() {
17831 return Err(serde::de::Error::duplicate_field("cells"));
17832 }
17833 cells__ = Some(map_.next_value()?);
17834 }
17835 }
17836 }
17837 Ok(values_node::ExprTuple {
17838 cells: cells__.unwrap_or_default(),
17839 })
17840 }
17841 }
17842 deserializer.deserialize_struct("stream_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
17843 }
17844}
17845impl serde::Serialize for VectorIndexLookupJoinNode {
17846 #[allow(deprecated)]
17847 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17848 where
17849 S: serde::Serializer,
17850 {
17851 use serde::ser::SerializeStruct;
17852 let mut len = 0;
17853 if self.reader_desc.is_some() {
17854 len += 1;
17855 }
17856 if self.vector_column_idx != 0 {
17857 len += 1;
17858 }
17859 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexLookupJoinNode", len)?;
17860 if let Some(v) = self.reader_desc.as_ref() {
17861 struct_ser.serialize_field("readerDesc", v)?;
17862 }
17863 if self.vector_column_idx != 0 {
17864 struct_ser.serialize_field("vectorColumnIdx", &self.vector_column_idx)?;
17865 }
17866 struct_ser.end()
17867 }
17868}
17869impl<'de> serde::Deserialize<'de> for VectorIndexLookupJoinNode {
17870 #[allow(deprecated)]
17871 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17872 where
17873 D: serde::Deserializer<'de>,
17874 {
17875 const FIELDS: &[&str] = &[
17876 "reader_desc",
17877 "readerDesc",
17878 "vector_column_idx",
17879 "vectorColumnIdx",
17880 ];
17881
17882 #[allow(clippy::enum_variant_names)]
17883 enum GeneratedField {
17884 ReaderDesc,
17885 VectorColumnIdx,
17886 }
17887 impl<'de> serde::Deserialize<'de> for GeneratedField {
17888 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17889 where
17890 D: serde::Deserializer<'de>,
17891 {
17892 struct GeneratedVisitor;
17893
17894 impl serde::de::Visitor<'_> for GeneratedVisitor {
17895 type Value = GeneratedField;
17896
17897 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17898 write!(formatter, "expected one of: {:?}", &FIELDS)
17899 }
17900
17901 #[allow(unused_variables)]
17902 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17903 where
17904 E: serde::de::Error,
17905 {
17906 match value {
17907 "readerDesc" | "reader_desc" => Ok(GeneratedField::ReaderDesc),
17908 "vectorColumnIdx" | "vector_column_idx" => Ok(GeneratedField::VectorColumnIdx),
17909 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17910 }
17911 }
17912 }
17913 deserializer.deserialize_identifier(GeneratedVisitor)
17914 }
17915 }
17916 struct GeneratedVisitor;
17917 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17918 type Value = VectorIndexLookupJoinNode;
17919
17920 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17921 formatter.write_str("struct stream_plan.VectorIndexLookupJoinNode")
17922 }
17923
17924 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexLookupJoinNode, V::Error>
17925 where
17926 V: serde::de::MapAccess<'de>,
17927 {
17928 let mut reader_desc__ = None;
17929 let mut vector_column_idx__ = None;
17930 while let Some(k) = map_.next_key()? {
17931 match k {
17932 GeneratedField::ReaderDesc => {
17933 if reader_desc__.is_some() {
17934 return Err(serde::de::Error::duplicate_field("readerDesc"));
17935 }
17936 reader_desc__ = map_.next_value()?;
17937 }
17938 GeneratedField::VectorColumnIdx => {
17939 if vector_column_idx__.is_some() {
17940 return Err(serde::de::Error::duplicate_field("vectorColumnIdx"));
17941 }
17942 vector_column_idx__ =
17943 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17944 ;
17945 }
17946 }
17947 }
17948 Ok(VectorIndexLookupJoinNode {
17949 reader_desc: reader_desc__,
17950 vector_column_idx: vector_column_idx__.unwrap_or_default(),
17951 })
17952 }
17953 }
17954 deserializer.deserialize_struct("stream_plan.VectorIndexLookupJoinNode", FIELDS, GeneratedVisitor)
17955 }
17956}
17957impl serde::Serialize for VectorIndexWriteNode {
17958 #[allow(deprecated)]
17959 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17960 where
17961 S: serde::Serializer,
17962 {
17963 use serde::ser::SerializeStruct;
17964 let mut len = 0;
17965 if self.table.is_some() {
17966 len += 1;
17967 }
17968 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexWriteNode", len)?;
17969 if let Some(v) = self.table.as_ref() {
17970 struct_ser.serialize_field("table", v)?;
17971 }
17972 struct_ser.end()
17973 }
17974}
17975impl<'de> serde::Deserialize<'de> for VectorIndexWriteNode {
17976 #[allow(deprecated)]
17977 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17978 where
17979 D: serde::Deserializer<'de>,
17980 {
17981 const FIELDS: &[&str] = &[
17982 "table",
17983 ];
17984
17985 #[allow(clippy::enum_variant_names)]
17986 enum GeneratedField {
17987 Table,
17988 }
17989 impl<'de> serde::Deserialize<'de> for GeneratedField {
17990 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17991 where
17992 D: serde::Deserializer<'de>,
17993 {
17994 struct GeneratedVisitor;
17995
17996 impl serde::de::Visitor<'_> for GeneratedVisitor {
17997 type Value = GeneratedField;
17998
17999 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18000 write!(formatter, "expected one of: {:?}", &FIELDS)
18001 }
18002
18003 #[allow(unused_variables)]
18004 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18005 where
18006 E: serde::de::Error,
18007 {
18008 match value {
18009 "table" => Ok(GeneratedField::Table),
18010 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18011 }
18012 }
18013 }
18014 deserializer.deserialize_identifier(GeneratedVisitor)
18015 }
18016 }
18017 struct GeneratedVisitor;
18018 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18019 type Value = VectorIndexWriteNode;
18020
18021 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18022 formatter.write_str("struct stream_plan.VectorIndexWriteNode")
18023 }
18024
18025 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexWriteNode, V::Error>
18026 where
18027 V: serde::de::MapAccess<'de>,
18028 {
18029 let mut table__ = None;
18030 while let Some(k) = map_.next_key()? {
18031 match k {
18032 GeneratedField::Table => {
18033 if table__.is_some() {
18034 return Err(serde::de::Error::duplicate_field("table"));
18035 }
18036 table__ = map_.next_value()?;
18037 }
18038 }
18039 }
18040 Ok(VectorIndexWriteNode {
18041 table: table__,
18042 })
18043 }
18044 }
18045 deserializer.deserialize_struct("stream_plan.VectorIndexWriteNode", FIELDS, GeneratedVisitor)
18046 }
18047}
18048impl serde::Serialize for Watermark {
18049 #[allow(deprecated)]
18050 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18051 where
18052 S: serde::Serializer,
18053 {
18054 use serde::ser::SerializeStruct;
18055 let mut len = 0;
18056 if self.column.is_some() {
18057 len += 1;
18058 }
18059 if self.val.is_some() {
18060 len += 1;
18061 }
18062 let mut struct_ser = serializer.serialize_struct("stream_plan.Watermark", len)?;
18063 if let Some(v) = self.column.as_ref() {
18064 struct_ser.serialize_field("column", v)?;
18065 }
18066 if let Some(v) = self.val.as_ref() {
18067 struct_ser.serialize_field("val", v)?;
18068 }
18069 struct_ser.end()
18070 }
18071}
18072impl<'de> serde::Deserialize<'de> for Watermark {
18073 #[allow(deprecated)]
18074 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18075 where
18076 D: serde::Deserializer<'de>,
18077 {
18078 const FIELDS: &[&str] = &[
18079 "column",
18080 "val",
18081 ];
18082
18083 #[allow(clippy::enum_variant_names)]
18084 enum GeneratedField {
18085 Column,
18086 Val,
18087 }
18088 impl<'de> serde::Deserialize<'de> for GeneratedField {
18089 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18090 where
18091 D: serde::Deserializer<'de>,
18092 {
18093 struct GeneratedVisitor;
18094
18095 impl serde::de::Visitor<'_> for GeneratedVisitor {
18096 type Value = GeneratedField;
18097
18098 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18099 write!(formatter, "expected one of: {:?}", &FIELDS)
18100 }
18101
18102 #[allow(unused_variables)]
18103 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18104 where
18105 E: serde::de::Error,
18106 {
18107 match value {
18108 "column" => Ok(GeneratedField::Column),
18109 "val" => Ok(GeneratedField::Val),
18110 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18111 }
18112 }
18113 }
18114 deserializer.deserialize_identifier(GeneratedVisitor)
18115 }
18116 }
18117 struct GeneratedVisitor;
18118 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18119 type Value = Watermark;
18120
18121 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18122 formatter.write_str("struct stream_plan.Watermark")
18123 }
18124
18125 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Watermark, V::Error>
18126 where
18127 V: serde::de::MapAccess<'de>,
18128 {
18129 let mut column__ = None;
18130 let mut val__ = None;
18131 while let Some(k) = map_.next_key()? {
18132 match k {
18133 GeneratedField::Column => {
18134 if column__.is_some() {
18135 return Err(serde::de::Error::duplicate_field("column"));
18136 }
18137 column__ = map_.next_value()?;
18138 }
18139 GeneratedField::Val => {
18140 if val__.is_some() {
18141 return Err(serde::de::Error::duplicate_field("val"));
18142 }
18143 val__ = map_.next_value()?;
18144 }
18145 }
18146 }
18147 Ok(Watermark {
18148 column: column__,
18149 val: val__,
18150 })
18151 }
18152 }
18153 deserializer.deserialize_struct("stream_plan.Watermark", FIELDS, GeneratedVisitor)
18154 }
18155}
18156impl serde::Serialize for WatermarkFilterNode {
18157 #[allow(deprecated)]
18158 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18159 where
18160 S: serde::Serializer,
18161 {
18162 use serde::ser::SerializeStruct;
18163 let mut len = 0;
18164 if !self.watermark_descs.is_empty() {
18165 len += 1;
18166 }
18167 if !self.tables.is_empty() {
18168 len += 1;
18169 }
18170 let mut struct_ser = serializer.serialize_struct("stream_plan.WatermarkFilterNode", len)?;
18171 if !self.watermark_descs.is_empty() {
18172 struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
18173 }
18174 if !self.tables.is_empty() {
18175 struct_ser.serialize_field("tables", &self.tables)?;
18176 }
18177 struct_ser.end()
18178 }
18179}
18180impl<'de> serde::Deserialize<'de> for WatermarkFilterNode {
18181 #[allow(deprecated)]
18182 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18183 where
18184 D: serde::Deserializer<'de>,
18185 {
18186 const FIELDS: &[&str] = &[
18187 "watermark_descs",
18188 "watermarkDescs",
18189 "tables",
18190 ];
18191
18192 #[allow(clippy::enum_variant_names)]
18193 enum GeneratedField {
18194 WatermarkDescs,
18195 Tables,
18196 }
18197 impl<'de> serde::Deserialize<'de> for GeneratedField {
18198 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18199 where
18200 D: serde::Deserializer<'de>,
18201 {
18202 struct GeneratedVisitor;
18203
18204 impl serde::de::Visitor<'_> for GeneratedVisitor {
18205 type Value = GeneratedField;
18206
18207 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18208 write!(formatter, "expected one of: {:?}", &FIELDS)
18209 }
18210
18211 #[allow(unused_variables)]
18212 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18213 where
18214 E: serde::de::Error,
18215 {
18216 match value {
18217 "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
18218 "tables" => Ok(GeneratedField::Tables),
18219 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18220 }
18221 }
18222 }
18223 deserializer.deserialize_identifier(GeneratedVisitor)
18224 }
18225 }
18226 struct GeneratedVisitor;
18227 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18228 type Value = WatermarkFilterNode;
18229
18230 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18231 formatter.write_str("struct stream_plan.WatermarkFilterNode")
18232 }
18233
18234 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkFilterNode, V::Error>
18235 where
18236 V: serde::de::MapAccess<'de>,
18237 {
18238 let mut watermark_descs__ = None;
18239 let mut tables__ = None;
18240 while let Some(k) = map_.next_key()? {
18241 match k {
18242 GeneratedField::WatermarkDescs => {
18243 if watermark_descs__.is_some() {
18244 return Err(serde::de::Error::duplicate_field("watermarkDescs"));
18245 }
18246 watermark_descs__ = Some(map_.next_value()?);
18247 }
18248 GeneratedField::Tables => {
18249 if tables__.is_some() {
18250 return Err(serde::de::Error::duplicate_field("tables"));
18251 }
18252 tables__ = Some(map_.next_value()?);
18253 }
18254 }
18255 }
18256 Ok(WatermarkFilterNode {
18257 watermark_descs: watermark_descs__.unwrap_or_default(),
18258 tables: tables__.unwrap_or_default(),
18259 })
18260 }
18261 }
18262 deserializer.deserialize_struct("stream_plan.WatermarkFilterNode", FIELDS, GeneratedVisitor)
18263 }
18264}