1#![allow(clippy::useless_conversion)]
2use crate::stream_plan::*;
3impl serde::Serialize for ActorMapping {
4 #[allow(deprecated)]
5 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6 where
7 S: serde::Serializer,
8 {
9 use serde::ser::SerializeStruct;
10 let mut len = 0;
11 if !self.original_indices.is_empty() {
12 len += 1;
13 }
14 if !self.data.is_empty() {
15 len += 1;
16 }
17 let mut struct_ser = serializer.serialize_struct("stream_plan.ActorMapping", len)?;
18 if !self.original_indices.is_empty() {
19 struct_ser.serialize_field("originalIndices", &self.original_indices)?;
20 }
21 if !self.data.is_empty() {
22 struct_ser.serialize_field("data", &self.data)?;
23 }
24 struct_ser.end()
25 }
26}
27impl<'de> serde::Deserialize<'de> for ActorMapping {
28 #[allow(deprecated)]
29 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
30 where
31 D: serde::Deserializer<'de>,
32 {
33 const FIELDS: &[&str] = &[
34 "original_indices",
35 "originalIndices",
36 "data",
37 ];
38
39 #[allow(clippy::enum_variant_names)]
40 enum GeneratedField {
41 OriginalIndices,
42 Data,
43 }
44 impl<'de> serde::Deserialize<'de> for GeneratedField {
45 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
46 where
47 D: serde::Deserializer<'de>,
48 {
49 struct GeneratedVisitor;
50
51 impl serde::de::Visitor<'_> for GeneratedVisitor {
52 type Value = GeneratedField;
53
54 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
55 write!(formatter, "expected one of: {:?}", &FIELDS)
56 }
57
58 #[allow(unused_variables)]
59 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
60 where
61 E: serde::de::Error,
62 {
63 match value {
64 "originalIndices" | "original_indices" => Ok(GeneratedField::OriginalIndices),
65 "data" => Ok(GeneratedField::Data),
66 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
67 }
68 }
69 }
70 deserializer.deserialize_identifier(GeneratedVisitor)
71 }
72 }
73 struct GeneratedVisitor;
74 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
75 type Value = ActorMapping;
76
77 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
78 formatter.write_str("struct stream_plan.ActorMapping")
79 }
80
81 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorMapping, V::Error>
82 where
83 V: serde::de::MapAccess<'de>,
84 {
85 let mut original_indices__ = None;
86 let mut data__ = None;
87 while let Some(k) = map_.next_key()? {
88 match k {
89 GeneratedField::OriginalIndices => {
90 if original_indices__.is_some() {
91 return Err(serde::de::Error::duplicate_field("originalIndices"));
92 }
93 original_indices__ =
94 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
95 .into_iter().map(|x| x.0).collect())
96 ;
97 }
98 GeneratedField::Data => {
99 if data__.is_some() {
100 return Err(serde::de::Error::duplicate_field("data"));
101 }
102 data__ =
103 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
104 .into_iter().map(|x| x.0).collect())
105 ;
106 }
107 }
108 }
109 Ok(ActorMapping {
110 original_indices: original_indices__.unwrap_or_default(),
111 data: data__.unwrap_or_default(),
112 })
113 }
114 }
115 deserializer.deserialize_struct("stream_plan.ActorMapping", FIELDS, GeneratedVisitor)
116 }
117}
118impl serde::Serialize for AddMutation {
119 #[allow(deprecated)]
120 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
121 where
122 S: serde::Serializer,
123 {
124 use serde::ser::SerializeStruct;
125 let mut len = 0;
126 if !self.actor_dispatchers.is_empty() {
127 len += 1;
128 }
129 if !self.added_actors.is_empty() {
130 len += 1;
131 }
132 if !self.actor_splits.is_empty() {
133 len += 1;
134 }
135 if self.pause {
136 len += 1;
137 }
138 if !self.subscriptions_to_add.is_empty() {
139 len += 1;
140 }
141 if !self.backfill_nodes_to_pause.is_empty() {
142 len += 1;
143 }
144 if self.actor_cdc_table_snapshot_splits.is_some() {
145 len += 1;
146 }
147 if !self.new_upstream_sinks.is_empty() {
148 len += 1;
149 }
150 let mut struct_ser = serializer.serialize_struct("stream_plan.AddMutation", len)?;
151 if !self.actor_dispatchers.is_empty() {
152 struct_ser.serialize_field("actorDispatchers", &self.actor_dispatchers)?;
153 }
154 if !self.added_actors.is_empty() {
155 struct_ser.serialize_field("addedActors", &self.added_actors)?;
156 }
157 if !self.actor_splits.is_empty() {
158 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
159 }
160 if self.pause {
161 struct_ser.serialize_field("pause", &self.pause)?;
162 }
163 if !self.subscriptions_to_add.is_empty() {
164 struct_ser.serialize_field("subscriptionsToAdd", &self.subscriptions_to_add)?;
165 }
166 if !self.backfill_nodes_to_pause.is_empty() {
167 struct_ser.serialize_field("backfillNodesToPause", &self.backfill_nodes_to_pause)?;
168 }
169 if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
170 struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
171 }
172 if !self.new_upstream_sinks.is_empty() {
173 struct_ser.serialize_field("newUpstreamSinks", &self.new_upstream_sinks)?;
174 }
175 struct_ser.end()
176 }
177}
178impl<'de> serde::Deserialize<'de> for AddMutation {
179 #[allow(deprecated)]
180 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
181 where
182 D: serde::Deserializer<'de>,
183 {
184 const FIELDS: &[&str] = &[
185 "actor_dispatchers",
186 "actorDispatchers",
187 "added_actors",
188 "addedActors",
189 "actor_splits",
190 "actorSplits",
191 "pause",
192 "subscriptions_to_add",
193 "subscriptionsToAdd",
194 "backfill_nodes_to_pause",
195 "backfillNodesToPause",
196 "actor_cdc_table_snapshot_splits",
197 "actorCdcTableSnapshotSplits",
198 "new_upstream_sinks",
199 "newUpstreamSinks",
200 ];
201
202 #[allow(clippy::enum_variant_names)]
203 enum GeneratedField {
204 ActorDispatchers,
205 AddedActors,
206 ActorSplits,
207 Pause,
208 SubscriptionsToAdd,
209 BackfillNodesToPause,
210 ActorCdcTableSnapshotSplits,
211 NewUpstreamSinks,
212 }
213 impl<'de> serde::Deserialize<'de> for GeneratedField {
214 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
215 where
216 D: serde::Deserializer<'de>,
217 {
218 struct GeneratedVisitor;
219
220 impl serde::de::Visitor<'_> for GeneratedVisitor {
221 type Value = GeneratedField;
222
223 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
224 write!(formatter, "expected one of: {:?}", &FIELDS)
225 }
226
227 #[allow(unused_variables)]
228 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
229 where
230 E: serde::de::Error,
231 {
232 match value {
233 "actorDispatchers" | "actor_dispatchers" => Ok(GeneratedField::ActorDispatchers),
234 "addedActors" | "added_actors" => Ok(GeneratedField::AddedActors),
235 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
236 "pause" => Ok(GeneratedField::Pause),
237 "subscriptionsToAdd" | "subscriptions_to_add" => Ok(GeneratedField::SubscriptionsToAdd),
238 "backfillNodesToPause" | "backfill_nodes_to_pause" => Ok(GeneratedField::BackfillNodesToPause),
239 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
240 "newUpstreamSinks" | "new_upstream_sinks" => Ok(GeneratedField::NewUpstreamSinks),
241 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
242 }
243 }
244 }
245 deserializer.deserialize_identifier(GeneratedVisitor)
246 }
247 }
248 struct GeneratedVisitor;
249 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
250 type Value = AddMutation;
251
252 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
253 formatter.write_str("struct stream_plan.AddMutation")
254 }
255
256 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddMutation, V::Error>
257 where
258 V: serde::de::MapAccess<'de>,
259 {
260 let mut actor_dispatchers__ = None;
261 let mut added_actors__ = None;
262 let mut actor_splits__ = None;
263 let mut pause__ = None;
264 let mut subscriptions_to_add__ = None;
265 let mut backfill_nodes_to_pause__ = None;
266 let mut actor_cdc_table_snapshot_splits__ = None;
267 let mut new_upstream_sinks__ = None;
268 while let Some(k) = map_.next_key()? {
269 match k {
270 GeneratedField::ActorDispatchers => {
271 if actor_dispatchers__.is_some() {
272 return Err(serde::de::Error::duplicate_field("actorDispatchers"));
273 }
274 actor_dispatchers__ = Some(
275 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
276 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
277 );
278 }
279 GeneratedField::AddedActors => {
280 if added_actors__.is_some() {
281 return Err(serde::de::Error::duplicate_field("addedActors"));
282 }
283 added_actors__ =
284 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
285 .into_iter().map(|x| x.0).collect())
286 ;
287 }
288 GeneratedField::ActorSplits => {
289 if actor_splits__.is_some() {
290 return Err(serde::de::Error::duplicate_field("actorSplits"));
291 }
292 actor_splits__ = Some(
293 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
294 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
295 );
296 }
297 GeneratedField::Pause => {
298 if pause__.is_some() {
299 return Err(serde::de::Error::duplicate_field("pause"));
300 }
301 pause__ = Some(map_.next_value()?);
302 }
303 GeneratedField::SubscriptionsToAdd => {
304 if subscriptions_to_add__.is_some() {
305 return Err(serde::de::Error::duplicate_field("subscriptionsToAdd"));
306 }
307 subscriptions_to_add__ = Some(map_.next_value()?);
308 }
309 GeneratedField::BackfillNodesToPause => {
310 if backfill_nodes_to_pause__.is_some() {
311 return Err(serde::de::Error::duplicate_field("backfillNodesToPause"));
312 }
313 backfill_nodes_to_pause__ =
314 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
315 .into_iter().map(|x| x.0).collect())
316 ;
317 }
318 GeneratedField::ActorCdcTableSnapshotSplits => {
319 if actor_cdc_table_snapshot_splits__.is_some() {
320 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
321 }
322 actor_cdc_table_snapshot_splits__ = map_.next_value()?;
323 }
324 GeneratedField::NewUpstreamSinks => {
325 if new_upstream_sinks__.is_some() {
326 return Err(serde::de::Error::duplicate_field("newUpstreamSinks"));
327 }
328 new_upstream_sinks__ = Some(
329 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
330 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
331 );
332 }
333 }
334 }
335 Ok(AddMutation {
336 actor_dispatchers: actor_dispatchers__.unwrap_or_default(),
337 added_actors: added_actors__.unwrap_or_default(),
338 actor_splits: actor_splits__.unwrap_or_default(),
339 pause: pause__.unwrap_or_default(),
340 subscriptions_to_add: subscriptions_to_add__.unwrap_or_default(),
341 backfill_nodes_to_pause: backfill_nodes_to_pause__.unwrap_or_default(),
342 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
343 new_upstream_sinks: new_upstream_sinks__.unwrap_or_default(),
344 })
345 }
346 }
347 deserializer.deserialize_struct("stream_plan.AddMutation", FIELDS, GeneratedVisitor)
348 }
349}
350impl serde::Serialize for add_mutation::NewUpstreamSink {
351 #[allow(deprecated)]
352 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
353 where
354 S: serde::Serializer,
355 {
356 use serde::ser::SerializeStruct;
357 let mut len = 0;
358 if self.info.is_some() {
359 len += 1;
360 }
361 if !self.upstream_actors.is_empty() {
362 len += 1;
363 }
364 let mut struct_ser = serializer.serialize_struct("stream_plan.AddMutation.NewUpstreamSink", len)?;
365 if let Some(v) = self.info.as_ref() {
366 struct_ser.serialize_field("info", v)?;
367 }
368 if !self.upstream_actors.is_empty() {
369 struct_ser.serialize_field("upstreamActors", &self.upstream_actors)?;
370 }
371 struct_ser.end()
372 }
373}
374impl<'de> serde::Deserialize<'de> for add_mutation::NewUpstreamSink {
375 #[allow(deprecated)]
376 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
377 where
378 D: serde::Deserializer<'de>,
379 {
380 const FIELDS: &[&str] = &[
381 "info",
382 "upstream_actors",
383 "upstreamActors",
384 ];
385
386 #[allow(clippy::enum_variant_names)]
387 enum GeneratedField {
388 Info,
389 UpstreamActors,
390 }
391 impl<'de> serde::Deserialize<'de> for GeneratedField {
392 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
393 where
394 D: serde::Deserializer<'de>,
395 {
396 struct GeneratedVisitor;
397
398 impl serde::de::Visitor<'_> for GeneratedVisitor {
399 type Value = GeneratedField;
400
401 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
402 write!(formatter, "expected one of: {:?}", &FIELDS)
403 }
404
405 #[allow(unused_variables)]
406 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
407 where
408 E: serde::de::Error,
409 {
410 match value {
411 "info" => Ok(GeneratedField::Info),
412 "upstreamActors" | "upstream_actors" => Ok(GeneratedField::UpstreamActors),
413 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
414 }
415 }
416 }
417 deserializer.deserialize_identifier(GeneratedVisitor)
418 }
419 }
420 struct GeneratedVisitor;
421 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
422 type Value = add_mutation::NewUpstreamSink;
423
424 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
425 formatter.write_str("struct stream_plan.AddMutation.NewUpstreamSink")
426 }
427
428 fn visit_map<V>(self, mut map_: V) -> std::result::Result<add_mutation::NewUpstreamSink, V::Error>
429 where
430 V: serde::de::MapAccess<'de>,
431 {
432 let mut info__ = None;
433 let mut upstream_actors__ = None;
434 while let Some(k) = map_.next_key()? {
435 match k {
436 GeneratedField::Info => {
437 if info__.is_some() {
438 return Err(serde::de::Error::duplicate_field("info"));
439 }
440 info__ = map_.next_value()?;
441 }
442 GeneratedField::UpstreamActors => {
443 if upstream_actors__.is_some() {
444 return Err(serde::de::Error::duplicate_field("upstreamActors"));
445 }
446 upstream_actors__ = Some(map_.next_value()?);
447 }
448 }
449 }
450 Ok(add_mutation::NewUpstreamSink {
451 info: info__,
452 upstream_actors: upstream_actors__.unwrap_or_default(),
453 })
454 }
455 }
456 deserializer.deserialize_struct("stream_plan.AddMutation.NewUpstreamSink", FIELDS, GeneratedVisitor)
457 }
458}
459impl serde::Serialize for AggCallState {
460 #[allow(deprecated)]
461 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
462 where
463 S: serde::Serializer,
464 {
465 use serde::ser::SerializeStruct;
466 let mut len = 0;
467 if self.inner.is_some() {
468 len += 1;
469 }
470 let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState", len)?;
471 if let Some(v) = self.inner.as_ref() {
472 match v {
473 agg_call_state::Inner::ValueState(v) => {
474 struct_ser.serialize_field("valueState", v)?;
475 }
476 agg_call_state::Inner::MaterializedInputState(v) => {
477 struct_ser.serialize_field("materializedInputState", v)?;
478 }
479 }
480 }
481 struct_ser.end()
482 }
483}
484impl<'de> serde::Deserialize<'de> for AggCallState {
485 #[allow(deprecated)]
486 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
487 where
488 D: serde::Deserializer<'de>,
489 {
490 const FIELDS: &[&str] = &[
491 "value_state",
492 "valueState",
493 "materialized_input_state",
494 "materializedInputState",
495 ];
496
497 #[allow(clippy::enum_variant_names)]
498 enum GeneratedField {
499 ValueState,
500 MaterializedInputState,
501 }
502 impl<'de> serde::Deserialize<'de> for GeneratedField {
503 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
504 where
505 D: serde::Deserializer<'de>,
506 {
507 struct GeneratedVisitor;
508
509 impl serde::de::Visitor<'_> for GeneratedVisitor {
510 type Value = GeneratedField;
511
512 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
513 write!(formatter, "expected one of: {:?}", &FIELDS)
514 }
515
516 #[allow(unused_variables)]
517 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
518 where
519 E: serde::de::Error,
520 {
521 match value {
522 "valueState" | "value_state" => Ok(GeneratedField::ValueState),
523 "materializedInputState" | "materialized_input_state" => Ok(GeneratedField::MaterializedInputState),
524 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
525 }
526 }
527 }
528 deserializer.deserialize_identifier(GeneratedVisitor)
529 }
530 }
531 struct GeneratedVisitor;
532 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
533 type Value = AggCallState;
534
535 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
536 formatter.write_str("struct stream_plan.AggCallState")
537 }
538
539 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AggCallState, V::Error>
540 where
541 V: serde::de::MapAccess<'de>,
542 {
543 let mut inner__ = None;
544 while let Some(k) = map_.next_key()? {
545 match k {
546 GeneratedField::ValueState => {
547 if inner__.is_some() {
548 return Err(serde::de::Error::duplicate_field("valueState"));
549 }
550 inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::ValueState)
551;
552 }
553 GeneratedField::MaterializedInputState => {
554 if inner__.is_some() {
555 return Err(serde::de::Error::duplicate_field("materializedInputState"));
556 }
557 inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::MaterializedInputState)
558;
559 }
560 }
561 }
562 Ok(AggCallState {
563 inner: inner__,
564 })
565 }
566 }
567 deserializer.deserialize_struct("stream_plan.AggCallState", FIELDS, GeneratedVisitor)
568 }
569}
570impl serde::Serialize for agg_call_state::MaterializedInputState {
571 #[allow(deprecated)]
572 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
573 where
574 S: serde::Serializer,
575 {
576 use serde::ser::SerializeStruct;
577 let mut len = 0;
578 if self.table.is_some() {
579 len += 1;
580 }
581 if !self.included_upstream_indices.is_empty() {
582 len += 1;
583 }
584 if !self.table_value_indices.is_empty() {
585 len += 1;
586 }
587 if !self.order_columns.is_empty() {
588 len += 1;
589 }
590 let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState.MaterializedInputState", len)?;
591 if let Some(v) = self.table.as_ref() {
592 struct_ser.serialize_field("table", v)?;
593 }
594 if !self.included_upstream_indices.is_empty() {
595 struct_ser.serialize_field("includedUpstreamIndices", &self.included_upstream_indices)?;
596 }
597 if !self.table_value_indices.is_empty() {
598 struct_ser.serialize_field("tableValueIndices", &self.table_value_indices)?;
599 }
600 if !self.order_columns.is_empty() {
601 struct_ser.serialize_field("orderColumns", &self.order_columns)?;
602 }
603 struct_ser.end()
604 }
605}
606impl<'de> serde::Deserialize<'de> for agg_call_state::MaterializedInputState {
607 #[allow(deprecated)]
608 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
609 where
610 D: serde::Deserializer<'de>,
611 {
612 const FIELDS: &[&str] = &[
613 "table",
614 "included_upstream_indices",
615 "includedUpstreamIndices",
616 "table_value_indices",
617 "tableValueIndices",
618 "order_columns",
619 "orderColumns",
620 ];
621
622 #[allow(clippy::enum_variant_names)]
623 enum GeneratedField {
624 Table,
625 IncludedUpstreamIndices,
626 TableValueIndices,
627 OrderColumns,
628 }
629 impl<'de> serde::Deserialize<'de> for GeneratedField {
630 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
631 where
632 D: serde::Deserializer<'de>,
633 {
634 struct GeneratedVisitor;
635
636 impl serde::de::Visitor<'_> for GeneratedVisitor {
637 type Value = GeneratedField;
638
639 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
640 write!(formatter, "expected one of: {:?}", &FIELDS)
641 }
642
643 #[allow(unused_variables)]
644 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
645 where
646 E: serde::de::Error,
647 {
648 match value {
649 "table" => Ok(GeneratedField::Table),
650 "includedUpstreamIndices" | "included_upstream_indices" => Ok(GeneratedField::IncludedUpstreamIndices),
651 "tableValueIndices" | "table_value_indices" => Ok(GeneratedField::TableValueIndices),
652 "orderColumns" | "order_columns" => Ok(GeneratedField::OrderColumns),
653 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
654 }
655 }
656 }
657 deserializer.deserialize_identifier(GeneratedVisitor)
658 }
659 }
660 struct GeneratedVisitor;
661 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
662 type Value = agg_call_state::MaterializedInputState;
663
664 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
665 formatter.write_str("struct stream_plan.AggCallState.MaterializedInputState")
666 }
667
668 fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::MaterializedInputState, V::Error>
669 where
670 V: serde::de::MapAccess<'de>,
671 {
672 let mut table__ = None;
673 let mut included_upstream_indices__ = None;
674 let mut table_value_indices__ = None;
675 let mut order_columns__ = None;
676 while let Some(k) = map_.next_key()? {
677 match k {
678 GeneratedField::Table => {
679 if table__.is_some() {
680 return Err(serde::de::Error::duplicate_field("table"));
681 }
682 table__ = map_.next_value()?;
683 }
684 GeneratedField::IncludedUpstreamIndices => {
685 if included_upstream_indices__.is_some() {
686 return Err(serde::de::Error::duplicate_field("includedUpstreamIndices"));
687 }
688 included_upstream_indices__ =
689 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
690 .into_iter().map(|x| x.0).collect())
691 ;
692 }
693 GeneratedField::TableValueIndices => {
694 if table_value_indices__.is_some() {
695 return Err(serde::de::Error::duplicate_field("tableValueIndices"));
696 }
697 table_value_indices__ =
698 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
699 .into_iter().map(|x| x.0).collect())
700 ;
701 }
702 GeneratedField::OrderColumns => {
703 if order_columns__.is_some() {
704 return Err(serde::de::Error::duplicate_field("orderColumns"));
705 }
706 order_columns__ = Some(map_.next_value()?);
707 }
708 }
709 }
710 Ok(agg_call_state::MaterializedInputState {
711 table: table__,
712 included_upstream_indices: included_upstream_indices__.unwrap_or_default(),
713 table_value_indices: table_value_indices__.unwrap_or_default(),
714 order_columns: order_columns__.unwrap_or_default(),
715 })
716 }
717 }
718 deserializer.deserialize_struct("stream_plan.AggCallState.MaterializedInputState", FIELDS, GeneratedVisitor)
719 }
720}
721impl serde::Serialize for agg_call_state::ValueState {
722 #[allow(deprecated)]
723 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
724 where
725 S: serde::Serializer,
726 {
727 use serde::ser::SerializeStruct;
728 let len = 0;
729 let struct_ser = serializer.serialize_struct("stream_plan.AggCallState.ValueState", len)?;
730 struct_ser.end()
731 }
732}
733impl<'de> serde::Deserialize<'de> for agg_call_state::ValueState {
734 #[allow(deprecated)]
735 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
736 where
737 D: serde::Deserializer<'de>,
738 {
739 const FIELDS: &[&str] = &[
740 ];
741
742 #[allow(clippy::enum_variant_names)]
743 enum GeneratedField {
744 }
745 impl<'de> serde::Deserialize<'de> for GeneratedField {
746 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
747 where
748 D: serde::Deserializer<'de>,
749 {
750 struct GeneratedVisitor;
751
752 impl serde::de::Visitor<'_> for GeneratedVisitor {
753 type Value = GeneratedField;
754
755 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
756 write!(formatter, "expected one of: {:?}", &FIELDS)
757 }
758
759 #[allow(unused_variables)]
760 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
761 where
762 E: serde::de::Error,
763 {
764 Err(serde::de::Error::unknown_field(value, FIELDS))
765 }
766 }
767 deserializer.deserialize_identifier(GeneratedVisitor)
768 }
769 }
770 struct GeneratedVisitor;
771 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
772 type Value = agg_call_state::ValueState;
773
774 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
775 formatter.write_str("struct stream_plan.AggCallState.ValueState")
776 }
777
778 fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::ValueState, V::Error>
779 where
780 V: serde::de::MapAccess<'de>,
781 {
782 while map_.next_key::<GeneratedField>()?.is_some() {
783 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
784 }
785 Ok(agg_call_state::ValueState {
786 })
787 }
788 }
789 deserializer.deserialize_struct("stream_plan.AggCallState.ValueState", FIELDS, GeneratedVisitor)
790 }
791}
792impl serde::Serialize for AggNodeVersion {
793 #[allow(deprecated)]
794 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
795 where
796 S: serde::Serializer,
797 {
798 let variant = match self {
799 Self::Unspecified => "AGG_NODE_VERSION_UNSPECIFIED",
800 Self::Issue12140 => "AGG_NODE_VERSION_ISSUE_12140",
801 Self::Issue13465 => "AGG_NODE_VERSION_ISSUE_13465",
802 };
803 serializer.serialize_str(variant)
804 }
805}
806impl<'de> serde::Deserialize<'de> for AggNodeVersion {
807 #[allow(deprecated)]
808 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
809 where
810 D: serde::Deserializer<'de>,
811 {
812 const FIELDS: &[&str] = &[
813 "AGG_NODE_VERSION_UNSPECIFIED",
814 "AGG_NODE_VERSION_ISSUE_12140",
815 "AGG_NODE_VERSION_ISSUE_13465",
816 ];
817
818 struct GeneratedVisitor;
819
820 impl serde::de::Visitor<'_> for GeneratedVisitor {
821 type Value = AggNodeVersion;
822
823 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
824 write!(formatter, "expected one of: {:?}", &FIELDS)
825 }
826
827 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
828 where
829 E: serde::de::Error,
830 {
831 i32::try_from(v)
832 .ok()
833 .and_then(|x| x.try_into().ok())
834 .ok_or_else(|| {
835 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
836 })
837 }
838
839 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
840 where
841 E: serde::de::Error,
842 {
843 i32::try_from(v)
844 .ok()
845 .and_then(|x| x.try_into().ok())
846 .ok_or_else(|| {
847 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
848 })
849 }
850
851 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
852 where
853 E: serde::de::Error,
854 {
855 match value {
856 "AGG_NODE_VERSION_UNSPECIFIED" => Ok(AggNodeVersion::Unspecified),
857 "AGG_NODE_VERSION_ISSUE_12140" => Ok(AggNodeVersion::Issue12140),
858 "AGG_NODE_VERSION_ISSUE_13465" => Ok(AggNodeVersion::Issue13465),
859 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
860 }
861 }
862 }
863 deserializer.deserialize_any(GeneratedVisitor)
864 }
865}
866impl serde::Serialize for ArrangeNode {
867 #[allow(deprecated)]
868 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
869 where
870 S: serde::Serializer,
871 {
872 use serde::ser::SerializeStruct;
873 let mut len = 0;
874 if self.table_info.is_some() {
875 len += 1;
876 }
877 if !self.distribution_key.is_empty() {
878 len += 1;
879 }
880 if self.table.is_some() {
881 len += 1;
882 }
883 let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangeNode", len)?;
884 if let Some(v) = self.table_info.as_ref() {
885 struct_ser.serialize_field("tableInfo", v)?;
886 }
887 if !self.distribution_key.is_empty() {
888 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
889 }
890 if let Some(v) = self.table.as_ref() {
891 struct_ser.serialize_field("table", v)?;
892 }
893 struct_ser.end()
894 }
895}
896impl<'de> serde::Deserialize<'de> for ArrangeNode {
897 #[allow(deprecated)]
898 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
899 where
900 D: serde::Deserializer<'de>,
901 {
902 const FIELDS: &[&str] = &[
903 "table_info",
904 "tableInfo",
905 "distribution_key",
906 "distributionKey",
907 "table",
908 ];
909
910 #[allow(clippy::enum_variant_names)]
911 enum GeneratedField {
912 TableInfo,
913 DistributionKey,
914 Table,
915 }
916 impl<'de> serde::Deserialize<'de> for GeneratedField {
917 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
918 where
919 D: serde::Deserializer<'de>,
920 {
921 struct GeneratedVisitor;
922
923 impl serde::de::Visitor<'_> for GeneratedVisitor {
924 type Value = GeneratedField;
925
926 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
927 write!(formatter, "expected one of: {:?}", &FIELDS)
928 }
929
930 #[allow(unused_variables)]
931 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
932 where
933 E: serde::de::Error,
934 {
935 match value {
936 "tableInfo" | "table_info" => Ok(GeneratedField::TableInfo),
937 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
938 "table" => Ok(GeneratedField::Table),
939 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
940 }
941 }
942 }
943 deserializer.deserialize_identifier(GeneratedVisitor)
944 }
945 }
946 struct GeneratedVisitor;
947 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
948 type Value = ArrangeNode;
949
950 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
951 formatter.write_str("struct stream_plan.ArrangeNode")
952 }
953
954 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangeNode, V::Error>
955 where
956 V: serde::de::MapAccess<'de>,
957 {
958 let mut table_info__ = None;
959 let mut distribution_key__ = None;
960 let mut table__ = None;
961 while let Some(k) = map_.next_key()? {
962 match k {
963 GeneratedField::TableInfo => {
964 if table_info__.is_some() {
965 return Err(serde::de::Error::duplicate_field("tableInfo"));
966 }
967 table_info__ = map_.next_value()?;
968 }
969 GeneratedField::DistributionKey => {
970 if distribution_key__.is_some() {
971 return Err(serde::de::Error::duplicate_field("distributionKey"));
972 }
973 distribution_key__ =
974 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
975 .into_iter().map(|x| x.0).collect())
976 ;
977 }
978 GeneratedField::Table => {
979 if table__.is_some() {
980 return Err(serde::de::Error::duplicate_field("table"));
981 }
982 table__ = map_.next_value()?;
983 }
984 }
985 }
986 Ok(ArrangeNode {
987 table_info: table_info__,
988 distribution_key: distribution_key__.unwrap_or_default(),
989 table: table__,
990 })
991 }
992 }
993 deserializer.deserialize_struct("stream_plan.ArrangeNode", FIELDS, GeneratedVisitor)
994 }
995}
996impl serde::Serialize for ArrangementInfo {
997 #[allow(deprecated)]
998 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
999 where
1000 S: serde::Serializer,
1001 {
1002 use serde::ser::SerializeStruct;
1003 let mut len = 0;
1004 if !self.arrange_key_orders.is_empty() {
1005 len += 1;
1006 }
1007 if !self.column_descs.is_empty() {
1008 len += 1;
1009 }
1010 if self.table_desc.is_some() {
1011 len += 1;
1012 }
1013 if !self.output_col_idx.is_empty() {
1014 len += 1;
1015 }
1016 let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangementInfo", len)?;
1017 if !self.arrange_key_orders.is_empty() {
1018 struct_ser.serialize_field("arrangeKeyOrders", &self.arrange_key_orders)?;
1019 }
1020 if !self.column_descs.is_empty() {
1021 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
1022 }
1023 if let Some(v) = self.table_desc.as_ref() {
1024 struct_ser.serialize_field("tableDesc", v)?;
1025 }
1026 if !self.output_col_idx.is_empty() {
1027 struct_ser.serialize_field("outputColIdx", &self.output_col_idx)?;
1028 }
1029 struct_ser.end()
1030 }
1031}
1032impl<'de> serde::Deserialize<'de> for ArrangementInfo {
1033 #[allow(deprecated)]
1034 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1035 where
1036 D: serde::Deserializer<'de>,
1037 {
1038 const FIELDS: &[&str] = &[
1039 "arrange_key_orders",
1040 "arrangeKeyOrders",
1041 "column_descs",
1042 "columnDescs",
1043 "table_desc",
1044 "tableDesc",
1045 "output_col_idx",
1046 "outputColIdx",
1047 ];
1048
1049 #[allow(clippy::enum_variant_names)]
1050 enum GeneratedField {
1051 ArrangeKeyOrders,
1052 ColumnDescs,
1053 TableDesc,
1054 OutputColIdx,
1055 }
1056 impl<'de> serde::Deserialize<'de> for GeneratedField {
1057 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1058 where
1059 D: serde::Deserializer<'de>,
1060 {
1061 struct GeneratedVisitor;
1062
1063 impl serde::de::Visitor<'_> for GeneratedVisitor {
1064 type Value = GeneratedField;
1065
1066 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1067 write!(formatter, "expected one of: {:?}", &FIELDS)
1068 }
1069
1070 #[allow(unused_variables)]
1071 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1072 where
1073 E: serde::de::Error,
1074 {
1075 match value {
1076 "arrangeKeyOrders" | "arrange_key_orders" => Ok(GeneratedField::ArrangeKeyOrders),
1077 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
1078 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
1079 "outputColIdx" | "output_col_idx" => Ok(GeneratedField::OutputColIdx),
1080 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1081 }
1082 }
1083 }
1084 deserializer.deserialize_identifier(GeneratedVisitor)
1085 }
1086 }
1087 struct GeneratedVisitor;
1088 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1089 type Value = ArrangementInfo;
1090
1091 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1092 formatter.write_str("struct stream_plan.ArrangementInfo")
1093 }
1094
1095 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangementInfo, V::Error>
1096 where
1097 V: serde::de::MapAccess<'de>,
1098 {
1099 let mut arrange_key_orders__ = None;
1100 let mut column_descs__ = None;
1101 let mut table_desc__ = None;
1102 let mut output_col_idx__ = None;
1103 while let Some(k) = map_.next_key()? {
1104 match k {
1105 GeneratedField::ArrangeKeyOrders => {
1106 if arrange_key_orders__.is_some() {
1107 return Err(serde::de::Error::duplicate_field("arrangeKeyOrders"));
1108 }
1109 arrange_key_orders__ = Some(map_.next_value()?);
1110 }
1111 GeneratedField::ColumnDescs => {
1112 if column_descs__.is_some() {
1113 return Err(serde::de::Error::duplicate_field("columnDescs"));
1114 }
1115 column_descs__ = Some(map_.next_value()?);
1116 }
1117 GeneratedField::TableDesc => {
1118 if table_desc__.is_some() {
1119 return Err(serde::de::Error::duplicate_field("tableDesc"));
1120 }
1121 table_desc__ = map_.next_value()?;
1122 }
1123 GeneratedField::OutputColIdx => {
1124 if output_col_idx__.is_some() {
1125 return Err(serde::de::Error::duplicate_field("outputColIdx"));
1126 }
1127 output_col_idx__ =
1128 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1129 .into_iter().map(|x| x.0).collect())
1130 ;
1131 }
1132 }
1133 }
1134 Ok(ArrangementInfo {
1135 arrange_key_orders: arrange_key_orders__.unwrap_or_default(),
1136 column_descs: column_descs__.unwrap_or_default(),
1137 table_desc: table_desc__,
1138 output_col_idx: output_col_idx__.unwrap_or_default(),
1139 })
1140 }
1141 }
1142 deserializer.deserialize_struct("stream_plan.ArrangementInfo", FIELDS, GeneratedVisitor)
1143 }
1144}
1145impl serde::Serialize for AsOfJoinNode {
1146 #[allow(deprecated)]
1147 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1148 where
1149 S: serde::Serializer,
1150 {
1151 use serde::ser::SerializeStruct;
1152 let mut len = 0;
1153 if self.join_type != 0 {
1154 len += 1;
1155 }
1156 if !self.left_key.is_empty() {
1157 len += 1;
1158 }
1159 if !self.right_key.is_empty() {
1160 len += 1;
1161 }
1162 if self.left_table.is_some() {
1163 len += 1;
1164 }
1165 if self.right_table.is_some() {
1166 len += 1;
1167 }
1168 if !self.output_indices.is_empty() {
1169 len += 1;
1170 }
1171 if !self.left_deduped_input_pk_indices.is_empty() {
1172 len += 1;
1173 }
1174 if !self.right_deduped_input_pk_indices.is_empty() {
1175 len += 1;
1176 }
1177 if !self.null_safe.is_empty() {
1178 len += 1;
1179 }
1180 if self.asof_desc.is_some() {
1181 len += 1;
1182 }
1183 if self.join_encoding_type != 0 {
1184 len += 1;
1185 }
1186 let mut struct_ser = serializer.serialize_struct("stream_plan.AsOfJoinNode", len)?;
1187 if self.join_type != 0 {
1188 let v = super::plan_common::AsOfJoinType::try_from(self.join_type)
1189 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
1190 struct_ser.serialize_field("joinType", &v)?;
1191 }
1192 if !self.left_key.is_empty() {
1193 struct_ser.serialize_field("leftKey", &self.left_key)?;
1194 }
1195 if !self.right_key.is_empty() {
1196 struct_ser.serialize_field("rightKey", &self.right_key)?;
1197 }
1198 if let Some(v) = self.left_table.as_ref() {
1199 struct_ser.serialize_field("leftTable", v)?;
1200 }
1201 if let Some(v) = self.right_table.as_ref() {
1202 struct_ser.serialize_field("rightTable", v)?;
1203 }
1204 if !self.output_indices.is_empty() {
1205 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
1206 }
1207 if !self.left_deduped_input_pk_indices.is_empty() {
1208 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
1209 }
1210 if !self.right_deduped_input_pk_indices.is_empty() {
1211 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
1212 }
1213 if !self.null_safe.is_empty() {
1214 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
1215 }
1216 if let Some(v) = self.asof_desc.as_ref() {
1217 struct_ser.serialize_field("asofDesc", v)?;
1218 }
1219 if self.join_encoding_type != 0 {
1220 let v = JoinEncodingType::try_from(self.join_encoding_type)
1221 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
1222 struct_ser.serialize_field("joinEncodingType", &v)?;
1223 }
1224 struct_ser.end()
1225 }
1226}
1227impl<'de> serde::Deserialize<'de> for AsOfJoinNode {
1228 #[allow(deprecated)]
1229 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1230 where
1231 D: serde::Deserializer<'de>,
1232 {
1233 const FIELDS: &[&str] = &[
1234 "join_type",
1235 "joinType",
1236 "left_key",
1237 "leftKey",
1238 "right_key",
1239 "rightKey",
1240 "left_table",
1241 "leftTable",
1242 "right_table",
1243 "rightTable",
1244 "output_indices",
1245 "outputIndices",
1246 "left_deduped_input_pk_indices",
1247 "leftDedupedInputPkIndices",
1248 "right_deduped_input_pk_indices",
1249 "rightDedupedInputPkIndices",
1250 "null_safe",
1251 "nullSafe",
1252 "asof_desc",
1253 "asofDesc",
1254 "join_encoding_type",
1255 "joinEncodingType",
1256 ];
1257
1258 #[allow(clippy::enum_variant_names)]
1259 enum GeneratedField {
1260 JoinType,
1261 LeftKey,
1262 RightKey,
1263 LeftTable,
1264 RightTable,
1265 OutputIndices,
1266 LeftDedupedInputPkIndices,
1267 RightDedupedInputPkIndices,
1268 NullSafe,
1269 AsofDesc,
1270 JoinEncodingType,
1271 }
1272 impl<'de> serde::Deserialize<'de> for GeneratedField {
1273 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1274 where
1275 D: serde::Deserializer<'de>,
1276 {
1277 struct GeneratedVisitor;
1278
1279 impl serde::de::Visitor<'_> for GeneratedVisitor {
1280 type Value = GeneratedField;
1281
1282 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1283 write!(formatter, "expected one of: {:?}", &FIELDS)
1284 }
1285
1286 #[allow(unused_variables)]
1287 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1288 where
1289 E: serde::de::Error,
1290 {
1291 match value {
1292 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
1293 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
1294 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
1295 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
1296 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
1297 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
1298 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
1299 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
1300 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
1301 "asofDesc" | "asof_desc" => Ok(GeneratedField::AsofDesc),
1302 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
1303 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1304 }
1305 }
1306 }
1307 deserializer.deserialize_identifier(GeneratedVisitor)
1308 }
1309 }
1310 struct GeneratedVisitor;
1311 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1312 type Value = AsOfJoinNode;
1313
1314 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1315 formatter.write_str("struct stream_plan.AsOfJoinNode")
1316 }
1317
1318 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AsOfJoinNode, V::Error>
1319 where
1320 V: serde::de::MapAccess<'de>,
1321 {
1322 let mut join_type__ = None;
1323 let mut left_key__ = None;
1324 let mut right_key__ = None;
1325 let mut left_table__ = None;
1326 let mut right_table__ = None;
1327 let mut output_indices__ = None;
1328 let mut left_deduped_input_pk_indices__ = None;
1329 let mut right_deduped_input_pk_indices__ = None;
1330 let mut null_safe__ = None;
1331 let mut asof_desc__ = None;
1332 let mut join_encoding_type__ = None;
1333 while let Some(k) = map_.next_key()? {
1334 match k {
1335 GeneratedField::JoinType => {
1336 if join_type__.is_some() {
1337 return Err(serde::de::Error::duplicate_field("joinType"));
1338 }
1339 join_type__ = Some(map_.next_value::<super::plan_common::AsOfJoinType>()? as i32);
1340 }
1341 GeneratedField::LeftKey => {
1342 if left_key__.is_some() {
1343 return Err(serde::de::Error::duplicate_field("leftKey"));
1344 }
1345 left_key__ =
1346 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1347 .into_iter().map(|x| x.0).collect())
1348 ;
1349 }
1350 GeneratedField::RightKey => {
1351 if right_key__.is_some() {
1352 return Err(serde::de::Error::duplicate_field("rightKey"));
1353 }
1354 right_key__ =
1355 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1356 .into_iter().map(|x| x.0).collect())
1357 ;
1358 }
1359 GeneratedField::LeftTable => {
1360 if left_table__.is_some() {
1361 return Err(serde::de::Error::duplicate_field("leftTable"));
1362 }
1363 left_table__ = map_.next_value()?;
1364 }
1365 GeneratedField::RightTable => {
1366 if right_table__.is_some() {
1367 return Err(serde::de::Error::duplicate_field("rightTable"));
1368 }
1369 right_table__ = map_.next_value()?;
1370 }
1371 GeneratedField::OutputIndices => {
1372 if output_indices__.is_some() {
1373 return Err(serde::de::Error::duplicate_field("outputIndices"));
1374 }
1375 output_indices__ =
1376 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1377 .into_iter().map(|x| x.0).collect())
1378 ;
1379 }
1380 GeneratedField::LeftDedupedInputPkIndices => {
1381 if left_deduped_input_pk_indices__.is_some() {
1382 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
1383 }
1384 left_deduped_input_pk_indices__ =
1385 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1386 .into_iter().map(|x| x.0).collect())
1387 ;
1388 }
1389 GeneratedField::RightDedupedInputPkIndices => {
1390 if right_deduped_input_pk_indices__.is_some() {
1391 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
1392 }
1393 right_deduped_input_pk_indices__ =
1394 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1395 .into_iter().map(|x| x.0).collect())
1396 ;
1397 }
1398 GeneratedField::NullSafe => {
1399 if null_safe__.is_some() {
1400 return Err(serde::de::Error::duplicate_field("nullSafe"));
1401 }
1402 null_safe__ = Some(map_.next_value()?);
1403 }
1404 GeneratedField::AsofDesc => {
1405 if asof_desc__.is_some() {
1406 return Err(serde::de::Error::duplicate_field("asofDesc"));
1407 }
1408 asof_desc__ = map_.next_value()?;
1409 }
1410 GeneratedField::JoinEncodingType => {
1411 if join_encoding_type__.is_some() {
1412 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
1413 }
1414 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
1415 }
1416 }
1417 }
1418 Ok(AsOfJoinNode {
1419 join_type: join_type__.unwrap_or_default(),
1420 left_key: left_key__.unwrap_or_default(),
1421 right_key: right_key__.unwrap_or_default(),
1422 left_table: left_table__,
1423 right_table: right_table__,
1424 output_indices: output_indices__.unwrap_or_default(),
1425 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
1426 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
1427 null_safe: null_safe__.unwrap_or_default(),
1428 asof_desc: asof_desc__,
1429 join_encoding_type: join_encoding_type__.unwrap_or_default(),
1430 })
1431 }
1432 }
1433 deserializer.deserialize_struct("stream_plan.AsOfJoinNode", FIELDS, GeneratedVisitor)
1434 }
1435}
1436impl serde::Serialize for BackfillOrder {
1437 #[allow(deprecated)]
1438 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1439 where
1440 S: serde::Serializer,
1441 {
1442 use serde::ser::SerializeStruct;
1443 let mut len = 0;
1444 if !self.order.is_empty() {
1445 len += 1;
1446 }
1447 let mut struct_ser = serializer.serialize_struct("stream_plan.BackfillOrder", len)?;
1448 if !self.order.is_empty() {
1449 struct_ser.serialize_field("order", &self.order)?;
1450 }
1451 struct_ser.end()
1452 }
1453}
1454impl<'de> serde::Deserialize<'de> for BackfillOrder {
1455 #[allow(deprecated)]
1456 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1457 where
1458 D: serde::Deserializer<'de>,
1459 {
1460 const FIELDS: &[&str] = &[
1461 "order",
1462 ];
1463
1464 #[allow(clippy::enum_variant_names)]
1465 enum GeneratedField {
1466 Order,
1467 }
1468 impl<'de> serde::Deserialize<'de> for GeneratedField {
1469 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1470 where
1471 D: serde::Deserializer<'de>,
1472 {
1473 struct GeneratedVisitor;
1474
1475 impl serde::de::Visitor<'_> for GeneratedVisitor {
1476 type Value = GeneratedField;
1477
1478 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1479 write!(formatter, "expected one of: {:?}", &FIELDS)
1480 }
1481
1482 #[allow(unused_variables)]
1483 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1484 where
1485 E: serde::de::Error,
1486 {
1487 match value {
1488 "order" => Ok(GeneratedField::Order),
1489 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1490 }
1491 }
1492 }
1493 deserializer.deserialize_identifier(GeneratedVisitor)
1494 }
1495 }
1496 struct GeneratedVisitor;
1497 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1498 type Value = BackfillOrder;
1499
1500 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1501 formatter.write_str("struct stream_plan.BackfillOrder")
1502 }
1503
1504 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BackfillOrder, V::Error>
1505 where
1506 V: serde::de::MapAccess<'de>,
1507 {
1508 let mut order__ = None;
1509 while let Some(k) = map_.next_key()? {
1510 match k {
1511 GeneratedField::Order => {
1512 if order__.is_some() {
1513 return Err(serde::de::Error::duplicate_field("order"));
1514 }
1515 order__ = Some(
1516 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1517 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1518 );
1519 }
1520 }
1521 }
1522 Ok(BackfillOrder {
1523 order: order__.unwrap_or_default(),
1524 })
1525 }
1526 }
1527 deserializer.deserialize_struct("stream_plan.BackfillOrder", FIELDS, GeneratedVisitor)
1528 }
1529}
1530impl serde::Serialize for Barrier {
1531 #[allow(deprecated)]
1532 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1533 where
1534 S: serde::Serializer,
1535 {
1536 use serde::ser::SerializeStruct;
1537 let mut len = 0;
1538 if self.epoch.is_some() {
1539 len += 1;
1540 }
1541 if self.mutation.is_some() {
1542 len += 1;
1543 }
1544 if !self.tracing_context.is_empty() {
1545 len += 1;
1546 }
1547 if self.kind != 0 {
1548 len += 1;
1549 }
1550 let mut struct_ser = serializer.serialize_struct("stream_plan.Barrier", len)?;
1551 if let Some(v) = self.epoch.as_ref() {
1552 struct_ser.serialize_field("epoch", v)?;
1553 }
1554 if let Some(v) = self.mutation.as_ref() {
1555 struct_ser.serialize_field("mutation", v)?;
1556 }
1557 if !self.tracing_context.is_empty() {
1558 struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
1559 }
1560 if self.kind != 0 {
1561 let v = barrier::BarrierKind::try_from(self.kind)
1562 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
1563 struct_ser.serialize_field("kind", &v)?;
1564 }
1565 struct_ser.end()
1566 }
1567}
1568impl<'de> serde::Deserialize<'de> for Barrier {
1569 #[allow(deprecated)]
1570 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1571 where
1572 D: serde::Deserializer<'de>,
1573 {
1574 const FIELDS: &[&str] = &[
1575 "epoch",
1576 "mutation",
1577 "tracing_context",
1578 "tracingContext",
1579 "kind",
1580 ];
1581
1582 #[allow(clippy::enum_variant_names)]
1583 enum GeneratedField {
1584 Epoch,
1585 Mutation,
1586 TracingContext,
1587 Kind,
1588 }
1589 impl<'de> serde::Deserialize<'de> for GeneratedField {
1590 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1591 where
1592 D: serde::Deserializer<'de>,
1593 {
1594 struct GeneratedVisitor;
1595
1596 impl serde::de::Visitor<'_> for GeneratedVisitor {
1597 type Value = GeneratedField;
1598
1599 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1600 write!(formatter, "expected one of: {:?}", &FIELDS)
1601 }
1602
1603 #[allow(unused_variables)]
1604 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1605 where
1606 E: serde::de::Error,
1607 {
1608 match value {
1609 "epoch" => Ok(GeneratedField::Epoch),
1610 "mutation" => Ok(GeneratedField::Mutation),
1611 "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
1612 "kind" => Ok(GeneratedField::Kind),
1613 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1614 }
1615 }
1616 }
1617 deserializer.deserialize_identifier(GeneratedVisitor)
1618 }
1619 }
1620 struct GeneratedVisitor;
1621 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1622 type Value = Barrier;
1623
1624 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1625 formatter.write_str("struct stream_plan.Barrier")
1626 }
1627
1628 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Barrier, V::Error>
1629 where
1630 V: serde::de::MapAccess<'de>,
1631 {
1632 let mut epoch__ = None;
1633 let mut mutation__ = None;
1634 let mut tracing_context__ = None;
1635 let mut kind__ = None;
1636 while let Some(k) = map_.next_key()? {
1637 match k {
1638 GeneratedField::Epoch => {
1639 if epoch__.is_some() {
1640 return Err(serde::de::Error::duplicate_field("epoch"));
1641 }
1642 epoch__ = map_.next_value()?;
1643 }
1644 GeneratedField::Mutation => {
1645 if mutation__.is_some() {
1646 return Err(serde::de::Error::duplicate_field("mutation"));
1647 }
1648 mutation__ = map_.next_value()?;
1649 }
1650 GeneratedField::TracingContext => {
1651 if tracing_context__.is_some() {
1652 return Err(serde::de::Error::duplicate_field("tracingContext"));
1653 }
1654 tracing_context__ = Some(
1655 map_.next_value::<std::collections::HashMap<_, _>>()?
1656 );
1657 }
1658 GeneratedField::Kind => {
1659 if kind__.is_some() {
1660 return Err(serde::de::Error::duplicate_field("kind"));
1661 }
1662 kind__ = Some(map_.next_value::<barrier::BarrierKind>()? as i32);
1663 }
1664 }
1665 }
1666 Ok(Barrier {
1667 epoch: epoch__,
1668 mutation: mutation__,
1669 tracing_context: tracing_context__.unwrap_or_default(),
1670 kind: kind__.unwrap_or_default(),
1671 })
1672 }
1673 }
1674 deserializer.deserialize_struct("stream_plan.Barrier", FIELDS, GeneratedVisitor)
1675 }
1676}
1677impl serde::Serialize for barrier::BarrierKind {
1678 #[allow(deprecated)]
1679 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1680 where
1681 S: serde::Serializer,
1682 {
1683 let variant = match self {
1684 Self::Unspecified => "BARRIER_KIND_UNSPECIFIED",
1685 Self::Initial => "BARRIER_KIND_INITIAL",
1686 Self::Barrier => "BARRIER_KIND_BARRIER",
1687 Self::Checkpoint => "BARRIER_KIND_CHECKPOINT",
1688 };
1689 serializer.serialize_str(variant)
1690 }
1691}
1692impl<'de> serde::Deserialize<'de> for barrier::BarrierKind {
1693 #[allow(deprecated)]
1694 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1695 where
1696 D: serde::Deserializer<'de>,
1697 {
1698 const FIELDS: &[&str] = &[
1699 "BARRIER_KIND_UNSPECIFIED",
1700 "BARRIER_KIND_INITIAL",
1701 "BARRIER_KIND_BARRIER",
1702 "BARRIER_KIND_CHECKPOINT",
1703 ];
1704
1705 struct GeneratedVisitor;
1706
1707 impl serde::de::Visitor<'_> for GeneratedVisitor {
1708 type Value = barrier::BarrierKind;
1709
1710 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1711 write!(formatter, "expected one of: {:?}", &FIELDS)
1712 }
1713
1714 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1715 where
1716 E: serde::de::Error,
1717 {
1718 i32::try_from(v)
1719 .ok()
1720 .and_then(|x| x.try_into().ok())
1721 .ok_or_else(|| {
1722 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1723 })
1724 }
1725
1726 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1727 where
1728 E: serde::de::Error,
1729 {
1730 i32::try_from(v)
1731 .ok()
1732 .and_then(|x| x.try_into().ok())
1733 .ok_or_else(|| {
1734 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1735 })
1736 }
1737
1738 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1739 where
1740 E: serde::de::Error,
1741 {
1742 match value {
1743 "BARRIER_KIND_UNSPECIFIED" => Ok(barrier::BarrierKind::Unspecified),
1744 "BARRIER_KIND_INITIAL" => Ok(barrier::BarrierKind::Initial),
1745 "BARRIER_KIND_BARRIER" => Ok(barrier::BarrierKind::Barrier),
1746 "BARRIER_KIND_CHECKPOINT" => Ok(barrier::BarrierKind::Checkpoint),
1747 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1748 }
1749 }
1750 }
1751 deserializer.deserialize_any(GeneratedVisitor)
1752 }
1753}
1754impl serde::Serialize for BarrierMutation {
1755 #[allow(deprecated)]
1756 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1757 where
1758 S: serde::Serializer,
1759 {
1760 use serde::ser::SerializeStruct;
1761 let mut len = 0;
1762 if self.mutation.is_some() {
1763 len += 1;
1764 }
1765 let mut struct_ser = serializer.serialize_struct("stream_plan.BarrierMutation", len)?;
1766 if let Some(v) = self.mutation.as_ref() {
1767 match v {
1768 barrier_mutation::Mutation::Add(v) => {
1769 struct_ser.serialize_field("add", v)?;
1770 }
1771 barrier_mutation::Mutation::Stop(v) => {
1772 struct_ser.serialize_field("stop", v)?;
1773 }
1774 barrier_mutation::Mutation::Update(v) => {
1775 struct_ser.serialize_field("update", v)?;
1776 }
1777 barrier_mutation::Mutation::Splits(v) => {
1778 struct_ser.serialize_field("splits", v)?;
1779 }
1780 barrier_mutation::Mutation::Pause(v) => {
1781 struct_ser.serialize_field("pause", v)?;
1782 }
1783 barrier_mutation::Mutation::Resume(v) => {
1784 struct_ser.serialize_field("resume", v)?;
1785 }
1786 barrier_mutation::Mutation::Throttle(v) => {
1787 struct_ser.serialize_field("throttle", v)?;
1788 }
1789 barrier_mutation::Mutation::DropSubscriptions(v) => {
1790 struct_ser.serialize_field("dropSubscriptions", v)?;
1791 }
1792 barrier_mutation::Mutation::ConnectorPropsChange(v) => {
1793 struct_ser.serialize_field("connectorPropsChange", v)?;
1794 }
1795 barrier_mutation::Mutation::StartFragmentBackfill(v) => {
1796 struct_ser.serialize_field("startFragmentBackfill", v)?;
1797 }
1798 barrier_mutation::Mutation::RefreshStart(v) => {
1799 struct_ser.serialize_field("refreshStart", v)?;
1800 }
1801 barrier_mutation::Mutation::LoadFinish(v) => {
1802 struct_ser.serialize_field("loadFinish", v)?;
1803 }
1804 barrier_mutation::Mutation::ListFinish(v) => {
1805 struct_ser.serialize_field("listFinish", v)?;
1806 }
1807 barrier_mutation::Mutation::ResetSource(v) => {
1808 struct_ser.serialize_field("resetSource", v)?;
1809 }
1810 }
1811 }
1812 struct_ser.end()
1813 }
1814}
1815impl<'de> serde::Deserialize<'de> for BarrierMutation {
1816 #[allow(deprecated)]
1817 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1818 where
1819 D: serde::Deserializer<'de>,
1820 {
1821 const FIELDS: &[&str] = &[
1822 "add",
1823 "stop",
1824 "update",
1825 "splits",
1826 "pause",
1827 "resume",
1828 "throttle",
1829 "drop_subscriptions",
1830 "dropSubscriptions",
1831 "connector_props_change",
1832 "connectorPropsChange",
1833 "start_fragment_backfill",
1834 "startFragmentBackfill",
1835 "refresh_start",
1836 "refreshStart",
1837 "load_finish",
1838 "loadFinish",
1839 "list_finish",
1840 "listFinish",
1841 "reset_source",
1842 "resetSource",
1843 ];
1844
1845 #[allow(clippy::enum_variant_names)]
1846 enum GeneratedField {
1847 Add,
1848 Stop,
1849 Update,
1850 Splits,
1851 Pause,
1852 Resume,
1853 Throttle,
1854 DropSubscriptions,
1855 ConnectorPropsChange,
1856 StartFragmentBackfill,
1857 RefreshStart,
1858 LoadFinish,
1859 ListFinish,
1860 ResetSource,
1861 }
1862 impl<'de> serde::Deserialize<'de> for GeneratedField {
1863 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1864 where
1865 D: serde::Deserializer<'de>,
1866 {
1867 struct GeneratedVisitor;
1868
1869 impl serde::de::Visitor<'_> for GeneratedVisitor {
1870 type Value = GeneratedField;
1871
1872 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1873 write!(formatter, "expected one of: {:?}", &FIELDS)
1874 }
1875
1876 #[allow(unused_variables)]
1877 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1878 where
1879 E: serde::de::Error,
1880 {
1881 match value {
1882 "add" => Ok(GeneratedField::Add),
1883 "stop" => Ok(GeneratedField::Stop),
1884 "update" => Ok(GeneratedField::Update),
1885 "splits" => Ok(GeneratedField::Splits),
1886 "pause" => Ok(GeneratedField::Pause),
1887 "resume" => Ok(GeneratedField::Resume),
1888 "throttle" => Ok(GeneratedField::Throttle),
1889 "dropSubscriptions" | "drop_subscriptions" => Ok(GeneratedField::DropSubscriptions),
1890 "connectorPropsChange" | "connector_props_change" => Ok(GeneratedField::ConnectorPropsChange),
1891 "startFragmentBackfill" | "start_fragment_backfill" => Ok(GeneratedField::StartFragmentBackfill),
1892 "refreshStart" | "refresh_start" => Ok(GeneratedField::RefreshStart),
1893 "loadFinish" | "load_finish" => Ok(GeneratedField::LoadFinish),
1894 "listFinish" | "list_finish" => Ok(GeneratedField::ListFinish),
1895 "resetSource" | "reset_source" => Ok(GeneratedField::ResetSource),
1896 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1897 }
1898 }
1899 }
1900 deserializer.deserialize_identifier(GeneratedVisitor)
1901 }
1902 }
1903 struct GeneratedVisitor;
1904 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1905 type Value = BarrierMutation;
1906
1907 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1908 formatter.write_str("struct stream_plan.BarrierMutation")
1909 }
1910
1911 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierMutation, V::Error>
1912 where
1913 V: serde::de::MapAccess<'de>,
1914 {
1915 let mut mutation__ = None;
1916 while let Some(k) = map_.next_key()? {
1917 match k {
1918 GeneratedField::Add => {
1919 if mutation__.is_some() {
1920 return Err(serde::de::Error::duplicate_field("add"));
1921 }
1922 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Add)
1923;
1924 }
1925 GeneratedField::Stop => {
1926 if mutation__.is_some() {
1927 return Err(serde::de::Error::duplicate_field("stop"));
1928 }
1929 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Stop)
1930;
1931 }
1932 GeneratedField::Update => {
1933 if mutation__.is_some() {
1934 return Err(serde::de::Error::duplicate_field("update"));
1935 }
1936 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Update)
1937;
1938 }
1939 GeneratedField::Splits => {
1940 if mutation__.is_some() {
1941 return Err(serde::de::Error::duplicate_field("splits"));
1942 }
1943 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Splits)
1944;
1945 }
1946 GeneratedField::Pause => {
1947 if mutation__.is_some() {
1948 return Err(serde::de::Error::duplicate_field("pause"));
1949 }
1950 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Pause)
1951;
1952 }
1953 GeneratedField::Resume => {
1954 if mutation__.is_some() {
1955 return Err(serde::de::Error::duplicate_field("resume"));
1956 }
1957 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Resume)
1958;
1959 }
1960 GeneratedField::Throttle => {
1961 if mutation__.is_some() {
1962 return Err(serde::de::Error::duplicate_field("throttle"));
1963 }
1964 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Throttle)
1965;
1966 }
1967 GeneratedField::DropSubscriptions => {
1968 if mutation__.is_some() {
1969 return Err(serde::de::Error::duplicate_field("dropSubscriptions"));
1970 }
1971 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::DropSubscriptions)
1972;
1973 }
1974 GeneratedField::ConnectorPropsChange => {
1975 if mutation__.is_some() {
1976 return Err(serde::de::Error::duplicate_field("connectorPropsChange"));
1977 }
1978 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ConnectorPropsChange)
1979;
1980 }
1981 GeneratedField::StartFragmentBackfill => {
1982 if mutation__.is_some() {
1983 return Err(serde::de::Error::duplicate_field("startFragmentBackfill"));
1984 }
1985 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::StartFragmentBackfill)
1986;
1987 }
1988 GeneratedField::RefreshStart => {
1989 if mutation__.is_some() {
1990 return Err(serde::de::Error::duplicate_field("refreshStart"));
1991 }
1992 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::RefreshStart)
1993;
1994 }
1995 GeneratedField::LoadFinish => {
1996 if mutation__.is_some() {
1997 return Err(serde::de::Error::duplicate_field("loadFinish"));
1998 }
1999 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::LoadFinish)
2000;
2001 }
2002 GeneratedField::ListFinish => {
2003 if mutation__.is_some() {
2004 return Err(serde::de::Error::duplicate_field("listFinish"));
2005 }
2006 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ListFinish)
2007;
2008 }
2009 GeneratedField::ResetSource => {
2010 if mutation__.is_some() {
2011 return Err(serde::de::Error::duplicate_field("resetSource"));
2012 }
2013 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ResetSource)
2014;
2015 }
2016 }
2017 }
2018 Ok(BarrierMutation {
2019 mutation: mutation__,
2020 })
2021 }
2022 }
2023 deserializer.deserialize_struct("stream_plan.BarrierMutation", FIELDS, GeneratedVisitor)
2024 }
2025}
2026impl serde::Serialize for BarrierRecvNode {
2027 #[allow(deprecated)]
2028 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2029 where
2030 S: serde::Serializer,
2031 {
2032 use serde::ser::SerializeStruct;
2033 let len = 0;
2034 let struct_ser = serializer.serialize_struct("stream_plan.BarrierRecvNode", len)?;
2035 struct_ser.end()
2036 }
2037}
2038impl<'de> serde::Deserialize<'de> for BarrierRecvNode {
2039 #[allow(deprecated)]
2040 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2041 where
2042 D: serde::Deserializer<'de>,
2043 {
2044 const FIELDS: &[&str] = &[
2045 ];
2046
2047 #[allow(clippy::enum_variant_names)]
2048 enum GeneratedField {
2049 }
2050 impl<'de> serde::Deserialize<'de> for GeneratedField {
2051 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2052 where
2053 D: serde::Deserializer<'de>,
2054 {
2055 struct GeneratedVisitor;
2056
2057 impl serde::de::Visitor<'_> for GeneratedVisitor {
2058 type Value = GeneratedField;
2059
2060 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2061 write!(formatter, "expected one of: {:?}", &FIELDS)
2062 }
2063
2064 #[allow(unused_variables)]
2065 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2066 where
2067 E: serde::de::Error,
2068 {
2069 Err(serde::de::Error::unknown_field(value, FIELDS))
2070 }
2071 }
2072 deserializer.deserialize_identifier(GeneratedVisitor)
2073 }
2074 }
2075 struct GeneratedVisitor;
2076 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2077 type Value = BarrierRecvNode;
2078
2079 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2080 formatter.write_str("struct stream_plan.BarrierRecvNode")
2081 }
2082
2083 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierRecvNode, V::Error>
2084 where
2085 V: serde::de::MapAccess<'de>,
2086 {
2087 while map_.next_key::<GeneratedField>()?.is_some() {
2088 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2089 }
2090 Ok(BarrierRecvNode {
2091 })
2092 }
2093 }
2094 deserializer.deserialize_struct("stream_plan.BarrierRecvNode", FIELDS, GeneratedVisitor)
2095 }
2096}
2097impl serde::Serialize for BatchPlanNode {
2098 #[allow(deprecated)]
2099 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2100 where
2101 S: serde::Serializer,
2102 {
2103 use serde::ser::SerializeStruct;
2104 let mut len = 0;
2105 if self.table_desc.is_some() {
2106 len += 1;
2107 }
2108 if !self.column_ids.is_empty() {
2109 len += 1;
2110 }
2111 let mut struct_ser = serializer.serialize_struct("stream_plan.BatchPlanNode", len)?;
2112 if let Some(v) = self.table_desc.as_ref() {
2113 struct_ser.serialize_field("tableDesc", v)?;
2114 }
2115 if !self.column_ids.is_empty() {
2116 struct_ser.serialize_field("columnIds", &self.column_ids)?;
2117 }
2118 struct_ser.end()
2119 }
2120}
2121impl<'de> serde::Deserialize<'de> for BatchPlanNode {
2122 #[allow(deprecated)]
2123 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2124 where
2125 D: serde::Deserializer<'de>,
2126 {
2127 const FIELDS: &[&str] = &[
2128 "table_desc",
2129 "tableDesc",
2130 "column_ids",
2131 "columnIds",
2132 ];
2133
2134 #[allow(clippy::enum_variant_names)]
2135 enum GeneratedField {
2136 TableDesc,
2137 ColumnIds,
2138 }
2139 impl<'de> serde::Deserialize<'de> for GeneratedField {
2140 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2141 where
2142 D: serde::Deserializer<'de>,
2143 {
2144 struct GeneratedVisitor;
2145
2146 impl serde::de::Visitor<'_> for GeneratedVisitor {
2147 type Value = GeneratedField;
2148
2149 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2150 write!(formatter, "expected one of: {:?}", &FIELDS)
2151 }
2152
2153 #[allow(unused_variables)]
2154 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2155 where
2156 E: serde::de::Error,
2157 {
2158 match value {
2159 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
2160 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
2161 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2162 }
2163 }
2164 }
2165 deserializer.deserialize_identifier(GeneratedVisitor)
2166 }
2167 }
2168 struct GeneratedVisitor;
2169 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2170 type Value = BatchPlanNode;
2171
2172 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2173 formatter.write_str("struct stream_plan.BatchPlanNode")
2174 }
2175
2176 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BatchPlanNode, V::Error>
2177 where
2178 V: serde::de::MapAccess<'de>,
2179 {
2180 let mut table_desc__ = None;
2181 let mut column_ids__ = None;
2182 while let Some(k) = map_.next_key()? {
2183 match k {
2184 GeneratedField::TableDesc => {
2185 if table_desc__.is_some() {
2186 return Err(serde::de::Error::duplicate_field("tableDesc"));
2187 }
2188 table_desc__ = map_.next_value()?;
2189 }
2190 GeneratedField::ColumnIds => {
2191 if column_ids__.is_some() {
2192 return Err(serde::de::Error::duplicate_field("columnIds"));
2193 }
2194 column_ids__ =
2195 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2196 .into_iter().map(|x| x.0).collect())
2197 ;
2198 }
2199 }
2200 }
2201 Ok(BatchPlanNode {
2202 table_desc: table_desc__,
2203 column_ids: column_ids__.unwrap_or_default(),
2204 })
2205 }
2206 }
2207 deserializer.deserialize_struct("stream_plan.BatchPlanNode", FIELDS, GeneratedVisitor)
2208 }
2209}
2210impl serde::Serialize for CdcFilterNode {
2211 #[allow(deprecated)]
2212 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2213 where
2214 S: serde::Serializer,
2215 {
2216 use serde::ser::SerializeStruct;
2217 let mut len = 0;
2218 if self.search_condition.is_some() {
2219 len += 1;
2220 }
2221 if self.upstream_source_id != 0 {
2222 len += 1;
2223 }
2224 let mut struct_ser = serializer.serialize_struct("stream_plan.CdcFilterNode", len)?;
2225 if let Some(v) = self.search_condition.as_ref() {
2226 struct_ser.serialize_field("searchCondition", v)?;
2227 }
2228 if self.upstream_source_id != 0 {
2229 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
2230 }
2231 struct_ser.end()
2232 }
2233}
2234impl<'de> serde::Deserialize<'de> for CdcFilterNode {
2235 #[allow(deprecated)]
2236 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2237 where
2238 D: serde::Deserializer<'de>,
2239 {
2240 const FIELDS: &[&str] = &[
2241 "search_condition",
2242 "searchCondition",
2243 "upstream_source_id",
2244 "upstreamSourceId",
2245 ];
2246
2247 #[allow(clippy::enum_variant_names)]
2248 enum GeneratedField {
2249 SearchCondition,
2250 UpstreamSourceId,
2251 }
2252 impl<'de> serde::Deserialize<'de> for GeneratedField {
2253 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2254 where
2255 D: serde::Deserializer<'de>,
2256 {
2257 struct GeneratedVisitor;
2258
2259 impl serde::de::Visitor<'_> for GeneratedVisitor {
2260 type Value = GeneratedField;
2261
2262 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2263 write!(formatter, "expected one of: {:?}", &FIELDS)
2264 }
2265
2266 #[allow(unused_variables)]
2267 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2268 where
2269 E: serde::de::Error,
2270 {
2271 match value {
2272 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
2273 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
2274 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2275 }
2276 }
2277 }
2278 deserializer.deserialize_identifier(GeneratedVisitor)
2279 }
2280 }
2281 struct GeneratedVisitor;
2282 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2283 type Value = CdcFilterNode;
2284
2285 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2286 formatter.write_str("struct stream_plan.CdcFilterNode")
2287 }
2288
2289 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcFilterNode, V::Error>
2290 where
2291 V: serde::de::MapAccess<'de>,
2292 {
2293 let mut search_condition__ = None;
2294 let mut upstream_source_id__ = None;
2295 while let Some(k) = map_.next_key()? {
2296 match k {
2297 GeneratedField::SearchCondition => {
2298 if search_condition__.is_some() {
2299 return Err(serde::de::Error::duplicate_field("searchCondition"));
2300 }
2301 search_condition__ = map_.next_value()?;
2302 }
2303 GeneratedField::UpstreamSourceId => {
2304 if upstream_source_id__.is_some() {
2305 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
2306 }
2307 upstream_source_id__ =
2308 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2309 ;
2310 }
2311 }
2312 }
2313 Ok(CdcFilterNode {
2314 search_condition: search_condition__,
2315 upstream_source_id: upstream_source_id__.unwrap_or_default(),
2316 })
2317 }
2318 }
2319 deserializer.deserialize_struct("stream_plan.CdcFilterNode", FIELDS, GeneratedVisitor)
2320 }
2321}
2322impl serde::Serialize for ChangeLogNode {
2323 #[allow(deprecated)]
2324 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2325 where
2326 S: serde::Serializer,
2327 {
2328 use serde::ser::SerializeStruct;
2329 let mut len = 0;
2330 if self.need_op {
2331 len += 1;
2332 }
2333 if !self.distribution_keys.is_empty() {
2334 len += 1;
2335 }
2336 let mut struct_ser = serializer.serialize_struct("stream_plan.ChangeLogNode", len)?;
2337 if self.need_op {
2338 struct_ser.serialize_field("needOp", &self.need_op)?;
2339 }
2340 if !self.distribution_keys.is_empty() {
2341 struct_ser.serialize_field("distributionKeys", &self.distribution_keys)?;
2342 }
2343 struct_ser.end()
2344 }
2345}
2346impl<'de> serde::Deserialize<'de> for ChangeLogNode {
2347 #[allow(deprecated)]
2348 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2349 where
2350 D: serde::Deserializer<'de>,
2351 {
2352 const FIELDS: &[&str] = &[
2353 "need_op",
2354 "needOp",
2355 "distribution_keys",
2356 "distributionKeys",
2357 ];
2358
2359 #[allow(clippy::enum_variant_names)]
2360 enum GeneratedField {
2361 NeedOp,
2362 DistributionKeys,
2363 }
2364 impl<'de> serde::Deserialize<'de> for GeneratedField {
2365 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2366 where
2367 D: serde::Deserializer<'de>,
2368 {
2369 struct GeneratedVisitor;
2370
2371 impl serde::de::Visitor<'_> for GeneratedVisitor {
2372 type Value = GeneratedField;
2373
2374 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2375 write!(formatter, "expected one of: {:?}", &FIELDS)
2376 }
2377
2378 #[allow(unused_variables)]
2379 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2380 where
2381 E: serde::de::Error,
2382 {
2383 match value {
2384 "needOp" | "need_op" => Ok(GeneratedField::NeedOp),
2385 "distributionKeys" | "distribution_keys" => Ok(GeneratedField::DistributionKeys),
2386 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2387 }
2388 }
2389 }
2390 deserializer.deserialize_identifier(GeneratedVisitor)
2391 }
2392 }
2393 struct GeneratedVisitor;
2394 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2395 type Value = ChangeLogNode;
2396
2397 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2398 formatter.write_str("struct stream_plan.ChangeLogNode")
2399 }
2400
2401 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ChangeLogNode, V::Error>
2402 where
2403 V: serde::de::MapAccess<'de>,
2404 {
2405 let mut need_op__ = None;
2406 let mut distribution_keys__ = None;
2407 while let Some(k) = map_.next_key()? {
2408 match k {
2409 GeneratedField::NeedOp => {
2410 if need_op__.is_some() {
2411 return Err(serde::de::Error::duplicate_field("needOp"));
2412 }
2413 need_op__ = Some(map_.next_value()?);
2414 }
2415 GeneratedField::DistributionKeys => {
2416 if distribution_keys__.is_some() {
2417 return Err(serde::de::Error::duplicate_field("distributionKeys"));
2418 }
2419 distribution_keys__ =
2420 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2421 .into_iter().map(|x| x.0).collect())
2422 ;
2423 }
2424 }
2425 }
2426 Ok(ChangeLogNode {
2427 need_op: need_op__.unwrap_or_default(),
2428 distribution_keys: distribution_keys__.unwrap_or_default(),
2429 })
2430 }
2431 }
2432 deserializer.deserialize_struct("stream_plan.ChangeLogNode", FIELDS, GeneratedVisitor)
2433 }
2434}
2435impl serde::Serialize for Columns {
2436 #[allow(deprecated)]
2437 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2438 where
2439 S: serde::Serializer,
2440 {
2441 use serde::ser::SerializeStruct;
2442 let mut len = 0;
2443 if !self.columns.is_empty() {
2444 len += 1;
2445 }
2446 let mut struct_ser = serializer.serialize_struct("stream_plan.Columns", len)?;
2447 if !self.columns.is_empty() {
2448 struct_ser.serialize_field("columns", &self.columns)?;
2449 }
2450 struct_ser.end()
2451 }
2452}
2453impl<'de> serde::Deserialize<'de> for Columns {
2454 #[allow(deprecated)]
2455 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2456 where
2457 D: serde::Deserializer<'de>,
2458 {
2459 const FIELDS: &[&str] = &[
2460 "columns",
2461 ];
2462
2463 #[allow(clippy::enum_variant_names)]
2464 enum GeneratedField {
2465 Columns,
2466 }
2467 impl<'de> serde::Deserialize<'de> for GeneratedField {
2468 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2469 where
2470 D: serde::Deserializer<'de>,
2471 {
2472 struct GeneratedVisitor;
2473
2474 impl serde::de::Visitor<'_> for GeneratedVisitor {
2475 type Value = GeneratedField;
2476
2477 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2478 write!(formatter, "expected one of: {:?}", &FIELDS)
2479 }
2480
2481 #[allow(unused_variables)]
2482 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2483 where
2484 E: serde::de::Error,
2485 {
2486 match value {
2487 "columns" => Ok(GeneratedField::Columns),
2488 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2489 }
2490 }
2491 }
2492 deserializer.deserialize_identifier(GeneratedVisitor)
2493 }
2494 }
2495 struct GeneratedVisitor;
2496 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2497 type Value = Columns;
2498
2499 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2500 formatter.write_str("struct stream_plan.Columns")
2501 }
2502
2503 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Columns, V::Error>
2504 where
2505 V: serde::de::MapAccess<'de>,
2506 {
2507 let mut columns__ = None;
2508 while let Some(k) = map_.next_key()? {
2509 match k {
2510 GeneratedField::Columns => {
2511 if columns__.is_some() {
2512 return Err(serde::de::Error::duplicate_field("columns"));
2513 }
2514 columns__ = Some(map_.next_value()?);
2515 }
2516 }
2517 }
2518 Ok(Columns {
2519 columns: columns__.unwrap_or_default(),
2520 })
2521 }
2522 }
2523 deserializer.deserialize_struct("stream_plan.Columns", FIELDS, GeneratedVisitor)
2524 }
2525}
2526impl serde::Serialize for ConnectorPropsChangeMutation {
2527 #[allow(deprecated)]
2528 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2529 where
2530 S: serde::Serializer,
2531 {
2532 use serde::ser::SerializeStruct;
2533 let mut len = 0;
2534 if !self.connector_props_infos.is_empty() {
2535 len += 1;
2536 }
2537 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation", len)?;
2538 if !self.connector_props_infos.is_empty() {
2539 struct_ser.serialize_field("connectorPropsInfos", &self.connector_props_infos)?;
2540 }
2541 struct_ser.end()
2542 }
2543}
2544impl<'de> serde::Deserialize<'de> for ConnectorPropsChangeMutation {
2545 #[allow(deprecated)]
2546 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2547 where
2548 D: serde::Deserializer<'de>,
2549 {
2550 const FIELDS: &[&str] = &[
2551 "connector_props_infos",
2552 "connectorPropsInfos",
2553 ];
2554
2555 #[allow(clippy::enum_variant_names)]
2556 enum GeneratedField {
2557 ConnectorPropsInfos,
2558 }
2559 impl<'de> serde::Deserialize<'de> for GeneratedField {
2560 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2561 where
2562 D: serde::Deserializer<'de>,
2563 {
2564 struct GeneratedVisitor;
2565
2566 impl serde::de::Visitor<'_> for GeneratedVisitor {
2567 type Value = GeneratedField;
2568
2569 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2570 write!(formatter, "expected one of: {:?}", &FIELDS)
2571 }
2572
2573 #[allow(unused_variables)]
2574 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2575 where
2576 E: serde::de::Error,
2577 {
2578 match value {
2579 "connectorPropsInfos" | "connector_props_infos" => Ok(GeneratedField::ConnectorPropsInfos),
2580 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2581 }
2582 }
2583 }
2584 deserializer.deserialize_identifier(GeneratedVisitor)
2585 }
2586 }
2587 struct GeneratedVisitor;
2588 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2589 type Value = ConnectorPropsChangeMutation;
2590
2591 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2592 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation")
2593 }
2594
2595 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectorPropsChangeMutation, V::Error>
2596 where
2597 V: serde::de::MapAccess<'de>,
2598 {
2599 let mut connector_props_infos__ = None;
2600 while let Some(k) = map_.next_key()? {
2601 match k {
2602 GeneratedField::ConnectorPropsInfos => {
2603 if connector_props_infos__.is_some() {
2604 return Err(serde::de::Error::duplicate_field("connectorPropsInfos"));
2605 }
2606 connector_props_infos__ = Some(
2607 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
2608 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
2609 );
2610 }
2611 }
2612 }
2613 Ok(ConnectorPropsChangeMutation {
2614 connector_props_infos: connector_props_infos__.unwrap_or_default(),
2615 })
2616 }
2617 }
2618 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation", FIELDS, GeneratedVisitor)
2619 }
2620}
2621impl serde::Serialize for connector_props_change_mutation::ConnectorPropsInfo {
2622 #[allow(deprecated)]
2623 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2624 where
2625 S: serde::Serializer,
2626 {
2627 use serde::ser::SerializeStruct;
2628 let mut len = 0;
2629 if !self.connector_props_info.is_empty() {
2630 len += 1;
2631 }
2632 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", len)?;
2633 if !self.connector_props_info.is_empty() {
2634 struct_ser.serialize_field("connectorPropsInfo", &self.connector_props_info)?;
2635 }
2636 struct_ser.end()
2637 }
2638}
2639impl<'de> serde::Deserialize<'de> for connector_props_change_mutation::ConnectorPropsInfo {
2640 #[allow(deprecated)]
2641 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2642 where
2643 D: serde::Deserializer<'de>,
2644 {
2645 const FIELDS: &[&str] = &[
2646 "connector_props_info",
2647 "connectorPropsInfo",
2648 ];
2649
2650 #[allow(clippy::enum_variant_names)]
2651 enum GeneratedField {
2652 ConnectorPropsInfo,
2653 }
2654 impl<'de> serde::Deserialize<'de> for GeneratedField {
2655 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2656 where
2657 D: serde::Deserializer<'de>,
2658 {
2659 struct GeneratedVisitor;
2660
2661 impl serde::de::Visitor<'_> for GeneratedVisitor {
2662 type Value = GeneratedField;
2663
2664 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2665 write!(formatter, "expected one of: {:?}", &FIELDS)
2666 }
2667
2668 #[allow(unused_variables)]
2669 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2670 where
2671 E: serde::de::Error,
2672 {
2673 match value {
2674 "connectorPropsInfo" | "connector_props_info" => Ok(GeneratedField::ConnectorPropsInfo),
2675 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2676 }
2677 }
2678 }
2679 deserializer.deserialize_identifier(GeneratedVisitor)
2680 }
2681 }
2682 struct GeneratedVisitor;
2683 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2684 type Value = connector_props_change_mutation::ConnectorPropsInfo;
2685
2686 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2687 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo")
2688 }
2689
2690 fn visit_map<V>(self, mut map_: V) -> std::result::Result<connector_props_change_mutation::ConnectorPropsInfo, V::Error>
2691 where
2692 V: serde::de::MapAccess<'de>,
2693 {
2694 let mut connector_props_info__ = None;
2695 while let Some(k) = map_.next_key()? {
2696 match k {
2697 GeneratedField::ConnectorPropsInfo => {
2698 if connector_props_info__.is_some() {
2699 return Err(serde::de::Error::duplicate_field("connectorPropsInfo"));
2700 }
2701 connector_props_info__ = Some(
2702 map_.next_value::<std::collections::HashMap<_, _>>()?
2703 );
2704 }
2705 }
2706 }
2707 Ok(connector_props_change_mutation::ConnectorPropsInfo {
2708 connector_props_info: connector_props_info__.unwrap_or_default(),
2709 })
2710 }
2711 }
2712 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", FIELDS, GeneratedVisitor)
2713 }
2714}
2715impl serde::Serialize for DedupNode {
2716 #[allow(deprecated)]
2717 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2718 where
2719 S: serde::Serializer,
2720 {
2721 use serde::ser::SerializeStruct;
2722 let mut len = 0;
2723 if self.state_table.is_some() {
2724 len += 1;
2725 }
2726 if !self.dedup_column_indices.is_empty() {
2727 len += 1;
2728 }
2729 let mut struct_ser = serializer.serialize_struct("stream_plan.DedupNode", len)?;
2730 if let Some(v) = self.state_table.as_ref() {
2731 struct_ser.serialize_field("stateTable", v)?;
2732 }
2733 if !self.dedup_column_indices.is_empty() {
2734 struct_ser.serialize_field("dedupColumnIndices", &self.dedup_column_indices)?;
2735 }
2736 struct_ser.end()
2737 }
2738}
2739impl<'de> serde::Deserialize<'de> for DedupNode {
2740 #[allow(deprecated)]
2741 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2742 where
2743 D: serde::Deserializer<'de>,
2744 {
2745 const FIELDS: &[&str] = &[
2746 "state_table",
2747 "stateTable",
2748 "dedup_column_indices",
2749 "dedupColumnIndices",
2750 ];
2751
2752 #[allow(clippy::enum_variant_names)]
2753 enum GeneratedField {
2754 StateTable,
2755 DedupColumnIndices,
2756 }
2757 impl<'de> serde::Deserialize<'de> for GeneratedField {
2758 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2759 where
2760 D: serde::Deserializer<'de>,
2761 {
2762 struct GeneratedVisitor;
2763
2764 impl serde::de::Visitor<'_> for GeneratedVisitor {
2765 type Value = GeneratedField;
2766
2767 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2768 write!(formatter, "expected one of: {:?}", &FIELDS)
2769 }
2770
2771 #[allow(unused_variables)]
2772 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2773 where
2774 E: serde::de::Error,
2775 {
2776 match value {
2777 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
2778 "dedupColumnIndices" | "dedup_column_indices" => Ok(GeneratedField::DedupColumnIndices),
2779 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2780 }
2781 }
2782 }
2783 deserializer.deserialize_identifier(GeneratedVisitor)
2784 }
2785 }
2786 struct GeneratedVisitor;
2787 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2788 type Value = DedupNode;
2789
2790 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2791 formatter.write_str("struct stream_plan.DedupNode")
2792 }
2793
2794 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DedupNode, V::Error>
2795 where
2796 V: serde::de::MapAccess<'de>,
2797 {
2798 let mut state_table__ = None;
2799 let mut dedup_column_indices__ = None;
2800 while let Some(k) = map_.next_key()? {
2801 match k {
2802 GeneratedField::StateTable => {
2803 if state_table__.is_some() {
2804 return Err(serde::de::Error::duplicate_field("stateTable"));
2805 }
2806 state_table__ = map_.next_value()?;
2807 }
2808 GeneratedField::DedupColumnIndices => {
2809 if dedup_column_indices__.is_some() {
2810 return Err(serde::de::Error::duplicate_field("dedupColumnIndices"));
2811 }
2812 dedup_column_indices__ =
2813 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2814 .into_iter().map(|x| x.0).collect())
2815 ;
2816 }
2817 }
2818 }
2819 Ok(DedupNode {
2820 state_table: state_table__,
2821 dedup_column_indices: dedup_column_indices__.unwrap_or_default(),
2822 })
2823 }
2824 }
2825 deserializer.deserialize_struct("stream_plan.DedupNode", FIELDS, GeneratedVisitor)
2826 }
2827}
2828impl serde::Serialize for DeltaExpression {
2829 #[allow(deprecated)]
2830 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2831 where
2832 S: serde::Serializer,
2833 {
2834 use serde::ser::SerializeStruct;
2835 let mut len = 0;
2836 if self.delta_type != 0 {
2837 len += 1;
2838 }
2839 if self.delta.is_some() {
2840 len += 1;
2841 }
2842 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaExpression", len)?;
2843 if self.delta_type != 0 {
2844 let v = super::expr::expr_node::Type::try_from(self.delta_type)
2845 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.delta_type)))?;
2846 struct_ser.serialize_field("deltaType", &v)?;
2847 }
2848 if let Some(v) = self.delta.as_ref() {
2849 struct_ser.serialize_field("delta", v)?;
2850 }
2851 struct_ser.end()
2852 }
2853}
2854impl<'de> serde::Deserialize<'de> for DeltaExpression {
2855 #[allow(deprecated)]
2856 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2857 where
2858 D: serde::Deserializer<'de>,
2859 {
2860 const FIELDS: &[&str] = &[
2861 "delta_type",
2862 "deltaType",
2863 "delta",
2864 ];
2865
2866 #[allow(clippy::enum_variant_names)]
2867 enum GeneratedField {
2868 DeltaType,
2869 Delta,
2870 }
2871 impl<'de> serde::Deserialize<'de> for GeneratedField {
2872 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2873 where
2874 D: serde::Deserializer<'de>,
2875 {
2876 struct GeneratedVisitor;
2877
2878 impl serde::de::Visitor<'_> for GeneratedVisitor {
2879 type Value = GeneratedField;
2880
2881 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2882 write!(formatter, "expected one of: {:?}", &FIELDS)
2883 }
2884
2885 #[allow(unused_variables)]
2886 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2887 where
2888 E: serde::de::Error,
2889 {
2890 match value {
2891 "deltaType" | "delta_type" => Ok(GeneratedField::DeltaType),
2892 "delta" => Ok(GeneratedField::Delta),
2893 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2894 }
2895 }
2896 }
2897 deserializer.deserialize_identifier(GeneratedVisitor)
2898 }
2899 }
2900 struct GeneratedVisitor;
2901 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2902 type Value = DeltaExpression;
2903
2904 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2905 formatter.write_str("struct stream_plan.DeltaExpression")
2906 }
2907
2908 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaExpression, V::Error>
2909 where
2910 V: serde::de::MapAccess<'de>,
2911 {
2912 let mut delta_type__ = None;
2913 let mut delta__ = None;
2914 while let Some(k) = map_.next_key()? {
2915 match k {
2916 GeneratedField::DeltaType => {
2917 if delta_type__.is_some() {
2918 return Err(serde::de::Error::duplicate_field("deltaType"));
2919 }
2920 delta_type__ = Some(map_.next_value::<super::expr::expr_node::Type>()? as i32);
2921 }
2922 GeneratedField::Delta => {
2923 if delta__.is_some() {
2924 return Err(serde::de::Error::duplicate_field("delta"));
2925 }
2926 delta__ = map_.next_value()?;
2927 }
2928 }
2929 }
2930 Ok(DeltaExpression {
2931 delta_type: delta_type__.unwrap_or_default(),
2932 delta: delta__,
2933 })
2934 }
2935 }
2936 deserializer.deserialize_struct("stream_plan.DeltaExpression", FIELDS, GeneratedVisitor)
2937 }
2938}
2939impl serde::Serialize for DeltaIndexJoinNode {
2940 #[allow(deprecated)]
2941 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2942 where
2943 S: serde::Serializer,
2944 {
2945 use serde::ser::SerializeStruct;
2946 let mut len = 0;
2947 if self.join_type != 0 {
2948 len += 1;
2949 }
2950 if !self.left_key.is_empty() {
2951 len += 1;
2952 }
2953 if !self.right_key.is_empty() {
2954 len += 1;
2955 }
2956 if self.condition.is_some() {
2957 len += 1;
2958 }
2959 if self.left_table_id != 0 {
2960 len += 1;
2961 }
2962 if self.right_table_id != 0 {
2963 len += 1;
2964 }
2965 if self.left_info.is_some() {
2966 len += 1;
2967 }
2968 if self.right_info.is_some() {
2969 len += 1;
2970 }
2971 if !self.output_indices.is_empty() {
2972 len += 1;
2973 }
2974 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaIndexJoinNode", len)?;
2975 if self.join_type != 0 {
2976 let v = super::plan_common::JoinType::try_from(self.join_type)
2977 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
2978 struct_ser.serialize_field("joinType", &v)?;
2979 }
2980 if !self.left_key.is_empty() {
2981 struct_ser.serialize_field("leftKey", &self.left_key)?;
2982 }
2983 if !self.right_key.is_empty() {
2984 struct_ser.serialize_field("rightKey", &self.right_key)?;
2985 }
2986 if let Some(v) = self.condition.as_ref() {
2987 struct_ser.serialize_field("condition", v)?;
2988 }
2989 if self.left_table_id != 0 {
2990 struct_ser.serialize_field("leftTableId", &self.left_table_id)?;
2991 }
2992 if self.right_table_id != 0 {
2993 struct_ser.serialize_field("rightTableId", &self.right_table_id)?;
2994 }
2995 if let Some(v) = self.left_info.as_ref() {
2996 struct_ser.serialize_field("leftInfo", v)?;
2997 }
2998 if let Some(v) = self.right_info.as_ref() {
2999 struct_ser.serialize_field("rightInfo", v)?;
3000 }
3001 if !self.output_indices.is_empty() {
3002 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
3003 }
3004 struct_ser.end()
3005 }
3006}
3007impl<'de> serde::Deserialize<'de> for DeltaIndexJoinNode {
3008 #[allow(deprecated)]
3009 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3010 where
3011 D: serde::Deserializer<'de>,
3012 {
3013 const FIELDS: &[&str] = &[
3014 "join_type",
3015 "joinType",
3016 "left_key",
3017 "leftKey",
3018 "right_key",
3019 "rightKey",
3020 "condition",
3021 "left_table_id",
3022 "leftTableId",
3023 "right_table_id",
3024 "rightTableId",
3025 "left_info",
3026 "leftInfo",
3027 "right_info",
3028 "rightInfo",
3029 "output_indices",
3030 "outputIndices",
3031 ];
3032
3033 #[allow(clippy::enum_variant_names)]
3034 enum GeneratedField {
3035 JoinType,
3036 LeftKey,
3037 RightKey,
3038 Condition,
3039 LeftTableId,
3040 RightTableId,
3041 LeftInfo,
3042 RightInfo,
3043 OutputIndices,
3044 }
3045 impl<'de> serde::Deserialize<'de> for GeneratedField {
3046 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3047 where
3048 D: serde::Deserializer<'de>,
3049 {
3050 struct GeneratedVisitor;
3051
3052 impl serde::de::Visitor<'_> for GeneratedVisitor {
3053 type Value = GeneratedField;
3054
3055 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3056 write!(formatter, "expected one of: {:?}", &FIELDS)
3057 }
3058
3059 #[allow(unused_variables)]
3060 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3061 where
3062 E: serde::de::Error,
3063 {
3064 match value {
3065 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
3066 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
3067 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
3068 "condition" => Ok(GeneratedField::Condition),
3069 "leftTableId" | "left_table_id" => Ok(GeneratedField::LeftTableId),
3070 "rightTableId" | "right_table_id" => Ok(GeneratedField::RightTableId),
3071 "leftInfo" | "left_info" => Ok(GeneratedField::LeftInfo),
3072 "rightInfo" | "right_info" => Ok(GeneratedField::RightInfo),
3073 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
3074 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3075 }
3076 }
3077 }
3078 deserializer.deserialize_identifier(GeneratedVisitor)
3079 }
3080 }
3081 struct GeneratedVisitor;
3082 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3083 type Value = DeltaIndexJoinNode;
3084
3085 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3086 formatter.write_str("struct stream_plan.DeltaIndexJoinNode")
3087 }
3088
3089 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaIndexJoinNode, V::Error>
3090 where
3091 V: serde::de::MapAccess<'de>,
3092 {
3093 let mut join_type__ = None;
3094 let mut left_key__ = None;
3095 let mut right_key__ = None;
3096 let mut condition__ = None;
3097 let mut left_table_id__ = None;
3098 let mut right_table_id__ = None;
3099 let mut left_info__ = None;
3100 let mut right_info__ = None;
3101 let mut output_indices__ = None;
3102 while let Some(k) = map_.next_key()? {
3103 match k {
3104 GeneratedField::JoinType => {
3105 if join_type__.is_some() {
3106 return Err(serde::de::Error::duplicate_field("joinType"));
3107 }
3108 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
3109 }
3110 GeneratedField::LeftKey => {
3111 if left_key__.is_some() {
3112 return Err(serde::de::Error::duplicate_field("leftKey"));
3113 }
3114 left_key__ =
3115 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3116 .into_iter().map(|x| x.0).collect())
3117 ;
3118 }
3119 GeneratedField::RightKey => {
3120 if right_key__.is_some() {
3121 return Err(serde::de::Error::duplicate_field("rightKey"));
3122 }
3123 right_key__ =
3124 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3125 .into_iter().map(|x| x.0).collect())
3126 ;
3127 }
3128 GeneratedField::Condition => {
3129 if condition__.is_some() {
3130 return Err(serde::de::Error::duplicate_field("condition"));
3131 }
3132 condition__ = map_.next_value()?;
3133 }
3134 GeneratedField::LeftTableId => {
3135 if left_table_id__.is_some() {
3136 return Err(serde::de::Error::duplicate_field("leftTableId"));
3137 }
3138 left_table_id__ =
3139 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3140 ;
3141 }
3142 GeneratedField::RightTableId => {
3143 if right_table_id__.is_some() {
3144 return Err(serde::de::Error::duplicate_field("rightTableId"));
3145 }
3146 right_table_id__ =
3147 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3148 ;
3149 }
3150 GeneratedField::LeftInfo => {
3151 if left_info__.is_some() {
3152 return Err(serde::de::Error::duplicate_field("leftInfo"));
3153 }
3154 left_info__ = map_.next_value()?;
3155 }
3156 GeneratedField::RightInfo => {
3157 if right_info__.is_some() {
3158 return Err(serde::de::Error::duplicate_field("rightInfo"));
3159 }
3160 right_info__ = map_.next_value()?;
3161 }
3162 GeneratedField::OutputIndices => {
3163 if output_indices__.is_some() {
3164 return Err(serde::de::Error::duplicate_field("outputIndices"));
3165 }
3166 output_indices__ =
3167 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3168 .into_iter().map(|x| x.0).collect())
3169 ;
3170 }
3171 }
3172 }
3173 Ok(DeltaIndexJoinNode {
3174 join_type: join_type__.unwrap_or_default(),
3175 left_key: left_key__.unwrap_or_default(),
3176 right_key: right_key__.unwrap_or_default(),
3177 condition: condition__,
3178 left_table_id: left_table_id__.unwrap_or_default(),
3179 right_table_id: right_table_id__.unwrap_or_default(),
3180 left_info: left_info__,
3181 right_info: right_info__,
3182 output_indices: output_indices__.unwrap_or_default(),
3183 })
3184 }
3185 }
3186 deserializer.deserialize_struct("stream_plan.DeltaIndexJoinNode", FIELDS, GeneratedVisitor)
3187 }
3188}
3189impl serde::Serialize for DispatchOutputMapping {
3190 #[allow(deprecated)]
3191 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3192 where
3193 S: serde::Serializer,
3194 {
3195 use serde::ser::SerializeStruct;
3196 let mut len = 0;
3197 if !self.indices.is_empty() {
3198 len += 1;
3199 }
3200 if !self.types.is_empty() {
3201 len += 1;
3202 }
3203 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping", len)?;
3204 if !self.indices.is_empty() {
3205 struct_ser.serialize_field("indices", &self.indices)?;
3206 }
3207 if !self.types.is_empty() {
3208 struct_ser.serialize_field("types", &self.types)?;
3209 }
3210 struct_ser.end()
3211 }
3212}
3213impl<'de> serde::Deserialize<'de> for DispatchOutputMapping {
3214 #[allow(deprecated)]
3215 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3216 where
3217 D: serde::Deserializer<'de>,
3218 {
3219 const FIELDS: &[&str] = &[
3220 "indices",
3221 "types",
3222 ];
3223
3224 #[allow(clippy::enum_variant_names)]
3225 enum GeneratedField {
3226 Indices,
3227 Types,
3228 }
3229 impl<'de> serde::Deserialize<'de> for GeneratedField {
3230 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3231 where
3232 D: serde::Deserializer<'de>,
3233 {
3234 struct GeneratedVisitor;
3235
3236 impl serde::de::Visitor<'_> for GeneratedVisitor {
3237 type Value = GeneratedField;
3238
3239 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3240 write!(formatter, "expected one of: {:?}", &FIELDS)
3241 }
3242
3243 #[allow(unused_variables)]
3244 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3245 where
3246 E: serde::de::Error,
3247 {
3248 match value {
3249 "indices" => Ok(GeneratedField::Indices),
3250 "types" => Ok(GeneratedField::Types),
3251 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3252 }
3253 }
3254 }
3255 deserializer.deserialize_identifier(GeneratedVisitor)
3256 }
3257 }
3258 struct GeneratedVisitor;
3259 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3260 type Value = DispatchOutputMapping;
3261
3262 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3263 formatter.write_str("struct stream_plan.DispatchOutputMapping")
3264 }
3265
3266 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchOutputMapping, V::Error>
3267 where
3268 V: serde::de::MapAccess<'de>,
3269 {
3270 let mut indices__ = None;
3271 let mut types__ = None;
3272 while let Some(k) = map_.next_key()? {
3273 match k {
3274 GeneratedField::Indices => {
3275 if indices__.is_some() {
3276 return Err(serde::de::Error::duplicate_field("indices"));
3277 }
3278 indices__ =
3279 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3280 .into_iter().map(|x| x.0).collect())
3281 ;
3282 }
3283 GeneratedField::Types => {
3284 if types__.is_some() {
3285 return Err(serde::de::Error::duplicate_field("types"));
3286 }
3287 types__ = Some(map_.next_value()?);
3288 }
3289 }
3290 }
3291 Ok(DispatchOutputMapping {
3292 indices: indices__.unwrap_or_default(),
3293 types: types__.unwrap_or_default(),
3294 })
3295 }
3296 }
3297 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping", FIELDS, GeneratedVisitor)
3298 }
3299}
3300impl serde::Serialize for dispatch_output_mapping::TypePair {
3301 #[allow(deprecated)]
3302 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3303 where
3304 S: serde::Serializer,
3305 {
3306 use serde::ser::SerializeStruct;
3307 let mut len = 0;
3308 if self.upstream.is_some() {
3309 len += 1;
3310 }
3311 if self.downstream.is_some() {
3312 len += 1;
3313 }
3314 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping.TypePair", len)?;
3315 if let Some(v) = self.upstream.as_ref() {
3316 struct_ser.serialize_field("upstream", v)?;
3317 }
3318 if let Some(v) = self.downstream.as_ref() {
3319 struct_ser.serialize_field("downstream", v)?;
3320 }
3321 struct_ser.end()
3322 }
3323}
3324impl<'de> serde::Deserialize<'de> for dispatch_output_mapping::TypePair {
3325 #[allow(deprecated)]
3326 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3327 where
3328 D: serde::Deserializer<'de>,
3329 {
3330 const FIELDS: &[&str] = &[
3331 "upstream",
3332 "downstream",
3333 ];
3334
3335 #[allow(clippy::enum_variant_names)]
3336 enum GeneratedField {
3337 Upstream,
3338 Downstream,
3339 }
3340 impl<'de> serde::Deserialize<'de> for GeneratedField {
3341 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3342 where
3343 D: serde::Deserializer<'de>,
3344 {
3345 struct GeneratedVisitor;
3346
3347 impl serde::de::Visitor<'_> for GeneratedVisitor {
3348 type Value = GeneratedField;
3349
3350 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3351 write!(formatter, "expected one of: {:?}", &FIELDS)
3352 }
3353
3354 #[allow(unused_variables)]
3355 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3356 where
3357 E: serde::de::Error,
3358 {
3359 match value {
3360 "upstream" => Ok(GeneratedField::Upstream),
3361 "downstream" => Ok(GeneratedField::Downstream),
3362 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3363 }
3364 }
3365 }
3366 deserializer.deserialize_identifier(GeneratedVisitor)
3367 }
3368 }
3369 struct GeneratedVisitor;
3370 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3371 type Value = dispatch_output_mapping::TypePair;
3372
3373 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3374 formatter.write_str("struct stream_plan.DispatchOutputMapping.TypePair")
3375 }
3376
3377 fn visit_map<V>(self, mut map_: V) -> std::result::Result<dispatch_output_mapping::TypePair, V::Error>
3378 where
3379 V: serde::de::MapAccess<'de>,
3380 {
3381 let mut upstream__ = None;
3382 let mut downstream__ = None;
3383 while let Some(k) = map_.next_key()? {
3384 match k {
3385 GeneratedField::Upstream => {
3386 if upstream__.is_some() {
3387 return Err(serde::de::Error::duplicate_field("upstream"));
3388 }
3389 upstream__ = map_.next_value()?;
3390 }
3391 GeneratedField::Downstream => {
3392 if downstream__.is_some() {
3393 return Err(serde::de::Error::duplicate_field("downstream"));
3394 }
3395 downstream__ = map_.next_value()?;
3396 }
3397 }
3398 }
3399 Ok(dispatch_output_mapping::TypePair {
3400 upstream: upstream__,
3401 downstream: downstream__,
3402 })
3403 }
3404 }
3405 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping.TypePair", FIELDS, GeneratedVisitor)
3406 }
3407}
3408impl serde::Serialize for DispatchStrategy {
3409 #[allow(deprecated)]
3410 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3411 where
3412 S: serde::Serializer,
3413 {
3414 use serde::ser::SerializeStruct;
3415 let mut len = 0;
3416 if self.r#type != 0 {
3417 len += 1;
3418 }
3419 if !self.dist_key_indices.is_empty() {
3420 len += 1;
3421 }
3422 if self.output_mapping.is_some() {
3423 len += 1;
3424 }
3425 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchStrategy", len)?;
3426 if self.r#type != 0 {
3427 let v = DispatcherType::try_from(self.r#type)
3428 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3429 struct_ser.serialize_field("type", &v)?;
3430 }
3431 if !self.dist_key_indices.is_empty() {
3432 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3433 }
3434 if let Some(v) = self.output_mapping.as_ref() {
3435 struct_ser.serialize_field("outputMapping", v)?;
3436 }
3437 struct_ser.end()
3438 }
3439}
3440impl<'de> serde::Deserialize<'de> for DispatchStrategy {
3441 #[allow(deprecated)]
3442 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3443 where
3444 D: serde::Deserializer<'de>,
3445 {
3446 const FIELDS: &[&str] = &[
3447 "type",
3448 "dist_key_indices",
3449 "distKeyIndices",
3450 "output_mapping",
3451 "outputMapping",
3452 ];
3453
3454 #[allow(clippy::enum_variant_names)]
3455 enum GeneratedField {
3456 Type,
3457 DistKeyIndices,
3458 OutputMapping,
3459 }
3460 impl<'de> serde::Deserialize<'de> for GeneratedField {
3461 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3462 where
3463 D: serde::Deserializer<'de>,
3464 {
3465 struct GeneratedVisitor;
3466
3467 impl serde::de::Visitor<'_> for GeneratedVisitor {
3468 type Value = GeneratedField;
3469
3470 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3471 write!(formatter, "expected one of: {:?}", &FIELDS)
3472 }
3473
3474 #[allow(unused_variables)]
3475 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3476 where
3477 E: serde::de::Error,
3478 {
3479 match value {
3480 "type" => Ok(GeneratedField::Type),
3481 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3482 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3483 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3484 }
3485 }
3486 }
3487 deserializer.deserialize_identifier(GeneratedVisitor)
3488 }
3489 }
3490 struct GeneratedVisitor;
3491 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3492 type Value = DispatchStrategy;
3493
3494 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3495 formatter.write_str("struct stream_plan.DispatchStrategy")
3496 }
3497
3498 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchStrategy, V::Error>
3499 where
3500 V: serde::de::MapAccess<'de>,
3501 {
3502 let mut r#type__ = None;
3503 let mut dist_key_indices__ = None;
3504 let mut output_mapping__ = None;
3505 while let Some(k) = map_.next_key()? {
3506 match k {
3507 GeneratedField::Type => {
3508 if r#type__.is_some() {
3509 return Err(serde::de::Error::duplicate_field("type"));
3510 }
3511 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3512 }
3513 GeneratedField::DistKeyIndices => {
3514 if dist_key_indices__.is_some() {
3515 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3516 }
3517 dist_key_indices__ =
3518 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3519 .into_iter().map(|x| x.0).collect())
3520 ;
3521 }
3522 GeneratedField::OutputMapping => {
3523 if output_mapping__.is_some() {
3524 return Err(serde::de::Error::duplicate_field("outputMapping"));
3525 }
3526 output_mapping__ = map_.next_value()?;
3527 }
3528 }
3529 }
3530 Ok(DispatchStrategy {
3531 r#type: r#type__.unwrap_or_default(),
3532 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3533 output_mapping: output_mapping__,
3534 })
3535 }
3536 }
3537 deserializer.deserialize_struct("stream_plan.DispatchStrategy", FIELDS, GeneratedVisitor)
3538 }
3539}
3540impl serde::Serialize for Dispatcher {
3541 #[allow(deprecated)]
3542 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3543 where
3544 S: serde::Serializer,
3545 {
3546 use serde::ser::SerializeStruct;
3547 let mut len = 0;
3548 if self.r#type != 0 {
3549 len += 1;
3550 }
3551 if !self.dist_key_indices.is_empty() {
3552 len += 1;
3553 }
3554 if self.output_mapping.is_some() {
3555 len += 1;
3556 }
3557 if self.hash_mapping.is_some() {
3558 len += 1;
3559 }
3560 if self.dispatcher_id != 0 {
3561 len += 1;
3562 }
3563 if !self.downstream_actor_id.is_empty() {
3564 len += 1;
3565 }
3566 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatcher", len)?;
3567 if self.r#type != 0 {
3568 let v = DispatcherType::try_from(self.r#type)
3569 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3570 struct_ser.serialize_field("type", &v)?;
3571 }
3572 if !self.dist_key_indices.is_empty() {
3573 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3574 }
3575 if let Some(v) = self.output_mapping.as_ref() {
3576 struct_ser.serialize_field("outputMapping", v)?;
3577 }
3578 if let Some(v) = self.hash_mapping.as_ref() {
3579 struct_ser.serialize_field("hashMapping", v)?;
3580 }
3581 if self.dispatcher_id != 0 {
3582 struct_ser.serialize_field("dispatcherId", &self.dispatcher_id)?;
3583 }
3584 if !self.downstream_actor_id.is_empty() {
3585 struct_ser.serialize_field("downstreamActorId", &self.downstream_actor_id)?;
3586 }
3587 struct_ser.end()
3588 }
3589}
3590impl<'de> serde::Deserialize<'de> for Dispatcher {
3591 #[allow(deprecated)]
3592 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3593 where
3594 D: serde::Deserializer<'de>,
3595 {
3596 const FIELDS: &[&str] = &[
3597 "type",
3598 "dist_key_indices",
3599 "distKeyIndices",
3600 "output_mapping",
3601 "outputMapping",
3602 "hash_mapping",
3603 "hashMapping",
3604 "dispatcher_id",
3605 "dispatcherId",
3606 "downstream_actor_id",
3607 "downstreamActorId",
3608 ];
3609
3610 #[allow(clippy::enum_variant_names)]
3611 enum GeneratedField {
3612 Type,
3613 DistKeyIndices,
3614 OutputMapping,
3615 HashMapping,
3616 DispatcherId,
3617 DownstreamActorId,
3618 }
3619 impl<'de> serde::Deserialize<'de> for GeneratedField {
3620 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3621 where
3622 D: serde::Deserializer<'de>,
3623 {
3624 struct GeneratedVisitor;
3625
3626 impl serde::de::Visitor<'_> for GeneratedVisitor {
3627 type Value = GeneratedField;
3628
3629 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3630 write!(formatter, "expected one of: {:?}", &FIELDS)
3631 }
3632
3633 #[allow(unused_variables)]
3634 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3635 where
3636 E: serde::de::Error,
3637 {
3638 match value {
3639 "type" => Ok(GeneratedField::Type),
3640 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3641 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3642 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
3643 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
3644 "downstreamActorId" | "downstream_actor_id" => Ok(GeneratedField::DownstreamActorId),
3645 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3646 }
3647 }
3648 }
3649 deserializer.deserialize_identifier(GeneratedVisitor)
3650 }
3651 }
3652 struct GeneratedVisitor;
3653 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3654 type Value = Dispatcher;
3655
3656 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3657 formatter.write_str("struct stream_plan.Dispatcher")
3658 }
3659
3660 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatcher, V::Error>
3661 where
3662 V: serde::de::MapAccess<'de>,
3663 {
3664 let mut r#type__ = None;
3665 let mut dist_key_indices__ = None;
3666 let mut output_mapping__ = None;
3667 let mut hash_mapping__ = None;
3668 let mut dispatcher_id__ = None;
3669 let mut downstream_actor_id__ = None;
3670 while let Some(k) = map_.next_key()? {
3671 match k {
3672 GeneratedField::Type => {
3673 if r#type__.is_some() {
3674 return Err(serde::de::Error::duplicate_field("type"));
3675 }
3676 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3677 }
3678 GeneratedField::DistKeyIndices => {
3679 if dist_key_indices__.is_some() {
3680 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3681 }
3682 dist_key_indices__ =
3683 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3684 .into_iter().map(|x| x.0).collect())
3685 ;
3686 }
3687 GeneratedField::OutputMapping => {
3688 if output_mapping__.is_some() {
3689 return Err(serde::de::Error::duplicate_field("outputMapping"));
3690 }
3691 output_mapping__ = map_.next_value()?;
3692 }
3693 GeneratedField::HashMapping => {
3694 if hash_mapping__.is_some() {
3695 return Err(serde::de::Error::duplicate_field("hashMapping"));
3696 }
3697 hash_mapping__ = map_.next_value()?;
3698 }
3699 GeneratedField::DispatcherId => {
3700 if dispatcher_id__.is_some() {
3701 return Err(serde::de::Error::duplicate_field("dispatcherId"));
3702 }
3703 dispatcher_id__ =
3704 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3705 ;
3706 }
3707 GeneratedField::DownstreamActorId => {
3708 if downstream_actor_id__.is_some() {
3709 return Err(serde::de::Error::duplicate_field("downstreamActorId"));
3710 }
3711 downstream_actor_id__ =
3712 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3713 .into_iter().map(|x| x.0).collect())
3714 ;
3715 }
3716 }
3717 }
3718 Ok(Dispatcher {
3719 r#type: r#type__.unwrap_or_default(),
3720 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3721 output_mapping: output_mapping__,
3722 hash_mapping: hash_mapping__,
3723 dispatcher_id: dispatcher_id__.unwrap_or_default(),
3724 downstream_actor_id: downstream_actor_id__.unwrap_or_default(),
3725 })
3726 }
3727 }
3728 deserializer.deserialize_struct("stream_plan.Dispatcher", FIELDS, GeneratedVisitor)
3729 }
3730}
3731impl serde::Serialize for DispatcherType {
3732 #[allow(deprecated)]
3733 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3734 where
3735 S: serde::Serializer,
3736 {
3737 let variant = match self {
3738 Self::Unspecified => "DISPATCHER_TYPE_UNSPECIFIED",
3739 Self::Hash => "DISPATCHER_TYPE_HASH",
3740 Self::Broadcast => "DISPATCHER_TYPE_BROADCAST",
3741 Self::Simple => "DISPATCHER_TYPE_SIMPLE",
3742 Self::NoShuffle => "DISPATCHER_TYPE_NO_SHUFFLE",
3743 };
3744 serializer.serialize_str(variant)
3745 }
3746}
3747impl<'de> serde::Deserialize<'de> for DispatcherType {
3748 #[allow(deprecated)]
3749 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3750 where
3751 D: serde::Deserializer<'de>,
3752 {
3753 const FIELDS: &[&str] = &[
3754 "DISPATCHER_TYPE_UNSPECIFIED",
3755 "DISPATCHER_TYPE_HASH",
3756 "DISPATCHER_TYPE_BROADCAST",
3757 "DISPATCHER_TYPE_SIMPLE",
3758 "DISPATCHER_TYPE_NO_SHUFFLE",
3759 ];
3760
3761 struct GeneratedVisitor;
3762
3763 impl serde::de::Visitor<'_> for GeneratedVisitor {
3764 type Value = DispatcherType;
3765
3766 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3767 write!(formatter, "expected one of: {:?}", &FIELDS)
3768 }
3769
3770 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3771 where
3772 E: serde::de::Error,
3773 {
3774 i32::try_from(v)
3775 .ok()
3776 .and_then(|x| x.try_into().ok())
3777 .ok_or_else(|| {
3778 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3779 })
3780 }
3781
3782 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3783 where
3784 E: serde::de::Error,
3785 {
3786 i32::try_from(v)
3787 .ok()
3788 .and_then(|x| x.try_into().ok())
3789 .ok_or_else(|| {
3790 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3791 })
3792 }
3793
3794 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3795 where
3796 E: serde::de::Error,
3797 {
3798 match value {
3799 "DISPATCHER_TYPE_UNSPECIFIED" => Ok(DispatcherType::Unspecified),
3800 "DISPATCHER_TYPE_HASH" => Ok(DispatcherType::Hash),
3801 "DISPATCHER_TYPE_BROADCAST" => Ok(DispatcherType::Broadcast),
3802 "DISPATCHER_TYPE_SIMPLE" => Ok(DispatcherType::Simple),
3803 "DISPATCHER_TYPE_NO_SHUFFLE" => Ok(DispatcherType::NoShuffle),
3804 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3805 }
3806 }
3807 }
3808 deserializer.deserialize_any(GeneratedVisitor)
3809 }
3810}
3811impl serde::Serialize for Dispatchers {
3812 #[allow(deprecated)]
3813 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3814 where
3815 S: serde::Serializer,
3816 {
3817 use serde::ser::SerializeStruct;
3818 let mut len = 0;
3819 if !self.dispatchers.is_empty() {
3820 len += 1;
3821 }
3822 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatchers", len)?;
3823 if !self.dispatchers.is_empty() {
3824 struct_ser.serialize_field("dispatchers", &self.dispatchers)?;
3825 }
3826 struct_ser.end()
3827 }
3828}
3829impl<'de> serde::Deserialize<'de> for Dispatchers {
3830 #[allow(deprecated)]
3831 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3832 where
3833 D: serde::Deserializer<'de>,
3834 {
3835 const FIELDS: &[&str] = &[
3836 "dispatchers",
3837 ];
3838
3839 #[allow(clippy::enum_variant_names)]
3840 enum GeneratedField {
3841 Dispatchers,
3842 }
3843 impl<'de> serde::Deserialize<'de> for GeneratedField {
3844 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3845 where
3846 D: serde::Deserializer<'de>,
3847 {
3848 struct GeneratedVisitor;
3849
3850 impl serde::de::Visitor<'_> for GeneratedVisitor {
3851 type Value = GeneratedField;
3852
3853 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3854 write!(formatter, "expected one of: {:?}", &FIELDS)
3855 }
3856
3857 #[allow(unused_variables)]
3858 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3859 where
3860 E: serde::de::Error,
3861 {
3862 match value {
3863 "dispatchers" => Ok(GeneratedField::Dispatchers),
3864 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3865 }
3866 }
3867 }
3868 deserializer.deserialize_identifier(GeneratedVisitor)
3869 }
3870 }
3871 struct GeneratedVisitor;
3872 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3873 type Value = Dispatchers;
3874
3875 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3876 formatter.write_str("struct stream_plan.Dispatchers")
3877 }
3878
3879 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatchers, V::Error>
3880 where
3881 V: serde::de::MapAccess<'de>,
3882 {
3883 let mut dispatchers__ = None;
3884 while let Some(k) = map_.next_key()? {
3885 match k {
3886 GeneratedField::Dispatchers => {
3887 if dispatchers__.is_some() {
3888 return Err(serde::de::Error::duplicate_field("dispatchers"));
3889 }
3890 dispatchers__ = Some(map_.next_value()?);
3891 }
3892 }
3893 }
3894 Ok(Dispatchers {
3895 dispatchers: dispatchers__.unwrap_or_default(),
3896 })
3897 }
3898 }
3899 deserializer.deserialize_struct("stream_plan.Dispatchers", FIELDS, GeneratedVisitor)
3900 }
3901}
3902impl serde::Serialize for DmlNode {
3903 #[allow(deprecated)]
3904 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3905 where
3906 S: serde::Serializer,
3907 {
3908 use serde::ser::SerializeStruct;
3909 let mut len = 0;
3910 if self.table_id != 0 {
3911 len += 1;
3912 }
3913 if self.table_version_id != 0 {
3914 len += 1;
3915 }
3916 if !self.column_descs.is_empty() {
3917 len += 1;
3918 }
3919 if self.rate_limit.is_some() {
3920 len += 1;
3921 }
3922 let mut struct_ser = serializer.serialize_struct("stream_plan.DmlNode", len)?;
3923 if self.table_id != 0 {
3924 struct_ser.serialize_field("tableId", &self.table_id)?;
3925 }
3926 if self.table_version_id != 0 {
3927 #[allow(clippy::needless_borrow)]
3928 #[allow(clippy::needless_borrows_for_generic_args)]
3929 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
3930 }
3931 if !self.column_descs.is_empty() {
3932 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
3933 }
3934 if let Some(v) = self.rate_limit.as_ref() {
3935 struct_ser.serialize_field("rateLimit", v)?;
3936 }
3937 struct_ser.end()
3938 }
3939}
3940impl<'de> serde::Deserialize<'de> for DmlNode {
3941 #[allow(deprecated)]
3942 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3943 where
3944 D: serde::Deserializer<'de>,
3945 {
3946 const FIELDS: &[&str] = &[
3947 "table_id",
3948 "tableId",
3949 "table_version_id",
3950 "tableVersionId",
3951 "column_descs",
3952 "columnDescs",
3953 "rate_limit",
3954 "rateLimit",
3955 ];
3956
3957 #[allow(clippy::enum_variant_names)]
3958 enum GeneratedField {
3959 TableId,
3960 TableVersionId,
3961 ColumnDescs,
3962 RateLimit,
3963 }
3964 impl<'de> serde::Deserialize<'de> for GeneratedField {
3965 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3966 where
3967 D: serde::Deserializer<'de>,
3968 {
3969 struct GeneratedVisitor;
3970
3971 impl serde::de::Visitor<'_> for GeneratedVisitor {
3972 type Value = GeneratedField;
3973
3974 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3975 write!(formatter, "expected one of: {:?}", &FIELDS)
3976 }
3977
3978 #[allow(unused_variables)]
3979 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3980 where
3981 E: serde::de::Error,
3982 {
3983 match value {
3984 "tableId" | "table_id" => Ok(GeneratedField::TableId),
3985 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
3986 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
3987 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
3988 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3989 }
3990 }
3991 }
3992 deserializer.deserialize_identifier(GeneratedVisitor)
3993 }
3994 }
3995 struct GeneratedVisitor;
3996 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3997 type Value = DmlNode;
3998
3999 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4000 formatter.write_str("struct stream_plan.DmlNode")
4001 }
4002
4003 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DmlNode, V::Error>
4004 where
4005 V: serde::de::MapAccess<'de>,
4006 {
4007 let mut table_id__ = None;
4008 let mut table_version_id__ = None;
4009 let mut column_descs__ = None;
4010 let mut rate_limit__ = None;
4011 while let Some(k) = map_.next_key()? {
4012 match k {
4013 GeneratedField::TableId => {
4014 if table_id__.is_some() {
4015 return Err(serde::de::Error::duplicate_field("tableId"));
4016 }
4017 table_id__ =
4018 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4019 ;
4020 }
4021 GeneratedField::TableVersionId => {
4022 if table_version_id__.is_some() {
4023 return Err(serde::de::Error::duplicate_field("tableVersionId"));
4024 }
4025 table_version_id__ =
4026 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4027 ;
4028 }
4029 GeneratedField::ColumnDescs => {
4030 if column_descs__.is_some() {
4031 return Err(serde::de::Error::duplicate_field("columnDescs"));
4032 }
4033 column_descs__ = Some(map_.next_value()?);
4034 }
4035 GeneratedField::RateLimit => {
4036 if rate_limit__.is_some() {
4037 return Err(serde::de::Error::duplicate_field("rateLimit"));
4038 }
4039 rate_limit__ =
4040 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4041 ;
4042 }
4043 }
4044 }
4045 Ok(DmlNode {
4046 table_id: table_id__.unwrap_or_default(),
4047 table_version_id: table_version_id__.unwrap_or_default(),
4048 column_descs: column_descs__.unwrap_or_default(),
4049 rate_limit: rate_limit__,
4050 })
4051 }
4052 }
4053 deserializer.deserialize_struct("stream_plan.DmlNode", FIELDS, GeneratedVisitor)
4054 }
4055}
4056impl serde::Serialize for DropSubscriptionsMutation {
4057 #[allow(deprecated)]
4058 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4059 where
4060 S: serde::Serializer,
4061 {
4062 use serde::ser::SerializeStruct;
4063 let mut len = 0;
4064 if !self.info.is_empty() {
4065 len += 1;
4066 }
4067 let mut struct_ser = serializer.serialize_struct("stream_plan.DropSubscriptionsMutation", len)?;
4068 if !self.info.is_empty() {
4069 struct_ser.serialize_field("info", &self.info)?;
4070 }
4071 struct_ser.end()
4072 }
4073}
4074impl<'de> serde::Deserialize<'de> for DropSubscriptionsMutation {
4075 #[allow(deprecated)]
4076 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4077 where
4078 D: serde::Deserializer<'de>,
4079 {
4080 const FIELDS: &[&str] = &[
4081 "info",
4082 ];
4083
4084 #[allow(clippy::enum_variant_names)]
4085 enum GeneratedField {
4086 Info,
4087 }
4088 impl<'de> serde::Deserialize<'de> for GeneratedField {
4089 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4090 where
4091 D: serde::Deserializer<'de>,
4092 {
4093 struct GeneratedVisitor;
4094
4095 impl serde::de::Visitor<'_> for GeneratedVisitor {
4096 type Value = GeneratedField;
4097
4098 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4099 write!(formatter, "expected one of: {:?}", &FIELDS)
4100 }
4101
4102 #[allow(unused_variables)]
4103 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4104 where
4105 E: serde::de::Error,
4106 {
4107 match value {
4108 "info" => Ok(GeneratedField::Info),
4109 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4110 }
4111 }
4112 }
4113 deserializer.deserialize_identifier(GeneratedVisitor)
4114 }
4115 }
4116 struct GeneratedVisitor;
4117 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4118 type Value = DropSubscriptionsMutation;
4119
4120 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4121 formatter.write_str("struct stream_plan.DropSubscriptionsMutation")
4122 }
4123
4124 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionsMutation, V::Error>
4125 where
4126 V: serde::de::MapAccess<'de>,
4127 {
4128 let mut info__ = None;
4129 while let Some(k) = map_.next_key()? {
4130 match k {
4131 GeneratedField::Info => {
4132 if info__.is_some() {
4133 return Err(serde::de::Error::duplicate_field("info"));
4134 }
4135 info__ = Some(map_.next_value()?);
4136 }
4137 }
4138 }
4139 Ok(DropSubscriptionsMutation {
4140 info: info__.unwrap_or_default(),
4141 })
4142 }
4143 }
4144 deserializer.deserialize_struct("stream_plan.DropSubscriptionsMutation", FIELDS, GeneratedVisitor)
4145 }
4146}
4147impl serde::Serialize for DynamicFilterNode {
4148 #[allow(deprecated)]
4149 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4150 where
4151 S: serde::Serializer,
4152 {
4153 use serde::ser::SerializeStruct;
4154 let mut len = 0;
4155 if self.left_key != 0 {
4156 len += 1;
4157 }
4158 if self.condition.is_some() {
4159 len += 1;
4160 }
4161 if self.left_table.is_some() {
4162 len += 1;
4163 }
4164 if self.right_table.is_some() {
4165 len += 1;
4166 }
4167 if self.condition_always_relax {
4168 len += 1;
4169 }
4170 if self.cleaned_by_watermark {
4171 len += 1;
4172 }
4173 let mut struct_ser = serializer.serialize_struct("stream_plan.DynamicFilterNode", len)?;
4174 if self.left_key != 0 {
4175 struct_ser.serialize_field("leftKey", &self.left_key)?;
4176 }
4177 if let Some(v) = self.condition.as_ref() {
4178 struct_ser.serialize_field("condition", v)?;
4179 }
4180 if let Some(v) = self.left_table.as_ref() {
4181 struct_ser.serialize_field("leftTable", v)?;
4182 }
4183 if let Some(v) = self.right_table.as_ref() {
4184 struct_ser.serialize_field("rightTable", v)?;
4185 }
4186 if self.condition_always_relax {
4187 struct_ser.serialize_field("conditionAlwaysRelax", &self.condition_always_relax)?;
4188 }
4189 if self.cleaned_by_watermark {
4190 struct_ser.serialize_field("cleanedByWatermark", &self.cleaned_by_watermark)?;
4191 }
4192 struct_ser.end()
4193 }
4194}
4195impl<'de> serde::Deserialize<'de> for DynamicFilterNode {
4196 #[allow(deprecated)]
4197 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4198 where
4199 D: serde::Deserializer<'de>,
4200 {
4201 const FIELDS: &[&str] = &[
4202 "left_key",
4203 "leftKey",
4204 "condition",
4205 "left_table",
4206 "leftTable",
4207 "right_table",
4208 "rightTable",
4209 "condition_always_relax",
4210 "conditionAlwaysRelax",
4211 "cleaned_by_watermark",
4212 "cleanedByWatermark",
4213 ];
4214
4215 #[allow(clippy::enum_variant_names)]
4216 enum GeneratedField {
4217 LeftKey,
4218 Condition,
4219 LeftTable,
4220 RightTable,
4221 ConditionAlwaysRelax,
4222 CleanedByWatermark,
4223 }
4224 impl<'de> serde::Deserialize<'de> for GeneratedField {
4225 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4226 where
4227 D: serde::Deserializer<'de>,
4228 {
4229 struct GeneratedVisitor;
4230
4231 impl serde::de::Visitor<'_> for GeneratedVisitor {
4232 type Value = GeneratedField;
4233
4234 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4235 write!(formatter, "expected one of: {:?}", &FIELDS)
4236 }
4237
4238 #[allow(unused_variables)]
4239 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4240 where
4241 E: serde::de::Error,
4242 {
4243 match value {
4244 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
4245 "condition" => Ok(GeneratedField::Condition),
4246 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
4247 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
4248 "conditionAlwaysRelax" | "condition_always_relax" => Ok(GeneratedField::ConditionAlwaysRelax),
4249 "cleanedByWatermark" | "cleaned_by_watermark" => Ok(GeneratedField::CleanedByWatermark),
4250 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4251 }
4252 }
4253 }
4254 deserializer.deserialize_identifier(GeneratedVisitor)
4255 }
4256 }
4257 struct GeneratedVisitor;
4258 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4259 type Value = DynamicFilterNode;
4260
4261 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4262 formatter.write_str("struct stream_plan.DynamicFilterNode")
4263 }
4264
4265 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DynamicFilterNode, V::Error>
4266 where
4267 V: serde::de::MapAccess<'de>,
4268 {
4269 let mut left_key__ = None;
4270 let mut condition__ = None;
4271 let mut left_table__ = None;
4272 let mut right_table__ = None;
4273 let mut condition_always_relax__ = None;
4274 let mut cleaned_by_watermark__ = None;
4275 while let Some(k) = map_.next_key()? {
4276 match k {
4277 GeneratedField::LeftKey => {
4278 if left_key__.is_some() {
4279 return Err(serde::de::Error::duplicate_field("leftKey"));
4280 }
4281 left_key__ =
4282 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4283 ;
4284 }
4285 GeneratedField::Condition => {
4286 if condition__.is_some() {
4287 return Err(serde::de::Error::duplicate_field("condition"));
4288 }
4289 condition__ = map_.next_value()?;
4290 }
4291 GeneratedField::LeftTable => {
4292 if left_table__.is_some() {
4293 return Err(serde::de::Error::duplicate_field("leftTable"));
4294 }
4295 left_table__ = map_.next_value()?;
4296 }
4297 GeneratedField::RightTable => {
4298 if right_table__.is_some() {
4299 return Err(serde::de::Error::duplicate_field("rightTable"));
4300 }
4301 right_table__ = map_.next_value()?;
4302 }
4303 GeneratedField::ConditionAlwaysRelax => {
4304 if condition_always_relax__.is_some() {
4305 return Err(serde::de::Error::duplicate_field("conditionAlwaysRelax"));
4306 }
4307 condition_always_relax__ = Some(map_.next_value()?);
4308 }
4309 GeneratedField::CleanedByWatermark => {
4310 if cleaned_by_watermark__.is_some() {
4311 return Err(serde::de::Error::duplicate_field("cleanedByWatermark"));
4312 }
4313 cleaned_by_watermark__ = Some(map_.next_value()?);
4314 }
4315 }
4316 }
4317 Ok(DynamicFilterNode {
4318 left_key: left_key__.unwrap_or_default(),
4319 condition: condition__,
4320 left_table: left_table__,
4321 right_table: right_table__,
4322 condition_always_relax: condition_always_relax__.unwrap_or_default(),
4323 cleaned_by_watermark: cleaned_by_watermark__.unwrap_or_default(),
4324 })
4325 }
4326 }
4327 deserializer.deserialize_struct("stream_plan.DynamicFilterNode", FIELDS, GeneratedVisitor)
4328 }
4329}
4330impl serde::Serialize for EowcGapFillNode {
4331 #[allow(deprecated)]
4332 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4333 where
4334 S: serde::Serializer,
4335 {
4336 use serde::ser::SerializeStruct;
4337 let mut len = 0;
4338 if self.time_column_index != 0 {
4339 len += 1;
4340 }
4341 if self.interval.is_some() {
4342 len += 1;
4343 }
4344 if !self.fill_columns.is_empty() {
4345 len += 1;
4346 }
4347 if !self.fill_strategies.is_empty() {
4348 len += 1;
4349 }
4350 if self.buffer_table.is_some() {
4351 len += 1;
4352 }
4353 if self.prev_row_table.is_some() {
4354 len += 1;
4355 }
4356 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcGapFillNode", len)?;
4357 if self.time_column_index != 0 {
4358 struct_ser.serialize_field("timeColumnIndex", &self.time_column_index)?;
4359 }
4360 if let Some(v) = self.interval.as_ref() {
4361 struct_ser.serialize_field("interval", v)?;
4362 }
4363 if !self.fill_columns.is_empty() {
4364 struct_ser.serialize_field("fillColumns", &self.fill_columns)?;
4365 }
4366 if !self.fill_strategies.is_empty() {
4367 struct_ser.serialize_field("fillStrategies", &self.fill_strategies)?;
4368 }
4369 if let Some(v) = self.buffer_table.as_ref() {
4370 struct_ser.serialize_field("bufferTable", v)?;
4371 }
4372 if let Some(v) = self.prev_row_table.as_ref() {
4373 struct_ser.serialize_field("prevRowTable", v)?;
4374 }
4375 struct_ser.end()
4376 }
4377}
4378impl<'de> serde::Deserialize<'de> for EowcGapFillNode {
4379 #[allow(deprecated)]
4380 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4381 where
4382 D: serde::Deserializer<'de>,
4383 {
4384 const FIELDS: &[&str] = &[
4385 "time_column_index",
4386 "timeColumnIndex",
4387 "interval",
4388 "fill_columns",
4389 "fillColumns",
4390 "fill_strategies",
4391 "fillStrategies",
4392 "buffer_table",
4393 "bufferTable",
4394 "prev_row_table",
4395 "prevRowTable",
4396 ];
4397
4398 #[allow(clippy::enum_variant_names)]
4399 enum GeneratedField {
4400 TimeColumnIndex,
4401 Interval,
4402 FillColumns,
4403 FillStrategies,
4404 BufferTable,
4405 PrevRowTable,
4406 }
4407 impl<'de> serde::Deserialize<'de> for GeneratedField {
4408 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4409 where
4410 D: serde::Deserializer<'de>,
4411 {
4412 struct GeneratedVisitor;
4413
4414 impl serde::de::Visitor<'_> for GeneratedVisitor {
4415 type Value = GeneratedField;
4416
4417 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4418 write!(formatter, "expected one of: {:?}", &FIELDS)
4419 }
4420
4421 #[allow(unused_variables)]
4422 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4423 where
4424 E: serde::de::Error,
4425 {
4426 match value {
4427 "timeColumnIndex" | "time_column_index" => Ok(GeneratedField::TimeColumnIndex),
4428 "interval" => Ok(GeneratedField::Interval),
4429 "fillColumns" | "fill_columns" => Ok(GeneratedField::FillColumns),
4430 "fillStrategies" | "fill_strategies" => Ok(GeneratedField::FillStrategies),
4431 "bufferTable" | "buffer_table" => Ok(GeneratedField::BufferTable),
4432 "prevRowTable" | "prev_row_table" => Ok(GeneratedField::PrevRowTable),
4433 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4434 }
4435 }
4436 }
4437 deserializer.deserialize_identifier(GeneratedVisitor)
4438 }
4439 }
4440 struct GeneratedVisitor;
4441 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4442 type Value = EowcGapFillNode;
4443
4444 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4445 formatter.write_str("struct stream_plan.EowcGapFillNode")
4446 }
4447
4448 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcGapFillNode, V::Error>
4449 where
4450 V: serde::de::MapAccess<'de>,
4451 {
4452 let mut time_column_index__ = None;
4453 let mut interval__ = None;
4454 let mut fill_columns__ = None;
4455 let mut fill_strategies__ = None;
4456 let mut buffer_table__ = None;
4457 let mut prev_row_table__ = None;
4458 while let Some(k) = map_.next_key()? {
4459 match k {
4460 GeneratedField::TimeColumnIndex => {
4461 if time_column_index__.is_some() {
4462 return Err(serde::de::Error::duplicate_field("timeColumnIndex"));
4463 }
4464 time_column_index__ =
4465 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4466 ;
4467 }
4468 GeneratedField::Interval => {
4469 if interval__.is_some() {
4470 return Err(serde::de::Error::duplicate_field("interval"));
4471 }
4472 interval__ = map_.next_value()?;
4473 }
4474 GeneratedField::FillColumns => {
4475 if fill_columns__.is_some() {
4476 return Err(serde::de::Error::duplicate_field("fillColumns"));
4477 }
4478 fill_columns__ =
4479 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4480 .into_iter().map(|x| x.0).collect())
4481 ;
4482 }
4483 GeneratedField::FillStrategies => {
4484 if fill_strategies__.is_some() {
4485 return Err(serde::de::Error::duplicate_field("fillStrategies"));
4486 }
4487 fill_strategies__ = Some(map_.next_value()?);
4488 }
4489 GeneratedField::BufferTable => {
4490 if buffer_table__.is_some() {
4491 return Err(serde::de::Error::duplicate_field("bufferTable"));
4492 }
4493 buffer_table__ = map_.next_value()?;
4494 }
4495 GeneratedField::PrevRowTable => {
4496 if prev_row_table__.is_some() {
4497 return Err(serde::de::Error::duplicate_field("prevRowTable"));
4498 }
4499 prev_row_table__ = map_.next_value()?;
4500 }
4501 }
4502 }
4503 Ok(EowcGapFillNode {
4504 time_column_index: time_column_index__.unwrap_or_default(),
4505 interval: interval__,
4506 fill_columns: fill_columns__.unwrap_or_default(),
4507 fill_strategies: fill_strategies__.unwrap_or_default(),
4508 buffer_table: buffer_table__,
4509 prev_row_table: prev_row_table__,
4510 })
4511 }
4512 }
4513 deserializer.deserialize_struct("stream_plan.EowcGapFillNode", FIELDS, GeneratedVisitor)
4514 }
4515}
4516impl serde::Serialize for EowcOverWindowNode {
4517 #[allow(deprecated)]
4518 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4519 where
4520 S: serde::Serializer,
4521 {
4522 use serde::ser::SerializeStruct;
4523 let mut len = 0;
4524 if !self.calls.is_empty() {
4525 len += 1;
4526 }
4527 if !self.partition_by.is_empty() {
4528 len += 1;
4529 }
4530 if !self.order_by.is_empty() {
4531 len += 1;
4532 }
4533 if self.state_table.is_some() {
4534 len += 1;
4535 }
4536 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcOverWindowNode", len)?;
4537 if !self.calls.is_empty() {
4538 struct_ser.serialize_field("calls", &self.calls)?;
4539 }
4540 if !self.partition_by.is_empty() {
4541 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
4542 }
4543 if !self.order_by.is_empty() {
4544 struct_ser.serialize_field("orderBy", &self.order_by)?;
4545 }
4546 if let Some(v) = self.state_table.as_ref() {
4547 struct_ser.serialize_field("stateTable", v)?;
4548 }
4549 struct_ser.end()
4550 }
4551}
4552impl<'de> serde::Deserialize<'de> for EowcOverWindowNode {
4553 #[allow(deprecated)]
4554 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4555 where
4556 D: serde::Deserializer<'de>,
4557 {
4558 const FIELDS: &[&str] = &[
4559 "calls",
4560 "partition_by",
4561 "partitionBy",
4562 "order_by",
4563 "orderBy",
4564 "state_table",
4565 "stateTable",
4566 ];
4567
4568 #[allow(clippy::enum_variant_names)]
4569 enum GeneratedField {
4570 Calls,
4571 PartitionBy,
4572 OrderBy,
4573 StateTable,
4574 }
4575 impl<'de> serde::Deserialize<'de> for GeneratedField {
4576 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4577 where
4578 D: serde::Deserializer<'de>,
4579 {
4580 struct GeneratedVisitor;
4581
4582 impl serde::de::Visitor<'_> for GeneratedVisitor {
4583 type Value = GeneratedField;
4584
4585 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4586 write!(formatter, "expected one of: {:?}", &FIELDS)
4587 }
4588
4589 #[allow(unused_variables)]
4590 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4591 where
4592 E: serde::de::Error,
4593 {
4594 match value {
4595 "calls" => Ok(GeneratedField::Calls),
4596 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
4597 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
4598 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
4599 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4600 }
4601 }
4602 }
4603 deserializer.deserialize_identifier(GeneratedVisitor)
4604 }
4605 }
4606 struct GeneratedVisitor;
4607 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4608 type Value = EowcOverWindowNode;
4609
4610 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4611 formatter.write_str("struct stream_plan.EowcOverWindowNode")
4612 }
4613
4614 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcOverWindowNode, V::Error>
4615 where
4616 V: serde::de::MapAccess<'de>,
4617 {
4618 let mut calls__ = None;
4619 let mut partition_by__ = None;
4620 let mut order_by__ = None;
4621 let mut state_table__ = None;
4622 while let Some(k) = map_.next_key()? {
4623 match k {
4624 GeneratedField::Calls => {
4625 if calls__.is_some() {
4626 return Err(serde::de::Error::duplicate_field("calls"));
4627 }
4628 calls__ = Some(map_.next_value()?);
4629 }
4630 GeneratedField::PartitionBy => {
4631 if partition_by__.is_some() {
4632 return Err(serde::de::Error::duplicate_field("partitionBy"));
4633 }
4634 partition_by__ =
4635 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4636 .into_iter().map(|x| x.0).collect())
4637 ;
4638 }
4639 GeneratedField::OrderBy => {
4640 if order_by__.is_some() {
4641 return Err(serde::de::Error::duplicate_field("orderBy"));
4642 }
4643 order_by__ = Some(map_.next_value()?);
4644 }
4645 GeneratedField::StateTable => {
4646 if state_table__.is_some() {
4647 return Err(serde::de::Error::duplicate_field("stateTable"));
4648 }
4649 state_table__ = map_.next_value()?;
4650 }
4651 }
4652 }
4653 Ok(EowcOverWindowNode {
4654 calls: calls__.unwrap_or_default(),
4655 partition_by: partition_by__.unwrap_or_default(),
4656 order_by: order_by__.unwrap_or_default(),
4657 state_table: state_table__,
4658 })
4659 }
4660 }
4661 deserializer.deserialize_struct("stream_plan.EowcOverWindowNode", FIELDS, GeneratedVisitor)
4662 }
4663}
4664impl serde::Serialize for ExchangeNode {
4665 #[allow(deprecated)]
4666 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4667 where
4668 S: serde::Serializer,
4669 {
4670 use serde::ser::SerializeStruct;
4671 let mut len = 0;
4672 if self.strategy.is_some() {
4673 len += 1;
4674 }
4675 let mut struct_ser = serializer.serialize_struct("stream_plan.ExchangeNode", len)?;
4676 if let Some(v) = self.strategy.as_ref() {
4677 struct_ser.serialize_field("strategy", v)?;
4678 }
4679 struct_ser.end()
4680 }
4681}
4682impl<'de> serde::Deserialize<'de> for ExchangeNode {
4683 #[allow(deprecated)]
4684 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4685 where
4686 D: serde::Deserializer<'de>,
4687 {
4688 const FIELDS: &[&str] = &[
4689 "strategy",
4690 ];
4691
4692 #[allow(clippy::enum_variant_names)]
4693 enum GeneratedField {
4694 Strategy,
4695 }
4696 impl<'de> serde::Deserialize<'de> for GeneratedField {
4697 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4698 where
4699 D: serde::Deserializer<'de>,
4700 {
4701 struct GeneratedVisitor;
4702
4703 impl serde::de::Visitor<'_> for GeneratedVisitor {
4704 type Value = GeneratedField;
4705
4706 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4707 write!(formatter, "expected one of: {:?}", &FIELDS)
4708 }
4709
4710 #[allow(unused_variables)]
4711 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4712 where
4713 E: serde::de::Error,
4714 {
4715 match value {
4716 "strategy" => Ok(GeneratedField::Strategy),
4717 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4718 }
4719 }
4720 }
4721 deserializer.deserialize_identifier(GeneratedVisitor)
4722 }
4723 }
4724 struct GeneratedVisitor;
4725 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4726 type Value = ExchangeNode;
4727
4728 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4729 formatter.write_str("struct stream_plan.ExchangeNode")
4730 }
4731
4732 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExchangeNode, V::Error>
4733 where
4734 V: serde::de::MapAccess<'de>,
4735 {
4736 let mut strategy__ = None;
4737 while let Some(k) = map_.next_key()? {
4738 match k {
4739 GeneratedField::Strategy => {
4740 if strategy__.is_some() {
4741 return Err(serde::de::Error::duplicate_field("strategy"));
4742 }
4743 strategy__ = map_.next_value()?;
4744 }
4745 }
4746 }
4747 Ok(ExchangeNode {
4748 strategy: strategy__,
4749 })
4750 }
4751 }
4752 deserializer.deserialize_struct("stream_plan.ExchangeNode", FIELDS, GeneratedVisitor)
4753 }
4754}
4755impl serde::Serialize for ExpandNode {
4756 #[allow(deprecated)]
4757 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4758 where
4759 S: serde::Serializer,
4760 {
4761 use serde::ser::SerializeStruct;
4762 let mut len = 0;
4763 if !self.column_subsets.is_empty() {
4764 len += 1;
4765 }
4766 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode", len)?;
4767 if !self.column_subsets.is_empty() {
4768 struct_ser.serialize_field("columnSubsets", &self.column_subsets)?;
4769 }
4770 struct_ser.end()
4771 }
4772}
4773impl<'de> serde::Deserialize<'de> for ExpandNode {
4774 #[allow(deprecated)]
4775 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4776 where
4777 D: serde::Deserializer<'de>,
4778 {
4779 const FIELDS: &[&str] = &[
4780 "column_subsets",
4781 "columnSubsets",
4782 ];
4783
4784 #[allow(clippy::enum_variant_names)]
4785 enum GeneratedField {
4786 ColumnSubsets,
4787 }
4788 impl<'de> serde::Deserialize<'de> for GeneratedField {
4789 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4790 where
4791 D: serde::Deserializer<'de>,
4792 {
4793 struct GeneratedVisitor;
4794
4795 impl serde::de::Visitor<'_> for GeneratedVisitor {
4796 type Value = GeneratedField;
4797
4798 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4799 write!(formatter, "expected one of: {:?}", &FIELDS)
4800 }
4801
4802 #[allow(unused_variables)]
4803 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4804 where
4805 E: serde::de::Error,
4806 {
4807 match value {
4808 "columnSubsets" | "column_subsets" => Ok(GeneratedField::ColumnSubsets),
4809 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4810 }
4811 }
4812 }
4813 deserializer.deserialize_identifier(GeneratedVisitor)
4814 }
4815 }
4816 struct GeneratedVisitor;
4817 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4818 type Value = ExpandNode;
4819
4820 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4821 formatter.write_str("struct stream_plan.ExpandNode")
4822 }
4823
4824 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpandNode, V::Error>
4825 where
4826 V: serde::de::MapAccess<'de>,
4827 {
4828 let mut column_subsets__ = None;
4829 while let Some(k) = map_.next_key()? {
4830 match k {
4831 GeneratedField::ColumnSubsets => {
4832 if column_subsets__.is_some() {
4833 return Err(serde::de::Error::duplicate_field("columnSubsets"));
4834 }
4835 column_subsets__ = Some(map_.next_value()?);
4836 }
4837 }
4838 }
4839 Ok(ExpandNode {
4840 column_subsets: column_subsets__.unwrap_or_default(),
4841 })
4842 }
4843 }
4844 deserializer.deserialize_struct("stream_plan.ExpandNode", FIELDS, GeneratedVisitor)
4845 }
4846}
4847impl serde::Serialize for expand_node::Subset {
4848 #[allow(deprecated)]
4849 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4850 where
4851 S: serde::Serializer,
4852 {
4853 use serde::ser::SerializeStruct;
4854 let mut len = 0;
4855 if !self.column_indices.is_empty() {
4856 len += 1;
4857 }
4858 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode.Subset", len)?;
4859 if !self.column_indices.is_empty() {
4860 struct_ser.serialize_field("columnIndices", &self.column_indices)?;
4861 }
4862 struct_ser.end()
4863 }
4864}
4865impl<'de> serde::Deserialize<'de> for expand_node::Subset {
4866 #[allow(deprecated)]
4867 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4868 where
4869 D: serde::Deserializer<'de>,
4870 {
4871 const FIELDS: &[&str] = &[
4872 "column_indices",
4873 "columnIndices",
4874 ];
4875
4876 #[allow(clippy::enum_variant_names)]
4877 enum GeneratedField {
4878 ColumnIndices,
4879 }
4880 impl<'de> serde::Deserialize<'de> for GeneratedField {
4881 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4882 where
4883 D: serde::Deserializer<'de>,
4884 {
4885 struct GeneratedVisitor;
4886
4887 impl serde::de::Visitor<'_> for GeneratedVisitor {
4888 type Value = GeneratedField;
4889
4890 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4891 write!(formatter, "expected one of: {:?}", &FIELDS)
4892 }
4893
4894 #[allow(unused_variables)]
4895 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4896 where
4897 E: serde::de::Error,
4898 {
4899 match value {
4900 "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
4901 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4902 }
4903 }
4904 }
4905 deserializer.deserialize_identifier(GeneratedVisitor)
4906 }
4907 }
4908 struct GeneratedVisitor;
4909 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4910 type Value = expand_node::Subset;
4911
4912 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4913 formatter.write_str("struct stream_plan.ExpandNode.Subset")
4914 }
4915
4916 fn visit_map<V>(self, mut map_: V) -> std::result::Result<expand_node::Subset, V::Error>
4917 where
4918 V: serde::de::MapAccess<'de>,
4919 {
4920 let mut column_indices__ = None;
4921 while let Some(k) = map_.next_key()? {
4922 match k {
4923 GeneratedField::ColumnIndices => {
4924 if column_indices__.is_some() {
4925 return Err(serde::de::Error::duplicate_field("columnIndices"));
4926 }
4927 column_indices__ =
4928 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4929 .into_iter().map(|x| x.0).collect())
4930 ;
4931 }
4932 }
4933 }
4934 Ok(expand_node::Subset {
4935 column_indices: column_indices__.unwrap_or_default(),
4936 })
4937 }
4938 }
4939 deserializer.deserialize_struct("stream_plan.ExpandNode.Subset", FIELDS, GeneratedVisitor)
4940 }
4941}
4942impl serde::Serialize for FilterNode {
4943 #[allow(deprecated)]
4944 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4945 where
4946 S: serde::Serializer,
4947 {
4948 use serde::ser::SerializeStruct;
4949 let mut len = 0;
4950 if self.search_condition.is_some() {
4951 len += 1;
4952 }
4953 let mut struct_ser = serializer.serialize_struct("stream_plan.FilterNode", len)?;
4954 if let Some(v) = self.search_condition.as_ref() {
4955 struct_ser.serialize_field("searchCondition", v)?;
4956 }
4957 struct_ser.end()
4958 }
4959}
4960impl<'de> serde::Deserialize<'de> for FilterNode {
4961 #[allow(deprecated)]
4962 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4963 where
4964 D: serde::Deserializer<'de>,
4965 {
4966 const FIELDS: &[&str] = &[
4967 "search_condition",
4968 "searchCondition",
4969 ];
4970
4971 #[allow(clippy::enum_variant_names)]
4972 enum GeneratedField {
4973 SearchCondition,
4974 }
4975 impl<'de> serde::Deserialize<'de> for GeneratedField {
4976 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4977 where
4978 D: serde::Deserializer<'de>,
4979 {
4980 struct GeneratedVisitor;
4981
4982 impl serde::de::Visitor<'_> for GeneratedVisitor {
4983 type Value = GeneratedField;
4984
4985 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4986 write!(formatter, "expected one of: {:?}", &FIELDS)
4987 }
4988
4989 #[allow(unused_variables)]
4990 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4991 where
4992 E: serde::de::Error,
4993 {
4994 match value {
4995 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
4996 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4997 }
4998 }
4999 }
5000 deserializer.deserialize_identifier(GeneratedVisitor)
5001 }
5002 }
5003 struct GeneratedVisitor;
5004 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5005 type Value = FilterNode;
5006
5007 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5008 formatter.write_str("struct stream_plan.FilterNode")
5009 }
5010
5011 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FilterNode, V::Error>
5012 where
5013 V: serde::de::MapAccess<'de>,
5014 {
5015 let mut search_condition__ = None;
5016 while let Some(k) = map_.next_key()? {
5017 match k {
5018 GeneratedField::SearchCondition => {
5019 if search_condition__.is_some() {
5020 return Err(serde::de::Error::duplicate_field("searchCondition"));
5021 }
5022 search_condition__ = map_.next_value()?;
5023 }
5024 }
5025 }
5026 Ok(FilterNode {
5027 search_condition: search_condition__,
5028 })
5029 }
5030 }
5031 deserializer.deserialize_struct("stream_plan.FilterNode", FIELDS, GeneratedVisitor)
5032 }
5033}
5034impl serde::Serialize for GapFillNode {
5035 #[allow(deprecated)]
5036 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5037 where
5038 S: serde::Serializer,
5039 {
5040 use serde::ser::SerializeStruct;
5041 let mut len = 0;
5042 if self.time_column_index != 0 {
5043 len += 1;
5044 }
5045 if self.interval.is_some() {
5046 len += 1;
5047 }
5048 if !self.fill_columns.is_empty() {
5049 len += 1;
5050 }
5051 if !self.fill_strategies.is_empty() {
5052 len += 1;
5053 }
5054 if self.state_table.is_some() {
5055 len += 1;
5056 }
5057 let mut struct_ser = serializer.serialize_struct("stream_plan.GapFillNode", len)?;
5058 if self.time_column_index != 0 {
5059 struct_ser.serialize_field("timeColumnIndex", &self.time_column_index)?;
5060 }
5061 if let Some(v) = self.interval.as_ref() {
5062 struct_ser.serialize_field("interval", v)?;
5063 }
5064 if !self.fill_columns.is_empty() {
5065 struct_ser.serialize_field("fillColumns", &self.fill_columns)?;
5066 }
5067 if !self.fill_strategies.is_empty() {
5068 struct_ser.serialize_field("fillStrategies", &self.fill_strategies)?;
5069 }
5070 if let Some(v) = self.state_table.as_ref() {
5071 struct_ser.serialize_field("stateTable", v)?;
5072 }
5073 struct_ser.end()
5074 }
5075}
5076impl<'de> serde::Deserialize<'de> for GapFillNode {
5077 #[allow(deprecated)]
5078 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5079 where
5080 D: serde::Deserializer<'de>,
5081 {
5082 const FIELDS: &[&str] = &[
5083 "time_column_index",
5084 "timeColumnIndex",
5085 "interval",
5086 "fill_columns",
5087 "fillColumns",
5088 "fill_strategies",
5089 "fillStrategies",
5090 "state_table",
5091 "stateTable",
5092 ];
5093
5094 #[allow(clippy::enum_variant_names)]
5095 enum GeneratedField {
5096 TimeColumnIndex,
5097 Interval,
5098 FillColumns,
5099 FillStrategies,
5100 StateTable,
5101 }
5102 impl<'de> serde::Deserialize<'de> for GeneratedField {
5103 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5104 where
5105 D: serde::Deserializer<'de>,
5106 {
5107 struct GeneratedVisitor;
5108
5109 impl serde::de::Visitor<'_> for GeneratedVisitor {
5110 type Value = GeneratedField;
5111
5112 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5113 write!(formatter, "expected one of: {:?}", &FIELDS)
5114 }
5115
5116 #[allow(unused_variables)]
5117 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5118 where
5119 E: serde::de::Error,
5120 {
5121 match value {
5122 "timeColumnIndex" | "time_column_index" => Ok(GeneratedField::TimeColumnIndex),
5123 "interval" => Ok(GeneratedField::Interval),
5124 "fillColumns" | "fill_columns" => Ok(GeneratedField::FillColumns),
5125 "fillStrategies" | "fill_strategies" => Ok(GeneratedField::FillStrategies),
5126 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
5127 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5128 }
5129 }
5130 }
5131 deserializer.deserialize_identifier(GeneratedVisitor)
5132 }
5133 }
5134 struct GeneratedVisitor;
5135 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5136 type Value = GapFillNode;
5137
5138 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5139 formatter.write_str("struct stream_plan.GapFillNode")
5140 }
5141
5142 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GapFillNode, V::Error>
5143 where
5144 V: serde::de::MapAccess<'de>,
5145 {
5146 let mut time_column_index__ = None;
5147 let mut interval__ = None;
5148 let mut fill_columns__ = None;
5149 let mut fill_strategies__ = None;
5150 let mut state_table__ = None;
5151 while let Some(k) = map_.next_key()? {
5152 match k {
5153 GeneratedField::TimeColumnIndex => {
5154 if time_column_index__.is_some() {
5155 return Err(serde::de::Error::duplicate_field("timeColumnIndex"));
5156 }
5157 time_column_index__ =
5158 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5159 ;
5160 }
5161 GeneratedField::Interval => {
5162 if interval__.is_some() {
5163 return Err(serde::de::Error::duplicate_field("interval"));
5164 }
5165 interval__ = map_.next_value()?;
5166 }
5167 GeneratedField::FillColumns => {
5168 if fill_columns__.is_some() {
5169 return Err(serde::de::Error::duplicate_field("fillColumns"));
5170 }
5171 fill_columns__ =
5172 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5173 .into_iter().map(|x| x.0).collect())
5174 ;
5175 }
5176 GeneratedField::FillStrategies => {
5177 if fill_strategies__.is_some() {
5178 return Err(serde::de::Error::duplicate_field("fillStrategies"));
5179 }
5180 fill_strategies__ = Some(map_.next_value()?);
5181 }
5182 GeneratedField::StateTable => {
5183 if state_table__.is_some() {
5184 return Err(serde::de::Error::duplicate_field("stateTable"));
5185 }
5186 state_table__ = map_.next_value()?;
5187 }
5188 }
5189 }
5190 Ok(GapFillNode {
5191 time_column_index: time_column_index__.unwrap_or_default(),
5192 interval: interval__,
5193 fill_columns: fill_columns__.unwrap_or_default(),
5194 fill_strategies: fill_strategies__.unwrap_or_default(),
5195 state_table: state_table__,
5196 })
5197 }
5198 }
5199 deserializer.deserialize_struct("stream_plan.GapFillNode", FIELDS, GeneratedVisitor)
5200 }
5201}
5202impl serde::Serialize for GlobalApproxPercentileNode {
5203 #[allow(deprecated)]
5204 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5205 where
5206 S: serde::Serializer,
5207 {
5208 use serde::ser::SerializeStruct;
5209 let mut len = 0;
5210 if self.base != 0. {
5211 len += 1;
5212 }
5213 if self.quantile != 0. {
5214 len += 1;
5215 }
5216 if self.bucket_state_table.is_some() {
5217 len += 1;
5218 }
5219 if self.count_state_table.is_some() {
5220 len += 1;
5221 }
5222 let mut struct_ser = serializer.serialize_struct("stream_plan.GlobalApproxPercentileNode", len)?;
5223 if self.base != 0. {
5224 struct_ser.serialize_field("base", &self.base)?;
5225 }
5226 if self.quantile != 0. {
5227 struct_ser.serialize_field("quantile", &self.quantile)?;
5228 }
5229 if let Some(v) = self.bucket_state_table.as_ref() {
5230 struct_ser.serialize_field("bucketStateTable", v)?;
5231 }
5232 if let Some(v) = self.count_state_table.as_ref() {
5233 struct_ser.serialize_field("countStateTable", v)?;
5234 }
5235 struct_ser.end()
5236 }
5237}
5238impl<'de> serde::Deserialize<'de> for GlobalApproxPercentileNode {
5239 #[allow(deprecated)]
5240 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5241 where
5242 D: serde::Deserializer<'de>,
5243 {
5244 const FIELDS: &[&str] = &[
5245 "base",
5246 "quantile",
5247 "bucket_state_table",
5248 "bucketStateTable",
5249 "count_state_table",
5250 "countStateTable",
5251 ];
5252
5253 #[allow(clippy::enum_variant_names)]
5254 enum GeneratedField {
5255 Base,
5256 Quantile,
5257 BucketStateTable,
5258 CountStateTable,
5259 }
5260 impl<'de> serde::Deserialize<'de> for GeneratedField {
5261 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5262 where
5263 D: serde::Deserializer<'de>,
5264 {
5265 struct GeneratedVisitor;
5266
5267 impl serde::de::Visitor<'_> for GeneratedVisitor {
5268 type Value = GeneratedField;
5269
5270 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5271 write!(formatter, "expected one of: {:?}", &FIELDS)
5272 }
5273
5274 #[allow(unused_variables)]
5275 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5276 where
5277 E: serde::de::Error,
5278 {
5279 match value {
5280 "base" => Ok(GeneratedField::Base),
5281 "quantile" => Ok(GeneratedField::Quantile),
5282 "bucketStateTable" | "bucket_state_table" => Ok(GeneratedField::BucketStateTable),
5283 "countStateTable" | "count_state_table" => Ok(GeneratedField::CountStateTable),
5284 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5285 }
5286 }
5287 }
5288 deserializer.deserialize_identifier(GeneratedVisitor)
5289 }
5290 }
5291 struct GeneratedVisitor;
5292 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5293 type Value = GlobalApproxPercentileNode;
5294
5295 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5296 formatter.write_str("struct stream_plan.GlobalApproxPercentileNode")
5297 }
5298
5299 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GlobalApproxPercentileNode, V::Error>
5300 where
5301 V: serde::de::MapAccess<'de>,
5302 {
5303 let mut base__ = None;
5304 let mut quantile__ = None;
5305 let mut bucket_state_table__ = None;
5306 let mut count_state_table__ = None;
5307 while let Some(k) = map_.next_key()? {
5308 match k {
5309 GeneratedField::Base => {
5310 if base__.is_some() {
5311 return Err(serde::de::Error::duplicate_field("base"));
5312 }
5313 base__ =
5314 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5315 ;
5316 }
5317 GeneratedField::Quantile => {
5318 if quantile__.is_some() {
5319 return Err(serde::de::Error::duplicate_field("quantile"));
5320 }
5321 quantile__ =
5322 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5323 ;
5324 }
5325 GeneratedField::BucketStateTable => {
5326 if bucket_state_table__.is_some() {
5327 return Err(serde::de::Error::duplicate_field("bucketStateTable"));
5328 }
5329 bucket_state_table__ = map_.next_value()?;
5330 }
5331 GeneratedField::CountStateTable => {
5332 if count_state_table__.is_some() {
5333 return Err(serde::de::Error::duplicate_field("countStateTable"));
5334 }
5335 count_state_table__ = map_.next_value()?;
5336 }
5337 }
5338 }
5339 Ok(GlobalApproxPercentileNode {
5340 base: base__.unwrap_or_default(),
5341 quantile: quantile__.unwrap_or_default(),
5342 bucket_state_table: bucket_state_table__,
5343 count_state_table: count_state_table__,
5344 })
5345 }
5346 }
5347 deserializer.deserialize_struct("stream_plan.GlobalApproxPercentileNode", FIELDS, GeneratedVisitor)
5348 }
5349}
5350impl serde::Serialize for GroupTopNNode {
5351 #[allow(deprecated)]
5352 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5353 where
5354 S: serde::Serializer,
5355 {
5356 use serde::ser::SerializeStruct;
5357 let mut len = 0;
5358 if self.limit != 0 {
5359 len += 1;
5360 }
5361 if self.offset != 0 {
5362 len += 1;
5363 }
5364 if !self.group_key.is_empty() {
5365 len += 1;
5366 }
5367 if self.table.is_some() {
5368 len += 1;
5369 }
5370 if !self.order_by.is_empty() {
5371 len += 1;
5372 }
5373 if self.with_ties {
5374 len += 1;
5375 }
5376 let mut struct_ser = serializer.serialize_struct("stream_plan.GroupTopNNode", len)?;
5377 if self.limit != 0 {
5378 #[allow(clippy::needless_borrow)]
5379 #[allow(clippy::needless_borrows_for_generic_args)]
5380 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
5381 }
5382 if self.offset != 0 {
5383 #[allow(clippy::needless_borrow)]
5384 #[allow(clippy::needless_borrows_for_generic_args)]
5385 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
5386 }
5387 if !self.group_key.is_empty() {
5388 struct_ser.serialize_field("groupKey", &self.group_key)?;
5389 }
5390 if let Some(v) = self.table.as_ref() {
5391 struct_ser.serialize_field("table", v)?;
5392 }
5393 if !self.order_by.is_empty() {
5394 struct_ser.serialize_field("orderBy", &self.order_by)?;
5395 }
5396 if self.with_ties {
5397 struct_ser.serialize_field("withTies", &self.with_ties)?;
5398 }
5399 struct_ser.end()
5400 }
5401}
5402impl<'de> serde::Deserialize<'de> for GroupTopNNode {
5403 #[allow(deprecated)]
5404 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5405 where
5406 D: serde::Deserializer<'de>,
5407 {
5408 const FIELDS: &[&str] = &[
5409 "limit",
5410 "offset",
5411 "group_key",
5412 "groupKey",
5413 "table",
5414 "order_by",
5415 "orderBy",
5416 "with_ties",
5417 "withTies",
5418 ];
5419
5420 #[allow(clippy::enum_variant_names)]
5421 enum GeneratedField {
5422 Limit,
5423 Offset,
5424 GroupKey,
5425 Table,
5426 OrderBy,
5427 WithTies,
5428 }
5429 impl<'de> serde::Deserialize<'de> for GeneratedField {
5430 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5431 where
5432 D: serde::Deserializer<'de>,
5433 {
5434 struct GeneratedVisitor;
5435
5436 impl serde::de::Visitor<'_> for GeneratedVisitor {
5437 type Value = GeneratedField;
5438
5439 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5440 write!(formatter, "expected one of: {:?}", &FIELDS)
5441 }
5442
5443 #[allow(unused_variables)]
5444 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5445 where
5446 E: serde::de::Error,
5447 {
5448 match value {
5449 "limit" => Ok(GeneratedField::Limit),
5450 "offset" => Ok(GeneratedField::Offset),
5451 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5452 "table" => Ok(GeneratedField::Table),
5453 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
5454 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
5455 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5456 }
5457 }
5458 }
5459 deserializer.deserialize_identifier(GeneratedVisitor)
5460 }
5461 }
5462 struct GeneratedVisitor;
5463 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5464 type Value = GroupTopNNode;
5465
5466 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5467 formatter.write_str("struct stream_plan.GroupTopNNode")
5468 }
5469
5470 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupTopNNode, V::Error>
5471 where
5472 V: serde::de::MapAccess<'de>,
5473 {
5474 let mut limit__ = None;
5475 let mut offset__ = None;
5476 let mut group_key__ = None;
5477 let mut table__ = None;
5478 let mut order_by__ = None;
5479 let mut with_ties__ = None;
5480 while let Some(k) = map_.next_key()? {
5481 match k {
5482 GeneratedField::Limit => {
5483 if limit__.is_some() {
5484 return Err(serde::de::Error::duplicate_field("limit"));
5485 }
5486 limit__ =
5487 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5488 ;
5489 }
5490 GeneratedField::Offset => {
5491 if offset__.is_some() {
5492 return Err(serde::de::Error::duplicate_field("offset"));
5493 }
5494 offset__ =
5495 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5496 ;
5497 }
5498 GeneratedField::GroupKey => {
5499 if group_key__.is_some() {
5500 return Err(serde::de::Error::duplicate_field("groupKey"));
5501 }
5502 group_key__ =
5503 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5504 .into_iter().map(|x| x.0).collect())
5505 ;
5506 }
5507 GeneratedField::Table => {
5508 if table__.is_some() {
5509 return Err(serde::de::Error::duplicate_field("table"));
5510 }
5511 table__ = map_.next_value()?;
5512 }
5513 GeneratedField::OrderBy => {
5514 if order_by__.is_some() {
5515 return Err(serde::de::Error::duplicate_field("orderBy"));
5516 }
5517 order_by__ = Some(map_.next_value()?);
5518 }
5519 GeneratedField::WithTies => {
5520 if with_ties__.is_some() {
5521 return Err(serde::de::Error::duplicate_field("withTies"));
5522 }
5523 with_ties__ = Some(map_.next_value()?);
5524 }
5525 }
5526 }
5527 Ok(GroupTopNNode {
5528 limit: limit__.unwrap_or_default(),
5529 offset: offset__.unwrap_or_default(),
5530 group_key: group_key__.unwrap_or_default(),
5531 table: table__,
5532 order_by: order_by__.unwrap_or_default(),
5533 with_ties: with_ties__.unwrap_or_default(),
5534 })
5535 }
5536 }
5537 deserializer.deserialize_struct("stream_plan.GroupTopNNode", FIELDS, GeneratedVisitor)
5538 }
5539}
5540impl serde::Serialize for HashAggNode {
5541 #[allow(deprecated)]
5542 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5543 where
5544 S: serde::Serializer,
5545 {
5546 use serde::ser::SerializeStruct;
5547 let mut len = 0;
5548 if !self.group_key.is_empty() {
5549 len += 1;
5550 }
5551 if !self.agg_calls.is_empty() {
5552 len += 1;
5553 }
5554 if !self.agg_call_states.is_empty() {
5555 len += 1;
5556 }
5557 if self.intermediate_state_table.is_some() {
5558 len += 1;
5559 }
5560 if self.is_append_only {
5561 len += 1;
5562 }
5563 if !self.distinct_dedup_tables.is_empty() {
5564 len += 1;
5565 }
5566 if self.row_count_index != 0 {
5567 len += 1;
5568 }
5569 if self.emit_on_window_close {
5570 len += 1;
5571 }
5572 if self.version != 0 {
5573 len += 1;
5574 }
5575 let mut struct_ser = serializer.serialize_struct("stream_plan.HashAggNode", len)?;
5576 if !self.group_key.is_empty() {
5577 struct_ser.serialize_field("groupKey", &self.group_key)?;
5578 }
5579 if !self.agg_calls.is_empty() {
5580 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
5581 }
5582 if !self.agg_call_states.is_empty() {
5583 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
5584 }
5585 if let Some(v) = self.intermediate_state_table.as_ref() {
5586 struct_ser.serialize_field("intermediateStateTable", v)?;
5587 }
5588 if self.is_append_only {
5589 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5590 }
5591 if !self.distinct_dedup_tables.is_empty() {
5592 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
5593 }
5594 if self.row_count_index != 0 {
5595 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
5596 }
5597 if self.emit_on_window_close {
5598 struct_ser.serialize_field("emitOnWindowClose", &self.emit_on_window_close)?;
5599 }
5600 if self.version != 0 {
5601 let v = AggNodeVersion::try_from(self.version)
5602 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
5603 struct_ser.serialize_field("version", &v)?;
5604 }
5605 struct_ser.end()
5606 }
5607}
5608impl<'de> serde::Deserialize<'de> for HashAggNode {
5609 #[allow(deprecated)]
5610 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5611 where
5612 D: serde::Deserializer<'de>,
5613 {
5614 const FIELDS: &[&str] = &[
5615 "group_key",
5616 "groupKey",
5617 "agg_calls",
5618 "aggCalls",
5619 "agg_call_states",
5620 "aggCallStates",
5621 "intermediate_state_table",
5622 "intermediateStateTable",
5623 "is_append_only",
5624 "isAppendOnly",
5625 "distinct_dedup_tables",
5626 "distinctDedupTables",
5627 "row_count_index",
5628 "rowCountIndex",
5629 "emit_on_window_close",
5630 "emitOnWindowClose",
5631 "version",
5632 ];
5633
5634 #[allow(clippy::enum_variant_names)]
5635 enum GeneratedField {
5636 GroupKey,
5637 AggCalls,
5638 AggCallStates,
5639 IntermediateStateTable,
5640 IsAppendOnly,
5641 DistinctDedupTables,
5642 RowCountIndex,
5643 EmitOnWindowClose,
5644 Version,
5645 }
5646 impl<'de> serde::Deserialize<'de> for GeneratedField {
5647 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5648 where
5649 D: serde::Deserializer<'de>,
5650 {
5651 struct GeneratedVisitor;
5652
5653 impl serde::de::Visitor<'_> for GeneratedVisitor {
5654 type Value = GeneratedField;
5655
5656 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5657 write!(formatter, "expected one of: {:?}", &FIELDS)
5658 }
5659
5660 #[allow(unused_variables)]
5661 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5662 where
5663 E: serde::de::Error,
5664 {
5665 match value {
5666 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5667 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
5668 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
5669 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
5670 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5671 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
5672 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
5673 "emitOnWindowClose" | "emit_on_window_close" => Ok(GeneratedField::EmitOnWindowClose),
5674 "version" => Ok(GeneratedField::Version),
5675 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5676 }
5677 }
5678 }
5679 deserializer.deserialize_identifier(GeneratedVisitor)
5680 }
5681 }
5682 struct GeneratedVisitor;
5683 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5684 type Value = HashAggNode;
5685
5686 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5687 formatter.write_str("struct stream_plan.HashAggNode")
5688 }
5689
5690 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashAggNode, V::Error>
5691 where
5692 V: serde::de::MapAccess<'de>,
5693 {
5694 let mut group_key__ = None;
5695 let mut agg_calls__ = None;
5696 let mut agg_call_states__ = None;
5697 let mut intermediate_state_table__ = None;
5698 let mut is_append_only__ = None;
5699 let mut distinct_dedup_tables__ = None;
5700 let mut row_count_index__ = None;
5701 let mut emit_on_window_close__ = None;
5702 let mut version__ = None;
5703 while let Some(k) = map_.next_key()? {
5704 match k {
5705 GeneratedField::GroupKey => {
5706 if group_key__.is_some() {
5707 return Err(serde::de::Error::duplicate_field("groupKey"));
5708 }
5709 group_key__ =
5710 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5711 .into_iter().map(|x| x.0).collect())
5712 ;
5713 }
5714 GeneratedField::AggCalls => {
5715 if agg_calls__.is_some() {
5716 return Err(serde::de::Error::duplicate_field("aggCalls"));
5717 }
5718 agg_calls__ = Some(map_.next_value()?);
5719 }
5720 GeneratedField::AggCallStates => {
5721 if agg_call_states__.is_some() {
5722 return Err(serde::de::Error::duplicate_field("aggCallStates"));
5723 }
5724 agg_call_states__ = Some(map_.next_value()?);
5725 }
5726 GeneratedField::IntermediateStateTable => {
5727 if intermediate_state_table__.is_some() {
5728 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
5729 }
5730 intermediate_state_table__ = map_.next_value()?;
5731 }
5732 GeneratedField::IsAppendOnly => {
5733 if is_append_only__.is_some() {
5734 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
5735 }
5736 is_append_only__ = Some(map_.next_value()?);
5737 }
5738 GeneratedField::DistinctDedupTables => {
5739 if distinct_dedup_tables__.is_some() {
5740 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
5741 }
5742 distinct_dedup_tables__ = Some(
5743 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5744 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
5745 );
5746 }
5747 GeneratedField::RowCountIndex => {
5748 if row_count_index__.is_some() {
5749 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
5750 }
5751 row_count_index__ =
5752 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5753 ;
5754 }
5755 GeneratedField::EmitOnWindowClose => {
5756 if emit_on_window_close__.is_some() {
5757 return Err(serde::de::Error::duplicate_field("emitOnWindowClose"));
5758 }
5759 emit_on_window_close__ = Some(map_.next_value()?);
5760 }
5761 GeneratedField::Version => {
5762 if version__.is_some() {
5763 return Err(serde::de::Error::duplicate_field("version"));
5764 }
5765 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
5766 }
5767 }
5768 }
5769 Ok(HashAggNode {
5770 group_key: group_key__.unwrap_or_default(),
5771 agg_calls: agg_calls__.unwrap_or_default(),
5772 agg_call_states: agg_call_states__.unwrap_or_default(),
5773 intermediate_state_table: intermediate_state_table__,
5774 is_append_only: is_append_only__.unwrap_or_default(),
5775 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
5776 row_count_index: row_count_index__.unwrap_or_default(),
5777 emit_on_window_close: emit_on_window_close__.unwrap_or_default(),
5778 version: version__.unwrap_or_default(),
5779 })
5780 }
5781 }
5782 deserializer.deserialize_struct("stream_plan.HashAggNode", FIELDS, GeneratedVisitor)
5783 }
5784}
5785impl serde::Serialize for HashJoinNode {
5786 #[allow(deprecated)]
5787 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5788 where
5789 S: serde::Serializer,
5790 {
5791 use serde::ser::SerializeStruct;
5792 let mut len = 0;
5793 if self.join_type != 0 {
5794 len += 1;
5795 }
5796 if !self.left_key.is_empty() {
5797 len += 1;
5798 }
5799 if !self.right_key.is_empty() {
5800 len += 1;
5801 }
5802 if self.condition.is_some() {
5803 len += 1;
5804 }
5805 if !self.inequality_pairs.is_empty() {
5806 len += 1;
5807 }
5808 if self.left_table.is_some() {
5809 len += 1;
5810 }
5811 if self.right_table.is_some() {
5812 len += 1;
5813 }
5814 if self.left_degree_table.is_some() {
5815 len += 1;
5816 }
5817 if self.right_degree_table.is_some() {
5818 len += 1;
5819 }
5820 if !self.output_indices.is_empty() {
5821 len += 1;
5822 }
5823 if !self.left_deduped_input_pk_indices.is_empty() {
5824 len += 1;
5825 }
5826 if !self.right_deduped_input_pk_indices.is_empty() {
5827 len += 1;
5828 }
5829 if !self.null_safe.is_empty() {
5830 len += 1;
5831 }
5832 if self.is_append_only {
5833 len += 1;
5834 }
5835 if self.join_encoding_type != 0 {
5836 len += 1;
5837 }
5838 if !self.inequality_pairs_v2.is_empty() {
5839 len += 1;
5840 }
5841 let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinNode", len)?;
5842 if self.join_type != 0 {
5843 let v = super::plan_common::JoinType::try_from(self.join_type)
5844 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
5845 struct_ser.serialize_field("joinType", &v)?;
5846 }
5847 if !self.left_key.is_empty() {
5848 struct_ser.serialize_field("leftKey", &self.left_key)?;
5849 }
5850 if !self.right_key.is_empty() {
5851 struct_ser.serialize_field("rightKey", &self.right_key)?;
5852 }
5853 if let Some(v) = self.condition.as_ref() {
5854 struct_ser.serialize_field("condition", v)?;
5855 }
5856 if !self.inequality_pairs.is_empty() {
5857 struct_ser.serialize_field("inequalityPairs", &self.inequality_pairs)?;
5858 }
5859 if let Some(v) = self.left_table.as_ref() {
5860 struct_ser.serialize_field("leftTable", v)?;
5861 }
5862 if let Some(v) = self.right_table.as_ref() {
5863 struct_ser.serialize_field("rightTable", v)?;
5864 }
5865 if let Some(v) = self.left_degree_table.as_ref() {
5866 struct_ser.serialize_field("leftDegreeTable", v)?;
5867 }
5868 if let Some(v) = self.right_degree_table.as_ref() {
5869 struct_ser.serialize_field("rightDegreeTable", v)?;
5870 }
5871 if !self.output_indices.is_empty() {
5872 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
5873 }
5874 if !self.left_deduped_input_pk_indices.is_empty() {
5875 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
5876 }
5877 if !self.right_deduped_input_pk_indices.is_empty() {
5878 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
5879 }
5880 if !self.null_safe.is_empty() {
5881 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
5882 }
5883 if self.is_append_only {
5884 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5885 }
5886 if self.join_encoding_type != 0 {
5887 let v = JoinEncodingType::try_from(self.join_encoding_type)
5888 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
5889 struct_ser.serialize_field("joinEncodingType", &v)?;
5890 }
5891 if !self.inequality_pairs_v2.is_empty() {
5892 struct_ser.serialize_field("inequalityPairsV2", &self.inequality_pairs_v2)?;
5893 }
5894 struct_ser.end()
5895 }
5896}
5897impl<'de> serde::Deserialize<'de> for HashJoinNode {
5898 #[allow(deprecated)]
5899 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5900 where
5901 D: serde::Deserializer<'de>,
5902 {
5903 const FIELDS: &[&str] = &[
5904 "join_type",
5905 "joinType",
5906 "left_key",
5907 "leftKey",
5908 "right_key",
5909 "rightKey",
5910 "condition",
5911 "inequality_pairs",
5912 "inequalityPairs",
5913 "left_table",
5914 "leftTable",
5915 "right_table",
5916 "rightTable",
5917 "left_degree_table",
5918 "leftDegreeTable",
5919 "right_degree_table",
5920 "rightDegreeTable",
5921 "output_indices",
5922 "outputIndices",
5923 "left_deduped_input_pk_indices",
5924 "leftDedupedInputPkIndices",
5925 "right_deduped_input_pk_indices",
5926 "rightDedupedInputPkIndices",
5927 "null_safe",
5928 "nullSafe",
5929 "is_append_only",
5930 "isAppendOnly",
5931 "join_encoding_type",
5932 "joinEncodingType",
5933 "inequality_pairs_v2",
5934 "inequalityPairsV2",
5935 ];
5936
5937 #[allow(clippy::enum_variant_names)]
5938 enum GeneratedField {
5939 JoinType,
5940 LeftKey,
5941 RightKey,
5942 Condition,
5943 InequalityPairs,
5944 LeftTable,
5945 RightTable,
5946 LeftDegreeTable,
5947 RightDegreeTable,
5948 OutputIndices,
5949 LeftDedupedInputPkIndices,
5950 RightDedupedInputPkIndices,
5951 NullSafe,
5952 IsAppendOnly,
5953 JoinEncodingType,
5954 InequalityPairsV2,
5955 }
5956 impl<'de> serde::Deserialize<'de> for GeneratedField {
5957 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5958 where
5959 D: serde::Deserializer<'de>,
5960 {
5961 struct GeneratedVisitor;
5962
5963 impl serde::de::Visitor<'_> for GeneratedVisitor {
5964 type Value = GeneratedField;
5965
5966 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5967 write!(formatter, "expected one of: {:?}", &FIELDS)
5968 }
5969
5970 #[allow(unused_variables)]
5971 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5972 where
5973 E: serde::de::Error,
5974 {
5975 match value {
5976 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
5977 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
5978 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
5979 "condition" => Ok(GeneratedField::Condition),
5980 "inequalityPairs" | "inequality_pairs" => Ok(GeneratedField::InequalityPairs),
5981 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
5982 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
5983 "leftDegreeTable" | "left_degree_table" => Ok(GeneratedField::LeftDegreeTable),
5984 "rightDegreeTable" | "right_degree_table" => Ok(GeneratedField::RightDegreeTable),
5985 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
5986 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
5987 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
5988 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
5989 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5990 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
5991 "inequalityPairsV2" | "inequality_pairs_v2" => Ok(GeneratedField::InequalityPairsV2),
5992 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5993 }
5994 }
5995 }
5996 deserializer.deserialize_identifier(GeneratedVisitor)
5997 }
5998 }
5999 struct GeneratedVisitor;
6000 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6001 type Value = HashJoinNode;
6002
6003 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6004 formatter.write_str("struct stream_plan.HashJoinNode")
6005 }
6006
6007 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinNode, V::Error>
6008 where
6009 V: serde::de::MapAccess<'de>,
6010 {
6011 let mut join_type__ = None;
6012 let mut left_key__ = None;
6013 let mut right_key__ = None;
6014 let mut condition__ = None;
6015 let mut inequality_pairs__ = None;
6016 let mut left_table__ = None;
6017 let mut right_table__ = None;
6018 let mut left_degree_table__ = None;
6019 let mut right_degree_table__ = None;
6020 let mut output_indices__ = None;
6021 let mut left_deduped_input_pk_indices__ = None;
6022 let mut right_deduped_input_pk_indices__ = None;
6023 let mut null_safe__ = None;
6024 let mut is_append_only__ = None;
6025 let mut join_encoding_type__ = None;
6026 let mut inequality_pairs_v2__ = None;
6027 while let Some(k) = map_.next_key()? {
6028 match k {
6029 GeneratedField::JoinType => {
6030 if join_type__.is_some() {
6031 return Err(serde::de::Error::duplicate_field("joinType"));
6032 }
6033 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
6034 }
6035 GeneratedField::LeftKey => {
6036 if left_key__.is_some() {
6037 return Err(serde::de::Error::duplicate_field("leftKey"));
6038 }
6039 left_key__ =
6040 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6041 .into_iter().map(|x| x.0).collect())
6042 ;
6043 }
6044 GeneratedField::RightKey => {
6045 if right_key__.is_some() {
6046 return Err(serde::de::Error::duplicate_field("rightKey"));
6047 }
6048 right_key__ =
6049 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6050 .into_iter().map(|x| x.0).collect())
6051 ;
6052 }
6053 GeneratedField::Condition => {
6054 if condition__.is_some() {
6055 return Err(serde::de::Error::duplicate_field("condition"));
6056 }
6057 condition__ = map_.next_value()?;
6058 }
6059 GeneratedField::InequalityPairs => {
6060 if inequality_pairs__.is_some() {
6061 return Err(serde::de::Error::duplicate_field("inequalityPairs"));
6062 }
6063 inequality_pairs__ = Some(map_.next_value()?);
6064 }
6065 GeneratedField::LeftTable => {
6066 if left_table__.is_some() {
6067 return Err(serde::de::Error::duplicate_field("leftTable"));
6068 }
6069 left_table__ = map_.next_value()?;
6070 }
6071 GeneratedField::RightTable => {
6072 if right_table__.is_some() {
6073 return Err(serde::de::Error::duplicate_field("rightTable"));
6074 }
6075 right_table__ = map_.next_value()?;
6076 }
6077 GeneratedField::LeftDegreeTable => {
6078 if left_degree_table__.is_some() {
6079 return Err(serde::de::Error::duplicate_field("leftDegreeTable"));
6080 }
6081 left_degree_table__ = map_.next_value()?;
6082 }
6083 GeneratedField::RightDegreeTable => {
6084 if right_degree_table__.is_some() {
6085 return Err(serde::de::Error::duplicate_field("rightDegreeTable"));
6086 }
6087 right_degree_table__ = map_.next_value()?;
6088 }
6089 GeneratedField::OutputIndices => {
6090 if output_indices__.is_some() {
6091 return Err(serde::de::Error::duplicate_field("outputIndices"));
6092 }
6093 output_indices__ =
6094 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6095 .into_iter().map(|x| x.0).collect())
6096 ;
6097 }
6098 GeneratedField::LeftDedupedInputPkIndices => {
6099 if left_deduped_input_pk_indices__.is_some() {
6100 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
6101 }
6102 left_deduped_input_pk_indices__ =
6103 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6104 .into_iter().map(|x| x.0).collect())
6105 ;
6106 }
6107 GeneratedField::RightDedupedInputPkIndices => {
6108 if right_deduped_input_pk_indices__.is_some() {
6109 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
6110 }
6111 right_deduped_input_pk_indices__ =
6112 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6113 .into_iter().map(|x| x.0).collect())
6114 ;
6115 }
6116 GeneratedField::NullSafe => {
6117 if null_safe__.is_some() {
6118 return Err(serde::de::Error::duplicate_field("nullSafe"));
6119 }
6120 null_safe__ = Some(map_.next_value()?);
6121 }
6122 GeneratedField::IsAppendOnly => {
6123 if is_append_only__.is_some() {
6124 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
6125 }
6126 is_append_only__ = Some(map_.next_value()?);
6127 }
6128 GeneratedField::JoinEncodingType => {
6129 if join_encoding_type__.is_some() {
6130 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
6131 }
6132 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
6133 }
6134 GeneratedField::InequalityPairsV2 => {
6135 if inequality_pairs_v2__.is_some() {
6136 return Err(serde::de::Error::duplicate_field("inequalityPairsV2"));
6137 }
6138 inequality_pairs_v2__ = Some(map_.next_value()?);
6139 }
6140 }
6141 }
6142 Ok(HashJoinNode {
6143 join_type: join_type__.unwrap_or_default(),
6144 left_key: left_key__.unwrap_or_default(),
6145 right_key: right_key__.unwrap_or_default(),
6146 condition: condition__,
6147 inequality_pairs: inequality_pairs__.unwrap_or_default(),
6148 left_table: left_table__,
6149 right_table: right_table__,
6150 left_degree_table: left_degree_table__,
6151 right_degree_table: right_degree_table__,
6152 output_indices: output_indices__.unwrap_or_default(),
6153 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
6154 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
6155 null_safe: null_safe__.unwrap_or_default(),
6156 is_append_only: is_append_only__.unwrap_or_default(),
6157 join_encoding_type: join_encoding_type__.unwrap_or_default(),
6158 inequality_pairs_v2: inequality_pairs_v2__.unwrap_or_default(),
6159 })
6160 }
6161 }
6162 deserializer.deserialize_struct("stream_plan.HashJoinNode", FIELDS, GeneratedVisitor)
6163 }
6164}
6165impl serde::Serialize for HopWindowNode {
6166 #[allow(deprecated)]
6167 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6168 where
6169 S: serde::Serializer,
6170 {
6171 use serde::ser::SerializeStruct;
6172 let mut len = 0;
6173 if self.time_col != 0 {
6174 len += 1;
6175 }
6176 if self.window_slide.is_some() {
6177 len += 1;
6178 }
6179 if self.window_size.is_some() {
6180 len += 1;
6181 }
6182 if !self.output_indices.is_empty() {
6183 len += 1;
6184 }
6185 if !self.window_start_exprs.is_empty() {
6186 len += 1;
6187 }
6188 if !self.window_end_exprs.is_empty() {
6189 len += 1;
6190 }
6191 let mut struct_ser = serializer.serialize_struct("stream_plan.HopWindowNode", len)?;
6192 if self.time_col != 0 {
6193 struct_ser.serialize_field("timeCol", &self.time_col)?;
6194 }
6195 if let Some(v) = self.window_slide.as_ref() {
6196 struct_ser.serialize_field("windowSlide", v)?;
6197 }
6198 if let Some(v) = self.window_size.as_ref() {
6199 struct_ser.serialize_field("windowSize", v)?;
6200 }
6201 if !self.output_indices.is_empty() {
6202 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
6203 }
6204 if !self.window_start_exprs.is_empty() {
6205 struct_ser.serialize_field("windowStartExprs", &self.window_start_exprs)?;
6206 }
6207 if !self.window_end_exprs.is_empty() {
6208 struct_ser.serialize_field("windowEndExprs", &self.window_end_exprs)?;
6209 }
6210 struct_ser.end()
6211 }
6212}
6213impl<'de> serde::Deserialize<'de> for HopWindowNode {
6214 #[allow(deprecated)]
6215 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6216 where
6217 D: serde::Deserializer<'de>,
6218 {
6219 const FIELDS: &[&str] = &[
6220 "time_col",
6221 "timeCol",
6222 "window_slide",
6223 "windowSlide",
6224 "window_size",
6225 "windowSize",
6226 "output_indices",
6227 "outputIndices",
6228 "window_start_exprs",
6229 "windowStartExprs",
6230 "window_end_exprs",
6231 "windowEndExprs",
6232 ];
6233
6234 #[allow(clippy::enum_variant_names)]
6235 enum GeneratedField {
6236 TimeCol,
6237 WindowSlide,
6238 WindowSize,
6239 OutputIndices,
6240 WindowStartExprs,
6241 WindowEndExprs,
6242 }
6243 impl<'de> serde::Deserialize<'de> for GeneratedField {
6244 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6245 where
6246 D: serde::Deserializer<'de>,
6247 {
6248 struct GeneratedVisitor;
6249
6250 impl serde::de::Visitor<'_> for GeneratedVisitor {
6251 type Value = GeneratedField;
6252
6253 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6254 write!(formatter, "expected one of: {:?}", &FIELDS)
6255 }
6256
6257 #[allow(unused_variables)]
6258 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6259 where
6260 E: serde::de::Error,
6261 {
6262 match value {
6263 "timeCol" | "time_col" => Ok(GeneratedField::TimeCol),
6264 "windowSlide" | "window_slide" => Ok(GeneratedField::WindowSlide),
6265 "windowSize" | "window_size" => Ok(GeneratedField::WindowSize),
6266 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
6267 "windowStartExprs" | "window_start_exprs" => Ok(GeneratedField::WindowStartExprs),
6268 "windowEndExprs" | "window_end_exprs" => Ok(GeneratedField::WindowEndExprs),
6269 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6270 }
6271 }
6272 }
6273 deserializer.deserialize_identifier(GeneratedVisitor)
6274 }
6275 }
6276 struct GeneratedVisitor;
6277 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6278 type Value = HopWindowNode;
6279
6280 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6281 formatter.write_str("struct stream_plan.HopWindowNode")
6282 }
6283
6284 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HopWindowNode, V::Error>
6285 where
6286 V: serde::de::MapAccess<'de>,
6287 {
6288 let mut time_col__ = None;
6289 let mut window_slide__ = None;
6290 let mut window_size__ = None;
6291 let mut output_indices__ = None;
6292 let mut window_start_exprs__ = None;
6293 let mut window_end_exprs__ = None;
6294 while let Some(k) = map_.next_key()? {
6295 match k {
6296 GeneratedField::TimeCol => {
6297 if time_col__.is_some() {
6298 return Err(serde::de::Error::duplicate_field("timeCol"));
6299 }
6300 time_col__ =
6301 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6302 ;
6303 }
6304 GeneratedField::WindowSlide => {
6305 if window_slide__.is_some() {
6306 return Err(serde::de::Error::duplicate_field("windowSlide"));
6307 }
6308 window_slide__ = map_.next_value()?;
6309 }
6310 GeneratedField::WindowSize => {
6311 if window_size__.is_some() {
6312 return Err(serde::de::Error::duplicate_field("windowSize"));
6313 }
6314 window_size__ = map_.next_value()?;
6315 }
6316 GeneratedField::OutputIndices => {
6317 if output_indices__.is_some() {
6318 return Err(serde::de::Error::duplicate_field("outputIndices"));
6319 }
6320 output_indices__ =
6321 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6322 .into_iter().map(|x| x.0).collect())
6323 ;
6324 }
6325 GeneratedField::WindowStartExprs => {
6326 if window_start_exprs__.is_some() {
6327 return Err(serde::de::Error::duplicate_field("windowStartExprs"));
6328 }
6329 window_start_exprs__ = Some(map_.next_value()?);
6330 }
6331 GeneratedField::WindowEndExprs => {
6332 if window_end_exprs__.is_some() {
6333 return Err(serde::de::Error::duplicate_field("windowEndExprs"));
6334 }
6335 window_end_exprs__ = Some(map_.next_value()?);
6336 }
6337 }
6338 }
6339 Ok(HopWindowNode {
6340 time_col: time_col__.unwrap_or_default(),
6341 window_slide: window_slide__,
6342 window_size: window_size__,
6343 output_indices: output_indices__.unwrap_or_default(),
6344 window_start_exprs: window_start_exprs__.unwrap_or_default(),
6345 window_end_exprs: window_end_exprs__.unwrap_or_default(),
6346 })
6347 }
6348 }
6349 deserializer.deserialize_struct("stream_plan.HopWindowNode", FIELDS, GeneratedVisitor)
6350 }
6351}
6352impl serde::Serialize for InequalityPair {
6353 #[allow(deprecated)]
6354 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6355 where
6356 S: serde::Serializer,
6357 {
6358 use serde::ser::SerializeStruct;
6359 let mut len = 0;
6360 if self.key_required_larger != 0 {
6361 len += 1;
6362 }
6363 if self.key_required_smaller != 0 {
6364 len += 1;
6365 }
6366 if self.clean_state {
6367 len += 1;
6368 }
6369 if self.delta_expression.is_some() {
6370 len += 1;
6371 }
6372 let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPair", len)?;
6373 if self.key_required_larger != 0 {
6374 struct_ser.serialize_field("keyRequiredLarger", &self.key_required_larger)?;
6375 }
6376 if self.key_required_smaller != 0 {
6377 struct_ser.serialize_field("keyRequiredSmaller", &self.key_required_smaller)?;
6378 }
6379 if self.clean_state {
6380 struct_ser.serialize_field("cleanState", &self.clean_state)?;
6381 }
6382 if let Some(v) = self.delta_expression.as_ref() {
6383 struct_ser.serialize_field("deltaExpression", v)?;
6384 }
6385 struct_ser.end()
6386 }
6387}
6388impl<'de> serde::Deserialize<'de> for InequalityPair {
6389 #[allow(deprecated)]
6390 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6391 where
6392 D: serde::Deserializer<'de>,
6393 {
6394 const FIELDS: &[&str] = &[
6395 "key_required_larger",
6396 "keyRequiredLarger",
6397 "key_required_smaller",
6398 "keyRequiredSmaller",
6399 "clean_state",
6400 "cleanState",
6401 "delta_expression",
6402 "deltaExpression",
6403 ];
6404
6405 #[allow(clippy::enum_variant_names)]
6406 enum GeneratedField {
6407 KeyRequiredLarger,
6408 KeyRequiredSmaller,
6409 CleanState,
6410 DeltaExpression,
6411 }
6412 impl<'de> serde::Deserialize<'de> for GeneratedField {
6413 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6414 where
6415 D: serde::Deserializer<'de>,
6416 {
6417 struct GeneratedVisitor;
6418
6419 impl serde::de::Visitor<'_> for GeneratedVisitor {
6420 type Value = GeneratedField;
6421
6422 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6423 write!(formatter, "expected one of: {:?}", &FIELDS)
6424 }
6425
6426 #[allow(unused_variables)]
6427 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6428 where
6429 E: serde::de::Error,
6430 {
6431 match value {
6432 "keyRequiredLarger" | "key_required_larger" => Ok(GeneratedField::KeyRequiredLarger),
6433 "keyRequiredSmaller" | "key_required_smaller" => Ok(GeneratedField::KeyRequiredSmaller),
6434 "cleanState" | "clean_state" => Ok(GeneratedField::CleanState),
6435 "deltaExpression" | "delta_expression" => Ok(GeneratedField::DeltaExpression),
6436 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6437 }
6438 }
6439 }
6440 deserializer.deserialize_identifier(GeneratedVisitor)
6441 }
6442 }
6443 struct GeneratedVisitor;
6444 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6445 type Value = InequalityPair;
6446
6447 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6448 formatter.write_str("struct stream_plan.InequalityPair")
6449 }
6450
6451 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPair, V::Error>
6452 where
6453 V: serde::de::MapAccess<'de>,
6454 {
6455 let mut key_required_larger__ = None;
6456 let mut key_required_smaller__ = None;
6457 let mut clean_state__ = None;
6458 let mut delta_expression__ = None;
6459 while let Some(k) = map_.next_key()? {
6460 match k {
6461 GeneratedField::KeyRequiredLarger => {
6462 if key_required_larger__.is_some() {
6463 return Err(serde::de::Error::duplicate_field("keyRequiredLarger"));
6464 }
6465 key_required_larger__ =
6466 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6467 ;
6468 }
6469 GeneratedField::KeyRequiredSmaller => {
6470 if key_required_smaller__.is_some() {
6471 return Err(serde::de::Error::duplicate_field("keyRequiredSmaller"));
6472 }
6473 key_required_smaller__ =
6474 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6475 ;
6476 }
6477 GeneratedField::CleanState => {
6478 if clean_state__.is_some() {
6479 return Err(serde::de::Error::duplicate_field("cleanState"));
6480 }
6481 clean_state__ = Some(map_.next_value()?);
6482 }
6483 GeneratedField::DeltaExpression => {
6484 if delta_expression__.is_some() {
6485 return Err(serde::de::Error::duplicate_field("deltaExpression"));
6486 }
6487 delta_expression__ = map_.next_value()?;
6488 }
6489 }
6490 }
6491 Ok(InequalityPair {
6492 key_required_larger: key_required_larger__.unwrap_or_default(),
6493 key_required_smaller: key_required_smaller__.unwrap_or_default(),
6494 clean_state: clean_state__.unwrap_or_default(),
6495 delta_expression: delta_expression__,
6496 })
6497 }
6498 }
6499 deserializer.deserialize_struct("stream_plan.InequalityPair", FIELDS, GeneratedVisitor)
6500 }
6501}
6502impl serde::Serialize for InequalityPairV2 {
6503 #[allow(deprecated)]
6504 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6505 where
6506 S: serde::Serializer,
6507 {
6508 use serde::ser::SerializeStruct;
6509 let mut len = 0;
6510 if self.left_idx != 0 {
6511 len += 1;
6512 }
6513 if self.right_idx != 0 {
6514 len += 1;
6515 }
6516 if self.clean_left_state {
6517 len += 1;
6518 }
6519 if self.clean_right_state {
6520 len += 1;
6521 }
6522 if self.op != 0 {
6523 len += 1;
6524 }
6525 let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPairV2", len)?;
6526 if self.left_idx != 0 {
6527 struct_ser.serialize_field("leftIdx", &self.left_idx)?;
6528 }
6529 if self.right_idx != 0 {
6530 struct_ser.serialize_field("rightIdx", &self.right_idx)?;
6531 }
6532 if self.clean_left_state {
6533 struct_ser.serialize_field("cleanLeftState", &self.clean_left_state)?;
6534 }
6535 if self.clean_right_state {
6536 struct_ser.serialize_field("cleanRightState", &self.clean_right_state)?;
6537 }
6538 if self.op != 0 {
6539 let v = InequalityType::try_from(self.op)
6540 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.op)))?;
6541 struct_ser.serialize_field("op", &v)?;
6542 }
6543 struct_ser.end()
6544 }
6545}
6546impl<'de> serde::Deserialize<'de> for InequalityPairV2 {
6547 #[allow(deprecated)]
6548 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6549 where
6550 D: serde::Deserializer<'de>,
6551 {
6552 const FIELDS: &[&str] = &[
6553 "left_idx",
6554 "leftIdx",
6555 "right_idx",
6556 "rightIdx",
6557 "clean_left_state",
6558 "cleanLeftState",
6559 "clean_right_state",
6560 "cleanRightState",
6561 "op",
6562 ];
6563
6564 #[allow(clippy::enum_variant_names)]
6565 enum GeneratedField {
6566 LeftIdx,
6567 RightIdx,
6568 CleanLeftState,
6569 CleanRightState,
6570 Op,
6571 }
6572 impl<'de> serde::Deserialize<'de> for GeneratedField {
6573 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6574 where
6575 D: serde::Deserializer<'de>,
6576 {
6577 struct GeneratedVisitor;
6578
6579 impl serde::de::Visitor<'_> for GeneratedVisitor {
6580 type Value = GeneratedField;
6581
6582 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6583 write!(formatter, "expected one of: {:?}", &FIELDS)
6584 }
6585
6586 #[allow(unused_variables)]
6587 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6588 where
6589 E: serde::de::Error,
6590 {
6591 match value {
6592 "leftIdx" | "left_idx" => Ok(GeneratedField::LeftIdx),
6593 "rightIdx" | "right_idx" => Ok(GeneratedField::RightIdx),
6594 "cleanLeftState" | "clean_left_state" => Ok(GeneratedField::CleanLeftState),
6595 "cleanRightState" | "clean_right_state" => Ok(GeneratedField::CleanRightState),
6596 "op" => Ok(GeneratedField::Op),
6597 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6598 }
6599 }
6600 }
6601 deserializer.deserialize_identifier(GeneratedVisitor)
6602 }
6603 }
6604 struct GeneratedVisitor;
6605 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6606 type Value = InequalityPairV2;
6607
6608 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6609 formatter.write_str("struct stream_plan.InequalityPairV2")
6610 }
6611
6612 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPairV2, V::Error>
6613 where
6614 V: serde::de::MapAccess<'de>,
6615 {
6616 let mut left_idx__ = None;
6617 let mut right_idx__ = None;
6618 let mut clean_left_state__ = None;
6619 let mut clean_right_state__ = None;
6620 let mut op__ = None;
6621 while let Some(k) = map_.next_key()? {
6622 match k {
6623 GeneratedField::LeftIdx => {
6624 if left_idx__.is_some() {
6625 return Err(serde::de::Error::duplicate_field("leftIdx"));
6626 }
6627 left_idx__ =
6628 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6629 ;
6630 }
6631 GeneratedField::RightIdx => {
6632 if right_idx__.is_some() {
6633 return Err(serde::de::Error::duplicate_field("rightIdx"));
6634 }
6635 right_idx__ =
6636 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6637 ;
6638 }
6639 GeneratedField::CleanLeftState => {
6640 if clean_left_state__.is_some() {
6641 return Err(serde::de::Error::duplicate_field("cleanLeftState"));
6642 }
6643 clean_left_state__ = Some(map_.next_value()?);
6644 }
6645 GeneratedField::CleanRightState => {
6646 if clean_right_state__.is_some() {
6647 return Err(serde::de::Error::duplicate_field("cleanRightState"));
6648 }
6649 clean_right_state__ = Some(map_.next_value()?);
6650 }
6651 GeneratedField::Op => {
6652 if op__.is_some() {
6653 return Err(serde::de::Error::duplicate_field("op"));
6654 }
6655 op__ = Some(map_.next_value::<InequalityType>()? as i32);
6656 }
6657 }
6658 }
6659 Ok(InequalityPairV2 {
6660 left_idx: left_idx__.unwrap_or_default(),
6661 right_idx: right_idx__.unwrap_or_default(),
6662 clean_left_state: clean_left_state__.unwrap_or_default(),
6663 clean_right_state: clean_right_state__.unwrap_or_default(),
6664 op: op__.unwrap_or_default(),
6665 })
6666 }
6667 }
6668 deserializer.deserialize_struct("stream_plan.InequalityPairV2", FIELDS, GeneratedVisitor)
6669 }
6670}
6671impl serde::Serialize for InequalityType {
6672 #[allow(deprecated)]
6673 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6674 where
6675 S: serde::Serializer,
6676 {
6677 let variant = match self {
6678 Self::Unspecified => "INEQUALITY_TYPE_UNSPECIFIED",
6679 Self::LessThan => "INEQUALITY_TYPE_LESS_THAN",
6680 Self::LessThanOrEqual => "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL",
6681 Self::GreaterThan => "INEQUALITY_TYPE_GREATER_THAN",
6682 Self::GreaterThanOrEqual => "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL",
6683 };
6684 serializer.serialize_str(variant)
6685 }
6686}
6687impl<'de> serde::Deserialize<'de> for InequalityType {
6688 #[allow(deprecated)]
6689 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6690 where
6691 D: serde::Deserializer<'de>,
6692 {
6693 const FIELDS: &[&str] = &[
6694 "INEQUALITY_TYPE_UNSPECIFIED",
6695 "INEQUALITY_TYPE_LESS_THAN",
6696 "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL",
6697 "INEQUALITY_TYPE_GREATER_THAN",
6698 "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL",
6699 ];
6700
6701 struct GeneratedVisitor;
6702
6703 impl serde::de::Visitor<'_> for GeneratedVisitor {
6704 type Value = InequalityType;
6705
6706 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6707 write!(formatter, "expected one of: {:?}", &FIELDS)
6708 }
6709
6710 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6711 where
6712 E: serde::de::Error,
6713 {
6714 i32::try_from(v)
6715 .ok()
6716 .and_then(|x| x.try_into().ok())
6717 .ok_or_else(|| {
6718 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6719 })
6720 }
6721
6722 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6723 where
6724 E: serde::de::Error,
6725 {
6726 i32::try_from(v)
6727 .ok()
6728 .and_then(|x| x.try_into().ok())
6729 .ok_or_else(|| {
6730 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6731 })
6732 }
6733
6734 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6735 where
6736 E: serde::de::Error,
6737 {
6738 match value {
6739 "INEQUALITY_TYPE_UNSPECIFIED" => Ok(InequalityType::Unspecified),
6740 "INEQUALITY_TYPE_LESS_THAN" => Ok(InequalityType::LessThan),
6741 "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL" => Ok(InequalityType::LessThanOrEqual),
6742 "INEQUALITY_TYPE_GREATER_THAN" => Ok(InequalityType::GreaterThan),
6743 "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL" => Ok(InequalityType::GreaterThanOrEqual),
6744 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6745 }
6746 }
6747 }
6748 deserializer.deserialize_any(GeneratedVisitor)
6749 }
6750}
6751impl serde::Serialize for JoinEncodingType {
6752 #[allow(deprecated)]
6753 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6754 where
6755 S: serde::Serializer,
6756 {
6757 let variant = match self {
6758 Self::Unspecified => "UNSPECIFIED",
6759 Self::MemoryOptimized => "MEMORY_OPTIMIZED",
6760 Self::CpuOptimized => "CPU_OPTIMIZED",
6761 };
6762 serializer.serialize_str(variant)
6763 }
6764}
6765impl<'de> serde::Deserialize<'de> for JoinEncodingType {
6766 #[allow(deprecated)]
6767 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6768 where
6769 D: serde::Deserializer<'de>,
6770 {
6771 const FIELDS: &[&str] = &[
6772 "UNSPECIFIED",
6773 "MEMORY_OPTIMIZED",
6774 "CPU_OPTIMIZED",
6775 ];
6776
6777 struct GeneratedVisitor;
6778
6779 impl serde::de::Visitor<'_> for GeneratedVisitor {
6780 type Value = JoinEncodingType;
6781
6782 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6783 write!(formatter, "expected one of: {:?}", &FIELDS)
6784 }
6785
6786 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6787 where
6788 E: serde::de::Error,
6789 {
6790 i32::try_from(v)
6791 .ok()
6792 .and_then(|x| x.try_into().ok())
6793 .ok_or_else(|| {
6794 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6795 })
6796 }
6797
6798 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6799 where
6800 E: serde::de::Error,
6801 {
6802 i32::try_from(v)
6803 .ok()
6804 .and_then(|x| x.try_into().ok())
6805 .ok_or_else(|| {
6806 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6807 })
6808 }
6809
6810 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6811 where
6812 E: serde::de::Error,
6813 {
6814 match value {
6815 "UNSPECIFIED" => Ok(JoinEncodingType::Unspecified),
6816 "MEMORY_OPTIMIZED" => Ok(JoinEncodingType::MemoryOptimized),
6817 "CPU_OPTIMIZED" => Ok(JoinEncodingType::CpuOptimized),
6818 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6819 }
6820 }
6821 }
6822 deserializer.deserialize_any(GeneratedVisitor)
6823 }
6824}
6825impl serde::Serialize for ListFinishMutation {
6826 #[allow(deprecated)]
6827 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6828 where
6829 S: serde::Serializer,
6830 {
6831 use serde::ser::SerializeStruct;
6832 let mut len = 0;
6833 if self.associated_source_id != 0 {
6834 len += 1;
6835 }
6836 let mut struct_ser = serializer.serialize_struct("stream_plan.ListFinishMutation", len)?;
6837 if self.associated_source_id != 0 {
6838 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
6839 }
6840 struct_ser.end()
6841 }
6842}
6843impl<'de> serde::Deserialize<'de> for ListFinishMutation {
6844 #[allow(deprecated)]
6845 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6846 where
6847 D: serde::Deserializer<'de>,
6848 {
6849 const FIELDS: &[&str] = &[
6850 "associated_source_id",
6851 "associatedSourceId",
6852 ];
6853
6854 #[allow(clippy::enum_variant_names)]
6855 enum GeneratedField {
6856 AssociatedSourceId,
6857 }
6858 impl<'de> serde::Deserialize<'de> for GeneratedField {
6859 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6860 where
6861 D: serde::Deserializer<'de>,
6862 {
6863 struct GeneratedVisitor;
6864
6865 impl serde::de::Visitor<'_> for GeneratedVisitor {
6866 type Value = GeneratedField;
6867
6868 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6869 write!(formatter, "expected one of: {:?}", &FIELDS)
6870 }
6871
6872 #[allow(unused_variables)]
6873 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6874 where
6875 E: serde::de::Error,
6876 {
6877 match value {
6878 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
6879 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6880 }
6881 }
6882 }
6883 deserializer.deserialize_identifier(GeneratedVisitor)
6884 }
6885 }
6886 struct GeneratedVisitor;
6887 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6888 type Value = ListFinishMutation;
6889
6890 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6891 formatter.write_str("struct stream_plan.ListFinishMutation")
6892 }
6893
6894 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFinishMutation, V::Error>
6895 where
6896 V: serde::de::MapAccess<'de>,
6897 {
6898 let mut associated_source_id__ = None;
6899 while let Some(k) = map_.next_key()? {
6900 match k {
6901 GeneratedField::AssociatedSourceId => {
6902 if associated_source_id__.is_some() {
6903 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
6904 }
6905 associated_source_id__ =
6906 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6907 ;
6908 }
6909 }
6910 }
6911 Ok(ListFinishMutation {
6912 associated_source_id: associated_source_id__.unwrap_or_default(),
6913 })
6914 }
6915 }
6916 deserializer.deserialize_struct("stream_plan.ListFinishMutation", FIELDS, GeneratedVisitor)
6917 }
6918}
6919impl serde::Serialize for LoadFinishMutation {
6920 #[allow(deprecated)]
6921 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6922 where
6923 S: serde::Serializer,
6924 {
6925 use serde::ser::SerializeStruct;
6926 let mut len = 0;
6927 if self.associated_source_id != 0 {
6928 len += 1;
6929 }
6930 let mut struct_ser = serializer.serialize_struct("stream_plan.LoadFinishMutation", len)?;
6931 if self.associated_source_id != 0 {
6932 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
6933 }
6934 struct_ser.end()
6935 }
6936}
6937impl<'de> serde::Deserialize<'de> for LoadFinishMutation {
6938 #[allow(deprecated)]
6939 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6940 where
6941 D: serde::Deserializer<'de>,
6942 {
6943 const FIELDS: &[&str] = &[
6944 "associated_source_id",
6945 "associatedSourceId",
6946 ];
6947
6948 #[allow(clippy::enum_variant_names)]
6949 enum GeneratedField {
6950 AssociatedSourceId,
6951 }
6952 impl<'de> serde::Deserialize<'de> for GeneratedField {
6953 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6954 where
6955 D: serde::Deserializer<'de>,
6956 {
6957 struct GeneratedVisitor;
6958
6959 impl serde::de::Visitor<'_> for GeneratedVisitor {
6960 type Value = GeneratedField;
6961
6962 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6963 write!(formatter, "expected one of: {:?}", &FIELDS)
6964 }
6965
6966 #[allow(unused_variables)]
6967 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6968 where
6969 E: serde::de::Error,
6970 {
6971 match value {
6972 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
6973 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6974 }
6975 }
6976 }
6977 deserializer.deserialize_identifier(GeneratedVisitor)
6978 }
6979 }
6980 struct GeneratedVisitor;
6981 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6982 type Value = LoadFinishMutation;
6983
6984 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6985 formatter.write_str("struct stream_plan.LoadFinishMutation")
6986 }
6987
6988 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LoadFinishMutation, V::Error>
6989 where
6990 V: serde::de::MapAccess<'de>,
6991 {
6992 let mut associated_source_id__ = None;
6993 while let Some(k) = map_.next_key()? {
6994 match k {
6995 GeneratedField::AssociatedSourceId => {
6996 if associated_source_id__.is_some() {
6997 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
6998 }
6999 associated_source_id__ =
7000 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7001 ;
7002 }
7003 }
7004 }
7005 Ok(LoadFinishMutation {
7006 associated_source_id: associated_source_id__.unwrap_or_default(),
7007 })
7008 }
7009 }
7010 deserializer.deserialize_struct("stream_plan.LoadFinishMutation", FIELDS, GeneratedVisitor)
7011 }
7012}
7013impl serde::Serialize for LocalApproxPercentileNode {
7014 #[allow(deprecated)]
7015 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7016 where
7017 S: serde::Serializer,
7018 {
7019 use serde::ser::SerializeStruct;
7020 let mut len = 0;
7021 if self.base != 0. {
7022 len += 1;
7023 }
7024 if self.percentile_index != 0 {
7025 len += 1;
7026 }
7027 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalApproxPercentileNode", len)?;
7028 if self.base != 0. {
7029 struct_ser.serialize_field("base", &self.base)?;
7030 }
7031 if self.percentile_index != 0 {
7032 struct_ser.serialize_field("percentileIndex", &self.percentile_index)?;
7033 }
7034 struct_ser.end()
7035 }
7036}
7037impl<'de> serde::Deserialize<'de> for LocalApproxPercentileNode {
7038 #[allow(deprecated)]
7039 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7040 where
7041 D: serde::Deserializer<'de>,
7042 {
7043 const FIELDS: &[&str] = &[
7044 "base",
7045 "percentile_index",
7046 "percentileIndex",
7047 ];
7048
7049 #[allow(clippy::enum_variant_names)]
7050 enum GeneratedField {
7051 Base,
7052 PercentileIndex,
7053 }
7054 impl<'de> serde::Deserialize<'de> for GeneratedField {
7055 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7056 where
7057 D: serde::Deserializer<'de>,
7058 {
7059 struct GeneratedVisitor;
7060
7061 impl serde::de::Visitor<'_> for GeneratedVisitor {
7062 type Value = GeneratedField;
7063
7064 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7065 write!(formatter, "expected one of: {:?}", &FIELDS)
7066 }
7067
7068 #[allow(unused_variables)]
7069 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7070 where
7071 E: serde::de::Error,
7072 {
7073 match value {
7074 "base" => Ok(GeneratedField::Base),
7075 "percentileIndex" | "percentile_index" => Ok(GeneratedField::PercentileIndex),
7076 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7077 }
7078 }
7079 }
7080 deserializer.deserialize_identifier(GeneratedVisitor)
7081 }
7082 }
7083 struct GeneratedVisitor;
7084 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7085 type Value = LocalApproxPercentileNode;
7086
7087 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7088 formatter.write_str("struct stream_plan.LocalApproxPercentileNode")
7089 }
7090
7091 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalApproxPercentileNode, V::Error>
7092 where
7093 V: serde::de::MapAccess<'de>,
7094 {
7095 let mut base__ = None;
7096 let mut percentile_index__ = None;
7097 while let Some(k) = map_.next_key()? {
7098 match k {
7099 GeneratedField::Base => {
7100 if base__.is_some() {
7101 return Err(serde::de::Error::duplicate_field("base"));
7102 }
7103 base__ =
7104 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7105 ;
7106 }
7107 GeneratedField::PercentileIndex => {
7108 if percentile_index__.is_some() {
7109 return Err(serde::de::Error::duplicate_field("percentileIndex"));
7110 }
7111 percentile_index__ =
7112 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7113 ;
7114 }
7115 }
7116 }
7117 Ok(LocalApproxPercentileNode {
7118 base: base__.unwrap_or_default(),
7119 percentile_index: percentile_index__.unwrap_or_default(),
7120 })
7121 }
7122 }
7123 deserializer.deserialize_struct("stream_plan.LocalApproxPercentileNode", FIELDS, GeneratedVisitor)
7124 }
7125}
7126impl serde::Serialize for LocalityProviderNode {
7127 #[allow(deprecated)]
7128 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7129 where
7130 S: serde::Serializer,
7131 {
7132 use serde::ser::SerializeStruct;
7133 let mut len = 0;
7134 if !self.locality_columns.is_empty() {
7135 len += 1;
7136 }
7137 if self.state_table.is_some() {
7138 len += 1;
7139 }
7140 if self.progress_table.is_some() {
7141 len += 1;
7142 }
7143 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalityProviderNode", len)?;
7144 if !self.locality_columns.is_empty() {
7145 struct_ser.serialize_field("localityColumns", &self.locality_columns)?;
7146 }
7147 if let Some(v) = self.state_table.as_ref() {
7148 struct_ser.serialize_field("stateTable", v)?;
7149 }
7150 if let Some(v) = self.progress_table.as_ref() {
7151 struct_ser.serialize_field("progressTable", v)?;
7152 }
7153 struct_ser.end()
7154 }
7155}
7156impl<'de> serde::Deserialize<'de> for LocalityProviderNode {
7157 #[allow(deprecated)]
7158 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7159 where
7160 D: serde::Deserializer<'de>,
7161 {
7162 const FIELDS: &[&str] = &[
7163 "locality_columns",
7164 "localityColumns",
7165 "state_table",
7166 "stateTable",
7167 "progress_table",
7168 "progressTable",
7169 ];
7170
7171 #[allow(clippy::enum_variant_names)]
7172 enum GeneratedField {
7173 LocalityColumns,
7174 StateTable,
7175 ProgressTable,
7176 }
7177 impl<'de> serde::Deserialize<'de> for GeneratedField {
7178 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7179 where
7180 D: serde::Deserializer<'de>,
7181 {
7182 struct GeneratedVisitor;
7183
7184 impl serde::de::Visitor<'_> for GeneratedVisitor {
7185 type Value = GeneratedField;
7186
7187 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7188 write!(formatter, "expected one of: {:?}", &FIELDS)
7189 }
7190
7191 #[allow(unused_variables)]
7192 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7193 where
7194 E: serde::de::Error,
7195 {
7196 match value {
7197 "localityColumns" | "locality_columns" => Ok(GeneratedField::LocalityColumns),
7198 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7199 "progressTable" | "progress_table" => Ok(GeneratedField::ProgressTable),
7200 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7201 }
7202 }
7203 }
7204 deserializer.deserialize_identifier(GeneratedVisitor)
7205 }
7206 }
7207 struct GeneratedVisitor;
7208 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7209 type Value = LocalityProviderNode;
7210
7211 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7212 formatter.write_str("struct stream_plan.LocalityProviderNode")
7213 }
7214
7215 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalityProviderNode, V::Error>
7216 where
7217 V: serde::de::MapAccess<'de>,
7218 {
7219 let mut locality_columns__ = None;
7220 let mut state_table__ = None;
7221 let mut progress_table__ = None;
7222 while let Some(k) = map_.next_key()? {
7223 match k {
7224 GeneratedField::LocalityColumns => {
7225 if locality_columns__.is_some() {
7226 return Err(serde::de::Error::duplicate_field("localityColumns"));
7227 }
7228 locality_columns__ =
7229 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7230 .into_iter().map(|x| x.0).collect())
7231 ;
7232 }
7233 GeneratedField::StateTable => {
7234 if state_table__.is_some() {
7235 return Err(serde::de::Error::duplicate_field("stateTable"));
7236 }
7237 state_table__ = map_.next_value()?;
7238 }
7239 GeneratedField::ProgressTable => {
7240 if progress_table__.is_some() {
7241 return Err(serde::de::Error::duplicate_field("progressTable"));
7242 }
7243 progress_table__ = map_.next_value()?;
7244 }
7245 }
7246 }
7247 Ok(LocalityProviderNode {
7248 locality_columns: locality_columns__.unwrap_or_default(),
7249 state_table: state_table__,
7250 progress_table: progress_table__,
7251 })
7252 }
7253 }
7254 deserializer.deserialize_struct("stream_plan.LocalityProviderNode", FIELDS, GeneratedVisitor)
7255 }
7256}
7257impl serde::Serialize for LookupNode {
7258 #[allow(deprecated)]
7259 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7260 where
7261 S: serde::Serializer,
7262 {
7263 use serde::ser::SerializeStruct;
7264 let mut len = 0;
7265 if !self.arrange_key.is_empty() {
7266 len += 1;
7267 }
7268 if !self.stream_key.is_empty() {
7269 len += 1;
7270 }
7271 if self.use_current_epoch {
7272 len += 1;
7273 }
7274 if !self.column_mapping.is_empty() {
7275 len += 1;
7276 }
7277 if self.arrangement_table_info.is_some() {
7278 len += 1;
7279 }
7280 if self.arrangement_table_id.is_some() {
7281 len += 1;
7282 }
7283 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupNode", len)?;
7284 if !self.arrange_key.is_empty() {
7285 struct_ser.serialize_field("arrangeKey", &self.arrange_key)?;
7286 }
7287 if !self.stream_key.is_empty() {
7288 struct_ser.serialize_field("streamKey", &self.stream_key)?;
7289 }
7290 if self.use_current_epoch {
7291 struct_ser.serialize_field("useCurrentEpoch", &self.use_current_epoch)?;
7292 }
7293 if !self.column_mapping.is_empty() {
7294 struct_ser.serialize_field("columnMapping", &self.column_mapping)?;
7295 }
7296 if let Some(v) = self.arrangement_table_info.as_ref() {
7297 struct_ser.serialize_field("arrangementTableInfo", v)?;
7298 }
7299 if let Some(v) = self.arrangement_table_id.as_ref() {
7300 match v {
7301 lookup_node::ArrangementTableId::TableId(v) => {
7302 struct_ser.serialize_field("tableId", v)?;
7303 }
7304 lookup_node::ArrangementTableId::IndexId(v) => {
7305 struct_ser.serialize_field("indexId", v)?;
7306 }
7307 }
7308 }
7309 struct_ser.end()
7310 }
7311}
7312impl<'de> serde::Deserialize<'de> for LookupNode {
7313 #[allow(deprecated)]
7314 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7315 where
7316 D: serde::Deserializer<'de>,
7317 {
7318 const FIELDS: &[&str] = &[
7319 "arrange_key",
7320 "arrangeKey",
7321 "stream_key",
7322 "streamKey",
7323 "use_current_epoch",
7324 "useCurrentEpoch",
7325 "column_mapping",
7326 "columnMapping",
7327 "arrangement_table_info",
7328 "arrangementTableInfo",
7329 "table_id",
7330 "tableId",
7331 "index_id",
7332 "indexId",
7333 ];
7334
7335 #[allow(clippy::enum_variant_names)]
7336 enum GeneratedField {
7337 ArrangeKey,
7338 StreamKey,
7339 UseCurrentEpoch,
7340 ColumnMapping,
7341 ArrangementTableInfo,
7342 TableId,
7343 IndexId,
7344 }
7345 impl<'de> serde::Deserialize<'de> for GeneratedField {
7346 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7347 where
7348 D: serde::Deserializer<'de>,
7349 {
7350 struct GeneratedVisitor;
7351
7352 impl serde::de::Visitor<'_> for GeneratedVisitor {
7353 type Value = GeneratedField;
7354
7355 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7356 write!(formatter, "expected one of: {:?}", &FIELDS)
7357 }
7358
7359 #[allow(unused_variables)]
7360 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7361 where
7362 E: serde::de::Error,
7363 {
7364 match value {
7365 "arrangeKey" | "arrange_key" => Ok(GeneratedField::ArrangeKey),
7366 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
7367 "useCurrentEpoch" | "use_current_epoch" => Ok(GeneratedField::UseCurrentEpoch),
7368 "columnMapping" | "column_mapping" => Ok(GeneratedField::ColumnMapping),
7369 "arrangementTableInfo" | "arrangement_table_info" => Ok(GeneratedField::ArrangementTableInfo),
7370 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7371 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
7372 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7373 }
7374 }
7375 }
7376 deserializer.deserialize_identifier(GeneratedVisitor)
7377 }
7378 }
7379 struct GeneratedVisitor;
7380 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7381 type Value = LookupNode;
7382
7383 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7384 formatter.write_str("struct stream_plan.LookupNode")
7385 }
7386
7387 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupNode, V::Error>
7388 where
7389 V: serde::de::MapAccess<'de>,
7390 {
7391 let mut arrange_key__ = None;
7392 let mut stream_key__ = None;
7393 let mut use_current_epoch__ = None;
7394 let mut column_mapping__ = None;
7395 let mut arrangement_table_info__ = None;
7396 let mut arrangement_table_id__ = None;
7397 while let Some(k) = map_.next_key()? {
7398 match k {
7399 GeneratedField::ArrangeKey => {
7400 if arrange_key__.is_some() {
7401 return Err(serde::de::Error::duplicate_field("arrangeKey"));
7402 }
7403 arrange_key__ =
7404 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7405 .into_iter().map(|x| x.0).collect())
7406 ;
7407 }
7408 GeneratedField::StreamKey => {
7409 if stream_key__.is_some() {
7410 return Err(serde::de::Error::duplicate_field("streamKey"));
7411 }
7412 stream_key__ =
7413 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7414 .into_iter().map(|x| x.0).collect())
7415 ;
7416 }
7417 GeneratedField::UseCurrentEpoch => {
7418 if use_current_epoch__.is_some() {
7419 return Err(serde::de::Error::duplicate_field("useCurrentEpoch"));
7420 }
7421 use_current_epoch__ = Some(map_.next_value()?);
7422 }
7423 GeneratedField::ColumnMapping => {
7424 if column_mapping__.is_some() {
7425 return Err(serde::de::Error::duplicate_field("columnMapping"));
7426 }
7427 column_mapping__ =
7428 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7429 .into_iter().map(|x| x.0).collect())
7430 ;
7431 }
7432 GeneratedField::ArrangementTableInfo => {
7433 if arrangement_table_info__.is_some() {
7434 return Err(serde::de::Error::duplicate_field("arrangementTableInfo"));
7435 }
7436 arrangement_table_info__ = map_.next_value()?;
7437 }
7438 GeneratedField::TableId => {
7439 if arrangement_table_id__.is_some() {
7440 return Err(serde::de::Error::duplicate_field("tableId"));
7441 }
7442 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::TableId(x.0));
7443 }
7444 GeneratedField::IndexId => {
7445 if arrangement_table_id__.is_some() {
7446 return Err(serde::de::Error::duplicate_field("indexId"));
7447 }
7448 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::IndexId(x.0));
7449 }
7450 }
7451 }
7452 Ok(LookupNode {
7453 arrange_key: arrange_key__.unwrap_or_default(),
7454 stream_key: stream_key__.unwrap_or_default(),
7455 use_current_epoch: use_current_epoch__.unwrap_or_default(),
7456 column_mapping: column_mapping__.unwrap_or_default(),
7457 arrangement_table_info: arrangement_table_info__,
7458 arrangement_table_id: arrangement_table_id__,
7459 })
7460 }
7461 }
7462 deserializer.deserialize_struct("stream_plan.LookupNode", FIELDS, GeneratedVisitor)
7463 }
7464}
7465impl serde::Serialize for LookupUnionNode {
7466 #[allow(deprecated)]
7467 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7468 where
7469 S: serde::Serializer,
7470 {
7471 use serde::ser::SerializeStruct;
7472 let mut len = 0;
7473 if !self.order.is_empty() {
7474 len += 1;
7475 }
7476 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupUnionNode", len)?;
7477 if !self.order.is_empty() {
7478 struct_ser.serialize_field("order", &self.order)?;
7479 }
7480 struct_ser.end()
7481 }
7482}
7483impl<'de> serde::Deserialize<'de> for LookupUnionNode {
7484 #[allow(deprecated)]
7485 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7486 where
7487 D: serde::Deserializer<'de>,
7488 {
7489 const FIELDS: &[&str] = &[
7490 "order",
7491 ];
7492
7493 #[allow(clippy::enum_variant_names)]
7494 enum GeneratedField {
7495 Order,
7496 }
7497 impl<'de> serde::Deserialize<'de> for GeneratedField {
7498 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7499 where
7500 D: serde::Deserializer<'de>,
7501 {
7502 struct GeneratedVisitor;
7503
7504 impl serde::de::Visitor<'_> for GeneratedVisitor {
7505 type Value = GeneratedField;
7506
7507 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7508 write!(formatter, "expected one of: {:?}", &FIELDS)
7509 }
7510
7511 #[allow(unused_variables)]
7512 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7513 where
7514 E: serde::de::Error,
7515 {
7516 match value {
7517 "order" => Ok(GeneratedField::Order),
7518 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7519 }
7520 }
7521 }
7522 deserializer.deserialize_identifier(GeneratedVisitor)
7523 }
7524 }
7525 struct GeneratedVisitor;
7526 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7527 type Value = LookupUnionNode;
7528
7529 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7530 formatter.write_str("struct stream_plan.LookupUnionNode")
7531 }
7532
7533 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupUnionNode, V::Error>
7534 where
7535 V: serde::de::MapAccess<'de>,
7536 {
7537 let mut order__ = None;
7538 while let Some(k) = map_.next_key()? {
7539 match k {
7540 GeneratedField::Order => {
7541 if order__.is_some() {
7542 return Err(serde::de::Error::duplicate_field("order"));
7543 }
7544 order__ =
7545 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7546 .into_iter().map(|x| x.0).collect())
7547 ;
7548 }
7549 }
7550 }
7551 Ok(LookupUnionNode {
7552 order: order__.unwrap_or_default(),
7553 })
7554 }
7555 }
7556 deserializer.deserialize_struct("stream_plan.LookupUnionNode", FIELDS, GeneratedVisitor)
7557 }
7558}
7559impl serde::Serialize for MaterializeNode {
7560 #[allow(deprecated)]
7561 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7562 where
7563 S: serde::Serializer,
7564 {
7565 use serde::ser::SerializeStruct;
7566 let mut len = 0;
7567 if self.table_id != 0 {
7568 len += 1;
7569 }
7570 if !self.column_orders.is_empty() {
7571 len += 1;
7572 }
7573 if self.table.is_some() {
7574 len += 1;
7575 }
7576 if self.staging_table.is_some() {
7577 len += 1;
7578 }
7579 if self.refresh_progress_table.is_some() {
7580 len += 1;
7581 }
7582 if self.cleaned_by_ttl_watermark {
7583 len += 1;
7584 }
7585 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializeNode", len)?;
7586 if self.table_id != 0 {
7587 struct_ser.serialize_field("tableId", &self.table_id)?;
7588 }
7589 if !self.column_orders.is_empty() {
7590 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
7591 }
7592 if let Some(v) = self.table.as_ref() {
7593 struct_ser.serialize_field("table", v)?;
7594 }
7595 if let Some(v) = self.staging_table.as_ref() {
7596 struct_ser.serialize_field("stagingTable", v)?;
7597 }
7598 if let Some(v) = self.refresh_progress_table.as_ref() {
7599 struct_ser.serialize_field("refreshProgressTable", v)?;
7600 }
7601 if self.cleaned_by_ttl_watermark {
7602 struct_ser.serialize_field("cleanedByTtlWatermark", &self.cleaned_by_ttl_watermark)?;
7603 }
7604 struct_ser.end()
7605 }
7606}
7607impl<'de> serde::Deserialize<'de> for MaterializeNode {
7608 #[allow(deprecated)]
7609 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7610 where
7611 D: serde::Deserializer<'de>,
7612 {
7613 const FIELDS: &[&str] = &[
7614 "table_id",
7615 "tableId",
7616 "column_orders",
7617 "columnOrders",
7618 "table",
7619 "staging_table",
7620 "stagingTable",
7621 "refresh_progress_table",
7622 "refreshProgressTable",
7623 "cleaned_by_ttl_watermark",
7624 "cleanedByTtlWatermark",
7625 ];
7626
7627 #[allow(clippy::enum_variant_names)]
7628 enum GeneratedField {
7629 TableId,
7630 ColumnOrders,
7631 Table,
7632 StagingTable,
7633 RefreshProgressTable,
7634 CleanedByTtlWatermark,
7635 }
7636 impl<'de> serde::Deserialize<'de> for GeneratedField {
7637 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7638 where
7639 D: serde::Deserializer<'de>,
7640 {
7641 struct GeneratedVisitor;
7642
7643 impl serde::de::Visitor<'_> for GeneratedVisitor {
7644 type Value = GeneratedField;
7645
7646 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7647 write!(formatter, "expected one of: {:?}", &FIELDS)
7648 }
7649
7650 #[allow(unused_variables)]
7651 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7652 where
7653 E: serde::de::Error,
7654 {
7655 match value {
7656 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7657 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
7658 "table" => Ok(GeneratedField::Table),
7659 "stagingTable" | "staging_table" => Ok(GeneratedField::StagingTable),
7660 "refreshProgressTable" | "refresh_progress_table" => Ok(GeneratedField::RefreshProgressTable),
7661 "cleanedByTtlWatermark" | "cleaned_by_ttl_watermark" => Ok(GeneratedField::CleanedByTtlWatermark),
7662 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7663 }
7664 }
7665 }
7666 deserializer.deserialize_identifier(GeneratedVisitor)
7667 }
7668 }
7669 struct GeneratedVisitor;
7670 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7671 type Value = MaterializeNode;
7672
7673 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7674 formatter.write_str("struct stream_plan.MaterializeNode")
7675 }
7676
7677 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializeNode, V::Error>
7678 where
7679 V: serde::de::MapAccess<'de>,
7680 {
7681 let mut table_id__ = None;
7682 let mut column_orders__ = None;
7683 let mut table__ = None;
7684 let mut staging_table__ = None;
7685 let mut refresh_progress_table__ = None;
7686 let mut cleaned_by_ttl_watermark__ = None;
7687 while let Some(k) = map_.next_key()? {
7688 match k {
7689 GeneratedField::TableId => {
7690 if table_id__.is_some() {
7691 return Err(serde::de::Error::duplicate_field("tableId"));
7692 }
7693 table_id__ =
7694 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7695 ;
7696 }
7697 GeneratedField::ColumnOrders => {
7698 if column_orders__.is_some() {
7699 return Err(serde::de::Error::duplicate_field("columnOrders"));
7700 }
7701 column_orders__ = Some(map_.next_value()?);
7702 }
7703 GeneratedField::Table => {
7704 if table__.is_some() {
7705 return Err(serde::de::Error::duplicate_field("table"));
7706 }
7707 table__ = map_.next_value()?;
7708 }
7709 GeneratedField::StagingTable => {
7710 if staging_table__.is_some() {
7711 return Err(serde::de::Error::duplicate_field("stagingTable"));
7712 }
7713 staging_table__ = map_.next_value()?;
7714 }
7715 GeneratedField::RefreshProgressTable => {
7716 if refresh_progress_table__.is_some() {
7717 return Err(serde::de::Error::duplicate_field("refreshProgressTable"));
7718 }
7719 refresh_progress_table__ = map_.next_value()?;
7720 }
7721 GeneratedField::CleanedByTtlWatermark => {
7722 if cleaned_by_ttl_watermark__.is_some() {
7723 return Err(serde::de::Error::duplicate_field("cleanedByTtlWatermark"));
7724 }
7725 cleaned_by_ttl_watermark__ = Some(map_.next_value()?);
7726 }
7727 }
7728 }
7729 Ok(MaterializeNode {
7730 table_id: table_id__.unwrap_or_default(),
7731 column_orders: column_orders__.unwrap_or_default(),
7732 table: table__,
7733 staging_table: staging_table__,
7734 refresh_progress_table: refresh_progress_table__,
7735 cleaned_by_ttl_watermark: cleaned_by_ttl_watermark__.unwrap_or_default(),
7736 })
7737 }
7738 }
7739 deserializer.deserialize_struct("stream_plan.MaterializeNode", FIELDS, GeneratedVisitor)
7740 }
7741}
7742impl serde::Serialize for MaterializedExprsNode {
7743 #[allow(deprecated)]
7744 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7745 where
7746 S: serde::Serializer,
7747 {
7748 use serde::ser::SerializeStruct;
7749 let mut len = 0;
7750 if !self.exprs.is_empty() {
7751 len += 1;
7752 }
7753 if self.state_table.is_some() {
7754 len += 1;
7755 }
7756 if self.state_clean_col_idx.is_some() {
7757 len += 1;
7758 }
7759 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializedExprsNode", len)?;
7760 if !self.exprs.is_empty() {
7761 struct_ser.serialize_field("exprs", &self.exprs)?;
7762 }
7763 if let Some(v) = self.state_table.as_ref() {
7764 struct_ser.serialize_field("stateTable", v)?;
7765 }
7766 if let Some(v) = self.state_clean_col_idx.as_ref() {
7767 struct_ser.serialize_field("stateCleanColIdx", v)?;
7768 }
7769 struct_ser.end()
7770 }
7771}
7772impl<'de> serde::Deserialize<'de> for MaterializedExprsNode {
7773 #[allow(deprecated)]
7774 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7775 where
7776 D: serde::Deserializer<'de>,
7777 {
7778 const FIELDS: &[&str] = &[
7779 "exprs",
7780 "state_table",
7781 "stateTable",
7782 "state_clean_col_idx",
7783 "stateCleanColIdx",
7784 ];
7785
7786 #[allow(clippy::enum_variant_names)]
7787 enum GeneratedField {
7788 Exprs,
7789 StateTable,
7790 StateCleanColIdx,
7791 }
7792 impl<'de> serde::Deserialize<'de> for GeneratedField {
7793 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7794 where
7795 D: serde::Deserializer<'de>,
7796 {
7797 struct GeneratedVisitor;
7798
7799 impl serde::de::Visitor<'_> for GeneratedVisitor {
7800 type Value = GeneratedField;
7801
7802 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7803 write!(formatter, "expected one of: {:?}", &FIELDS)
7804 }
7805
7806 #[allow(unused_variables)]
7807 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7808 where
7809 E: serde::de::Error,
7810 {
7811 match value {
7812 "exprs" => Ok(GeneratedField::Exprs),
7813 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7814 "stateCleanColIdx" | "state_clean_col_idx" => Ok(GeneratedField::StateCleanColIdx),
7815 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7816 }
7817 }
7818 }
7819 deserializer.deserialize_identifier(GeneratedVisitor)
7820 }
7821 }
7822 struct GeneratedVisitor;
7823 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7824 type Value = MaterializedExprsNode;
7825
7826 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7827 formatter.write_str("struct stream_plan.MaterializedExprsNode")
7828 }
7829
7830 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializedExprsNode, V::Error>
7831 where
7832 V: serde::de::MapAccess<'de>,
7833 {
7834 let mut exprs__ = None;
7835 let mut state_table__ = None;
7836 let mut state_clean_col_idx__ = None;
7837 while let Some(k) = map_.next_key()? {
7838 match k {
7839 GeneratedField::Exprs => {
7840 if exprs__.is_some() {
7841 return Err(serde::de::Error::duplicate_field("exprs"));
7842 }
7843 exprs__ = Some(map_.next_value()?);
7844 }
7845 GeneratedField::StateTable => {
7846 if state_table__.is_some() {
7847 return Err(serde::de::Error::duplicate_field("stateTable"));
7848 }
7849 state_table__ = map_.next_value()?;
7850 }
7851 GeneratedField::StateCleanColIdx => {
7852 if state_clean_col_idx__.is_some() {
7853 return Err(serde::de::Error::duplicate_field("stateCleanColIdx"));
7854 }
7855 state_clean_col_idx__ =
7856 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
7857 ;
7858 }
7859 }
7860 }
7861 Ok(MaterializedExprsNode {
7862 exprs: exprs__.unwrap_or_default(),
7863 state_table: state_table__,
7864 state_clean_col_idx: state_clean_col_idx__,
7865 })
7866 }
7867 }
7868 deserializer.deserialize_struct("stream_plan.MaterializedExprsNode", FIELDS, GeneratedVisitor)
7869 }
7870}
7871impl serde::Serialize for MergeNode {
7872 #[allow(deprecated)]
7873 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7874 where
7875 S: serde::Serializer,
7876 {
7877 use serde::ser::SerializeStruct;
7878 let mut len = 0;
7879 if !self.upstream_actor_id.is_empty() {
7880 len += 1;
7881 }
7882 if self.upstream_fragment_id != 0 {
7883 len += 1;
7884 }
7885 if self.upstream_dispatcher_type != 0 {
7886 len += 1;
7887 }
7888 if !self.fields.is_empty() {
7889 len += 1;
7890 }
7891 let mut struct_ser = serializer.serialize_struct("stream_plan.MergeNode", len)?;
7892 if !self.upstream_actor_id.is_empty() {
7893 struct_ser.serialize_field("upstreamActorId", &self.upstream_actor_id)?;
7894 }
7895 if self.upstream_fragment_id != 0 {
7896 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
7897 }
7898 if self.upstream_dispatcher_type != 0 {
7899 let v = DispatcherType::try_from(self.upstream_dispatcher_type)
7900 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.upstream_dispatcher_type)))?;
7901 struct_ser.serialize_field("upstreamDispatcherType", &v)?;
7902 }
7903 if !self.fields.is_empty() {
7904 struct_ser.serialize_field("fields", &self.fields)?;
7905 }
7906 struct_ser.end()
7907 }
7908}
7909impl<'de> serde::Deserialize<'de> for MergeNode {
7910 #[allow(deprecated)]
7911 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7912 where
7913 D: serde::Deserializer<'de>,
7914 {
7915 const FIELDS: &[&str] = &[
7916 "upstream_actor_id",
7917 "upstreamActorId",
7918 "upstream_fragment_id",
7919 "upstreamFragmentId",
7920 "upstream_dispatcher_type",
7921 "upstreamDispatcherType",
7922 "fields",
7923 ];
7924
7925 #[allow(clippy::enum_variant_names)]
7926 enum GeneratedField {
7927 UpstreamActorId,
7928 UpstreamFragmentId,
7929 UpstreamDispatcherType,
7930 Fields,
7931 }
7932 impl<'de> serde::Deserialize<'de> for GeneratedField {
7933 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7934 where
7935 D: serde::Deserializer<'de>,
7936 {
7937 struct GeneratedVisitor;
7938
7939 impl serde::de::Visitor<'_> for GeneratedVisitor {
7940 type Value = GeneratedField;
7941
7942 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7943 write!(formatter, "expected one of: {:?}", &FIELDS)
7944 }
7945
7946 #[allow(unused_variables)]
7947 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7948 where
7949 E: serde::de::Error,
7950 {
7951 match value {
7952 "upstreamActorId" | "upstream_actor_id" => Ok(GeneratedField::UpstreamActorId),
7953 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
7954 "upstreamDispatcherType" | "upstream_dispatcher_type" => Ok(GeneratedField::UpstreamDispatcherType),
7955 "fields" => Ok(GeneratedField::Fields),
7956 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7957 }
7958 }
7959 }
7960 deserializer.deserialize_identifier(GeneratedVisitor)
7961 }
7962 }
7963 struct GeneratedVisitor;
7964 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7965 type Value = MergeNode;
7966
7967 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7968 formatter.write_str("struct stream_plan.MergeNode")
7969 }
7970
7971 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeNode, V::Error>
7972 where
7973 V: serde::de::MapAccess<'de>,
7974 {
7975 let mut upstream_actor_id__ = None;
7976 let mut upstream_fragment_id__ = None;
7977 let mut upstream_dispatcher_type__ = None;
7978 let mut fields__ = None;
7979 while let Some(k) = map_.next_key()? {
7980 match k {
7981 GeneratedField::UpstreamActorId => {
7982 if upstream_actor_id__.is_some() {
7983 return Err(serde::de::Error::duplicate_field("upstreamActorId"));
7984 }
7985 upstream_actor_id__ =
7986 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7987 .into_iter().map(|x| x.0).collect())
7988 ;
7989 }
7990 GeneratedField::UpstreamFragmentId => {
7991 if upstream_fragment_id__.is_some() {
7992 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
7993 }
7994 upstream_fragment_id__ =
7995 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7996 ;
7997 }
7998 GeneratedField::UpstreamDispatcherType => {
7999 if upstream_dispatcher_type__.is_some() {
8000 return Err(serde::de::Error::duplicate_field("upstreamDispatcherType"));
8001 }
8002 upstream_dispatcher_type__ = Some(map_.next_value::<DispatcherType>()? as i32);
8003 }
8004 GeneratedField::Fields => {
8005 if fields__.is_some() {
8006 return Err(serde::de::Error::duplicate_field("fields"));
8007 }
8008 fields__ = Some(map_.next_value()?);
8009 }
8010 }
8011 }
8012 Ok(MergeNode {
8013 upstream_actor_id: upstream_actor_id__.unwrap_or_default(),
8014 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
8015 upstream_dispatcher_type: upstream_dispatcher_type__.unwrap_or_default(),
8016 fields: fields__.unwrap_or_default(),
8017 })
8018 }
8019 }
8020 deserializer.deserialize_struct("stream_plan.MergeNode", FIELDS, GeneratedVisitor)
8021 }
8022}
8023impl serde::Serialize for NoOpNode {
8024 #[allow(deprecated)]
8025 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8026 where
8027 S: serde::Serializer,
8028 {
8029 use serde::ser::SerializeStruct;
8030 let len = 0;
8031 let struct_ser = serializer.serialize_struct("stream_plan.NoOpNode", len)?;
8032 struct_ser.end()
8033 }
8034}
8035impl<'de> serde::Deserialize<'de> for NoOpNode {
8036 #[allow(deprecated)]
8037 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8038 where
8039 D: serde::Deserializer<'de>,
8040 {
8041 const FIELDS: &[&str] = &[
8042 ];
8043
8044 #[allow(clippy::enum_variant_names)]
8045 enum GeneratedField {
8046 }
8047 impl<'de> serde::Deserialize<'de> for GeneratedField {
8048 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8049 where
8050 D: serde::Deserializer<'de>,
8051 {
8052 struct GeneratedVisitor;
8053
8054 impl serde::de::Visitor<'_> for GeneratedVisitor {
8055 type Value = GeneratedField;
8056
8057 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8058 write!(formatter, "expected one of: {:?}", &FIELDS)
8059 }
8060
8061 #[allow(unused_variables)]
8062 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8063 where
8064 E: serde::de::Error,
8065 {
8066 Err(serde::de::Error::unknown_field(value, FIELDS))
8067 }
8068 }
8069 deserializer.deserialize_identifier(GeneratedVisitor)
8070 }
8071 }
8072 struct GeneratedVisitor;
8073 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8074 type Value = NoOpNode;
8075
8076 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8077 formatter.write_str("struct stream_plan.NoOpNode")
8078 }
8079
8080 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NoOpNode, V::Error>
8081 where
8082 V: serde::de::MapAccess<'de>,
8083 {
8084 while map_.next_key::<GeneratedField>()?.is_some() {
8085 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8086 }
8087 Ok(NoOpNode {
8088 })
8089 }
8090 }
8091 deserializer.deserialize_struct("stream_plan.NoOpNode", FIELDS, GeneratedVisitor)
8092 }
8093}
8094impl serde::Serialize for NowModeGenerateSeries {
8095 #[allow(deprecated)]
8096 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8097 where
8098 S: serde::Serializer,
8099 {
8100 use serde::ser::SerializeStruct;
8101 let mut len = 0;
8102 if self.start_timestamp.is_some() {
8103 len += 1;
8104 }
8105 if self.interval.is_some() {
8106 len += 1;
8107 }
8108 let mut struct_ser = serializer.serialize_struct("stream_plan.NowModeGenerateSeries", len)?;
8109 if let Some(v) = self.start_timestamp.as_ref() {
8110 struct_ser.serialize_field("startTimestamp", v)?;
8111 }
8112 if let Some(v) = self.interval.as_ref() {
8113 struct_ser.serialize_field("interval", v)?;
8114 }
8115 struct_ser.end()
8116 }
8117}
8118impl<'de> serde::Deserialize<'de> for NowModeGenerateSeries {
8119 #[allow(deprecated)]
8120 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8121 where
8122 D: serde::Deserializer<'de>,
8123 {
8124 const FIELDS: &[&str] = &[
8125 "start_timestamp",
8126 "startTimestamp",
8127 "interval",
8128 ];
8129
8130 #[allow(clippy::enum_variant_names)]
8131 enum GeneratedField {
8132 StartTimestamp,
8133 Interval,
8134 }
8135 impl<'de> serde::Deserialize<'de> for GeneratedField {
8136 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8137 where
8138 D: serde::Deserializer<'de>,
8139 {
8140 struct GeneratedVisitor;
8141
8142 impl serde::de::Visitor<'_> for GeneratedVisitor {
8143 type Value = GeneratedField;
8144
8145 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8146 write!(formatter, "expected one of: {:?}", &FIELDS)
8147 }
8148
8149 #[allow(unused_variables)]
8150 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8151 where
8152 E: serde::de::Error,
8153 {
8154 match value {
8155 "startTimestamp" | "start_timestamp" => Ok(GeneratedField::StartTimestamp),
8156 "interval" => Ok(GeneratedField::Interval),
8157 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8158 }
8159 }
8160 }
8161 deserializer.deserialize_identifier(GeneratedVisitor)
8162 }
8163 }
8164 struct GeneratedVisitor;
8165 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8166 type Value = NowModeGenerateSeries;
8167
8168 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8169 formatter.write_str("struct stream_plan.NowModeGenerateSeries")
8170 }
8171
8172 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeGenerateSeries, V::Error>
8173 where
8174 V: serde::de::MapAccess<'de>,
8175 {
8176 let mut start_timestamp__ = None;
8177 let mut interval__ = None;
8178 while let Some(k) = map_.next_key()? {
8179 match k {
8180 GeneratedField::StartTimestamp => {
8181 if start_timestamp__.is_some() {
8182 return Err(serde::de::Error::duplicate_field("startTimestamp"));
8183 }
8184 start_timestamp__ = map_.next_value()?;
8185 }
8186 GeneratedField::Interval => {
8187 if interval__.is_some() {
8188 return Err(serde::de::Error::duplicate_field("interval"));
8189 }
8190 interval__ = map_.next_value()?;
8191 }
8192 }
8193 }
8194 Ok(NowModeGenerateSeries {
8195 start_timestamp: start_timestamp__,
8196 interval: interval__,
8197 })
8198 }
8199 }
8200 deserializer.deserialize_struct("stream_plan.NowModeGenerateSeries", FIELDS, GeneratedVisitor)
8201 }
8202}
8203impl serde::Serialize for NowModeUpdateCurrent {
8204 #[allow(deprecated)]
8205 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8206 where
8207 S: serde::Serializer,
8208 {
8209 use serde::ser::SerializeStruct;
8210 let len = 0;
8211 let struct_ser = serializer.serialize_struct("stream_plan.NowModeUpdateCurrent", len)?;
8212 struct_ser.end()
8213 }
8214}
8215impl<'de> serde::Deserialize<'de> for NowModeUpdateCurrent {
8216 #[allow(deprecated)]
8217 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8218 where
8219 D: serde::Deserializer<'de>,
8220 {
8221 const FIELDS: &[&str] = &[
8222 ];
8223
8224 #[allow(clippy::enum_variant_names)]
8225 enum GeneratedField {
8226 }
8227 impl<'de> serde::Deserialize<'de> for GeneratedField {
8228 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8229 where
8230 D: serde::Deserializer<'de>,
8231 {
8232 struct GeneratedVisitor;
8233
8234 impl serde::de::Visitor<'_> for GeneratedVisitor {
8235 type Value = GeneratedField;
8236
8237 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8238 write!(formatter, "expected one of: {:?}", &FIELDS)
8239 }
8240
8241 #[allow(unused_variables)]
8242 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8243 where
8244 E: serde::de::Error,
8245 {
8246 Err(serde::de::Error::unknown_field(value, FIELDS))
8247 }
8248 }
8249 deserializer.deserialize_identifier(GeneratedVisitor)
8250 }
8251 }
8252 struct GeneratedVisitor;
8253 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8254 type Value = NowModeUpdateCurrent;
8255
8256 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8257 formatter.write_str("struct stream_plan.NowModeUpdateCurrent")
8258 }
8259
8260 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeUpdateCurrent, V::Error>
8261 where
8262 V: serde::de::MapAccess<'de>,
8263 {
8264 while map_.next_key::<GeneratedField>()?.is_some() {
8265 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8266 }
8267 Ok(NowModeUpdateCurrent {
8268 })
8269 }
8270 }
8271 deserializer.deserialize_struct("stream_plan.NowModeUpdateCurrent", FIELDS, GeneratedVisitor)
8272 }
8273}
8274impl serde::Serialize for NowNode {
8275 #[allow(deprecated)]
8276 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8277 where
8278 S: serde::Serializer,
8279 {
8280 use serde::ser::SerializeStruct;
8281 let mut len = 0;
8282 if self.state_table.is_some() {
8283 len += 1;
8284 }
8285 if self.mode.is_some() {
8286 len += 1;
8287 }
8288 let mut struct_ser = serializer.serialize_struct("stream_plan.NowNode", len)?;
8289 if let Some(v) = self.state_table.as_ref() {
8290 struct_ser.serialize_field("stateTable", v)?;
8291 }
8292 if let Some(v) = self.mode.as_ref() {
8293 match v {
8294 now_node::Mode::UpdateCurrent(v) => {
8295 struct_ser.serialize_field("updateCurrent", v)?;
8296 }
8297 now_node::Mode::GenerateSeries(v) => {
8298 struct_ser.serialize_field("generateSeries", v)?;
8299 }
8300 }
8301 }
8302 struct_ser.end()
8303 }
8304}
8305impl<'de> serde::Deserialize<'de> for NowNode {
8306 #[allow(deprecated)]
8307 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8308 where
8309 D: serde::Deserializer<'de>,
8310 {
8311 const FIELDS: &[&str] = &[
8312 "state_table",
8313 "stateTable",
8314 "update_current",
8315 "updateCurrent",
8316 "generate_series",
8317 "generateSeries",
8318 ];
8319
8320 #[allow(clippy::enum_variant_names)]
8321 enum GeneratedField {
8322 StateTable,
8323 UpdateCurrent,
8324 GenerateSeries,
8325 }
8326 impl<'de> serde::Deserialize<'de> for GeneratedField {
8327 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8328 where
8329 D: serde::Deserializer<'de>,
8330 {
8331 struct GeneratedVisitor;
8332
8333 impl serde::de::Visitor<'_> for GeneratedVisitor {
8334 type Value = GeneratedField;
8335
8336 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8337 write!(formatter, "expected one of: {:?}", &FIELDS)
8338 }
8339
8340 #[allow(unused_variables)]
8341 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8342 where
8343 E: serde::de::Error,
8344 {
8345 match value {
8346 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
8347 "updateCurrent" | "update_current" => Ok(GeneratedField::UpdateCurrent),
8348 "generateSeries" | "generate_series" => Ok(GeneratedField::GenerateSeries),
8349 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8350 }
8351 }
8352 }
8353 deserializer.deserialize_identifier(GeneratedVisitor)
8354 }
8355 }
8356 struct GeneratedVisitor;
8357 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8358 type Value = NowNode;
8359
8360 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8361 formatter.write_str("struct stream_plan.NowNode")
8362 }
8363
8364 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowNode, V::Error>
8365 where
8366 V: serde::de::MapAccess<'de>,
8367 {
8368 let mut state_table__ = None;
8369 let mut mode__ = None;
8370 while let Some(k) = map_.next_key()? {
8371 match k {
8372 GeneratedField::StateTable => {
8373 if state_table__.is_some() {
8374 return Err(serde::de::Error::duplicate_field("stateTable"));
8375 }
8376 state_table__ = map_.next_value()?;
8377 }
8378 GeneratedField::UpdateCurrent => {
8379 if mode__.is_some() {
8380 return Err(serde::de::Error::duplicate_field("updateCurrent"));
8381 }
8382 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::UpdateCurrent)
8383;
8384 }
8385 GeneratedField::GenerateSeries => {
8386 if mode__.is_some() {
8387 return Err(serde::de::Error::duplicate_field("generateSeries"));
8388 }
8389 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::GenerateSeries)
8390;
8391 }
8392 }
8393 }
8394 Ok(NowNode {
8395 state_table: state_table__,
8396 mode: mode__,
8397 })
8398 }
8399 }
8400 deserializer.deserialize_struct("stream_plan.NowNode", FIELDS, GeneratedVisitor)
8401 }
8402}
8403impl serde::Serialize for OverWindowCachePolicy {
8404 #[allow(deprecated)]
8405 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8406 where
8407 S: serde::Serializer,
8408 {
8409 let variant = match self {
8410 Self::Unspecified => "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
8411 Self::Full => "OVER_WINDOW_CACHE_POLICY_FULL",
8412 Self::Recent => "OVER_WINDOW_CACHE_POLICY_RECENT",
8413 Self::RecentFirstN => "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
8414 Self::RecentLastN => "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
8415 };
8416 serializer.serialize_str(variant)
8417 }
8418}
8419impl<'de> serde::Deserialize<'de> for OverWindowCachePolicy {
8420 #[allow(deprecated)]
8421 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8422 where
8423 D: serde::Deserializer<'de>,
8424 {
8425 const FIELDS: &[&str] = &[
8426 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
8427 "OVER_WINDOW_CACHE_POLICY_FULL",
8428 "OVER_WINDOW_CACHE_POLICY_RECENT",
8429 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
8430 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
8431 ];
8432
8433 struct GeneratedVisitor;
8434
8435 impl serde::de::Visitor<'_> for GeneratedVisitor {
8436 type Value = OverWindowCachePolicy;
8437
8438 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8439 write!(formatter, "expected one of: {:?}", &FIELDS)
8440 }
8441
8442 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8443 where
8444 E: serde::de::Error,
8445 {
8446 i32::try_from(v)
8447 .ok()
8448 .and_then(|x| x.try_into().ok())
8449 .ok_or_else(|| {
8450 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8451 })
8452 }
8453
8454 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8455 where
8456 E: serde::de::Error,
8457 {
8458 i32::try_from(v)
8459 .ok()
8460 .and_then(|x| x.try_into().ok())
8461 .ok_or_else(|| {
8462 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8463 })
8464 }
8465
8466 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8467 where
8468 E: serde::de::Error,
8469 {
8470 match value {
8471 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED" => Ok(OverWindowCachePolicy::Unspecified),
8472 "OVER_WINDOW_CACHE_POLICY_FULL" => Ok(OverWindowCachePolicy::Full),
8473 "OVER_WINDOW_CACHE_POLICY_RECENT" => Ok(OverWindowCachePolicy::Recent),
8474 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N" => Ok(OverWindowCachePolicy::RecentFirstN),
8475 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N" => Ok(OverWindowCachePolicy::RecentLastN),
8476 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8477 }
8478 }
8479 }
8480 deserializer.deserialize_any(GeneratedVisitor)
8481 }
8482}
8483impl serde::Serialize for OverWindowNode {
8484 #[allow(deprecated)]
8485 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8486 where
8487 S: serde::Serializer,
8488 {
8489 use serde::ser::SerializeStruct;
8490 let mut len = 0;
8491 if !self.calls.is_empty() {
8492 len += 1;
8493 }
8494 if !self.partition_by.is_empty() {
8495 len += 1;
8496 }
8497 if !self.order_by.is_empty() {
8498 len += 1;
8499 }
8500 if self.state_table.is_some() {
8501 len += 1;
8502 }
8503 if self.cache_policy != 0 {
8504 len += 1;
8505 }
8506 let mut struct_ser = serializer.serialize_struct("stream_plan.OverWindowNode", len)?;
8507 if !self.calls.is_empty() {
8508 struct_ser.serialize_field("calls", &self.calls)?;
8509 }
8510 if !self.partition_by.is_empty() {
8511 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
8512 }
8513 if !self.order_by.is_empty() {
8514 struct_ser.serialize_field("orderBy", &self.order_by)?;
8515 }
8516 if let Some(v) = self.state_table.as_ref() {
8517 struct_ser.serialize_field("stateTable", v)?;
8518 }
8519 if self.cache_policy != 0 {
8520 let v = OverWindowCachePolicy::try_from(self.cache_policy)
8521 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cache_policy)))?;
8522 struct_ser.serialize_field("cachePolicy", &v)?;
8523 }
8524 struct_ser.end()
8525 }
8526}
8527impl<'de> serde::Deserialize<'de> for OverWindowNode {
8528 #[allow(deprecated)]
8529 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8530 where
8531 D: serde::Deserializer<'de>,
8532 {
8533 const FIELDS: &[&str] = &[
8534 "calls",
8535 "partition_by",
8536 "partitionBy",
8537 "order_by",
8538 "orderBy",
8539 "state_table",
8540 "stateTable",
8541 "cache_policy",
8542 "cachePolicy",
8543 ];
8544
8545 #[allow(clippy::enum_variant_names)]
8546 enum GeneratedField {
8547 Calls,
8548 PartitionBy,
8549 OrderBy,
8550 StateTable,
8551 CachePolicy,
8552 }
8553 impl<'de> serde::Deserialize<'de> for GeneratedField {
8554 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8555 where
8556 D: serde::Deserializer<'de>,
8557 {
8558 struct GeneratedVisitor;
8559
8560 impl serde::de::Visitor<'_> for GeneratedVisitor {
8561 type Value = GeneratedField;
8562
8563 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8564 write!(formatter, "expected one of: {:?}", &FIELDS)
8565 }
8566
8567 #[allow(unused_variables)]
8568 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8569 where
8570 E: serde::de::Error,
8571 {
8572 match value {
8573 "calls" => Ok(GeneratedField::Calls),
8574 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
8575 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
8576 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
8577 "cachePolicy" | "cache_policy" => Ok(GeneratedField::CachePolicy),
8578 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8579 }
8580 }
8581 }
8582 deserializer.deserialize_identifier(GeneratedVisitor)
8583 }
8584 }
8585 struct GeneratedVisitor;
8586 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8587 type Value = OverWindowNode;
8588
8589 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8590 formatter.write_str("struct stream_plan.OverWindowNode")
8591 }
8592
8593 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverWindowNode, V::Error>
8594 where
8595 V: serde::de::MapAccess<'de>,
8596 {
8597 let mut calls__ = None;
8598 let mut partition_by__ = None;
8599 let mut order_by__ = None;
8600 let mut state_table__ = None;
8601 let mut cache_policy__ = None;
8602 while let Some(k) = map_.next_key()? {
8603 match k {
8604 GeneratedField::Calls => {
8605 if calls__.is_some() {
8606 return Err(serde::de::Error::duplicate_field("calls"));
8607 }
8608 calls__ = Some(map_.next_value()?);
8609 }
8610 GeneratedField::PartitionBy => {
8611 if partition_by__.is_some() {
8612 return Err(serde::de::Error::duplicate_field("partitionBy"));
8613 }
8614 partition_by__ =
8615 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8616 .into_iter().map(|x| x.0).collect())
8617 ;
8618 }
8619 GeneratedField::OrderBy => {
8620 if order_by__.is_some() {
8621 return Err(serde::de::Error::duplicate_field("orderBy"));
8622 }
8623 order_by__ = Some(map_.next_value()?);
8624 }
8625 GeneratedField::StateTable => {
8626 if state_table__.is_some() {
8627 return Err(serde::de::Error::duplicate_field("stateTable"));
8628 }
8629 state_table__ = map_.next_value()?;
8630 }
8631 GeneratedField::CachePolicy => {
8632 if cache_policy__.is_some() {
8633 return Err(serde::de::Error::duplicate_field("cachePolicy"));
8634 }
8635 cache_policy__ = Some(map_.next_value::<OverWindowCachePolicy>()? as i32);
8636 }
8637 }
8638 }
8639 Ok(OverWindowNode {
8640 calls: calls__.unwrap_or_default(),
8641 partition_by: partition_by__.unwrap_or_default(),
8642 order_by: order_by__.unwrap_or_default(),
8643 state_table: state_table__,
8644 cache_policy: cache_policy__.unwrap_or_default(),
8645 })
8646 }
8647 }
8648 deserializer.deserialize_struct("stream_plan.OverWindowNode", FIELDS, GeneratedVisitor)
8649 }
8650}
8651impl serde::Serialize for PauseMutation {
8652 #[allow(deprecated)]
8653 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8654 where
8655 S: serde::Serializer,
8656 {
8657 use serde::ser::SerializeStruct;
8658 let len = 0;
8659 let struct_ser = serializer.serialize_struct("stream_plan.PauseMutation", len)?;
8660 struct_ser.end()
8661 }
8662}
8663impl<'de> serde::Deserialize<'de> for PauseMutation {
8664 #[allow(deprecated)]
8665 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8666 where
8667 D: serde::Deserializer<'de>,
8668 {
8669 const FIELDS: &[&str] = &[
8670 ];
8671
8672 #[allow(clippy::enum_variant_names)]
8673 enum GeneratedField {
8674 }
8675 impl<'de> serde::Deserialize<'de> for GeneratedField {
8676 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8677 where
8678 D: serde::Deserializer<'de>,
8679 {
8680 struct GeneratedVisitor;
8681
8682 impl serde::de::Visitor<'_> for GeneratedVisitor {
8683 type Value = GeneratedField;
8684
8685 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8686 write!(formatter, "expected one of: {:?}", &FIELDS)
8687 }
8688
8689 #[allow(unused_variables)]
8690 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8691 where
8692 E: serde::de::Error,
8693 {
8694 Err(serde::de::Error::unknown_field(value, FIELDS))
8695 }
8696 }
8697 deserializer.deserialize_identifier(GeneratedVisitor)
8698 }
8699 }
8700 struct GeneratedVisitor;
8701 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8702 type Value = PauseMutation;
8703
8704 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8705 formatter.write_str("struct stream_plan.PauseMutation")
8706 }
8707
8708 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseMutation, V::Error>
8709 where
8710 V: serde::de::MapAccess<'de>,
8711 {
8712 while map_.next_key::<GeneratedField>()?.is_some() {
8713 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8714 }
8715 Ok(PauseMutation {
8716 })
8717 }
8718 }
8719 deserializer.deserialize_struct("stream_plan.PauseMutation", FIELDS, GeneratedVisitor)
8720 }
8721}
8722impl serde::Serialize for ProjectNode {
8723 #[allow(deprecated)]
8724 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8725 where
8726 S: serde::Serializer,
8727 {
8728 use serde::ser::SerializeStruct;
8729 let mut len = 0;
8730 if !self.select_list.is_empty() {
8731 len += 1;
8732 }
8733 if !self.watermark_input_cols.is_empty() {
8734 len += 1;
8735 }
8736 if !self.watermark_output_cols.is_empty() {
8737 len += 1;
8738 }
8739 if !self.nondecreasing_exprs.is_empty() {
8740 len += 1;
8741 }
8742 if self.noop_update_hint {
8743 len += 1;
8744 }
8745 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectNode", len)?;
8746 if !self.select_list.is_empty() {
8747 struct_ser.serialize_field("selectList", &self.select_list)?;
8748 }
8749 if !self.watermark_input_cols.is_empty() {
8750 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
8751 }
8752 if !self.watermark_output_cols.is_empty() {
8753 struct_ser.serialize_field("watermarkOutputCols", &self.watermark_output_cols)?;
8754 }
8755 if !self.nondecreasing_exprs.is_empty() {
8756 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
8757 }
8758 if self.noop_update_hint {
8759 struct_ser.serialize_field("noopUpdateHint", &self.noop_update_hint)?;
8760 }
8761 struct_ser.end()
8762 }
8763}
8764impl<'de> serde::Deserialize<'de> for ProjectNode {
8765 #[allow(deprecated)]
8766 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8767 where
8768 D: serde::Deserializer<'de>,
8769 {
8770 const FIELDS: &[&str] = &[
8771 "select_list",
8772 "selectList",
8773 "watermark_input_cols",
8774 "watermarkInputCols",
8775 "watermark_output_cols",
8776 "watermarkOutputCols",
8777 "nondecreasing_exprs",
8778 "nondecreasingExprs",
8779 "noop_update_hint",
8780 "noopUpdateHint",
8781 ];
8782
8783 #[allow(clippy::enum_variant_names)]
8784 enum GeneratedField {
8785 SelectList,
8786 WatermarkInputCols,
8787 WatermarkOutputCols,
8788 NondecreasingExprs,
8789 NoopUpdateHint,
8790 }
8791 impl<'de> serde::Deserialize<'de> for GeneratedField {
8792 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8793 where
8794 D: serde::Deserializer<'de>,
8795 {
8796 struct GeneratedVisitor;
8797
8798 impl serde::de::Visitor<'_> for GeneratedVisitor {
8799 type Value = GeneratedField;
8800
8801 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8802 write!(formatter, "expected one of: {:?}", &FIELDS)
8803 }
8804
8805 #[allow(unused_variables)]
8806 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8807 where
8808 E: serde::de::Error,
8809 {
8810 match value {
8811 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
8812 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
8813 "watermarkOutputCols" | "watermark_output_cols" => Ok(GeneratedField::WatermarkOutputCols),
8814 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
8815 "noopUpdateHint" | "noop_update_hint" => Ok(GeneratedField::NoopUpdateHint),
8816 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8817 }
8818 }
8819 }
8820 deserializer.deserialize_identifier(GeneratedVisitor)
8821 }
8822 }
8823 struct GeneratedVisitor;
8824 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8825 type Value = ProjectNode;
8826
8827 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8828 formatter.write_str("struct stream_plan.ProjectNode")
8829 }
8830
8831 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
8832 where
8833 V: serde::de::MapAccess<'de>,
8834 {
8835 let mut select_list__ = None;
8836 let mut watermark_input_cols__ = None;
8837 let mut watermark_output_cols__ = None;
8838 let mut nondecreasing_exprs__ = None;
8839 let mut noop_update_hint__ = None;
8840 while let Some(k) = map_.next_key()? {
8841 match k {
8842 GeneratedField::SelectList => {
8843 if select_list__.is_some() {
8844 return Err(serde::de::Error::duplicate_field("selectList"));
8845 }
8846 select_list__ = Some(map_.next_value()?);
8847 }
8848 GeneratedField::WatermarkInputCols => {
8849 if watermark_input_cols__.is_some() {
8850 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
8851 }
8852 watermark_input_cols__ =
8853 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8854 .into_iter().map(|x| x.0).collect())
8855 ;
8856 }
8857 GeneratedField::WatermarkOutputCols => {
8858 if watermark_output_cols__.is_some() {
8859 return Err(serde::de::Error::duplicate_field("watermarkOutputCols"));
8860 }
8861 watermark_output_cols__ =
8862 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8863 .into_iter().map(|x| x.0).collect())
8864 ;
8865 }
8866 GeneratedField::NondecreasingExprs => {
8867 if nondecreasing_exprs__.is_some() {
8868 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
8869 }
8870 nondecreasing_exprs__ =
8871 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8872 .into_iter().map(|x| x.0).collect())
8873 ;
8874 }
8875 GeneratedField::NoopUpdateHint => {
8876 if noop_update_hint__.is_some() {
8877 return Err(serde::de::Error::duplicate_field("noopUpdateHint"));
8878 }
8879 noop_update_hint__ = Some(map_.next_value()?);
8880 }
8881 }
8882 }
8883 Ok(ProjectNode {
8884 select_list: select_list__.unwrap_or_default(),
8885 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
8886 watermark_output_cols: watermark_output_cols__.unwrap_or_default(),
8887 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
8888 noop_update_hint: noop_update_hint__.unwrap_or_default(),
8889 })
8890 }
8891 }
8892 deserializer.deserialize_struct("stream_plan.ProjectNode", FIELDS, GeneratedVisitor)
8893 }
8894}
8895impl serde::Serialize for ProjectSetNode {
8896 #[allow(deprecated)]
8897 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8898 where
8899 S: serde::Serializer,
8900 {
8901 use serde::ser::SerializeStruct;
8902 let mut len = 0;
8903 if !self.select_list.is_empty() {
8904 len += 1;
8905 }
8906 if !self.watermark_input_cols.is_empty() {
8907 len += 1;
8908 }
8909 if !self.watermark_expr_indices.is_empty() {
8910 len += 1;
8911 }
8912 if !self.nondecreasing_exprs.is_empty() {
8913 len += 1;
8914 }
8915 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectSetNode", len)?;
8916 if !self.select_list.is_empty() {
8917 struct_ser.serialize_field("selectList", &self.select_list)?;
8918 }
8919 if !self.watermark_input_cols.is_empty() {
8920 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
8921 }
8922 if !self.watermark_expr_indices.is_empty() {
8923 struct_ser.serialize_field("watermarkExprIndices", &self.watermark_expr_indices)?;
8924 }
8925 if !self.nondecreasing_exprs.is_empty() {
8926 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
8927 }
8928 struct_ser.end()
8929 }
8930}
8931impl<'de> serde::Deserialize<'de> for ProjectSetNode {
8932 #[allow(deprecated)]
8933 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8934 where
8935 D: serde::Deserializer<'de>,
8936 {
8937 const FIELDS: &[&str] = &[
8938 "select_list",
8939 "selectList",
8940 "watermark_input_cols",
8941 "watermarkInputCols",
8942 "watermark_expr_indices",
8943 "watermarkExprIndices",
8944 "nondecreasing_exprs",
8945 "nondecreasingExprs",
8946 ];
8947
8948 #[allow(clippy::enum_variant_names)]
8949 enum GeneratedField {
8950 SelectList,
8951 WatermarkInputCols,
8952 WatermarkExprIndices,
8953 NondecreasingExprs,
8954 }
8955 impl<'de> serde::Deserialize<'de> for GeneratedField {
8956 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8957 where
8958 D: serde::Deserializer<'de>,
8959 {
8960 struct GeneratedVisitor;
8961
8962 impl serde::de::Visitor<'_> for GeneratedVisitor {
8963 type Value = GeneratedField;
8964
8965 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8966 write!(formatter, "expected one of: {:?}", &FIELDS)
8967 }
8968
8969 #[allow(unused_variables)]
8970 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8971 where
8972 E: serde::de::Error,
8973 {
8974 match value {
8975 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
8976 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
8977 "watermarkExprIndices" | "watermark_expr_indices" => Ok(GeneratedField::WatermarkExprIndices),
8978 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
8979 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8980 }
8981 }
8982 }
8983 deserializer.deserialize_identifier(GeneratedVisitor)
8984 }
8985 }
8986 struct GeneratedVisitor;
8987 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8988 type Value = ProjectSetNode;
8989
8990 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8991 formatter.write_str("struct stream_plan.ProjectSetNode")
8992 }
8993
8994 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
8995 where
8996 V: serde::de::MapAccess<'de>,
8997 {
8998 let mut select_list__ = None;
8999 let mut watermark_input_cols__ = None;
9000 let mut watermark_expr_indices__ = None;
9001 let mut nondecreasing_exprs__ = None;
9002 while let Some(k) = map_.next_key()? {
9003 match k {
9004 GeneratedField::SelectList => {
9005 if select_list__.is_some() {
9006 return Err(serde::de::Error::duplicate_field("selectList"));
9007 }
9008 select_list__ = Some(map_.next_value()?);
9009 }
9010 GeneratedField::WatermarkInputCols => {
9011 if watermark_input_cols__.is_some() {
9012 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
9013 }
9014 watermark_input_cols__ =
9015 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9016 .into_iter().map(|x| x.0).collect())
9017 ;
9018 }
9019 GeneratedField::WatermarkExprIndices => {
9020 if watermark_expr_indices__.is_some() {
9021 return Err(serde::de::Error::duplicate_field("watermarkExprIndices"));
9022 }
9023 watermark_expr_indices__ =
9024 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9025 .into_iter().map(|x| x.0).collect())
9026 ;
9027 }
9028 GeneratedField::NondecreasingExprs => {
9029 if nondecreasing_exprs__.is_some() {
9030 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
9031 }
9032 nondecreasing_exprs__ =
9033 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9034 .into_iter().map(|x| x.0).collect())
9035 ;
9036 }
9037 }
9038 }
9039 Ok(ProjectSetNode {
9040 select_list: select_list__.unwrap_or_default(),
9041 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
9042 watermark_expr_indices: watermark_expr_indices__.unwrap_or_default(),
9043 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
9044 })
9045 }
9046 }
9047 deserializer.deserialize_struct("stream_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
9048 }
9049}
9050impl serde::Serialize for RefreshStartMutation {
9051 #[allow(deprecated)]
9052 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9053 where
9054 S: serde::Serializer,
9055 {
9056 use serde::ser::SerializeStruct;
9057 let mut len = 0;
9058 if self.table_id != 0 {
9059 len += 1;
9060 }
9061 if self.associated_source_id != 0 {
9062 len += 1;
9063 }
9064 let mut struct_ser = serializer.serialize_struct("stream_plan.RefreshStartMutation", len)?;
9065 if self.table_id != 0 {
9066 struct_ser.serialize_field("tableId", &self.table_id)?;
9067 }
9068 if self.associated_source_id != 0 {
9069 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
9070 }
9071 struct_ser.end()
9072 }
9073}
9074impl<'de> serde::Deserialize<'de> for RefreshStartMutation {
9075 #[allow(deprecated)]
9076 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9077 where
9078 D: serde::Deserializer<'de>,
9079 {
9080 const FIELDS: &[&str] = &[
9081 "table_id",
9082 "tableId",
9083 "associated_source_id",
9084 "associatedSourceId",
9085 ];
9086
9087 #[allow(clippy::enum_variant_names)]
9088 enum GeneratedField {
9089 TableId,
9090 AssociatedSourceId,
9091 }
9092 impl<'de> serde::Deserialize<'de> for GeneratedField {
9093 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9094 where
9095 D: serde::Deserializer<'de>,
9096 {
9097 struct GeneratedVisitor;
9098
9099 impl serde::de::Visitor<'_> for GeneratedVisitor {
9100 type Value = GeneratedField;
9101
9102 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9103 write!(formatter, "expected one of: {:?}", &FIELDS)
9104 }
9105
9106 #[allow(unused_variables)]
9107 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9108 where
9109 E: serde::de::Error,
9110 {
9111 match value {
9112 "tableId" | "table_id" => Ok(GeneratedField::TableId),
9113 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
9114 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9115 }
9116 }
9117 }
9118 deserializer.deserialize_identifier(GeneratedVisitor)
9119 }
9120 }
9121 struct GeneratedVisitor;
9122 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9123 type Value = RefreshStartMutation;
9124
9125 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9126 formatter.write_str("struct stream_plan.RefreshStartMutation")
9127 }
9128
9129 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshStartMutation, V::Error>
9130 where
9131 V: serde::de::MapAccess<'de>,
9132 {
9133 let mut table_id__ = None;
9134 let mut associated_source_id__ = None;
9135 while let Some(k) = map_.next_key()? {
9136 match k {
9137 GeneratedField::TableId => {
9138 if table_id__.is_some() {
9139 return Err(serde::de::Error::duplicate_field("tableId"));
9140 }
9141 table_id__ =
9142 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9143 ;
9144 }
9145 GeneratedField::AssociatedSourceId => {
9146 if associated_source_id__.is_some() {
9147 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
9148 }
9149 associated_source_id__ =
9150 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9151 ;
9152 }
9153 }
9154 }
9155 Ok(RefreshStartMutation {
9156 table_id: table_id__.unwrap_or_default(),
9157 associated_source_id: associated_source_id__.unwrap_or_default(),
9158 })
9159 }
9160 }
9161 deserializer.deserialize_struct("stream_plan.RefreshStartMutation", FIELDS, GeneratedVisitor)
9162 }
9163}
9164impl serde::Serialize for ResetSourceMutation {
9165 #[allow(deprecated)]
9166 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9167 where
9168 S: serde::Serializer,
9169 {
9170 use serde::ser::SerializeStruct;
9171 let mut len = 0;
9172 if self.source_id != 0 {
9173 len += 1;
9174 }
9175 let mut struct_ser = serializer.serialize_struct("stream_plan.ResetSourceMutation", len)?;
9176 if self.source_id != 0 {
9177 struct_ser.serialize_field("sourceId", &self.source_id)?;
9178 }
9179 struct_ser.end()
9180 }
9181}
9182impl<'de> serde::Deserialize<'de> for ResetSourceMutation {
9183 #[allow(deprecated)]
9184 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9185 where
9186 D: serde::Deserializer<'de>,
9187 {
9188 const FIELDS: &[&str] = &[
9189 "source_id",
9190 "sourceId",
9191 ];
9192
9193 #[allow(clippy::enum_variant_names)]
9194 enum GeneratedField {
9195 SourceId,
9196 }
9197 impl<'de> serde::Deserialize<'de> for GeneratedField {
9198 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9199 where
9200 D: serde::Deserializer<'de>,
9201 {
9202 struct GeneratedVisitor;
9203
9204 impl serde::de::Visitor<'_> for GeneratedVisitor {
9205 type Value = GeneratedField;
9206
9207 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9208 write!(formatter, "expected one of: {:?}", &FIELDS)
9209 }
9210
9211 #[allow(unused_variables)]
9212 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9213 where
9214 E: serde::de::Error,
9215 {
9216 match value {
9217 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
9218 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9219 }
9220 }
9221 }
9222 deserializer.deserialize_identifier(GeneratedVisitor)
9223 }
9224 }
9225 struct GeneratedVisitor;
9226 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9227 type Value = ResetSourceMutation;
9228
9229 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9230 formatter.write_str("struct stream_plan.ResetSourceMutation")
9231 }
9232
9233 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceMutation, V::Error>
9234 where
9235 V: serde::de::MapAccess<'de>,
9236 {
9237 let mut source_id__ = None;
9238 while let Some(k) = map_.next_key()? {
9239 match k {
9240 GeneratedField::SourceId => {
9241 if source_id__.is_some() {
9242 return Err(serde::de::Error::duplicate_field("sourceId"));
9243 }
9244 source_id__ =
9245 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9246 ;
9247 }
9248 }
9249 }
9250 Ok(ResetSourceMutation {
9251 source_id: source_id__.unwrap_or_default(),
9252 })
9253 }
9254 }
9255 deserializer.deserialize_struct("stream_plan.ResetSourceMutation", FIELDS, GeneratedVisitor)
9256 }
9257}
9258impl serde::Serialize for ResumeMutation {
9259 #[allow(deprecated)]
9260 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9261 where
9262 S: serde::Serializer,
9263 {
9264 use serde::ser::SerializeStruct;
9265 let len = 0;
9266 let struct_ser = serializer.serialize_struct("stream_plan.ResumeMutation", len)?;
9267 struct_ser.end()
9268 }
9269}
9270impl<'de> serde::Deserialize<'de> for ResumeMutation {
9271 #[allow(deprecated)]
9272 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9273 where
9274 D: serde::Deserializer<'de>,
9275 {
9276 const FIELDS: &[&str] = &[
9277 ];
9278
9279 #[allow(clippy::enum_variant_names)]
9280 enum GeneratedField {
9281 }
9282 impl<'de> serde::Deserialize<'de> for GeneratedField {
9283 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9284 where
9285 D: serde::Deserializer<'de>,
9286 {
9287 struct GeneratedVisitor;
9288
9289 impl serde::de::Visitor<'_> for GeneratedVisitor {
9290 type Value = GeneratedField;
9291
9292 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9293 write!(formatter, "expected one of: {:?}", &FIELDS)
9294 }
9295
9296 #[allow(unused_variables)]
9297 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9298 where
9299 E: serde::de::Error,
9300 {
9301 Err(serde::de::Error::unknown_field(value, FIELDS))
9302 }
9303 }
9304 deserializer.deserialize_identifier(GeneratedVisitor)
9305 }
9306 }
9307 struct GeneratedVisitor;
9308 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9309 type Value = ResumeMutation;
9310
9311 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9312 formatter.write_str("struct stream_plan.ResumeMutation")
9313 }
9314
9315 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeMutation, V::Error>
9316 where
9317 V: serde::de::MapAccess<'de>,
9318 {
9319 while map_.next_key::<GeneratedField>()?.is_some() {
9320 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9321 }
9322 Ok(ResumeMutation {
9323 })
9324 }
9325 }
9326 deserializer.deserialize_struct("stream_plan.ResumeMutation", FIELDS, GeneratedVisitor)
9327 }
9328}
9329impl serde::Serialize for RowIdGenNode {
9330 #[allow(deprecated)]
9331 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9332 where
9333 S: serde::Serializer,
9334 {
9335 use serde::ser::SerializeStruct;
9336 let mut len = 0;
9337 if self.row_id_index != 0 {
9338 len += 1;
9339 }
9340 let mut struct_ser = serializer.serialize_struct("stream_plan.RowIdGenNode", len)?;
9341 if self.row_id_index != 0 {
9342 #[allow(clippy::needless_borrow)]
9343 #[allow(clippy::needless_borrows_for_generic_args)]
9344 struct_ser.serialize_field("rowIdIndex", ToString::to_string(&self.row_id_index).as_str())?;
9345 }
9346 struct_ser.end()
9347 }
9348}
9349impl<'de> serde::Deserialize<'de> for RowIdGenNode {
9350 #[allow(deprecated)]
9351 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9352 where
9353 D: serde::Deserializer<'de>,
9354 {
9355 const FIELDS: &[&str] = &[
9356 "row_id_index",
9357 "rowIdIndex",
9358 ];
9359
9360 #[allow(clippy::enum_variant_names)]
9361 enum GeneratedField {
9362 RowIdIndex,
9363 }
9364 impl<'de> serde::Deserialize<'de> for GeneratedField {
9365 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9366 where
9367 D: serde::Deserializer<'de>,
9368 {
9369 struct GeneratedVisitor;
9370
9371 impl serde::de::Visitor<'_> for GeneratedVisitor {
9372 type Value = GeneratedField;
9373
9374 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9375 write!(formatter, "expected one of: {:?}", &FIELDS)
9376 }
9377
9378 #[allow(unused_variables)]
9379 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9380 where
9381 E: serde::de::Error,
9382 {
9383 match value {
9384 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
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 = RowIdGenNode;
9395
9396 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9397 formatter.write_str("struct stream_plan.RowIdGenNode")
9398 }
9399
9400 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowIdGenNode, V::Error>
9401 where
9402 V: serde::de::MapAccess<'de>,
9403 {
9404 let mut row_id_index__ = None;
9405 while let Some(k) = map_.next_key()? {
9406 match k {
9407 GeneratedField::RowIdIndex => {
9408 if row_id_index__.is_some() {
9409 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
9410 }
9411 row_id_index__ =
9412 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9413 ;
9414 }
9415 }
9416 }
9417 Ok(RowIdGenNode {
9418 row_id_index: row_id_index__.unwrap_or_default(),
9419 })
9420 }
9421 }
9422 deserializer.deserialize_struct("stream_plan.RowIdGenNode", FIELDS, GeneratedVisitor)
9423 }
9424}
9425impl serde::Serialize for RowMergeNode {
9426 #[allow(deprecated)]
9427 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9428 where
9429 S: serde::Serializer,
9430 {
9431 use serde::ser::SerializeStruct;
9432 let mut len = 0;
9433 if self.lhs_mapping.is_some() {
9434 len += 1;
9435 }
9436 if self.rhs_mapping.is_some() {
9437 len += 1;
9438 }
9439 let mut struct_ser = serializer.serialize_struct("stream_plan.RowMergeNode", len)?;
9440 if let Some(v) = self.lhs_mapping.as_ref() {
9441 struct_ser.serialize_field("lhsMapping", v)?;
9442 }
9443 if let Some(v) = self.rhs_mapping.as_ref() {
9444 struct_ser.serialize_field("rhsMapping", v)?;
9445 }
9446 struct_ser.end()
9447 }
9448}
9449impl<'de> serde::Deserialize<'de> for RowMergeNode {
9450 #[allow(deprecated)]
9451 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9452 where
9453 D: serde::Deserializer<'de>,
9454 {
9455 const FIELDS: &[&str] = &[
9456 "lhs_mapping",
9457 "lhsMapping",
9458 "rhs_mapping",
9459 "rhsMapping",
9460 ];
9461
9462 #[allow(clippy::enum_variant_names)]
9463 enum GeneratedField {
9464 LhsMapping,
9465 RhsMapping,
9466 }
9467 impl<'de> serde::Deserialize<'de> for GeneratedField {
9468 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9469 where
9470 D: serde::Deserializer<'de>,
9471 {
9472 struct GeneratedVisitor;
9473
9474 impl serde::de::Visitor<'_> for GeneratedVisitor {
9475 type Value = GeneratedField;
9476
9477 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9478 write!(formatter, "expected one of: {:?}", &FIELDS)
9479 }
9480
9481 #[allow(unused_variables)]
9482 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9483 where
9484 E: serde::de::Error,
9485 {
9486 match value {
9487 "lhsMapping" | "lhs_mapping" => Ok(GeneratedField::LhsMapping),
9488 "rhsMapping" | "rhs_mapping" => Ok(GeneratedField::RhsMapping),
9489 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9490 }
9491 }
9492 }
9493 deserializer.deserialize_identifier(GeneratedVisitor)
9494 }
9495 }
9496 struct GeneratedVisitor;
9497 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9498 type Value = RowMergeNode;
9499
9500 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9501 formatter.write_str("struct stream_plan.RowMergeNode")
9502 }
9503
9504 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowMergeNode, V::Error>
9505 where
9506 V: serde::de::MapAccess<'de>,
9507 {
9508 let mut lhs_mapping__ = None;
9509 let mut rhs_mapping__ = None;
9510 while let Some(k) = map_.next_key()? {
9511 match k {
9512 GeneratedField::LhsMapping => {
9513 if lhs_mapping__.is_some() {
9514 return Err(serde::de::Error::duplicate_field("lhsMapping"));
9515 }
9516 lhs_mapping__ = map_.next_value()?;
9517 }
9518 GeneratedField::RhsMapping => {
9519 if rhs_mapping__.is_some() {
9520 return Err(serde::de::Error::duplicate_field("rhsMapping"));
9521 }
9522 rhs_mapping__ = map_.next_value()?;
9523 }
9524 }
9525 }
9526 Ok(RowMergeNode {
9527 lhs_mapping: lhs_mapping__,
9528 rhs_mapping: rhs_mapping__,
9529 })
9530 }
9531 }
9532 deserializer.deserialize_struct("stream_plan.RowMergeNode", FIELDS, GeneratedVisitor)
9533 }
9534}
9535impl serde::Serialize for SimpleAggNode {
9536 #[allow(deprecated)]
9537 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9538 where
9539 S: serde::Serializer,
9540 {
9541 use serde::ser::SerializeStruct;
9542 let mut len = 0;
9543 if !self.agg_calls.is_empty() {
9544 len += 1;
9545 }
9546 if !self.agg_call_states.is_empty() {
9547 len += 1;
9548 }
9549 if self.intermediate_state_table.is_some() {
9550 len += 1;
9551 }
9552 if self.is_append_only {
9553 len += 1;
9554 }
9555 if !self.distinct_dedup_tables.is_empty() {
9556 len += 1;
9557 }
9558 if self.row_count_index != 0 {
9559 len += 1;
9560 }
9561 if self.version != 0 {
9562 len += 1;
9563 }
9564 if self.must_output_per_barrier {
9565 len += 1;
9566 }
9567 let mut struct_ser = serializer.serialize_struct("stream_plan.SimpleAggNode", len)?;
9568 if !self.agg_calls.is_empty() {
9569 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
9570 }
9571 if !self.agg_call_states.is_empty() {
9572 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
9573 }
9574 if let Some(v) = self.intermediate_state_table.as_ref() {
9575 struct_ser.serialize_field("intermediateStateTable", v)?;
9576 }
9577 if self.is_append_only {
9578 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
9579 }
9580 if !self.distinct_dedup_tables.is_empty() {
9581 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
9582 }
9583 if self.row_count_index != 0 {
9584 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
9585 }
9586 if self.version != 0 {
9587 let v = AggNodeVersion::try_from(self.version)
9588 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
9589 struct_ser.serialize_field("version", &v)?;
9590 }
9591 if self.must_output_per_barrier {
9592 struct_ser.serialize_field("mustOutputPerBarrier", &self.must_output_per_barrier)?;
9593 }
9594 struct_ser.end()
9595 }
9596}
9597impl<'de> serde::Deserialize<'de> for SimpleAggNode {
9598 #[allow(deprecated)]
9599 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9600 where
9601 D: serde::Deserializer<'de>,
9602 {
9603 const FIELDS: &[&str] = &[
9604 "agg_calls",
9605 "aggCalls",
9606 "agg_call_states",
9607 "aggCallStates",
9608 "intermediate_state_table",
9609 "intermediateStateTable",
9610 "is_append_only",
9611 "isAppendOnly",
9612 "distinct_dedup_tables",
9613 "distinctDedupTables",
9614 "row_count_index",
9615 "rowCountIndex",
9616 "version",
9617 "must_output_per_barrier",
9618 "mustOutputPerBarrier",
9619 ];
9620
9621 #[allow(clippy::enum_variant_names)]
9622 enum GeneratedField {
9623 AggCalls,
9624 AggCallStates,
9625 IntermediateStateTable,
9626 IsAppendOnly,
9627 DistinctDedupTables,
9628 RowCountIndex,
9629 Version,
9630 MustOutputPerBarrier,
9631 }
9632 impl<'de> serde::Deserialize<'de> for GeneratedField {
9633 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9634 where
9635 D: serde::Deserializer<'de>,
9636 {
9637 struct GeneratedVisitor;
9638
9639 impl serde::de::Visitor<'_> for GeneratedVisitor {
9640 type Value = GeneratedField;
9641
9642 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9643 write!(formatter, "expected one of: {:?}", &FIELDS)
9644 }
9645
9646 #[allow(unused_variables)]
9647 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9648 where
9649 E: serde::de::Error,
9650 {
9651 match value {
9652 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
9653 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
9654 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
9655 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
9656 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
9657 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
9658 "version" => Ok(GeneratedField::Version),
9659 "mustOutputPerBarrier" | "must_output_per_barrier" => Ok(GeneratedField::MustOutputPerBarrier),
9660 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9661 }
9662 }
9663 }
9664 deserializer.deserialize_identifier(GeneratedVisitor)
9665 }
9666 }
9667 struct GeneratedVisitor;
9668 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9669 type Value = SimpleAggNode;
9670
9671 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9672 formatter.write_str("struct stream_plan.SimpleAggNode")
9673 }
9674
9675 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SimpleAggNode, V::Error>
9676 where
9677 V: serde::de::MapAccess<'de>,
9678 {
9679 let mut agg_calls__ = None;
9680 let mut agg_call_states__ = None;
9681 let mut intermediate_state_table__ = None;
9682 let mut is_append_only__ = None;
9683 let mut distinct_dedup_tables__ = None;
9684 let mut row_count_index__ = None;
9685 let mut version__ = None;
9686 let mut must_output_per_barrier__ = None;
9687 while let Some(k) = map_.next_key()? {
9688 match k {
9689 GeneratedField::AggCalls => {
9690 if agg_calls__.is_some() {
9691 return Err(serde::de::Error::duplicate_field("aggCalls"));
9692 }
9693 agg_calls__ = Some(map_.next_value()?);
9694 }
9695 GeneratedField::AggCallStates => {
9696 if agg_call_states__.is_some() {
9697 return Err(serde::de::Error::duplicate_field("aggCallStates"));
9698 }
9699 agg_call_states__ = Some(map_.next_value()?);
9700 }
9701 GeneratedField::IntermediateStateTable => {
9702 if intermediate_state_table__.is_some() {
9703 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
9704 }
9705 intermediate_state_table__ = map_.next_value()?;
9706 }
9707 GeneratedField::IsAppendOnly => {
9708 if is_append_only__.is_some() {
9709 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
9710 }
9711 is_append_only__ = Some(map_.next_value()?);
9712 }
9713 GeneratedField::DistinctDedupTables => {
9714 if distinct_dedup_tables__.is_some() {
9715 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
9716 }
9717 distinct_dedup_tables__ = Some(
9718 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
9719 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
9720 );
9721 }
9722 GeneratedField::RowCountIndex => {
9723 if row_count_index__.is_some() {
9724 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
9725 }
9726 row_count_index__ =
9727 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9728 ;
9729 }
9730 GeneratedField::Version => {
9731 if version__.is_some() {
9732 return Err(serde::de::Error::duplicate_field("version"));
9733 }
9734 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
9735 }
9736 GeneratedField::MustOutputPerBarrier => {
9737 if must_output_per_barrier__.is_some() {
9738 return Err(serde::de::Error::duplicate_field("mustOutputPerBarrier"));
9739 }
9740 must_output_per_barrier__ = Some(map_.next_value()?);
9741 }
9742 }
9743 }
9744 Ok(SimpleAggNode {
9745 agg_calls: agg_calls__.unwrap_or_default(),
9746 agg_call_states: agg_call_states__.unwrap_or_default(),
9747 intermediate_state_table: intermediate_state_table__,
9748 is_append_only: is_append_only__.unwrap_or_default(),
9749 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
9750 row_count_index: row_count_index__.unwrap_or_default(),
9751 version: version__.unwrap_or_default(),
9752 must_output_per_barrier: must_output_per_barrier__.unwrap_or_default(),
9753 })
9754 }
9755 }
9756 deserializer.deserialize_struct("stream_plan.SimpleAggNode", FIELDS, GeneratedVisitor)
9757 }
9758}
9759impl serde::Serialize for SinkAddColumnsOp {
9760 #[allow(deprecated)]
9761 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9762 where
9763 S: serde::Serializer,
9764 {
9765 use serde::ser::SerializeStruct;
9766 let mut len = 0;
9767 if !self.fields.is_empty() {
9768 len += 1;
9769 }
9770 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkAddColumnsOp", len)?;
9771 if !self.fields.is_empty() {
9772 struct_ser.serialize_field("fields", &self.fields)?;
9773 }
9774 struct_ser.end()
9775 }
9776}
9777impl<'de> serde::Deserialize<'de> for SinkAddColumnsOp {
9778 #[allow(deprecated)]
9779 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9780 where
9781 D: serde::Deserializer<'de>,
9782 {
9783 const FIELDS: &[&str] = &[
9784 "fields",
9785 ];
9786
9787 #[allow(clippy::enum_variant_names)]
9788 enum GeneratedField {
9789 Fields,
9790 }
9791 impl<'de> serde::Deserialize<'de> for GeneratedField {
9792 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9793 where
9794 D: serde::Deserializer<'de>,
9795 {
9796 struct GeneratedVisitor;
9797
9798 impl serde::de::Visitor<'_> for GeneratedVisitor {
9799 type Value = GeneratedField;
9800
9801 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9802 write!(formatter, "expected one of: {:?}", &FIELDS)
9803 }
9804
9805 #[allow(unused_variables)]
9806 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9807 where
9808 E: serde::de::Error,
9809 {
9810 match value {
9811 "fields" => Ok(GeneratedField::Fields),
9812 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9813 }
9814 }
9815 }
9816 deserializer.deserialize_identifier(GeneratedVisitor)
9817 }
9818 }
9819 struct GeneratedVisitor;
9820 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9821 type Value = SinkAddColumnsOp;
9822
9823 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9824 formatter.write_str("struct stream_plan.SinkAddColumnsOp")
9825 }
9826
9827 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkAddColumnsOp, V::Error>
9828 where
9829 V: serde::de::MapAccess<'de>,
9830 {
9831 let mut fields__ = None;
9832 while let Some(k) = map_.next_key()? {
9833 match k {
9834 GeneratedField::Fields => {
9835 if fields__.is_some() {
9836 return Err(serde::de::Error::duplicate_field("fields"));
9837 }
9838 fields__ = Some(map_.next_value()?);
9839 }
9840 }
9841 }
9842 Ok(SinkAddColumnsOp {
9843 fields: fields__.unwrap_or_default(),
9844 })
9845 }
9846 }
9847 deserializer.deserialize_struct("stream_plan.SinkAddColumnsOp", FIELDS, GeneratedVisitor)
9848 }
9849}
9850impl serde::Serialize for SinkDesc {
9851 #[allow(deprecated)]
9852 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9853 where
9854 S: serde::Serializer,
9855 {
9856 use serde::ser::SerializeStruct;
9857 let mut len = 0;
9858 if self.id != 0 {
9859 len += 1;
9860 }
9861 if !self.name.is_empty() {
9862 len += 1;
9863 }
9864 if !self.definition.is_empty() {
9865 len += 1;
9866 }
9867 if !self.plan_pk.is_empty() {
9868 len += 1;
9869 }
9870 if !self.downstream_pk.is_empty() {
9871 len += 1;
9872 }
9873 if !self.distribution_key.is_empty() {
9874 len += 1;
9875 }
9876 if !self.properties.is_empty() {
9877 len += 1;
9878 }
9879 if self.sink_type != 0 {
9880 len += 1;
9881 }
9882 if !self.column_catalogs.is_empty() {
9883 len += 1;
9884 }
9885 if !self.db_name.is_empty() {
9886 len += 1;
9887 }
9888 if !self.sink_from_name.is_empty() {
9889 len += 1;
9890 }
9891 if self.format_desc.is_some() {
9892 len += 1;
9893 }
9894 if self.target_table.is_some() {
9895 len += 1;
9896 }
9897 if self.extra_partition_col_idx.is_some() {
9898 len += 1;
9899 }
9900 if !self.secret_refs.is_empty() {
9901 len += 1;
9902 }
9903 if self.raw_ignore_delete {
9904 len += 1;
9905 }
9906 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDesc", len)?;
9907 if self.id != 0 {
9908 struct_ser.serialize_field("id", &self.id)?;
9909 }
9910 if !self.name.is_empty() {
9911 struct_ser.serialize_field("name", &self.name)?;
9912 }
9913 if !self.definition.is_empty() {
9914 struct_ser.serialize_field("definition", &self.definition)?;
9915 }
9916 if !self.plan_pk.is_empty() {
9917 struct_ser.serialize_field("planPk", &self.plan_pk)?;
9918 }
9919 if !self.downstream_pk.is_empty() {
9920 struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
9921 }
9922 if !self.distribution_key.is_empty() {
9923 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
9924 }
9925 if !self.properties.is_empty() {
9926 struct_ser.serialize_field("properties", &self.properties)?;
9927 }
9928 if self.sink_type != 0 {
9929 let v = super::catalog::SinkType::try_from(self.sink_type)
9930 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
9931 struct_ser.serialize_field("sinkType", &v)?;
9932 }
9933 if !self.column_catalogs.is_empty() {
9934 struct_ser.serialize_field("columnCatalogs", &self.column_catalogs)?;
9935 }
9936 if !self.db_name.is_empty() {
9937 struct_ser.serialize_field("dbName", &self.db_name)?;
9938 }
9939 if !self.sink_from_name.is_empty() {
9940 struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
9941 }
9942 if let Some(v) = self.format_desc.as_ref() {
9943 struct_ser.serialize_field("formatDesc", v)?;
9944 }
9945 if let Some(v) = self.target_table.as_ref() {
9946 struct_ser.serialize_field("targetTable", v)?;
9947 }
9948 if let Some(v) = self.extra_partition_col_idx.as_ref() {
9949 #[allow(clippy::needless_borrow)]
9950 #[allow(clippy::needless_borrows_for_generic_args)]
9951 struct_ser.serialize_field("extraPartitionColIdx", ToString::to_string(&v).as_str())?;
9952 }
9953 if !self.secret_refs.is_empty() {
9954 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
9955 }
9956 if self.raw_ignore_delete {
9957 struct_ser.serialize_field("rawIgnoreDelete", &self.raw_ignore_delete)?;
9958 }
9959 struct_ser.end()
9960 }
9961}
9962impl<'de> serde::Deserialize<'de> for SinkDesc {
9963 #[allow(deprecated)]
9964 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9965 where
9966 D: serde::Deserializer<'de>,
9967 {
9968 const FIELDS: &[&str] = &[
9969 "id",
9970 "name",
9971 "definition",
9972 "plan_pk",
9973 "planPk",
9974 "downstream_pk",
9975 "downstreamPk",
9976 "distribution_key",
9977 "distributionKey",
9978 "properties",
9979 "sink_type",
9980 "sinkType",
9981 "column_catalogs",
9982 "columnCatalogs",
9983 "db_name",
9984 "dbName",
9985 "sink_from_name",
9986 "sinkFromName",
9987 "format_desc",
9988 "formatDesc",
9989 "target_table",
9990 "targetTable",
9991 "extra_partition_col_idx",
9992 "extraPartitionColIdx",
9993 "secret_refs",
9994 "secretRefs",
9995 "raw_ignore_delete",
9996 "rawIgnoreDelete",
9997 ];
9998
9999 #[allow(clippy::enum_variant_names)]
10000 enum GeneratedField {
10001 Id,
10002 Name,
10003 Definition,
10004 PlanPk,
10005 DownstreamPk,
10006 DistributionKey,
10007 Properties,
10008 SinkType,
10009 ColumnCatalogs,
10010 DbName,
10011 SinkFromName,
10012 FormatDesc,
10013 TargetTable,
10014 ExtraPartitionColIdx,
10015 SecretRefs,
10016 RawIgnoreDelete,
10017 }
10018 impl<'de> serde::Deserialize<'de> for GeneratedField {
10019 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10020 where
10021 D: serde::Deserializer<'de>,
10022 {
10023 struct GeneratedVisitor;
10024
10025 impl serde::de::Visitor<'_> for GeneratedVisitor {
10026 type Value = GeneratedField;
10027
10028 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10029 write!(formatter, "expected one of: {:?}", &FIELDS)
10030 }
10031
10032 #[allow(unused_variables)]
10033 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10034 where
10035 E: serde::de::Error,
10036 {
10037 match value {
10038 "id" => Ok(GeneratedField::Id),
10039 "name" => Ok(GeneratedField::Name),
10040 "definition" => Ok(GeneratedField::Definition),
10041 "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
10042 "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
10043 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
10044 "properties" => Ok(GeneratedField::Properties),
10045 "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
10046 "columnCatalogs" | "column_catalogs" => Ok(GeneratedField::ColumnCatalogs),
10047 "dbName" | "db_name" => Ok(GeneratedField::DbName),
10048 "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
10049 "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
10050 "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
10051 "extraPartitionColIdx" | "extra_partition_col_idx" => Ok(GeneratedField::ExtraPartitionColIdx),
10052 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
10053 "rawIgnoreDelete" | "raw_ignore_delete" => Ok(GeneratedField::RawIgnoreDelete),
10054 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10055 }
10056 }
10057 }
10058 deserializer.deserialize_identifier(GeneratedVisitor)
10059 }
10060 }
10061 struct GeneratedVisitor;
10062 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10063 type Value = SinkDesc;
10064
10065 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10066 formatter.write_str("struct stream_plan.SinkDesc")
10067 }
10068
10069 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDesc, V::Error>
10070 where
10071 V: serde::de::MapAccess<'de>,
10072 {
10073 let mut id__ = None;
10074 let mut name__ = None;
10075 let mut definition__ = None;
10076 let mut plan_pk__ = None;
10077 let mut downstream_pk__ = None;
10078 let mut distribution_key__ = None;
10079 let mut properties__ = None;
10080 let mut sink_type__ = None;
10081 let mut column_catalogs__ = None;
10082 let mut db_name__ = None;
10083 let mut sink_from_name__ = None;
10084 let mut format_desc__ = None;
10085 let mut target_table__ = None;
10086 let mut extra_partition_col_idx__ = None;
10087 let mut secret_refs__ = None;
10088 let mut raw_ignore_delete__ = None;
10089 while let Some(k) = map_.next_key()? {
10090 match k {
10091 GeneratedField::Id => {
10092 if id__.is_some() {
10093 return Err(serde::de::Error::duplicate_field("id"));
10094 }
10095 id__ =
10096 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10097 ;
10098 }
10099 GeneratedField::Name => {
10100 if name__.is_some() {
10101 return Err(serde::de::Error::duplicate_field("name"));
10102 }
10103 name__ = Some(map_.next_value()?);
10104 }
10105 GeneratedField::Definition => {
10106 if definition__.is_some() {
10107 return Err(serde::de::Error::duplicate_field("definition"));
10108 }
10109 definition__ = Some(map_.next_value()?);
10110 }
10111 GeneratedField::PlanPk => {
10112 if plan_pk__.is_some() {
10113 return Err(serde::de::Error::duplicate_field("planPk"));
10114 }
10115 plan_pk__ = Some(map_.next_value()?);
10116 }
10117 GeneratedField::DownstreamPk => {
10118 if downstream_pk__.is_some() {
10119 return Err(serde::de::Error::duplicate_field("downstreamPk"));
10120 }
10121 downstream_pk__ =
10122 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10123 .into_iter().map(|x| x.0).collect())
10124 ;
10125 }
10126 GeneratedField::DistributionKey => {
10127 if distribution_key__.is_some() {
10128 return Err(serde::de::Error::duplicate_field("distributionKey"));
10129 }
10130 distribution_key__ =
10131 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10132 .into_iter().map(|x| x.0).collect())
10133 ;
10134 }
10135 GeneratedField::Properties => {
10136 if properties__.is_some() {
10137 return Err(serde::de::Error::duplicate_field("properties"));
10138 }
10139 properties__ = Some(
10140 map_.next_value::<std::collections::BTreeMap<_, _>>()?
10141 );
10142 }
10143 GeneratedField::SinkType => {
10144 if sink_type__.is_some() {
10145 return Err(serde::de::Error::duplicate_field("sinkType"));
10146 }
10147 sink_type__ = Some(map_.next_value::<super::catalog::SinkType>()? as i32);
10148 }
10149 GeneratedField::ColumnCatalogs => {
10150 if column_catalogs__.is_some() {
10151 return Err(serde::de::Error::duplicate_field("columnCatalogs"));
10152 }
10153 column_catalogs__ = Some(map_.next_value()?);
10154 }
10155 GeneratedField::DbName => {
10156 if db_name__.is_some() {
10157 return Err(serde::de::Error::duplicate_field("dbName"));
10158 }
10159 db_name__ = Some(map_.next_value()?);
10160 }
10161 GeneratedField::SinkFromName => {
10162 if sink_from_name__.is_some() {
10163 return Err(serde::de::Error::duplicate_field("sinkFromName"));
10164 }
10165 sink_from_name__ = Some(map_.next_value()?);
10166 }
10167 GeneratedField::FormatDesc => {
10168 if format_desc__.is_some() {
10169 return Err(serde::de::Error::duplicate_field("formatDesc"));
10170 }
10171 format_desc__ = map_.next_value()?;
10172 }
10173 GeneratedField::TargetTable => {
10174 if target_table__.is_some() {
10175 return Err(serde::de::Error::duplicate_field("targetTable"));
10176 }
10177 target_table__ =
10178 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10179 ;
10180 }
10181 GeneratedField::ExtraPartitionColIdx => {
10182 if extra_partition_col_idx__.is_some() {
10183 return Err(serde::de::Error::duplicate_field("extraPartitionColIdx"));
10184 }
10185 extra_partition_col_idx__ =
10186 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10187 ;
10188 }
10189 GeneratedField::SecretRefs => {
10190 if secret_refs__.is_some() {
10191 return Err(serde::de::Error::duplicate_field("secretRefs"));
10192 }
10193 secret_refs__ = Some(
10194 map_.next_value::<std::collections::BTreeMap<_, _>>()?
10195 );
10196 }
10197 GeneratedField::RawIgnoreDelete => {
10198 if raw_ignore_delete__.is_some() {
10199 return Err(serde::de::Error::duplicate_field("rawIgnoreDelete"));
10200 }
10201 raw_ignore_delete__ = Some(map_.next_value()?);
10202 }
10203 }
10204 }
10205 Ok(SinkDesc {
10206 id: id__.unwrap_or_default(),
10207 name: name__.unwrap_or_default(),
10208 definition: definition__.unwrap_or_default(),
10209 plan_pk: plan_pk__.unwrap_or_default(),
10210 downstream_pk: downstream_pk__.unwrap_or_default(),
10211 distribution_key: distribution_key__.unwrap_or_default(),
10212 properties: properties__.unwrap_or_default(),
10213 sink_type: sink_type__.unwrap_or_default(),
10214 column_catalogs: column_catalogs__.unwrap_or_default(),
10215 db_name: db_name__.unwrap_or_default(),
10216 sink_from_name: sink_from_name__.unwrap_or_default(),
10217 format_desc: format_desc__,
10218 target_table: target_table__,
10219 extra_partition_col_idx: extra_partition_col_idx__,
10220 secret_refs: secret_refs__.unwrap_or_default(),
10221 raw_ignore_delete: raw_ignore_delete__.unwrap_or_default(),
10222 })
10223 }
10224 }
10225 deserializer.deserialize_struct("stream_plan.SinkDesc", FIELDS, GeneratedVisitor)
10226 }
10227}
10228impl serde::Serialize for SinkDropColumnsOp {
10229 #[allow(deprecated)]
10230 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10231 where
10232 S: serde::Serializer,
10233 {
10234 use serde::ser::SerializeStruct;
10235 let mut len = 0;
10236 if !self.column_names.is_empty() {
10237 len += 1;
10238 }
10239 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDropColumnsOp", len)?;
10240 if !self.column_names.is_empty() {
10241 struct_ser.serialize_field("columnNames", &self.column_names)?;
10242 }
10243 struct_ser.end()
10244 }
10245}
10246impl<'de> serde::Deserialize<'de> for SinkDropColumnsOp {
10247 #[allow(deprecated)]
10248 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10249 where
10250 D: serde::Deserializer<'de>,
10251 {
10252 const FIELDS: &[&str] = &[
10253 "column_names",
10254 "columnNames",
10255 ];
10256
10257 #[allow(clippy::enum_variant_names)]
10258 enum GeneratedField {
10259 ColumnNames,
10260 }
10261 impl<'de> serde::Deserialize<'de> for GeneratedField {
10262 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10263 where
10264 D: serde::Deserializer<'de>,
10265 {
10266 struct GeneratedVisitor;
10267
10268 impl serde::de::Visitor<'_> for GeneratedVisitor {
10269 type Value = GeneratedField;
10270
10271 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10272 write!(formatter, "expected one of: {:?}", &FIELDS)
10273 }
10274
10275 #[allow(unused_variables)]
10276 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10277 where
10278 E: serde::de::Error,
10279 {
10280 match value {
10281 "columnNames" | "column_names" => Ok(GeneratedField::ColumnNames),
10282 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10283 }
10284 }
10285 }
10286 deserializer.deserialize_identifier(GeneratedVisitor)
10287 }
10288 }
10289 struct GeneratedVisitor;
10290 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10291 type Value = SinkDropColumnsOp;
10292
10293 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10294 formatter.write_str("struct stream_plan.SinkDropColumnsOp")
10295 }
10296
10297 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDropColumnsOp, V::Error>
10298 where
10299 V: serde::de::MapAccess<'de>,
10300 {
10301 let mut column_names__ = None;
10302 while let Some(k) = map_.next_key()? {
10303 match k {
10304 GeneratedField::ColumnNames => {
10305 if column_names__.is_some() {
10306 return Err(serde::de::Error::duplicate_field("columnNames"));
10307 }
10308 column_names__ = Some(map_.next_value()?);
10309 }
10310 }
10311 }
10312 Ok(SinkDropColumnsOp {
10313 column_names: column_names__.unwrap_or_default(),
10314 })
10315 }
10316 }
10317 deserializer.deserialize_struct("stream_plan.SinkDropColumnsOp", FIELDS, GeneratedVisitor)
10318 }
10319}
10320impl serde::Serialize for SinkLogStoreType {
10321 #[allow(deprecated)]
10322 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10323 where
10324 S: serde::Serializer,
10325 {
10326 let variant = match self {
10327 Self::Unspecified => "SINK_LOG_STORE_TYPE_UNSPECIFIED",
10328 Self::KvLogStore => "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
10329 Self::InMemoryLogStore => "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
10330 };
10331 serializer.serialize_str(variant)
10332 }
10333}
10334impl<'de> serde::Deserialize<'de> for SinkLogStoreType {
10335 #[allow(deprecated)]
10336 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10337 where
10338 D: serde::Deserializer<'de>,
10339 {
10340 const FIELDS: &[&str] = &[
10341 "SINK_LOG_STORE_TYPE_UNSPECIFIED",
10342 "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
10343 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
10344 ];
10345
10346 struct GeneratedVisitor;
10347
10348 impl serde::de::Visitor<'_> for GeneratedVisitor {
10349 type Value = SinkLogStoreType;
10350
10351 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10352 write!(formatter, "expected one of: {:?}", &FIELDS)
10353 }
10354
10355 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
10356 where
10357 E: serde::de::Error,
10358 {
10359 i32::try_from(v)
10360 .ok()
10361 .and_then(|x| x.try_into().ok())
10362 .ok_or_else(|| {
10363 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
10364 })
10365 }
10366
10367 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
10368 where
10369 E: serde::de::Error,
10370 {
10371 i32::try_from(v)
10372 .ok()
10373 .and_then(|x| x.try_into().ok())
10374 .ok_or_else(|| {
10375 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
10376 })
10377 }
10378
10379 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
10380 where
10381 E: serde::de::Error,
10382 {
10383 match value {
10384 "SINK_LOG_STORE_TYPE_UNSPECIFIED" => Ok(SinkLogStoreType::Unspecified),
10385 "SINK_LOG_STORE_TYPE_KV_LOG_STORE" => Ok(SinkLogStoreType::KvLogStore),
10386 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE" => Ok(SinkLogStoreType::InMemoryLogStore),
10387 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
10388 }
10389 }
10390 }
10391 deserializer.deserialize_any(GeneratedVisitor)
10392 }
10393}
10394impl serde::Serialize for SinkNode {
10395 #[allow(deprecated)]
10396 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10397 where
10398 S: serde::Serializer,
10399 {
10400 use serde::ser::SerializeStruct;
10401 let mut len = 0;
10402 if self.sink_desc.is_some() {
10403 len += 1;
10404 }
10405 if self.table.is_some() {
10406 len += 1;
10407 }
10408 if self.log_store_type != 0 {
10409 len += 1;
10410 }
10411 if self.rate_limit.is_some() {
10412 len += 1;
10413 }
10414 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkNode", len)?;
10415 if let Some(v) = self.sink_desc.as_ref() {
10416 struct_ser.serialize_field("sinkDesc", v)?;
10417 }
10418 if let Some(v) = self.table.as_ref() {
10419 struct_ser.serialize_field("table", v)?;
10420 }
10421 if self.log_store_type != 0 {
10422 let v = SinkLogStoreType::try_from(self.log_store_type)
10423 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.log_store_type)))?;
10424 struct_ser.serialize_field("logStoreType", &v)?;
10425 }
10426 if let Some(v) = self.rate_limit.as_ref() {
10427 struct_ser.serialize_field("rateLimit", v)?;
10428 }
10429 struct_ser.end()
10430 }
10431}
10432impl<'de> serde::Deserialize<'de> for SinkNode {
10433 #[allow(deprecated)]
10434 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10435 where
10436 D: serde::Deserializer<'de>,
10437 {
10438 const FIELDS: &[&str] = &[
10439 "sink_desc",
10440 "sinkDesc",
10441 "table",
10442 "log_store_type",
10443 "logStoreType",
10444 "rate_limit",
10445 "rateLimit",
10446 ];
10447
10448 #[allow(clippy::enum_variant_names)]
10449 enum GeneratedField {
10450 SinkDesc,
10451 Table,
10452 LogStoreType,
10453 RateLimit,
10454 }
10455 impl<'de> serde::Deserialize<'de> for GeneratedField {
10456 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10457 where
10458 D: serde::Deserializer<'de>,
10459 {
10460 struct GeneratedVisitor;
10461
10462 impl serde::de::Visitor<'_> for GeneratedVisitor {
10463 type Value = GeneratedField;
10464
10465 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10466 write!(formatter, "expected one of: {:?}", &FIELDS)
10467 }
10468
10469 #[allow(unused_variables)]
10470 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10471 where
10472 E: serde::de::Error,
10473 {
10474 match value {
10475 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
10476 "table" => Ok(GeneratedField::Table),
10477 "logStoreType" | "log_store_type" => Ok(GeneratedField::LogStoreType),
10478 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
10479 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10480 }
10481 }
10482 }
10483 deserializer.deserialize_identifier(GeneratedVisitor)
10484 }
10485 }
10486 struct GeneratedVisitor;
10487 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10488 type Value = SinkNode;
10489
10490 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10491 formatter.write_str("struct stream_plan.SinkNode")
10492 }
10493
10494 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkNode, V::Error>
10495 where
10496 V: serde::de::MapAccess<'de>,
10497 {
10498 let mut sink_desc__ = None;
10499 let mut table__ = None;
10500 let mut log_store_type__ = None;
10501 let mut rate_limit__ = None;
10502 while let Some(k) = map_.next_key()? {
10503 match k {
10504 GeneratedField::SinkDesc => {
10505 if sink_desc__.is_some() {
10506 return Err(serde::de::Error::duplicate_field("sinkDesc"));
10507 }
10508 sink_desc__ = map_.next_value()?;
10509 }
10510 GeneratedField::Table => {
10511 if table__.is_some() {
10512 return Err(serde::de::Error::duplicate_field("table"));
10513 }
10514 table__ = map_.next_value()?;
10515 }
10516 GeneratedField::LogStoreType => {
10517 if log_store_type__.is_some() {
10518 return Err(serde::de::Error::duplicate_field("logStoreType"));
10519 }
10520 log_store_type__ = Some(map_.next_value::<SinkLogStoreType>()? as i32);
10521 }
10522 GeneratedField::RateLimit => {
10523 if rate_limit__.is_some() {
10524 return Err(serde::de::Error::duplicate_field("rateLimit"));
10525 }
10526 rate_limit__ =
10527 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10528 ;
10529 }
10530 }
10531 }
10532 Ok(SinkNode {
10533 sink_desc: sink_desc__,
10534 table: table__,
10535 log_store_type: log_store_type__.unwrap_or_default(),
10536 rate_limit: rate_limit__,
10537 })
10538 }
10539 }
10540 deserializer.deserialize_struct("stream_plan.SinkNode", FIELDS, GeneratedVisitor)
10541 }
10542}
10543impl serde::Serialize for SinkSchemaChange {
10544 #[allow(deprecated)]
10545 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10546 where
10547 S: serde::Serializer,
10548 {
10549 use serde::ser::SerializeStruct;
10550 let mut len = 0;
10551 if !self.original_schema.is_empty() {
10552 len += 1;
10553 }
10554 if self.op.is_some() {
10555 len += 1;
10556 }
10557 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkSchemaChange", len)?;
10558 if !self.original_schema.is_empty() {
10559 struct_ser.serialize_field("originalSchema", &self.original_schema)?;
10560 }
10561 if let Some(v) = self.op.as_ref() {
10562 match v {
10563 sink_schema_change::Op::AddColumns(v) => {
10564 struct_ser.serialize_field("addColumns", v)?;
10565 }
10566 sink_schema_change::Op::DropColumns(v) => {
10567 struct_ser.serialize_field("dropColumns", v)?;
10568 }
10569 }
10570 }
10571 struct_ser.end()
10572 }
10573}
10574impl<'de> serde::Deserialize<'de> for SinkSchemaChange {
10575 #[allow(deprecated)]
10576 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10577 where
10578 D: serde::Deserializer<'de>,
10579 {
10580 const FIELDS: &[&str] = &[
10581 "original_schema",
10582 "originalSchema",
10583 "add_columns",
10584 "addColumns",
10585 "drop_columns",
10586 "dropColumns",
10587 ];
10588
10589 #[allow(clippy::enum_variant_names)]
10590 enum GeneratedField {
10591 OriginalSchema,
10592 AddColumns,
10593 DropColumns,
10594 }
10595 impl<'de> serde::Deserialize<'de> for GeneratedField {
10596 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10597 where
10598 D: serde::Deserializer<'de>,
10599 {
10600 struct GeneratedVisitor;
10601
10602 impl serde::de::Visitor<'_> for GeneratedVisitor {
10603 type Value = GeneratedField;
10604
10605 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10606 write!(formatter, "expected one of: {:?}", &FIELDS)
10607 }
10608
10609 #[allow(unused_variables)]
10610 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10611 where
10612 E: serde::de::Error,
10613 {
10614 match value {
10615 "originalSchema" | "original_schema" => Ok(GeneratedField::OriginalSchema),
10616 "addColumns" | "add_columns" => Ok(GeneratedField::AddColumns),
10617 "dropColumns" | "drop_columns" => Ok(GeneratedField::DropColumns),
10618 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10619 }
10620 }
10621 }
10622 deserializer.deserialize_identifier(GeneratedVisitor)
10623 }
10624 }
10625 struct GeneratedVisitor;
10626 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10627 type Value = SinkSchemaChange;
10628
10629 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10630 formatter.write_str("struct stream_plan.SinkSchemaChange")
10631 }
10632
10633 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkSchemaChange, V::Error>
10634 where
10635 V: serde::de::MapAccess<'de>,
10636 {
10637 let mut original_schema__ = None;
10638 let mut op__ = None;
10639 while let Some(k) = map_.next_key()? {
10640 match k {
10641 GeneratedField::OriginalSchema => {
10642 if original_schema__.is_some() {
10643 return Err(serde::de::Error::duplicate_field("originalSchema"));
10644 }
10645 original_schema__ = Some(map_.next_value()?);
10646 }
10647 GeneratedField::AddColumns => {
10648 if op__.is_some() {
10649 return Err(serde::de::Error::duplicate_field("addColumns"));
10650 }
10651 op__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_schema_change::Op::AddColumns)
10652;
10653 }
10654 GeneratedField::DropColumns => {
10655 if op__.is_some() {
10656 return Err(serde::de::Error::duplicate_field("dropColumns"));
10657 }
10658 op__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_schema_change::Op::DropColumns)
10659;
10660 }
10661 }
10662 }
10663 Ok(SinkSchemaChange {
10664 original_schema: original_schema__.unwrap_or_default(),
10665 op: op__,
10666 })
10667 }
10668 }
10669 deserializer.deserialize_struct("stream_plan.SinkSchemaChange", FIELDS, GeneratedVisitor)
10670 }
10671}
10672impl serde::Serialize for SortNode {
10673 #[allow(deprecated)]
10674 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10675 where
10676 S: serde::Serializer,
10677 {
10678 use serde::ser::SerializeStruct;
10679 let mut len = 0;
10680 if self.state_table.is_some() {
10681 len += 1;
10682 }
10683 if self.sort_column_index != 0 {
10684 len += 1;
10685 }
10686 let mut struct_ser = serializer.serialize_struct("stream_plan.SortNode", len)?;
10687 if let Some(v) = self.state_table.as_ref() {
10688 struct_ser.serialize_field("stateTable", v)?;
10689 }
10690 if self.sort_column_index != 0 {
10691 struct_ser.serialize_field("sortColumnIndex", &self.sort_column_index)?;
10692 }
10693 struct_ser.end()
10694 }
10695}
10696impl<'de> serde::Deserialize<'de> for SortNode {
10697 #[allow(deprecated)]
10698 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10699 where
10700 D: serde::Deserializer<'de>,
10701 {
10702 const FIELDS: &[&str] = &[
10703 "state_table",
10704 "stateTable",
10705 "sort_column_index",
10706 "sortColumnIndex",
10707 ];
10708
10709 #[allow(clippy::enum_variant_names)]
10710 enum GeneratedField {
10711 StateTable,
10712 SortColumnIndex,
10713 }
10714 impl<'de> serde::Deserialize<'de> for GeneratedField {
10715 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10716 where
10717 D: serde::Deserializer<'de>,
10718 {
10719 struct GeneratedVisitor;
10720
10721 impl serde::de::Visitor<'_> for GeneratedVisitor {
10722 type Value = GeneratedField;
10723
10724 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10725 write!(formatter, "expected one of: {:?}", &FIELDS)
10726 }
10727
10728 #[allow(unused_variables)]
10729 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10730 where
10731 E: serde::de::Error,
10732 {
10733 match value {
10734 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
10735 "sortColumnIndex" | "sort_column_index" => Ok(GeneratedField::SortColumnIndex),
10736 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10737 }
10738 }
10739 }
10740 deserializer.deserialize_identifier(GeneratedVisitor)
10741 }
10742 }
10743 struct GeneratedVisitor;
10744 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10745 type Value = SortNode;
10746
10747 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10748 formatter.write_str("struct stream_plan.SortNode")
10749 }
10750
10751 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
10752 where
10753 V: serde::de::MapAccess<'de>,
10754 {
10755 let mut state_table__ = None;
10756 let mut sort_column_index__ = None;
10757 while let Some(k) = map_.next_key()? {
10758 match k {
10759 GeneratedField::StateTable => {
10760 if state_table__.is_some() {
10761 return Err(serde::de::Error::duplicate_field("stateTable"));
10762 }
10763 state_table__ = map_.next_value()?;
10764 }
10765 GeneratedField::SortColumnIndex => {
10766 if sort_column_index__.is_some() {
10767 return Err(serde::de::Error::duplicate_field("sortColumnIndex"));
10768 }
10769 sort_column_index__ =
10770 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10771 ;
10772 }
10773 }
10774 }
10775 Ok(SortNode {
10776 state_table: state_table__,
10777 sort_column_index: sort_column_index__.unwrap_or_default(),
10778 })
10779 }
10780 }
10781 deserializer.deserialize_struct("stream_plan.SortNode", FIELDS, GeneratedVisitor)
10782 }
10783}
10784impl serde::Serialize for SourceBackfillNode {
10785 #[allow(deprecated)]
10786 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10787 where
10788 S: serde::Serializer,
10789 {
10790 use serde::ser::SerializeStruct;
10791 let mut len = 0;
10792 if self.upstream_source_id != 0 {
10793 len += 1;
10794 }
10795 if self.row_id_index.is_some() {
10796 len += 1;
10797 }
10798 if !self.columns.is_empty() {
10799 len += 1;
10800 }
10801 if self.info.is_some() {
10802 len += 1;
10803 }
10804 if !self.source_name.is_empty() {
10805 len += 1;
10806 }
10807 if !self.with_properties.is_empty() {
10808 len += 1;
10809 }
10810 if self.rate_limit.is_some() {
10811 len += 1;
10812 }
10813 if self.state_table.is_some() {
10814 len += 1;
10815 }
10816 if !self.secret_refs.is_empty() {
10817 len += 1;
10818 }
10819 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceBackfillNode", len)?;
10820 if self.upstream_source_id != 0 {
10821 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
10822 }
10823 if let Some(v) = self.row_id_index.as_ref() {
10824 struct_ser.serialize_field("rowIdIndex", v)?;
10825 }
10826 if !self.columns.is_empty() {
10827 struct_ser.serialize_field("columns", &self.columns)?;
10828 }
10829 if let Some(v) = self.info.as_ref() {
10830 struct_ser.serialize_field("info", v)?;
10831 }
10832 if !self.source_name.is_empty() {
10833 struct_ser.serialize_field("sourceName", &self.source_name)?;
10834 }
10835 if !self.with_properties.is_empty() {
10836 struct_ser.serialize_field("withProperties", &self.with_properties)?;
10837 }
10838 if let Some(v) = self.rate_limit.as_ref() {
10839 struct_ser.serialize_field("rateLimit", v)?;
10840 }
10841 if let Some(v) = self.state_table.as_ref() {
10842 struct_ser.serialize_field("stateTable", v)?;
10843 }
10844 if !self.secret_refs.is_empty() {
10845 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
10846 }
10847 struct_ser.end()
10848 }
10849}
10850impl<'de> serde::Deserialize<'de> for SourceBackfillNode {
10851 #[allow(deprecated)]
10852 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10853 where
10854 D: serde::Deserializer<'de>,
10855 {
10856 const FIELDS: &[&str] = &[
10857 "upstream_source_id",
10858 "upstreamSourceId",
10859 "row_id_index",
10860 "rowIdIndex",
10861 "columns",
10862 "info",
10863 "source_name",
10864 "sourceName",
10865 "with_properties",
10866 "withProperties",
10867 "rate_limit",
10868 "rateLimit",
10869 "state_table",
10870 "stateTable",
10871 "secret_refs",
10872 "secretRefs",
10873 ];
10874
10875 #[allow(clippy::enum_variant_names)]
10876 enum GeneratedField {
10877 UpstreamSourceId,
10878 RowIdIndex,
10879 Columns,
10880 Info,
10881 SourceName,
10882 WithProperties,
10883 RateLimit,
10884 StateTable,
10885 SecretRefs,
10886 }
10887 impl<'de> serde::Deserialize<'de> for GeneratedField {
10888 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10889 where
10890 D: serde::Deserializer<'de>,
10891 {
10892 struct GeneratedVisitor;
10893
10894 impl serde::de::Visitor<'_> for GeneratedVisitor {
10895 type Value = GeneratedField;
10896
10897 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10898 write!(formatter, "expected one of: {:?}", &FIELDS)
10899 }
10900
10901 #[allow(unused_variables)]
10902 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10903 where
10904 E: serde::de::Error,
10905 {
10906 match value {
10907 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
10908 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
10909 "columns" => Ok(GeneratedField::Columns),
10910 "info" => Ok(GeneratedField::Info),
10911 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
10912 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
10913 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
10914 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
10915 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
10916 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10917 }
10918 }
10919 }
10920 deserializer.deserialize_identifier(GeneratedVisitor)
10921 }
10922 }
10923 struct GeneratedVisitor;
10924 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10925 type Value = SourceBackfillNode;
10926
10927 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10928 formatter.write_str("struct stream_plan.SourceBackfillNode")
10929 }
10930
10931 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceBackfillNode, V::Error>
10932 where
10933 V: serde::de::MapAccess<'de>,
10934 {
10935 let mut upstream_source_id__ = None;
10936 let mut row_id_index__ = None;
10937 let mut columns__ = None;
10938 let mut info__ = None;
10939 let mut source_name__ = None;
10940 let mut with_properties__ = None;
10941 let mut rate_limit__ = None;
10942 let mut state_table__ = None;
10943 let mut secret_refs__ = None;
10944 while let Some(k) = map_.next_key()? {
10945 match k {
10946 GeneratedField::UpstreamSourceId => {
10947 if upstream_source_id__.is_some() {
10948 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
10949 }
10950 upstream_source_id__ =
10951 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10952 ;
10953 }
10954 GeneratedField::RowIdIndex => {
10955 if row_id_index__.is_some() {
10956 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
10957 }
10958 row_id_index__ =
10959 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10960 ;
10961 }
10962 GeneratedField::Columns => {
10963 if columns__.is_some() {
10964 return Err(serde::de::Error::duplicate_field("columns"));
10965 }
10966 columns__ = Some(map_.next_value()?);
10967 }
10968 GeneratedField::Info => {
10969 if info__.is_some() {
10970 return Err(serde::de::Error::duplicate_field("info"));
10971 }
10972 info__ = map_.next_value()?;
10973 }
10974 GeneratedField::SourceName => {
10975 if source_name__.is_some() {
10976 return Err(serde::de::Error::duplicate_field("sourceName"));
10977 }
10978 source_name__ = Some(map_.next_value()?);
10979 }
10980 GeneratedField::WithProperties => {
10981 if with_properties__.is_some() {
10982 return Err(serde::de::Error::duplicate_field("withProperties"));
10983 }
10984 with_properties__ = Some(
10985 map_.next_value::<std::collections::BTreeMap<_, _>>()?
10986 );
10987 }
10988 GeneratedField::RateLimit => {
10989 if rate_limit__.is_some() {
10990 return Err(serde::de::Error::duplicate_field("rateLimit"));
10991 }
10992 rate_limit__ =
10993 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10994 ;
10995 }
10996 GeneratedField::StateTable => {
10997 if state_table__.is_some() {
10998 return Err(serde::de::Error::duplicate_field("stateTable"));
10999 }
11000 state_table__ = map_.next_value()?;
11001 }
11002 GeneratedField::SecretRefs => {
11003 if secret_refs__.is_some() {
11004 return Err(serde::de::Error::duplicate_field("secretRefs"));
11005 }
11006 secret_refs__ = Some(
11007 map_.next_value::<std::collections::BTreeMap<_, _>>()?
11008 );
11009 }
11010 }
11011 }
11012 Ok(SourceBackfillNode {
11013 upstream_source_id: upstream_source_id__.unwrap_or_default(),
11014 row_id_index: row_id_index__,
11015 columns: columns__.unwrap_or_default(),
11016 info: info__,
11017 source_name: source_name__.unwrap_or_default(),
11018 with_properties: with_properties__.unwrap_or_default(),
11019 rate_limit: rate_limit__,
11020 state_table: state_table__,
11021 secret_refs: secret_refs__.unwrap_or_default(),
11022 })
11023 }
11024 }
11025 deserializer.deserialize_struct("stream_plan.SourceBackfillNode", FIELDS, GeneratedVisitor)
11026 }
11027}
11028impl serde::Serialize for SourceChangeSplitMutation {
11029 #[allow(deprecated)]
11030 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11031 where
11032 S: serde::Serializer,
11033 {
11034 use serde::ser::SerializeStruct;
11035 let mut len = 0;
11036 if !self.actor_splits.is_empty() {
11037 len += 1;
11038 }
11039 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceChangeSplitMutation", len)?;
11040 if !self.actor_splits.is_empty() {
11041 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
11042 }
11043 struct_ser.end()
11044 }
11045}
11046impl<'de> serde::Deserialize<'de> for SourceChangeSplitMutation {
11047 #[allow(deprecated)]
11048 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11049 where
11050 D: serde::Deserializer<'de>,
11051 {
11052 const FIELDS: &[&str] = &[
11053 "actor_splits",
11054 "actorSplits",
11055 ];
11056
11057 #[allow(clippy::enum_variant_names)]
11058 enum GeneratedField {
11059 ActorSplits,
11060 }
11061 impl<'de> serde::Deserialize<'de> for GeneratedField {
11062 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11063 where
11064 D: serde::Deserializer<'de>,
11065 {
11066 struct GeneratedVisitor;
11067
11068 impl serde::de::Visitor<'_> for GeneratedVisitor {
11069 type Value = GeneratedField;
11070
11071 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11072 write!(formatter, "expected one of: {:?}", &FIELDS)
11073 }
11074
11075 #[allow(unused_variables)]
11076 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11077 where
11078 E: serde::de::Error,
11079 {
11080 match value {
11081 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
11082 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11083 }
11084 }
11085 }
11086 deserializer.deserialize_identifier(GeneratedVisitor)
11087 }
11088 }
11089 struct GeneratedVisitor;
11090 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11091 type Value = SourceChangeSplitMutation;
11092
11093 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11094 formatter.write_str("struct stream_plan.SourceChangeSplitMutation")
11095 }
11096
11097 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceChangeSplitMutation, V::Error>
11098 where
11099 V: serde::de::MapAccess<'de>,
11100 {
11101 let mut actor_splits__ = None;
11102 while let Some(k) = map_.next_key()? {
11103 match k {
11104 GeneratedField::ActorSplits => {
11105 if actor_splits__.is_some() {
11106 return Err(serde::de::Error::duplicate_field("actorSplits"));
11107 }
11108 actor_splits__ = Some(
11109 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11110 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
11111 );
11112 }
11113 }
11114 }
11115 Ok(SourceChangeSplitMutation {
11116 actor_splits: actor_splits__.unwrap_or_default(),
11117 })
11118 }
11119 }
11120 deserializer.deserialize_struct("stream_plan.SourceChangeSplitMutation", FIELDS, GeneratedVisitor)
11121 }
11122}
11123impl serde::Serialize for SourceNode {
11124 #[allow(deprecated)]
11125 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11126 where
11127 S: serde::Serializer,
11128 {
11129 use serde::ser::SerializeStruct;
11130 let mut len = 0;
11131 if self.source_inner.is_some() {
11132 len += 1;
11133 }
11134 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceNode", len)?;
11135 if let Some(v) = self.source_inner.as_ref() {
11136 struct_ser.serialize_field("sourceInner", v)?;
11137 }
11138 struct_ser.end()
11139 }
11140}
11141impl<'de> serde::Deserialize<'de> for SourceNode {
11142 #[allow(deprecated)]
11143 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11144 where
11145 D: serde::Deserializer<'de>,
11146 {
11147 const FIELDS: &[&str] = &[
11148 "source_inner",
11149 "sourceInner",
11150 ];
11151
11152 #[allow(clippy::enum_variant_names)]
11153 enum GeneratedField {
11154 SourceInner,
11155 }
11156 impl<'de> serde::Deserialize<'de> for GeneratedField {
11157 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11158 where
11159 D: serde::Deserializer<'de>,
11160 {
11161 struct GeneratedVisitor;
11162
11163 impl serde::de::Visitor<'_> for GeneratedVisitor {
11164 type Value = GeneratedField;
11165
11166 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11167 write!(formatter, "expected one of: {:?}", &FIELDS)
11168 }
11169
11170 #[allow(unused_variables)]
11171 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11172 where
11173 E: serde::de::Error,
11174 {
11175 match value {
11176 "sourceInner" | "source_inner" => Ok(GeneratedField::SourceInner),
11177 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11178 }
11179 }
11180 }
11181 deserializer.deserialize_identifier(GeneratedVisitor)
11182 }
11183 }
11184 struct GeneratedVisitor;
11185 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11186 type Value = SourceNode;
11187
11188 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11189 formatter.write_str("struct stream_plan.SourceNode")
11190 }
11191
11192 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
11193 where
11194 V: serde::de::MapAccess<'de>,
11195 {
11196 let mut source_inner__ = None;
11197 while let Some(k) = map_.next_key()? {
11198 match k {
11199 GeneratedField::SourceInner => {
11200 if source_inner__.is_some() {
11201 return Err(serde::de::Error::duplicate_field("sourceInner"));
11202 }
11203 source_inner__ = map_.next_value()?;
11204 }
11205 }
11206 }
11207 Ok(SourceNode {
11208 source_inner: source_inner__,
11209 })
11210 }
11211 }
11212 deserializer.deserialize_struct("stream_plan.SourceNode", FIELDS, GeneratedVisitor)
11213 }
11214}
11215impl serde::Serialize for StartFragmentBackfillMutation {
11216 #[allow(deprecated)]
11217 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11218 where
11219 S: serde::Serializer,
11220 {
11221 use serde::ser::SerializeStruct;
11222 let mut len = 0;
11223 if !self.fragment_ids.is_empty() {
11224 len += 1;
11225 }
11226 let mut struct_ser = serializer.serialize_struct("stream_plan.StartFragmentBackfillMutation", len)?;
11227 if !self.fragment_ids.is_empty() {
11228 struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
11229 }
11230 struct_ser.end()
11231 }
11232}
11233impl<'de> serde::Deserialize<'de> for StartFragmentBackfillMutation {
11234 #[allow(deprecated)]
11235 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11236 where
11237 D: serde::Deserializer<'de>,
11238 {
11239 const FIELDS: &[&str] = &[
11240 "fragment_ids",
11241 "fragmentIds",
11242 ];
11243
11244 #[allow(clippy::enum_variant_names)]
11245 enum GeneratedField {
11246 FragmentIds,
11247 }
11248 impl<'de> serde::Deserialize<'de> for GeneratedField {
11249 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11250 where
11251 D: serde::Deserializer<'de>,
11252 {
11253 struct GeneratedVisitor;
11254
11255 impl serde::de::Visitor<'_> for GeneratedVisitor {
11256 type Value = GeneratedField;
11257
11258 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11259 write!(formatter, "expected one of: {:?}", &FIELDS)
11260 }
11261
11262 #[allow(unused_variables)]
11263 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11264 where
11265 E: serde::de::Error,
11266 {
11267 match value {
11268 "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
11269 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11270 }
11271 }
11272 }
11273 deserializer.deserialize_identifier(GeneratedVisitor)
11274 }
11275 }
11276 struct GeneratedVisitor;
11277 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11278 type Value = StartFragmentBackfillMutation;
11279
11280 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11281 formatter.write_str("struct stream_plan.StartFragmentBackfillMutation")
11282 }
11283
11284 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StartFragmentBackfillMutation, V::Error>
11285 where
11286 V: serde::de::MapAccess<'de>,
11287 {
11288 let mut fragment_ids__ = None;
11289 while let Some(k) = map_.next_key()? {
11290 match k {
11291 GeneratedField::FragmentIds => {
11292 if fragment_ids__.is_some() {
11293 return Err(serde::de::Error::duplicate_field("fragmentIds"));
11294 }
11295 fragment_ids__ =
11296 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11297 .into_iter().map(|x| x.0).collect())
11298 ;
11299 }
11300 }
11301 }
11302 Ok(StartFragmentBackfillMutation {
11303 fragment_ids: fragment_ids__.unwrap_or_default(),
11304 })
11305 }
11306 }
11307 deserializer.deserialize_struct("stream_plan.StartFragmentBackfillMutation", FIELDS, GeneratedVisitor)
11308 }
11309}
11310impl serde::Serialize for StopMutation {
11311 #[allow(deprecated)]
11312 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11313 where
11314 S: serde::Serializer,
11315 {
11316 use serde::ser::SerializeStruct;
11317 let mut len = 0;
11318 if !self.actors.is_empty() {
11319 len += 1;
11320 }
11321 if !self.dropped_sink_fragments.is_empty() {
11322 len += 1;
11323 }
11324 let mut struct_ser = serializer.serialize_struct("stream_plan.StopMutation", len)?;
11325 if !self.actors.is_empty() {
11326 struct_ser.serialize_field("actors", &self.actors)?;
11327 }
11328 if !self.dropped_sink_fragments.is_empty() {
11329 struct_ser.serialize_field("droppedSinkFragments", &self.dropped_sink_fragments)?;
11330 }
11331 struct_ser.end()
11332 }
11333}
11334impl<'de> serde::Deserialize<'de> for StopMutation {
11335 #[allow(deprecated)]
11336 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11337 where
11338 D: serde::Deserializer<'de>,
11339 {
11340 const FIELDS: &[&str] = &[
11341 "actors",
11342 "dropped_sink_fragments",
11343 "droppedSinkFragments",
11344 ];
11345
11346 #[allow(clippy::enum_variant_names)]
11347 enum GeneratedField {
11348 Actors,
11349 DroppedSinkFragments,
11350 }
11351 impl<'de> serde::Deserialize<'de> for GeneratedField {
11352 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11353 where
11354 D: serde::Deserializer<'de>,
11355 {
11356 struct GeneratedVisitor;
11357
11358 impl serde::de::Visitor<'_> for GeneratedVisitor {
11359 type Value = GeneratedField;
11360
11361 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11362 write!(formatter, "expected one of: {:?}", &FIELDS)
11363 }
11364
11365 #[allow(unused_variables)]
11366 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11367 where
11368 E: serde::de::Error,
11369 {
11370 match value {
11371 "actors" => Ok(GeneratedField::Actors),
11372 "droppedSinkFragments" | "dropped_sink_fragments" => Ok(GeneratedField::DroppedSinkFragments),
11373 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11374 }
11375 }
11376 }
11377 deserializer.deserialize_identifier(GeneratedVisitor)
11378 }
11379 }
11380 struct GeneratedVisitor;
11381 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11382 type Value = StopMutation;
11383
11384 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11385 formatter.write_str("struct stream_plan.StopMutation")
11386 }
11387
11388 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopMutation, V::Error>
11389 where
11390 V: serde::de::MapAccess<'de>,
11391 {
11392 let mut actors__ = None;
11393 let mut dropped_sink_fragments__ = None;
11394 while let Some(k) = map_.next_key()? {
11395 match k {
11396 GeneratedField::Actors => {
11397 if actors__.is_some() {
11398 return Err(serde::de::Error::duplicate_field("actors"));
11399 }
11400 actors__ =
11401 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11402 .into_iter().map(|x| x.0).collect())
11403 ;
11404 }
11405 GeneratedField::DroppedSinkFragments => {
11406 if dropped_sink_fragments__.is_some() {
11407 return Err(serde::de::Error::duplicate_field("droppedSinkFragments"));
11408 }
11409 dropped_sink_fragments__ =
11410 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11411 .into_iter().map(|x| x.0).collect())
11412 ;
11413 }
11414 }
11415 }
11416 Ok(StopMutation {
11417 actors: actors__.unwrap_or_default(),
11418 dropped_sink_fragments: dropped_sink_fragments__.unwrap_or_default(),
11419 })
11420 }
11421 }
11422 deserializer.deserialize_struct("stream_plan.StopMutation", FIELDS, GeneratedVisitor)
11423 }
11424}
11425impl serde::Serialize for StreamActor {
11426 #[allow(deprecated)]
11427 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11428 where
11429 S: serde::Serializer,
11430 {
11431 use serde::ser::SerializeStruct;
11432 let mut len = 0;
11433 if self.actor_id != 0 {
11434 len += 1;
11435 }
11436 if self.fragment_id != 0 {
11437 len += 1;
11438 }
11439 if !self.dispatcher.is_empty() {
11440 len += 1;
11441 }
11442 if self.vnode_bitmap.is_some() {
11443 len += 1;
11444 }
11445 if !self.mview_definition.is_empty() {
11446 len += 1;
11447 }
11448 if self.expr_context.is_some() {
11449 len += 1;
11450 }
11451 if !self.config_override.is_empty() {
11452 len += 1;
11453 }
11454 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamActor", len)?;
11455 if self.actor_id != 0 {
11456 struct_ser.serialize_field("actorId", &self.actor_id)?;
11457 }
11458 if self.fragment_id != 0 {
11459 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
11460 }
11461 if !self.dispatcher.is_empty() {
11462 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
11463 }
11464 if let Some(v) = self.vnode_bitmap.as_ref() {
11465 struct_ser.serialize_field("vnodeBitmap", v)?;
11466 }
11467 if !self.mview_definition.is_empty() {
11468 struct_ser.serialize_field("mviewDefinition", &self.mview_definition)?;
11469 }
11470 if let Some(v) = self.expr_context.as_ref() {
11471 struct_ser.serialize_field("exprContext", v)?;
11472 }
11473 if !self.config_override.is_empty() {
11474 struct_ser.serialize_field("configOverride", &self.config_override)?;
11475 }
11476 struct_ser.end()
11477 }
11478}
11479impl<'de> serde::Deserialize<'de> for StreamActor {
11480 #[allow(deprecated)]
11481 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11482 where
11483 D: serde::Deserializer<'de>,
11484 {
11485 const FIELDS: &[&str] = &[
11486 "actor_id",
11487 "actorId",
11488 "fragment_id",
11489 "fragmentId",
11490 "dispatcher",
11491 "vnode_bitmap",
11492 "vnodeBitmap",
11493 "mview_definition",
11494 "mviewDefinition",
11495 "expr_context",
11496 "exprContext",
11497 "config_override",
11498 "configOverride",
11499 ];
11500
11501 #[allow(clippy::enum_variant_names)]
11502 enum GeneratedField {
11503 ActorId,
11504 FragmentId,
11505 Dispatcher,
11506 VnodeBitmap,
11507 MviewDefinition,
11508 ExprContext,
11509 ConfigOverride,
11510 }
11511 impl<'de> serde::Deserialize<'de> for GeneratedField {
11512 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11513 where
11514 D: serde::Deserializer<'de>,
11515 {
11516 struct GeneratedVisitor;
11517
11518 impl serde::de::Visitor<'_> for GeneratedVisitor {
11519 type Value = GeneratedField;
11520
11521 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11522 write!(formatter, "expected one of: {:?}", &FIELDS)
11523 }
11524
11525 #[allow(unused_variables)]
11526 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11527 where
11528 E: serde::de::Error,
11529 {
11530 match value {
11531 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
11532 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
11533 "dispatcher" => Ok(GeneratedField::Dispatcher),
11534 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
11535 "mviewDefinition" | "mview_definition" => Ok(GeneratedField::MviewDefinition),
11536 "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
11537 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
11538 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11539 }
11540 }
11541 }
11542 deserializer.deserialize_identifier(GeneratedVisitor)
11543 }
11544 }
11545 struct GeneratedVisitor;
11546 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11547 type Value = StreamActor;
11548
11549 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11550 formatter.write_str("struct stream_plan.StreamActor")
11551 }
11552
11553 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamActor, V::Error>
11554 where
11555 V: serde::de::MapAccess<'de>,
11556 {
11557 let mut actor_id__ = None;
11558 let mut fragment_id__ = None;
11559 let mut dispatcher__ = None;
11560 let mut vnode_bitmap__ = None;
11561 let mut mview_definition__ = None;
11562 let mut expr_context__ = None;
11563 let mut config_override__ = None;
11564 while let Some(k) = map_.next_key()? {
11565 match k {
11566 GeneratedField::ActorId => {
11567 if actor_id__.is_some() {
11568 return Err(serde::de::Error::duplicate_field("actorId"));
11569 }
11570 actor_id__ =
11571 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11572 ;
11573 }
11574 GeneratedField::FragmentId => {
11575 if fragment_id__.is_some() {
11576 return Err(serde::de::Error::duplicate_field("fragmentId"));
11577 }
11578 fragment_id__ =
11579 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11580 ;
11581 }
11582 GeneratedField::Dispatcher => {
11583 if dispatcher__.is_some() {
11584 return Err(serde::de::Error::duplicate_field("dispatcher"));
11585 }
11586 dispatcher__ = Some(map_.next_value()?);
11587 }
11588 GeneratedField::VnodeBitmap => {
11589 if vnode_bitmap__.is_some() {
11590 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
11591 }
11592 vnode_bitmap__ = map_.next_value()?;
11593 }
11594 GeneratedField::MviewDefinition => {
11595 if mview_definition__.is_some() {
11596 return Err(serde::de::Error::duplicate_field("mviewDefinition"));
11597 }
11598 mview_definition__ = Some(map_.next_value()?);
11599 }
11600 GeneratedField::ExprContext => {
11601 if expr_context__.is_some() {
11602 return Err(serde::de::Error::duplicate_field("exprContext"));
11603 }
11604 expr_context__ = map_.next_value()?;
11605 }
11606 GeneratedField::ConfigOverride => {
11607 if config_override__.is_some() {
11608 return Err(serde::de::Error::duplicate_field("configOverride"));
11609 }
11610 config_override__ = Some(map_.next_value()?);
11611 }
11612 }
11613 }
11614 Ok(StreamActor {
11615 actor_id: actor_id__.unwrap_or_default(),
11616 fragment_id: fragment_id__.unwrap_or_default(),
11617 dispatcher: dispatcher__.unwrap_or_default(),
11618 vnode_bitmap: vnode_bitmap__,
11619 mview_definition: mview_definition__.unwrap_or_default(),
11620 expr_context: expr_context__,
11621 config_override: config_override__.unwrap_or_default(),
11622 })
11623 }
11624 }
11625 deserializer.deserialize_struct("stream_plan.StreamActor", FIELDS, GeneratedVisitor)
11626 }
11627}
11628impl serde::Serialize for StreamCdcScanNode {
11629 #[allow(deprecated)]
11630 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11631 where
11632 S: serde::Serializer,
11633 {
11634 use serde::ser::SerializeStruct;
11635 let mut len = 0;
11636 if self.table_id != 0 {
11637 len += 1;
11638 }
11639 if !self.upstream_column_ids.is_empty() {
11640 len += 1;
11641 }
11642 if !self.output_indices.is_empty() {
11643 len += 1;
11644 }
11645 if self.state_table.is_some() {
11646 len += 1;
11647 }
11648 if self.cdc_table_desc.is_some() {
11649 len += 1;
11650 }
11651 if self.rate_limit.is_some() {
11652 len += 1;
11653 }
11654 if self.disable_backfill {
11655 len += 1;
11656 }
11657 if self.options.is_some() {
11658 len += 1;
11659 }
11660 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanNode", len)?;
11661 if self.table_id != 0 {
11662 struct_ser.serialize_field("tableId", &self.table_id)?;
11663 }
11664 if !self.upstream_column_ids.is_empty() {
11665 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
11666 }
11667 if !self.output_indices.is_empty() {
11668 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
11669 }
11670 if let Some(v) = self.state_table.as_ref() {
11671 struct_ser.serialize_field("stateTable", v)?;
11672 }
11673 if let Some(v) = self.cdc_table_desc.as_ref() {
11674 struct_ser.serialize_field("cdcTableDesc", v)?;
11675 }
11676 if let Some(v) = self.rate_limit.as_ref() {
11677 struct_ser.serialize_field("rateLimit", v)?;
11678 }
11679 if self.disable_backfill {
11680 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
11681 }
11682 if let Some(v) = self.options.as_ref() {
11683 struct_ser.serialize_field("options", v)?;
11684 }
11685 struct_ser.end()
11686 }
11687}
11688impl<'de> serde::Deserialize<'de> for StreamCdcScanNode {
11689 #[allow(deprecated)]
11690 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11691 where
11692 D: serde::Deserializer<'de>,
11693 {
11694 const FIELDS: &[&str] = &[
11695 "table_id",
11696 "tableId",
11697 "upstream_column_ids",
11698 "upstreamColumnIds",
11699 "output_indices",
11700 "outputIndices",
11701 "state_table",
11702 "stateTable",
11703 "cdc_table_desc",
11704 "cdcTableDesc",
11705 "rate_limit",
11706 "rateLimit",
11707 "disable_backfill",
11708 "disableBackfill",
11709 "options",
11710 ];
11711
11712 #[allow(clippy::enum_variant_names)]
11713 enum GeneratedField {
11714 TableId,
11715 UpstreamColumnIds,
11716 OutputIndices,
11717 StateTable,
11718 CdcTableDesc,
11719 RateLimit,
11720 DisableBackfill,
11721 Options,
11722 }
11723 impl<'de> serde::Deserialize<'de> for GeneratedField {
11724 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11725 where
11726 D: serde::Deserializer<'de>,
11727 {
11728 struct GeneratedVisitor;
11729
11730 impl serde::de::Visitor<'_> for GeneratedVisitor {
11731 type Value = GeneratedField;
11732
11733 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11734 write!(formatter, "expected one of: {:?}", &FIELDS)
11735 }
11736
11737 #[allow(unused_variables)]
11738 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11739 where
11740 E: serde::de::Error,
11741 {
11742 match value {
11743 "tableId" | "table_id" => Ok(GeneratedField::TableId),
11744 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
11745 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
11746 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11747 "cdcTableDesc" | "cdc_table_desc" => Ok(GeneratedField::CdcTableDesc),
11748 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11749 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
11750 "options" => Ok(GeneratedField::Options),
11751 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11752 }
11753 }
11754 }
11755 deserializer.deserialize_identifier(GeneratedVisitor)
11756 }
11757 }
11758 struct GeneratedVisitor;
11759 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11760 type Value = StreamCdcScanNode;
11761
11762 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11763 formatter.write_str("struct stream_plan.StreamCdcScanNode")
11764 }
11765
11766 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanNode, V::Error>
11767 where
11768 V: serde::de::MapAccess<'de>,
11769 {
11770 let mut table_id__ = None;
11771 let mut upstream_column_ids__ = None;
11772 let mut output_indices__ = None;
11773 let mut state_table__ = None;
11774 let mut cdc_table_desc__ = None;
11775 let mut rate_limit__ = None;
11776 let mut disable_backfill__ = None;
11777 let mut options__ = None;
11778 while let Some(k) = map_.next_key()? {
11779 match k {
11780 GeneratedField::TableId => {
11781 if table_id__.is_some() {
11782 return Err(serde::de::Error::duplicate_field("tableId"));
11783 }
11784 table_id__ =
11785 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11786 ;
11787 }
11788 GeneratedField::UpstreamColumnIds => {
11789 if upstream_column_ids__.is_some() {
11790 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
11791 }
11792 upstream_column_ids__ =
11793 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11794 .into_iter().map(|x| x.0).collect())
11795 ;
11796 }
11797 GeneratedField::OutputIndices => {
11798 if output_indices__.is_some() {
11799 return Err(serde::de::Error::duplicate_field("outputIndices"));
11800 }
11801 output_indices__ =
11802 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11803 .into_iter().map(|x| x.0).collect())
11804 ;
11805 }
11806 GeneratedField::StateTable => {
11807 if state_table__.is_some() {
11808 return Err(serde::de::Error::duplicate_field("stateTable"));
11809 }
11810 state_table__ = map_.next_value()?;
11811 }
11812 GeneratedField::CdcTableDesc => {
11813 if cdc_table_desc__.is_some() {
11814 return Err(serde::de::Error::duplicate_field("cdcTableDesc"));
11815 }
11816 cdc_table_desc__ = map_.next_value()?;
11817 }
11818 GeneratedField::RateLimit => {
11819 if rate_limit__.is_some() {
11820 return Err(serde::de::Error::duplicate_field("rateLimit"));
11821 }
11822 rate_limit__ =
11823 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11824 ;
11825 }
11826 GeneratedField::DisableBackfill => {
11827 if disable_backfill__.is_some() {
11828 return Err(serde::de::Error::duplicate_field("disableBackfill"));
11829 }
11830 disable_backfill__ = Some(map_.next_value()?);
11831 }
11832 GeneratedField::Options => {
11833 if options__.is_some() {
11834 return Err(serde::de::Error::duplicate_field("options"));
11835 }
11836 options__ = map_.next_value()?;
11837 }
11838 }
11839 }
11840 Ok(StreamCdcScanNode {
11841 table_id: table_id__.unwrap_or_default(),
11842 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
11843 output_indices: output_indices__.unwrap_or_default(),
11844 state_table: state_table__,
11845 cdc_table_desc: cdc_table_desc__,
11846 rate_limit: rate_limit__,
11847 disable_backfill: disable_backfill__.unwrap_or_default(),
11848 options: options__,
11849 })
11850 }
11851 }
11852 deserializer.deserialize_struct("stream_plan.StreamCdcScanNode", FIELDS, GeneratedVisitor)
11853 }
11854}
11855impl serde::Serialize for StreamCdcScanOptions {
11856 #[allow(deprecated)]
11857 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11858 where
11859 S: serde::Serializer,
11860 {
11861 use serde::ser::SerializeStruct;
11862 let mut len = 0;
11863 if self.disable_backfill {
11864 len += 1;
11865 }
11866 if self.snapshot_barrier_interval != 0 {
11867 len += 1;
11868 }
11869 if self.snapshot_batch_size != 0 {
11870 len += 1;
11871 }
11872 if self.backfill_parallelism != 0 {
11873 len += 1;
11874 }
11875 if self.backfill_num_rows_per_split != 0 {
11876 len += 1;
11877 }
11878 if self.backfill_as_even_splits {
11879 len += 1;
11880 }
11881 if self.backfill_split_pk_column_index != 0 {
11882 len += 1;
11883 }
11884 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanOptions", len)?;
11885 if self.disable_backfill {
11886 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
11887 }
11888 if self.snapshot_barrier_interval != 0 {
11889 struct_ser.serialize_field("snapshotBarrierInterval", &self.snapshot_barrier_interval)?;
11890 }
11891 if self.snapshot_batch_size != 0 {
11892 struct_ser.serialize_field("snapshotBatchSize", &self.snapshot_batch_size)?;
11893 }
11894 if self.backfill_parallelism != 0 {
11895 struct_ser.serialize_field("backfillParallelism", &self.backfill_parallelism)?;
11896 }
11897 if self.backfill_num_rows_per_split != 0 {
11898 #[allow(clippy::needless_borrow)]
11899 #[allow(clippy::needless_borrows_for_generic_args)]
11900 struct_ser.serialize_field("backfillNumRowsPerSplit", ToString::to_string(&self.backfill_num_rows_per_split).as_str())?;
11901 }
11902 if self.backfill_as_even_splits {
11903 struct_ser.serialize_field("backfillAsEvenSplits", &self.backfill_as_even_splits)?;
11904 }
11905 if self.backfill_split_pk_column_index != 0 {
11906 struct_ser.serialize_field("backfillSplitPkColumnIndex", &self.backfill_split_pk_column_index)?;
11907 }
11908 struct_ser.end()
11909 }
11910}
11911impl<'de> serde::Deserialize<'de> for StreamCdcScanOptions {
11912 #[allow(deprecated)]
11913 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11914 where
11915 D: serde::Deserializer<'de>,
11916 {
11917 const FIELDS: &[&str] = &[
11918 "disable_backfill",
11919 "disableBackfill",
11920 "snapshot_barrier_interval",
11921 "snapshotBarrierInterval",
11922 "snapshot_batch_size",
11923 "snapshotBatchSize",
11924 "backfill_parallelism",
11925 "backfillParallelism",
11926 "backfill_num_rows_per_split",
11927 "backfillNumRowsPerSplit",
11928 "backfill_as_even_splits",
11929 "backfillAsEvenSplits",
11930 "backfill_split_pk_column_index",
11931 "backfillSplitPkColumnIndex",
11932 ];
11933
11934 #[allow(clippy::enum_variant_names)]
11935 enum GeneratedField {
11936 DisableBackfill,
11937 SnapshotBarrierInterval,
11938 SnapshotBatchSize,
11939 BackfillParallelism,
11940 BackfillNumRowsPerSplit,
11941 BackfillAsEvenSplits,
11942 BackfillSplitPkColumnIndex,
11943 }
11944 impl<'de> serde::Deserialize<'de> for GeneratedField {
11945 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11946 where
11947 D: serde::Deserializer<'de>,
11948 {
11949 struct GeneratedVisitor;
11950
11951 impl serde::de::Visitor<'_> for GeneratedVisitor {
11952 type Value = GeneratedField;
11953
11954 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11955 write!(formatter, "expected one of: {:?}", &FIELDS)
11956 }
11957
11958 #[allow(unused_variables)]
11959 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11960 where
11961 E: serde::de::Error,
11962 {
11963 match value {
11964 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
11965 "snapshotBarrierInterval" | "snapshot_barrier_interval" => Ok(GeneratedField::SnapshotBarrierInterval),
11966 "snapshotBatchSize" | "snapshot_batch_size" => Ok(GeneratedField::SnapshotBatchSize),
11967 "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
11968 "backfillNumRowsPerSplit" | "backfill_num_rows_per_split" => Ok(GeneratedField::BackfillNumRowsPerSplit),
11969 "backfillAsEvenSplits" | "backfill_as_even_splits" => Ok(GeneratedField::BackfillAsEvenSplits),
11970 "backfillSplitPkColumnIndex" | "backfill_split_pk_column_index" => Ok(GeneratedField::BackfillSplitPkColumnIndex),
11971 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11972 }
11973 }
11974 }
11975 deserializer.deserialize_identifier(GeneratedVisitor)
11976 }
11977 }
11978 struct GeneratedVisitor;
11979 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11980 type Value = StreamCdcScanOptions;
11981
11982 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11983 formatter.write_str("struct stream_plan.StreamCdcScanOptions")
11984 }
11985
11986 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanOptions, V::Error>
11987 where
11988 V: serde::de::MapAccess<'de>,
11989 {
11990 let mut disable_backfill__ = None;
11991 let mut snapshot_barrier_interval__ = None;
11992 let mut snapshot_batch_size__ = None;
11993 let mut backfill_parallelism__ = None;
11994 let mut backfill_num_rows_per_split__ = None;
11995 let mut backfill_as_even_splits__ = None;
11996 let mut backfill_split_pk_column_index__ = None;
11997 while let Some(k) = map_.next_key()? {
11998 match k {
11999 GeneratedField::DisableBackfill => {
12000 if disable_backfill__.is_some() {
12001 return Err(serde::de::Error::duplicate_field("disableBackfill"));
12002 }
12003 disable_backfill__ = Some(map_.next_value()?);
12004 }
12005 GeneratedField::SnapshotBarrierInterval => {
12006 if snapshot_barrier_interval__.is_some() {
12007 return Err(serde::de::Error::duplicate_field("snapshotBarrierInterval"));
12008 }
12009 snapshot_barrier_interval__ =
12010 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12011 ;
12012 }
12013 GeneratedField::SnapshotBatchSize => {
12014 if snapshot_batch_size__.is_some() {
12015 return Err(serde::de::Error::duplicate_field("snapshotBatchSize"));
12016 }
12017 snapshot_batch_size__ =
12018 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12019 ;
12020 }
12021 GeneratedField::BackfillParallelism => {
12022 if backfill_parallelism__.is_some() {
12023 return Err(serde::de::Error::duplicate_field("backfillParallelism"));
12024 }
12025 backfill_parallelism__ =
12026 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12027 ;
12028 }
12029 GeneratedField::BackfillNumRowsPerSplit => {
12030 if backfill_num_rows_per_split__.is_some() {
12031 return Err(serde::de::Error::duplicate_field("backfillNumRowsPerSplit"));
12032 }
12033 backfill_num_rows_per_split__ =
12034 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12035 ;
12036 }
12037 GeneratedField::BackfillAsEvenSplits => {
12038 if backfill_as_even_splits__.is_some() {
12039 return Err(serde::de::Error::duplicate_field("backfillAsEvenSplits"));
12040 }
12041 backfill_as_even_splits__ = Some(map_.next_value()?);
12042 }
12043 GeneratedField::BackfillSplitPkColumnIndex => {
12044 if backfill_split_pk_column_index__.is_some() {
12045 return Err(serde::de::Error::duplicate_field("backfillSplitPkColumnIndex"));
12046 }
12047 backfill_split_pk_column_index__ =
12048 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12049 ;
12050 }
12051 }
12052 }
12053 Ok(StreamCdcScanOptions {
12054 disable_backfill: disable_backfill__.unwrap_or_default(),
12055 snapshot_barrier_interval: snapshot_barrier_interval__.unwrap_or_default(),
12056 snapshot_batch_size: snapshot_batch_size__.unwrap_or_default(),
12057 backfill_parallelism: backfill_parallelism__.unwrap_or_default(),
12058 backfill_num_rows_per_split: backfill_num_rows_per_split__.unwrap_or_default(),
12059 backfill_as_even_splits: backfill_as_even_splits__.unwrap_or_default(),
12060 backfill_split_pk_column_index: backfill_split_pk_column_index__.unwrap_or_default(),
12061 })
12062 }
12063 }
12064 deserializer.deserialize_struct("stream_plan.StreamCdcScanOptions", FIELDS, GeneratedVisitor)
12065 }
12066}
12067impl serde::Serialize for StreamContext {
12068 #[allow(deprecated)]
12069 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12070 where
12071 S: serde::Serializer,
12072 {
12073 use serde::ser::SerializeStruct;
12074 let mut len = 0;
12075 if !self.timezone.is_empty() {
12076 len += 1;
12077 }
12078 if !self.config_override.is_empty() {
12079 len += 1;
12080 }
12081 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamContext", len)?;
12082 if !self.timezone.is_empty() {
12083 struct_ser.serialize_field("timezone", &self.timezone)?;
12084 }
12085 if !self.config_override.is_empty() {
12086 struct_ser.serialize_field("configOverride", &self.config_override)?;
12087 }
12088 struct_ser.end()
12089 }
12090}
12091impl<'de> serde::Deserialize<'de> for StreamContext {
12092 #[allow(deprecated)]
12093 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12094 where
12095 D: serde::Deserializer<'de>,
12096 {
12097 const FIELDS: &[&str] = &[
12098 "timezone",
12099 "config_override",
12100 "configOverride",
12101 ];
12102
12103 #[allow(clippy::enum_variant_names)]
12104 enum GeneratedField {
12105 Timezone,
12106 ConfigOverride,
12107 }
12108 impl<'de> serde::Deserialize<'de> for GeneratedField {
12109 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12110 where
12111 D: serde::Deserializer<'de>,
12112 {
12113 struct GeneratedVisitor;
12114
12115 impl serde::de::Visitor<'_> for GeneratedVisitor {
12116 type Value = GeneratedField;
12117
12118 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12119 write!(formatter, "expected one of: {:?}", &FIELDS)
12120 }
12121
12122 #[allow(unused_variables)]
12123 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12124 where
12125 E: serde::de::Error,
12126 {
12127 match value {
12128 "timezone" => Ok(GeneratedField::Timezone),
12129 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
12130 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12131 }
12132 }
12133 }
12134 deserializer.deserialize_identifier(GeneratedVisitor)
12135 }
12136 }
12137 struct GeneratedVisitor;
12138 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12139 type Value = StreamContext;
12140
12141 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12142 formatter.write_str("struct stream_plan.StreamContext")
12143 }
12144
12145 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamContext, V::Error>
12146 where
12147 V: serde::de::MapAccess<'de>,
12148 {
12149 let mut timezone__ = None;
12150 let mut config_override__ = None;
12151 while let Some(k) = map_.next_key()? {
12152 match k {
12153 GeneratedField::Timezone => {
12154 if timezone__.is_some() {
12155 return Err(serde::de::Error::duplicate_field("timezone"));
12156 }
12157 timezone__ = Some(map_.next_value()?);
12158 }
12159 GeneratedField::ConfigOverride => {
12160 if config_override__.is_some() {
12161 return Err(serde::de::Error::duplicate_field("configOverride"));
12162 }
12163 config_override__ = Some(map_.next_value()?);
12164 }
12165 }
12166 }
12167 Ok(StreamContext {
12168 timezone: timezone__.unwrap_or_default(),
12169 config_override: config_override__.unwrap_or_default(),
12170 })
12171 }
12172 }
12173 deserializer.deserialize_struct("stream_plan.StreamContext", FIELDS, GeneratedVisitor)
12174 }
12175}
12176impl serde::Serialize for StreamFragmentGraph {
12177 #[allow(deprecated)]
12178 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12179 where
12180 S: serde::Serializer,
12181 {
12182 use serde::ser::SerializeStruct;
12183 let mut len = 0;
12184 if !self.fragments.is_empty() {
12185 len += 1;
12186 }
12187 if !self.edges.is_empty() {
12188 len += 1;
12189 }
12190 if !self.dependent_table_ids.is_empty() {
12191 len += 1;
12192 }
12193 if self.table_ids_cnt != 0 {
12194 len += 1;
12195 }
12196 if self.ctx.is_some() {
12197 len += 1;
12198 }
12199 if self.parallelism.is_some() {
12200 len += 1;
12201 }
12202 if self.backfill_parallelism.is_some() {
12203 len += 1;
12204 }
12205 if self.max_parallelism != 0 {
12206 len += 1;
12207 }
12208 if self.backfill_order.is_some() {
12209 len += 1;
12210 }
12211 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph", len)?;
12212 if !self.fragments.is_empty() {
12213 struct_ser.serialize_field("fragments", &self.fragments)?;
12214 }
12215 if !self.edges.is_empty() {
12216 struct_ser.serialize_field("edges", &self.edges)?;
12217 }
12218 if !self.dependent_table_ids.is_empty() {
12219 struct_ser.serialize_field("dependentTableIds", &self.dependent_table_ids)?;
12220 }
12221 if self.table_ids_cnt != 0 {
12222 struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
12223 }
12224 if let Some(v) = self.ctx.as_ref() {
12225 struct_ser.serialize_field("ctx", v)?;
12226 }
12227 if let Some(v) = self.parallelism.as_ref() {
12228 struct_ser.serialize_field("parallelism", v)?;
12229 }
12230 if let Some(v) = self.backfill_parallelism.as_ref() {
12231 struct_ser.serialize_field("backfillParallelism", v)?;
12232 }
12233 if self.max_parallelism != 0 {
12234 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
12235 }
12236 if let Some(v) = self.backfill_order.as_ref() {
12237 struct_ser.serialize_field("backfillOrder", v)?;
12238 }
12239 struct_ser.end()
12240 }
12241}
12242impl<'de> serde::Deserialize<'de> for StreamFragmentGraph {
12243 #[allow(deprecated)]
12244 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12245 where
12246 D: serde::Deserializer<'de>,
12247 {
12248 const FIELDS: &[&str] = &[
12249 "fragments",
12250 "edges",
12251 "dependent_table_ids",
12252 "dependentTableIds",
12253 "table_ids_cnt",
12254 "tableIdsCnt",
12255 "ctx",
12256 "parallelism",
12257 "backfill_parallelism",
12258 "backfillParallelism",
12259 "max_parallelism",
12260 "maxParallelism",
12261 "backfill_order",
12262 "backfillOrder",
12263 ];
12264
12265 #[allow(clippy::enum_variant_names)]
12266 enum GeneratedField {
12267 Fragments,
12268 Edges,
12269 DependentTableIds,
12270 TableIdsCnt,
12271 Ctx,
12272 Parallelism,
12273 BackfillParallelism,
12274 MaxParallelism,
12275 BackfillOrder,
12276 }
12277 impl<'de> serde::Deserialize<'de> for GeneratedField {
12278 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12279 where
12280 D: serde::Deserializer<'de>,
12281 {
12282 struct GeneratedVisitor;
12283
12284 impl serde::de::Visitor<'_> for GeneratedVisitor {
12285 type Value = GeneratedField;
12286
12287 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12288 write!(formatter, "expected one of: {:?}", &FIELDS)
12289 }
12290
12291 #[allow(unused_variables)]
12292 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12293 where
12294 E: serde::de::Error,
12295 {
12296 match value {
12297 "fragments" => Ok(GeneratedField::Fragments),
12298 "edges" => Ok(GeneratedField::Edges),
12299 "dependentTableIds" | "dependent_table_ids" => Ok(GeneratedField::DependentTableIds),
12300 "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
12301 "ctx" => Ok(GeneratedField::Ctx),
12302 "parallelism" => Ok(GeneratedField::Parallelism),
12303 "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
12304 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
12305 "backfillOrder" | "backfill_order" => Ok(GeneratedField::BackfillOrder),
12306 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12307 }
12308 }
12309 }
12310 deserializer.deserialize_identifier(GeneratedVisitor)
12311 }
12312 }
12313 struct GeneratedVisitor;
12314 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12315 type Value = StreamFragmentGraph;
12316
12317 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12318 formatter.write_str("struct stream_plan.StreamFragmentGraph")
12319 }
12320
12321 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFragmentGraph, V::Error>
12322 where
12323 V: serde::de::MapAccess<'de>,
12324 {
12325 let mut fragments__ = None;
12326 let mut edges__ = None;
12327 let mut dependent_table_ids__ = None;
12328 let mut table_ids_cnt__ = None;
12329 let mut ctx__ = None;
12330 let mut parallelism__ = None;
12331 let mut backfill_parallelism__ = None;
12332 let mut max_parallelism__ = None;
12333 let mut backfill_order__ = None;
12334 while let Some(k) = map_.next_key()? {
12335 match k {
12336 GeneratedField::Fragments => {
12337 if fragments__.is_some() {
12338 return Err(serde::de::Error::duplicate_field("fragments"));
12339 }
12340 fragments__ = Some(
12341 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
12342 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
12343 );
12344 }
12345 GeneratedField::Edges => {
12346 if edges__.is_some() {
12347 return Err(serde::de::Error::duplicate_field("edges"));
12348 }
12349 edges__ = Some(map_.next_value()?);
12350 }
12351 GeneratedField::DependentTableIds => {
12352 if dependent_table_ids__.is_some() {
12353 return Err(serde::de::Error::duplicate_field("dependentTableIds"));
12354 }
12355 dependent_table_ids__ =
12356 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12357 .into_iter().map(|x| x.0).collect())
12358 ;
12359 }
12360 GeneratedField::TableIdsCnt => {
12361 if table_ids_cnt__.is_some() {
12362 return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
12363 }
12364 table_ids_cnt__ =
12365 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12366 ;
12367 }
12368 GeneratedField::Ctx => {
12369 if ctx__.is_some() {
12370 return Err(serde::de::Error::duplicate_field("ctx"));
12371 }
12372 ctx__ = map_.next_value()?;
12373 }
12374 GeneratedField::Parallelism => {
12375 if parallelism__.is_some() {
12376 return Err(serde::de::Error::duplicate_field("parallelism"));
12377 }
12378 parallelism__ = map_.next_value()?;
12379 }
12380 GeneratedField::BackfillParallelism => {
12381 if backfill_parallelism__.is_some() {
12382 return Err(serde::de::Error::duplicate_field("backfillParallelism"));
12383 }
12384 backfill_parallelism__ = map_.next_value()?;
12385 }
12386 GeneratedField::MaxParallelism => {
12387 if max_parallelism__.is_some() {
12388 return Err(serde::de::Error::duplicate_field("maxParallelism"));
12389 }
12390 max_parallelism__ =
12391 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12392 ;
12393 }
12394 GeneratedField::BackfillOrder => {
12395 if backfill_order__.is_some() {
12396 return Err(serde::de::Error::duplicate_field("backfillOrder"));
12397 }
12398 backfill_order__ = map_.next_value()?;
12399 }
12400 }
12401 }
12402 Ok(StreamFragmentGraph {
12403 fragments: fragments__.unwrap_or_default(),
12404 edges: edges__.unwrap_or_default(),
12405 dependent_table_ids: dependent_table_ids__.unwrap_or_default(),
12406 table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
12407 ctx: ctx__,
12408 parallelism: parallelism__,
12409 backfill_parallelism: backfill_parallelism__,
12410 max_parallelism: max_parallelism__.unwrap_or_default(),
12411 backfill_order: backfill_order__,
12412 })
12413 }
12414 }
12415 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph", FIELDS, GeneratedVisitor)
12416 }
12417}
12418impl serde::Serialize for stream_fragment_graph::Parallelism {
12419 #[allow(deprecated)]
12420 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12421 where
12422 S: serde::Serializer,
12423 {
12424 use serde::ser::SerializeStruct;
12425 let mut len = 0;
12426 if self.parallelism != 0 {
12427 len += 1;
12428 }
12429 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.Parallelism", len)?;
12430 if self.parallelism != 0 {
12431 #[allow(clippy::needless_borrow)]
12432 #[allow(clippy::needless_borrows_for_generic_args)]
12433 struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
12434 }
12435 struct_ser.end()
12436 }
12437}
12438impl<'de> serde::Deserialize<'de> for stream_fragment_graph::Parallelism {
12439 #[allow(deprecated)]
12440 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12441 where
12442 D: serde::Deserializer<'de>,
12443 {
12444 const FIELDS: &[&str] = &[
12445 "parallelism",
12446 ];
12447
12448 #[allow(clippy::enum_variant_names)]
12449 enum GeneratedField {
12450 Parallelism,
12451 }
12452 impl<'de> serde::Deserialize<'de> for GeneratedField {
12453 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12454 where
12455 D: serde::Deserializer<'de>,
12456 {
12457 struct GeneratedVisitor;
12458
12459 impl serde::de::Visitor<'_> for GeneratedVisitor {
12460 type Value = GeneratedField;
12461
12462 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12463 write!(formatter, "expected one of: {:?}", &FIELDS)
12464 }
12465
12466 #[allow(unused_variables)]
12467 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12468 where
12469 E: serde::de::Error,
12470 {
12471 match value {
12472 "parallelism" => Ok(GeneratedField::Parallelism),
12473 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12474 }
12475 }
12476 }
12477 deserializer.deserialize_identifier(GeneratedVisitor)
12478 }
12479 }
12480 struct GeneratedVisitor;
12481 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12482 type Value = stream_fragment_graph::Parallelism;
12483
12484 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12485 formatter.write_str("struct stream_plan.StreamFragmentGraph.Parallelism")
12486 }
12487
12488 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::Parallelism, V::Error>
12489 where
12490 V: serde::de::MapAccess<'de>,
12491 {
12492 let mut parallelism__ = None;
12493 while let Some(k) = map_.next_key()? {
12494 match k {
12495 GeneratedField::Parallelism => {
12496 if parallelism__.is_some() {
12497 return Err(serde::de::Error::duplicate_field("parallelism"));
12498 }
12499 parallelism__ =
12500 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12501 ;
12502 }
12503 }
12504 }
12505 Ok(stream_fragment_graph::Parallelism {
12506 parallelism: parallelism__.unwrap_or_default(),
12507 })
12508 }
12509 }
12510 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.Parallelism", FIELDS, GeneratedVisitor)
12511 }
12512}
12513impl serde::Serialize for stream_fragment_graph::StreamFragment {
12514 #[allow(deprecated)]
12515 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12516 where
12517 S: serde::Serializer,
12518 {
12519 use serde::ser::SerializeStruct;
12520 let mut len = 0;
12521 if self.fragment_id != 0 {
12522 len += 1;
12523 }
12524 if self.node.is_some() {
12525 len += 1;
12526 }
12527 if self.fragment_type_mask != 0 {
12528 len += 1;
12529 }
12530 if self.requires_singleton {
12531 len += 1;
12532 }
12533 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", len)?;
12534 if self.fragment_id != 0 {
12535 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
12536 }
12537 if let Some(v) = self.node.as_ref() {
12538 struct_ser.serialize_field("node", v)?;
12539 }
12540 if self.fragment_type_mask != 0 {
12541 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
12542 }
12543 if self.requires_singleton {
12544 struct_ser.serialize_field("requiresSingleton", &self.requires_singleton)?;
12545 }
12546 struct_ser.end()
12547 }
12548}
12549impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragment {
12550 #[allow(deprecated)]
12551 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12552 where
12553 D: serde::Deserializer<'de>,
12554 {
12555 const FIELDS: &[&str] = &[
12556 "fragment_id",
12557 "fragmentId",
12558 "node",
12559 "fragment_type_mask",
12560 "fragmentTypeMask",
12561 "requires_singleton",
12562 "requiresSingleton",
12563 ];
12564
12565 #[allow(clippy::enum_variant_names)]
12566 enum GeneratedField {
12567 FragmentId,
12568 Node,
12569 FragmentTypeMask,
12570 RequiresSingleton,
12571 }
12572 impl<'de> serde::Deserialize<'de> for GeneratedField {
12573 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12574 where
12575 D: serde::Deserializer<'de>,
12576 {
12577 struct GeneratedVisitor;
12578
12579 impl serde::de::Visitor<'_> for GeneratedVisitor {
12580 type Value = GeneratedField;
12581
12582 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12583 write!(formatter, "expected one of: {:?}", &FIELDS)
12584 }
12585
12586 #[allow(unused_variables)]
12587 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12588 where
12589 E: serde::de::Error,
12590 {
12591 match value {
12592 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
12593 "node" => Ok(GeneratedField::Node),
12594 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
12595 "requiresSingleton" | "requires_singleton" => Ok(GeneratedField::RequiresSingleton),
12596 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12597 }
12598 }
12599 }
12600 deserializer.deserialize_identifier(GeneratedVisitor)
12601 }
12602 }
12603 struct GeneratedVisitor;
12604 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12605 type Value = stream_fragment_graph::StreamFragment;
12606
12607 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12608 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragment")
12609 }
12610
12611 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragment, V::Error>
12612 where
12613 V: serde::de::MapAccess<'de>,
12614 {
12615 let mut fragment_id__ = None;
12616 let mut node__ = None;
12617 let mut fragment_type_mask__ = None;
12618 let mut requires_singleton__ = None;
12619 while let Some(k) = map_.next_key()? {
12620 match k {
12621 GeneratedField::FragmentId => {
12622 if fragment_id__.is_some() {
12623 return Err(serde::de::Error::duplicate_field("fragmentId"));
12624 }
12625 fragment_id__ =
12626 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12627 ;
12628 }
12629 GeneratedField::Node => {
12630 if node__.is_some() {
12631 return Err(serde::de::Error::duplicate_field("node"));
12632 }
12633 node__ = map_.next_value()?;
12634 }
12635 GeneratedField::FragmentTypeMask => {
12636 if fragment_type_mask__.is_some() {
12637 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
12638 }
12639 fragment_type_mask__ =
12640 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12641 ;
12642 }
12643 GeneratedField::RequiresSingleton => {
12644 if requires_singleton__.is_some() {
12645 return Err(serde::de::Error::duplicate_field("requiresSingleton"));
12646 }
12647 requires_singleton__ = Some(map_.next_value()?);
12648 }
12649 }
12650 }
12651 Ok(stream_fragment_graph::StreamFragment {
12652 fragment_id: fragment_id__.unwrap_or_default(),
12653 node: node__,
12654 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
12655 requires_singleton: requires_singleton__.unwrap_or_default(),
12656 })
12657 }
12658 }
12659 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", FIELDS, GeneratedVisitor)
12660 }
12661}
12662impl serde::Serialize for stream_fragment_graph::StreamFragmentEdge {
12663 #[allow(deprecated)]
12664 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12665 where
12666 S: serde::Serializer,
12667 {
12668 use serde::ser::SerializeStruct;
12669 let mut len = 0;
12670 if self.dispatch_strategy.is_some() {
12671 len += 1;
12672 }
12673 if self.link_id != 0 {
12674 len += 1;
12675 }
12676 if self.upstream_id != 0 {
12677 len += 1;
12678 }
12679 if self.downstream_id != 0 {
12680 len += 1;
12681 }
12682 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", len)?;
12683 if let Some(v) = self.dispatch_strategy.as_ref() {
12684 struct_ser.serialize_field("dispatchStrategy", v)?;
12685 }
12686 if self.link_id != 0 {
12687 #[allow(clippy::needless_borrow)]
12688 #[allow(clippy::needless_borrows_for_generic_args)]
12689 struct_ser.serialize_field("linkId", ToString::to_string(&self.link_id).as_str())?;
12690 }
12691 if self.upstream_id != 0 {
12692 struct_ser.serialize_field("upstreamId", &self.upstream_id)?;
12693 }
12694 if self.downstream_id != 0 {
12695 struct_ser.serialize_field("downstreamId", &self.downstream_id)?;
12696 }
12697 struct_ser.end()
12698 }
12699}
12700impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragmentEdge {
12701 #[allow(deprecated)]
12702 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12703 where
12704 D: serde::Deserializer<'de>,
12705 {
12706 const FIELDS: &[&str] = &[
12707 "dispatch_strategy",
12708 "dispatchStrategy",
12709 "link_id",
12710 "linkId",
12711 "upstream_id",
12712 "upstreamId",
12713 "downstream_id",
12714 "downstreamId",
12715 ];
12716
12717 #[allow(clippy::enum_variant_names)]
12718 enum GeneratedField {
12719 DispatchStrategy,
12720 LinkId,
12721 UpstreamId,
12722 DownstreamId,
12723 }
12724 impl<'de> serde::Deserialize<'de> for GeneratedField {
12725 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12726 where
12727 D: serde::Deserializer<'de>,
12728 {
12729 struct GeneratedVisitor;
12730
12731 impl serde::de::Visitor<'_> for GeneratedVisitor {
12732 type Value = GeneratedField;
12733
12734 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12735 write!(formatter, "expected one of: {:?}", &FIELDS)
12736 }
12737
12738 #[allow(unused_variables)]
12739 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12740 where
12741 E: serde::de::Error,
12742 {
12743 match value {
12744 "dispatchStrategy" | "dispatch_strategy" => Ok(GeneratedField::DispatchStrategy),
12745 "linkId" | "link_id" => Ok(GeneratedField::LinkId),
12746 "upstreamId" | "upstream_id" => Ok(GeneratedField::UpstreamId),
12747 "downstreamId" | "downstream_id" => Ok(GeneratedField::DownstreamId),
12748 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12749 }
12750 }
12751 }
12752 deserializer.deserialize_identifier(GeneratedVisitor)
12753 }
12754 }
12755 struct GeneratedVisitor;
12756 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12757 type Value = stream_fragment_graph::StreamFragmentEdge;
12758
12759 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12760 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragmentEdge")
12761 }
12762
12763 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragmentEdge, V::Error>
12764 where
12765 V: serde::de::MapAccess<'de>,
12766 {
12767 let mut dispatch_strategy__ = None;
12768 let mut link_id__ = None;
12769 let mut upstream_id__ = None;
12770 let mut downstream_id__ = None;
12771 while let Some(k) = map_.next_key()? {
12772 match k {
12773 GeneratedField::DispatchStrategy => {
12774 if dispatch_strategy__.is_some() {
12775 return Err(serde::de::Error::duplicate_field("dispatchStrategy"));
12776 }
12777 dispatch_strategy__ = map_.next_value()?;
12778 }
12779 GeneratedField::LinkId => {
12780 if link_id__.is_some() {
12781 return Err(serde::de::Error::duplicate_field("linkId"));
12782 }
12783 link_id__ =
12784 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12785 ;
12786 }
12787 GeneratedField::UpstreamId => {
12788 if upstream_id__.is_some() {
12789 return Err(serde::de::Error::duplicate_field("upstreamId"));
12790 }
12791 upstream_id__ =
12792 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12793 ;
12794 }
12795 GeneratedField::DownstreamId => {
12796 if downstream_id__.is_some() {
12797 return Err(serde::de::Error::duplicate_field("downstreamId"));
12798 }
12799 downstream_id__ =
12800 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12801 ;
12802 }
12803 }
12804 }
12805 Ok(stream_fragment_graph::StreamFragmentEdge {
12806 dispatch_strategy: dispatch_strategy__,
12807 link_id: link_id__.unwrap_or_default(),
12808 upstream_id: upstream_id__.unwrap_or_default(),
12809 downstream_id: downstream_id__.unwrap_or_default(),
12810 })
12811 }
12812 }
12813 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", FIELDS, GeneratedVisitor)
12814 }
12815}
12816impl serde::Serialize for StreamFsFetch {
12817 #[allow(deprecated)]
12818 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12819 where
12820 S: serde::Serializer,
12821 {
12822 use serde::ser::SerializeStruct;
12823 let mut len = 0;
12824 if self.source_id != 0 {
12825 len += 1;
12826 }
12827 if self.state_table.is_some() {
12828 len += 1;
12829 }
12830 if self.row_id_index.is_some() {
12831 len += 1;
12832 }
12833 if !self.columns.is_empty() {
12834 len += 1;
12835 }
12836 if !self.with_properties.is_empty() {
12837 len += 1;
12838 }
12839 if self.info.is_some() {
12840 len += 1;
12841 }
12842 if !self.source_name.is_empty() {
12843 len += 1;
12844 }
12845 if self.rate_limit.is_some() {
12846 len += 1;
12847 }
12848 if !self.secret_refs.is_empty() {
12849 len += 1;
12850 }
12851 if self.refresh_mode.is_some() {
12852 len += 1;
12853 }
12854 if self.associated_table_id.is_some() {
12855 len += 1;
12856 }
12857 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetch", len)?;
12858 if self.source_id != 0 {
12859 struct_ser.serialize_field("sourceId", &self.source_id)?;
12860 }
12861 if let Some(v) = self.state_table.as_ref() {
12862 struct_ser.serialize_field("stateTable", v)?;
12863 }
12864 if let Some(v) = self.row_id_index.as_ref() {
12865 struct_ser.serialize_field("rowIdIndex", v)?;
12866 }
12867 if !self.columns.is_empty() {
12868 struct_ser.serialize_field("columns", &self.columns)?;
12869 }
12870 if !self.with_properties.is_empty() {
12871 struct_ser.serialize_field("withProperties", &self.with_properties)?;
12872 }
12873 if let Some(v) = self.info.as_ref() {
12874 struct_ser.serialize_field("info", v)?;
12875 }
12876 if !self.source_name.is_empty() {
12877 struct_ser.serialize_field("sourceName", &self.source_name)?;
12878 }
12879 if let Some(v) = self.rate_limit.as_ref() {
12880 struct_ser.serialize_field("rateLimit", v)?;
12881 }
12882 if !self.secret_refs.is_empty() {
12883 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
12884 }
12885 if let Some(v) = self.refresh_mode.as_ref() {
12886 struct_ser.serialize_field("refreshMode", v)?;
12887 }
12888 if let Some(v) = self.associated_table_id.as_ref() {
12889 struct_ser.serialize_field("associatedTableId", v)?;
12890 }
12891 struct_ser.end()
12892 }
12893}
12894impl<'de> serde::Deserialize<'de> for StreamFsFetch {
12895 #[allow(deprecated)]
12896 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12897 where
12898 D: serde::Deserializer<'de>,
12899 {
12900 const FIELDS: &[&str] = &[
12901 "source_id",
12902 "sourceId",
12903 "state_table",
12904 "stateTable",
12905 "row_id_index",
12906 "rowIdIndex",
12907 "columns",
12908 "with_properties",
12909 "withProperties",
12910 "info",
12911 "source_name",
12912 "sourceName",
12913 "rate_limit",
12914 "rateLimit",
12915 "secret_refs",
12916 "secretRefs",
12917 "refresh_mode",
12918 "refreshMode",
12919 "associated_table_id",
12920 "associatedTableId",
12921 ];
12922
12923 #[allow(clippy::enum_variant_names)]
12924 enum GeneratedField {
12925 SourceId,
12926 StateTable,
12927 RowIdIndex,
12928 Columns,
12929 WithProperties,
12930 Info,
12931 SourceName,
12932 RateLimit,
12933 SecretRefs,
12934 RefreshMode,
12935 AssociatedTableId,
12936 }
12937 impl<'de> serde::Deserialize<'de> for GeneratedField {
12938 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12939 where
12940 D: serde::Deserializer<'de>,
12941 {
12942 struct GeneratedVisitor;
12943
12944 impl serde::de::Visitor<'_> for GeneratedVisitor {
12945 type Value = GeneratedField;
12946
12947 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12948 write!(formatter, "expected one of: {:?}", &FIELDS)
12949 }
12950
12951 #[allow(unused_variables)]
12952 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12953 where
12954 E: serde::de::Error,
12955 {
12956 match value {
12957 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
12958 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
12959 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
12960 "columns" => Ok(GeneratedField::Columns),
12961 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
12962 "info" => Ok(GeneratedField::Info),
12963 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
12964 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
12965 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
12966 "refreshMode" | "refresh_mode" => Ok(GeneratedField::RefreshMode),
12967 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
12968 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12969 }
12970 }
12971 }
12972 deserializer.deserialize_identifier(GeneratedVisitor)
12973 }
12974 }
12975 struct GeneratedVisitor;
12976 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12977 type Value = StreamFsFetch;
12978
12979 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12980 formatter.write_str("struct stream_plan.StreamFsFetch")
12981 }
12982
12983 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetch, V::Error>
12984 where
12985 V: serde::de::MapAccess<'de>,
12986 {
12987 let mut source_id__ = None;
12988 let mut state_table__ = None;
12989 let mut row_id_index__ = None;
12990 let mut columns__ = None;
12991 let mut with_properties__ = None;
12992 let mut info__ = None;
12993 let mut source_name__ = None;
12994 let mut rate_limit__ = None;
12995 let mut secret_refs__ = None;
12996 let mut refresh_mode__ = None;
12997 let mut associated_table_id__ = None;
12998 while let Some(k) = map_.next_key()? {
12999 match k {
13000 GeneratedField::SourceId => {
13001 if source_id__.is_some() {
13002 return Err(serde::de::Error::duplicate_field("sourceId"));
13003 }
13004 source_id__ =
13005 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13006 ;
13007 }
13008 GeneratedField::StateTable => {
13009 if state_table__.is_some() {
13010 return Err(serde::de::Error::duplicate_field("stateTable"));
13011 }
13012 state_table__ = map_.next_value()?;
13013 }
13014 GeneratedField::RowIdIndex => {
13015 if row_id_index__.is_some() {
13016 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
13017 }
13018 row_id_index__ =
13019 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13020 ;
13021 }
13022 GeneratedField::Columns => {
13023 if columns__.is_some() {
13024 return Err(serde::de::Error::duplicate_field("columns"));
13025 }
13026 columns__ = Some(map_.next_value()?);
13027 }
13028 GeneratedField::WithProperties => {
13029 if with_properties__.is_some() {
13030 return Err(serde::de::Error::duplicate_field("withProperties"));
13031 }
13032 with_properties__ = Some(
13033 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13034 );
13035 }
13036 GeneratedField::Info => {
13037 if info__.is_some() {
13038 return Err(serde::de::Error::duplicate_field("info"));
13039 }
13040 info__ = map_.next_value()?;
13041 }
13042 GeneratedField::SourceName => {
13043 if source_name__.is_some() {
13044 return Err(serde::de::Error::duplicate_field("sourceName"));
13045 }
13046 source_name__ = Some(map_.next_value()?);
13047 }
13048 GeneratedField::RateLimit => {
13049 if rate_limit__.is_some() {
13050 return Err(serde::de::Error::duplicate_field("rateLimit"));
13051 }
13052 rate_limit__ =
13053 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13054 ;
13055 }
13056 GeneratedField::SecretRefs => {
13057 if secret_refs__.is_some() {
13058 return Err(serde::de::Error::duplicate_field("secretRefs"));
13059 }
13060 secret_refs__ = Some(
13061 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13062 );
13063 }
13064 GeneratedField::RefreshMode => {
13065 if refresh_mode__.is_some() {
13066 return Err(serde::de::Error::duplicate_field("refreshMode"));
13067 }
13068 refresh_mode__ = map_.next_value()?;
13069 }
13070 GeneratedField::AssociatedTableId => {
13071 if associated_table_id__.is_some() {
13072 return Err(serde::de::Error::duplicate_field("associatedTableId"));
13073 }
13074 associated_table_id__ =
13075 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13076 ;
13077 }
13078 }
13079 }
13080 Ok(StreamFsFetch {
13081 source_id: source_id__.unwrap_or_default(),
13082 state_table: state_table__,
13083 row_id_index: row_id_index__,
13084 columns: columns__.unwrap_or_default(),
13085 with_properties: with_properties__.unwrap_or_default(),
13086 info: info__,
13087 source_name: source_name__.unwrap_or_default(),
13088 rate_limit: rate_limit__,
13089 secret_refs: secret_refs__.unwrap_or_default(),
13090 refresh_mode: refresh_mode__,
13091 associated_table_id: associated_table_id__,
13092 })
13093 }
13094 }
13095 deserializer.deserialize_struct("stream_plan.StreamFsFetch", FIELDS, GeneratedVisitor)
13096 }
13097}
13098impl serde::Serialize for StreamFsFetchNode {
13099 #[allow(deprecated)]
13100 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13101 where
13102 S: serde::Serializer,
13103 {
13104 use serde::ser::SerializeStruct;
13105 let mut len = 0;
13106 if self.node_inner.is_some() {
13107 len += 1;
13108 }
13109 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetchNode", len)?;
13110 if let Some(v) = self.node_inner.as_ref() {
13111 struct_ser.serialize_field("nodeInner", v)?;
13112 }
13113 struct_ser.end()
13114 }
13115}
13116impl<'de> serde::Deserialize<'de> for StreamFsFetchNode {
13117 #[allow(deprecated)]
13118 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13119 where
13120 D: serde::Deserializer<'de>,
13121 {
13122 const FIELDS: &[&str] = &[
13123 "node_inner",
13124 "nodeInner",
13125 ];
13126
13127 #[allow(clippy::enum_variant_names)]
13128 enum GeneratedField {
13129 NodeInner,
13130 }
13131 impl<'de> serde::Deserialize<'de> for GeneratedField {
13132 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13133 where
13134 D: serde::Deserializer<'de>,
13135 {
13136 struct GeneratedVisitor;
13137
13138 impl serde::de::Visitor<'_> for GeneratedVisitor {
13139 type Value = GeneratedField;
13140
13141 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13142 write!(formatter, "expected one of: {:?}", &FIELDS)
13143 }
13144
13145 #[allow(unused_variables)]
13146 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13147 where
13148 E: serde::de::Error,
13149 {
13150 match value {
13151 "nodeInner" | "node_inner" => Ok(GeneratedField::NodeInner),
13152 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13153 }
13154 }
13155 }
13156 deserializer.deserialize_identifier(GeneratedVisitor)
13157 }
13158 }
13159 struct GeneratedVisitor;
13160 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13161 type Value = StreamFsFetchNode;
13162
13163 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13164 formatter.write_str("struct stream_plan.StreamFsFetchNode")
13165 }
13166
13167 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetchNode, V::Error>
13168 where
13169 V: serde::de::MapAccess<'de>,
13170 {
13171 let mut node_inner__ = None;
13172 while let Some(k) = map_.next_key()? {
13173 match k {
13174 GeneratedField::NodeInner => {
13175 if node_inner__.is_some() {
13176 return Err(serde::de::Error::duplicate_field("nodeInner"));
13177 }
13178 node_inner__ = map_.next_value()?;
13179 }
13180 }
13181 }
13182 Ok(StreamFsFetchNode {
13183 node_inner: node_inner__,
13184 })
13185 }
13186 }
13187 deserializer.deserialize_struct("stream_plan.StreamFsFetchNode", FIELDS, GeneratedVisitor)
13188 }
13189}
13190impl serde::Serialize for StreamMessage {
13191 #[allow(deprecated)]
13192 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13193 where
13194 S: serde::Serializer,
13195 {
13196 use serde::ser::SerializeStruct;
13197 let mut len = 0;
13198 if self.stream_message.is_some() {
13199 len += 1;
13200 }
13201 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessage", len)?;
13202 if let Some(v) = self.stream_message.as_ref() {
13203 match v {
13204 stream_message::StreamMessage::StreamChunk(v) => {
13205 struct_ser.serialize_field("streamChunk", v)?;
13206 }
13207 stream_message::StreamMessage::Barrier(v) => {
13208 struct_ser.serialize_field("barrier", v)?;
13209 }
13210 stream_message::StreamMessage::Watermark(v) => {
13211 struct_ser.serialize_field("watermark", v)?;
13212 }
13213 }
13214 }
13215 struct_ser.end()
13216 }
13217}
13218impl<'de> serde::Deserialize<'de> for StreamMessage {
13219 #[allow(deprecated)]
13220 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13221 where
13222 D: serde::Deserializer<'de>,
13223 {
13224 const FIELDS: &[&str] = &[
13225 "stream_chunk",
13226 "streamChunk",
13227 "barrier",
13228 "watermark",
13229 ];
13230
13231 #[allow(clippy::enum_variant_names)]
13232 enum GeneratedField {
13233 StreamChunk,
13234 Barrier,
13235 Watermark,
13236 }
13237 impl<'de> serde::Deserialize<'de> for GeneratedField {
13238 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13239 where
13240 D: serde::Deserializer<'de>,
13241 {
13242 struct GeneratedVisitor;
13243
13244 impl serde::de::Visitor<'_> for GeneratedVisitor {
13245 type Value = GeneratedField;
13246
13247 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13248 write!(formatter, "expected one of: {:?}", &FIELDS)
13249 }
13250
13251 #[allow(unused_variables)]
13252 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13253 where
13254 E: serde::de::Error,
13255 {
13256 match value {
13257 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
13258 "barrier" => Ok(GeneratedField::Barrier),
13259 "watermark" => Ok(GeneratedField::Watermark),
13260 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13261 }
13262 }
13263 }
13264 deserializer.deserialize_identifier(GeneratedVisitor)
13265 }
13266 }
13267 struct GeneratedVisitor;
13268 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13269 type Value = StreamMessage;
13270
13271 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13272 formatter.write_str("struct stream_plan.StreamMessage")
13273 }
13274
13275 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessage, V::Error>
13276 where
13277 V: serde::de::MapAccess<'de>,
13278 {
13279 let mut stream_message__ = None;
13280 while let Some(k) = map_.next_key()? {
13281 match k {
13282 GeneratedField::StreamChunk => {
13283 if stream_message__.is_some() {
13284 return Err(serde::de::Error::duplicate_field("streamChunk"));
13285 }
13286 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::StreamChunk)
13287;
13288 }
13289 GeneratedField::Barrier => {
13290 if stream_message__.is_some() {
13291 return Err(serde::de::Error::duplicate_field("barrier"));
13292 }
13293 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Barrier)
13294;
13295 }
13296 GeneratedField::Watermark => {
13297 if stream_message__.is_some() {
13298 return Err(serde::de::Error::duplicate_field("watermark"));
13299 }
13300 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Watermark)
13301;
13302 }
13303 }
13304 }
13305 Ok(StreamMessage {
13306 stream_message: stream_message__,
13307 })
13308 }
13309 }
13310 deserializer.deserialize_struct("stream_plan.StreamMessage", FIELDS, GeneratedVisitor)
13311 }
13312}
13313impl serde::Serialize for StreamMessageBatch {
13314 #[allow(deprecated)]
13315 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13316 where
13317 S: serde::Serializer,
13318 {
13319 use serde::ser::SerializeStruct;
13320 let mut len = 0;
13321 if self.stream_message_batch.is_some() {
13322 len += 1;
13323 }
13324 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch", len)?;
13325 if let Some(v) = self.stream_message_batch.as_ref() {
13326 match v {
13327 stream_message_batch::StreamMessageBatch::StreamChunk(v) => {
13328 struct_ser.serialize_field("streamChunk", v)?;
13329 }
13330 stream_message_batch::StreamMessageBatch::BarrierBatch(v) => {
13331 struct_ser.serialize_field("barrierBatch", v)?;
13332 }
13333 stream_message_batch::StreamMessageBatch::Watermark(v) => {
13334 struct_ser.serialize_field("watermark", v)?;
13335 }
13336 }
13337 }
13338 struct_ser.end()
13339 }
13340}
13341impl<'de> serde::Deserialize<'de> for StreamMessageBatch {
13342 #[allow(deprecated)]
13343 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13344 where
13345 D: serde::Deserializer<'de>,
13346 {
13347 const FIELDS: &[&str] = &[
13348 "stream_chunk",
13349 "streamChunk",
13350 "barrier_batch",
13351 "barrierBatch",
13352 "watermark",
13353 ];
13354
13355 #[allow(clippy::enum_variant_names)]
13356 enum GeneratedField {
13357 StreamChunk,
13358 BarrierBatch,
13359 Watermark,
13360 }
13361 impl<'de> serde::Deserialize<'de> for GeneratedField {
13362 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13363 where
13364 D: serde::Deserializer<'de>,
13365 {
13366 struct GeneratedVisitor;
13367
13368 impl serde::de::Visitor<'_> for GeneratedVisitor {
13369 type Value = GeneratedField;
13370
13371 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13372 write!(formatter, "expected one of: {:?}", &FIELDS)
13373 }
13374
13375 #[allow(unused_variables)]
13376 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13377 where
13378 E: serde::de::Error,
13379 {
13380 match value {
13381 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
13382 "barrierBatch" | "barrier_batch" => Ok(GeneratedField::BarrierBatch),
13383 "watermark" => Ok(GeneratedField::Watermark),
13384 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13385 }
13386 }
13387 }
13388 deserializer.deserialize_identifier(GeneratedVisitor)
13389 }
13390 }
13391 struct GeneratedVisitor;
13392 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13393 type Value = StreamMessageBatch;
13394
13395 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13396 formatter.write_str("struct stream_plan.StreamMessageBatch")
13397 }
13398
13399 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessageBatch, V::Error>
13400 where
13401 V: serde::de::MapAccess<'de>,
13402 {
13403 let mut stream_message_batch__ = None;
13404 while let Some(k) = map_.next_key()? {
13405 match k {
13406 GeneratedField::StreamChunk => {
13407 if stream_message_batch__.is_some() {
13408 return Err(serde::de::Error::duplicate_field("streamChunk"));
13409 }
13410 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::StreamChunk)
13411;
13412 }
13413 GeneratedField::BarrierBatch => {
13414 if stream_message_batch__.is_some() {
13415 return Err(serde::de::Error::duplicate_field("barrierBatch"));
13416 }
13417 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::BarrierBatch)
13418;
13419 }
13420 GeneratedField::Watermark => {
13421 if stream_message_batch__.is_some() {
13422 return Err(serde::de::Error::duplicate_field("watermark"));
13423 }
13424 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::Watermark)
13425;
13426 }
13427 }
13428 }
13429 Ok(StreamMessageBatch {
13430 stream_message_batch: stream_message_batch__,
13431 })
13432 }
13433 }
13434 deserializer.deserialize_struct("stream_plan.StreamMessageBatch", FIELDS, GeneratedVisitor)
13435 }
13436}
13437impl serde::Serialize for stream_message_batch::BarrierBatch {
13438 #[allow(deprecated)]
13439 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13440 where
13441 S: serde::Serializer,
13442 {
13443 use serde::ser::SerializeStruct;
13444 let mut len = 0;
13445 if !self.barriers.is_empty() {
13446 len += 1;
13447 }
13448 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", len)?;
13449 if !self.barriers.is_empty() {
13450 struct_ser.serialize_field("barriers", &self.barriers)?;
13451 }
13452 struct_ser.end()
13453 }
13454}
13455impl<'de> serde::Deserialize<'de> for stream_message_batch::BarrierBatch {
13456 #[allow(deprecated)]
13457 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13458 where
13459 D: serde::Deserializer<'de>,
13460 {
13461 const FIELDS: &[&str] = &[
13462 "barriers",
13463 ];
13464
13465 #[allow(clippy::enum_variant_names)]
13466 enum GeneratedField {
13467 Barriers,
13468 }
13469 impl<'de> serde::Deserialize<'de> for GeneratedField {
13470 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13471 where
13472 D: serde::Deserializer<'de>,
13473 {
13474 struct GeneratedVisitor;
13475
13476 impl serde::de::Visitor<'_> for GeneratedVisitor {
13477 type Value = GeneratedField;
13478
13479 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13480 write!(formatter, "expected one of: {:?}", &FIELDS)
13481 }
13482
13483 #[allow(unused_variables)]
13484 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13485 where
13486 E: serde::de::Error,
13487 {
13488 match value {
13489 "barriers" => Ok(GeneratedField::Barriers),
13490 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13491 }
13492 }
13493 }
13494 deserializer.deserialize_identifier(GeneratedVisitor)
13495 }
13496 }
13497 struct GeneratedVisitor;
13498 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13499 type Value = stream_message_batch::BarrierBatch;
13500
13501 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13502 formatter.write_str("struct stream_plan.StreamMessageBatch.BarrierBatch")
13503 }
13504
13505 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_message_batch::BarrierBatch, V::Error>
13506 where
13507 V: serde::de::MapAccess<'de>,
13508 {
13509 let mut barriers__ = None;
13510 while let Some(k) = map_.next_key()? {
13511 match k {
13512 GeneratedField::Barriers => {
13513 if barriers__.is_some() {
13514 return Err(serde::de::Error::duplicate_field("barriers"));
13515 }
13516 barriers__ = Some(map_.next_value()?);
13517 }
13518 }
13519 }
13520 Ok(stream_message_batch::BarrierBatch {
13521 barriers: barriers__.unwrap_or_default(),
13522 })
13523 }
13524 }
13525 deserializer.deserialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", FIELDS, GeneratedVisitor)
13526 }
13527}
13528impl serde::Serialize for StreamNode {
13529 #[allow(deprecated)]
13530 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13531 where
13532 S: serde::Serializer,
13533 {
13534 use serde::ser::SerializeStruct;
13535 let mut len = 0;
13536 if self.operator_id != 0 {
13537 len += 1;
13538 }
13539 if !self.input.is_empty() {
13540 len += 1;
13541 }
13542 if !self.stream_key.is_empty() {
13543 len += 1;
13544 }
13545 if self.stream_kind != 0 {
13546 len += 1;
13547 }
13548 if !self.identity.is_empty() {
13549 len += 1;
13550 }
13551 if !self.fields.is_empty() {
13552 len += 1;
13553 }
13554 if self.node_body.is_some() {
13555 len += 1;
13556 }
13557 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamNode", len)?;
13558 if self.operator_id != 0 {
13559 #[allow(clippy::needless_borrow)]
13560 #[allow(clippy::needless_borrows_for_generic_args)]
13561 struct_ser.serialize_field("operatorId", ToString::to_string(&self.operator_id).as_str())?;
13562 }
13563 if !self.input.is_empty() {
13564 struct_ser.serialize_field("input", &self.input)?;
13565 }
13566 if !self.stream_key.is_empty() {
13567 struct_ser.serialize_field("streamKey", &self.stream_key)?;
13568 }
13569 if self.stream_kind != 0 {
13570 let v = stream_node::StreamKind::try_from(self.stream_kind)
13571 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_kind)))?;
13572 struct_ser.serialize_field("streamKind", &v)?;
13573 }
13574 if !self.identity.is_empty() {
13575 struct_ser.serialize_field("identity", &self.identity)?;
13576 }
13577 if !self.fields.is_empty() {
13578 struct_ser.serialize_field("fields", &self.fields)?;
13579 }
13580 if let Some(v) = self.node_body.as_ref() {
13581 match v {
13582 stream_node::NodeBody::Source(v) => {
13583 struct_ser.serialize_field("source", v)?;
13584 }
13585 stream_node::NodeBody::Project(v) => {
13586 struct_ser.serialize_field("project", v)?;
13587 }
13588 stream_node::NodeBody::Filter(v) => {
13589 struct_ser.serialize_field("filter", v)?;
13590 }
13591 stream_node::NodeBody::Materialize(v) => {
13592 struct_ser.serialize_field("materialize", v)?;
13593 }
13594 stream_node::NodeBody::StatelessSimpleAgg(v) => {
13595 struct_ser.serialize_field("statelessSimpleAgg", v)?;
13596 }
13597 stream_node::NodeBody::SimpleAgg(v) => {
13598 struct_ser.serialize_field("simpleAgg", v)?;
13599 }
13600 stream_node::NodeBody::HashAgg(v) => {
13601 struct_ser.serialize_field("hashAgg", v)?;
13602 }
13603 stream_node::NodeBody::AppendOnlyTopN(v) => {
13604 struct_ser.serialize_field("appendOnlyTopN", v)?;
13605 }
13606 stream_node::NodeBody::HashJoin(v) => {
13607 struct_ser.serialize_field("hashJoin", v)?;
13608 }
13609 stream_node::NodeBody::TopN(v) => {
13610 struct_ser.serialize_field("topN", v)?;
13611 }
13612 stream_node::NodeBody::HopWindow(v) => {
13613 struct_ser.serialize_field("hopWindow", v)?;
13614 }
13615 stream_node::NodeBody::Merge(v) => {
13616 struct_ser.serialize_field("merge", v)?;
13617 }
13618 stream_node::NodeBody::Exchange(v) => {
13619 struct_ser.serialize_field("exchange", v)?;
13620 }
13621 stream_node::NodeBody::StreamScan(v) => {
13622 struct_ser.serialize_field("streamScan", v)?;
13623 }
13624 stream_node::NodeBody::BatchPlan(v) => {
13625 struct_ser.serialize_field("batchPlan", v)?;
13626 }
13627 stream_node::NodeBody::Lookup(v) => {
13628 struct_ser.serialize_field("lookup", v)?;
13629 }
13630 stream_node::NodeBody::Arrange(v) => {
13631 struct_ser.serialize_field("arrange", v)?;
13632 }
13633 stream_node::NodeBody::LookupUnion(v) => {
13634 struct_ser.serialize_field("lookupUnion", v)?;
13635 }
13636 stream_node::NodeBody::Union(v) => {
13637 struct_ser.serialize_field("union", v)?;
13638 }
13639 stream_node::NodeBody::DeltaIndexJoin(v) => {
13640 struct_ser.serialize_field("deltaIndexJoin", v)?;
13641 }
13642 stream_node::NodeBody::Sink(v) => {
13643 struct_ser.serialize_field("sink", v)?;
13644 }
13645 stream_node::NodeBody::Expand(v) => {
13646 struct_ser.serialize_field("expand", v)?;
13647 }
13648 stream_node::NodeBody::DynamicFilter(v) => {
13649 struct_ser.serialize_field("dynamicFilter", v)?;
13650 }
13651 stream_node::NodeBody::ProjectSet(v) => {
13652 struct_ser.serialize_field("projectSet", v)?;
13653 }
13654 stream_node::NodeBody::GroupTopN(v) => {
13655 struct_ser.serialize_field("groupTopN", v)?;
13656 }
13657 stream_node::NodeBody::Sort(v) => {
13658 struct_ser.serialize_field("sort", v)?;
13659 }
13660 stream_node::NodeBody::WatermarkFilter(v) => {
13661 struct_ser.serialize_field("watermarkFilter", v)?;
13662 }
13663 stream_node::NodeBody::Dml(v) => {
13664 struct_ser.serialize_field("dml", v)?;
13665 }
13666 stream_node::NodeBody::RowIdGen(v) => {
13667 struct_ser.serialize_field("rowIdGen", v)?;
13668 }
13669 stream_node::NodeBody::Now(v) => {
13670 struct_ser.serialize_field("now", v)?;
13671 }
13672 stream_node::NodeBody::AppendOnlyGroupTopN(v) => {
13673 struct_ser.serialize_field("appendOnlyGroupTopN", v)?;
13674 }
13675 stream_node::NodeBody::TemporalJoin(v) => {
13676 struct_ser.serialize_field("temporalJoin", v)?;
13677 }
13678 stream_node::NodeBody::BarrierRecv(v) => {
13679 struct_ser.serialize_field("barrierRecv", v)?;
13680 }
13681 stream_node::NodeBody::Values(v) => {
13682 struct_ser.serialize_field("values", v)?;
13683 }
13684 stream_node::NodeBody::AppendOnlyDedup(v) => {
13685 struct_ser.serialize_field("appendOnlyDedup", v)?;
13686 }
13687 stream_node::NodeBody::NoOp(v) => {
13688 struct_ser.serialize_field("noOp", v)?;
13689 }
13690 stream_node::NodeBody::EowcOverWindow(v) => {
13691 struct_ser.serialize_field("eowcOverWindow", v)?;
13692 }
13693 stream_node::NodeBody::OverWindow(v) => {
13694 struct_ser.serialize_field("overWindow", v)?;
13695 }
13696 stream_node::NodeBody::StreamFsFetch(v) => {
13697 struct_ser.serialize_field("streamFsFetch", v)?;
13698 }
13699 stream_node::NodeBody::StreamCdcScan(v) => {
13700 struct_ser.serialize_field("streamCdcScan", v)?;
13701 }
13702 stream_node::NodeBody::CdcFilter(v) => {
13703 struct_ser.serialize_field("cdcFilter", v)?;
13704 }
13705 stream_node::NodeBody::SourceBackfill(v) => {
13706 struct_ser.serialize_field("sourceBackfill", v)?;
13707 }
13708 stream_node::NodeBody::Changelog(v) => {
13709 struct_ser.serialize_field("changelog", v)?;
13710 }
13711 stream_node::NodeBody::LocalApproxPercentile(v) => {
13712 struct_ser.serialize_field("localApproxPercentile", v)?;
13713 }
13714 stream_node::NodeBody::GlobalApproxPercentile(v) => {
13715 struct_ser.serialize_field("globalApproxPercentile", v)?;
13716 }
13717 stream_node::NodeBody::RowMerge(v) => {
13718 struct_ser.serialize_field("rowMerge", v)?;
13719 }
13720 stream_node::NodeBody::AsOfJoin(v) => {
13721 struct_ser.serialize_field("asOfJoin", v)?;
13722 }
13723 stream_node::NodeBody::SyncLogStore(v) => {
13724 struct_ser.serialize_field("syncLogStore", v)?;
13725 }
13726 stream_node::NodeBody::MaterializedExprs(v) => {
13727 struct_ser.serialize_field("materializedExprs", v)?;
13728 }
13729 stream_node::NodeBody::VectorIndexWrite(v) => {
13730 struct_ser.serialize_field("vectorIndexWrite", v)?;
13731 }
13732 stream_node::NodeBody::UpstreamSinkUnion(v) => {
13733 struct_ser.serialize_field("upstreamSinkUnion", v)?;
13734 }
13735 stream_node::NodeBody::LocalityProvider(v) => {
13736 struct_ser.serialize_field("localityProvider", v)?;
13737 }
13738 stream_node::NodeBody::EowcGapFill(v) => {
13739 struct_ser.serialize_field("eowcGapFill", v)?;
13740 }
13741 stream_node::NodeBody::GapFill(v) => {
13742 struct_ser.serialize_field("gapFill", v)?;
13743 }
13744 stream_node::NodeBody::VectorIndexLookupJoin(v) => {
13745 struct_ser.serialize_field("vectorIndexLookupJoin", v)?;
13746 }
13747 }
13748 }
13749 struct_ser.end()
13750 }
13751}
13752impl<'de> serde::Deserialize<'de> for StreamNode {
13753 #[allow(deprecated)]
13754 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13755 where
13756 D: serde::Deserializer<'de>,
13757 {
13758 const FIELDS: &[&str] = &[
13759 "operator_id",
13760 "operatorId",
13761 "input",
13762 "stream_key",
13763 "streamKey",
13764 "stream_kind",
13765 "streamKind",
13766 "identity",
13767 "fields",
13768 "source",
13769 "project",
13770 "filter",
13771 "materialize",
13772 "stateless_simple_agg",
13773 "statelessSimpleAgg",
13774 "simple_agg",
13775 "simpleAgg",
13776 "hash_agg",
13777 "hashAgg",
13778 "append_only_top_n",
13779 "appendOnlyTopN",
13780 "hash_join",
13781 "hashJoin",
13782 "top_n",
13783 "topN",
13784 "hop_window",
13785 "hopWindow",
13786 "merge",
13787 "exchange",
13788 "stream_scan",
13789 "streamScan",
13790 "batch_plan",
13791 "batchPlan",
13792 "lookup",
13793 "arrange",
13794 "lookup_union",
13795 "lookupUnion",
13796 "union",
13797 "delta_index_join",
13798 "deltaIndexJoin",
13799 "sink",
13800 "expand",
13801 "dynamic_filter",
13802 "dynamicFilter",
13803 "project_set",
13804 "projectSet",
13805 "group_top_n",
13806 "groupTopN",
13807 "sort",
13808 "watermark_filter",
13809 "watermarkFilter",
13810 "dml",
13811 "row_id_gen",
13812 "rowIdGen",
13813 "now",
13814 "append_only_group_top_n",
13815 "appendOnlyGroupTopN",
13816 "temporal_join",
13817 "temporalJoin",
13818 "barrier_recv",
13819 "barrierRecv",
13820 "values",
13821 "append_only_dedup",
13822 "appendOnlyDedup",
13823 "no_op",
13824 "noOp",
13825 "eowc_over_window",
13826 "eowcOverWindow",
13827 "over_window",
13828 "overWindow",
13829 "stream_fs_fetch",
13830 "streamFsFetch",
13831 "stream_cdc_scan",
13832 "streamCdcScan",
13833 "cdc_filter",
13834 "cdcFilter",
13835 "source_backfill",
13836 "sourceBackfill",
13837 "changelog",
13838 "local_approx_percentile",
13839 "localApproxPercentile",
13840 "global_approx_percentile",
13841 "globalApproxPercentile",
13842 "row_merge",
13843 "rowMerge",
13844 "as_of_join",
13845 "asOfJoin",
13846 "sync_log_store",
13847 "syncLogStore",
13848 "materialized_exprs",
13849 "materializedExprs",
13850 "vector_index_write",
13851 "vectorIndexWrite",
13852 "upstream_sink_union",
13853 "upstreamSinkUnion",
13854 "locality_provider",
13855 "localityProvider",
13856 "eowc_gap_fill",
13857 "eowcGapFill",
13858 "gap_fill",
13859 "gapFill",
13860 "vector_index_lookup_join",
13861 "vectorIndexLookupJoin",
13862 ];
13863
13864 #[allow(clippy::enum_variant_names)]
13865 enum GeneratedField {
13866 OperatorId,
13867 Input,
13868 StreamKey,
13869 StreamKind,
13870 Identity,
13871 Fields,
13872 Source,
13873 Project,
13874 Filter,
13875 Materialize,
13876 StatelessSimpleAgg,
13877 SimpleAgg,
13878 HashAgg,
13879 AppendOnlyTopN,
13880 HashJoin,
13881 TopN,
13882 HopWindow,
13883 Merge,
13884 Exchange,
13885 StreamScan,
13886 BatchPlan,
13887 Lookup,
13888 Arrange,
13889 LookupUnion,
13890 Union,
13891 DeltaIndexJoin,
13892 Sink,
13893 Expand,
13894 DynamicFilter,
13895 ProjectSet,
13896 GroupTopN,
13897 Sort,
13898 WatermarkFilter,
13899 Dml,
13900 RowIdGen,
13901 Now,
13902 AppendOnlyGroupTopN,
13903 TemporalJoin,
13904 BarrierRecv,
13905 Values,
13906 AppendOnlyDedup,
13907 NoOp,
13908 EowcOverWindow,
13909 OverWindow,
13910 StreamFsFetch,
13911 StreamCdcScan,
13912 CdcFilter,
13913 SourceBackfill,
13914 Changelog,
13915 LocalApproxPercentile,
13916 GlobalApproxPercentile,
13917 RowMerge,
13918 AsOfJoin,
13919 SyncLogStore,
13920 MaterializedExprs,
13921 VectorIndexWrite,
13922 UpstreamSinkUnion,
13923 LocalityProvider,
13924 EowcGapFill,
13925 GapFill,
13926 VectorIndexLookupJoin,
13927 }
13928 impl<'de> serde::Deserialize<'de> for GeneratedField {
13929 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13930 where
13931 D: serde::Deserializer<'de>,
13932 {
13933 struct GeneratedVisitor;
13934
13935 impl serde::de::Visitor<'_> for GeneratedVisitor {
13936 type Value = GeneratedField;
13937
13938 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13939 write!(formatter, "expected one of: {:?}", &FIELDS)
13940 }
13941
13942 #[allow(unused_variables)]
13943 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13944 where
13945 E: serde::de::Error,
13946 {
13947 match value {
13948 "operatorId" | "operator_id" => Ok(GeneratedField::OperatorId),
13949 "input" => Ok(GeneratedField::Input),
13950 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
13951 "streamKind" | "stream_kind" => Ok(GeneratedField::StreamKind),
13952 "identity" => Ok(GeneratedField::Identity),
13953 "fields" => Ok(GeneratedField::Fields),
13954 "source" => Ok(GeneratedField::Source),
13955 "project" => Ok(GeneratedField::Project),
13956 "filter" => Ok(GeneratedField::Filter),
13957 "materialize" => Ok(GeneratedField::Materialize),
13958 "statelessSimpleAgg" | "stateless_simple_agg" => Ok(GeneratedField::StatelessSimpleAgg),
13959 "simpleAgg" | "simple_agg" => Ok(GeneratedField::SimpleAgg),
13960 "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
13961 "appendOnlyTopN" | "append_only_top_n" => Ok(GeneratedField::AppendOnlyTopN),
13962 "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
13963 "topN" | "top_n" => Ok(GeneratedField::TopN),
13964 "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
13965 "merge" => Ok(GeneratedField::Merge),
13966 "exchange" => Ok(GeneratedField::Exchange),
13967 "streamScan" | "stream_scan" => Ok(GeneratedField::StreamScan),
13968 "batchPlan" | "batch_plan" => Ok(GeneratedField::BatchPlan),
13969 "lookup" => Ok(GeneratedField::Lookup),
13970 "arrange" => Ok(GeneratedField::Arrange),
13971 "lookupUnion" | "lookup_union" => Ok(GeneratedField::LookupUnion),
13972 "union" => Ok(GeneratedField::Union),
13973 "deltaIndexJoin" | "delta_index_join" => Ok(GeneratedField::DeltaIndexJoin),
13974 "sink" => Ok(GeneratedField::Sink),
13975 "expand" => Ok(GeneratedField::Expand),
13976 "dynamicFilter" | "dynamic_filter" => Ok(GeneratedField::DynamicFilter),
13977 "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
13978 "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
13979 "sort" => Ok(GeneratedField::Sort),
13980 "watermarkFilter" | "watermark_filter" => Ok(GeneratedField::WatermarkFilter),
13981 "dml" => Ok(GeneratedField::Dml),
13982 "rowIdGen" | "row_id_gen" => Ok(GeneratedField::RowIdGen),
13983 "now" => Ok(GeneratedField::Now),
13984 "appendOnlyGroupTopN" | "append_only_group_top_n" => Ok(GeneratedField::AppendOnlyGroupTopN),
13985 "temporalJoin" | "temporal_join" => Ok(GeneratedField::TemporalJoin),
13986 "barrierRecv" | "barrier_recv" => Ok(GeneratedField::BarrierRecv),
13987 "values" => Ok(GeneratedField::Values),
13988 "appendOnlyDedup" | "append_only_dedup" => Ok(GeneratedField::AppendOnlyDedup),
13989 "noOp" | "no_op" => Ok(GeneratedField::NoOp),
13990 "eowcOverWindow" | "eowc_over_window" => Ok(GeneratedField::EowcOverWindow),
13991 "overWindow" | "over_window" => Ok(GeneratedField::OverWindow),
13992 "streamFsFetch" | "stream_fs_fetch" => Ok(GeneratedField::StreamFsFetch),
13993 "streamCdcScan" | "stream_cdc_scan" => Ok(GeneratedField::StreamCdcScan),
13994 "cdcFilter" | "cdc_filter" => Ok(GeneratedField::CdcFilter),
13995 "sourceBackfill" | "source_backfill" => Ok(GeneratedField::SourceBackfill),
13996 "changelog" => Ok(GeneratedField::Changelog),
13997 "localApproxPercentile" | "local_approx_percentile" => Ok(GeneratedField::LocalApproxPercentile),
13998 "globalApproxPercentile" | "global_approx_percentile" => Ok(GeneratedField::GlobalApproxPercentile),
13999 "rowMerge" | "row_merge" => Ok(GeneratedField::RowMerge),
14000 "asOfJoin" | "as_of_join" => Ok(GeneratedField::AsOfJoin),
14001 "syncLogStore" | "sync_log_store" => Ok(GeneratedField::SyncLogStore),
14002 "materializedExprs" | "materialized_exprs" => Ok(GeneratedField::MaterializedExprs),
14003 "vectorIndexWrite" | "vector_index_write" => Ok(GeneratedField::VectorIndexWrite),
14004 "upstreamSinkUnion" | "upstream_sink_union" => Ok(GeneratedField::UpstreamSinkUnion),
14005 "localityProvider" | "locality_provider" => Ok(GeneratedField::LocalityProvider),
14006 "eowcGapFill" | "eowc_gap_fill" => Ok(GeneratedField::EowcGapFill),
14007 "gapFill" | "gap_fill" => Ok(GeneratedField::GapFill),
14008 "vectorIndexLookupJoin" | "vector_index_lookup_join" => Ok(GeneratedField::VectorIndexLookupJoin),
14009 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14010 }
14011 }
14012 }
14013 deserializer.deserialize_identifier(GeneratedVisitor)
14014 }
14015 }
14016 struct GeneratedVisitor;
14017 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14018 type Value = StreamNode;
14019
14020 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14021 formatter.write_str("struct stream_plan.StreamNode")
14022 }
14023
14024 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamNode, V::Error>
14025 where
14026 V: serde::de::MapAccess<'de>,
14027 {
14028 let mut operator_id__ = None;
14029 let mut input__ = None;
14030 let mut stream_key__ = None;
14031 let mut stream_kind__ = None;
14032 let mut identity__ = None;
14033 let mut fields__ = None;
14034 let mut node_body__ = None;
14035 while let Some(k) = map_.next_key()? {
14036 match k {
14037 GeneratedField::OperatorId => {
14038 if operator_id__.is_some() {
14039 return Err(serde::de::Error::duplicate_field("operatorId"));
14040 }
14041 operator_id__ =
14042 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14043 ;
14044 }
14045 GeneratedField::Input => {
14046 if input__.is_some() {
14047 return Err(serde::de::Error::duplicate_field("input"));
14048 }
14049 input__ = Some(map_.next_value()?);
14050 }
14051 GeneratedField::StreamKey => {
14052 if stream_key__.is_some() {
14053 return Err(serde::de::Error::duplicate_field("streamKey"));
14054 }
14055 stream_key__ =
14056 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14057 .into_iter().map(|x| x.0).collect())
14058 ;
14059 }
14060 GeneratedField::StreamKind => {
14061 if stream_kind__.is_some() {
14062 return Err(serde::de::Error::duplicate_field("streamKind"));
14063 }
14064 stream_kind__ = Some(map_.next_value::<stream_node::StreamKind>()? as i32);
14065 }
14066 GeneratedField::Identity => {
14067 if identity__.is_some() {
14068 return Err(serde::de::Error::duplicate_field("identity"));
14069 }
14070 identity__ = Some(map_.next_value()?);
14071 }
14072 GeneratedField::Fields => {
14073 if fields__.is_some() {
14074 return Err(serde::de::Error::duplicate_field("fields"));
14075 }
14076 fields__ = Some(map_.next_value()?);
14077 }
14078 GeneratedField::Source => {
14079 if node_body__.is_some() {
14080 return Err(serde::de::Error::duplicate_field("source"));
14081 }
14082 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Source)
14083;
14084 }
14085 GeneratedField::Project => {
14086 if node_body__.is_some() {
14087 return Err(serde::de::Error::duplicate_field("project"));
14088 }
14089 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Project)
14090;
14091 }
14092 GeneratedField::Filter => {
14093 if node_body__.is_some() {
14094 return Err(serde::de::Error::duplicate_field("filter"));
14095 }
14096 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Filter)
14097;
14098 }
14099 GeneratedField::Materialize => {
14100 if node_body__.is_some() {
14101 return Err(serde::de::Error::duplicate_field("materialize"));
14102 }
14103 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Materialize)
14104;
14105 }
14106 GeneratedField::StatelessSimpleAgg => {
14107 if node_body__.is_some() {
14108 return Err(serde::de::Error::duplicate_field("statelessSimpleAgg"));
14109 }
14110 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StatelessSimpleAgg)
14111;
14112 }
14113 GeneratedField::SimpleAgg => {
14114 if node_body__.is_some() {
14115 return Err(serde::de::Error::duplicate_field("simpleAgg"));
14116 }
14117 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SimpleAgg)
14118;
14119 }
14120 GeneratedField::HashAgg => {
14121 if node_body__.is_some() {
14122 return Err(serde::de::Error::duplicate_field("hashAgg"));
14123 }
14124 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashAgg)
14125;
14126 }
14127 GeneratedField::AppendOnlyTopN => {
14128 if node_body__.is_some() {
14129 return Err(serde::de::Error::duplicate_field("appendOnlyTopN"));
14130 }
14131 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyTopN)
14132;
14133 }
14134 GeneratedField::HashJoin => {
14135 if node_body__.is_some() {
14136 return Err(serde::de::Error::duplicate_field("hashJoin"));
14137 }
14138 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashJoin)
14139;
14140 }
14141 GeneratedField::TopN => {
14142 if node_body__.is_some() {
14143 return Err(serde::de::Error::duplicate_field("topN"));
14144 }
14145 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TopN)
14146;
14147 }
14148 GeneratedField::HopWindow => {
14149 if node_body__.is_some() {
14150 return Err(serde::de::Error::duplicate_field("hopWindow"));
14151 }
14152 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HopWindow)
14153;
14154 }
14155 GeneratedField::Merge => {
14156 if node_body__.is_some() {
14157 return Err(serde::de::Error::duplicate_field("merge"));
14158 }
14159 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Merge)
14160;
14161 }
14162 GeneratedField::Exchange => {
14163 if node_body__.is_some() {
14164 return Err(serde::de::Error::duplicate_field("exchange"));
14165 }
14166 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Exchange)
14167;
14168 }
14169 GeneratedField::StreamScan => {
14170 if node_body__.is_some() {
14171 return Err(serde::de::Error::duplicate_field("streamScan"));
14172 }
14173 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamScan)
14174;
14175 }
14176 GeneratedField::BatchPlan => {
14177 if node_body__.is_some() {
14178 return Err(serde::de::Error::duplicate_field("batchPlan"));
14179 }
14180 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BatchPlan)
14181;
14182 }
14183 GeneratedField::Lookup => {
14184 if node_body__.is_some() {
14185 return Err(serde::de::Error::duplicate_field("lookup"));
14186 }
14187 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Lookup)
14188;
14189 }
14190 GeneratedField::Arrange => {
14191 if node_body__.is_some() {
14192 return Err(serde::de::Error::duplicate_field("arrange"));
14193 }
14194 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Arrange)
14195;
14196 }
14197 GeneratedField::LookupUnion => {
14198 if node_body__.is_some() {
14199 return Err(serde::de::Error::duplicate_field("lookupUnion"));
14200 }
14201 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LookupUnion)
14202;
14203 }
14204 GeneratedField::Union => {
14205 if node_body__.is_some() {
14206 return Err(serde::de::Error::duplicate_field("union"));
14207 }
14208 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Union)
14209;
14210 }
14211 GeneratedField::DeltaIndexJoin => {
14212 if node_body__.is_some() {
14213 return Err(serde::de::Error::duplicate_field("deltaIndexJoin"));
14214 }
14215 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DeltaIndexJoin)
14216;
14217 }
14218 GeneratedField::Sink => {
14219 if node_body__.is_some() {
14220 return Err(serde::de::Error::duplicate_field("sink"));
14221 }
14222 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sink)
14223;
14224 }
14225 GeneratedField::Expand => {
14226 if node_body__.is_some() {
14227 return Err(serde::de::Error::duplicate_field("expand"));
14228 }
14229 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Expand)
14230;
14231 }
14232 GeneratedField::DynamicFilter => {
14233 if node_body__.is_some() {
14234 return Err(serde::de::Error::duplicate_field("dynamicFilter"));
14235 }
14236 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DynamicFilter)
14237;
14238 }
14239 GeneratedField::ProjectSet => {
14240 if node_body__.is_some() {
14241 return Err(serde::de::Error::duplicate_field("projectSet"));
14242 }
14243 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::ProjectSet)
14244;
14245 }
14246 GeneratedField::GroupTopN => {
14247 if node_body__.is_some() {
14248 return Err(serde::de::Error::duplicate_field("groupTopN"));
14249 }
14250 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GroupTopN)
14251;
14252 }
14253 GeneratedField::Sort => {
14254 if node_body__.is_some() {
14255 return Err(serde::de::Error::duplicate_field("sort"));
14256 }
14257 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sort)
14258;
14259 }
14260 GeneratedField::WatermarkFilter => {
14261 if node_body__.is_some() {
14262 return Err(serde::de::Error::duplicate_field("watermarkFilter"));
14263 }
14264 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::WatermarkFilter)
14265;
14266 }
14267 GeneratedField::Dml => {
14268 if node_body__.is_some() {
14269 return Err(serde::de::Error::duplicate_field("dml"));
14270 }
14271 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Dml)
14272;
14273 }
14274 GeneratedField::RowIdGen => {
14275 if node_body__.is_some() {
14276 return Err(serde::de::Error::duplicate_field("rowIdGen"));
14277 }
14278 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowIdGen)
14279;
14280 }
14281 GeneratedField::Now => {
14282 if node_body__.is_some() {
14283 return Err(serde::de::Error::duplicate_field("now"));
14284 }
14285 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Now)
14286;
14287 }
14288 GeneratedField::AppendOnlyGroupTopN => {
14289 if node_body__.is_some() {
14290 return Err(serde::de::Error::duplicate_field("appendOnlyGroupTopN"));
14291 }
14292 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyGroupTopN)
14293;
14294 }
14295 GeneratedField::TemporalJoin => {
14296 if node_body__.is_some() {
14297 return Err(serde::de::Error::duplicate_field("temporalJoin"));
14298 }
14299 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TemporalJoin)
14300;
14301 }
14302 GeneratedField::BarrierRecv => {
14303 if node_body__.is_some() {
14304 return Err(serde::de::Error::duplicate_field("barrierRecv"));
14305 }
14306 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BarrierRecv)
14307;
14308 }
14309 GeneratedField::Values => {
14310 if node_body__.is_some() {
14311 return Err(serde::de::Error::duplicate_field("values"));
14312 }
14313 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Values)
14314;
14315 }
14316 GeneratedField::AppendOnlyDedup => {
14317 if node_body__.is_some() {
14318 return Err(serde::de::Error::duplicate_field("appendOnlyDedup"));
14319 }
14320 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyDedup)
14321;
14322 }
14323 GeneratedField::NoOp => {
14324 if node_body__.is_some() {
14325 return Err(serde::de::Error::duplicate_field("noOp"));
14326 }
14327 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::NoOp)
14328;
14329 }
14330 GeneratedField::EowcOverWindow => {
14331 if node_body__.is_some() {
14332 return Err(serde::de::Error::duplicate_field("eowcOverWindow"));
14333 }
14334 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcOverWindow)
14335;
14336 }
14337 GeneratedField::OverWindow => {
14338 if node_body__.is_some() {
14339 return Err(serde::de::Error::duplicate_field("overWindow"));
14340 }
14341 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::OverWindow)
14342;
14343 }
14344 GeneratedField::StreamFsFetch => {
14345 if node_body__.is_some() {
14346 return Err(serde::de::Error::duplicate_field("streamFsFetch"));
14347 }
14348 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamFsFetch)
14349;
14350 }
14351 GeneratedField::StreamCdcScan => {
14352 if node_body__.is_some() {
14353 return Err(serde::de::Error::duplicate_field("streamCdcScan"));
14354 }
14355 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamCdcScan)
14356;
14357 }
14358 GeneratedField::CdcFilter => {
14359 if node_body__.is_some() {
14360 return Err(serde::de::Error::duplicate_field("cdcFilter"));
14361 }
14362 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CdcFilter)
14363;
14364 }
14365 GeneratedField::SourceBackfill => {
14366 if node_body__.is_some() {
14367 return Err(serde::de::Error::duplicate_field("sourceBackfill"));
14368 }
14369 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SourceBackfill)
14370;
14371 }
14372 GeneratedField::Changelog => {
14373 if node_body__.is_some() {
14374 return Err(serde::de::Error::duplicate_field("changelog"));
14375 }
14376 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Changelog)
14377;
14378 }
14379 GeneratedField::LocalApproxPercentile => {
14380 if node_body__.is_some() {
14381 return Err(serde::de::Error::duplicate_field("localApproxPercentile"));
14382 }
14383 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalApproxPercentile)
14384;
14385 }
14386 GeneratedField::GlobalApproxPercentile => {
14387 if node_body__.is_some() {
14388 return Err(serde::de::Error::duplicate_field("globalApproxPercentile"));
14389 }
14390 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GlobalApproxPercentile)
14391;
14392 }
14393 GeneratedField::RowMerge => {
14394 if node_body__.is_some() {
14395 return Err(serde::de::Error::duplicate_field("rowMerge"));
14396 }
14397 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowMerge)
14398;
14399 }
14400 GeneratedField::AsOfJoin => {
14401 if node_body__.is_some() {
14402 return Err(serde::de::Error::duplicate_field("asOfJoin"));
14403 }
14404 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AsOfJoin)
14405;
14406 }
14407 GeneratedField::SyncLogStore => {
14408 if node_body__.is_some() {
14409 return Err(serde::de::Error::duplicate_field("syncLogStore"));
14410 }
14411 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SyncLogStore)
14412;
14413 }
14414 GeneratedField::MaterializedExprs => {
14415 if node_body__.is_some() {
14416 return Err(serde::de::Error::duplicate_field("materializedExprs"));
14417 }
14418 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MaterializedExprs)
14419;
14420 }
14421 GeneratedField::VectorIndexWrite => {
14422 if node_body__.is_some() {
14423 return Err(serde::de::Error::duplicate_field("vectorIndexWrite"));
14424 }
14425 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexWrite)
14426;
14427 }
14428 GeneratedField::UpstreamSinkUnion => {
14429 if node_body__.is_some() {
14430 return Err(serde::de::Error::duplicate_field("upstreamSinkUnion"));
14431 }
14432 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::UpstreamSinkUnion)
14433;
14434 }
14435 GeneratedField::LocalityProvider => {
14436 if node_body__.is_some() {
14437 return Err(serde::de::Error::duplicate_field("localityProvider"));
14438 }
14439 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalityProvider)
14440;
14441 }
14442 GeneratedField::EowcGapFill => {
14443 if node_body__.is_some() {
14444 return Err(serde::de::Error::duplicate_field("eowcGapFill"));
14445 }
14446 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcGapFill)
14447;
14448 }
14449 GeneratedField::GapFill => {
14450 if node_body__.is_some() {
14451 return Err(serde::de::Error::duplicate_field("gapFill"));
14452 }
14453 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GapFill)
14454;
14455 }
14456 GeneratedField::VectorIndexLookupJoin => {
14457 if node_body__.is_some() {
14458 return Err(serde::de::Error::duplicate_field("vectorIndexLookupJoin"));
14459 }
14460 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexLookupJoin)
14461;
14462 }
14463 }
14464 }
14465 Ok(StreamNode {
14466 operator_id: operator_id__.unwrap_or_default(),
14467 input: input__.unwrap_or_default(),
14468 stream_key: stream_key__.unwrap_or_default(),
14469 stream_kind: stream_kind__.unwrap_or_default(),
14470 identity: identity__.unwrap_or_default(),
14471 fields: fields__.unwrap_or_default(),
14472 node_body: node_body__,
14473 })
14474 }
14475 }
14476 deserializer.deserialize_struct("stream_plan.StreamNode", FIELDS, GeneratedVisitor)
14477 }
14478}
14479impl serde::Serialize for stream_node::StreamKind {
14480 #[allow(deprecated)]
14481 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14482 where
14483 S: serde::Serializer,
14484 {
14485 let variant = match self {
14486 Self::Retract => "STREAM_KIND_RETRACT",
14487 Self::AppendOnly => "STREAM_KIND_APPEND_ONLY",
14488 Self::Upsert => "STREAM_KIND_UPSERT",
14489 };
14490 serializer.serialize_str(variant)
14491 }
14492}
14493impl<'de> serde::Deserialize<'de> for stream_node::StreamKind {
14494 #[allow(deprecated)]
14495 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14496 where
14497 D: serde::Deserializer<'de>,
14498 {
14499 const FIELDS: &[&str] = &[
14500 "STREAM_KIND_RETRACT",
14501 "STREAM_KIND_APPEND_ONLY",
14502 "STREAM_KIND_UPSERT",
14503 ];
14504
14505 struct GeneratedVisitor;
14506
14507 impl serde::de::Visitor<'_> for GeneratedVisitor {
14508 type Value = stream_node::StreamKind;
14509
14510 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14511 write!(formatter, "expected one of: {:?}", &FIELDS)
14512 }
14513
14514 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14515 where
14516 E: serde::de::Error,
14517 {
14518 i32::try_from(v)
14519 .ok()
14520 .and_then(|x| x.try_into().ok())
14521 .ok_or_else(|| {
14522 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14523 })
14524 }
14525
14526 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14527 where
14528 E: serde::de::Error,
14529 {
14530 i32::try_from(v)
14531 .ok()
14532 .and_then(|x| x.try_into().ok())
14533 .ok_or_else(|| {
14534 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14535 })
14536 }
14537
14538 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14539 where
14540 E: serde::de::Error,
14541 {
14542 match value {
14543 "STREAM_KIND_RETRACT" => Ok(stream_node::StreamKind::Retract),
14544 "STREAM_KIND_APPEND_ONLY" => Ok(stream_node::StreamKind::AppendOnly),
14545 "STREAM_KIND_UPSERT" => Ok(stream_node::StreamKind::Upsert),
14546 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14547 }
14548 }
14549 }
14550 deserializer.deserialize_any(GeneratedVisitor)
14551 }
14552}
14553impl serde::Serialize for StreamScanNode {
14554 #[allow(deprecated)]
14555 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14556 where
14557 S: serde::Serializer,
14558 {
14559 use serde::ser::SerializeStruct;
14560 let mut len = 0;
14561 if self.table_id != 0 {
14562 len += 1;
14563 }
14564 if !self.upstream_column_ids.is_empty() {
14565 len += 1;
14566 }
14567 if !self.output_indices.is_empty() {
14568 len += 1;
14569 }
14570 if self.stream_scan_type != 0 {
14571 len += 1;
14572 }
14573 if self.state_table.is_some() {
14574 len += 1;
14575 }
14576 if self.table_desc.is_some() {
14577 len += 1;
14578 }
14579 if self.rate_limit.is_some() {
14580 len += 1;
14581 }
14582 if self.snapshot_read_barrier_interval != 0 {
14583 len += 1;
14584 }
14585 if self.arrangement_table.is_some() {
14586 len += 1;
14587 }
14588 if self.snapshot_backfill_epoch.is_some() {
14589 len += 1;
14590 }
14591 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamScanNode", len)?;
14592 if self.table_id != 0 {
14593 struct_ser.serialize_field("tableId", &self.table_id)?;
14594 }
14595 if !self.upstream_column_ids.is_empty() {
14596 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
14597 }
14598 if !self.output_indices.is_empty() {
14599 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
14600 }
14601 if self.stream_scan_type != 0 {
14602 let v = StreamScanType::try_from(self.stream_scan_type)
14603 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_scan_type)))?;
14604 struct_ser.serialize_field("streamScanType", &v)?;
14605 }
14606 if let Some(v) = self.state_table.as_ref() {
14607 struct_ser.serialize_field("stateTable", v)?;
14608 }
14609 if let Some(v) = self.table_desc.as_ref() {
14610 struct_ser.serialize_field("tableDesc", v)?;
14611 }
14612 if let Some(v) = self.rate_limit.as_ref() {
14613 struct_ser.serialize_field("rateLimit", v)?;
14614 }
14615 if self.snapshot_read_barrier_interval != 0 {
14616 struct_ser.serialize_field("snapshotReadBarrierInterval", &self.snapshot_read_barrier_interval)?;
14617 }
14618 if let Some(v) = self.arrangement_table.as_ref() {
14619 struct_ser.serialize_field("arrangementTable", v)?;
14620 }
14621 if let Some(v) = self.snapshot_backfill_epoch.as_ref() {
14622 #[allow(clippy::needless_borrow)]
14623 #[allow(clippy::needless_borrows_for_generic_args)]
14624 struct_ser.serialize_field("snapshotBackfillEpoch", ToString::to_string(&v).as_str())?;
14625 }
14626 struct_ser.end()
14627 }
14628}
14629impl<'de> serde::Deserialize<'de> for StreamScanNode {
14630 #[allow(deprecated)]
14631 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14632 where
14633 D: serde::Deserializer<'de>,
14634 {
14635 const FIELDS: &[&str] = &[
14636 "table_id",
14637 "tableId",
14638 "upstream_column_ids",
14639 "upstreamColumnIds",
14640 "output_indices",
14641 "outputIndices",
14642 "stream_scan_type",
14643 "streamScanType",
14644 "state_table",
14645 "stateTable",
14646 "table_desc",
14647 "tableDesc",
14648 "rate_limit",
14649 "rateLimit",
14650 "snapshot_read_barrier_interval",
14651 "snapshotReadBarrierInterval",
14652 "arrangement_table",
14653 "arrangementTable",
14654 "snapshot_backfill_epoch",
14655 "snapshotBackfillEpoch",
14656 ];
14657
14658 #[allow(clippy::enum_variant_names)]
14659 enum GeneratedField {
14660 TableId,
14661 UpstreamColumnIds,
14662 OutputIndices,
14663 StreamScanType,
14664 StateTable,
14665 TableDesc,
14666 RateLimit,
14667 SnapshotReadBarrierInterval,
14668 ArrangementTable,
14669 SnapshotBackfillEpoch,
14670 }
14671 impl<'de> serde::Deserialize<'de> for GeneratedField {
14672 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14673 where
14674 D: serde::Deserializer<'de>,
14675 {
14676 struct GeneratedVisitor;
14677
14678 impl serde::de::Visitor<'_> for GeneratedVisitor {
14679 type Value = GeneratedField;
14680
14681 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14682 write!(formatter, "expected one of: {:?}", &FIELDS)
14683 }
14684
14685 #[allow(unused_variables)]
14686 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14687 where
14688 E: serde::de::Error,
14689 {
14690 match value {
14691 "tableId" | "table_id" => Ok(GeneratedField::TableId),
14692 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
14693 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
14694 "streamScanType" | "stream_scan_type" => Ok(GeneratedField::StreamScanType),
14695 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
14696 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
14697 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
14698 "snapshotReadBarrierInterval" | "snapshot_read_barrier_interval" => Ok(GeneratedField::SnapshotReadBarrierInterval),
14699 "arrangementTable" | "arrangement_table" => Ok(GeneratedField::ArrangementTable),
14700 "snapshotBackfillEpoch" | "snapshot_backfill_epoch" => Ok(GeneratedField::SnapshotBackfillEpoch),
14701 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14702 }
14703 }
14704 }
14705 deserializer.deserialize_identifier(GeneratedVisitor)
14706 }
14707 }
14708 struct GeneratedVisitor;
14709 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14710 type Value = StreamScanNode;
14711
14712 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14713 formatter.write_str("struct stream_plan.StreamScanNode")
14714 }
14715
14716 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamScanNode, V::Error>
14717 where
14718 V: serde::de::MapAccess<'de>,
14719 {
14720 let mut table_id__ = None;
14721 let mut upstream_column_ids__ = None;
14722 let mut output_indices__ = None;
14723 let mut stream_scan_type__ = None;
14724 let mut state_table__ = None;
14725 let mut table_desc__ = None;
14726 let mut rate_limit__ = None;
14727 let mut snapshot_read_barrier_interval__ = None;
14728 let mut arrangement_table__ = None;
14729 let mut snapshot_backfill_epoch__ = None;
14730 while let Some(k) = map_.next_key()? {
14731 match k {
14732 GeneratedField::TableId => {
14733 if table_id__.is_some() {
14734 return Err(serde::de::Error::duplicate_field("tableId"));
14735 }
14736 table_id__ =
14737 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14738 ;
14739 }
14740 GeneratedField::UpstreamColumnIds => {
14741 if upstream_column_ids__.is_some() {
14742 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
14743 }
14744 upstream_column_ids__ =
14745 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14746 .into_iter().map(|x| x.0).collect())
14747 ;
14748 }
14749 GeneratedField::OutputIndices => {
14750 if output_indices__.is_some() {
14751 return Err(serde::de::Error::duplicate_field("outputIndices"));
14752 }
14753 output_indices__ =
14754 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14755 .into_iter().map(|x| x.0).collect())
14756 ;
14757 }
14758 GeneratedField::StreamScanType => {
14759 if stream_scan_type__.is_some() {
14760 return Err(serde::de::Error::duplicate_field("streamScanType"));
14761 }
14762 stream_scan_type__ = Some(map_.next_value::<StreamScanType>()? as i32);
14763 }
14764 GeneratedField::StateTable => {
14765 if state_table__.is_some() {
14766 return Err(serde::de::Error::duplicate_field("stateTable"));
14767 }
14768 state_table__ = map_.next_value()?;
14769 }
14770 GeneratedField::TableDesc => {
14771 if table_desc__.is_some() {
14772 return Err(serde::de::Error::duplicate_field("tableDesc"));
14773 }
14774 table_desc__ = map_.next_value()?;
14775 }
14776 GeneratedField::RateLimit => {
14777 if rate_limit__.is_some() {
14778 return Err(serde::de::Error::duplicate_field("rateLimit"));
14779 }
14780 rate_limit__ =
14781 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14782 ;
14783 }
14784 GeneratedField::SnapshotReadBarrierInterval => {
14785 if snapshot_read_barrier_interval__.is_some() {
14786 return Err(serde::de::Error::duplicate_field("snapshotReadBarrierInterval"));
14787 }
14788 snapshot_read_barrier_interval__ =
14789 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14790 ;
14791 }
14792 GeneratedField::ArrangementTable => {
14793 if arrangement_table__.is_some() {
14794 return Err(serde::de::Error::duplicate_field("arrangementTable"));
14795 }
14796 arrangement_table__ = map_.next_value()?;
14797 }
14798 GeneratedField::SnapshotBackfillEpoch => {
14799 if snapshot_backfill_epoch__.is_some() {
14800 return Err(serde::de::Error::duplicate_field("snapshotBackfillEpoch"));
14801 }
14802 snapshot_backfill_epoch__ =
14803 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14804 ;
14805 }
14806 }
14807 }
14808 Ok(StreamScanNode {
14809 table_id: table_id__.unwrap_or_default(),
14810 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
14811 output_indices: output_indices__.unwrap_or_default(),
14812 stream_scan_type: stream_scan_type__.unwrap_or_default(),
14813 state_table: state_table__,
14814 table_desc: table_desc__,
14815 rate_limit: rate_limit__,
14816 snapshot_read_barrier_interval: snapshot_read_barrier_interval__.unwrap_or_default(),
14817 arrangement_table: arrangement_table__,
14818 snapshot_backfill_epoch: snapshot_backfill_epoch__,
14819 })
14820 }
14821 }
14822 deserializer.deserialize_struct("stream_plan.StreamScanNode", FIELDS, GeneratedVisitor)
14823 }
14824}
14825impl serde::Serialize for StreamScanType {
14826 #[allow(deprecated)]
14827 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14828 where
14829 S: serde::Serializer,
14830 {
14831 let variant = match self {
14832 Self::Unspecified => "STREAM_SCAN_TYPE_UNSPECIFIED",
14833 Self::Chain => "STREAM_SCAN_TYPE_CHAIN",
14834 Self::Rearrange => "STREAM_SCAN_TYPE_REARRANGE",
14835 Self::Backfill => "STREAM_SCAN_TYPE_BACKFILL",
14836 Self::UpstreamOnly => "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
14837 Self::ArrangementBackfill => "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
14838 Self::SnapshotBackfill => "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
14839 Self::CrossDbSnapshotBackfill => "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
14840 };
14841 serializer.serialize_str(variant)
14842 }
14843}
14844impl<'de> serde::Deserialize<'de> for StreamScanType {
14845 #[allow(deprecated)]
14846 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14847 where
14848 D: serde::Deserializer<'de>,
14849 {
14850 const FIELDS: &[&str] = &[
14851 "STREAM_SCAN_TYPE_UNSPECIFIED",
14852 "STREAM_SCAN_TYPE_CHAIN",
14853 "STREAM_SCAN_TYPE_REARRANGE",
14854 "STREAM_SCAN_TYPE_BACKFILL",
14855 "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
14856 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
14857 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
14858 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
14859 ];
14860
14861 struct GeneratedVisitor;
14862
14863 impl serde::de::Visitor<'_> for GeneratedVisitor {
14864 type Value = StreamScanType;
14865
14866 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14867 write!(formatter, "expected one of: {:?}", &FIELDS)
14868 }
14869
14870 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14871 where
14872 E: serde::de::Error,
14873 {
14874 i32::try_from(v)
14875 .ok()
14876 .and_then(|x| x.try_into().ok())
14877 .ok_or_else(|| {
14878 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14879 })
14880 }
14881
14882 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14883 where
14884 E: serde::de::Error,
14885 {
14886 i32::try_from(v)
14887 .ok()
14888 .and_then(|x| x.try_into().ok())
14889 .ok_or_else(|| {
14890 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14891 })
14892 }
14893
14894 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14895 where
14896 E: serde::de::Error,
14897 {
14898 match value {
14899 "STREAM_SCAN_TYPE_UNSPECIFIED" => Ok(StreamScanType::Unspecified),
14900 "STREAM_SCAN_TYPE_CHAIN" => Ok(StreamScanType::Chain),
14901 "STREAM_SCAN_TYPE_REARRANGE" => Ok(StreamScanType::Rearrange),
14902 "STREAM_SCAN_TYPE_BACKFILL" => Ok(StreamScanType::Backfill),
14903 "STREAM_SCAN_TYPE_UPSTREAM_ONLY" => Ok(StreamScanType::UpstreamOnly),
14904 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL" => Ok(StreamScanType::ArrangementBackfill),
14905 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL" => Ok(StreamScanType::SnapshotBackfill),
14906 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL" => Ok(StreamScanType::CrossDbSnapshotBackfill),
14907 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14908 }
14909 }
14910 }
14911 deserializer.deserialize_any(GeneratedVisitor)
14912 }
14913}
14914impl serde::Serialize for StreamSource {
14915 #[allow(deprecated)]
14916 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14917 where
14918 S: serde::Serializer,
14919 {
14920 use serde::ser::SerializeStruct;
14921 let mut len = 0;
14922 if self.source_id != 0 {
14923 len += 1;
14924 }
14925 if self.state_table.is_some() {
14926 len += 1;
14927 }
14928 if self.row_id_index.is_some() {
14929 len += 1;
14930 }
14931 if !self.columns.is_empty() {
14932 len += 1;
14933 }
14934 if !self.with_properties.is_empty() {
14935 len += 1;
14936 }
14937 if self.info.is_some() {
14938 len += 1;
14939 }
14940 if !self.source_name.is_empty() {
14941 len += 1;
14942 }
14943 if self.rate_limit.is_some() {
14944 len += 1;
14945 }
14946 if !self.secret_refs.is_empty() {
14947 len += 1;
14948 }
14949 if self.downstream_columns.is_some() {
14950 len += 1;
14951 }
14952 if self.refresh_mode.is_some() {
14953 len += 1;
14954 }
14955 if self.associated_table_id.is_some() {
14956 len += 1;
14957 }
14958 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamSource", len)?;
14959 if self.source_id != 0 {
14960 struct_ser.serialize_field("sourceId", &self.source_id)?;
14961 }
14962 if let Some(v) = self.state_table.as_ref() {
14963 struct_ser.serialize_field("stateTable", v)?;
14964 }
14965 if let Some(v) = self.row_id_index.as_ref() {
14966 struct_ser.serialize_field("rowIdIndex", v)?;
14967 }
14968 if !self.columns.is_empty() {
14969 struct_ser.serialize_field("columns", &self.columns)?;
14970 }
14971 if !self.with_properties.is_empty() {
14972 struct_ser.serialize_field("withProperties", &self.with_properties)?;
14973 }
14974 if let Some(v) = self.info.as_ref() {
14975 struct_ser.serialize_field("info", v)?;
14976 }
14977 if !self.source_name.is_empty() {
14978 struct_ser.serialize_field("sourceName", &self.source_name)?;
14979 }
14980 if let Some(v) = self.rate_limit.as_ref() {
14981 struct_ser.serialize_field("rateLimit", v)?;
14982 }
14983 if !self.secret_refs.is_empty() {
14984 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
14985 }
14986 if let Some(v) = self.downstream_columns.as_ref() {
14987 struct_ser.serialize_field("downstreamColumns", v)?;
14988 }
14989 if let Some(v) = self.refresh_mode.as_ref() {
14990 struct_ser.serialize_field("refreshMode", v)?;
14991 }
14992 if let Some(v) = self.associated_table_id.as_ref() {
14993 struct_ser.serialize_field("associatedTableId", v)?;
14994 }
14995 struct_ser.end()
14996 }
14997}
14998impl<'de> serde::Deserialize<'de> for StreamSource {
14999 #[allow(deprecated)]
15000 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15001 where
15002 D: serde::Deserializer<'de>,
15003 {
15004 const FIELDS: &[&str] = &[
15005 "source_id",
15006 "sourceId",
15007 "state_table",
15008 "stateTable",
15009 "row_id_index",
15010 "rowIdIndex",
15011 "columns",
15012 "with_properties",
15013 "withProperties",
15014 "info",
15015 "source_name",
15016 "sourceName",
15017 "rate_limit",
15018 "rateLimit",
15019 "secret_refs",
15020 "secretRefs",
15021 "downstream_columns",
15022 "downstreamColumns",
15023 "refresh_mode",
15024 "refreshMode",
15025 "associated_table_id",
15026 "associatedTableId",
15027 ];
15028
15029 #[allow(clippy::enum_variant_names)]
15030 enum GeneratedField {
15031 SourceId,
15032 StateTable,
15033 RowIdIndex,
15034 Columns,
15035 WithProperties,
15036 Info,
15037 SourceName,
15038 RateLimit,
15039 SecretRefs,
15040 DownstreamColumns,
15041 RefreshMode,
15042 AssociatedTableId,
15043 }
15044 impl<'de> serde::Deserialize<'de> for GeneratedField {
15045 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15046 where
15047 D: serde::Deserializer<'de>,
15048 {
15049 struct GeneratedVisitor;
15050
15051 impl serde::de::Visitor<'_> for GeneratedVisitor {
15052 type Value = GeneratedField;
15053
15054 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15055 write!(formatter, "expected one of: {:?}", &FIELDS)
15056 }
15057
15058 #[allow(unused_variables)]
15059 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15060 where
15061 E: serde::de::Error,
15062 {
15063 match value {
15064 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
15065 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
15066 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
15067 "columns" => Ok(GeneratedField::Columns),
15068 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
15069 "info" => Ok(GeneratedField::Info),
15070 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
15071 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
15072 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
15073 "downstreamColumns" | "downstream_columns" => Ok(GeneratedField::DownstreamColumns),
15074 "refreshMode" | "refresh_mode" => Ok(GeneratedField::RefreshMode),
15075 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
15076 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15077 }
15078 }
15079 }
15080 deserializer.deserialize_identifier(GeneratedVisitor)
15081 }
15082 }
15083 struct GeneratedVisitor;
15084 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15085 type Value = StreamSource;
15086
15087 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15088 formatter.write_str("struct stream_plan.StreamSource")
15089 }
15090
15091 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSource, V::Error>
15092 where
15093 V: serde::de::MapAccess<'de>,
15094 {
15095 let mut source_id__ = None;
15096 let mut state_table__ = None;
15097 let mut row_id_index__ = None;
15098 let mut columns__ = None;
15099 let mut with_properties__ = None;
15100 let mut info__ = None;
15101 let mut source_name__ = None;
15102 let mut rate_limit__ = None;
15103 let mut secret_refs__ = None;
15104 let mut downstream_columns__ = None;
15105 let mut refresh_mode__ = None;
15106 let mut associated_table_id__ = None;
15107 while let Some(k) = map_.next_key()? {
15108 match k {
15109 GeneratedField::SourceId => {
15110 if source_id__.is_some() {
15111 return Err(serde::de::Error::duplicate_field("sourceId"));
15112 }
15113 source_id__ =
15114 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15115 ;
15116 }
15117 GeneratedField::StateTable => {
15118 if state_table__.is_some() {
15119 return Err(serde::de::Error::duplicate_field("stateTable"));
15120 }
15121 state_table__ = map_.next_value()?;
15122 }
15123 GeneratedField::RowIdIndex => {
15124 if row_id_index__.is_some() {
15125 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
15126 }
15127 row_id_index__ =
15128 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15129 ;
15130 }
15131 GeneratedField::Columns => {
15132 if columns__.is_some() {
15133 return Err(serde::de::Error::duplicate_field("columns"));
15134 }
15135 columns__ = Some(map_.next_value()?);
15136 }
15137 GeneratedField::WithProperties => {
15138 if with_properties__.is_some() {
15139 return Err(serde::de::Error::duplicate_field("withProperties"));
15140 }
15141 with_properties__ = Some(
15142 map_.next_value::<std::collections::BTreeMap<_, _>>()?
15143 );
15144 }
15145 GeneratedField::Info => {
15146 if info__.is_some() {
15147 return Err(serde::de::Error::duplicate_field("info"));
15148 }
15149 info__ = map_.next_value()?;
15150 }
15151 GeneratedField::SourceName => {
15152 if source_name__.is_some() {
15153 return Err(serde::de::Error::duplicate_field("sourceName"));
15154 }
15155 source_name__ = Some(map_.next_value()?);
15156 }
15157 GeneratedField::RateLimit => {
15158 if rate_limit__.is_some() {
15159 return Err(serde::de::Error::duplicate_field("rateLimit"));
15160 }
15161 rate_limit__ =
15162 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15163 ;
15164 }
15165 GeneratedField::SecretRefs => {
15166 if secret_refs__.is_some() {
15167 return Err(serde::de::Error::duplicate_field("secretRefs"));
15168 }
15169 secret_refs__ = Some(
15170 map_.next_value::<std::collections::BTreeMap<_, _>>()?
15171 );
15172 }
15173 GeneratedField::DownstreamColumns => {
15174 if downstream_columns__.is_some() {
15175 return Err(serde::de::Error::duplicate_field("downstreamColumns"));
15176 }
15177 downstream_columns__ = map_.next_value()?;
15178 }
15179 GeneratedField::RefreshMode => {
15180 if refresh_mode__.is_some() {
15181 return Err(serde::de::Error::duplicate_field("refreshMode"));
15182 }
15183 refresh_mode__ = map_.next_value()?;
15184 }
15185 GeneratedField::AssociatedTableId => {
15186 if associated_table_id__.is_some() {
15187 return Err(serde::de::Error::duplicate_field("associatedTableId"));
15188 }
15189 associated_table_id__ =
15190 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15191 ;
15192 }
15193 }
15194 }
15195 Ok(StreamSource {
15196 source_id: source_id__.unwrap_or_default(),
15197 state_table: state_table__,
15198 row_id_index: row_id_index__,
15199 columns: columns__.unwrap_or_default(),
15200 with_properties: with_properties__.unwrap_or_default(),
15201 info: info__,
15202 source_name: source_name__.unwrap_or_default(),
15203 rate_limit: rate_limit__,
15204 secret_refs: secret_refs__.unwrap_or_default(),
15205 downstream_columns: downstream_columns__,
15206 refresh_mode: refresh_mode__,
15207 associated_table_id: associated_table_id__,
15208 })
15209 }
15210 }
15211 deserializer.deserialize_struct("stream_plan.StreamSource", FIELDS, GeneratedVisitor)
15212 }
15213}
15214impl serde::Serialize for SubscriptionUpstreamInfo {
15215 #[allow(deprecated)]
15216 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15217 where
15218 S: serde::Serializer,
15219 {
15220 use serde::ser::SerializeStruct;
15221 let mut len = 0;
15222 if self.subscriber_id != 0 {
15223 len += 1;
15224 }
15225 if self.upstream_mv_table_id != 0 {
15226 len += 1;
15227 }
15228 let mut struct_ser = serializer.serialize_struct("stream_plan.SubscriptionUpstreamInfo", len)?;
15229 if self.subscriber_id != 0 {
15230 struct_ser.serialize_field("subscriberId", &self.subscriber_id)?;
15231 }
15232 if self.upstream_mv_table_id != 0 {
15233 struct_ser.serialize_field("upstreamMvTableId", &self.upstream_mv_table_id)?;
15234 }
15235 struct_ser.end()
15236 }
15237}
15238impl<'de> serde::Deserialize<'de> for SubscriptionUpstreamInfo {
15239 #[allow(deprecated)]
15240 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15241 where
15242 D: serde::Deserializer<'de>,
15243 {
15244 const FIELDS: &[&str] = &[
15245 "subscriber_id",
15246 "subscriberId",
15247 "upstream_mv_table_id",
15248 "upstreamMvTableId",
15249 ];
15250
15251 #[allow(clippy::enum_variant_names)]
15252 enum GeneratedField {
15253 SubscriberId,
15254 UpstreamMvTableId,
15255 }
15256 impl<'de> serde::Deserialize<'de> for GeneratedField {
15257 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15258 where
15259 D: serde::Deserializer<'de>,
15260 {
15261 struct GeneratedVisitor;
15262
15263 impl serde::de::Visitor<'_> for GeneratedVisitor {
15264 type Value = GeneratedField;
15265
15266 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15267 write!(formatter, "expected one of: {:?}", &FIELDS)
15268 }
15269
15270 #[allow(unused_variables)]
15271 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15272 where
15273 E: serde::de::Error,
15274 {
15275 match value {
15276 "subscriberId" | "subscriber_id" => Ok(GeneratedField::SubscriberId),
15277 "upstreamMvTableId" | "upstream_mv_table_id" => Ok(GeneratedField::UpstreamMvTableId),
15278 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15279 }
15280 }
15281 }
15282 deserializer.deserialize_identifier(GeneratedVisitor)
15283 }
15284 }
15285 struct GeneratedVisitor;
15286 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15287 type Value = SubscriptionUpstreamInfo;
15288
15289 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15290 formatter.write_str("struct stream_plan.SubscriptionUpstreamInfo")
15291 }
15292
15293 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscriptionUpstreamInfo, V::Error>
15294 where
15295 V: serde::de::MapAccess<'de>,
15296 {
15297 let mut subscriber_id__ = None;
15298 let mut upstream_mv_table_id__ = None;
15299 while let Some(k) = map_.next_key()? {
15300 match k {
15301 GeneratedField::SubscriberId => {
15302 if subscriber_id__.is_some() {
15303 return Err(serde::de::Error::duplicate_field("subscriberId"));
15304 }
15305 subscriber_id__ =
15306 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15307 ;
15308 }
15309 GeneratedField::UpstreamMvTableId => {
15310 if upstream_mv_table_id__.is_some() {
15311 return Err(serde::de::Error::duplicate_field("upstreamMvTableId"));
15312 }
15313 upstream_mv_table_id__ =
15314 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15315 ;
15316 }
15317 }
15318 }
15319 Ok(SubscriptionUpstreamInfo {
15320 subscriber_id: subscriber_id__.unwrap_or_default(),
15321 upstream_mv_table_id: upstream_mv_table_id__.unwrap_or_default(),
15322 })
15323 }
15324 }
15325 deserializer.deserialize_struct("stream_plan.SubscriptionUpstreamInfo", FIELDS, GeneratedVisitor)
15326 }
15327}
15328impl serde::Serialize for SyncLogStoreNode {
15329 #[allow(deprecated)]
15330 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15331 where
15332 S: serde::Serializer,
15333 {
15334 use serde::ser::SerializeStruct;
15335 let mut len = 0;
15336 if self.log_store_table.is_some() {
15337 len += 1;
15338 }
15339 if self.pause_duration_ms.is_some() {
15340 len += 1;
15341 }
15342 if self.buffer_size.is_some() {
15343 len += 1;
15344 }
15345 if self.aligned {
15346 len += 1;
15347 }
15348 let mut struct_ser = serializer.serialize_struct("stream_plan.SyncLogStoreNode", len)?;
15349 if let Some(v) = self.log_store_table.as_ref() {
15350 struct_ser.serialize_field("logStoreTable", v)?;
15351 }
15352 if let Some(v) = self.pause_duration_ms.as_ref() {
15353 struct_ser.serialize_field("pauseDurationMs", v)?;
15354 }
15355 if let Some(v) = self.buffer_size.as_ref() {
15356 struct_ser.serialize_field("bufferSize", v)?;
15357 }
15358 if self.aligned {
15359 struct_ser.serialize_field("aligned", &self.aligned)?;
15360 }
15361 struct_ser.end()
15362 }
15363}
15364impl<'de> serde::Deserialize<'de> for SyncLogStoreNode {
15365 #[allow(deprecated)]
15366 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15367 where
15368 D: serde::Deserializer<'de>,
15369 {
15370 const FIELDS: &[&str] = &[
15371 "log_store_table",
15372 "logStoreTable",
15373 "pause_duration_ms",
15374 "pauseDurationMs",
15375 "buffer_size",
15376 "bufferSize",
15377 "aligned",
15378 ];
15379
15380 #[allow(clippy::enum_variant_names)]
15381 enum GeneratedField {
15382 LogStoreTable,
15383 PauseDurationMs,
15384 BufferSize,
15385 Aligned,
15386 }
15387 impl<'de> serde::Deserialize<'de> for GeneratedField {
15388 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15389 where
15390 D: serde::Deserializer<'de>,
15391 {
15392 struct GeneratedVisitor;
15393
15394 impl serde::de::Visitor<'_> for GeneratedVisitor {
15395 type Value = GeneratedField;
15396
15397 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15398 write!(formatter, "expected one of: {:?}", &FIELDS)
15399 }
15400
15401 #[allow(unused_variables)]
15402 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15403 where
15404 E: serde::de::Error,
15405 {
15406 match value {
15407 "logStoreTable" | "log_store_table" => Ok(GeneratedField::LogStoreTable),
15408 "pauseDurationMs" | "pause_duration_ms" => Ok(GeneratedField::PauseDurationMs),
15409 "bufferSize" | "buffer_size" => Ok(GeneratedField::BufferSize),
15410 "aligned" => Ok(GeneratedField::Aligned),
15411 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15412 }
15413 }
15414 }
15415 deserializer.deserialize_identifier(GeneratedVisitor)
15416 }
15417 }
15418 struct GeneratedVisitor;
15419 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15420 type Value = SyncLogStoreNode;
15421
15422 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15423 formatter.write_str("struct stream_plan.SyncLogStoreNode")
15424 }
15425
15426 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SyncLogStoreNode, V::Error>
15427 where
15428 V: serde::de::MapAccess<'de>,
15429 {
15430 let mut log_store_table__ = None;
15431 let mut pause_duration_ms__ = None;
15432 let mut buffer_size__ = None;
15433 let mut aligned__ = None;
15434 while let Some(k) = map_.next_key()? {
15435 match k {
15436 GeneratedField::LogStoreTable => {
15437 if log_store_table__.is_some() {
15438 return Err(serde::de::Error::duplicate_field("logStoreTable"));
15439 }
15440 log_store_table__ = map_.next_value()?;
15441 }
15442 GeneratedField::PauseDurationMs => {
15443 if pause_duration_ms__.is_some() {
15444 return Err(serde::de::Error::duplicate_field("pauseDurationMs"));
15445 }
15446 pause_duration_ms__ =
15447 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15448 ;
15449 }
15450 GeneratedField::BufferSize => {
15451 if buffer_size__.is_some() {
15452 return Err(serde::de::Error::duplicate_field("bufferSize"));
15453 }
15454 buffer_size__ =
15455 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15456 ;
15457 }
15458 GeneratedField::Aligned => {
15459 if aligned__.is_some() {
15460 return Err(serde::de::Error::duplicate_field("aligned"));
15461 }
15462 aligned__ = Some(map_.next_value()?);
15463 }
15464 }
15465 }
15466 Ok(SyncLogStoreNode {
15467 log_store_table: log_store_table__,
15468 pause_duration_ms: pause_duration_ms__,
15469 buffer_size: buffer_size__,
15470 aligned: aligned__.unwrap_or_default(),
15471 })
15472 }
15473 }
15474 deserializer.deserialize_struct("stream_plan.SyncLogStoreNode", FIELDS, GeneratedVisitor)
15475 }
15476}
15477impl serde::Serialize for TemporalJoinNode {
15478 #[allow(deprecated)]
15479 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15480 where
15481 S: serde::Serializer,
15482 {
15483 use serde::ser::SerializeStruct;
15484 let mut len = 0;
15485 if self.join_type != 0 {
15486 len += 1;
15487 }
15488 if !self.left_key.is_empty() {
15489 len += 1;
15490 }
15491 if !self.right_key.is_empty() {
15492 len += 1;
15493 }
15494 if !self.null_safe.is_empty() {
15495 len += 1;
15496 }
15497 if self.condition.is_some() {
15498 len += 1;
15499 }
15500 if !self.output_indices.is_empty() {
15501 len += 1;
15502 }
15503 if self.table_desc.is_some() {
15504 len += 1;
15505 }
15506 if !self.table_output_indices.is_empty() {
15507 len += 1;
15508 }
15509 if self.memo_table.is_some() {
15510 len += 1;
15511 }
15512 if self.is_nested_loop {
15513 len += 1;
15514 }
15515 let mut struct_ser = serializer.serialize_struct("stream_plan.TemporalJoinNode", len)?;
15516 if self.join_type != 0 {
15517 let v = super::plan_common::JoinType::try_from(self.join_type)
15518 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
15519 struct_ser.serialize_field("joinType", &v)?;
15520 }
15521 if !self.left_key.is_empty() {
15522 struct_ser.serialize_field("leftKey", &self.left_key)?;
15523 }
15524 if !self.right_key.is_empty() {
15525 struct_ser.serialize_field("rightKey", &self.right_key)?;
15526 }
15527 if !self.null_safe.is_empty() {
15528 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
15529 }
15530 if let Some(v) = self.condition.as_ref() {
15531 struct_ser.serialize_field("condition", v)?;
15532 }
15533 if !self.output_indices.is_empty() {
15534 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
15535 }
15536 if let Some(v) = self.table_desc.as_ref() {
15537 struct_ser.serialize_field("tableDesc", v)?;
15538 }
15539 if !self.table_output_indices.is_empty() {
15540 struct_ser.serialize_field("tableOutputIndices", &self.table_output_indices)?;
15541 }
15542 if let Some(v) = self.memo_table.as_ref() {
15543 struct_ser.serialize_field("memoTable", v)?;
15544 }
15545 if self.is_nested_loop {
15546 struct_ser.serialize_field("isNestedLoop", &self.is_nested_loop)?;
15547 }
15548 struct_ser.end()
15549 }
15550}
15551impl<'de> serde::Deserialize<'de> for TemporalJoinNode {
15552 #[allow(deprecated)]
15553 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15554 where
15555 D: serde::Deserializer<'de>,
15556 {
15557 const FIELDS: &[&str] = &[
15558 "join_type",
15559 "joinType",
15560 "left_key",
15561 "leftKey",
15562 "right_key",
15563 "rightKey",
15564 "null_safe",
15565 "nullSafe",
15566 "condition",
15567 "output_indices",
15568 "outputIndices",
15569 "table_desc",
15570 "tableDesc",
15571 "table_output_indices",
15572 "tableOutputIndices",
15573 "memo_table",
15574 "memoTable",
15575 "is_nested_loop",
15576 "isNestedLoop",
15577 ];
15578
15579 #[allow(clippy::enum_variant_names)]
15580 enum GeneratedField {
15581 JoinType,
15582 LeftKey,
15583 RightKey,
15584 NullSafe,
15585 Condition,
15586 OutputIndices,
15587 TableDesc,
15588 TableOutputIndices,
15589 MemoTable,
15590 IsNestedLoop,
15591 }
15592 impl<'de> serde::Deserialize<'de> for GeneratedField {
15593 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15594 where
15595 D: serde::Deserializer<'de>,
15596 {
15597 struct GeneratedVisitor;
15598
15599 impl serde::de::Visitor<'_> for GeneratedVisitor {
15600 type Value = GeneratedField;
15601
15602 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15603 write!(formatter, "expected one of: {:?}", &FIELDS)
15604 }
15605
15606 #[allow(unused_variables)]
15607 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15608 where
15609 E: serde::de::Error,
15610 {
15611 match value {
15612 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
15613 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
15614 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
15615 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
15616 "condition" => Ok(GeneratedField::Condition),
15617 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
15618 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
15619 "tableOutputIndices" | "table_output_indices" => Ok(GeneratedField::TableOutputIndices),
15620 "memoTable" | "memo_table" => Ok(GeneratedField::MemoTable),
15621 "isNestedLoop" | "is_nested_loop" => Ok(GeneratedField::IsNestedLoop),
15622 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15623 }
15624 }
15625 }
15626 deserializer.deserialize_identifier(GeneratedVisitor)
15627 }
15628 }
15629 struct GeneratedVisitor;
15630 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15631 type Value = TemporalJoinNode;
15632
15633 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15634 formatter.write_str("struct stream_plan.TemporalJoinNode")
15635 }
15636
15637 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TemporalJoinNode, V::Error>
15638 where
15639 V: serde::de::MapAccess<'de>,
15640 {
15641 let mut join_type__ = None;
15642 let mut left_key__ = None;
15643 let mut right_key__ = None;
15644 let mut null_safe__ = None;
15645 let mut condition__ = None;
15646 let mut output_indices__ = None;
15647 let mut table_desc__ = None;
15648 let mut table_output_indices__ = None;
15649 let mut memo_table__ = None;
15650 let mut is_nested_loop__ = None;
15651 while let Some(k) = map_.next_key()? {
15652 match k {
15653 GeneratedField::JoinType => {
15654 if join_type__.is_some() {
15655 return Err(serde::de::Error::duplicate_field("joinType"));
15656 }
15657 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
15658 }
15659 GeneratedField::LeftKey => {
15660 if left_key__.is_some() {
15661 return Err(serde::de::Error::duplicate_field("leftKey"));
15662 }
15663 left_key__ =
15664 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15665 .into_iter().map(|x| x.0).collect())
15666 ;
15667 }
15668 GeneratedField::RightKey => {
15669 if right_key__.is_some() {
15670 return Err(serde::de::Error::duplicate_field("rightKey"));
15671 }
15672 right_key__ =
15673 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15674 .into_iter().map(|x| x.0).collect())
15675 ;
15676 }
15677 GeneratedField::NullSafe => {
15678 if null_safe__.is_some() {
15679 return Err(serde::de::Error::duplicate_field("nullSafe"));
15680 }
15681 null_safe__ = Some(map_.next_value()?);
15682 }
15683 GeneratedField::Condition => {
15684 if condition__.is_some() {
15685 return Err(serde::de::Error::duplicate_field("condition"));
15686 }
15687 condition__ = map_.next_value()?;
15688 }
15689 GeneratedField::OutputIndices => {
15690 if output_indices__.is_some() {
15691 return Err(serde::de::Error::duplicate_field("outputIndices"));
15692 }
15693 output_indices__ =
15694 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15695 .into_iter().map(|x| x.0).collect())
15696 ;
15697 }
15698 GeneratedField::TableDesc => {
15699 if table_desc__.is_some() {
15700 return Err(serde::de::Error::duplicate_field("tableDesc"));
15701 }
15702 table_desc__ = map_.next_value()?;
15703 }
15704 GeneratedField::TableOutputIndices => {
15705 if table_output_indices__.is_some() {
15706 return Err(serde::de::Error::duplicate_field("tableOutputIndices"));
15707 }
15708 table_output_indices__ =
15709 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15710 .into_iter().map(|x| x.0).collect())
15711 ;
15712 }
15713 GeneratedField::MemoTable => {
15714 if memo_table__.is_some() {
15715 return Err(serde::de::Error::duplicate_field("memoTable"));
15716 }
15717 memo_table__ = map_.next_value()?;
15718 }
15719 GeneratedField::IsNestedLoop => {
15720 if is_nested_loop__.is_some() {
15721 return Err(serde::de::Error::duplicate_field("isNestedLoop"));
15722 }
15723 is_nested_loop__ = Some(map_.next_value()?);
15724 }
15725 }
15726 }
15727 Ok(TemporalJoinNode {
15728 join_type: join_type__.unwrap_or_default(),
15729 left_key: left_key__.unwrap_or_default(),
15730 right_key: right_key__.unwrap_or_default(),
15731 null_safe: null_safe__.unwrap_or_default(),
15732 condition: condition__,
15733 output_indices: output_indices__.unwrap_or_default(),
15734 table_desc: table_desc__,
15735 table_output_indices: table_output_indices__.unwrap_or_default(),
15736 memo_table: memo_table__,
15737 is_nested_loop: is_nested_loop__.unwrap_or_default(),
15738 })
15739 }
15740 }
15741 deserializer.deserialize_struct("stream_plan.TemporalJoinNode", FIELDS, GeneratedVisitor)
15742 }
15743}
15744impl serde::Serialize for ThrottleMutation {
15745 #[allow(deprecated)]
15746 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15747 where
15748 S: serde::Serializer,
15749 {
15750 use serde::ser::SerializeStruct;
15751 let mut len = 0;
15752 if !self.fragment_throttle.is_empty() {
15753 len += 1;
15754 }
15755 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation", len)?;
15756 if !self.fragment_throttle.is_empty() {
15757 struct_ser.serialize_field("fragmentThrottle", &self.fragment_throttle)?;
15758 }
15759 struct_ser.end()
15760 }
15761}
15762impl<'de> serde::Deserialize<'de> for ThrottleMutation {
15763 #[allow(deprecated)]
15764 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15765 where
15766 D: serde::Deserializer<'de>,
15767 {
15768 const FIELDS: &[&str] = &[
15769 "fragment_throttle",
15770 "fragmentThrottle",
15771 ];
15772
15773 #[allow(clippy::enum_variant_names)]
15774 enum GeneratedField {
15775 FragmentThrottle,
15776 }
15777 impl<'de> serde::Deserialize<'de> for GeneratedField {
15778 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15779 where
15780 D: serde::Deserializer<'de>,
15781 {
15782 struct GeneratedVisitor;
15783
15784 impl serde::de::Visitor<'_> for GeneratedVisitor {
15785 type Value = GeneratedField;
15786
15787 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15788 write!(formatter, "expected one of: {:?}", &FIELDS)
15789 }
15790
15791 #[allow(unused_variables)]
15792 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15793 where
15794 E: serde::de::Error,
15795 {
15796 match value {
15797 "fragmentThrottle" | "fragment_throttle" => Ok(GeneratedField::FragmentThrottle),
15798 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15799 }
15800 }
15801 }
15802 deserializer.deserialize_identifier(GeneratedVisitor)
15803 }
15804 }
15805 struct GeneratedVisitor;
15806 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15807 type Value = ThrottleMutation;
15808
15809 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15810 formatter.write_str("struct stream_plan.ThrottleMutation")
15811 }
15812
15813 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ThrottleMutation, V::Error>
15814 where
15815 V: serde::de::MapAccess<'de>,
15816 {
15817 let mut fragment_throttle__ = None;
15818 while let Some(k) = map_.next_key()? {
15819 match k {
15820 GeneratedField::FragmentThrottle => {
15821 if fragment_throttle__.is_some() {
15822 return Err(serde::de::Error::duplicate_field("fragmentThrottle"));
15823 }
15824 fragment_throttle__ = Some(
15825 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15826 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15827 );
15828 }
15829 }
15830 }
15831 Ok(ThrottleMutation {
15832 fragment_throttle: fragment_throttle__.unwrap_or_default(),
15833 })
15834 }
15835 }
15836 deserializer.deserialize_struct("stream_plan.ThrottleMutation", FIELDS, GeneratedVisitor)
15837 }
15838}
15839impl serde::Serialize for throttle_mutation::ThrottleConfig {
15840 #[allow(deprecated)]
15841 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15842 where
15843 S: serde::Serializer,
15844 {
15845 use serde::ser::SerializeStruct;
15846 let mut len = 0;
15847 if self.rate_limit.is_some() {
15848 len += 1;
15849 }
15850 if self.throttle_type != 0 {
15851 len += 1;
15852 }
15853 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation.ThrottleConfig", len)?;
15854 if let Some(v) = self.rate_limit.as_ref() {
15855 struct_ser.serialize_field("rateLimit", v)?;
15856 }
15857 if self.throttle_type != 0 {
15858 let v = super::common::ThrottleType::try_from(self.throttle_type)
15859 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.throttle_type)))?;
15860 struct_ser.serialize_field("throttleType", &v)?;
15861 }
15862 struct_ser.end()
15863 }
15864}
15865impl<'de> serde::Deserialize<'de> for throttle_mutation::ThrottleConfig {
15866 #[allow(deprecated)]
15867 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15868 where
15869 D: serde::Deserializer<'de>,
15870 {
15871 const FIELDS: &[&str] = &[
15872 "rate_limit",
15873 "rateLimit",
15874 "throttle_type",
15875 "throttleType",
15876 ];
15877
15878 #[allow(clippy::enum_variant_names)]
15879 enum GeneratedField {
15880 RateLimit,
15881 ThrottleType,
15882 }
15883 impl<'de> serde::Deserialize<'de> for GeneratedField {
15884 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15885 where
15886 D: serde::Deserializer<'de>,
15887 {
15888 struct GeneratedVisitor;
15889
15890 impl serde::de::Visitor<'_> for GeneratedVisitor {
15891 type Value = GeneratedField;
15892
15893 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15894 write!(formatter, "expected one of: {:?}", &FIELDS)
15895 }
15896
15897 #[allow(unused_variables)]
15898 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15899 where
15900 E: serde::de::Error,
15901 {
15902 match value {
15903 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
15904 "throttleType" | "throttle_type" => Ok(GeneratedField::ThrottleType),
15905 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15906 }
15907 }
15908 }
15909 deserializer.deserialize_identifier(GeneratedVisitor)
15910 }
15911 }
15912 struct GeneratedVisitor;
15913 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15914 type Value = throttle_mutation::ThrottleConfig;
15915
15916 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15917 formatter.write_str("struct stream_plan.ThrottleMutation.ThrottleConfig")
15918 }
15919
15920 fn visit_map<V>(self, mut map_: V) -> std::result::Result<throttle_mutation::ThrottleConfig, V::Error>
15921 where
15922 V: serde::de::MapAccess<'de>,
15923 {
15924 let mut rate_limit__ = None;
15925 let mut throttle_type__ = None;
15926 while let Some(k) = map_.next_key()? {
15927 match k {
15928 GeneratedField::RateLimit => {
15929 if rate_limit__.is_some() {
15930 return Err(serde::de::Error::duplicate_field("rateLimit"));
15931 }
15932 rate_limit__ =
15933 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15934 ;
15935 }
15936 GeneratedField::ThrottleType => {
15937 if throttle_type__.is_some() {
15938 return Err(serde::de::Error::duplicate_field("throttleType"));
15939 }
15940 throttle_type__ = Some(map_.next_value::<super::common::ThrottleType>()? as i32);
15941 }
15942 }
15943 }
15944 Ok(throttle_mutation::ThrottleConfig {
15945 rate_limit: rate_limit__,
15946 throttle_type: throttle_type__.unwrap_or_default(),
15947 })
15948 }
15949 }
15950 deserializer.deserialize_struct("stream_plan.ThrottleMutation.ThrottleConfig", FIELDS, GeneratedVisitor)
15951 }
15952}
15953impl serde::Serialize for TopNNode {
15954 #[allow(deprecated)]
15955 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15956 where
15957 S: serde::Serializer,
15958 {
15959 use serde::ser::SerializeStruct;
15960 let mut len = 0;
15961 if self.limit != 0 {
15962 len += 1;
15963 }
15964 if self.offset != 0 {
15965 len += 1;
15966 }
15967 if self.table.is_some() {
15968 len += 1;
15969 }
15970 if !self.order_by.is_empty() {
15971 len += 1;
15972 }
15973 if self.with_ties {
15974 len += 1;
15975 }
15976 let mut struct_ser = serializer.serialize_struct("stream_plan.TopNNode", len)?;
15977 if self.limit != 0 {
15978 #[allow(clippy::needless_borrow)]
15979 #[allow(clippy::needless_borrows_for_generic_args)]
15980 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
15981 }
15982 if self.offset != 0 {
15983 #[allow(clippy::needless_borrow)]
15984 #[allow(clippy::needless_borrows_for_generic_args)]
15985 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
15986 }
15987 if let Some(v) = self.table.as_ref() {
15988 struct_ser.serialize_field("table", v)?;
15989 }
15990 if !self.order_by.is_empty() {
15991 struct_ser.serialize_field("orderBy", &self.order_by)?;
15992 }
15993 if self.with_ties {
15994 struct_ser.serialize_field("withTies", &self.with_ties)?;
15995 }
15996 struct_ser.end()
15997 }
15998}
15999impl<'de> serde::Deserialize<'de> for TopNNode {
16000 #[allow(deprecated)]
16001 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16002 where
16003 D: serde::Deserializer<'de>,
16004 {
16005 const FIELDS: &[&str] = &[
16006 "limit",
16007 "offset",
16008 "table",
16009 "order_by",
16010 "orderBy",
16011 "with_ties",
16012 "withTies",
16013 ];
16014
16015 #[allow(clippy::enum_variant_names)]
16016 enum GeneratedField {
16017 Limit,
16018 Offset,
16019 Table,
16020 OrderBy,
16021 WithTies,
16022 }
16023 impl<'de> serde::Deserialize<'de> for GeneratedField {
16024 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16025 where
16026 D: serde::Deserializer<'de>,
16027 {
16028 struct GeneratedVisitor;
16029
16030 impl serde::de::Visitor<'_> for GeneratedVisitor {
16031 type Value = GeneratedField;
16032
16033 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16034 write!(formatter, "expected one of: {:?}", &FIELDS)
16035 }
16036
16037 #[allow(unused_variables)]
16038 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16039 where
16040 E: serde::de::Error,
16041 {
16042 match value {
16043 "limit" => Ok(GeneratedField::Limit),
16044 "offset" => Ok(GeneratedField::Offset),
16045 "table" => Ok(GeneratedField::Table),
16046 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
16047 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
16048 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16049 }
16050 }
16051 }
16052 deserializer.deserialize_identifier(GeneratedVisitor)
16053 }
16054 }
16055 struct GeneratedVisitor;
16056 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16057 type Value = TopNNode;
16058
16059 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16060 formatter.write_str("struct stream_plan.TopNNode")
16061 }
16062
16063 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
16064 where
16065 V: serde::de::MapAccess<'de>,
16066 {
16067 let mut limit__ = None;
16068 let mut offset__ = None;
16069 let mut table__ = None;
16070 let mut order_by__ = None;
16071 let mut with_ties__ = None;
16072 while let Some(k) = map_.next_key()? {
16073 match k {
16074 GeneratedField::Limit => {
16075 if limit__.is_some() {
16076 return Err(serde::de::Error::duplicate_field("limit"));
16077 }
16078 limit__ =
16079 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16080 ;
16081 }
16082 GeneratedField::Offset => {
16083 if offset__.is_some() {
16084 return Err(serde::de::Error::duplicate_field("offset"));
16085 }
16086 offset__ =
16087 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16088 ;
16089 }
16090 GeneratedField::Table => {
16091 if table__.is_some() {
16092 return Err(serde::de::Error::duplicate_field("table"));
16093 }
16094 table__ = map_.next_value()?;
16095 }
16096 GeneratedField::OrderBy => {
16097 if order_by__.is_some() {
16098 return Err(serde::de::Error::duplicate_field("orderBy"));
16099 }
16100 order_by__ = Some(map_.next_value()?);
16101 }
16102 GeneratedField::WithTies => {
16103 if with_ties__.is_some() {
16104 return Err(serde::de::Error::duplicate_field("withTies"));
16105 }
16106 with_ties__ = Some(map_.next_value()?);
16107 }
16108 }
16109 }
16110 Ok(TopNNode {
16111 limit: limit__.unwrap_or_default(),
16112 offset: offset__.unwrap_or_default(),
16113 table: table__,
16114 order_by: order_by__.unwrap_or_default(),
16115 with_ties: with_ties__.unwrap_or_default(),
16116 })
16117 }
16118 }
16119 deserializer.deserialize_struct("stream_plan.TopNNode", FIELDS, GeneratedVisitor)
16120 }
16121}
16122impl serde::Serialize for UnionNode {
16123 #[allow(deprecated)]
16124 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16125 where
16126 S: serde::Serializer,
16127 {
16128 use serde::ser::SerializeStruct;
16129 let len = 0;
16130 let struct_ser = serializer.serialize_struct("stream_plan.UnionNode", len)?;
16131 struct_ser.end()
16132 }
16133}
16134impl<'de> serde::Deserialize<'de> for UnionNode {
16135 #[allow(deprecated)]
16136 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16137 where
16138 D: serde::Deserializer<'de>,
16139 {
16140 const FIELDS: &[&str] = &[
16141 ];
16142
16143 #[allow(clippy::enum_variant_names)]
16144 enum GeneratedField {
16145 }
16146 impl<'de> serde::Deserialize<'de> for GeneratedField {
16147 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16148 where
16149 D: serde::Deserializer<'de>,
16150 {
16151 struct GeneratedVisitor;
16152
16153 impl serde::de::Visitor<'_> for GeneratedVisitor {
16154 type Value = GeneratedField;
16155
16156 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16157 write!(formatter, "expected one of: {:?}", &FIELDS)
16158 }
16159
16160 #[allow(unused_variables)]
16161 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16162 where
16163 E: serde::de::Error,
16164 {
16165 Err(serde::de::Error::unknown_field(value, FIELDS))
16166 }
16167 }
16168 deserializer.deserialize_identifier(GeneratedVisitor)
16169 }
16170 }
16171 struct GeneratedVisitor;
16172 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16173 type Value = UnionNode;
16174
16175 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16176 formatter.write_str("struct stream_plan.UnionNode")
16177 }
16178
16179 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
16180 where
16181 V: serde::de::MapAccess<'de>,
16182 {
16183 while map_.next_key::<GeneratedField>()?.is_some() {
16184 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16185 }
16186 Ok(UnionNode {
16187 })
16188 }
16189 }
16190 deserializer.deserialize_struct("stream_plan.UnionNode", FIELDS, GeneratedVisitor)
16191 }
16192}
16193impl serde::Serialize for UpdateMutation {
16194 #[allow(deprecated)]
16195 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16196 where
16197 S: serde::Serializer,
16198 {
16199 use serde::ser::SerializeStruct;
16200 let mut len = 0;
16201 if !self.dispatcher_update.is_empty() {
16202 len += 1;
16203 }
16204 if !self.merge_update.is_empty() {
16205 len += 1;
16206 }
16207 if !self.actor_vnode_bitmap_update.is_empty() {
16208 len += 1;
16209 }
16210 if !self.dropped_actors.is_empty() {
16211 len += 1;
16212 }
16213 if !self.actor_splits.is_empty() {
16214 len += 1;
16215 }
16216 if !self.actor_new_dispatchers.is_empty() {
16217 len += 1;
16218 }
16219 if self.actor_cdc_table_snapshot_splits.is_some() {
16220 len += 1;
16221 }
16222 if !self.sink_schema_change.is_empty() {
16223 len += 1;
16224 }
16225 if !self.subscriptions_to_drop.is_empty() {
16226 len += 1;
16227 }
16228 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation", len)?;
16229 if !self.dispatcher_update.is_empty() {
16230 struct_ser.serialize_field("dispatcherUpdate", &self.dispatcher_update)?;
16231 }
16232 if !self.merge_update.is_empty() {
16233 struct_ser.serialize_field("mergeUpdate", &self.merge_update)?;
16234 }
16235 if !self.actor_vnode_bitmap_update.is_empty() {
16236 struct_ser.serialize_field("actorVnodeBitmapUpdate", &self.actor_vnode_bitmap_update)?;
16237 }
16238 if !self.dropped_actors.is_empty() {
16239 struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
16240 }
16241 if !self.actor_splits.is_empty() {
16242 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
16243 }
16244 if !self.actor_new_dispatchers.is_empty() {
16245 struct_ser.serialize_field("actorNewDispatchers", &self.actor_new_dispatchers)?;
16246 }
16247 if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
16248 struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
16249 }
16250 if !self.sink_schema_change.is_empty() {
16251 struct_ser.serialize_field("sinkSchemaChange", &self.sink_schema_change)?;
16252 }
16253 if !self.subscriptions_to_drop.is_empty() {
16254 struct_ser.serialize_field("subscriptionsToDrop", &self.subscriptions_to_drop)?;
16255 }
16256 struct_ser.end()
16257 }
16258}
16259impl<'de> serde::Deserialize<'de> for UpdateMutation {
16260 #[allow(deprecated)]
16261 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16262 where
16263 D: serde::Deserializer<'de>,
16264 {
16265 const FIELDS: &[&str] = &[
16266 "dispatcher_update",
16267 "dispatcherUpdate",
16268 "merge_update",
16269 "mergeUpdate",
16270 "actor_vnode_bitmap_update",
16271 "actorVnodeBitmapUpdate",
16272 "dropped_actors",
16273 "droppedActors",
16274 "actor_splits",
16275 "actorSplits",
16276 "actor_new_dispatchers",
16277 "actorNewDispatchers",
16278 "actor_cdc_table_snapshot_splits",
16279 "actorCdcTableSnapshotSplits",
16280 "sink_schema_change",
16281 "sinkSchemaChange",
16282 "subscriptions_to_drop",
16283 "subscriptionsToDrop",
16284 ];
16285
16286 #[allow(clippy::enum_variant_names)]
16287 enum GeneratedField {
16288 DispatcherUpdate,
16289 MergeUpdate,
16290 ActorVnodeBitmapUpdate,
16291 DroppedActors,
16292 ActorSplits,
16293 ActorNewDispatchers,
16294 ActorCdcTableSnapshotSplits,
16295 SinkSchemaChange,
16296 SubscriptionsToDrop,
16297 }
16298 impl<'de> serde::Deserialize<'de> for GeneratedField {
16299 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16300 where
16301 D: serde::Deserializer<'de>,
16302 {
16303 struct GeneratedVisitor;
16304
16305 impl serde::de::Visitor<'_> for GeneratedVisitor {
16306 type Value = GeneratedField;
16307
16308 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16309 write!(formatter, "expected one of: {:?}", &FIELDS)
16310 }
16311
16312 #[allow(unused_variables)]
16313 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16314 where
16315 E: serde::de::Error,
16316 {
16317 match value {
16318 "dispatcherUpdate" | "dispatcher_update" => Ok(GeneratedField::DispatcherUpdate),
16319 "mergeUpdate" | "merge_update" => Ok(GeneratedField::MergeUpdate),
16320 "actorVnodeBitmapUpdate" | "actor_vnode_bitmap_update" => Ok(GeneratedField::ActorVnodeBitmapUpdate),
16321 "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
16322 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
16323 "actorNewDispatchers" | "actor_new_dispatchers" => Ok(GeneratedField::ActorNewDispatchers),
16324 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
16325 "sinkSchemaChange" | "sink_schema_change" => Ok(GeneratedField::SinkSchemaChange),
16326 "subscriptionsToDrop" | "subscriptions_to_drop" => Ok(GeneratedField::SubscriptionsToDrop),
16327 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16328 }
16329 }
16330 }
16331 deserializer.deserialize_identifier(GeneratedVisitor)
16332 }
16333 }
16334 struct GeneratedVisitor;
16335 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16336 type Value = UpdateMutation;
16337
16338 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16339 formatter.write_str("struct stream_plan.UpdateMutation")
16340 }
16341
16342 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateMutation, V::Error>
16343 where
16344 V: serde::de::MapAccess<'de>,
16345 {
16346 let mut dispatcher_update__ = None;
16347 let mut merge_update__ = None;
16348 let mut actor_vnode_bitmap_update__ = None;
16349 let mut dropped_actors__ = None;
16350 let mut actor_splits__ = None;
16351 let mut actor_new_dispatchers__ = None;
16352 let mut actor_cdc_table_snapshot_splits__ = None;
16353 let mut sink_schema_change__ = None;
16354 let mut subscriptions_to_drop__ = None;
16355 while let Some(k) = map_.next_key()? {
16356 match k {
16357 GeneratedField::DispatcherUpdate => {
16358 if dispatcher_update__.is_some() {
16359 return Err(serde::de::Error::duplicate_field("dispatcherUpdate"));
16360 }
16361 dispatcher_update__ = Some(map_.next_value()?);
16362 }
16363 GeneratedField::MergeUpdate => {
16364 if merge_update__.is_some() {
16365 return Err(serde::de::Error::duplicate_field("mergeUpdate"));
16366 }
16367 merge_update__ = Some(map_.next_value()?);
16368 }
16369 GeneratedField::ActorVnodeBitmapUpdate => {
16370 if actor_vnode_bitmap_update__.is_some() {
16371 return Err(serde::de::Error::duplicate_field("actorVnodeBitmapUpdate"));
16372 }
16373 actor_vnode_bitmap_update__ = Some(
16374 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
16375 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
16376 );
16377 }
16378 GeneratedField::DroppedActors => {
16379 if dropped_actors__.is_some() {
16380 return Err(serde::de::Error::duplicate_field("droppedActors"));
16381 }
16382 dropped_actors__ =
16383 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16384 .into_iter().map(|x| x.0).collect())
16385 ;
16386 }
16387 GeneratedField::ActorSplits => {
16388 if actor_splits__.is_some() {
16389 return Err(serde::de::Error::duplicate_field("actorSplits"));
16390 }
16391 actor_splits__ = Some(
16392 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
16393 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
16394 );
16395 }
16396 GeneratedField::ActorNewDispatchers => {
16397 if actor_new_dispatchers__.is_some() {
16398 return Err(serde::de::Error::duplicate_field("actorNewDispatchers"));
16399 }
16400 actor_new_dispatchers__ = Some(
16401 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
16402 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
16403 );
16404 }
16405 GeneratedField::ActorCdcTableSnapshotSplits => {
16406 if actor_cdc_table_snapshot_splits__.is_some() {
16407 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
16408 }
16409 actor_cdc_table_snapshot_splits__ = map_.next_value()?;
16410 }
16411 GeneratedField::SinkSchemaChange => {
16412 if sink_schema_change__.is_some() {
16413 return Err(serde::de::Error::duplicate_field("sinkSchemaChange"));
16414 }
16415 sink_schema_change__ = Some(
16416 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
16417 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
16418 );
16419 }
16420 GeneratedField::SubscriptionsToDrop => {
16421 if subscriptions_to_drop__.is_some() {
16422 return Err(serde::de::Error::duplicate_field("subscriptionsToDrop"));
16423 }
16424 subscriptions_to_drop__ = Some(map_.next_value()?);
16425 }
16426 }
16427 }
16428 Ok(UpdateMutation {
16429 dispatcher_update: dispatcher_update__.unwrap_or_default(),
16430 merge_update: merge_update__.unwrap_or_default(),
16431 actor_vnode_bitmap_update: actor_vnode_bitmap_update__.unwrap_or_default(),
16432 dropped_actors: dropped_actors__.unwrap_or_default(),
16433 actor_splits: actor_splits__.unwrap_or_default(),
16434 actor_new_dispatchers: actor_new_dispatchers__.unwrap_or_default(),
16435 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
16436 sink_schema_change: sink_schema_change__.unwrap_or_default(),
16437 subscriptions_to_drop: subscriptions_to_drop__.unwrap_or_default(),
16438 })
16439 }
16440 }
16441 deserializer.deserialize_struct("stream_plan.UpdateMutation", FIELDS, GeneratedVisitor)
16442 }
16443}
16444impl serde::Serialize for update_mutation::DispatcherUpdate {
16445 #[allow(deprecated)]
16446 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16447 where
16448 S: serde::Serializer,
16449 {
16450 use serde::ser::SerializeStruct;
16451 let mut len = 0;
16452 if self.actor_id != 0 {
16453 len += 1;
16454 }
16455 if self.dispatcher_id != 0 {
16456 len += 1;
16457 }
16458 if self.hash_mapping.is_some() {
16459 len += 1;
16460 }
16461 if !self.added_downstream_actor_id.is_empty() {
16462 len += 1;
16463 }
16464 if !self.removed_downstream_actor_id.is_empty() {
16465 len += 1;
16466 }
16467 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", len)?;
16468 if self.actor_id != 0 {
16469 struct_ser.serialize_field("actorId", &self.actor_id)?;
16470 }
16471 if self.dispatcher_id != 0 {
16472 struct_ser.serialize_field("dispatcherId", &self.dispatcher_id)?;
16473 }
16474 if let Some(v) = self.hash_mapping.as_ref() {
16475 struct_ser.serialize_field("hashMapping", v)?;
16476 }
16477 if !self.added_downstream_actor_id.is_empty() {
16478 struct_ser.serialize_field("addedDownstreamActorId", &self.added_downstream_actor_id)?;
16479 }
16480 if !self.removed_downstream_actor_id.is_empty() {
16481 struct_ser.serialize_field("removedDownstreamActorId", &self.removed_downstream_actor_id)?;
16482 }
16483 struct_ser.end()
16484 }
16485}
16486impl<'de> serde::Deserialize<'de> for update_mutation::DispatcherUpdate {
16487 #[allow(deprecated)]
16488 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16489 where
16490 D: serde::Deserializer<'de>,
16491 {
16492 const FIELDS: &[&str] = &[
16493 "actor_id",
16494 "actorId",
16495 "dispatcher_id",
16496 "dispatcherId",
16497 "hash_mapping",
16498 "hashMapping",
16499 "added_downstream_actor_id",
16500 "addedDownstreamActorId",
16501 "removed_downstream_actor_id",
16502 "removedDownstreamActorId",
16503 ];
16504
16505 #[allow(clippy::enum_variant_names)]
16506 enum GeneratedField {
16507 ActorId,
16508 DispatcherId,
16509 HashMapping,
16510 AddedDownstreamActorId,
16511 RemovedDownstreamActorId,
16512 }
16513 impl<'de> serde::Deserialize<'de> for GeneratedField {
16514 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16515 where
16516 D: serde::Deserializer<'de>,
16517 {
16518 struct GeneratedVisitor;
16519
16520 impl serde::de::Visitor<'_> for GeneratedVisitor {
16521 type Value = GeneratedField;
16522
16523 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16524 write!(formatter, "expected one of: {:?}", &FIELDS)
16525 }
16526
16527 #[allow(unused_variables)]
16528 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16529 where
16530 E: serde::de::Error,
16531 {
16532 match value {
16533 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
16534 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
16535 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
16536 "addedDownstreamActorId" | "added_downstream_actor_id" => Ok(GeneratedField::AddedDownstreamActorId),
16537 "removedDownstreamActorId" | "removed_downstream_actor_id" => Ok(GeneratedField::RemovedDownstreamActorId),
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 = update_mutation::DispatcherUpdate;
16548
16549 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16550 formatter.write_str("struct stream_plan.UpdateMutation.DispatcherUpdate")
16551 }
16552
16553 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::DispatcherUpdate, V::Error>
16554 where
16555 V: serde::de::MapAccess<'de>,
16556 {
16557 let mut actor_id__ = None;
16558 let mut dispatcher_id__ = None;
16559 let mut hash_mapping__ = None;
16560 let mut added_downstream_actor_id__ = None;
16561 let mut removed_downstream_actor_id__ = None;
16562 while let Some(k) = map_.next_key()? {
16563 match k {
16564 GeneratedField::ActorId => {
16565 if actor_id__.is_some() {
16566 return Err(serde::de::Error::duplicate_field("actorId"));
16567 }
16568 actor_id__ =
16569 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16570 ;
16571 }
16572 GeneratedField::DispatcherId => {
16573 if dispatcher_id__.is_some() {
16574 return Err(serde::de::Error::duplicate_field("dispatcherId"));
16575 }
16576 dispatcher_id__ =
16577 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16578 ;
16579 }
16580 GeneratedField::HashMapping => {
16581 if hash_mapping__.is_some() {
16582 return Err(serde::de::Error::duplicate_field("hashMapping"));
16583 }
16584 hash_mapping__ = map_.next_value()?;
16585 }
16586 GeneratedField::AddedDownstreamActorId => {
16587 if added_downstream_actor_id__.is_some() {
16588 return Err(serde::de::Error::duplicate_field("addedDownstreamActorId"));
16589 }
16590 added_downstream_actor_id__ =
16591 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16592 .into_iter().map(|x| x.0).collect())
16593 ;
16594 }
16595 GeneratedField::RemovedDownstreamActorId => {
16596 if removed_downstream_actor_id__.is_some() {
16597 return Err(serde::de::Error::duplicate_field("removedDownstreamActorId"));
16598 }
16599 removed_downstream_actor_id__ =
16600 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16601 .into_iter().map(|x| x.0).collect())
16602 ;
16603 }
16604 }
16605 }
16606 Ok(update_mutation::DispatcherUpdate {
16607 actor_id: actor_id__.unwrap_or_default(),
16608 dispatcher_id: dispatcher_id__.unwrap_or_default(),
16609 hash_mapping: hash_mapping__,
16610 added_downstream_actor_id: added_downstream_actor_id__.unwrap_or_default(),
16611 removed_downstream_actor_id: removed_downstream_actor_id__.unwrap_or_default(),
16612 })
16613 }
16614 }
16615 deserializer.deserialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", FIELDS, GeneratedVisitor)
16616 }
16617}
16618impl serde::Serialize for update_mutation::MergeUpdate {
16619 #[allow(deprecated)]
16620 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16621 where
16622 S: serde::Serializer,
16623 {
16624 use serde::ser::SerializeStruct;
16625 let mut len = 0;
16626 if self.actor_id != 0 {
16627 len += 1;
16628 }
16629 if self.upstream_fragment_id != 0 {
16630 len += 1;
16631 }
16632 if self.new_upstream_fragment_id.is_some() {
16633 len += 1;
16634 }
16635 if !self.added_upstream_actors.is_empty() {
16636 len += 1;
16637 }
16638 if !self.removed_upstream_actor_id.is_empty() {
16639 len += 1;
16640 }
16641 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.MergeUpdate", len)?;
16642 if self.actor_id != 0 {
16643 struct_ser.serialize_field("actorId", &self.actor_id)?;
16644 }
16645 if self.upstream_fragment_id != 0 {
16646 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
16647 }
16648 if let Some(v) = self.new_upstream_fragment_id.as_ref() {
16649 struct_ser.serialize_field("newUpstreamFragmentId", v)?;
16650 }
16651 if !self.added_upstream_actors.is_empty() {
16652 struct_ser.serialize_field("addedUpstreamActors", &self.added_upstream_actors)?;
16653 }
16654 if !self.removed_upstream_actor_id.is_empty() {
16655 struct_ser.serialize_field("removedUpstreamActorId", &self.removed_upstream_actor_id)?;
16656 }
16657 struct_ser.end()
16658 }
16659}
16660impl<'de> serde::Deserialize<'de> for update_mutation::MergeUpdate {
16661 #[allow(deprecated)]
16662 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16663 where
16664 D: serde::Deserializer<'de>,
16665 {
16666 const FIELDS: &[&str] = &[
16667 "actor_id",
16668 "actorId",
16669 "upstream_fragment_id",
16670 "upstreamFragmentId",
16671 "new_upstream_fragment_id",
16672 "newUpstreamFragmentId",
16673 "added_upstream_actors",
16674 "addedUpstreamActors",
16675 "removed_upstream_actor_id",
16676 "removedUpstreamActorId",
16677 ];
16678
16679 #[allow(clippy::enum_variant_names)]
16680 enum GeneratedField {
16681 ActorId,
16682 UpstreamFragmentId,
16683 NewUpstreamFragmentId,
16684 AddedUpstreamActors,
16685 RemovedUpstreamActorId,
16686 }
16687 impl<'de> serde::Deserialize<'de> for GeneratedField {
16688 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16689 where
16690 D: serde::Deserializer<'de>,
16691 {
16692 struct GeneratedVisitor;
16693
16694 impl serde::de::Visitor<'_> for GeneratedVisitor {
16695 type Value = GeneratedField;
16696
16697 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16698 write!(formatter, "expected one of: {:?}", &FIELDS)
16699 }
16700
16701 #[allow(unused_variables)]
16702 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16703 where
16704 E: serde::de::Error,
16705 {
16706 match value {
16707 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
16708 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
16709 "newUpstreamFragmentId" | "new_upstream_fragment_id" => Ok(GeneratedField::NewUpstreamFragmentId),
16710 "addedUpstreamActors" | "added_upstream_actors" => Ok(GeneratedField::AddedUpstreamActors),
16711 "removedUpstreamActorId" | "removed_upstream_actor_id" => Ok(GeneratedField::RemovedUpstreamActorId),
16712 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16713 }
16714 }
16715 }
16716 deserializer.deserialize_identifier(GeneratedVisitor)
16717 }
16718 }
16719 struct GeneratedVisitor;
16720 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16721 type Value = update_mutation::MergeUpdate;
16722
16723 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16724 formatter.write_str("struct stream_plan.UpdateMutation.MergeUpdate")
16725 }
16726
16727 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::MergeUpdate, V::Error>
16728 where
16729 V: serde::de::MapAccess<'de>,
16730 {
16731 let mut actor_id__ = None;
16732 let mut upstream_fragment_id__ = None;
16733 let mut new_upstream_fragment_id__ = None;
16734 let mut added_upstream_actors__ = None;
16735 let mut removed_upstream_actor_id__ = None;
16736 while let Some(k) = map_.next_key()? {
16737 match k {
16738 GeneratedField::ActorId => {
16739 if actor_id__.is_some() {
16740 return Err(serde::de::Error::duplicate_field("actorId"));
16741 }
16742 actor_id__ =
16743 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16744 ;
16745 }
16746 GeneratedField::UpstreamFragmentId => {
16747 if upstream_fragment_id__.is_some() {
16748 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
16749 }
16750 upstream_fragment_id__ =
16751 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16752 ;
16753 }
16754 GeneratedField::NewUpstreamFragmentId => {
16755 if new_upstream_fragment_id__.is_some() {
16756 return Err(serde::de::Error::duplicate_field("newUpstreamFragmentId"));
16757 }
16758 new_upstream_fragment_id__ =
16759 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16760 ;
16761 }
16762 GeneratedField::AddedUpstreamActors => {
16763 if added_upstream_actors__.is_some() {
16764 return Err(serde::de::Error::duplicate_field("addedUpstreamActors"));
16765 }
16766 added_upstream_actors__ = Some(map_.next_value()?);
16767 }
16768 GeneratedField::RemovedUpstreamActorId => {
16769 if removed_upstream_actor_id__.is_some() {
16770 return Err(serde::de::Error::duplicate_field("removedUpstreamActorId"));
16771 }
16772 removed_upstream_actor_id__ =
16773 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16774 .into_iter().map(|x| x.0).collect())
16775 ;
16776 }
16777 }
16778 }
16779 Ok(update_mutation::MergeUpdate {
16780 actor_id: actor_id__.unwrap_or_default(),
16781 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
16782 new_upstream_fragment_id: new_upstream_fragment_id__,
16783 added_upstream_actors: added_upstream_actors__.unwrap_or_default(),
16784 removed_upstream_actor_id: removed_upstream_actor_id__.unwrap_or_default(),
16785 })
16786 }
16787 }
16788 deserializer.deserialize_struct("stream_plan.UpdateMutation.MergeUpdate", FIELDS, GeneratedVisitor)
16789 }
16790}
16791impl serde::Serialize for UpstreamSinkInfo {
16792 #[allow(deprecated)]
16793 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16794 where
16795 S: serde::Serializer,
16796 {
16797 use serde::ser::SerializeStruct;
16798 let mut len = 0;
16799 if self.upstream_fragment_id != 0 {
16800 len += 1;
16801 }
16802 if !self.sink_output_schema.is_empty() {
16803 len += 1;
16804 }
16805 if !self.project_exprs.is_empty() {
16806 len += 1;
16807 }
16808 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkInfo", len)?;
16809 if self.upstream_fragment_id != 0 {
16810 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
16811 }
16812 if !self.sink_output_schema.is_empty() {
16813 struct_ser.serialize_field("sinkOutputSchema", &self.sink_output_schema)?;
16814 }
16815 if !self.project_exprs.is_empty() {
16816 struct_ser.serialize_field("projectExprs", &self.project_exprs)?;
16817 }
16818 struct_ser.end()
16819 }
16820}
16821impl<'de> serde::Deserialize<'de> for UpstreamSinkInfo {
16822 #[allow(deprecated)]
16823 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16824 where
16825 D: serde::Deserializer<'de>,
16826 {
16827 const FIELDS: &[&str] = &[
16828 "upstream_fragment_id",
16829 "upstreamFragmentId",
16830 "sink_output_schema",
16831 "sinkOutputSchema",
16832 "project_exprs",
16833 "projectExprs",
16834 ];
16835
16836 #[allow(clippy::enum_variant_names)]
16837 enum GeneratedField {
16838 UpstreamFragmentId,
16839 SinkOutputSchema,
16840 ProjectExprs,
16841 }
16842 impl<'de> serde::Deserialize<'de> for GeneratedField {
16843 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16844 where
16845 D: serde::Deserializer<'de>,
16846 {
16847 struct GeneratedVisitor;
16848
16849 impl serde::de::Visitor<'_> for GeneratedVisitor {
16850 type Value = GeneratedField;
16851
16852 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16853 write!(formatter, "expected one of: {:?}", &FIELDS)
16854 }
16855
16856 #[allow(unused_variables)]
16857 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16858 where
16859 E: serde::de::Error,
16860 {
16861 match value {
16862 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
16863 "sinkOutputSchema" | "sink_output_schema" => Ok(GeneratedField::SinkOutputSchema),
16864 "projectExprs" | "project_exprs" => Ok(GeneratedField::ProjectExprs),
16865 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16866 }
16867 }
16868 }
16869 deserializer.deserialize_identifier(GeneratedVisitor)
16870 }
16871 }
16872 struct GeneratedVisitor;
16873 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16874 type Value = UpstreamSinkInfo;
16875
16876 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16877 formatter.write_str("struct stream_plan.UpstreamSinkInfo")
16878 }
16879
16880 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkInfo, V::Error>
16881 where
16882 V: serde::de::MapAccess<'de>,
16883 {
16884 let mut upstream_fragment_id__ = None;
16885 let mut sink_output_schema__ = None;
16886 let mut project_exprs__ = None;
16887 while let Some(k) = map_.next_key()? {
16888 match k {
16889 GeneratedField::UpstreamFragmentId => {
16890 if upstream_fragment_id__.is_some() {
16891 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
16892 }
16893 upstream_fragment_id__ =
16894 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16895 ;
16896 }
16897 GeneratedField::SinkOutputSchema => {
16898 if sink_output_schema__.is_some() {
16899 return Err(serde::de::Error::duplicate_field("sinkOutputSchema"));
16900 }
16901 sink_output_schema__ = Some(map_.next_value()?);
16902 }
16903 GeneratedField::ProjectExprs => {
16904 if project_exprs__.is_some() {
16905 return Err(serde::de::Error::duplicate_field("projectExprs"));
16906 }
16907 project_exprs__ = Some(map_.next_value()?);
16908 }
16909 }
16910 }
16911 Ok(UpstreamSinkInfo {
16912 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
16913 sink_output_schema: sink_output_schema__.unwrap_or_default(),
16914 project_exprs: project_exprs__.unwrap_or_default(),
16915 })
16916 }
16917 }
16918 deserializer.deserialize_struct("stream_plan.UpstreamSinkInfo", FIELDS, GeneratedVisitor)
16919 }
16920}
16921impl serde::Serialize for UpstreamSinkUnionNode {
16922 #[allow(deprecated)]
16923 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16924 where
16925 S: serde::Serializer,
16926 {
16927 use serde::ser::SerializeStruct;
16928 let mut len = 0;
16929 if !self.init_upstreams.is_empty() {
16930 len += 1;
16931 }
16932 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkUnionNode", len)?;
16933 if !self.init_upstreams.is_empty() {
16934 struct_ser.serialize_field("initUpstreams", &self.init_upstreams)?;
16935 }
16936 struct_ser.end()
16937 }
16938}
16939impl<'de> serde::Deserialize<'de> for UpstreamSinkUnionNode {
16940 #[allow(deprecated)]
16941 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16942 where
16943 D: serde::Deserializer<'de>,
16944 {
16945 const FIELDS: &[&str] = &[
16946 "init_upstreams",
16947 "initUpstreams",
16948 ];
16949
16950 #[allow(clippy::enum_variant_names)]
16951 enum GeneratedField {
16952 InitUpstreams,
16953 }
16954 impl<'de> serde::Deserialize<'de> for GeneratedField {
16955 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16956 where
16957 D: serde::Deserializer<'de>,
16958 {
16959 struct GeneratedVisitor;
16960
16961 impl serde::de::Visitor<'_> for GeneratedVisitor {
16962 type Value = GeneratedField;
16963
16964 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16965 write!(formatter, "expected one of: {:?}", &FIELDS)
16966 }
16967
16968 #[allow(unused_variables)]
16969 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16970 where
16971 E: serde::de::Error,
16972 {
16973 match value {
16974 "initUpstreams" | "init_upstreams" => Ok(GeneratedField::InitUpstreams),
16975 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16976 }
16977 }
16978 }
16979 deserializer.deserialize_identifier(GeneratedVisitor)
16980 }
16981 }
16982 struct GeneratedVisitor;
16983 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16984 type Value = UpstreamSinkUnionNode;
16985
16986 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16987 formatter.write_str("struct stream_plan.UpstreamSinkUnionNode")
16988 }
16989
16990 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkUnionNode, V::Error>
16991 where
16992 V: serde::de::MapAccess<'de>,
16993 {
16994 let mut init_upstreams__ = None;
16995 while let Some(k) = map_.next_key()? {
16996 match k {
16997 GeneratedField::InitUpstreams => {
16998 if init_upstreams__.is_some() {
16999 return Err(serde::de::Error::duplicate_field("initUpstreams"));
17000 }
17001 init_upstreams__ = Some(map_.next_value()?);
17002 }
17003 }
17004 }
17005 Ok(UpstreamSinkUnionNode {
17006 init_upstreams: init_upstreams__.unwrap_or_default(),
17007 })
17008 }
17009 }
17010 deserializer.deserialize_struct("stream_plan.UpstreamSinkUnionNode", FIELDS, GeneratedVisitor)
17011 }
17012}
17013impl serde::Serialize for ValuesNode {
17014 #[allow(deprecated)]
17015 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17016 where
17017 S: serde::Serializer,
17018 {
17019 use serde::ser::SerializeStruct;
17020 let mut len = 0;
17021 if !self.tuples.is_empty() {
17022 len += 1;
17023 }
17024 if !self.fields.is_empty() {
17025 len += 1;
17026 }
17027 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode", len)?;
17028 if !self.tuples.is_empty() {
17029 struct_ser.serialize_field("tuples", &self.tuples)?;
17030 }
17031 if !self.fields.is_empty() {
17032 struct_ser.serialize_field("fields", &self.fields)?;
17033 }
17034 struct_ser.end()
17035 }
17036}
17037impl<'de> serde::Deserialize<'de> for ValuesNode {
17038 #[allow(deprecated)]
17039 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17040 where
17041 D: serde::Deserializer<'de>,
17042 {
17043 const FIELDS: &[&str] = &[
17044 "tuples",
17045 "fields",
17046 ];
17047
17048 #[allow(clippy::enum_variant_names)]
17049 enum GeneratedField {
17050 Tuples,
17051 Fields,
17052 }
17053 impl<'de> serde::Deserialize<'de> for GeneratedField {
17054 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17055 where
17056 D: serde::Deserializer<'de>,
17057 {
17058 struct GeneratedVisitor;
17059
17060 impl serde::de::Visitor<'_> for GeneratedVisitor {
17061 type Value = GeneratedField;
17062
17063 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17064 write!(formatter, "expected one of: {:?}", &FIELDS)
17065 }
17066
17067 #[allow(unused_variables)]
17068 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17069 where
17070 E: serde::de::Error,
17071 {
17072 match value {
17073 "tuples" => Ok(GeneratedField::Tuples),
17074 "fields" => Ok(GeneratedField::Fields),
17075 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17076 }
17077 }
17078 }
17079 deserializer.deserialize_identifier(GeneratedVisitor)
17080 }
17081 }
17082 struct GeneratedVisitor;
17083 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17084 type Value = ValuesNode;
17085
17086 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17087 formatter.write_str("struct stream_plan.ValuesNode")
17088 }
17089
17090 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
17091 where
17092 V: serde::de::MapAccess<'de>,
17093 {
17094 let mut tuples__ = None;
17095 let mut fields__ = None;
17096 while let Some(k) = map_.next_key()? {
17097 match k {
17098 GeneratedField::Tuples => {
17099 if tuples__.is_some() {
17100 return Err(serde::de::Error::duplicate_field("tuples"));
17101 }
17102 tuples__ = Some(map_.next_value()?);
17103 }
17104 GeneratedField::Fields => {
17105 if fields__.is_some() {
17106 return Err(serde::de::Error::duplicate_field("fields"));
17107 }
17108 fields__ = Some(map_.next_value()?);
17109 }
17110 }
17111 }
17112 Ok(ValuesNode {
17113 tuples: tuples__.unwrap_or_default(),
17114 fields: fields__.unwrap_or_default(),
17115 })
17116 }
17117 }
17118 deserializer.deserialize_struct("stream_plan.ValuesNode", FIELDS, GeneratedVisitor)
17119 }
17120}
17121impl serde::Serialize for values_node::ExprTuple {
17122 #[allow(deprecated)]
17123 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17124 where
17125 S: serde::Serializer,
17126 {
17127 use serde::ser::SerializeStruct;
17128 let mut len = 0;
17129 if !self.cells.is_empty() {
17130 len += 1;
17131 }
17132 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode.ExprTuple", len)?;
17133 if !self.cells.is_empty() {
17134 struct_ser.serialize_field("cells", &self.cells)?;
17135 }
17136 struct_ser.end()
17137 }
17138}
17139impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
17140 #[allow(deprecated)]
17141 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17142 where
17143 D: serde::Deserializer<'de>,
17144 {
17145 const FIELDS: &[&str] = &[
17146 "cells",
17147 ];
17148
17149 #[allow(clippy::enum_variant_names)]
17150 enum GeneratedField {
17151 Cells,
17152 }
17153 impl<'de> serde::Deserialize<'de> for GeneratedField {
17154 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17155 where
17156 D: serde::Deserializer<'de>,
17157 {
17158 struct GeneratedVisitor;
17159
17160 impl serde::de::Visitor<'_> for GeneratedVisitor {
17161 type Value = GeneratedField;
17162
17163 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17164 write!(formatter, "expected one of: {:?}", &FIELDS)
17165 }
17166
17167 #[allow(unused_variables)]
17168 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17169 where
17170 E: serde::de::Error,
17171 {
17172 match value {
17173 "cells" => Ok(GeneratedField::Cells),
17174 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17175 }
17176 }
17177 }
17178 deserializer.deserialize_identifier(GeneratedVisitor)
17179 }
17180 }
17181 struct GeneratedVisitor;
17182 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17183 type Value = values_node::ExprTuple;
17184
17185 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17186 formatter.write_str("struct stream_plan.ValuesNode.ExprTuple")
17187 }
17188
17189 fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
17190 where
17191 V: serde::de::MapAccess<'de>,
17192 {
17193 let mut cells__ = None;
17194 while let Some(k) = map_.next_key()? {
17195 match k {
17196 GeneratedField::Cells => {
17197 if cells__.is_some() {
17198 return Err(serde::de::Error::duplicate_field("cells"));
17199 }
17200 cells__ = Some(map_.next_value()?);
17201 }
17202 }
17203 }
17204 Ok(values_node::ExprTuple {
17205 cells: cells__.unwrap_or_default(),
17206 })
17207 }
17208 }
17209 deserializer.deserialize_struct("stream_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
17210 }
17211}
17212impl serde::Serialize for VectorIndexLookupJoinNode {
17213 #[allow(deprecated)]
17214 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17215 where
17216 S: serde::Serializer,
17217 {
17218 use serde::ser::SerializeStruct;
17219 let mut len = 0;
17220 if self.reader_desc.is_some() {
17221 len += 1;
17222 }
17223 if self.vector_column_idx != 0 {
17224 len += 1;
17225 }
17226 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexLookupJoinNode", len)?;
17227 if let Some(v) = self.reader_desc.as_ref() {
17228 struct_ser.serialize_field("readerDesc", v)?;
17229 }
17230 if self.vector_column_idx != 0 {
17231 struct_ser.serialize_field("vectorColumnIdx", &self.vector_column_idx)?;
17232 }
17233 struct_ser.end()
17234 }
17235}
17236impl<'de> serde::Deserialize<'de> for VectorIndexLookupJoinNode {
17237 #[allow(deprecated)]
17238 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17239 where
17240 D: serde::Deserializer<'de>,
17241 {
17242 const FIELDS: &[&str] = &[
17243 "reader_desc",
17244 "readerDesc",
17245 "vector_column_idx",
17246 "vectorColumnIdx",
17247 ];
17248
17249 #[allow(clippy::enum_variant_names)]
17250 enum GeneratedField {
17251 ReaderDesc,
17252 VectorColumnIdx,
17253 }
17254 impl<'de> serde::Deserialize<'de> for GeneratedField {
17255 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17256 where
17257 D: serde::Deserializer<'de>,
17258 {
17259 struct GeneratedVisitor;
17260
17261 impl serde::de::Visitor<'_> for GeneratedVisitor {
17262 type Value = GeneratedField;
17263
17264 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17265 write!(formatter, "expected one of: {:?}", &FIELDS)
17266 }
17267
17268 #[allow(unused_variables)]
17269 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17270 where
17271 E: serde::de::Error,
17272 {
17273 match value {
17274 "readerDesc" | "reader_desc" => Ok(GeneratedField::ReaderDesc),
17275 "vectorColumnIdx" | "vector_column_idx" => Ok(GeneratedField::VectorColumnIdx),
17276 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17277 }
17278 }
17279 }
17280 deserializer.deserialize_identifier(GeneratedVisitor)
17281 }
17282 }
17283 struct GeneratedVisitor;
17284 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17285 type Value = VectorIndexLookupJoinNode;
17286
17287 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17288 formatter.write_str("struct stream_plan.VectorIndexLookupJoinNode")
17289 }
17290
17291 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexLookupJoinNode, V::Error>
17292 where
17293 V: serde::de::MapAccess<'de>,
17294 {
17295 let mut reader_desc__ = None;
17296 let mut vector_column_idx__ = None;
17297 while let Some(k) = map_.next_key()? {
17298 match k {
17299 GeneratedField::ReaderDesc => {
17300 if reader_desc__.is_some() {
17301 return Err(serde::de::Error::duplicate_field("readerDesc"));
17302 }
17303 reader_desc__ = map_.next_value()?;
17304 }
17305 GeneratedField::VectorColumnIdx => {
17306 if vector_column_idx__.is_some() {
17307 return Err(serde::de::Error::duplicate_field("vectorColumnIdx"));
17308 }
17309 vector_column_idx__ =
17310 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17311 ;
17312 }
17313 }
17314 }
17315 Ok(VectorIndexLookupJoinNode {
17316 reader_desc: reader_desc__,
17317 vector_column_idx: vector_column_idx__.unwrap_or_default(),
17318 })
17319 }
17320 }
17321 deserializer.deserialize_struct("stream_plan.VectorIndexLookupJoinNode", FIELDS, GeneratedVisitor)
17322 }
17323}
17324impl serde::Serialize for VectorIndexWriteNode {
17325 #[allow(deprecated)]
17326 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17327 where
17328 S: serde::Serializer,
17329 {
17330 use serde::ser::SerializeStruct;
17331 let mut len = 0;
17332 if self.table.is_some() {
17333 len += 1;
17334 }
17335 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexWriteNode", len)?;
17336 if let Some(v) = self.table.as_ref() {
17337 struct_ser.serialize_field("table", v)?;
17338 }
17339 struct_ser.end()
17340 }
17341}
17342impl<'de> serde::Deserialize<'de> for VectorIndexWriteNode {
17343 #[allow(deprecated)]
17344 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17345 where
17346 D: serde::Deserializer<'de>,
17347 {
17348 const FIELDS: &[&str] = &[
17349 "table",
17350 ];
17351
17352 #[allow(clippy::enum_variant_names)]
17353 enum GeneratedField {
17354 Table,
17355 }
17356 impl<'de> serde::Deserialize<'de> for GeneratedField {
17357 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17358 where
17359 D: serde::Deserializer<'de>,
17360 {
17361 struct GeneratedVisitor;
17362
17363 impl serde::de::Visitor<'_> for GeneratedVisitor {
17364 type Value = GeneratedField;
17365
17366 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17367 write!(formatter, "expected one of: {:?}", &FIELDS)
17368 }
17369
17370 #[allow(unused_variables)]
17371 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17372 where
17373 E: serde::de::Error,
17374 {
17375 match value {
17376 "table" => Ok(GeneratedField::Table),
17377 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17378 }
17379 }
17380 }
17381 deserializer.deserialize_identifier(GeneratedVisitor)
17382 }
17383 }
17384 struct GeneratedVisitor;
17385 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17386 type Value = VectorIndexWriteNode;
17387
17388 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17389 formatter.write_str("struct stream_plan.VectorIndexWriteNode")
17390 }
17391
17392 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexWriteNode, V::Error>
17393 where
17394 V: serde::de::MapAccess<'de>,
17395 {
17396 let mut table__ = None;
17397 while let Some(k) = map_.next_key()? {
17398 match k {
17399 GeneratedField::Table => {
17400 if table__.is_some() {
17401 return Err(serde::de::Error::duplicate_field("table"));
17402 }
17403 table__ = map_.next_value()?;
17404 }
17405 }
17406 }
17407 Ok(VectorIndexWriteNode {
17408 table: table__,
17409 })
17410 }
17411 }
17412 deserializer.deserialize_struct("stream_plan.VectorIndexWriteNode", FIELDS, GeneratedVisitor)
17413 }
17414}
17415impl serde::Serialize for Watermark {
17416 #[allow(deprecated)]
17417 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17418 where
17419 S: serde::Serializer,
17420 {
17421 use serde::ser::SerializeStruct;
17422 let mut len = 0;
17423 if self.column.is_some() {
17424 len += 1;
17425 }
17426 if self.val.is_some() {
17427 len += 1;
17428 }
17429 let mut struct_ser = serializer.serialize_struct("stream_plan.Watermark", len)?;
17430 if let Some(v) = self.column.as_ref() {
17431 struct_ser.serialize_field("column", v)?;
17432 }
17433 if let Some(v) = self.val.as_ref() {
17434 struct_ser.serialize_field("val", v)?;
17435 }
17436 struct_ser.end()
17437 }
17438}
17439impl<'de> serde::Deserialize<'de> for Watermark {
17440 #[allow(deprecated)]
17441 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17442 where
17443 D: serde::Deserializer<'de>,
17444 {
17445 const FIELDS: &[&str] = &[
17446 "column",
17447 "val",
17448 ];
17449
17450 #[allow(clippy::enum_variant_names)]
17451 enum GeneratedField {
17452 Column,
17453 Val,
17454 }
17455 impl<'de> serde::Deserialize<'de> for GeneratedField {
17456 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17457 where
17458 D: serde::Deserializer<'de>,
17459 {
17460 struct GeneratedVisitor;
17461
17462 impl serde::de::Visitor<'_> for GeneratedVisitor {
17463 type Value = GeneratedField;
17464
17465 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17466 write!(formatter, "expected one of: {:?}", &FIELDS)
17467 }
17468
17469 #[allow(unused_variables)]
17470 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17471 where
17472 E: serde::de::Error,
17473 {
17474 match value {
17475 "column" => Ok(GeneratedField::Column),
17476 "val" => Ok(GeneratedField::Val),
17477 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17478 }
17479 }
17480 }
17481 deserializer.deserialize_identifier(GeneratedVisitor)
17482 }
17483 }
17484 struct GeneratedVisitor;
17485 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17486 type Value = Watermark;
17487
17488 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17489 formatter.write_str("struct stream_plan.Watermark")
17490 }
17491
17492 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Watermark, V::Error>
17493 where
17494 V: serde::de::MapAccess<'de>,
17495 {
17496 let mut column__ = None;
17497 let mut val__ = None;
17498 while let Some(k) = map_.next_key()? {
17499 match k {
17500 GeneratedField::Column => {
17501 if column__.is_some() {
17502 return Err(serde::de::Error::duplicate_field("column"));
17503 }
17504 column__ = map_.next_value()?;
17505 }
17506 GeneratedField::Val => {
17507 if val__.is_some() {
17508 return Err(serde::de::Error::duplicate_field("val"));
17509 }
17510 val__ = map_.next_value()?;
17511 }
17512 }
17513 }
17514 Ok(Watermark {
17515 column: column__,
17516 val: val__,
17517 })
17518 }
17519 }
17520 deserializer.deserialize_struct("stream_plan.Watermark", FIELDS, GeneratedVisitor)
17521 }
17522}
17523impl serde::Serialize for WatermarkFilterNode {
17524 #[allow(deprecated)]
17525 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17526 where
17527 S: serde::Serializer,
17528 {
17529 use serde::ser::SerializeStruct;
17530 let mut len = 0;
17531 if !self.watermark_descs.is_empty() {
17532 len += 1;
17533 }
17534 if !self.tables.is_empty() {
17535 len += 1;
17536 }
17537 let mut struct_ser = serializer.serialize_struct("stream_plan.WatermarkFilterNode", len)?;
17538 if !self.watermark_descs.is_empty() {
17539 struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
17540 }
17541 if !self.tables.is_empty() {
17542 struct_ser.serialize_field("tables", &self.tables)?;
17543 }
17544 struct_ser.end()
17545 }
17546}
17547impl<'de> serde::Deserialize<'de> for WatermarkFilterNode {
17548 #[allow(deprecated)]
17549 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17550 where
17551 D: serde::Deserializer<'de>,
17552 {
17553 const FIELDS: &[&str] = &[
17554 "watermark_descs",
17555 "watermarkDescs",
17556 "tables",
17557 ];
17558
17559 #[allow(clippy::enum_variant_names)]
17560 enum GeneratedField {
17561 WatermarkDescs,
17562 Tables,
17563 }
17564 impl<'de> serde::Deserialize<'de> for GeneratedField {
17565 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17566 where
17567 D: serde::Deserializer<'de>,
17568 {
17569 struct GeneratedVisitor;
17570
17571 impl serde::de::Visitor<'_> for GeneratedVisitor {
17572 type Value = GeneratedField;
17573
17574 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17575 write!(formatter, "expected one of: {:?}", &FIELDS)
17576 }
17577
17578 #[allow(unused_variables)]
17579 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17580 where
17581 E: serde::de::Error,
17582 {
17583 match value {
17584 "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
17585 "tables" => Ok(GeneratedField::Tables),
17586 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17587 }
17588 }
17589 }
17590 deserializer.deserialize_identifier(GeneratedVisitor)
17591 }
17592 }
17593 struct GeneratedVisitor;
17594 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17595 type Value = WatermarkFilterNode;
17596
17597 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17598 formatter.write_str("struct stream_plan.WatermarkFilterNode")
17599 }
17600
17601 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkFilterNode, V::Error>
17602 where
17603 V: serde::de::MapAccess<'de>,
17604 {
17605 let mut watermark_descs__ = None;
17606 let mut tables__ = None;
17607 while let Some(k) = map_.next_key()? {
17608 match k {
17609 GeneratedField::WatermarkDescs => {
17610 if watermark_descs__.is_some() {
17611 return Err(serde::de::Error::duplicate_field("watermarkDescs"));
17612 }
17613 watermark_descs__ = Some(map_.next_value()?);
17614 }
17615 GeneratedField::Tables => {
17616 if tables__.is_some() {
17617 return Err(serde::de::Error::duplicate_field("tables"));
17618 }
17619 tables__ = Some(map_.next_value()?);
17620 }
17621 }
17622 }
17623 Ok(WatermarkFilterNode {
17624 watermark_descs: watermark_descs__.unwrap_or_default(),
17625 tables: tables__.unwrap_or_default(),
17626 })
17627 }
17628 }
17629 deserializer.deserialize_struct("stream_plan.WatermarkFilterNode", FIELDS, GeneratedVisitor)
17630 }
17631}