1#![allow(clippy::useless_conversion)]
2use crate::stream_plan::*;
3impl serde::Serialize for ActorMapping {
4 #[allow(deprecated)]
5 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6 where
7 S: serde::Serializer,
8 {
9 use serde::ser::SerializeStruct;
10 let mut len = 0;
11 if !self.original_indices.is_empty() {
12 len += 1;
13 }
14 if !self.data.is_empty() {
15 len += 1;
16 }
17 let mut struct_ser = serializer.serialize_struct("stream_plan.ActorMapping", len)?;
18 if !self.original_indices.is_empty() {
19 struct_ser.serialize_field("originalIndices", &self.original_indices)?;
20 }
21 if !self.data.is_empty() {
22 struct_ser.serialize_field("data", &self.data)?;
23 }
24 struct_ser.end()
25 }
26}
27impl<'de> serde::Deserialize<'de> for ActorMapping {
28 #[allow(deprecated)]
29 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
30 where
31 D: serde::Deserializer<'de>,
32 {
33 const FIELDS: &[&str] = &[
34 "original_indices",
35 "originalIndices",
36 "data",
37 ];
38
39 #[allow(clippy::enum_variant_names)]
40 enum GeneratedField {
41 OriginalIndices,
42 Data,
43 }
44 impl<'de> serde::Deserialize<'de> for GeneratedField {
45 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
46 where
47 D: serde::Deserializer<'de>,
48 {
49 struct GeneratedVisitor;
50
51 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
52 type Value = GeneratedField;
53
54 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
55 write!(formatter, "expected one of: {:?}", &FIELDS)
56 }
57
58 #[allow(unused_variables)]
59 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
60 where
61 E: serde::de::Error,
62 {
63 match value {
64 "originalIndices" | "original_indices" => Ok(GeneratedField::OriginalIndices),
65 "data" => Ok(GeneratedField::Data),
66 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
67 }
68 }
69 }
70 deserializer.deserialize_identifier(GeneratedVisitor)
71 }
72 }
73 struct GeneratedVisitor;
74 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
75 type Value = ActorMapping;
76
77 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
78 formatter.write_str("struct stream_plan.ActorMapping")
79 }
80
81 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorMapping, V::Error>
82 where
83 V: serde::de::MapAccess<'de>,
84 {
85 let mut original_indices__ = None;
86 let mut data__ = None;
87 while let Some(k) = map_.next_key()? {
88 match k {
89 GeneratedField::OriginalIndices => {
90 if original_indices__.is_some() {
91 return Err(serde::de::Error::duplicate_field("originalIndices"));
92 }
93 original_indices__ =
94 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
95 .into_iter().map(|x| x.0).collect())
96 ;
97 }
98 GeneratedField::Data => {
99 if data__.is_some() {
100 return Err(serde::de::Error::duplicate_field("data"));
101 }
102 data__ =
103 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
104 .into_iter().map(|x| x.0).collect())
105 ;
106 }
107 }
108 }
109 Ok(ActorMapping {
110 original_indices: original_indices__.unwrap_or_default(),
111 data: data__.unwrap_or_default(),
112 })
113 }
114 }
115 deserializer.deserialize_struct("stream_plan.ActorMapping", FIELDS, GeneratedVisitor)
116 }
117}
118impl serde::Serialize for AddMutation {
119 #[allow(deprecated)]
120 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
121 where
122 S: serde::Serializer,
123 {
124 use serde::ser::SerializeStruct;
125 let mut len = 0;
126 if !self.actor_dispatchers.is_empty() {
127 len += 1;
128 }
129 if !self.added_actors.is_empty() {
130 len += 1;
131 }
132 if !self.actor_splits.is_empty() {
133 len += 1;
134 }
135 if self.pause {
136 len += 1;
137 }
138 if !self.subscriptions_to_add.is_empty() {
139 len += 1;
140 }
141 if !self.backfill_nodes_to_pause.is_empty() {
142 len += 1;
143 }
144 if self.actor_cdc_table_snapshot_splits.is_some() {
145 len += 1;
146 }
147 if !self.new_upstream_sinks.is_empty() {
148 len += 1;
149 }
150 let mut struct_ser = serializer.serialize_struct("stream_plan.AddMutation", len)?;
151 if !self.actor_dispatchers.is_empty() {
152 struct_ser.serialize_field("actorDispatchers", &self.actor_dispatchers)?;
153 }
154 if !self.added_actors.is_empty() {
155 struct_ser.serialize_field("addedActors", &self.added_actors)?;
156 }
157 if !self.actor_splits.is_empty() {
158 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
159 }
160 if self.pause {
161 struct_ser.serialize_field("pause", &self.pause)?;
162 }
163 if !self.subscriptions_to_add.is_empty() {
164 struct_ser.serialize_field("subscriptionsToAdd", &self.subscriptions_to_add)?;
165 }
166 if !self.backfill_nodes_to_pause.is_empty() {
167 struct_ser.serialize_field("backfillNodesToPause", &self.backfill_nodes_to_pause)?;
168 }
169 if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
170 struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
171 }
172 if !self.new_upstream_sinks.is_empty() {
173 struct_ser.serialize_field("newUpstreamSinks", &self.new_upstream_sinks)?;
174 }
175 struct_ser.end()
176 }
177}
178impl<'de> serde::Deserialize<'de> for AddMutation {
179 #[allow(deprecated)]
180 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
181 where
182 D: serde::Deserializer<'de>,
183 {
184 const FIELDS: &[&str] = &[
185 "actor_dispatchers",
186 "actorDispatchers",
187 "added_actors",
188 "addedActors",
189 "actor_splits",
190 "actorSplits",
191 "pause",
192 "subscriptions_to_add",
193 "subscriptionsToAdd",
194 "backfill_nodes_to_pause",
195 "backfillNodesToPause",
196 "actor_cdc_table_snapshot_splits",
197 "actorCdcTableSnapshotSplits",
198 "new_upstream_sinks",
199 "newUpstreamSinks",
200 ];
201
202 #[allow(clippy::enum_variant_names)]
203 enum GeneratedField {
204 ActorDispatchers,
205 AddedActors,
206 ActorSplits,
207 Pause,
208 SubscriptionsToAdd,
209 BackfillNodesToPause,
210 ActorCdcTableSnapshotSplits,
211 NewUpstreamSinks,
212 }
213 impl<'de> serde::Deserialize<'de> for GeneratedField {
214 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
215 where
216 D: serde::Deserializer<'de>,
217 {
218 struct GeneratedVisitor;
219
220 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
221 type Value = GeneratedField;
222
223 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
224 write!(formatter, "expected one of: {:?}", &FIELDS)
225 }
226
227 #[allow(unused_variables)]
228 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
229 where
230 E: serde::de::Error,
231 {
232 match value {
233 "actorDispatchers" | "actor_dispatchers" => Ok(GeneratedField::ActorDispatchers),
234 "addedActors" | "added_actors" => Ok(GeneratedField::AddedActors),
235 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
236 "pause" => Ok(GeneratedField::Pause),
237 "subscriptionsToAdd" | "subscriptions_to_add" => Ok(GeneratedField::SubscriptionsToAdd),
238 "backfillNodesToPause" | "backfill_nodes_to_pause" => Ok(GeneratedField::BackfillNodesToPause),
239 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
240 "newUpstreamSinks" | "new_upstream_sinks" => Ok(GeneratedField::NewUpstreamSinks),
241 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
242 }
243 }
244 }
245 deserializer.deserialize_identifier(GeneratedVisitor)
246 }
247 }
248 struct GeneratedVisitor;
249 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
250 type Value = AddMutation;
251
252 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
253 formatter.write_str("struct stream_plan.AddMutation")
254 }
255
256 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddMutation, V::Error>
257 where
258 V: serde::de::MapAccess<'de>,
259 {
260 let mut actor_dispatchers__ = None;
261 let mut added_actors__ = None;
262 let mut actor_splits__ = None;
263 let mut pause__ = None;
264 let mut subscriptions_to_add__ = None;
265 let mut backfill_nodes_to_pause__ = None;
266 let mut actor_cdc_table_snapshot_splits__ = None;
267 let mut new_upstream_sinks__ = None;
268 while let Some(k) = map_.next_key()? {
269 match k {
270 GeneratedField::ActorDispatchers => {
271 if actor_dispatchers__.is_some() {
272 return Err(serde::de::Error::duplicate_field("actorDispatchers"));
273 }
274 actor_dispatchers__ = Some(
275 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
276 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
277 );
278 }
279 GeneratedField::AddedActors => {
280 if added_actors__.is_some() {
281 return Err(serde::de::Error::duplicate_field("addedActors"));
282 }
283 added_actors__ =
284 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
285 .into_iter().map(|x| x.0).collect())
286 ;
287 }
288 GeneratedField::ActorSplits => {
289 if actor_splits__.is_some() {
290 return Err(serde::de::Error::duplicate_field("actorSplits"));
291 }
292 actor_splits__ = Some(
293 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
294 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
295 );
296 }
297 GeneratedField::Pause => {
298 if pause__.is_some() {
299 return Err(serde::de::Error::duplicate_field("pause"));
300 }
301 pause__ = Some(map_.next_value()?);
302 }
303 GeneratedField::SubscriptionsToAdd => {
304 if subscriptions_to_add__.is_some() {
305 return Err(serde::de::Error::duplicate_field("subscriptionsToAdd"));
306 }
307 subscriptions_to_add__ = Some(map_.next_value()?);
308 }
309 GeneratedField::BackfillNodesToPause => {
310 if backfill_nodes_to_pause__.is_some() {
311 return Err(serde::de::Error::duplicate_field("backfillNodesToPause"));
312 }
313 backfill_nodes_to_pause__ =
314 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
315 .into_iter().map(|x| x.0).collect())
316 ;
317 }
318 GeneratedField::ActorCdcTableSnapshotSplits => {
319 if actor_cdc_table_snapshot_splits__.is_some() {
320 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
321 }
322 actor_cdc_table_snapshot_splits__ = map_.next_value()?;
323 }
324 GeneratedField::NewUpstreamSinks => {
325 if new_upstream_sinks__.is_some() {
326 return Err(serde::de::Error::duplicate_field("newUpstreamSinks"));
327 }
328 new_upstream_sinks__ = Some(
329 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
330 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
331 );
332 }
333 }
334 }
335 Ok(AddMutation {
336 actor_dispatchers: actor_dispatchers__.unwrap_or_default(),
337 added_actors: added_actors__.unwrap_or_default(),
338 actor_splits: actor_splits__.unwrap_or_default(),
339 pause: pause__.unwrap_or_default(),
340 subscriptions_to_add: subscriptions_to_add__.unwrap_or_default(),
341 backfill_nodes_to_pause: backfill_nodes_to_pause__.unwrap_or_default(),
342 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
343 new_upstream_sinks: new_upstream_sinks__.unwrap_or_default(),
344 })
345 }
346 }
347 deserializer.deserialize_struct("stream_plan.AddMutation", FIELDS, GeneratedVisitor)
348 }
349}
350impl serde::Serialize for add_mutation::NewUpstreamSink {
351 #[allow(deprecated)]
352 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
353 where
354 S: serde::Serializer,
355 {
356 use serde::ser::SerializeStruct;
357 let mut len = 0;
358 if self.info.is_some() {
359 len += 1;
360 }
361 if !self.upstream_actors.is_empty() {
362 len += 1;
363 }
364 let mut struct_ser = serializer.serialize_struct("stream_plan.AddMutation.NewUpstreamSink", len)?;
365 if let Some(v) = self.info.as_ref() {
366 struct_ser.serialize_field("info", v)?;
367 }
368 if !self.upstream_actors.is_empty() {
369 struct_ser.serialize_field("upstreamActors", &self.upstream_actors)?;
370 }
371 struct_ser.end()
372 }
373}
374impl<'de> serde::Deserialize<'de> for add_mutation::NewUpstreamSink {
375 #[allow(deprecated)]
376 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
377 where
378 D: serde::Deserializer<'de>,
379 {
380 const FIELDS: &[&str] = &[
381 "info",
382 "upstream_actors",
383 "upstreamActors",
384 ];
385
386 #[allow(clippy::enum_variant_names)]
387 enum GeneratedField {
388 Info,
389 UpstreamActors,
390 }
391 impl<'de> serde::Deserialize<'de> for GeneratedField {
392 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
393 where
394 D: serde::Deserializer<'de>,
395 {
396 struct GeneratedVisitor;
397
398 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
399 type Value = GeneratedField;
400
401 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
402 write!(formatter, "expected one of: {:?}", &FIELDS)
403 }
404
405 #[allow(unused_variables)]
406 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
407 where
408 E: serde::de::Error,
409 {
410 match value {
411 "info" => Ok(GeneratedField::Info),
412 "upstreamActors" | "upstream_actors" => Ok(GeneratedField::UpstreamActors),
413 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
414 }
415 }
416 }
417 deserializer.deserialize_identifier(GeneratedVisitor)
418 }
419 }
420 struct GeneratedVisitor;
421 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
422 type Value = add_mutation::NewUpstreamSink;
423
424 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
425 formatter.write_str("struct stream_plan.AddMutation.NewUpstreamSink")
426 }
427
428 fn visit_map<V>(self, mut map_: V) -> std::result::Result<add_mutation::NewUpstreamSink, V::Error>
429 where
430 V: serde::de::MapAccess<'de>,
431 {
432 let mut info__ = None;
433 let mut upstream_actors__ = None;
434 while let Some(k) = map_.next_key()? {
435 match k {
436 GeneratedField::Info => {
437 if info__.is_some() {
438 return Err(serde::de::Error::duplicate_field("info"));
439 }
440 info__ = map_.next_value()?;
441 }
442 GeneratedField::UpstreamActors => {
443 if upstream_actors__.is_some() {
444 return Err(serde::de::Error::duplicate_field("upstreamActors"));
445 }
446 upstream_actors__ = Some(map_.next_value()?);
447 }
448 }
449 }
450 Ok(add_mutation::NewUpstreamSink {
451 info: info__,
452 upstream_actors: upstream_actors__.unwrap_or_default(),
453 })
454 }
455 }
456 deserializer.deserialize_struct("stream_plan.AddMutation.NewUpstreamSink", FIELDS, GeneratedVisitor)
457 }
458}
459impl serde::Serialize for AggCallState {
460 #[allow(deprecated)]
461 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
462 where
463 S: serde::Serializer,
464 {
465 use serde::ser::SerializeStruct;
466 let mut len = 0;
467 if self.inner.is_some() {
468 len += 1;
469 }
470 let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState", len)?;
471 if let Some(v) = self.inner.as_ref() {
472 match v {
473 agg_call_state::Inner::ValueState(v) => {
474 struct_ser.serialize_field("valueState", v)?;
475 }
476 agg_call_state::Inner::MaterializedInputState(v) => {
477 struct_ser.serialize_field("materializedInputState", v)?;
478 }
479 }
480 }
481 struct_ser.end()
482 }
483}
484impl<'de> serde::Deserialize<'de> for AggCallState {
485 #[allow(deprecated)]
486 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
487 where
488 D: serde::Deserializer<'de>,
489 {
490 const FIELDS: &[&str] = &[
491 "value_state",
492 "valueState",
493 "materialized_input_state",
494 "materializedInputState",
495 ];
496
497 #[allow(clippy::enum_variant_names)]
498 enum GeneratedField {
499 ValueState,
500 MaterializedInputState,
501 }
502 impl<'de> serde::Deserialize<'de> for GeneratedField {
503 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
504 where
505 D: serde::Deserializer<'de>,
506 {
507 struct GeneratedVisitor;
508
509 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
510 type Value = GeneratedField;
511
512 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
513 write!(formatter, "expected one of: {:?}", &FIELDS)
514 }
515
516 #[allow(unused_variables)]
517 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
518 where
519 E: serde::de::Error,
520 {
521 match value {
522 "valueState" | "value_state" => Ok(GeneratedField::ValueState),
523 "materializedInputState" | "materialized_input_state" => Ok(GeneratedField::MaterializedInputState),
524 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
525 }
526 }
527 }
528 deserializer.deserialize_identifier(GeneratedVisitor)
529 }
530 }
531 struct GeneratedVisitor;
532 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
533 type Value = AggCallState;
534
535 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
536 formatter.write_str("struct stream_plan.AggCallState")
537 }
538
539 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AggCallState, V::Error>
540 where
541 V: serde::de::MapAccess<'de>,
542 {
543 let mut inner__ = None;
544 while let Some(k) = map_.next_key()? {
545 match k {
546 GeneratedField::ValueState => {
547 if inner__.is_some() {
548 return Err(serde::de::Error::duplicate_field("valueState"));
549 }
550 inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::ValueState)
551;
552 }
553 GeneratedField::MaterializedInputState => {
554 if inner__.is_some() {
555 return Err(serde::de::Error::duplicate_field("materializedInputState"));
556 }
557 inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::MaterializedInputState)
558;
559 }
560 }
561 }
562 Ok(AggCallState {
563 inner: inner__,
564 })
565 }
566 }
567 deserializer.deserialize_struct("stream_plan.AggCallState", FIELDS, GeneratedVisitor)
568 }
569}
570impl serde::Serialize for agg_call_state::MaterializedInputState {
571 #[allow(deprecated)]
572 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
573 where
574 S: serde::Serializer,
575 {
576 use serde::ser::SerializeStruct;
577 let mut len = 0;
578 if self.table.is_some() {
579 len += 1;
580 }
581 if !self.included_upstream_indices.is_empty() {
582 len += 1;
583 }
584 if !self.table_value_indices.is_empty() {
585 len += 1;
586 }
587 if !self.order_columns.is_empty() {
588 len += 1;
589 }
590 let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState.MaterializedInputState", len)?;
591 if let Some(v) = self.table.as_ref() {
592 struct_ser.serialize_field("table", v)?;
593 }
594 if !self.included_upstream_indices.is_empty() {
595 struct_ser.serialize_field("includedUpstreamIndices", &self.included_upstream_indices)?;
596 }
597 if !self.table_value_indices.is_empty() {
598 struct_ser.serialize_field("tableValueIndices", &self.table_value_indices)?;
599 }
600 if !self.order_columns.is_empty() {
601 struct_ser.serialize_field("orderColumns", &self.order_columns)?;
602 }
603 struct_ser.end()
604 }
605}
606impl<'de> serde::Deserialize<'de> for agg_call_state::MaterializedInputState {
607 #[allow(deprecated)]
608 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
609 where
610 D: serde::Deserializer<'de>,
611 {
612 const FIELDS: &[&str] = &[
613 "table",
614 "included_upstream_indices",
615 "includedUpstreamIndices",
616 "table_value_indices",
617 "tableValueIndices",
618 "order_columns",
619 "orderColumns",
620 ];
621
622 #[allow(clippy::enum_variant_names)]
623 enum GeneratedField {
624 Table,
625 IncludedUpstreamIndices,
626 TableValueIndices,
627 OrderColumns,
628 }
629 impl<'de> serde::Deserialize<'de> for GeneratedField {
630 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
631 where
632 D: serde::Deserializer<'de>,
633 {
634 struct GeneratedVisitor;
635
636 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
637 type Value = GeneratedField;
638
639 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
640 write!(formatter, "expected one of: {:?}", &FIELDS)
641 }
642
643 #[allow(unused_variables)]
644 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
645 where
646 E: serde::de::Error,
647 {
648 match value {
649 "table" => Ok(GeneratedField::Table),
650 "includedUpstreamIndices" | "included_upstream_indices" => Ok(GeneratedField::IncludedUpstreamIndices),
651 "tableValueIndices" | "table_value_indices" => Ok(GeneratedField::TableValueIndices),
652 "orderColumns" | "order_columns" => Ok(GeneratedField::OrderColumns),
653 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
654 }
655 }
656 }
657 deserializer.deserialize_identifier(GeneratedVisitor)
658 }
659 }
660 struct GeneratedVisitor;
661 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
662 type Value = agg_call_state::MaterializedInputState;
663
664 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
665 formatter.write_str("struct stream_plan.AggCallState.MaterializedInputState")
666 }
667
668 fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::MaterializedInputState, V::Error>
669 where
670 V: serde::de::MapAccess<'de>,
671 {
672 let mut table__ = None;
673 let mut included_upstream_indices__ = None;
674 let mut table_value_indices__ = None;
675 let mut order_columns__ = None;
676 while let Some(k) = map_.next_key()? {
677 match k {
678 GeneratedField::Table => {
679 if table__.is_some() {
680 return Err(serde::de::Error::duplicate_field("table"));
681 }
682 table__ = map_.next_value()?;
683 }
684 GeneratedField::IncludedUpstreamIndices => {
685 if included_upstream_indices__.is_some() {
686 return Err(serde::de::Error::duplicate_field("includedUpstreamIndices"));
687 }
688 included_upstream_indices__ =
689 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
690 .into_iter().map(|x| x.0).collect())
691 ;
692 }
693 GeneratedField::TableValueIndices => {
694 if table_value_indices__.is_some() {
695 return Err(serde::de::Error::duplicate_field("tableValueIndices"));
696 }
697 table_value_indices__ =
698 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
699 .into_iter().map(|x| x.0).collect())
700 ;
701 }
702 GeneratedField::OrderColumns => {
703 if order_columns__.is_some() {
704 return Err(serde::de::Error::duplicate_field("orderColumns"));
705 }
706 order_columns__ = Some(map_.next_value()?);
707 }
708 }
709 }
710 Ok(agg_call_state::MaterializedInputState {
711 table: table__,
712 included_upstream_indices: included_upstream_indices__.unwrap_or_default(),
713 table_value_indices: table_value_indices__.unwrap_or_default(),
714 order_columns: order_columns__.unwrap_or_default(),
715 })
716 }
717 }
718 deserializer.deserialize_struct("stream_plan.AggCallState.MaterializedInputState", FIELDS, GeneratedVisitor)
719 }
720}
721impl serde::Serialize for agg_call_state::ValueState {
722 #[allow(deprecated)]
723 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
724 where
725 S: serde::Serializer,
726 {
727 use serde::ser::SerializeStruct;
728 let len = 0;
729 let struct_ser = serializer.serialize_struct("stream_plan.AggCallState.ValueState", len)?;
730 struct_ser.end()
731 }
732}
733impl<'de> serde::Deserialize<'de> for agg_call_state::ValueState {
734 #[allow(deprecated)]
735 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
736 where
737 D: serde::Deserializer<'de>,
738 {
739 const FIELDS: &[&str] = &[
740 ];
741
742 #[allow(clippy::enum_variant_names)]
743 enum GeneratedField {
744 }
745 impl<'de> serde::Deserialize<'de> for GeneratedField {
746 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
747 where
748 D: serde::Deserializer<'de>,
749 {
750 struct GeneratedVisitor;
751
752 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
753 type Value = GeneratedField;
754
755 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
756 write!(formatter, "expected one of: {:?}", &FIELDS)
757 }
758
759 #[allow(unused_variables)]
760 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
761 where
762 E: serde::de::Error,
763 {
764 Err(serde::de::Error::unknown_field(value, FIELDS))
765 }
766 }
767 deserializer.deserialize_identifier(GeneratedVisitor)
768 }
769 }
770 struct GeneratedVisitor;
771 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
772 type Value = agg_call_state::ValueState;
773
774 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
775 formatter.write_str("struct stream_plan.AggCallState.ValueState")
776 }
777
778 fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::ValueState, V::Error>
779 where
780 V: serde::de::MapAccess<'de>,
781 {
782 while map_.next_key::<GeneratedField>()?.is_some() {
783 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
784 }
785 Ok(agg_call_state::ValueState {
786 })
787 }
788 }
789 deserializer.deserialize_struct("stream_plan.AggCallState.ValueState", FIELDS, GeneratedVisitor)
790 }
791}
792impl serde::Serialize for AggNodeVersion {
793 #[allow(deprecated)]
794 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
795 where
796 S: serde::Serializer,
797 {
798 let variant = match self {
799 Self::Unspecified => "AGG_NODE_VERSION_UNSPECIFIED",
800 Self::Issue12140 => "AGG_NODE_VERSION_ISSUE_12140",
801 Self::Issue13465 => "AGG_NODE_VERSION_ISSUE_13465",
802 };
803 serializer.serialize_str(variant)
804 }
805}
806impl<'de> serde::Deserialize<'de> for AggNodeVersion {
807 #[allow(deprecated)]
808 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
809 where
810 D: serde::Deserializer<'de>,
811 {
812 const FIELDS: &[&str] = &[
813 "AGG_NODE_VERSION_UNSPECIFIED",
814 "AGG_NODE_VERSION_ISSUE_12140",
815 "AGG_NODE_VERSION_ISSUE_13465",
816 ];
817
818 struct GeneratedVisitor;
819
820 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
821 type Value = AggNodeVersion;
822
823 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
824 write!(formatter, "expected one of: {:?}", &FIELDS)
825 }
826
827 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
828 where
829 E: serde::de::Error,
830 {
831 i32::try_from(v)
832 .ok()
833 .and_then(|x| x.try_into().ok())
834 .ok_or_else(|| {
835 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
836 })
837 }
838
839 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
840 where
841 E: serde::de::Error,
842 {
843 i32::try_from(v)
844 .ok()
845 .and_then(|x| x.try_into().ok())
846 .ok_or_else(|| {
847 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
848 })
849 }
850
851 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
852 where
853 E: serde::de::Error,
854 {
855 match value {
856 "AGG_NODE_VERSION_UNSPECIFIED" => Ok(AggNodeVersion::Unspecified),
857 "AGG_NODE_VERSION_ISSUE_12140" => Ok(AggNodeVersion::Issue12140),
858 "AGG_NODE_VERSION_ISSUE_13465" => Ok(AggNodeVersion::Issue13465),
859 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
860 }
861 }
862 }
863 deserializer.deserialize_any(GeneratedVisitor)
864 }
865}
866impl serde::Serialize for ArrangeNode {
867 #[allow(deprecated)]
868 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
869 where
870 S: serde::Serializer,
871 {
872 use serde::ser::SerializeStruct;
873 let mut len = 0;
874 if self.table_info.is_some() {
875 len += 1;
876 }
877 if !self.distribution_key.is_empty() {
878 len += 1;
879 }
880 if self.table.is_some() {
881 len += 1;
882 }
883 let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangeNode", len)?;
884 if let Some(v) = self.table_info.as_ref() {
885 struct_ser.serialize_field("tableInfo", v)?;
886 }
887 if !self.distribution_key.is_empty() {
888 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
889 }
890 if let Some(v) = self.table.as_ref() {
891 struct_ser.serialize_field("table", v)?;
892 }
893 struct_ser.end()
894 }
895}
896impl<'de> serde::Deserialize<'de> for ArrangeNode {
897 #[allow(deprecated)]
898 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
899 where
900 D: serde::Deserializer<'de>,
901 {
902 const FIELDS: &[&str] = &[
903 "table_info",
904 "tableInfo",
905 "distribution_key",
906 "distributionKey",
907 "table",
908 ];
909
910 #[allow(clippy::enum_variant_names)]
911 enum GeneratedField {
912 TableInfo,
913 DistributionKey,
914 Table,
915 }
916 impl<'de> serde::Deserialize<'de> for GeneratedField {
917 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
918 where
919 D: serde::Deserializer<'de>,
920 {
921 struct GeneratedVisitor;
922
923 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
924 type Value = GeneratedField;
925
926 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
927 write!(formatter, "expected one of: {:?}", &FIELDS)
928 }
929
930 #[allow(unused_variables)]
931 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
932 where
933 E: serde::de::Error,
934 {
935 match value {
936 "tableInfo" | "table_info" => Ok(GeneratedField::TableInfo),
937 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
938 "table" => Ok(GeneratedField::Table),
939 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
940 }
941 }
942 }
943 deserializer.deserialize_identifier(GeneratedVisitor)
944 }
945 }
946 struct GeneratedVisitor;
947 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
948 type Value = ArrangeNode;
949
950 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
951 formatter.write_str("struct stream_plan.ArrangeNode")
952 }
953
954 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangeNode, V::Error>
955 where
956 V: serde::de::MapAccess<'de>,
957 {
958 let mut table_info__ = None;
959 let mut distribution_key__ = None;
960 let mut table__ = None;
961 while let Some(k) = map_.next_key()? {
962 match k {
963 GeneratedField::TableInfo => {
964 if table_info__.is_some() {
965 return Err(serde::de::Error::duplicate_field("tableInfo"));
966 }
967 table_info__ = map_.next_value()?;
968 }
969 GeneratedField::DistributionKey => {
970 if distribution_key__.is_some() {
971 return Err(serde::de::Error::duplicate_field("distributionKey"));
972 }
973 distribution_key__ =
974 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
975 .into_iter().map(|x| x.0).collect())
976 ;
977 }
978 GeneratedField::Table => {
979 if table__.is_some() {
980 return Err(serde::de::Error::duplicate_field("table"));
981 }
982 table__ = map_.next_value()?;
983 }
984 }
985 }
986 Ok(ArrangeNode {
987 table_info: table_info__,
988 distribution_key: distribution_key__.unwrap_or_default(),
989 table: table__,
990 })
991 }
992 }
993 deserializer.deserialize_struct("stream_plan.ArrangeNode", FIELDS, GeneratedVisitor)
994 }
995}
996impl serde::Serialize for ArrangementInfo {
997 #[allow(deprecated)]
998 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
999 where
1000 S: serde::Serializer,
1001 {
1002 use serde::ser::SerializeStruct;
1003 let mut len = 0;
1004 if !self.arrange_key_orders.is_empty() {
1005 len += 1;
1006 }
1007 if !self.column_descs.is_empty() {
1008 len += 1;
1009 }
1010 if self.table_desc.is_some() {
1011 len += 1;
1012 }
1013 if !self.output_col_idx.is_empty() {
1014 len += 1;
1015 }
1016 let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangementInfo", len)?;
1017 if !self.arrange_key_orders.is_empty() {
1018 struct_ser.serialize_field("arrangeKeyOrders", &self.arrange_key_orders)?;
1019 }
1020 if !self.column_descs.is_empty() {
1021 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
1022 }
1023 if let Some(v) = self.table_desc.as_ref() {
1024 struct_ser.serialize_field("tableDesc", v)?;
1025 }
1026 if !self.output_col_idx.is_empty() {
1027 struct_ser.serialize_field("outputColIdx", &self.output_col_idx)?;
1028 }
1029 struct_ser.end()
1030 }
1031}
1032impl<'de> serde::Deserialize<'de> for ArrangementInfo {
1033 #[allow(deprecated)]
1034 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1035 where
1036 D: serde::Deserializer<'de>,
1037 {
1038 const FIELDS: &[&str] = &[
1039 "arrange_key_orders",
1040 "arrangeKeyOrders",
1041 "column_descs",
1042 "columnDescs",
1043 "table_desc",
1044 "tableDesc",
1045 "output_col_idx",
1046 "outputColIdx",
1047 ];
1048
1049 #[allow(clippy::enum_variant_names)]
1050 enum GeneratedField {
1051 ArrangeKeyOrders,
1052 ColumnDescs,
1053 TableDesc,
1054 OutputColIdx,
1055 }
1056 impl<'de> serde::Deserialize<'de> for GeneratedField {
1057 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1058 where
1059 D: serde::Deserializer<'de>,
1060 {
1061 struct GeneratedVisitor;
1062
1063 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1064 type Value = GeneratedField;
1065
1066 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1067 write!(formatter, "expected one of: {:?}", &FIELDS)
1068 }
1069
1070 #[allow(unused_variables)]
1071 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1072 where
1073 E: serde::de::Error,
1074 {
1075 match value {
1076 "arrangeKeyOrders" | "arrange_key_orders" => Ok(GeneratedField::ArrangeKeyOrders),
1077 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
1078 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
1079 "outputColIdx" | "output_col_idx" => Ok(GeneratedField::OutputColIdx),
1080 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1081 }
1082 }
1083 }
1084 deserializer.deserialize_identifier(GeneratedVisitor)
1085 }
1086 }
1087 struct GeneratedVisitor;
1088 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1089 type Value = ArrangementInfo;
1090
1091 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1092 formatter.write_str("struct stream_plan.ArrangementInfo")
1093 }
1094
1095 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangementInfo, V::Error>
1096 where
1097 V: serde::de::MapAccess<'de>,
1098 {
1099 let mut arrange_key_orders__ = None;
1100 let mut column_descs__ = None;
1101 let mut table_desc__ = None;
1102 let mut output_col_idx__ = None;
1103 while let Some(k) = map_.next_key()? {
1104 match k {
1105 GeneratedField::ArrangeKeyOrders => {
1106 if arrange_key_orders__.is_some() {
1107 return Err(serde::de::Error::duplicate_field("arrangeKeyOrders"));
1108 }
1109 arrange_key_orders__ = Some(map_.next_value()?);
1110 }
1111 GeneratedField::ColumnDescs => {
1112 if column_descs__.is_some() {
1113 return Err(serde::de::Error::duplicate_field("columnDescs"));
1114 }
1115 column_descs__ = Some(map_.next_value()?);
1116 }
1117 GeneratedField::TableDesc => {
1118 if table_desc__.is_some() {
1119 return Err(serde::de::Error::duplicate_field("tableDesc"));
1120 }
1121 table_desc__ = map_.next_value()?;
1122 }
1123 GeneratedField::OutputColIdx => {
1124 if output_col_idx__.is_some() {
1125 return Err(serde::de::Error::duplicate_field("outputColIdx"));
1126 }
1127 output_col_idx__ =
1128 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1129 .into_iter().map(|x| x.0).collect())
1130 ;
1131 }
1132 }
1133 }
1134 Ok(ArrangementInfo {
1135 arrange_key_orders: arrange_key_orders__.unwrap_or_default(),
1136 column_descs: column_descs__.unwrap_or_default(),
1137 table_desc: table_desc__,
1138 output_col_idx: output_col_idx__.unwrap_or_default(),
1139 })
1140 }
1141 }
1142 deserializer.deserialize_struct("stream_plan.ArrangementInfo", FIELDS, GeneratedVisitor)
1143 }
1144}
1145impl serde::Serialize for AsOfJoinNode {
1146 #[allow(deprecated)]
1147 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1148 where
1149 S: serde::Serializer,
1150 {
1151 use serde::ser::SerializeStruct;
1152 let mut len = 0;
1153 if self.join_type != 0 {
1154 len += 1;
1155 }
1156 if !self.left_key.is_empty() {
1157 len += 1;
1158 }
1159 if !self.right_key.is_empty() {
1160 len += 1;
1161 }
1162 if self.left_table.is_some() {
1163 len += 1;
1164 }
1165 if self.right_table.is_some() {
1166 len += 1;
1167 }
1168 if !self.output_indices.is_empty() {
1169 len += 1;
1170 }
1171 if !self.left_deduped_input_pk_indices.is_empty() {
1172 len += 1;
1173 }
1174 if !self.right_deduped_input_pk_indices.is_empty() {
1175 len += 1;
1176 }
1177 if !self.null_safe.is_empty() {
1178 len += 1;
1179 }
1180 if self.asof_desc.is_some() {
1181 len += 1;
1182 }
1183 if self.join_encoding_type != 0 {
1184 len += 1;
1185 }
1186 let mut struct_ser = serializer.serialize_struct("stream_plan.AsOfJoinNode", len)?;
1187 if self.join_type != 0 {
1188 let v = super::plan_common::AsOfJoinType::try_from(self.join_type)
1189 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
1190 struct_ser.serialize_field("joinType", &v)?;
1191 }
1192 if !self.left_key.is_empty() {
1193 struct_ser.serialize_field("leftKey", &self.left_key)?;
1194 }
1195 if !self.right_key.is_empty() {
1196 struct_ser.serialize_field("rightKey", &self.right_key)?;
1197 }
1198 if let Some(v) = self.left_table.as_ref() {
1199 struct_ser.serialize_field("leftTable", v)?;
1200 }
1201 if let Some(v) = self.right_table.as_ref() {
1202 struct_ser.serialize_field("rightTable", v)?;
1203 }
1204 if !self.output_indices.is_empty() {
1205 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
1206 }
1207 if !self.left_deduped_input_pk_indices.is_empty() {
1208 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
1209 }
1210 if !self.right_deduped_input_pk_indices.is_empty() {
1211 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
1212 }
1213 if !self.null_safe.is_empty() {
1214 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
1215 }
1216 if let Some(v) = self.asof_desc.as_ref() {
1217 struct_ser.serialize_field("asofDesc", v)?;
1218 }
1219 if self.join_encoding_type != 0 {
1220 let v = JoinEncodingType::try_from(self.join_encoding_type)
1221 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
1222 struct_ser.serialize_field("joinEncodingType", &v)?;
1223 }
1224 struct_ser.end()
1225 }
1226}
1227impl<'de> serde::Deserialize<'de> for AsOfJoinNode {
1228 #[allow(deprecated)]
1229 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1230 where
1231 D: serde::Deserializer<'de>,
1232 {
1233 const FIELDS: &[&str] = &[
1234 "join_type",
1235 "joinType",
1236 "left_key",
1237 "leftKey",
1238 "right_key",
1239 "rightKey",
1240 "left_table",
1241 "leftTable",
1242 "right_table",
1243 "rightTable",
1244 "output_indices",
1245 "outputIndices",
1246 "left_deduped_input_pk_indices",
1247 "leftDedupedInputPkIndices",
1248 "right_deduped_input_pk_indices",
1249 "rightDedupedInputPkIndices",
1250 "null_safe",
1251 "nullSafe",
1252 "asof_desc",
1253 "asofDesc",
1254 "join_encoding_type",
1255 "joinEncodingType",
1256 ];
1257
1258 #[allow(clippy::enum_variant_names)]
1259 enum GeneratedField {
1260 JoinType,
1261 LeftKey,
1262 RightKey,
1263 LeftTable,
1264 RightTable,
1265 OutputIndices,
1266 LeftDedupedInputPkIndices,
1267 RightDedupedInputPkIndices,
1268 NullSafe,
1269 AsofDesc,
1270 JoinEncodingType,
1271 }
1272 impl<'de> serde::Deserialize<'de> for GeneratedField {
1273 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1274 where
1275 D: serde::Deserializer<'de>,
1276 {
1277 struct GeneratedVisitor;
1278
1279 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1280 type Value = GeneratedField;
1281
1282 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1283 write!(formatter, "expected one of: {:?}", &FIELDS)
1284 }
1285
1286 #[allow(unused_variables)]
1287 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1288 where
1289 E: serde::de::Error,
1290 {
1291 match value {
1292 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
1293 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
1294 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
1295 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
1296 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
1297 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
1298 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
1299 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
1300 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
1301 "asofDesc" | "asof_desc" => Ok(GeneratedField::AsofDesc),
1302 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
1303 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1304 }
1305 }
1306 }
1307 deserializer.deserialize_identifier(GeneratedVisitor)
1308 }
1309 }
1310 struct GeneratedVisitor;
1311 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1312 type Value = AsOfJoinNode;
1313
1314 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1315 formatter.write_str("struct stream_plan.AsOfJoinNode")
1316 }
1317
1318 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AsOfJoinNode, V::Error>
1319 where
1320 V: serde::de::MapAccess<'de>,
1321 {
1322 let mut join_type__ = None;
1323 let mut left_key__ = None;
1324 let mut right_key__ = None;
1325 let mut left_table__ = None;
1326 let mut right_table__ = None;
1327 let mut output_indices__ = None;
1328 let mut left_deduped_input_pk_indices__ = None;
1329 let mut right_deduped_input_pk_indices__ = None;
1330 let mut null_safe__ = None;
1331 let mut asof_desc__ = None;
1332 let mut join_encoding_type__ = None;
1333 while let Some(k) = map_.next_key()? {
1334 match k {
1335 GeneratedField::JoinType => {
1336 if join_type__.is_some() {
1337 return Err(serde::de::Error::duplicate_field("joinType"));
1338 }
1339 join_type__ = Some(map_.next_value::<super::plan_common::AsOfJoinType>()? as i32);
1340 }
1341 GeneratedField::LeftKey => {
1342 if left_key__.is_some() {
1343 return Err(serde::de::Error::duplicate_field("leftKey"));
1344 }
1345 left_key__ =
1346 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1347 .into_iter().map(|x| x.0).collect())
1348 ;
1349 }
1350 GeneratedField::RightKey => {
1351 if right_key__.is_some() {
1352 return Err(serde::de::Error::duplicate_field("rightKey"));
1353 }
1354 right_key__ =
1355 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1356 .into_iter().map(|x| x.0).collect())
1357 ;
1358 }
1359 GeneratedField::LeftTable => {
1360 if left_table__.is_some() {
1361 return Err(serde::de::Error::duplicate_field("leftTable"));
1362 }
1363 left_table__ = map_.next_value()?;
1364 }
1365 GeneratedField::RightTable => {
1366 if right_table__.is_some() {
1367 return Err(serde::de::Error::duplicate_field("rightTable"));
1368 }
1369 right_table__ = map_.next_value()?;
1370 }
1371 GeneratedField::OutputIndices => {
1372 if output_indices__.is_some() {
1373 return Err(serde::de::Error::duplicate_field("outputIndices"));
1374 }
1375 output_indices__ =
1376 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1377 .into_iter().map(|x| x.0).collect())
1378 ;
1379 }
1380 GeneratedField::LeftDedupedInputPkIndices => {
1381 if left_deduped_input_pk_indices__.is_some() {
1382 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
1383 }
1384 left_deduped_input_pk_indices__ =
1385 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1386 .into_iter().map(|x| x.0).collect())
1387 ;
1388 }
1389 GeneratedField::RightDedupedInputPkIndices => {
1390 if right_deduped_input_pk_indices__.is_some() {
1391 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
1392 }
1393 right_deduped_input_pk_indices__ =
1394 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1395 .into_iter().map(|x| x.0).collect())
1396 ;
1397 }
1398 GeneratedField::NullSafe => {
1399 if null_safe__.is_some() {
1400 return Err(serde::de::Error::duplicate_field("nullSafe"));
1401 }
1402 null_safe__ = Some(map_.next_value()?);
1403 }
1404 GeneratedField::AsofDesc => {
1405 if asof_desc__.is_some() {
1406 return Err(serde::de::Error::duplicate_field("asofDesc"));
1407 }
1408 asof_desc__ = map_.next_value()?;
1409 }
1410 GeneratedField::JoinEncodingType => {
1411 if join_encoding_type__.is_some() {
1412 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
1413 }
1414 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
1415 }
1416 }
1417 }
1418 Ok(AsOfJoinNode {
1419 join_type: join_type__.unwrap_or_default(),
1420 left_key: left_key__.unwrap_or_default(),
1421 right_key: right_key__.unwrap_or_default(),
1422 left_table: left_table__,
1423 right_table: right_table__,
1424 output_indices: output_indices__.unwrap_or_default(),
1425 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
1426 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
1427 null_safe: null_safe__.unwrap_or_default(),
1428 asof_desc: asof_desc__,
1429 join_encoding_type: join_encoding_type__.unwrap_or_default(),
1430 })
1431 }
1432 }
1433 deserializer.deserialize_struct("stream_plan.AsOfJoinNode", FIELDS, GeneratedVisitor)
1434 }
1435}
1436impl serde::Serialize for BackfillOrder {
1437 #[allow(deprecated)]
1438 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1439 where
1440 S: serde::Serializer,
1441 {
1442 use serde::ser::SerializeStruct;
1443 let mut len = 0;
1444 if !self.order.is_empty() {
1445 len += 1;
1446 }
1447 let mut struct_ser = serializer.serialize_struct("stream_plan.BackfillOrder", len)?;
1448 if !self.order.is_empty() {
1449 struct_ser.serialize_field("order", &self.order)?;
1450 }
1451 struct_ser.end()
1452 }
1453}
1454impl<'de> serde::Deserialize<'de> for BackfillOrder {
1455 #[allow(deprecated)]
1456 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1457 where
1458 D: serde::Deserializer<'de>,
1459 {
1460 const FIELDS: &[&str] = &[
1461 "order",
1462 ];
1463
1464 #[allow(clippy::enum_variant_names)]
1465 enum GeneratedField {
1466 Order,
1467 }
1468 impl<'de> serde::Deserialize<'de> for GeneratedField {
1469 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1470 where
1471 D: serde::Deserializer<'de>,
1472 {
1473 struct GeneratedVisitor;
1474
1475 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1476 type Value = GeneratedField;
1477
1478 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1479 write!(formatter, "expected one of: {:?}", &FIELDS)
1480 }
1481
1482 #[allow(unused_variables)]
1483 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1484 where
1485 E: serde::de::Error,
1486 {
1487 match value {
1488 "order" => Ok(GeneratedField::Order),
1489 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1490 }
1491 }
1492 }
1493 deserializer.deserialize_identifier(GeneratedVisitor)
1494 }
1495 }
1496 struct GeneratedVisitor;
1497 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1498 type Value = BackfillOrder;
1499
1500 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1501 formatter.write_str("struct stream_plan.BackfillOrder")
1502 }
1503
1504 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BackfillOrder, V::Error>
1505 where
1506 V: serde::de::MapAccess<'de>,
1507 {
1508 let mut order__ = None;
1509 while let Some(k) = map_.next_key()? {
1510 match k {
1511 GeneratedField::Order => {
1512 if order__.is_some() {
1513 return Err(serde::de::Error::duplicate_field("order"));
1514 }
1515 order__ = Some(
1516 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1517 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1518 );
1519 }
1520 }
1521 }
1522 Ok(BackfillOrder {
1523 order: order__.unwrap_or_default(),
1524 })
1525 }
1526 }
1527 deserializer.deserialize_struct("stream_plan.BackfillOrder", FIELDS, GeneratedVisitor)
1528 }
1529}
1530impl serde::Serialize for Barrier {
1531 #[allow(deprecated)]
1532 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1533 where
1534 S: serde::Serializer,
1535 {
1536 use serde::ser::SerializeStruct;
1537 let mut len = 0;
1538 if self.epoch.is_some() {
1539 len += 1;
1540 }
1541 if self.mutation.is_some() {
1542 len += 1;
1543 }
1544 if !self.tracing_context.is_empty() {
1545 len += 1;
1546 }
1547 if self.kind != 0 {
1548 len += 1;
1549 }
1550 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<'de> serde::de::Visitor<'de> 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<'de> serde::de::Visitor<'de> 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 }
1808 }
1809 struct_ser.end()
1810 }
1811}
1812impl<'de> serde::Deserialize<'de> for BarrierMutation {
1813 #[allow(deprecated)]
1814 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1815 where
1816 D: serde::Deserializer<'de>,
1817 {
1818 const FIELDS: &[&str] = &[
1819 "add",
1820 "stop",
1821 "update",
1822 "splits",
1823 "pause",
1824 "resume",
1825 "throttle",
1826 "drop_subscriptions",
1827 "dropSubscriptions",
1828 "connector_props_change",
1829 "connectorPropsChange",
1830 "start_fragment_backfill",
1831 "startFragmentBackfill",
1832 "refresh_start",
1833 "refreshStart",
1834 "load_finish",
1835 "loadFinish",
1836 "list_finish",
1837 "listFinish",
1838 ];
1839
1840 #[allow(clippy::enum_variant_names)]
1841 enum GeneratedField {
1842 Add,
1843 Stop,
1844 Update,
1845 Splits,
1846 Pause,
1847 Resume,
1848 Throttle,
1849 DropSubscriptions,
1850 ConnectorPropsChange,
1851 StartFragmentBackfill,
1852 RefreshStart,
1853 LoadFinish,
1854 ListFinish,
1855 }
1856 impl<'de> serde::Deserialize<'de> for GeneratedField {
1857 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1858 where
1859 D: serde::Deserializer<'de>,
1860 {
1861 struct GeneratedVisitor;
1862
1863 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1864 type Value = GeneratedField;
1865
1866 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1867 write!(formatter, "expected one of: {:?}", &FIELDS)
1868 }
1869
1870 #[allow(unused_variables)]
1871 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1872 where
1873 E: serde::de::Error,
1874 {
1875 match value {
1876 "add" => Ok(GeneratedField::Add),
1877 "stop" => Ok(GeneratedField::Stop),
1878 "update" => Ok(GeneratedField::Update),
1879 "splits" => Ok(GeneratedField::Splits),
1880 "pause" => Ok(GeneratedField::Pause),
1881 "resume" => Ok(GeneratedField::Resume),
1882 "throttle" => Ok(GeneratedField::Throttle),
1883 "dropSubscriptions" | "drop_subscriptions" => Ok(GeneratedField::DropSubscriptions),
1884 "connectorPropsChange" | "connector_props_change" => Ok(GeneratedField::ConnectorPropsChange),
1885 "startFragmentBackfill" | "start_fragment_backfill" => Ok(GeneratedField::StartFragmentBackfill),
1886 "refreshStart" | "refresh_start" => Ok(GeneratedField::RefreshStart),
1887 "loadFinish" | "load_finish" => Ok(GeneratedField::LoadFinish),
1888 "listFinish" | "list_finish" => Ok(GeneratedField::ListFinish),
1889 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1890 }
1891 }
1892 }
1893 deserializer.deserialize_identifier(GeneratedVisitor)
1894 }
1895 }
1896 struct GeneratedVisitor;
1897 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1898 type Value = BarrierMutation;
1899
1900 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1901 formatter.write_str("struct stream_plan.BarrierMutation")
1902 }
1903
1904 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierMutation, V::Error>
1905 where
1906 V: serde::de::MapAccess<'de>,
1907 {
1908 let mut mutation__ = None;
1909 while let Some(k) = map_.next_key()? {
1910 match k {
1911 GeneratedField::Add => {
1912 if mutation__.is_some() {
1913 return Err(serde::de::Error::duplicate_field("add"));
1914 }
1915 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Add)
1916;
1917 }
1918 GeneratedField::Stop => {
1919 if mutation__.is_some() {
1920 return Err(serde::de::Error::duplicate_field("stop"));
1921 }
1922 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Stop)
1923;
1924 }
1925 GeneratedField::Update => {
1926 if mutation__.is_some() {
1927 return Err(serde::de::Error::duplicate_field("update"));
1928 }
1929 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Update)
1930;
1931 }
1932 GeneratedField::Splits => {
1933 if mutation__.is_some() {
1934 return Err(serde::de::Error::duplicate_field("splits"));
1935 }
1936 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Splits)
1937;
1938 }
1939 GeneratedField::Pause => {
1940 if mutation__.is_some() {
1941 return Err(serde::de::Error::duplicate_field("pause"));
1942 }
1943 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Pause)
1944;
1945 }
1946 GeneratedField::Resume => {
1947 if mutation__.is_some() {
1948 return Err(serde::de::Error::duplicate_field("resume"));
1949 }
1950 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Resume)
1951;
1952 }
1953 GeneratedField::Throttle => {
1954 if mutation__.is_some() {
1955 return Err(serde::de::Error::duplicate_field("throttle"));
1956 }
1957 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Throttle)
1958;
1959 }
1960 GeneratedField::DropSubscriptions => {
1961 if mutation__.is_some() {
1962 return Err(serde::de::Error::duplicate_field("dropSubscriptions"));
1963 }
1964 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::DropSubscriptions)
1965;
1966 }
1967 GeneratedField::ConnectorPropsChange => {
1968 if mutation__.is_some() {
1969 return Err(serde::de::Error::duplicate_field("connectorPropsChange"));
1970 }
1971 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ConnectorPropsChange)
1972;
1973 }
1974 GeneratedField::StartFragmentBackfill => {
1975 if mutation__.is_some() {
1976 return Err(serde::de::Error::duplicate_field("startFragmentBackfill"));
1977 }
1978 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::StartFragmentBackfill)
1979;
1980 }
1981 GeneratedField::RefreshStart => {
1982 if mutation__.is_some() {
1983 return Err(serde::de::Error::duplicate_field("refreshStart"));
1984 }
1985 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::RefreshStart)
1986;
1987 }
1988 GeneratedField::LoadFinish => {
1989 if mutation__.is_some() {
1990 return Err(serde::de::Error::duplicate_field("loadFinish"));
1991 }
1992 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::LoadFinish)
1993;
1994 }
1995 GeneratedField::ListFinish => {
1996 if mutation__.is_some() {
1997 return Err(serde::de::Error::duplicate_field("listFinish"));
1998 }
1999 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ListFinish)
2000;
2001 }
2002 }
2003 }
2004 Ok(BarrierMutation {
2005 mutation: mutation__,
2006 })
2007 }
2008 }
2009 deserializer.deserialize_struct("stream_plan.BarrierMutation", FIELDS, GeneratedVisitor)
2010 }
2011}
2012impl serde::Serialize for BarrierRecvNode {
2013 #[allow(deprecated)]
2014 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2015 where
2016 S: serde::Serializer,
2017 {
2018 use serde::ser::SerializeStruct;
2019 let len = 0;
2020 let struct_ser = serializer.serialize_struct("stream_plan.BarrierRecvNode", len)?;
2021 struct_ser.end()
2022 }
2023}
2024impl<'de> serde::Deserialize<'de> for BarrierRecvNode {
2025 #[allow(deprecated)]
2026 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2027 where
2028 D: serde::Deserializer<'de>,
2029 {
2030 const FIELDS: &[&str] = &[
2031 ];
2032
2033 #[allow(clippy::enum_variant_names)]
2034 enum GeneratedField {
2035 }
2036 impl<'de> serde::Deserialize<'de> for GeneratedField {
2037 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2038 where
2039 D: serde::Deserializer<'de>,
2040 {
2041 struct GeneratedVisitor;
2042
2043 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2044 type Value = GeneratedField;
2045
2046 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2047 write!(formatter, "expected one of: {:?}", &FIELDS)
2048 }
2049
2050 #[allow(unused_variables)]
2051 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2052 where
2053 E: serde::de::Error,
2054 {
2055 Err(serde::de::Error::unknown_field(value, FIELDS))
2056 }
2057 }
2058 deserializer.deserialize_identifier(GeneratedVisitor)
2059 }
2060 }
2061 struct GeneratedVisitor;
2062 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2063 type Value = BarrierRecvNode;
2064
2065 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2066 formatter.write_str("struct stream_plan.BarrierRecvNode")
2067 }
2068
2069 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierRecvNode, V::Error>
2070 where
2071 V: serde::de::MapAccess<'de>,
2072 {
2073 while map_.next_key::<GeneratedField>()?.is_some() {
2074 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2075 }
2076 Ok(BarrierRecvNode {
2077 })
2078 }
2079 }
2080 deserializer.deserialize_struct("stream_plan.BarrierRecvNode", FIELDS, GeneratedVisitor)
2081 }
2082}
2083impl serde::Serialize for BatchPlanNode {
2084 #[allow(deprecated)]
2085 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2086 where
2087 S: serde::Serializer,
2088 {
2089 use serde::ser::SerializeStruct;
2090 let mut len = 0;
2091 if self.table_desc.is_some() {
2092 len += 1;
2093 }
2094 if !self.column_ids.is_empty() {
2095 len += 1;
2096 }
2097 let mut struct_ser = serializer.serialize_struct("stream_plan.BatchPlanNode", len)?;
2098 if let Some(v) = self.table_desc.as_ref() {
2099 struct_ser.serialize_field("tableDesc", v)?;
2100 }
2101 if !self.column_ids.is_empty() {
2102 struct_ser.serialize_field("columnIds", &self.column_ids)?;
2103 }
2104 struct_ser.end()
2105 }
2106}
2107impl<'de> serde::Deserialize<'de> for BatchPlanNode {
2108 #[allow(deprecated)]
2109 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2110 where
2111 D: serde::Deserializer<'de>,
2112 {
2113 const FIELDS: &[&str] = &[
2114 "table_desc",
2115 "tableDesc",
2116 "column_ids",
2117 "columnIds",
2118 ];
2119
2120 #[allow(clippy::enum_variant_names)]
2121 enum GeneratedField {
2122 TableDesc,
2123 ColumnIds,
2124 }
2125 impl<'de> serde::Deserialize<'de> for GeneratedField {
2126 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2127 where
2128 D: serde::Deserializer<'de>,
2129 {
2130 struct GeneratedVisitor;
2131
2132 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2133 type Value = GeneratedField;
2134
2135 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2136 write!(formatter, "expected one of: {:?}", &FIELDS)
2137 }
2138
2139 #[allow(unused_variables)]
2140 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2141 where
2142 E: serde::de::Error,
2143 {
2144 match value {
2145 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
2146 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
2147 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2148 }
2149 }
2150 }
2151 deserializer.deserialize_identifier(GeneratedVisitor)
2152 }
2153 }
2154 struct GeneratedVisitor;
2155 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2156 type Value = BatchPlanNode;
2157
2158 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2159 formatter.write_str("struct stream_plan.BatchPlanNode")
2160 }
2161
2162 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BatchPlanNode, V::Error>
2163 where
2164 V: serde::de::MapAccess<'de>,
2165 {
2166 let mut table_desc__ = None;
2167 let mut column_ids__ = None;
2168 while let Some(k) = map_.next_key()? {
2169 match k {
2170 GeneratedField::TableDesc => {
2171 if table_desc__.is_some() {
2172 return Err(serde::de::Error::duplicate_field("tableDesc"));
2173 }
2174 table_desc__ = map_.next_value()?;
2175 }
2176 GeneratedField::ColumnIds => {
2177 if column_ids__.is_some() {
2178 return Err(serde::de::Error::duplicate_field("columnIds"));
2179 }
2180 column_ids__ =
2181 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2182 .into_iter().map(|x| x.0).collect())
2183 ;
2184 }
2185 }
2186 }
2187 Ok(BatchPlanNode {
2188 table_desc: table_desc__,
2189 column_ids: column_ids__.unwrap_or_default(),
2190 })
2191 }
2192 }
2193 deserializer.deserialize_struct("stream_plan.BatchPlanNode", FIELDS, GeneratedVisitor)
2194 }
2195}
2196impl serde::Serialize for CdcFilterNode {
2197 #[allow(deprecated)]
2198 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2199 where
2200 S: serde::Serializer,
2201 {
2202 use serde::ser::SerializeStruct;
2203 let mut len = 0;
2204 if self.search_condition.is_some() {
2205 len += 1;
2206 }
2207 if self.upstream_source_id != 0 {
2208 len += 1;
2209 }
2210 let mut struct_ser = serializer.serialize_struct("stream_plan.CdcFilterNode", len)?;
2211 if let Some(v) = self.search_condition.as_ref() {
2212 struct_ser.serialize_field("searchCondition", v)?;
2213 }
2214 if self.upstream_source_id != 0 {
2215 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
2216 }
2217 struct_ser.end()
2218 }
2219}
2220impl<'de> serde::Deserialize<'de> for CdcFilterNode {
2221 #[allow(deprecated)]
2222 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2223 where
2224 D: serde::Deserializer<'de>,
2225 {
2226 const FIELDS: &[&str] = &[
2227 "search_condition",
2228 "searchCondition",
2229 "upstream_source_id",
2230 "upstreamSourceId",
2231 ];
2232
2233 #[allow(clippy::enum_variant_names)]
2234 enum GeneratedField {
2235 SearchCondition,
2236 UpstreamSourceId,
2237 }
2238 impl<'de> serde::Deserialize<'de> for GeneratedField {
2239 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2240 where
2241 D: serde::Deserializer<'de>,
2242 {
2243 struct GeneratedVisitor;
2244
2245 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2246 type Value = GeneratedField;
2247
2248 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2249 write!(formatter, "expected one of: {:?}", &FIELDS)
2250 }
2251
2252 #[allow(unused_variables)]
2253 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2254 where
2255 E: serde::de::Error,
2256 {
2257 match value {
2258 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
2259 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
2260 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2261 }
2262 }
2263 }
2264 deserializer.deserialize_identifier(GeneratedVisitor)
2265 }
2266 }
2267 struct GeneratedVisitor;
2268 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2269 type Value = CdcFilterNode;
2270
2271 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2272 formatter.write_str("struct stream_plan.CdcFilterNode")
2273 }
2274
2275 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcFilterNode, V::Error>
2276 where
2277 V: serde::de::MapAccess<'de>,
2278 {
2279 let mut search_condition__ = None;
2280 let mut upstream_source_id__ = None;
2281 while let Some(k) = map_.next_key()? {
2282 match k {
2283 GeneratedField::SearchCondition => {
2284 if search_condition__.is_some() {
2285 return Err(serde::de::Error::duplicate_field("searchCondition"));
2286 }
2287 search_condition__ = map_.next_value()?;
2288 }
2289 GeneratedField::UpstreamSourceId => {
2290 if upstream_source_id__.is_some() {
2291 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
2292 }
2293 upstream_source_id__ =
2294 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2295 ;
2296 }
2297 }
2298 }
2299 Ok(CdcFilterNode {
2300 search_condition: search_condition__,
2301 upstream_source_id: upstream_source_id__.unwrap_or_default(),
2302 })
2303 }
2304 }
2305 deserializer.deserialize_struct("stream_plan.CdcFilterNode", FIELDS, GeneratedVisitor)
2306 }
2307}
2308impl serde::Serialize for ChangeLogNode {
2309 #[allow(deprecated)]
2310 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2311 where
2312 S: serde::Serializer,
2313 {
2314 use serde::ser::SerializeStruct;
2315 let mut len = 0;
2316 if self.need_op {
2317 len += 1;
2318 }
2319 if !self.distribution_keys.is_empty() {
2320 len += 1;
2321 }
2322 let mut struct_ser = serializer.serialize_struct("stream_plan.ChangeLogNode", len)?;
2323 if self.need_op {
2324 struct_ser.serialize_field("needOp", &self.need_op)?;
2325 }
2326 if !self.distribution_keys.is_empty() {
2327 struct_ser.serialize_field("distributionKeys", &self.distribution_keys)?;
2328 }
2329 struct_ser.end()
2330 }
2331}
2332impl<'de> serde::Deserialize<'de> for ChangeLogNode {
2333 #[allow(deprecated)]
2334 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2335 where
2336 D: serde::Deserializer<'de>,
2337 {
2338 const FIELDS: &[&str] = &[
2339 "need_op",
2340 "needOp",
2341 "distribution_keys",
2342 "distributionKeys",
2343 ];
2344
2345 #[allow(clippy::enum_variant_names)]
2346 enum GeneratedField {
2347 NeedOp,
2348 DistributionKeys,
2349 }
2350 impl<'de> serde::Deserialize<'de> for GeneratedField {
2351 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2352 where
2353 D: serde::Deserializer<'de>,
2354 {
2355 struct GeneratedVisitor;
2356
2357 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2358 type Value = GeneratedField;
2359
2360 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2361 write!(formatter, "expected one of: {:?}", &FIELDS)
2362 }
2363
2364 #[allow(unused_variables)]
2365 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2366 where
2367 E: serde::de::Error,
2368 {
2369 match value {
2370 "needOp" | "need_op" => Ok(GeneratedField::NeedOp),
2371 "distributionKeys" | "distribution_keys" => Ok(GeneratedField::DistributionKeys),
2372 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2373 }
2374 }
2375 }
2376 deserializer.deserialize_identifier(GeneratedVisitor)
2377 }
2378 }
2379 struct GeneratedVisitor;
2380 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2381 type Value = ChangeLogNode;
2382
2383 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2384 formatter.write_str("struct stream_plan.ChangeLogNode")
2385 }
2386
2387 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ChangeLogNode, V::Error>
2388 where
2389 V: serde::de::MapAccess<'de>,
2390 {
2391 let mut need_op__ = None;
2392 let mut distribution_keys__ = None;
2393 while let Some(k) = map_.next_key()? {
2394 match k {
2395 GeneratedField::NeedOp => {
2396 if need_op__.is_some() {
2397 return Err(serde::de::Error::duplicate_field("needOp"));
2398 }
2399 need_op__ = Some(map_.next_value()?);
2400 }
2401 GeneratedField::DistributionKeys => {
2402 if distribution_keys__.is_some() {
2403 return Err(serde::de::Error::duplicate_field("distributionKeys"));
2404 }
2405 distribution_keys__ =
2406 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2407 .into_iter().map(|x| x.0).collect())
2408 ;
2409 }
2410 }
2411 }
2412 Ok(ChangeLogNode {
2413 need_op: need_op__.unwrap_or_default(),
2414 distribution_keys: distribution_keys__.unwrap_or_default(),
2415 })
2416 }
2417 }
2418 deserializer.deserialize_struct("stream_plan.ChangeLogNode", FIELDS, GeneratedVisitor)
2419 }
2420}
2421impl serde::Serialize for Columns {
2422 #[allow(deprecated)]
2423 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2424 where
2425 S: serde::Serializer,
2426 {
2427 use serde::ser::SerializeStruct;
2428 let mut len = 0;
2429 if !self.columns.is_empty() {
2430 len += 1;
2431 }
2432 let mut struct_ser = serializer.serialize_struct("stream_plan.Columns", len)?;
2433 if !self.columns.is_empty() {
2434 struct_ser.serialize_field("columns", &self.columns)?;
2435 }
2436 struct_ser.end()
2437 }
2438}
2439impl<'de> serde::Deserialize<'de> for Columns {
2440 #[allow(deprecated)]
2441 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2442 where
2443 D: serde::Deserializer<'de>,
2444 {
2445 const FIELDS: &[&str] = &[
2446 "columns",
2447 ];
2448
2449 #[allow(clippy::enum_variant_names)]
2450 enum GeneratedField {
2451 Columns,
2452 }
2453 impl<'de> serde::Deserialize<'de> for GeneratedField {
2454 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2455 where
2456 D: serde::Deserializer<'de>,
2457 {
2458 struct GeneratedVisitor;
2459
2460 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2461 type Value = GeneratedField;
2462
2463 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2464 write!(formatter, "expected one of: {:?}", &FIELDS)
2465 }
2466
2467 #[allow(unused_variables)]
2468 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2469 where
2470 E: serde::de::Error,
2471 {
2472 match value {
2473 "columns" => Ok(GeneratedField::Columns),
2474 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2475 }
2476 }
2477 }
2478 deserializer.deserialize_identifier(GeneratedVisitor)
2479 }
2480 }
2481 struct GeneratedVisitor;
2482 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2483 type Value = Columns;
2484
2485 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2486 formatter.write_str("struct stream_plan.Columns")
2487 }
2488
2489 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Columns, V::Error>
2490 where
2491 V: serde::de::MapAccess<'de>,
2492 {
2493 let mut columns__ = None;
2494 while let Some(k) = map_.next_key()? {
2495 match k {
2496 GeneratedField::Columns => {
2497 if columns__.is_some() {
2498 return Err(serde::de::Error::duplicate_field("columns"));
2499 }
2500 columns__ = Some(map_.next_value()?);
2501 }
2502 }
2503 }
2504 Ok(Columns {
2505 columns: columns__.unwrap_or_default(),
2506 })
2507 }
2508 }
2509 deserializer.deserialize_struct("stream_plan.Columns", FIELDS, GeneratedVisitor)
2510 }
2511}
2512impl serde::Serialize for ConnectorPropsChangeMutation {
2513 #[allow(deprecated)]
2514 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2515 where
2516 S: serde::Serializer,
2517 {
2518 use serde::ser::SerializeStruct;
2519 let mut len = 0;
2520 if !self.connector_props_infos.is_empty() {
2521 len += 1;
2522 }
2523 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation", len)?;
2524 if !self.connector_props_infos.is_empty() {
2525 struct_ser.serialize_field("connectorPropsInfos", &self.connector_props_infos)?;
2526 }
2527 struct_ser.end()
2528 }
2529}
2530impl<'de> serde::Deserialize<'de> for ConnectorPropsChangeMutation {
2531 #[allow(deprecated)]
2532 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2533 where
2534 D: serde::Deserializer<'de>,
2535 {
2536 const FIELDS: &[&str] = &[
2537 "connector_props_infos",
2538 "connectorPropsInfos",
2539 ];
2540
2541 #[allow(clippy::enum_variant_names)]
2542 enum GeneratedField {
2543 ConnectorPropsInfos,
2544 }
2545 impl<'de> serde::Deserialize<'de> for GeneratedField {
2546 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2547 where
2548 D: serde::Deserializer<'de>,
2549 {
2550 struct GeneratedVisitor;
2551
2552 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2553 type Value = GeneratedField;
2554
2555 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2556 write!(formatter, "expected one of: {:?}", &FIELDS)
2557 }
2558
2559 #[allow(unused_variables)]
2560 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2561 where
2562 E: serde::de::Error,
2563 {
2564 match value {
2565 "connectorPropsInfos" | "connector_props_infos" => Ok(GeneratedField::ConnectorPropsInfos),
2566 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2567 }
2568 }
2569 }
2570 deserializer.deserialize_identifier(GeneratedVisitor)
2571 }
2572 }
2573 struct GeneratedVisitor;
2574 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2575 type Value = ConnectorPropsChangeMutation;
2576
2577 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2578 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation")
2579 }
2580
2581 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectorPropsChangeMutation, V::Error>
2582 where
2583 V: serde::de::MapAccess<'de>,
2584 {
2585 let mut connector_props_infos__ = None;
2586 while let Some(k) = map_.next_key()? {
2587 match k {
2588 GeneratedField::ConnectorPropsInfos => {
2589 if connector_props_infos__.is_some() {
2590 return Err(serde::de::Error::duplicate_field("connectorPropsInfos"));
2591 }
2592 connector_props_infos__ = Some(
2593 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
2594 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
2595 );
2596 }
2597 }
2598 }
2599 Ok(ConnectorPropsChangeMutation {
2600 connector_props_infos: connector_props_infos__.unwrap_or_default(),
2601 })
2602 }
2603 }
2604 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation", FIELDS, GeneratedVisitor)
2605 }
2606}
2607impl serde::Serialize for connector_props_change_mutation::ConnectorPropsInfo {
2608 #[allow(deprecated)]
2609 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2610 where
2611 S: serde::Serializer,
2612 {
2613 use serde::ser::SerializeStruct;
2614 let mut len = 0;
2615 if !self.connector_props_info.is_empty() {
2616 len += 1;
2617 }
2618 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", len)?;
2619 if !self.connector_props_info.is_empty() {
2620 struct_ser.serialize_field("connectorPropsInfo", &self.connector_props_info)?;
2621 }
2622 struct_ser.end()
2623 }
2624}
2625impl<'de> serde::Deserialize<'de> for connector_props_change_mutation::ConnectorPropsInfo {
2626 #[allow(deprecated)]
2627 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2628 where
2629 D: serde::Deserializer<'de>,
2630 {
2631 const FIELDS: &[&str] = &[
2632 "connector_props_info",
2633 "connectorPropsInfo",
2634 ];
2635
2636 #[allow(clippy::enum_variant_names)]
2637 enum GeneratedField {
2638 ConnectorPropsInfo,
2639 }
2640 impl<'de> serde::Deserialize<'de> for GeneratedField {
2641 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2642 where
2643 D: serde::Deserializer<'de>,
2644 {
2645 struct GeneratedVisitor;
2646
2647 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2648 type Value = GeneratedField;
2649
2650 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2651 write!(formatter, "expected one of: {:?}", &FIELDS)
2652 }
2653
2654 #[allow(unused_variables)]
2655 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2656 where
2657 E: serde::de::Error,
2658 {
2659 match value {
2660 "connectorPropsInfo" | "connector_props_info" => Ok(GeneratedField::ConnectorPropsInfo),
2661 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2662 }
2663 }
2664 }
2665 deserializer.deserialize_identifier(GeneratedVisitor)
2666 }
2667 }
2668 struct GeneratedVisitor;
2669 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2670 type Value = connector_props_change_mutation::ConnectorPropsInfo;
2671
2672 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2673 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo")
2674 }
2675
2676 fn visit_map<V>(self, mut map_: V) -> std::result::Result<connector_props_change_mutation::ConnectorPropsInfo, V::Error>
2677 where
2678 V: serde::de::MapAccess<'de>,
2679 {
2680 let mut connector_props_info__ = None;
2681 while let Some(k) = map_.next_key()? {
2682 match k {
2683 GeneratedField::ConnectorPropsInfo => {
2684 if connector_props_info__.is_some() {
2685 return Err(serde::de::Error::duplicate_field("connectorPropsInfo"));
2686 }
2687 connector_props_info__ = Some(
2688 map_.next_value::<std::collections::HashMap<_, _>>()?
2689 );
2690 }
2691 }
2692 }
2693 Ok(connector_props_change_mutation::ConnectorPropsInfo {
2694 connector_props_info: connector_props_info__.unwrap_or_default(),
2695 })
2696 }
2697 }
2698 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", FIELDS, GeneratedVisitor)
2699 }
2700}
2701impl serde::Serialize for DedupNode {
2702 #[allow(deprecated)]
2703 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2704 where
2705 S: serde::Serializer,
2706 {
2707 use serde::ser::SerializeStruct;
2708 let mut len = 0;
2709 if self.state_table.is_some() {
2710 len += 1;
2711 }
2712 if !self.dedup_column_indices.is_empty() {
2713 len += 1;
2714 }
2715 let mut struct_ser = serializer.serialize_struct("stream_plan.DedupNode", len)?;
2716 if let Some(v) = self.state_table.as_ref() {
2717 struct_ser.serialize_field("stateTable", v)?;
2718 }
2719 if !self.dedup_column_indices.is_empty() {
2720 struct_ser.serialize_field("dedupColumnIndices", &self.dedup_column_indices)?;
2721 }
2722 struct_ser.end()
2723 }
2724}
2725impl<'de> serde::Deserialize<'de> for DedupNode {
2726 #[allow(deprecated)]
2727 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2728 where
2729 D: serde::Deserializer<'de>,
2730 {
2731 const FIELDS: &[&str] = &[
2732 "state_table",
2733 "stateTable",
2734 "dedup_column_indices",
2735 "dedupColumnIndices",
2736 ];
2737
2738 #[allow(clippy::enum_variant_names)]
2739 enum GeneratedField {
2740 StateTable,
2741 DedupColumnIndices,
2742 }
2743 impl<'de> serde::Deserialize<'de> for GeneratedField {
2744 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2745 where
2746 D: serde::Deserializer<'de>,
2747 {
2748 struct GeneratedVisitor;
2749
2750 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2751 type Value = GeneratedField;
2752
2753 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2754 write!(formatter, "expected one of: {:?}", &FIELDS)
2755 }
2756
2757 #[allow(unused_variables)]
2758 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2759 where
2760 E: serde::de::Error,
2761 {
2762 match value {
2763 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
2764 "dedupColumnIndices" | "dedup_column_indices" => Ok(GeneratedField::DedupColumnIndices),
2765 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2766 }
2767 }
2768 }
2769 deserializer.deserialize_identifier(GeneratedVisitor)
2770 }
2771 }
2772 struct GeneratedVisitor;
2773 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2774 type Value = DedupNode;
2775
2776 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2777 formatter.write_str("struct stream_plan.DedupNode")
2778 }
2779
2780 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DedupNode, V::Error>
2781 where
2782 V: serde::de::MapAccess<'de>,
2783 {
2784 let mut state_table__ = None;
2785 let mut dedup_column_indices__ = None;
2786 while let Some(k) = map_.next_key()? {
2787 match k {
2788 GeneratedField::StateTable => {
2789 if state_table__.is_some() {
2790 return Err(serde::de::Error::duplicate_field("stateTable"));
2791 }
2792 state_table__ = map_.next_value()?;
2793 }
2794 GeneratedField::DedupColumnIndices => {
2795 if dedup_column_indices__.is_some() {
2796 return Err(serde::de::Error::duplicate_field("dedupColumnIndices"));
2797 }
2798 dedup_column_indices__ =
2799 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2800 .into_iter().map(|x| x.0).collect())
2801 ;
2802 }
2803 }
2804 }
2805 Ok(DedupNode {
2806 state_table: state_table__,
2807 dedup_column_indices: dedup_column_indices__.unwrap_or_default(),
2808 })
2809 }
2810 }
2811 deserializer.deserialize_struct("stream_plan.DedupNode", FIELDS, GeneratedVisitor)
2812 }
2813}
2814impl serde::Serialize for DeltaExpression {
2815 #[allow(deprecated)]
2816 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2817 where
2818 S: serde::Serializer,
2819 {
2820 use serde::ser::SerializeStruct;
2821 let mut len = 0;
2822 if self.delta_type != 0 {
2823 len += 1;
2824 }
2825 if self.delta.is_some() {
2826 len += 1;
2827 }
2828 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaExpression", len)?;
2829 if self.delta_type != 0 {
2830 let v = super::expr::expr_node::Type::try_from(self.delta_type)
2831 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.delta_type)))?;
2832 struct_ser.serialize_field("deltaType", &v)?;
2833 }
2834 if let Some(v) = self.delta.as_ref() {
2835 struct_ser.serialize_field("delta", v)?;
2836 }
2837 struct_ser.end()
2838 }
2839}
2840impl<'de> serde::Deserialize<'de> for DeltaExpression {
2841 #[allow(deprecated)]
2842 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2843 where
2844 D: serde::Deserializer<'de>,
2845 {
2846 const FIELDS: &[&str] = &[
2847 "delta_type",
2848 "deltaType",
2849 "delta",
2850 ];
2851
2852 #[allow(clippy::enum_variant_names)]
2853 enum GeneratedField {
2854 DeltaType,
2855 Delta,
2856 }
2857 impl<'de> serde::Deserialize<'de> for GeneratedField {
2858 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2859 where
2860 D: serde::Deserializer<'de>,
2861 {
2862 struct GeneratedVisitor;
2863
2864 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2865 type Value = GeneratedField;
2866
2867 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2868 write!(formatter, "expected one of: {:?}", &FIELDS)
2869 }
2870
2871 #[allow(unused_variables)]
2872 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2873 where
2874 E: serde::de::Error,
2875 {
2876 match value {
2877 "deltaType" | "delta_type" => Ok(GeneratedField::DeltaType),
2878 "delta" => Ok(GeneratedField::Delta),
2879 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2880 }
2881 }
2882 }
2883 deserializer.deserialize_identifier(GeneratedVisitor)
2884 }
2885 }
2886 struct GeneratedVisitor;
2887 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2888 type Value = DeltaExpression;
2889
2890 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2891 formatter.write_str("struct stream_plan.DeltaExpression")
2892 }
2893
2894 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaExpression, V::Error>
2895 where
2896 V: serde::de::MapAccess<'de>,
2897 {
2898 let mut delta_type__ = None;
2899 let mut delta__ = None;
2900 while let Some(k) = map_.next_key()? {
2901 match k {
2902 GeneratedField::DeltaType => {
2903 if delta_type__.is_some() {
2904 return Err(serde::de::Error::duplicate_field("deltaType"));
2905 }
2906 delta_type__ = Some(map_.next_value::<super::expr::expr_node::Type>()? as i32);
2907 }
2908 GeneratedField::Delta => {
2909 if delta__.is_some() {
2910 return Err(serde::de::Error::duplicate_field("delta"));
2911 }
2912 delta__ = map_.next_value()?;
2913 }
2914 }
2915 }
2916 Ok(DeltaExpression {
2917 delta_type: delta_type__.unwrap_or_default(),
2918 delta: delta__,
2919 })
2920 }
2921 }
2922 deserializer.deserialize_struct("stream_plan.DeltaExpression", FIELDS, GeneratedVisitor)
2923 }
2924}
2925impl serde::Serialize for DeltaIndexJoinNode {
2926 #[allow(deprecated)]
2927 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2928 where
2929 S: serde::Serializer,
2930 {
2931 use serde::ser::SerializeStruct;
2932 let mut len = 0;
2933 if self.join_type != 0 {
2934 len += 1;
2935 }
2936 if !self.left_key.is_empty() {
2937 len += 1;
2938 }
2939 if !self.right_key.is_empty() {
2940 len += 1;
2941 }
2942 if self.condition.is_some() {
2943 len += 1;
2944 }
2945 if self.left_table_id != 0 {
2946 len += 1;
2947 }
2948 if self.right_table_id != 0 {
2949 len += 1;
2950 }
2951 if self.left_info.is_some() {
2952 len += 1;
2953 }
2954 if self.right_info.is_some() {
2955 len += 1;
2956 }
2957 if !self.output_indices.is_empty() {
2958 len += 1;
2959 }
2960 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaIndexJoinNode", len)?;
2961 if self.join_type != 0 {
2962 let v = super::plan_common::JoinType::try_from(self.join_type)
2963 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
2964 struct_ser.serialize_field("joinType", &v)?;
2965 }
2966 if !self.left_key.is_empty() {
2967 struct_ser.serialize_field("leftKey", &self.left_key)?;
2968 }
2969 if !self.right_key.is_empty() {
2970 struct_ser.serialize_field("rightKey", &self.right_key)?;
2971 }
2972 if let Some(v) = self.condition.as_ref() {
2973 struct_ser.serialize_field("condition", v)?;
2974 }
2975 if self.left_table_id != 0 {
2976 struct_ser.serialize_field("leftTableId", &self.left_table_id)?;
2977 }
2978 if self.right_table_id != 0 {
2979 struct_ser.serialize_field("rightTableId", &self.right_table_id)?;
2980 }
2981 if let Some(v) = self.left_info.as_ref() {
2982 struct_ser.serialize_field("leftInfo", v)?;
2983 }
2984 if let Some(v) = self.right_info.as_ref() {
2985 struct_ser.serialize_field("rightInfo", v)?;
2986 }
2987 if !self.output_indices.is_empty() {
2988 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
2989 }
2990 struct_ser.end()
2991 }
2992}
2993impl<'de> serde::Deserialize<'de> for DeltaIndexJoinNode {
2994 #[allow(deprecated)]
2995 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2996 where
2997 D: serde::Deserializer<'de>,
2998 {
2999 const FIELDS: &[&str] = &[
3000 "join_type",
3001 "joinType",
3002 "left_key",
3003 "leftKey",
3004 "right_key",
3005 "rightKey",
3006 "condition",
3007 "left_table_id",
3008 "leftTableId",
3009 "right_table_id",
3010 "rightTableId",
3011 "left_info",
3012 "leftInfo",
3013 "right_info",
3014 "rightInfo",
3015 "output_indices",
3016 "outputIndices",
3017 ];
3018
3019 #[allow(clippy::enum_variant_names)]
3020 enum GeneratedField {
3021 JoinType,
3022 LeftKey,
3023 RightKey,
3024 Condition,
3025 LeftTableId,
3026 RightTableId,
3027 LeftInfo,
3028 RightInfo,
3029 OutputIndices,
3030 }
3031 impl<'de> serde::Deserialize<'de> for GeneratedField {
3032 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3033 where
3034 D: serde::Deserializer<'de>,
3035 {
3036 struct GeneratedVisitor;
3037
3038 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3039 type Value = GeneratedField;
3040
3041 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3042 write!(formatter, "expected one of: {:?}", &FIELDS)
3043 }
3044
3045 #[allow(unused_variables)]
3046 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3047 where
3048 E: serde::de::Error,
3049 {
3050 match value {
3051 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
3052 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
3053 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
3054 "condition" => Ok(GeneratedField::Condition),
3055 "leftTableId" | "left_table_id" => Ok(GeneratedField::LeftTableId),
3056 "rightTableId" | "right_table_id" => Ok(GeneratedField::RightTableId),
3057 "leftInfo" | "left_info" => Ok(GeneratedField::LeftInfo),
3058 "rightInfo" | "right_info" => Ok(GeneratedField::RightInfo),
3059 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
3060 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3061 }
3062 }
3063 }
3064 deserializer.deserialize_identifier(GeneratedVisitor)
3065 }
3066 }
3067 struct GeneratedVisitor;
3068 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3069 type Value = DeltaIndexJoinNode;
3070
3071 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3072 formatter.write_str("struct stream_plan.DeltaIndexJoinNode")
3073 }
3074
3075 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaIndexJoinNode, V::Error>
3076 where
3077 V: serde::de::MapAccess<'de>,
3078 {
3079 let mut join_type__ = None;
3080 let mut left_key__ = None;
3081 let mut right_key__ = None;
3082 let mut condition__ = None;
3083 let mut left_table_id__ = None;
3084 let mut right_table_id__ = None;
3085 let mut left_info__ = None;
3086 let mut right_info__ = None;
3087 let mut output_indices__ = None;
3088 while let Some(k) = map_.next_key()? {
3089 match k {
3090 GeneratedField::JoinType => {
3091 if join_type__.is_some() {
3092 return Err(serde::de::Error::duplicate_field("joinType"));
3093 }
3094 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
3095 }
3096 GeneratedField::LeftKey => {
3097 if left_key__.is_some() {
3098 return Err(serde::de::Error::duplicate_field("leftKey"));
3099 }
3100 left_key__ =
3101 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3102 .into_iter().map(|x| x.0).collect())
3103 ;
3104 }
3105 GeneratedField::RightKey => {
3106 if right_key__.is_some() {
3107 return Err(serde::de::Error::duplicate_field("rightKey"));
3108 }
3109 right_key__ =
3110 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3111 .into_iter().map(|x| x.0).collect())
3112 ;
3113 }
3114 GeneratedField::Condition => {
3115 if condition__.is_some() {
3116 return Err(serde::de::Error::duplicate_field("condition"));
3117 }
3118 condition__ = map_.next_value()?;
3119 }
3120 GeneratedField::LeftTableId => {
3121 if left_table_id__.is_some() {
3122 return Err(serde::de::Error::duplicate_field("leftTableId"));
3123 }
3124 left_table_id__ =
3125 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3126 ;
3127 }
3128 GeneratedField::RightTableId => {
3129 if right_table_id__.is_some() {
3130 return Err(serde::de::Error::duplicate_field("rightTableId"));
3131 }
3132 right_table_id__ =
3133 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3134 ;
3135 }
3136 GeneratedField::LeftInfo => {
3137 if left_info__.is_some() {
3138 return Err(serde::de::Error::duplicate_field("leftInfo"));
3139 }
3140 left_info__ = map_.next_value()?;
3141 }
3142 GeneratedField::RightInfo => {
3143 if right_info__.is_some() {
3144 return Err(serde::de::Error::duplicate_field("rightInfo"));
3145 }
3146 right_info__ = map_.next_value()?;
3147 }
3148 GeneratedField::OutputIndices => {
3149 if output_indices__.is_some() {
3150 return Err(serde::de::Error::duplicate_field("outputIndices"));
3151 }
3152 output_indices__ =
3153 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3154 .into_iter().map(|x| x.0).collect())
3155 ;
3156 }
3157 }
3158 }
3159 Ok(DeltaIndexJoinNode {
3160 join_type: join_type__.unwrap_or_default(),
3161 left_key: left_key__.unwrap_or_default(),
3162 right_key: right_key__.unwrap_or_default(),
3163 condition: condition__,
3164 left_table_id: left_table_id__.unwrap_or_default(),
3165 right_table_id: right_table_id__.unwrap_or_default(),
3166 left_info: left_info__,
3167 right_info: right_info__,
3168 output_indices: output_indices__.unwrap_or_default(),
3169 })
3170 }
3171 }
3172 deserializer.deserialize_struct("stream_plan.DeltaIndexJoinNode", FIELDS, GeneratedVisitor)
3173 }
3174}
3175impl serde::Serialize for DispatchOutputMapping {
3176 #[allow(deprecated)]
3177 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3178 where
3179 S: serde::Serializer,
3180 {
3181 use serde::ser::SerializeStruct;
3182 let mut len = 0;
3183 if !self.indices.is_empty() {
3184 len += 1;
3185 }
3186 if !self.types.is_empty() {
3187 len += 1;
3188 }
3189 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping", len)?;
3190 if !self.indices.is_empty() {
3191 struct_ser.serialize_field("indices", &self.indices)?;
3192 }
3193 if !self.types.is_empty() {
3194 struct_ser.serialize_field("types", &self.types)?;
3195 }
3196 struct_ser.end()
3197 }
3198}
3199impl<'de> serde::Deserialize<'de> for DispatchOutputMapping {
3200 #[allow(deprecated)]
3201 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3202 where
3203 D: serde::Deserializer<'de>,
3204 {
3205 const FIELDS: &[&str] = &[
3206 "indices",
3207 "types",
3208 ];
3209
3210 #[allow(clippy::enum_variant_names)]
3211 enum GeneratedField {
3212 Indices,
3213 Types,
3214 }
3215 impl<'de> serde::Deserialize<'de> for GeneratedField {
3216 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3217 where
3218 D: serde::Deserializer<'de>,
3219 {
3220 struct GeneratedVisitor;
3221
3222 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3223 type Value = GeneratedField;
3224
3225 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3226 write!(formatter, "expected one of: {:?}", &FIELDS)
3227 }
3228
3229 #[allow(unused_variables)]
3230 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3231 where
3232 E: serde::de::Error,
3233 {
3234 match value {
3235 "indices" => Ok(GeneratedField::Indices),
3236 "types" => Ok(GeneratedField::Types),
3237 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3238 }
3239 }
3240 }
3241 deserializer.deserialize_identifier(GeneratedVisitor)
3242 }
3243 }
3244 struct GeneratedVisitor;
3245 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3246 type Value = DispatchOutputMapping;
3247
3248 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3249 formatter.write_str("struct stream_plan.DispatchOutputMapping")
3250 }
3251
3252 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchOutputMapping, V::Error>
3253 where
3254 V: serde::de::MapAccess<'de>,
3255 {
3256 let mut indices__ = None;
3257 let mut types__ = None;
3258 while let Some(k) = map_.next_key()? {
3259 match k {
3260 GeneratedField::Indices => {
3261 if indices__.is_some() {
3262 return Err(serde::de::Error::duplicate_field("indices"));
3263 }
3264 indices__ =
3265 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3266 .into_iter().map(|x| x.0).collect())
3267 ;
3268 }
3269 GeneratedField::Types => {
3270 if types__.is_some() {
3271 return Err(serde::de::Error::duplicate_field("types"));
3272 }
3273 types__ = Some(map_.next_value()?);
3274 }
3275 }
3276 }
3277 Ok(DispatchOutputMapping {
3278 indices: indices__.unwrap_or_default(),
3279 types: types__.unwrap_or_default(),
3280 })
3281 }
3282 }
3283 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping", FIELDS, GeneratedVisitor)
3284 }
3285}
3286impl serde::Serialize for dispatch_output_mapping::TypePair {
3287 #[allow(deprecated)]
3288 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3289 where
3290 S: serde::Serializer,
3291 {
3292 use serde::ser::SerializeStruct;
3293 let mut len = 0;
3294 if self.upstream.is_some() {
3295 len += 1;
3296 }
3297 if self.downstream.is_some() {
3298 len += 1;
3299 }
3300 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping.TypePair", len)?;
3301 if let Some(v) = self.upstream.as_ref() {
3302 struct_ser.serialize_field("upstream", v)?;
3303 }
3304 if let Some(v) = self.downstream.as_ref() {
3305 struct_ser.serialize_field("downstream", v)?;
3306 }
3307 struct_ser.end()
3308 }
3309}
3310impl<'de> serde::Deserialize<'de> for dispatch_output_mapping::TypePair {
3311 #[allow(deprecated)]
3312 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3313 where
3314 D: serde::Deserializer<'de>,
3315 {
3316 const FIELDS: &[&str] = &[
3317 "upstream",
3318 "downstream",
3319 ];
3320
3321 #[allow(clippy::enum_variant_names)]
3322 enum GeneratedField {
3323 Upstream,
3324 Downstream,
3325 }
3326 impl<'de> serde::Deserialize<'de> for GeneratedField {
3327 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3328 where
3329 D: serde::Deserializer<'de>,
3330 {
3331 struct GeneratedVisitor;
3332
3333 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3334 type Value = GeneratedField;
3335
3336 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3337 write!(formatter, "expected one of: {:?}", &FIELDS)
3338 }
3339
3340 #[allow(unused_variables)]
3341 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3342 where
3343 E: serde::de::Error,
3344 {
3345 match value {
3346 "upstream" => Ok(GeneratedField::Upstream),
3347 "downstream" => Ok(GeneratedField::Downstream),
3348 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3349 }
3350 }
3351 }
3352 deserializer.deserialize_identifier(GeneratedVisitor)
3353 }
3354 }
3355 struct GeneratedVisitor;
3356 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3357 type Value = dispatch_output_mapping::TypePair;
3358
3359 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3360 formatter.write_str("struct stream_plan.DispatchOutputMapping.TypePair")
3361 }
3362
3363 fn visit_map<V>(self, mut map_: V) -> std::result::Result<dispatch_output_mapping::TypePair, V::Error>
3364 where
3365 V: serde::de::MapAccess<'de>,
3366 {
3367 let mut upstream__ = None;
3368 let mut downstream__ = None;
3369 while let Some(k) = map_.next_key()? {
3370 match k {
3371 GeneratedField::Upstream => {
3372 if upstream__.is_some() {
3373 return Err(serde::de::Error::duplicate_field("upstream"));
3374 }
3375 upstream__ = map_.next_value()?;
3376 }
3377 GeneratedField::Downstream => {
3378 if downstream__.is_some() {
3379 return Err(serde::de::Error::duplicate_field("downstream"));
3380 }
3381 downstream__ = map_.next_value()?;
3382 }
3383 }
3384 }
3385 Ok(dispatch_output_mapping::TypePair {
3386 upstream: upstream__,
3387 downstream: downstream__,
3388 })
3389 }
3390 }
3391 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping.TypePair", FIELDS, GeneratedVisitor)
3392 }
3393}
3394impl serde::Serialize for DispatchStrategy {
3395 #[allow(deprecated)]
3396 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3397 where
3398 S: serde::Serializer,
3399 {
3400 use serde::ser::SerializeStruct;
3401 let mut len = 0;
3402 if self.r#type != 0 {
3403 len += 1;
3404 }
3405 if !self.dist_key_indices.is_empty() {
3406 len += 1;
3407 }
3408 if self.output_mapping.is_some() {
3409 len += 1;
3410 }
3411 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchStrategy", len)?;
3412 if self.r#type != 0 {
3413 let v = DispatcherType::try_from(self.r#type)
3414 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3415 struct_ser.serialize_field("type", &v)?;
3416 }
3417 if !self.dist_key_indices.is_empty() {
3418 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3419 }
3420 if let Some(v) = self.output_mapping.as_ref() {
3421 struct_ser.serialize_field("outputMapping", v)?;
3422 }
3423 struct_ser.end()
3424 }
3425}
3426impl<'de> serde::Deserialize<'de> for DispatchStrategy {
3427 #[allow(deprecated)]
3428 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3429 where
3430 D: serde::Deserializer<'de>,
3431 {
3432 const FIELDS: &[&str] = &[
3433 "type",
3434 "dist_key_indices",
3435 "distKeyIndices",
3436 "output_mapping",
3437 "outputMapping",
3438 ];
3439
3440 #[allow(clippy::enum_variant_names)]
3441 enum GeneratedField {
3442 Type,
3443 DistKeyIndices,
3444 OutputMapping,
3445 }
3446 impl<'de> serde::Deserialize<'de> for GeneratedField {
3447 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3448 where
3449 D: serde::Deserializer<'de>,
3450 {
3451 struct GeneratedVisitor;
3452
3453 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3454 type Value = GeneratedField;
3455
3456 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3457 write!(formatter, "expected one of: {:?}", &FIELDS)
3458 }
3459
3460 #[allow(unused_variables)]
3461 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3462 where
3463 E: serde::de::Error,
3464 {
3465 match value {
3466 "type" => Ok(GeneratedField::Type),
3467 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3468 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3469 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3470 }
3471 }
3472 }
3473 deserializer.deserialize_identifier(GeneratedVisitor)
3474 }
3475 }
3476 struct GeneratedVisitor;
3477 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3478 type Value = DispatchStrategy;
3479
3480 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3481 formatter.write_str("struct stream_plan.DispatchStrategy")
3482 }
3483
3484 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchStrategy, V::Error>
3485 where
3486 V: serde::de::MapAccess<'de>,
3487 {
3488 let mut r#type__ = None;
3489 let mut dist_key_indices__ = None;
3490 let mut output_mapping__ = None;
3491 while let Some(k) = map_.next_key()? {
3492 match k {
3493 GeneratedField::Type => {
3494 if r#type__.is_some() {
3495 return Err(serde::de::Error::duplicate_field("type"));
3496 }
3497 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3498 }
3499 GeneratedField::DistKeyIndices => {
3500 if dist_key_indices__.is_some() {
3501 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3502 }
3503 dist_key_indices__ =
3504 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3505 .into_iter().map(|x| x.0).collect())
3506 ;
3507 }
3508 GeneratedField::OutputMapping => {
3509 if output_mapping__.is_some() {
3510 return Err(serde::de::Error::duplicate_field("outputMapping"));
3511 }
3512 output_mapping__ = map_.next_value()?;
3513 }
3514 }
3515 }
3516 Ok(DispatchStrategy {
3517 r#type: r#type__.unwrap_or_default(),
3518 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3519 output_mapping: output_mapping__,
3520 })
3521 }
3522 }
3523 deserializer.deserialize_struct("stream_plan.DispatchStrategy", FIELDS, GeneratedVisitor)
3524 }
3525}
3526impl serde::Serialize for Dispatcher {
3527 #[allow(deprecated)]
3528 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3529 where
3530 S: serde::Serializer,
3531 {
3532 use serde::ser::SerializeStruct;
3533 let mut len = 0;
3534 if self.r#type != 0 {
3535 len += 1;
3536 }
3537 if !self.dist_key_indices.is_empty() {
3538 len += 1;
3539 }
3540 if self.output_mapping.is_some() {
3541 len += 1;
3542 }
3543 if self.hash_mapping.is_some() {
3544 len += 1;
3545 }
3546 if self.dispatcher_id != 0 {
3547 len += 1;
3548 }
3549 if !self.downstream_actor_id.is_empty() {
3550 len += 1;
3551 }
3552 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatcher", len)?;
3553 if self.r#type != 0 {
3554 let v = DispatcherType::try_from(self.r#type)
3555 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3556 struct_ser.serialize_field("type", &v)?;
3557 }
3558 if !self.dist_key_indices.is_empty() {
3559 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3560 }
3561 if let Some(v) = self.output_mapping.as_ref() {
3562 struct_ser.serialize_field("outputMapping", v)?;
3563 }
3564 if let Some(v) = self.hash_mapping.as_ref() {
3565 struct_ser.serialize_field("hashMapping", v)?;
3566 }
3567 if self.dispatcher_id != 0 {
3568 #[allow(clippy::needless_borrow)]
3569 #[allow(clippy::needless_borrows_for_generic_args)]
3570 struct_ser.serialize_field("dispatcherId", ToString::to_string(&self.dispatcher_id).as_str())?;
3571 }
3572 if !self.downstream_actor_id.is_empty() {
3573 struct_ser.serialize_field("downstreamActorId", &self.downstream_actor_id)?;
3574 }
3575 struct_ser.end()
3576 }
3577}
3578impl<'de> serde::Deserialize<'de> for Dispatcher {
3579 #[allow(deprecated)]
3580 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3581 where
3582 D: serde::Deserializer<'de>,
3583 {
3584 const FIELDS: &[&str] = &[
3585 "type",
3586 "dist_key_indices",
3587 "distKeyIndices",
3588 "output_mapping",
3589 "outputMapping",
3590 "hash_mapping",
3591 "hashMapping",
3592 "dispatcher_id",
3593 "dispatcherId",
3594 "downstream_actor_id",
3595 "downstreamActorId",
3596 ];
3597
3598 #[allow(clippy::enum_variant_names)]
3599 enum GeneratedField {
3600 Type,
3601 DistKeyIndices,
3602 OutputMapping,
3603 HashMapping,
3604 DispatcherId,
3605 DownstreamActorId,
3606 }
3607 impl<'de> serde::Deserialize<'de> for GeneratedField {
3608 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3609 where
3610 D: serde::Deserializer<'de>,
3611 {
3612 struct GeneratedVisitor;
3613
3614 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3615 type Value = GeneratedField;
3616
3617 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3618 write!(formatter, "expected one of: {:?}", &FIELDS)
3619 }
3620
3621 #[allow(unused_variables)]
3622 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3623 where
3624 E: serde::de::Error,
3625 {
3626 match value {
3627 "type" => Ok(GeneratedField::Type),
3628 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3629 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3630 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
3631 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
3632 "downstreamActorId" | "downstream_actor_id" => Ok(GeneratedField::DownstreamActorId),
3633 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3634 }
3635 }
3636 }
3637 deserializer.deserialize_identifier(GeneratedVisitor)
3638 }
3639 }
3640 struct GeneratedVisitor;
3641 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3642 type Value = Dispatcher;
3643
3644 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3645 formatter.write_str("struct stream_plan.Dispatcher")
3646 }
3647
3648 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatcher, V::Error>
3649 where
3650 V: serde::de::MapAccess<'de>,
3651 {
3652 let mut r#type__ = None;
3653 let mut dist_key_indices__ = None;
3654 let mut output_mapping__ = None;
3655 let mut hash_mapping__ = None;
3656 let mut dispatcher_id__ = None;
3657 let mut downstream_actor_id__ = None;
3658 while let Some(k) = map_.next_key()? {
3659 match k {
3660 GeneratedField::Type => {
3661 if r#type__.is_some() {
3662 return Err(serde::de::Error::duplicate_field("type"));
3663 }
3664 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3665 }
3666 GeneratedField::DistKeyIndices => {
3667 if dist_key_indices__.is_some() {
3668 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3669 }
3670 dist_key_indices__ =
3671 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3672 .into_iter().map(|x| x.0).collect())
3673 ;
3674 }
3675 GeneratedField::OutputMapping => {
3676 if output_mapping__.is_some() {
3677 return Err(serde::de::Error::duplicate_field("outputMapping"));
3678 }
3679 output_mapping__ = map_.next_value()?;
3680 }
3681 GeneratedField::HashMapping => {
3682 if hash_mapping__.is_some() {
3683 return Err(serde::de::Error::duplicate_field("hashMapping"));
3684 }
3685 hash_mapping__ = map_.next_value()?;
3686 }
3687 GeneratedField::DispatcherId => {
3688 if dispatcher_id__.is_some() {
3689 return Err(serde::de::Error::duplicate_field("dispatcherId"));
3690 }
3691 dispatcher_id__ =
3692 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3693 ;
3694 }
3695 GeneratedField::DownstreamActorId => {
3696 if downstream_actor_id__.is_some() {
3697 return Err(serde::de::Error::duplicate_field("downstreamActorId"));
3698 }
3699 downstream_actor_id__ =
3700 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3701 .into_iter().map(|x| x.0).collect())
3702 ;
3703 }
3704 }
3705 }
3706 Ok(Dispatcher {
3707 r#type: r#type__.unwrap_or_default(),
3708 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3709 output_mapping: output_mapping__,
3710 hash_mapping: hash_mapping__,
3711 dispatcher_id: dispatcher_id__.unwrap_or_default(),
3712 downstream_actor_id: downstream_actor_id__.unwrap_or_default(),
3713 })
3714 }
3715 }
3716 deserializer.deserialize_struct("stream_plan.Dispatcher", FIELDS, GeneratedVisitor)
3717 }
3718}
3719impl serde::Serialize for DispatcherType {
3720 #[allow(deprecated)]
3721 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3722 where
3723 S: serde::Serializer,
3724 {
3725 let variant = match self {
3726 Self::Unspecified => "DISPATCHER_TYPE_UNSPECIFIED",
3727 Self::Hash => "DISPATCHER_TYPE_HASH",
3728 Self::Broadcast => "DISPATCHER_TYPE_BROADCAST",
3729 Self::Simple => "DISPATCHER_TYPE_SIMPLE",
3730 Self::NoShuffle => "DISPATCHER_TYPE_NO_SHUFFLE",
3731 };
3732 serializer.serialize_str(variant)
3733 }
3734}
3735impl<'de> serde::Deserialize<'de> for DispatcherType {
3736 #[allow(deprecated)]
3737 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3738 where
3739 D: serde::Deserializer<'de>,
3740 {
3741 const FIELDS: &[&str] = &[
3742 "DISPATCHER_TYPE_UNSPECIFIED",
3743 "DISPATCHER_TYPE_HASH",
3744 "DISPATCHER_TYPE_BROADCAST",
3745 "DISPATCHER_TYPE_SIMPLE",
3746 "DISPATCHER_TYPE_NO_SHUFFLE",
3747 ];
3748
3749 struct GeneratedVisitor;
3750
3751 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3752 type Value = DispatcherType;
3753
3754 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3755 write!(formatter, "expected one of: {:?}", &FIELDS)
3756 }
3757
3758 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3759 where
3760 E: serde::de::Error,
3761 {
3762 i32::try_from(v)
3763 .ok()
3764 .and_then(|x| x.try_into().ok())
3765 .ok_or_else(|| {
3766 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3767 })
3768 }
3769
3770 fn visit_u64<E>(self, v: u64) -> 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::Unsigned(v), &self)
3779 })
3780 }
3781
3782 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3783 where
3784 E: serde::de::Error,
3785 {
3786 match value {
3787 "DISPATCHER_TYPE_UNSPECIFIED" => Ok(DispatcherType::Unspecified),
3788 "DISPATCHER_TYPE_HASH" => Ok(DispatcherType::Hash),
3789 "DISPATCHER_TYPE_BROADCAST" => Ok(DispatcherType::Broadcast),
3790 "DISPATCHER_TYPE_SIMPLE" => Ok(DispatcherType::Simple),
3791 "DISPATCHER_TYPE_NO_SHUFFLE" => Ok(DispatcherType::NoShuffle),
3792 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3793 }
3794 }
3795 }
3796 deserializer.deserialize_any(GeneratedVisitor)
3797 }
3798}
3799impl serde::Serialize for Dispatchers {
3800 #[allow(deprecated)]
3801 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3802 where
3803 S: serde::Serializer,
3804 {
3805 use serde::ser::SerializeStruct;
3806 let mut len = 0;
3807 if !self.dispatchers.is_empty() {
3808 len += 1;
3809 }
3810 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatchers", len)?;
3811 if !self.dispatchers.is_empty() {
3812 struct_ser.serialize_field("dispatchers", &self.dispatchers)?;
3813 }
3814 struct_ser.end()
3815 }
3816}
3817impl<'de> serde::Deserialize<'de> for Dispatchers {
3818 #[allow(deprecated)]
3819 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3820 where
3821 D: serde::Deserializer<'de>,
3822 {
3823 const FIELDS: &[&str] = &[
3824 "dispatchers",
3825 ];
3826
3827 #[allow(clippy::enum_variant_names)]
3828 enum GeneratedField {
3829 Dispatchers,
3830 }
3831 impl<'de> serde::Deserialize<'de> for GeneratedField {
3832 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3833 where
3834 D: serde::Deserializer<'de>,
3835 {
3836 struct GeneratedVisitor;
3837
3838 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3839 type Value = GeneratedField;
3840
3841 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3842 write!(formatter, "expected one of: {:?}", &FIELDS)
3843 }
3844
3845 #[allow(unused_variables)]
3846 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3847 where
3848 E: serde::de::Error,
3849 {
3850 match value {
3851 "dispatchers" => Ok(GeneratedField::Dispatchers),
3852 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3853 }
3854 }
3855 }
3856 deserializer.deserialize_identifier(GeneratedVisitor)
3857 }
3858 }
3859 struct GeneratedVisitor;
3860 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3861 type Value = Dispatchers;
3862
3863 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3864 formatter.write_str("struct stream_plan.Dispatchers")
3865 }
3866
3867 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatchers, V::Error>
3868 where
3869 V: serde::de::MapAccess<'de>,
3870 {
3871 let mut dispatchers__ = None;
3872 while let Some(k) = map_.next_key()? {
3873 match k {
3874 GeneratedField::Dispatchers => {
3875 if dispatchers__.is_some() {
3876 return Err(serde::de::Error::duplicate_field("dispatchers"));
3877 }
3878 dispatchers__ = Some(map_.next_value()?);
3879 }
3880 }
3881 }
3882 Ok(Dispatchers {
3883 dispatchers: dispatchers__.unwrap_or_default(),
3884 })
3885 }
3886 }
3887 deserializer.deserialize_struct("stream_plan.Dispatchers", FIELDS, GeneratedVisitor)
3888 }
3889}
3890impl serde::Serialize for DmlNode {
3891 #[allow(deprecated)]
3892 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3893 where
3894 S: serde::Serializer,
3895 {
3896 use serde::ser::SerializeStruct;
3897 let mut len = 0;
3898 if self.table_id != 0 {
3899 len += 1;
3900 }
3901 if self.table_version_id != 0 {
3902 len += 1;
3903 }
3904 if !self.column_descs.is_empty() {
3905 len += 1;
3906 }
3907 if self.rate_limit.is_some() {
3908 len += 1;
3909 }
3910 let mut struct_ser = serializer.serialize_struct("stream_plan.DmlNode", len)?;
3911 if self.table_id != 0 {
3912 struct_ser.serialize_field("tableId", &self.table_id)?;
3913 }
3914 if self.table_version_id != 0 {
3915 #[allow(clippy::needless_borrow)]
3916 #[allow(clippy::needless_borrows_for_generic_args)]
3917 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
3918 }
3919 if !self.column_descs.is_empty() {
3920 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
3921 }
3922 if let Some(v) = self.rate_limit.as_ref() {
3923 struct_ser.serialize_field("rateLimit", v)?;
3924 }
3925 struct_ser.end()
3926 }
3927}
3928impl<'de> serde::Deserialize<'de> for DmlNode {
3929 #[allow(deprecated)]
3930 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3931 where
3932 D: serde::Deserializer<'de>,
3933 {
3934 const FIELDS: &[&str] = &[
3935 "table_id",
3936 "tableId",
3937 "table_version_id",
3938 "tableVersionId",
3939 "column_descs",
3940 "columnDescs",
3941 "rate_limit",
3942 "rateLimit",
3943 ];
3944
3945 #[allow(clippy::enum_variant_names)]
3946 enum GeneratedField {
3947 TableId,
3948 TableVersionId,
3949 ColumnDescs,
3950 RateLimit,
3951 }
3952 impl<'de> serde::Deserialize<'de> for GeneratedField {
3953 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3954 where
3955 D: serde::Deserializer<'de>,
3956 {
3957 struct GeneratedVisitor;
3958
3959 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3960 type Value = GeneratedField;
3961
3962 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3963 write!(formatter, "expected one of: {:?}", &FIELDS)
3964 }
3965
3966 #[allow(unused_variables)]
3967 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3968 where
3969 E: serde::de::Error,
3970 {
3971 match value {
3972 "tableId" | "table_id" => Ok(GeneratedField::TableId),
3973 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
3974 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
3975 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
3976 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3977 }
3978 }
3979 }
3980 deserializer.deserialize_identifier(GeneratedVisitor)
3981 }
3982 }
3983 struct GeneratedVisitor;
3984 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3985 type Value = DmlNode;
3986
3987 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3988 formatter.write_str("struct stream_plan.DmlNode")
3989 }
3990
3991 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DmlNode, V::Error>
3992 where
3993 V: serde::de::MapAccess<'de>,
3994 {
3995 let mut table_id__ = None;
3996 let mut table_version_id__ = None;
3997 let mut column_descs__ = None;
3998 let mut rate_limit__ = None;
3999 while let Some(k) = map_.next_key()? {
4000 match k {
4001 GeneratedField::TableId => {
4002 if table_id__.is_some() {
4003 return Err(serde::de::Error::duplicate_field("tableId"));
4004 }
4005 table_id__ =
4006 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4007 ;
4008 }
4009 GeneratedField::TableVersionId => {
4010 if table_version_id__.is_some() {
4011 return Err(serde::de::Error::duplicate_field("tableVersionId"));
4012 }
4013 table_version_id__ =
4014 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4015 ;
4016 }
4017 GeneratedField::ColumnDescs => {
4018 if column_descs__.is_some() {
4019 return Err(serde::de::Error::duplicate_field("columnDescs"));
4020 }
4021 column_descs__ = Some(map_.next_value()?);
4022 }
4023 GeneratedField::RateLimit => {
4024 if rate_limit__.is_some() {
4025 return Err(serde::de::Error::duplicate_field("rateLimit"));
4026 }
4027 rate_limit__ =
4028 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4029 ;
4030 }
4031 }
4032 }
4033 Ok(DmlNode {
4034 table_id: table_id__.unwrap_or_default(),
4035 table_version_id: table_version_id__.unwrap_or_default(),
4036 column_descs: column_descs__.unwrap_or_default(),
4037 rate_limit: rate_limit__,
4038 })
4039 }
4040 }
4041 deserializer.deserialize_struct("stream_plan.DmlNode", FIELDS, GeneratedVisitor)
4042 }
4043}
4044impl serde::Serialize for DropSubscriptionsMutation {
4045 #[allow(deprecated)]
4046 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4047 where
4048 S: serde::Serializer,
4049 {
4050 use serde::ser::SerializeStruct;
4051 let mut len = 0;
4052 if !self.info.is_empty() {
4053 len += 1;
4054 }
4055 let mut struct_ser = serializer.serialize_struct("stream_plan.DropSubscriptionsMutation", len)?;
4056 if !self.info.is_empty() {
4057 struct_ser.serialize_field("info", &self.info)?;
4058 }
4059 struct_ser.end()
4060 }
4061}
4062impl<'de> serde::Deserialize<'de> for DropSubscriptionsMutation {
4063 #[allow(deprecated)]
4064 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4065 where
4066 D: serde::Deserializer<'de>,
4067 {
4068 const FIELDS: &[&str] = &[
4069 "info",
4070 ];
4071
4072 #[allow(clippy::enum_variant_names)]
4073 enum GeneratedField {
4074 Info,
4075 }
4076 impl<'de> serde::Deserialize<'de> for GeneratedField {
4077 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4078 where
4079 D: serde::Deserializer<'de>,
4080 {
4081 struct GeneratedVisitor;
4082
4083 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4084 type Value = GeneratedField;
4085
4086 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4087 write!(formatter, "expected one of: {:?}", &FIELDS)
4088 }
4089
4090 #[allow(unused_variables)]
4091 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4092 where
4093 E: serde::de::Error,
4094 {
4095 match value {
4096 "info" => Ok(GeneratedField::Info),
4097 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4098 }
4099 }
4100 }
4101 deserializer.deserialize_identifier(GeneratedVisitor)
4102 }
4103 }
4104 struct GeneratedVisitor;
4105 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4106 type Value = DropSubscriptionsMutation;
4107
4108 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4109 formatter.write_str("struct stream_plan.DropSubscriptionsMutation")
4110 }
4111
4112 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionsMutation, V::Error>
4113 where
4114 V: serde::de::MapAccess<'de>,
4115 {
4116 let mut info__ = None;
4117 while let Some(k) = map_.next_key()? {
4118 match k {
4119 GeneratedField::Info => {
4120 if info__.is_some() {
4121 return Err(serde::de::Error::duplicate_field("info"));
4122 }
4123 info__ = Some(map_.next_value()?);
4124 }
4125 }
4126 }
4127 Ok(DropSubscriptionsMutation {
4128 info: info__.unwrap_or_default(),
4129 })
4130 }
4131 }
4132 deserializer.deserialize_struct("stream_plan.DropSubscriptionsMutation", FIELDS, GeneratedVisitor)
4133 }
4134}
4135impl serde::Serialize for DynamicFilterNode {
4136 #[allow(deprecated)]
4137 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4138 where
4139 S: serde::Serializer,
4140 {
4141 use serde::ser::SerializeStruct;
4142 let mut len = 0;
4143 if self.left_key != 0 {
4144 len += 1;
4145 }
4146 if self.condition.is_some() {
4147 len += 1;
4148 }
4149 if self.left_table.is_some() {
4150 len += 1;
4151 }
4152 if self.right_table.is_some() {
4153 len += 1;
4154 }
4155 if self.condition_always_relax {
4156 len += 1;
4157 }
4158 let mut struct_ser = serializer.serialize_struct("stream_plan.DynamicFilterNode", len)?;
4159 if self.left_key != 0 {
4160 struct_ser.serialize_field("leftKey", &self.left_key)?;
4161 }
4162 if let Some(v) = self.condition.as_ref() {
4163 struct_ser.serialize_field("condition", v)?;
4164 }
4165 if let Some(v) = self.left_table.as_ref() {
4166 struct_ser.serialize_field("leftTable", v)?;
4167 }
4168 if let Some(v) = self.right_table.as_ref() {
4169 struct_ser.serialize_field("rightTable", v)?;
4170 }
4171 if self.condition_always_relax {
4172 struct_ser.serialize_field("conditionAlwaysRelax", &self.condition_always_relax)?;
4173 }
4174 struct_ser.end()
4175 }
4176}
4177impl<'de> serde::Deserialize<'de> for DynamicFilterNode {
4178 #[allow(deprecated)]
4179 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4180 where
4181 D: serde::Deserializer<'de>,
4182 {
4183 const FIELDS: &[&str] = &[
4184 "left_key",
4185 "leftKey",
4186 "condition",
4187 "left_table",
4188 "leftTable",
4189 "right_table",
4190 "rightTable",
4191 "condition_always_relax",
4192 "conditionAlwaysRelax",
4193 ];
4194
4195 #[allow(clippy::enum_variant_names)]
4196 enum GeneratedField {
4197 LeftKey,
4198 Condition,
4199 LeftTable,
4200 RightTable,
4201 ConditionAlwaysRelax,
4202 }
4203 impl<'de> serde::Deserialize<'de> for GeneratedField {
4204 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4205 where
4206 D: serde::Deserializer<'de>,
4207 {
4208 struct GeneratedVisitor;
4209
4210 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4211 type Value = GeneratedField;
4212
4213 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4214 write!(formatter, "expected one of: {:?}", &FIELDS)
4215 }
4216
4217 #[allow(unused_variables)]
4218 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4219 where
4220 E: serde::de::Error,
4221 {
4222 match value {
4223 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
4224 "condition" => Ok(GeneratedField::Condition),
4225 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
4226 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
4227 "conditionAlwaysRelax" | "condition_always_relax" => Ok(GeneratedField::ConditionAlwaysRelax),
4228 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4229 }
4230 }
4231 }
4232 deserializer.deserialize_identifier(GeneratedVisitor)
4233 }
4234 }
4235 struct GeneratedVisitor;
4236 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4237 type Value = DynamicFilterNode;
4238
4239 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4240 formatter.write_str("struct stream_plan.DynamicFilterNode")
4241 }
4242
4243 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DynamicFilterNode, V::Error>
4244 where
4245 V: serde::de::MapAccess<'de>,
4246 {
4247 let mut left_key__ = None;
4248 let mut condition__ = None;
4249 let mut left_table__ = None;
4250 let mut right_table__ = None;
4251 let mut condition_always_relax__ = None;
4252 while let Some(k) = map_.next_key()? {
4253 match k {
4254 GeneratedField::LeftKey => {
4255 if left_key__.is_some() {
4256 return Err(serde::de::Error::duplicate_field("leftKey"));
4257 }
4258 left_key__ =
4259 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4260 ;
4261 }
4262 GeneratedField::Condition => {
4263 if condition__.is_some() {
4264 return Err(serde::de::Error::duplicate_field("condition"));
4265 }
4266 condition__ = map_.next_value()?;
4267 }
4268 GeneratedField::LeftTable => {
4269 if left_table__.is_some() {
4270 return Err(serde::de::Error::duplicate_field("leftTable"));
4271 }
4272 left_table__ = map_.next_value()?;
4273 }
4274 GeneratedField::RightTable => {
4275 if right_table__.is_some() {
4276 return Err(serde::de::Error::duplicate_field("rightTable"));
4277 }
4278 right_table__ = map_.next_value()?;
4279 }
4280 GeneratedField::ConditionAlwaysRelax => {
4281 if condition_always_relax__.is_some() {
4282 return Err(serde::de::Error::duplicate_field("conditionAlwaysRelax"));
4283 }
4284 condition_always_relax__ = Some(map_.next_value()?);
4285 }
4286 }
4287 }
4288 Ok(DynamicFilterNode {
4289 left_key: left_key__.unwrap_or_default(),
4290 condition: condition__,
4291 left_table: left_table__,
4292 right_table: right_table__,
4293 condition_always_relax: condition_always_relax__.unwrap_or_default(),
4294 })
4295 }
4296 }
4297 deserializer.deserialize_struct("stream_plan.DynamicFilterNode", FIELDS, GeneratedVisitor)
4298 }
4299}
4300impl serde::Serialize for EowcGapFillNode {
4301 #[allow(deprecated)]
4302 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4303 where
4304 S: serde::Serializer,
4305 {
4306 use serde::ser::SerializeStruct;
4307 let mut len = 0;
4308 if self.time_column_index != 0 {
4309 len += 1;
4310 }
4311 if self.interval.is_some() {
4312 len += 1;
4313 }
4314 if !self.fill_columns.is_empty() {
4315 len += 1;
4316 }
4317 if !self.fill_strategies.is_empty() {
4318 len += 1;
4319 }
4320 if self.buffer_table.is_some() {
4321 len += 1;
4322 }
4323 if self.prev_row_table.is_some() {
4324 len += 1;
4325 }
4326 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcGapFillNode", len)?;
4327 if self.time_column_index != 0 {
4328 struct_ser.serialize_field("timeColumnIndex", &self.time_column_index)?;
4329 }
4330 if let Some(v) = self.interval.as_ref() {
4331 struct_ser.serialize_field("interval", v)?;
4332 }
4333 if !self.fill_columns.is_empty() {
4334 struct_ser.serialize_field("fillColumns", &self.fill_columns)?;
4335 }
4336 if !self.fill_strategies.is_empty() {
4337 struct_ser.serialize_field("fillStrategies", &self.fill_strategies)?;
4338 }
4339 if let Some(v) = self.buffer_table.as_ref() {
4340 struct_ser.serialize_field("bufferTable", v)?;
4341 }
4342 if let Some(v) = self.prev_row_table.as_ref() {
4343 struct_ser.serialize_field("prevRowTable", v)?;
4344 }
4345 struct_ser.end()
4346 }
4347}
4348impl<'de> serde::Deserialize<'de> for EowcGapFillNode {
4349 #[allow(deprecated)]
4350 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4351 where
4352 D: serde::Deserializer<'de>,
4353 {
4354 const FIELDS: &[&str] = &[
4355 "time_column_index",
4356 "timeColumnIndex",
4357 "interval",
4358 "fill_columns",
4359 "fillColumns",
4360 "fill_strategies",
4361 "fillStrategies",
4362 "buffer_table",
4363 "bufferTable",
4364 "prev_row_table",
4365 "prevRowTable",
4366 ];
4367
4368 #[allow(clippy::enum_variant_names)]
4369 enum GeneratedField {
4370 TimeColumnIndex,
4371 Interval,
4372 FillColumns,
4373 FillStrategies,
4374 BufferTable,
4375 PrevRowTable,
4376 }
4377 impl<'de> serde::Deserialize<'de> for GeneratedField {
4378 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4379 where
4380 D: serde::Deserializer<'de>,
4381 {
4382 struct GeneratedVisitor;
4383
4384 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4385 type Value = GeneratedField;
4386
4387 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4388 write!(formatter, "expected one of: {:?}", &FIELDS)
4389 }
4390
4391 #[allow(unused_variables)]
4392 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4393 where
4394 E: serde::de::Error,
4395 {
4396 match value {
4397 "timeColumnIndex" | "time_column_index" => Ok(GeneratedField::TimeColumnIndex),
4398 "interval" => Ok(GeneratedField::Interval),
4399 "fillColumns" | "fill_columns" => Ok(GeneratedField::FillColumns),
4400 "fillStrategies" | "fill_strategies" => Ok(GeneratedField::FillStrategies),
4401 "bufferTable" | "buffer_table" => Ok(GeneratedField::BufferTable),
4402 "prevRowTable" | "prev_row_table" => Ok(GeneratedField::PrevRowTable),
4403 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4404 }
4405 }
4406 }
4407 deserializer.deserialize_identifier(GeneratedVisitor)
4408 }
4409 }
4410 struct GeneratedVisitor;
4411 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4412 type Value = EowcGapFillNode;
4413
4414 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4415 formatter.write_str("struct stream_plan.EowcGapFillNode")
4416 }
4417
4418 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcGapFillNode, V::Error>
4419 where
4420 V: serde::de::MapAccess<'de>,
4421 {
4422 let mut time_column_index__ = None;
4423 let mut interval__ = None;
4424 let mut fill_columns__ = None;
4425 let mut fill_strategies__ = None;
4426 let mut buffer_table__ = None;
4427 let mut prev_row_table__ = None;
4428 while let Some(k) = map_.next_key()? {
4429 match k {
4430 GeneratedField::TimeColumnIndex => {
4431 if time_column_index__.is_some() {
4432 return Err(serde::de::Error::duplicate_field("timeColumnIndex"));
4433 }
4434 time_column_index__ =
4435 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4436 ;
4437 }
4438 GeneratedField::Interval => {
4439 if interval__.is_some() {
4440 return Err(serde::de::Error::duplicate_field("interval"));
4441 }
4442 interval__ = map_.next_value()?;
4443 }
4444 GeneratedField::FillColumns => {
4445 if fill_columns__.is_some() {
4446 return Err(serde::de::Error::duplicate_field("fillColumns"));
4447 }
4448 fill_columns__ =
4449 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4450 .into_iter().map(|x| x.0).collect())
4451 ;
4452 }
4453 GeneratedField::FillStrategies => {
4454 if fill_strategies__.is_some() {
4455 return Err(serde::de::Error::duplicate_field("fillStrategies"));
4456 }
4457 fill_strategies__ = Some(map_.next_value()?);
4458 }
4459 GeneratedField::BufferTable => {
4460 if buffer_table__.is_some() {
4461 return Err(serde::de::Error::duplicate_field("bufferTable"));
4462 }
4463 buffer_table__ = map_.next_value()?;
4464 }
4465 GeneratedField::PrevRowTable => {
4466 if prev_row_table__.is_some() {
4467 return Err(serde::de::Error::duplicate_field("prevRowTable"));
4468 }
4469 prev_row_table__ = map_.next_value()?;
4470 }
4471 }
4472 }
4473 Ok(EowcGapFillNode {
4474 time_column_index: time_column_index__.unwrap_or_default(),
4475 interval: interval__,
4476 fill_columns: fill_columns__.unwrap_or_default(),
4477 fill_strategies: fill_strategies__.unwrap_or_default(),
4478 buffer_table: buffer_table__,
4479 prev_row_table: prev_row_table__,
4480 })
4481 }
4482 }
4483 deserializer.deserialize_struct("stream_plan.EowcGapFillNode", FIELDS, GeneratedVisitor)
4484 }
4485}
4486impl serde::Serialize for EowcOverWindowNode {
4487 #[allow(deprecated)]
4488 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4489 where
4490 S: serde::Serializer,
4491 {
4492 use serde::ser::SerializeStruct;
4493 let mut len = 0;
4494 if !self.calls.is_empty() {
4495 len += 1;
4496 }
4497 if !self.partition_by.is_empty() {
4498 len += 1;
4499 }
4500 if !self.order_by.is_empty() {
4501 len += 1;
4502 }
4503 if self.state_table.is_some() {
4504 len += 1;
4505 }
4506 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcOverWindowNode", len)?;
4507 if !self.calls.is_empty() {
4508 struct_ser.serialize_field("calls", &self.calls)?;
4509 }
4510 if !self.partition_by.is_empty() {
4511 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
4512 }
4513 if !self.order_by.is_empty() {
4514 struct_ser.serialize_field("orderBy", &self.order_by)?;
4515 }
4516 if let Some(v) = self.state_table.as_ref() {
4517 struct_ser.serialize_field("stateTable", v)?;
4518 }
4519 struct_ser.end()
4520 }
4521}
4522impl<'de> serde::Deserialize<'de> for EowcOverWindowNode {
4523 #[allow(deprecated)]
4524 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4525 where
4526 D: serde::Deserializer<'de>,
4527 {
4528 const FIELDS: &[&str] = &[
4529 "calls",
4530 "partition_by",
4531 "partitionBy",
4532 "order_by",
4533 "orderBy",
4534 "state_table",
4535 "stateTable",
4536 ];
4537
4538 #[allow(clippy::enum_variant_names)]
4539 enum GeneratedField {
4540 Calls,
4541 PartitionBy,
4542 OrderBy,
4543 StateTable,
4544 }
4545 impl<'de> serde::Deserialize<'de> for GeneratedField {
4546 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4547 where
4548 D: serde::Deserializer<'de>,
4549 {
4550 struct GeneratedVisitor;
4551
4552 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4553 type Value = GeneratedField;
4554
4555 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4556 write!(formatter, "expected one of: {:?}", &FIELDS)
4557 }
4558
4559 #[allow(unused_variables)]
4560 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4561 where
4562 E: serde::de::Error,
4563 {
4564 match value {
4565 "calls" => Ok(GeneratedField::Calls),
4566 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
4567 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
4568 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
4569 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4570 }
4571 }
4572 }
4573 deserializer.deserialize_identifier(GeneratedVisitor)
4574 }
4575 }
4576 struct GeneratedVisitor;
4577 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4578 type Value = EowcOverWindowNode;
4579
4580 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4581 formatter.write_str("struct stream_plan.EowcOverWindowNode")
4582 }
4583
4584 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcOverWindowNode, V::Error>
4585 where
4586 V: serde::de::MapAccess<'de>,
4587 {
4588 let mut calls__ = None;
4589 let mut partition_by__ = None;
4590 let mut order_by__ = None;
4591 let mut state_table__ = None;
4592 while let Some(k) = map_.next_key()? {
4593 match k {
4594 GeneratedField::Calls => {
4595 if calls__.is_some() {
4596 return Err(serde::de::Error::duplicate_field("calls"));
4597 }
4598 calls__ = Some(map_.next_value()?);
4599 }
4600 GeneratedField::PartitionBy => {
4601 if partition_by__.is_some() {
4602 return Err(serde::de::Error::duplicate_field("partitionBy"));
4603 }
4604 partition_by__ =
4605 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4606 .into_iter().map(|x| x.0).collect())
4607 ;
4608 }
4609 GeneratedField::OrderBy => {
4610 if order_by__.is_some() {
4611 return Err(serde::de::Error::duplicate_field("orderBy"));
4612 }
4613 order_by__ = Some(map_.next_value()?);
4614 }
4615 GeneratedField::StateTable => {
4616 if state_table__.is_some() {
4617 return Err(serde::de::Error::duplicate_field("stateTable"));
4618 }
4619 state_table__ = map_.next_value()?;
4620 }
4621 }
4622 }
4623 Ok(EowcOverWindowNode {
4624 calls: calls__.unwrap_or_default(),
4625 partition_by: partition_by__.unwrap_or_default(),
4626 order_by: order_by__.unwrap_or_default(),
4627 state_table: state_table__,
4628 })
4629 }
4630 }
4631 deserializer.deserialize_struct("stream_plan.EowcOverWindowNode", FIELDS, GeneratedVisitor)
4632 }
4633}
4634impl serde::Serialize for ExchangeNode {
4635 #[allow(deprecated)]
4636 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4637 where
4638 S: serde::Serializer,
4639 {
4640 use serde::ser::SerializeStruct;
4641 let mut len = 0;
4642 if self.strategy.is_some() {
4643 len += 1;
4644 }
4645 let mut struct_ser = serializer.serialize_struct("stream_plan.ExchangeNode", len)?;
4646 if let Some(v) = self.strategy.as_ref() {
4647 struct_ser.serialize_field("strategy", v)?;
4648 }
4649 struct_ser.end()
4650 }
4651}
4652impl<'de> serde::Deserialize<'de> for ExchangeNode {
4653 #[allow(deprecated)]
4654 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4655 where
4656 D: serde::Deserializer<'de>,
4657 {
4658 const FIELDS: &[&str] = &[
4659 "strategy",
4660 ];
4661
4662 #[allow(clippy::enum_variant_names)]
4663 enum GeneratedField {
4664 Strategy,
4665 }
4666 impl<'de> serde::Deserialize<'de> for GeneratedField {
4667 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4668 where
4669 D: serde::Deserializer<'de>,
4670 {
4671 struct GeneratedVisitor;
4672
4673 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4674 type Value = GeneratedField;
4675
4676 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4677 write!(formatter, "expected one of: {:?}", &FIELDS)
4678 }
4679
4680 #[allow(unused_variables)]
4681 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4682 where
4683 E: serde::de::Error,
4684 {
4685 match value {
4686 "strategy" => Ok(GeneratedField::Strategy),
4687 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4688 }
4689 }
4690 }
4691 deserializer.deserialize_identifier(GeneratedVisitor)
4692 }
4693 }
4694 struct GeneratedVisitor;
4695 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4696 type Value = ExchangeNode;
4697
4698 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4699 formatter.write_str("struct stream_plan.ExchangeNode")
4700 }
4701
4702 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExchangeNode, V::Error>
4703 where
4704 V: serde::de::MapAccess<'de>,
4705 {
4706 let mut strategy__ = None;
4707 while let Some(k) = map_.next_key()? {
4708 match k {
4709 GeneratedField::Strategy => {
4710 if strategy__.is_some() {
4711 return Err(serde::de::Error::duplicate_field("strategy"));
4712 }
4713 strategy__ = map_.next_value()?;
4714 }
4715 }
4716 }
4717 Ok(ExchangeNode {
4718 strategy: strategy__,
4719 })
4720 }
4721 }
4722 deserializer.deserialize_struct("stream_plan.ExchangeNode", FIELDS, GeneratedVisitor)
4723 }
4724}
4725impl serde::Serialize for ExpandNode {
4726 #[allow(deprecated)]
4727 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4728 where
4729 S: serde::Serializer,
4730 {
4731 use serde::ser::SerializeStruct;
4732 let mut len = 0;
4733 if !self.column_subsets.is_empty() {
4734 len += 1;
4735 }
4736 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode", len)?;
4737 if !self.column_subsets.is_empty() {
4738 struct_ser.serialize_field("columnSubsets", &self.column_subsets)?;
4739 }
4740 struct_ser.end()
4741 }
4742}
4743impl<'de> serde::Deserialize<'de> for ExpandNode {
4744 #[allow(deprecated)]
4745 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4746 where
4747 D: serde::Deserializer<'de>,
4748 {
4749 const FIELDS: &[&str] = &[
4750 "column_subsets",
4751 "columnSubsets",
4752 ];
4753
4754 #[allow(clippy::enum_variant_names)]
4755 enum GeneratedField {
4756 ColumnSubsets,
4757 }
4758 impl<'de> serde::Deserialize<'de> for GeneratedField {
4759 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4760 where
4761 D: serde::Deserializer<'de>,
4762 {
4763 struct GeneratedVisitor;
4764
4765 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4766 type Value = GeneratedField;
4767
4768 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4769 write!(formatter, "expected one of: {:?}", &FIELDS)
4770 }
4771
4772 #[allow(unused_variables)]
4773 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4774 where
4775 E: serde::de::Error,
4776 {
4777 match value {
4778 "columnSubsets" | "column_subsets" => Ok(GeneratedField::ColumnSubsets),
4779 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4780 }
4781 }
4782 }
4783 deserializer.deserialize_identifier(GeneratedVisitor)
4784 }
4785 }
4786 struct GeneratedVisitor;
4787 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4788 type Value = ExpandNode;
4789
4790 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4791 formatter.write_str("struct stream_plan.ExpandNode")
4792 }
4793
4794 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpandNode, V::Error>
4795 where
4796 V: serde::de::MapAccess<'de>,
4797 {
4798 let mut column_subsets__ = None;
4799 while let Some(k) = map_.next_key()? {
4800 match k {
4801 GeneratedField::ColumnSubsets => {
4802 if column_subsets__.is_some() {
4803 return Err(serde::de::Error::duplicate_field("columnSubsets"));
4804 }
4805 column_subsets__ = Some(map_.next_value()?);
4806 }
4807 }
4808 }
4809 Ok(ExpandNode {
4810 column_subsets: column_subsets__.unwrap_or_default(),
4811 })
4812 }
4813 }
4814 deserializer.deserialize_struct("stream_plan.ExpandNode", FIELDS, GeneratedVisitor)
4815 }
4816}
4817impl serde::Serialize for expand_node::Subset {
4818 #[allow(deprecated)]
4819 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4820 where
4821 S: serde::Serializer,
4822 {
4823 use serde::ser::SerializeStruct;
4824 let mut len = 0;
4825 if !self.column_indices.is_empty() {
4826 len += 1;
4827 }
4828 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode.Subset", len)?;
4829 if !self.column_indices.is_empty() {
4830 struct_ser.serialize_field("columnIndices", &self.column_indices)?;
4831 }
4832 struct_ser.end()
4833 }
4834}
4835impl<'de> serde::Deserialize<'de> for expand_node::Subset {
4836 #[allow(deprecated)]
4837 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4838 where
4839 D: serde::Deserializer<'de>,
4840 {
4841 const FIELDS: &[&str] = &[
4842 "column_indices",
4843 "columnIndices",
4844 ];
4845
4846 #[allow(clippy::enum_variant_names)]
4847 enum GeneratedField {
4848 ColumnIndices,
4849 }
4850 impl<'de> serde::Deserialize<'de> for GeneratedField {
4851 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4852 where
4853 D: serde::Deserializer<'de>,
4854 {
4855 struct GeneratedVisitor;
4856
4857 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4858 type Value = GeneratedField;
4859
4860 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4861 write!(formatter, "expected one of: {:?}", &FIELDS)
4862 }
4863
4864 #[allow(unused_variables)]
4865 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4866 where
4867 E: serde::de::Error,
4868 {
4869 match value {
4870 "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
4871 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4872 }
4873 }
4874 }
4875 deserializer.deserialize_identifier(GeneratedVisitor)
4876 }
4877 }
4878 struct GeneratedVisitor;
4879 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4880 type Value = expand_node::Subset;
4881
4882 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4883 formatter.write_str("struct stream_plan.ExpandNode.Subset")
4884 }
4885
4886 fn visit_map<V>(self, mut map_: V) -> std::result::Result<expand_node::Subset, V::Error>
4887 where
4888 V: serde::de::MapAccess<'de>,
4889 {
4890 let mut column_indices__ = None;
4891 while let Some(k) = map_.next_key()? {
4892 match k {
4893 GeneratedField::ColumnIndices => {
4894 if column_indices__.is_some() {
4895 return Err(serde::de::Error::duplicate_field("columnIndices"));
4896 }
4897 column_indices__ =
4898 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4899 .into_iter().map(|x| x.0).collect())
4900 ;
4901 }
4902 }
4903 }
4904 Ok(expand_node::Subset {
4905 column_indices: column_indices__.unwrap_or_default(),
4906 })
4907 }
4908 }
4909 deserializer.deserialize_struct("stream_plan.ExpandNode.Subset", FIELDS, GeneratedVisitor)
4910 }
4911}
4912impl serde::Serialize for FilterNode {
4913 #[allow(deprecated)]
4914 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4915 where
4916 S: serde::Serializer,
4917 {
4918 use serde::ser::SerializeStruct;
4919 let mut len = 0;
4920 if self.search_condition.is_some() {
4921 len += 1;
4922 }
4923 let mut struct_ser = serializer.serialize_struct("stream_plan.FilterNode", len)?;
4924 if let Some(v) = self.search_condition.as_ref() {
4925 struct_ser.serialize_field("searchCondition", v)?;
4926 }
4927 struct_ser.end()
4928 }
4929}
4930impl<'de> serde::Deserialize<'de> for FilterNode {
4931 #[allow(deprecated)]
4932 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4933 where
4934 D: serde::Deserializer<'de>,
4935 {
4936 const FIELDS: &[&str] = &[
4937 "search_condition",
4938 "searchCondition",
4939 ];
4940
4941 #[allow(clippy::enum_variant_names)]
4942 enum GeneratedField {
4943 SearchCondition,
4944 }
4945 impl<'de> serde::Deserialize<'de> for GeneratedField {
4946 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4947 where
4948 D: serde::Deserializer<'de>,
4949 {
4950 struct GeneratedVisitor;
4951
4952 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4953 type Value = GeneratedField;
4954
4955 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4956 write!(formatter, "expected one of: {:?}", &FIELDS)
4957 }
4958
4959 #[allow(unused_variables)]
4960 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4961 where
4962 E: serde::de::Error,
4963 {
4964 match value {
4965 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
4966 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4967 }
4968 }
4969 }
4970 deserializer.deserialize_identifier(GeneratedVisitor)
4971 }
4972 }
4973 struct GeneratedVisitor;
4974 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4975 type Value = FilterNode;
4976
4977 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4978 formatter.write_str("struct stream_plan.FilterNode")
4979 }
4980
4981 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FilterNode, V::Error>
4982 where
4983 V: serde::de::MapAccess<'de>,
4984 {
4985 let mut search_condition__ = None;
4986 while let Some(k) = map_.next_key()? {
4987 match k {
4988 GeneratedField::SearchCondition => {
4989 if search_condition__.is_some() {
4990 return Err(serde::de::Error::duplicate_field("searchCondition"));
4991 }
4992 search_condition__ = map_.next_value()?;
4993 }
4994 }
4995 }
4996 Ok(FilterNode {
4997 search_condition: search_condition__,
4998 })
4999 }
5000 }
5001 deserializer.deserialize_struct("stream_plan.FilterNode", FIELDS, GeneratedVisitor)
5002 }
5003}
5004impl serde::Serialize for GapFillNode {
5005 #[allow(deprecated)]
5006 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5007 where
5008 S: serde::Serializer,
5009 {
5010 use serde::ser::SerializeStruct;
5011 let mut len = 0;
5012 if self.time_column_index != 0 {
5013 len += 1;
5014 }
5015 if self.interval.is_some() {
5016 len += 1;
5017 }
5018 if !self.fill_columns.is_empty() {
5019 len += 1;
5020 }
5021 if !self.fill_strategies.is_empty() {
5022 len += 1;
5023 }
5024 if self.state_table.is_some() {
5025 len += 1;
5026 }
5027 let mut struct_ser = serializer.serialize_struct("stream_plan.GapFillNode", len)?;
5028 if self.time_column_index != 0 {
5029 struct_ser.serialize_field("timeColumnIndex", &self.time_column_index)?;
5030 }
5031 if let Some(v) = self.interval.as_ref() {
5032 struct_ser.serialize_field("interval", v)?;
5033 }
5034 if !self.fill_columns.is_empty() {
5035 struct_ser.serialize_field("fillColumns", &self.fill_columns)?;
5036 }
5037 if !self.fill_strategies.is_empty() {
5038 struct_ser.serialize_field("fillStrategies", &self.fill_strategies)?;
5039 }
5040 if let Some(v) = self.state_table.as_ref() {
5041 struct_ser.serialize_field("stateTable", v)?;
5042 }
5043 struct_ser.end()
5044 }
5045}
5046impl<'de> serde::Deserialize<'de> for GapFillNode {
5047 #[allow(deprecated)]
5048 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5049 where
5050 D: serde::Deserializer<'de>,
5051 {
5052 const FIELDS: &[&str] = &[
5053 "time_column_index",
5054 "timeColumnIndex",
5055 "interval",
5056 "fill_columns",
5057 "fillColumns",
5058 "fill_strategies",
5059 "fillStrategies",
5060 "state_table",
5061 "stateTable",
5062 ];
5063
5064 #[allow(clippy::enum_variant_names)]
5065 enum GeneratedField {
5066 TimeColumnIndex,
5067 Interval,
5068 FillColumns,
5069 FillStrategies,
5070 StateTable,
5071 }
5072 impl<'de> serde::Deserialize<'de> for GeneratedField {
5073 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5074 where
5075 D: serde::Deserializer<'de>,
5076 {
5077 struct GeneratedVisitor;
5078
5079 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5080 type Value = GeneratedField;
5081
5082 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5083 write!(formatter, "expected one of: {:?}", &FIELDS)
5084 }
5085
5086 #[allow(unused_variables)]
5087 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5088 where
5089 E: serde::de::Error,
5090 {
5091 match value {
5092 "timeColumnIndex" | "time_column_index" => Ok(GeneratedField::TimeColumnIndex),
5093 "interval" => Ok(GeneratedField::Interval),
5094 "fillColumns" | "fill_columns" => Ok(GeneratedField::FillColumns),
5095 "fillStrategies" | "fill_strategies" => Ok(GeneratedField::FillStrategies),
5096 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
5097 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5098 }
5099 }
5100 }
5101 deserializer.deserialize_identifier(GeneratedVisitor)
5102 }
5103 }
5104 struct GeneratedVisitor;
5105 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5106 type Value = GapFillNode;
5107
5108 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5109 formatter.write_str("struct stream_plan.GapFillNode")
5110 }
5111
5112 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GapFillNode, V::Error>
5113 where
5114 V: serde::de::MapAccess<'de>,
5115 {
5116 let mut time_column_index__ = None;
5117 let mut interval__ = None;
5118 let mut fill_columns__ = None;
5119 let mut fill_strategies__ = None;
5120 let mut state_table__ = None;
5121 while let Some(k) = map_.next_key()? {
5122 match k {
5123 GeneratedField::TimeColumnIndex => {
5124 if time_column_index__.is_some() {
5125 return Err(serde::de::Error::duplicate_field("timeColumnIndex"));
5126 }
5127 time_column_index__ =
5128 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5129 ;
5130 }
5131 GeneratedField::Interval => {
5132 if interval__.is_some() {
5133 return Err(serde::de::Error::duplicate_field("interval"));
5134 }
5135 interval__ = map_.next_value()?;
5136 }
5137 GeneratedField::FillColumns => {
5138 if fill_columns__.is_some() {
5139 return Err(serde::de::Error::duplicate_field("fillColumns"));
5140 }
5141 fill_columns__ =
5142 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5143 .into_iter().map(|x| x.0).collect())
5144 ;
5145 }
5146 GeneratedField::FillStrategies => {
5147 if fill_strategies__.is_some() {
5148 return Err(serde::de::Error::duplicate_field("fillStrategies"));
5149 }
5150 fill_strategies__ = Some(map_.next_value()?);
5151 }
5152 GeneratedField::StateTable => {
5153 if state_table__.is_some() {
5154 return Err(serde::de::Error::duplicate_field("stateTable"));
5155 }
5156 state_table__ = map_.next_value()?;
5157 }
5158 }
5159 }
5160 Ok(GapFillNode {
5161 time_column_index: time_column_index__.unwrap_or_default(),
5162 interval: interval__,
5163 fill_columns: fill_columns__.unwrap_or_default(),
5164 fill_strategies: fill_strategies__.unwrap_or_default(),
5165 state_table: state_table__,
5166 })
5167 }
5168 }
5169 deserializer.deserialize_struct("stream_plan.GapFillNode", FIELDS, GeneratedVisitor)
5170 }
5171}
5172impl serde::Serialize for GlobalApproxPercentileNode {
5173 #[allow(deprecated)]
5174 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5175 where
5176 S: serde::Serializer,
5177 {
5178 use serde::ser::SerializeStruct;
5179 let mut len = 0;
5180 if self.base != 0. {
5181 len += 1;
5182 }
5183 if self.quantile != 0. {
5184 len += 1;
5185 }
5186 if self.bucket_state_table.is_some() {
5187 len += 1;
5188 }
5189 if self.count_state_table.is_some() {
5190 len += 1;
5191 }
5192 let mut struct_ser = serializer.serialize_struct("stream_plan.GlobalApproxPercentileNode", len)?;
5193 if self.base != 0. {
5194 struct_ser.serialize_field("base", &self.base)?;
5195 }
5196 if self.quantile != 0. {
5197 struct_ser.serialize_field("quantile", &self.quantile)?;
5198 }
5199 if let Some(v) = self.bucket_state_table.as_ref() {
5200 struct_ser.serialize_field("bucketStateTable", v)?;
5201 }
5202 if let Some(v) = self.count_state_table.as_ref() {
5203 struct_ser.serialize_field("countStateTable", v)?;
5204 }
5205 struct_ser.end()
5206 }
5207}
5208impl<'de> serde::Deserialize<'de> for GlobalApproxPercentileNode {
5209 #[allow(deprecated)]
5210 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5211 where
5212 D: serde::Deserializer<'de>,
5213 {
5214 const FIELDS: &[&str] = &[
5215 "base",
5216 "quantile",
5217 "bucket_state_table",
5218 "bucketStateTable",
5219 "count_state_table",
5220 "countStateTable",
5221 ];
5222
5223 #[allow(clippy::enum_variant_names)]
5224 enum GeneratedField {
5225 Base,
5226 Quantile,
5227 BucketStateTable,
5228 CountStateTable,
5229 }
5230 impl<'de> serde::Deserialize<'de> for GeneratedField {
5231 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5232 where
5233 D: serde::Deserializer<'de>,
5234 {
5235 struct GeneratedVisitor;
5236
5237 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5238 type Value = GeneratedField;
5239
5240 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5241 write!(formatter, "expected one of: {:?}", &FIELDS)
5242 }
5243
5244 #[allow(unused_variables)]
5245 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5246 where
5247 E: serde::de::Error,
5248 {
5249 match value {
5250 "base" => Ok(GeneratedField::Base),
5251 "quantile" => Ok(GeneratedField::Quantile),
5252 "bucketStateTable" | "bucket_state_table" => Ok(GeneratedField::BucketStateTable),
5253 "countStateTable" | "count_state_table" => Ok(GeneratedField::CountStateTable),
5254 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5255 }
5256 }
5257 }
5258 deserializer.deserialize_identifier(GeneratedVisitor)
5259 }
5260 }
5261 struct GeneratedVisitor;
5262 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5263 type Value = GlobalApproxPercentileNode;
5264
5265 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5266 formatter.write_str("struct stream_plan.GlobalApproxPercentileNode")
5267 }
5268
5269 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GlobalApproxPercentileNode, V::Error>
5270 where
5271 V: serde::de::MapAccess<'de>,
5272 {
5273 let mut base__ = None;
5274 let mut quantile__ = None;
5275 let mut bucket_state_table__ = None;
5276 let mut count_state_table__ = None;
5277 while let Some(k) = map_.next_key()? {
5278 match k {
5279 GeneratedField::Base => {
5280 if base__.is_some() {
5281 return Err(serde::de::Error::duplicate_field("base"));
5282 }
5283 base__ =
5284 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5285 ;
5286 }
5287 GeneratedField::Quantile => {
5288 if quantile__.is_some() {
5289 return Err(serde::de::Error::duplicate_field("quantile"));
5290 }
5291 quantile__ =
5292 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5293 ;
5294 }
5295 GeneratedField::BucketStateTable => {
5296 if bucket_state_table__.is_some() {
5297 return Err(serde::de::Error::duplicate_field("bucketStateTable"));
5298 }
5299 bucket_state_table__ = map_.next_value()?;
5300 }
5301 GeneratedField::CountStateTable => {
5302 if count_state_table__.is_some() {
5303 return Err(serde::de::Error::duplicate_field("countStateTable"));
5304 }
5305 count_state_table__ = map_.next_value()?;
5306 }
5307 }
5308 }
5309 Ok(GlobalApproxPercentileNode {
5310 base: base__.unwrap_or_default(),
5311 quantile: quantile__.unwrap_or_default(),
5312 bucket_state_table: bucket_state_table__,
5313 count_state_table: count_state_table__,
5314 })
5315 }
5316 }
5317 deserializer.deserialize_struct("stream_plan.GlobalApproxPercentileNode", FIELDS, GeneratedVisitor)
5318 }
5319}
5320impl serde::Serialize for GroupTopNNode {
5321 #[allow(deprecated)]
5322 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5323 where
5324 S: serde::Serializer,
5325 {
5326 use serde::ser::SerializeStruct;
5327 let mut len = 0;
5328 if self.limit != 0 {
5329 len += 1;
5330 }
5331 if self.offset != 0 {
5332 len += 1;
5333 }
5334 if !self.group_key.is_empty() {
5335 len += 1;
5336 }
5337 if self.table.is_some() {
5338 len += 1;
5339 }
5340 if !self.order_by.is_empty() {
5341 len += 1;
5342 }
5343 if self.with_ties {
5344 len += 1;
5345 }
5346 let mut struct_ser = serializer.serialize_struct("stream_plan.GroupTopNNode", len)?;
5347 if self.limit != 0 {
5348 #[allow(clippy::needless_borrow)]
5349 #[allow(clippy::needless_borrows_for_generic_args)]
5350 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
5351 }
5352 if self.offset != 0 {
5353 #[allow(clippy::needless_borrow)]
5354 #[allow(clippy::needless_borrows_for_generic_args)]
5355 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
5356 }
5357 if !self.group_key.is_empty() {
5358 struct_ser.serialize_field("groupKey", &self.group_key)?;
5359 }
5360 if let Some(v) = self.table.as_ref() {
5361 struct_ser.serialize_field("table", v)?;
5362 }
5363 if !self.order_by.is_empty() {
5364 struct_ser.serialize_field("orderBy", &self.order_by)?;
5365 }
5366 if self.with_ties {
5367 struct_ser.serialize_field("withTies", &self.with_ties)?;
5368 }
5369 struct_ser.end()
5370 }
5371}
5372impl<'de> serde::Deserialize<'de> for GroupTopNNode {
5373 #[allow(deprecated)]
5374 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5375 where
5376 D: serde::Deserializer<'de>,
5377 {
5378 const FIELDS: &[&str] = &[
5379 "limit",
5380 "offset",
5381 "group_key",
5382 "groupKey",
5383 "table",
5384 "order_by",
5385 "orderBy",
5386 "with_ties",
5387 "withTies",
5388 ];
5389
5390 #[allow(clippy::enum_variant_names)]
5391 enum GeneratedField {
5392 Limit,
5393 Offset,
5394 GroupKey,
5395 Table,
5396 OrderBy,
5397 WithTies,
5398 }
5399 impl<'de> serde::Deserialize<'de> for GeneratedField {
5400 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5401 where
5402 D: serde::Deserializer<'de>,
5403 {
5404 struct GeneratedVisitor;
5405
5406 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5407 type Value = GeneratedField;
5408
5409 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5410 write!(formatter, "expected one of: {:?}", &FIELDS)
5411 }
5412
5413 #[allow(unused_variables)]
5414 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5415 where
5416 E: serde::de::Error,
5417 {
5418 match value {
5419 "limit" => Ok(GeneratedField::Limit),
5420 "offset" => Ok(GeneratedField::Offset),
5421 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5422 "table" => Ok(GeneratedField::Table),
5423 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
5424 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
5425 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5426 }
5427 }
5428 }
5429 deserializer.deserialize_identifier(GeneratedVisitor)
5430 }
5431 }
5432 struct GeneratedVisitor;
5433 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5434 type Value = GroupTopNNode;
5435
5436 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5437 formatter.write_str("struct stream_plan.GroupTopNNode")
5438 }
5439
5440 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupTopNNode, V::Error>
5441 where
5442 V: serde::de::MapAccess<'de>,
5443 {
5444 let mut limit__ = None;
5445 let mut offset__ = None;
5446 let mut group_key__ = None;
5447 let mut table__ = None;
5448 let mut order_by__ = None;
5449 let mut with_ties__ = None;
5450 while let Some(k) = map_.next_key()? {
5451 match k {
5452 GeneratedField::Limit => {
5453 if limit__.is_some() {
5454 return Err(serde::de::Error::duplicate_field("limit"));
5455 }
5456 limit__ =
5457 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5458 ;
5459 }
5460 GeneratedField::Offset => {
5461 if offset__.is_some() {
5462 return Err(serde::de::Error::duplicate_field("offset"));
5463 }
5464 offset__ =
5465 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5466 ;
5467 }
5468 GeneratedField::GroupKey => {
5469 if group_key__.is_some() {
5470 return Err(serde::de::Error::duplicate_field("groupKey"));
5471 }
5472 group_key__ =
5473 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5474 .into_iter().map(|x| x.0).collect())
5475 ;
5476 }
5477 GeneratedField::Table => {
5478 if table__.is_some() {
5479 return Err(serde::de::Error::duplicate_field("table"));
5480 }
5481 table__ = map_.next_value()?;
5482 }
5483 GeneratedField::OrderBy => {
5484 if order_by__.is_some() {
5485 return Err(serde::de::Error::duplicate_field("orderBy"));
5486 }
5487 order_by__ = Some(map_.next_value()?);
5488 }
5489 GeneratedField::WithTies => {
5490 if with_ties__.is_some() {
5491 return Err(serde::de::Error::duplicate_field("withTies"));
5492 }
5493 with_ties__ = Some(map_.next_value()?);
5494 }
5495 }
5496 }
5497 Ok(GroupTopNNode {
5498 limit: limit__.unwrap_or_default(),
5499 offset: offset__.unwrap_or_default(),
5500 group_key: group_key__.unwrap_or_default(),
5501 table: table__,
5502 order_by: order_by__.unwrap_or_default(),
5503 with_ties: with_ties__.unwrap_or_default(),
5504 })
5505 }
5506 }
5507 deserializer.deserialize_struct("stream_plan.GroupTopNNode", FIELDS, GeneratedVisitor)
5508 }
5509}
5510impl serde::Serialize for HashAggNode {
5511 #[allow(deprecated)]
5512 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5513 where
5514 S: serde::Serializer,
5515 {
5516 use serde::ser::SerializeStruct;
5517 let mut len = 0;
5518 if !self.group_key.is_empty() {
5519 len += 1;
5520 }
5521 if !self.agg_calls.is_empty() {
5522 len += 1;
5523 }
5524 if !self.agg_call_states.is_empty() {
5525 len += 1;
5526 }
5527 if self.intermediate_state_table.is_some() {
5528 len += 1;
5529 }
5530 if self.is_append_only {
5531 len += 1;
5532 }
5533 if !self.distinct_dedup_tables.is_empty() {
5534 len += 1;
5535 }
5536 if self.row_count_index != 0 {
5537 len += 1;
5538 }
5539 if self.emit_on_window_close {
5540 len += 1;
5541 }
5542 if self.version != 0 {
5543 len += 1;
5544 }
5545 let mut struct_ser = serializer.serialize_struct("stream_plan.HashAggNode", len)?;
5546 if !self.group_key.is_empty() {
5547 struct_ser.serialize_field("groupKey", &self.group_key)?;
5548 }
5549 if !self.agg_calls.is_empty() {
5550 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
5551 }
5552 if !self.agg_call_states.is_empty() {
5553 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
5554 }
5555 if let Some(v) = self.intermediate_state_table.as_ref() {
5556 struct_ser.serialize_field("intermediateStateTable", v)?;
5557 }
5558 if self.is_append_only {
5559 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5560 }
5561 if !self.distinct_dedup_tables.is_empty() {
5562 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
5563 }
5564 if self.row_count_index != 0 {
5565 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
5566 }
5567 if self.emit_on_window_close {
5568 struct_ser.serialize_field("emitOnWindowClose", &self.emit_on_window_close)?;
5569 }
5570 if self.version != 0 {
5571 let v = AggNodeVersion::try_from(self.version)
5572 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
5573 struct_ser.serialize_field("version", &v)?;
5574 }
5575 struct_ser.end()
5576 }
5577}
5578impl<'de> serde::Deserialize<'de> for HashAggNode {
5579 #[allow(deprecated)]
5580 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5581 where
5582 D: serde::Deserializer<'de>,
5583 {
5584 const FIELDS: &[&str] = &[
5585 "group_key",
5586 "groupKey",
5587 "agg_calls",
5588 "aggCalls",
5589 "agg_call_states",
5590 "aggCallStates",
5591 "intermediate_state_table",
5592 "intermediateStateTable",
5593 "is_append_only",
5594 "isAppendOnly",
5595 "distinct_dedup_tables",
5596 "distinctDedupTables",
5597 "row_count_index",
5598 "rowCountIndex",
5599 "emit_on_window_close",
5600 "emitOnWindowClose",
5601 "version",
5602 ];
5603
5604 #[allow(clippy::enum_variant_names)]
5605 enum GeneratedField {
5606 GroupKey,
5607 AggCalls,
5608 AggCallStates,
5609 IntermediateStateTable,
5610 IsAppendOnly,
5611 DistinctDedupTables,
5612 RowCountIndex,
5613 EmitOnWindowClose,
5614 Version,
5615 }
5616 impl<'de> serde::Deserialize<'de> for GeneratedField {
5617 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5618 where
5619 D: serde::Deserializer<'de>,
5620 {
5621 struct GeneratedVisitor;
5622
5623 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5624 type Value = GeneratedField;
5625
5626 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5627 write!(formatter, "expected one of: {:?}", &FIELDS)
5628 }
5629
5630 #[allow(unused_variables)]
5631 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5632 where
5633 E: serde::de::Error,
5634 {
5635 match value {
5636 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5637 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
5638 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
5639 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
5640 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5641 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
5642 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
5643 "emitOnWindowClose" | "emit_on_window_close" => Ok(GeneratedField::EmitOnWindowClose),
5644 "version" => Ok(GeneratedField::Version),
5645 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5646 }
5647 }
5648 }
5649 deserializer.deserialize_identifier(GeneratedVisitor)
5650 }
5651 }
5652 struct GeneratedVisitor;
5653 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5654 type Value = HashAggNode;
5655
5656 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5657 formatter.write_str("struct stream_plan.HashAggNode")
5658 }
5659
5660 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashAggNode, V::Error>
5661 where
5662 V: serde::de::MapAccess<'de>,
5663 {
5664 let mut group_key__ = None;
5665 let mut agg_calls__ = None;
5666 let mut agg_call_states__ = None;
5667 let mut intermediate_state_table__ = None;
5668 let mut is_append_only__ = None;
5669 let mut distinct_dedup_tables__ = None;
5670 let mut row_count_index__ = None;
5671 let mut emit_on_window_close__ = None;
5672 let mut version__ = None;
5673 while let Some(k) = map_.next_key()? {
5674 match k {
5675 GeneratedField::GroupKey => {
5676 if group_key__.is_some() {
5677 return Err(serde::de::Error::duplicate_field("groupKey"));
5678 }
5679 group_key__ =
5680 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5681 .into_iter().map(|x| x.0).collect())
5682 ;
5683 }
5684 GeneratedField::AggCalls => {
5685 if agg_calls__.is_some() {
5686 return Err(serde::de::Error::duplicate_field("aggCalls"));
5687 }
5688 agg_calls__ = Some(map_.next_value()?);
5689 }
5690 GeneratedField::AggCallStates => {
5691 if agg_call_states__.is_some() {
5692 return Err(serde::de::Error::duplicate_field("aggCallStates"));
5693 }
5694 agg_call_states__ = Some(map_.next_value()?);
5695 }
5696 GeneratedField::IntermediateStateTable => {
5697 if intermediate_state_table__.is_some() {
5698 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
5699 }
5700 intermediate_state_table__ = map_.next_value()?;
5701 }
5702 GeneratedField::IsAppendOnly => {
5703 if is_append_only__.is_some() {
5704 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
5705 }
5706 is_append_only__ = Some(map_.next_value()?);
5707 }
5708 GeneratedField::DistinctDedupTables => {
5709 if distinct_dedup_tables__.is_some() {
5710 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
5711 }
5712 distinct_dedup_tables__ = Some(
5713 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5714 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
5715 );
5716 }
5717 GeneratedField::RowCountIndex => {
5718 if row_count_index__.is_some() {
5719 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
5720 }
5721 row_count_index__ =
5722 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5723 ;
5724 }
5725 GeneratedField::EmitOnWindowClose => {
5726 if emit_on_window_close__.is_some() {
5727 return Err(serde::de::Error::duplicate_field("emitOnWindowClose"));
5728 }
5729 emit_on_window_close__ = Some(map_.next_value()?);
5730 }
5731 GeneratedField::Version => {
5732 if version__.is_some() {
5733 return Err(serde::de::Error::duplicate_field("version"));
5734 }
5735 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
5736 }
5737 }
5738 }
5739 Ok(HashAggNode {
5740 group_key: group_key__.unwrap_or_default(),
5741 agg_calls: agg_calls__.unwrap_or_default(),
5742 agg_call_states: agg_call_states__.unwrap_or_default(),
5743 intermediate_state_table: intermediate_state_table__,
5744 is_append_only: is_append_only__.unwrap_or_default(),
5745 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
5746 row_count_index: row_count_index__.unwrap_or_default(),
5747 emit_on_window_close: emit_on_window_close__.unwrap_or_default(),
5748 version: version__.unwrap_or_default(),
5749 })
5750 }
5751 }
5752 deserializer.deserialize_struct("stream_plan.HashAggNode", FIELDS, GeneratedVisitor)
5753 }
5754}
5755impl serde::Serialize for HashJoinNode {
5756 #[allow(deprecated)]
5757 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5758 where
5759 S: serde::Serializer,
5760 {
5761 use serde::ser::SerializeStruct;
5762 let mut len = 0;
5763 if self.join_type != 0 {
5764 len += 1;
5765 }
5766 if !self.left_key.is_empty() {
5767 len += 1;
5768 }
5769 if !self.right_key.is_empty() {
5770 len += 1;
5771 }
5772 if self.condition.is_some() {
5773 len += 1;
5774 }
5775 if !self.inequality_pairs.is_empty() {
5776 len += 1;
5777 }
5778 if self.left_table.is_some() {
5779 len += 1;
5780 }
5781 if self.right_table.is_some() {
5782 len += 1;
5783 }
5784 if self.left_degree_table.is_some() {
5785 len += 1;
5786 }
5787 if self.right_degree_table.is_some() {
5788 len += 1;
5789 }
5790 if !self.output_indices.is_empty() {
5791 len += 1;
5792 }
5793 if !self.left_deduped_input_pk_indices.is_empty() {
5794 len += 1;
5795 }
5796 if !self.right_deduped_input_pk_indices.is_empty() {
5797 len += 1;
5798 }
5799 if !self.null_safe.is_empty() {
5800 len += 1;
5801 }
5802 if self.is_append_only {
5803 len += 1;
5804 }
5805 if self.join_encoding_type != 0 {
5806 len += 1;
5807 }
5808 let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinNode", len)?;
5809 if self.join_type != 0 {
5810 let v = super::plan_common::JoinType::try_from(self.join_type)
5811 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
5812 struct_ser.serialize_field("joinType", &v)?;
5813 }
5814 if !self.left_key.is_empty() {
5815 struct_ser.serialize_field("leftKey", &self.left_key)?;
5816 }
5817 if !self.right_key.is_empty() {
5818 struct_ser.serialize_field("rightKey", &self.right_key)?;
5819 }
5820 if let Some(v) = self.condition.as_ref() {
5821 struct_ser.serialize_field("condition", v)?;
5822 }
5823 if !self.inequality_pairs.is_empty() {
5824 struct_ser.serialize_field("inequalityPairs", &self.inequality_pairs)?;
5825 }
5826 if let Some(v) = self.left_table.as_ref() {
5827 struct_ser.serialize_field("leftTable", v)?;
5828 }
5829 if let Some(v) = self.right_table.as_ref() {
5830 struct_ser.serialize_field("rightTable", v)?;
5831 }
5832 if let Some(v) = self.left_degree_table.as_ref() {
5833 struct_ser.serialize_field("leftDegreeTable", v)?;
5834 }
5835 if let Some(v) = self.right_degree_table.as_ref() {
5836 struct_ser.serialize_field("rightDegreeTable", v)?;
5837 }
5838 if !self.output_indices.is_empty() {
5839 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
5840 }
5841 if !self.left_deduped_input_pk_indices.is_empty() {
5842 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
5843 }
5844 if !self.right_deduped_input_pk_indices.is_empty() {
5845 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
5846 }
5847 if !self.null_safe.is_empty() {
5848 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
5849 }
5850 if self.is_append_only {
5851 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5852 }
5853 if self.join_encoding_type != 0 {
5854 let v = JoinEncodingType::try_from(self.join_encoding_type)
5855 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
5856 struct_ser.serialize_field("joinEncodingType", &v)?;
5857 }
5858 struct_ser.end()
5859 }
5860}
5861impl<'de> serde::Deserialize<'de> for HashJoinNode {
5862 #[allow(deprecated)]
5863 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5864 where
5865 D: serde::Deserializer<'de>,
5866 {
5867 const FIELDS: &[&str] = &[
5868 "join_type",
5869 "joinType",
5870 "left_key",
5871 "leftKey",
5872 "right_key",
5873 "rightKey",
5874 "condition",
5875 "inequality_pairs",
5876 "inequalityPairs",
5877 "left_table",
5878 "leftTable",
5879 "right_table",
5880 "rightTable",
5881 "left_degree_table",
5882 "leftDegreeTable",
5883 "right_degree_table",
5884 "rightDegreeTable",
5885 "output_indices",
5886 "outputIndices",
5887 "left_deduped_input_pk_indices",
5888 "leftDedupedInputPkIndices",
5889 "right_deduped_input_pk_indices",
5890 "rightDedupedInputPkIndices",
5891 "null_safe",
5892 "nullSafe",
5893 "is_append_only",
5894 "isAppendOnly",
5895 "join_encoding_type",
5896 "joinEncodingType",
5897 ];
5898
5899 #[allow(clippy::enum_variant_names)]
5900 enum GeneratedField {
5901 JoinType,
5902 LeftKey,
5903 RightKey,
5904 Condition,
5905 InequalityPairs,
5906 LeftTable,
5907 RightTable,
5908 LeftDegreeTable,
5909 RightDegreeTable,
5910 OutputIndices,
5911 LeftDedupedInputPkIndices,
5912 RightDedupedInputPkIndices,
5913 NullSafe,
5914 IsAppendOnly,
5915 JoinEncodingType,
5916 }
5917 impl<'de> serde::Deserialize<'de> for GeneratedField {
5918 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5919 where
5920 D: serde::Deserializer<'de>,
5921 {
5922 struct GeneratedVisitor;
5923
5924 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5925 type Value = GeneratedField;
5926
5927 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5928 write!(formatter, "expected one of: {:?}", &FIELDS)
5929 }
5930
5931 #[allow(unused_variables)]
5932 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5933 where
5934 E: serde::de::Error,
5935 {
5936 match value {
5937 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
5938 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
5939 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
5940 "condition" => Ok(GeneratedField::Condition),
5941 "inequalityPairs" | "inequality_pairs" => Ok(GeneratedField::InequalityPairs),
5942 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
5943 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
5944 "leftDegreeTable" | "left_degree_table" => Ok(GeneratedField::LeftDegreeTable),
5945 "rightDegreeTable" | "right_degree_table" => Ok(GeneratedField::RightDegreeTable),
5946 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
5947 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
5948 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
5949 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
5950 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5951 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
5952 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5953 }
5954 }
5955 }
5956 deserializer.deserialize_identifier(GeneratedVisitor)
5957 }
5958 }
5959 struct GeneratedVisitor;
5960 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5961 type Value = HashJoinNode;
5962
5963 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5964 formatter.write_str("struct stream_plan.HashJoinNode")
5965 }
5966
5967 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinNode, V::Error>
5968 where
5969 V: serde::de::MapAccess<'de>,
5970 {
5971 let mut join_type__ = None;
5972 let mut left_key__ = None;
5973 let mut right_key__ = None;
5974 let mut condition__ = None;
5975 let mut inequality_pairs__ = None;
5976 let mut left_table__ = None;
5977 let mut right_table__ = None;
5978 let mut left_degree_table__ = None;
5979 let mut right_degree_table__ = None;
5980 let mut output_indices__ = None;
5981 let mut left_deduped_input_pk_indices__ = None;
5982 let mut right_deduped_input_pk_indices__ = None;
5983 let mut null_safe__ = None;
5984 let mut is_append_only__ = None;
5985 let mut join_encoding_type__ = None;
5986 while let Some(k) = map_.next_key()? {
5987 match k {
5988 GeneratedField::JoinType => {
5989 if join_type__.is_some() {
5990 return Err(serde::de::Error::duplicate_field("joinType"));
5991 }
5992 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
5993 }
5994 GeneratedField::LeftKey => {
5995 if left_key__.is_some() {
5996 return Err(serde::de::Error::duplicate_field("leftKey"));
5997 }
5998 left_key__ =
5999 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6000 .into_iter().map(|x| x.0).collect())
6001 ;
6002 }
6003 GeneratedField::RightKey => {
6004 if right_key__.is_some() {
6005 return Err(serde::de::Error::duplicate_field("rightKey"));
6006 }
6007 right_key__ =
6008 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6009 .into_iter().map(|x| x.0).collect())
6010 ;
6011 }
6012 GeneratedField::Condition => {
6013 if condition__.is_some() {
6014 return Err(serde::de::Error::duplicate_field("condition"));
6015 }
6016 condition__ = map_.next_value()?;
6017 }
6018 GeneratedField::InequalityPairs => {
6019 if inequality_pairs__.is_some() {
6020 return Err(serde::de::Error::duplicate_field("inequalityPairs"));
6021 }
6022 inequality_pairs__ = Some(map_.next_value()?);
6023 }
6024 GeneratedField::LeftTable => {
6025 if left_table__.is_some() {
6026 return Err(serde::de::Error::duplicate_field("leftTable"));
6027 }
6028 left_table__ = map_.next_value()?;
6029 }
6030 GeneratedField::RightTable => {
6031 if right_table__.is_some() {
6032 return Err(serde::de::Error::duplicate_field("rightTable"));
6033 }
6034 right_table__ = map_.next_value()?;
6035 }
6036 GeneratedField::LeftDegreeTable => {
6037 if left_degree_table__.is_some() {
6038 return Err(serde::de::Error::duplicate_field("leftDegreeTable"));
6039 }
6040 left_degree_table__ = map_.next_value()?;
6041 }
6042 GeneratedField::RightDegreeTable => {
6043 if right_degree_table__.is_some() {
6044 return Err(serde::de::Error::duplicate_field("rightDegreeTable"));
6045 }
6046 right_degree_table__ = map_.next_value()?;
6047 }
6048 GeneratedField::OutputIndices => {
6049 if output_indices__.is_some() {
6050 return Err(serde::de::Error::duplicate_field("outputIndices"));
6051 }
6052 output_indices__ =
6053 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6054 .into_iter().map(|x| x.0).collect())
6055 ;
6056 }
6057 GeneratedField::LeftDedupedInputPkIndices => {
6058 if left_deduped_input_pk_indices__.is_some() {
6059 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
6060 }
6061 left_deduped_input_pk_indices__ =
6062 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6063 .into_iter().map(|x| x.0).collect())
6064 ;
6065 }
6066 GeneratedField::RightDedupedInputPkIndices => {
6067 if right_deduped_input_pk_indices__.is_some() {
6068 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
6069 }
6070 right_deduped_input_pk_indices__ =
6071 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6072 .into_iter().map(|x| x.0).collect())
6073 ;
6074 }
6075 GeneratedField::NullSafe => {
6076 if null_safe__.is_some() {
6077 return Err(serde::de::Error::duplicate_field("nullSafe"));
6078 }
6079 null_safe__ = Some(map_.next_value()?);
6080 }
6081 GeneratedField::IsAppendOnly => {
6082 if is_append_only__.is_some() {
6083 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
6084 }
6085 is_append_only__ = Some(map_.next_value()?);
6086 }
6087 GeneratedField::JoinEncodingType => {
6088 if join_encoding_type__.is_some() {
6089 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
6090 }
6091 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
6092 }
6093 }
6094 }
6095 Ok(HashJoinNode {
6096 join_type: join_type__.unwrap_or_default(),
6097 left_key: left_key__.unwrap_or_default(),
6098 right_key: right_key__.unwrap_or_default(),
6099 condition: condition__,
6100 inequality_pairs: inequality_pairs__.unwrap_or_default(),
6101 left_table: left_table__,
6102 right_table: right_table__,
6103 left_degree_table: left_degree_table__,
6104 right_degree_table: right_degree_table__,
6105 output_indices: output_indices__.unwrap_or_default(),
6106 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
6107 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
6108 null_safe: null_safe__.unwrap_or_default(),
6109 is_append_only: is_append_only__.unwrap_or_default(),
6110 join_encoding_type: join_encoding_type__.unwrap_or_default(),
6111 })
6112 }
6113 }
6114 deserializer.deserialize_struct("stream_plan.HashJoinNode", FIELDS, GeneratedVisitor)
6115 }
6116}
6117impl serde::Serialize for HopWindowNode {
6118 #[allow(deprecated)]
6119 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6120 where
6121 S: serde::Serializer,
6122 {
6123 use serde::ser::SerializeStruct;
6124 let mut len = 0;
6125 if self.time_col != 0 {
6126 len += 1;
6127 }
6128 if self.window_slide.is_some() {
6129 len += 1;
6130 }
6131 if self.window_size.is_some() {
6132 len += 1;
6133 }
6134 if !self.output_indices.is_empty() {
6135 len += 1;
6136 }
6137 if !self.window_start_exprs.is_empty() {
6138 len += 1;
6139 }
6140 if !self.window_end_exprs.is_empty() {
6141 len += 1;
6142 }
6143 let mut struct_ser = serializer.serialize_struct("stream_plan.HopWindowNode", len)?;
6144 if self.time_col != 0 {
6145 struct_ser.serialize_field("timeCol", &self.time_col)?;
6146 }
6147 if let Some(v) = self.window_slide.as_ref() {
6148 struct_ser.serialize_field("windowSlide", v)?;
6149 }
6150 if let Some(v) = self.window_size.as_ref() {
6151 struct_ser.serialize_field("windowSize", v)?;
6152 }
6153 if !self.output_indices.is_empty() {
6154 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
6155 }
6156 if !self.window_start_exprs.is_empty() {
6157 struct_ser.serialize_field("windowStartExprs", &self.window_start_exprs)?;
6158 }
6159 if !self.window_end_exprs.is_empty() {
6160 struct_ser.serialize_field("windowEndExprs", &self.window_end_exprs)?;
6161 }
6162 struct_ser.end()
6163 }
6164}
6165impl<'de> serde::Deserialize<'de> for HopWindowNode {
6166 #[allow(deprecated)]
6167 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6168 where
6169 D: serde::Deserializer<'de>,
6170 {
6171 const FIELDS: &[&str] = &[
6172 "time_col",
6173 "timeCol",
6174 "window_slide",
6175 "windowSlide",
6176 "window_size",
6177 "windowSize",
6178 "output_indices",
6179 "outputIndices",
6180 "window_start_exprs",
6181 "windowStartExprs",
6182 "window_end_exprs",
6183 "windowEndExprs",
6184 ];
6185
6186 #[allow(clippy::enum_variant_names)]
6187 enum GeneratedField {
6188 TimeCol,
6189 WindowSlide,
6190 WindowSize,
6191 OutputIndices,
6192 WindowStartExprs,
6193 WindowEndExprs,
6194 }
6195 impl<'de> serde::Deserialize<'de> for GeneratedField {
6196 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6197 where
6198 D: serde::Deserializer<'de>,
6199 {
6200 struct GeneratedVisitor;
6201
6202 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6203 type Value = GeneratedField;
6204
6205 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6206 write!(formatter, "expected one of: {:?}", &FIELDS)
6207 }
6208
6209 #[allow(unused_variables)]
6210 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6211 where
6212 E: serde::de::Error,
6213 {
6214 match value {
6215 "timeCol" | "time_col" => Ok(GeneratedField::TimeCol),
6216 "windowSlide" | "window_slide" => Ok(GeneratedField::WindowSlide),
6217 "windowSize" | "window_size" => Ok(GeneratedField::WindowSize),
6218 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
6219 "windowStartExprs" | "window_start_exprs" => Ok(GeneratedField::WindowStartExprs),
6220 "windowEndExprs" | "window_end_exprs" => Ok(GeneratedField::WindowEndExprs),
6221 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6222 }
6223 }
6224 }
6225 deserializer.deserialize_identifier(GeneratedVisitor)
6226 }
6227 }
6228 struct GeneratedVisitor;
6229 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6230 type Value = HopWindowNode;
6231
6232 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6233 formatter.write_str("struct stream_plan.HopWindowNode")
6234 }
6235
6236 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HopWindowNode, V::Error>
6237 where
6238 V: serde::de::MapAccess<'de>,
6239 {
6240 let mut time_col__ = None;
6241 let mut window_slide__ = None;
6242 let mut window_size__ = None;
6243 let mut output_indices__ = None;
6244 let mut window_start_exprs__ = None;
6245 let mut window_end_exprs__ = None;
6246 while let Some(k) = map_.next_key()? {
6247 match k {
6248 GeneratedField::TimeCol => {
6249 if time_col__.is_some() {
6250 return Err(serde::de::Error::duplicate_field("timeCol"));
6251 }
6252 time_col__ =
6253 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6254 ;
6255 }
6256 GeneratedField::WindowSlide => {
6257 if window_slide__.is_some() {
6258 return Err(serde::de::Error::duplicate_field("windowSlide"));
6259 }
6260 window_slide__ = map_.next_value()?;
6261 }
6262 GeneratedField::WindowSize => {
6263 if window_size__.is_some() {
6264 return Err(serde::de::Error::duplicate_field("windowSize"));
6265 }
6266 window_size__ = map_.next_value()?;
6267 }
6268 GeneratedField::OutputIndices => {
6269 if output_indices__.is_some() {
6270 return Err(serde::de::Error::duplicate_field("outputIndices"));
6271 }
6272 output_indices__ =
6273 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6274 .into_iter().map(|x| x.0).collect())
6275 ;
6276 }
6277 GeneratedField::WindowStartExprs => {
6278 if window_start_exprs__.is_some() {
6279 return Err(serde::de::Error::duplicate_field("windowStartExprs"));
6280 }
6281 window_start_exprs__ = Some(map_.next_value()?);
6282 }
6283 GeneratedField::WindowEndExprs => {
6284 if window_end_exprs__.is_some() {
6285 return Err(serde::de::Error::duplicate_field("windowEndExprs"));
6286 }
6287 window_end_exprs__ = Some(map_.next_value()?);
6288 }
6289 }
6290 }
6291 Ok(HopWindowNode {
6292 time_col: time_col__.unwrap_or_default(),
6293 window_slide: window_slide__,
6294 window_size: window_size__,
6295 output_indices: output_indices__.unwrap_or_default(),
6296 window_start_exprs: window_start_exprs__.unwrap_or_default(),
6297 window_end_exprs: window_end_exprs__.unwrap_or_default(),
6298 })
6299 }
6300 }
6301 deserializer.deserialize_struct("stream_plan.HopWindowNode", FIELDS, GeneratedVisitor)
6302 }
6303}
6304impl serde::Serialize for InequalityPair {
6305 #[allow(deprecated)]
6306 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6307 where
6308 S: serde::Serializer,
6309 {
6310 use serde::ser::SerializeStruct;
6311 let mut len = 0;
6312 if self.key_required_larger != 0 {
6313 len += 1;
6314 }
6315 if self.key_required_smaller != 0 {
6316 len += 1;
6317 }
6318 if self.clean_state {
6319 len += 1;
6320 }
6321 if self.delta_expression.is_some() {
6322 len += 1;
6323 }
6324 let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPair", len)?;
6325 if self.key_required_larger != 0 {
6326 struct_ser.serialize_field("keyRequiredLarger", &self.key_required_larger)?;
6327 }
6328 if self.key_required_smaller != 0 {
6329 struct_ser.serialize_field("keyRequiredSmaller", &self.key_required_smaller)?;
6330 }
6331 if self.clean_state {
6332 struct_ser.serialize_field("cleanState", &self.clean_state)?;
6333 }
6334 if let Some(v) = self.delta_expression.as_ref() {
6335 struct_ser.serialize_field("deltaExpression", v)?;
6336 }
6337 struct_ser.end()
6338 }
6339}
6340impl<'de> serde::Deserialize<'de> for InequalityPair {
6341 #[allow(deprecated)]
6342 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6343 where
6344 D: serde::Deserializer<'de>,
6345 {
6346 const FIELDS: &[&str] = &[
6347 "key_required_larger",
6348 "keyRequiredLarger",
6349 "key_required_smaller",
6350 "keyRequiredSmaller",
6351 "clean_state",
6352 "cleanState",
6353 "delta_expression",
6354 "deltaExpression",
6355 ];
6356
6357 #[allow(clippy::enum_variant_names)]
6358 enum GeneratedField {
6359 KeyRequiredLarger,
6360 KeyRequiredSmaller,
6361 CleanState,
6362 DeltaExpression,
6363 }
6364 impl<'de> serde::Deserialize<'de> for GeneratedField {
6365 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6366 where
6367 D: serde::Deserializer<'de>,
6368 {
6369 struct GeneratedVisitor;
6370
6371 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6372 type Value = GeneratedField;
6373
6374 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6375 write!(formatter, "expected one of: {:?}", &FIELDS)
6376 }
6377
6378 #[allow(unused_variables)]
6379 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6380 where
6381 E: serde::de::Error,
6382 {
6383 match value {
6384 "keyRequiredLarger" | "key_required_larger" => Ok(GeneratedField::KeyRequiredLarger),
6385 "keyRequiredSmaller" | "key_required_smaller" => Ok(GeneratedField::KeyRequiredSmaller),
6386 "cleanState" | "clean_state" => Ok(GeneratedField::CleanState),
6387 "deltaExpression" | "delta_expression" => Ok(GeneratedField::DeltaExpression),
6388 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6389 }
6390 }
6391 }
6392 deserializer.deserialize_identifier(GeneratedVisitor)
6393 }
6394 }
6395 struct GeneratedVisitor;
6396 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6397 type Value = InequalityPair;
6398
6399 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6400 formatter.write_str("struct stream_plan.InequalityPair")
6401 }
6402
6403 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPair, V::Error>
6404 where
6405 V: serde::de::MapAccess<'de>,
6406 {
6407 let mut key_required_larger__ = None;
6408 let mut key_required_smaller__ = None;
6409 let mut clean_state__ = None;
6410 let mut delta_expression__ = None;
6411 while let Some(k) = map_.next_key()? {
6412 match k {
6413 GeneratedField::KeyRequiredLarger => {
6414 if key_required_larger__.is_some() {
6415 return Err(serde::de::Error::duplicate_field("keyRequiredLarger"));
6416 }
6417 key_required_larger__ =
6418 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6419 ;
6420 }
6421 GeneratedField::KeyRequiredSmaller => {
6422 if key_required_smaller__.is_some() {
6423 return Err(serde::de::Error::duplicate_field("keyRequiredSmaller"));
6424 }
6425 key_required_smaller__ =
6426 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6427 ;
6428 }
6429 GeneratedField::CleanState => {
6430 if clean_state__.is_some() {
6431 return Err(serde::de::Error::duplicate_field("cleanState"));
6432 }
6433 clean_state__ = Some(map_.next_value()?);
6434 }
6435 GeneratedField::DeltaExpression => {
6436 if delta_expression__.is_some() {
6437 return Err(serde::de::Error::duplicate_field("deltaExpression"));
6438 }
6439 delta_expression__ = map_.next_value()?;
6440 }
6441 }
6442 }
6443 Ok(InequalityPair {
6444 key_required_larger: key_required_larger__.unwrap_or_default(),
6445 key_required_smaller: key_required_smaller__.unwrap_or_default(),
6446 clean_state: clean_state__.unwrap_or_default(),
6447 delta_expression: delta_expression__,
6448 })
6449 }
6450 }
6451 deserializer.deserialize_struct("stream_plan.InequalityPair", FIELDS, GeneratedVisitor)
6452 }
6453}
6454impl serde::Serialize for JoinEncodingType {
6455 #[allow(deprecated)]
6456 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6457 where
6458 S: serde::Serializer,
6459 {
6460 let variant = match self {
6461 Self::Unspecified => "UNSPECIFIED",
6462 Self::MemoryOptimized => "MEMORY_OPTIMIZED",
6463 Self::CpuOptimized => "CPU_OPTIMIZED",
6464 };
6465 serializer.serialize_str(variant)
6466 }
6467}
6468impl<'de> serde::Deserialize<'de> for JoinEncodingType {
6469 #[allow(deprecated)]
6470 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6471 where
6472 D: serde::Deserializer<'de>,
6473 {
6474 const FIELDS: &[&str] = &[
6475 "UNSPECIFIED",
6476 "MEMORY_OPTIMIZED",
6477 "CPU_OPTIMIZED",
6478 ];
6479
6480 struct GeneratedVisitor;
6481
6482 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6483 type Value = JoinEncodingType;
6484
6485 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6486 write!(formatter, "expected one of: {:?}", &FIELDS)
6487 }
6488
6489 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6490 where
6491 E: serde::de::Error,
6492 {
6493 i32::try_from(v)
6494 .ok()
6495 .and_then(|x| x.try_into().ok())
6496 .ok_or_else(|| {
6497 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6498 })
6499 }
6500
6501 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6502 where
6503 E: serde::de::Error,
6504 {
6505 i32::try_from(v)
6506 .ok()
6507 .and_then(|x| x.try_into().ok())
6508 .ok_or_else(|| {
6509 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6510 })
6511 }
6512
6513 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6514 where
6515 E: serde::de::Error,
6516 {
6517 match value {
6518 "UNSPECIFIED" => Ok(JoinEncodingType::Unspecified),
6519 "MEMORY_OPTIMIZED" => Ok(JoinEncodingType::MemoryOptimized),
6520 "CPU_OPTIMIZED" => Ok(JoinEncodingType::CpuOptimized),
6521 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6522 }
6523 }
6524 }
6525 deserializer.deserialize_any(GeneratedVisitor)
6526 }
6527}
6528impl serde::Serialize for ListFinishMutation {
6529 #[allow(deprecated)]
6530 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6531 where
6532 S: serde::Serializer,
6533 {
6534 use serde::ser::SerializeStruct;
6535 let mut len = 0;
6536 if self.associated_source_id != 0 {
6537 len += 1;
6538 }
6539 let mut struct_ser = serializer.serialize_struct("stream_plan.ListFinishMutation", len)?;
6540 if self.associated_source_id != 0 {
6541 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
6542 }
6543 struct_ser.end()
6544 }
6545}
6546impl<'de> serde::Deserialize<'de> for ListFinishMutation {
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 "associated_source_id",
6554 "associatedSourceId",
6555 ];
6556
6557 #[allow(clippy::enum_variant_names)]
6558 enum GeneratedField {
6559 AssociatedSourceId,
6560 }
6561 impl<'de> serde::Deserialize<'de> for GeneratedField {
6562 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6563 where
6564 D: serde::Deserializer<'de>,
6565 {
6566 struct GeneratedVisitor;
6567
6568 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6569 type Value = GeneratedField;
6570
6571 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6572 write!(formatter, "expected one of: {:?}", &FIELDS)
6573 }
6574
6575 #[allow(unused_variables)]
6576 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6577 where
6578 E: serde::de::Error,
6579 {
6580 match value {
6581 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
6582 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6583 }
6584 }
6585 }
6586 deserializer.deserialize_identifier(GeneratedVisitor)
6587 }
6588 }
6589 struct GeneratedVisitor;
6590 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6591 type Value = ListFinishMutation;
6592
6593 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6594 formatter.write_str("struct stream_plan.ListFinishMutation")
6595 }
6596
6597 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFinishMutation, V::Error>
6598 where
6599 V: serde::de::MapAccess<'de>,
6600 {
6601 let mut associated_source_id__ = None;
6602 while let Some(k) = map_.next_key()? {
6603 match k {
6604 GeneratedField::AssociatedSourceId => {
6605 if associated_source_id__.is_some() {
6606 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
6607 }
6608 associated_source_id__ =
6609 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6610 ;
6611 }
6612 }
6613 }
6614 Ok(ListFinishMutation {
6615 associated_source_id: associated_source_id__.unwrap_or_default(),
6616 })
6617 }
6618 }
6619 deserializer.deserialize_struct("stream_plan.ListFinishMutation", FIELDS, GeneratedVisitor)
6620 }
6621}
6622impl serde::Serialize for LoadFinishMutation {
6623 #[allow(deprecated)]
6624 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6625 where
6626 S: serde::Serializer,
6627 {
6628 use serde::ser::SerializeStruct;
6629 let mut len = 0;
6630 if self.associated_source_id != 0 {
6631 len += 1;
6632 }
6633 let mut struct_ser = serializer.serialize_struct("stream_plan.LoadFinishMutation", len)?;
6634 if self.associated_source_id != 0 {
6635 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
6636 }
6637 struct_ser.end()
6638 }
6639}
6640impl<'de> serde::Deserialize<'de> for LoadFinishMutation {
6641 #[allow(deprecated)]
6642 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6643 where
6644 D: serde::Deserializer<'de>,
6645 {
6646 const FIELDS: &[&str] = &[
6647 "associated_source_id",
6648 "associatedSourceId",
6649 ];
6650
6651 #[allow(clippy::enum_variant_names)]
6652 enum GeneratedField {
6653 AssociatedSourceId,
6654 }
6655 impl<'de> serde::Deserialize<'de> for GeneratedField {
6656 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6657 where
6658 D: serde::Deserializer<'de>,
6659 {
6660 struct GeneratedVisitor;
6661
6662 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6663 type Value = GeneratedField;
6664
6665 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6666 write!(formatter, "expected one of: {:?}", &FIELDS)
6667 }
6668
6669 #[allow(unused_variables)]
6670 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6671 where
6672 E: serde::de::Error,
6673 {
6674 match value {
6675 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
6676 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6677 }
6678 }
6679 }
6680 deserializer.deserialize_identifier(GeneratedVisitor)
6681 }
6682 }
6683 struct GeneratedVisitor;
6684 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6685 type Value = LoadFinishMutation;
6686
6687 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6688 formatter.write_str("struct stream_plan.LoadFinishMutation")
6689 }
6690
6691 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LoadFinishMutation, V::Error>
6692 where
6693 V: serde::de::MapAccess<'de>,
6694 {
6695 let mut associated_source_id__ = None;
6696 while let Some(k) = map_.next_key()? {
6697 match k {
6698 GeneratedField::AssociatedSourceId => {
6699 if associated_source_id__.is_some() {
6700 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
6701 }
6702 associated_source_id__ =
6703 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6704 ;
6705 }
6706 }
6707 }
6708 Ok(LoadFinishMutation {
6709 associated_source_id: associated_source_id__.unwrap_or_default(),
6710 })
6711 }
6712 }
6713 deserializer.deserialize_struct("stream_plan.LoadFinishMutation", FIELDS, GeneratedVisitor)
6714 }
6715}
6716impl serde::Serialize for LocalApproxPercentileNode {
6717 #[allow(deprecated)]
6718 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6719 where
6720 S: serde::Serializer,
6721 {
6722 use serde::ser::SerializeStruct;
6723 let mut len = 0;
6724 if self.base != 0. {
6725 len += 1;
6726 }
6727 if self.percentile_index != 0 {
6728 len += 1;
6729 }
6730 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalApproxPercentileNode", len)?;
6731 if self.base != 0. {
6732 struct_ser.serialize_field("base", &self.base)?;
6733 }
6734 if self.percentile_index != 0 {
6735 struct_ser.serialize_field("percentileIndex", &self.percentile_index)?;
6736 }
6737 struct_ser.end()
6738 }
6739}
6740impl<'de> serde::Deserialize<'de> for LocalApproxPercentileNode {
6741 #[allow(deprecated)]
6742 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6743 where
6744 D: serde::Deserializer<'de>,
6745 {
6746 const FIELDS: &[&str] = &[
6747 "base",
6748 "percentile_index",
6749 "percentileIndex",
6750 ];
6751
6752 #[allow(clippy::enum_variant_names)]
6753 enum GeneratedField {
6754 Base,
6755 PercentileIndex,
6756 }
6757 impl<'de> serde::Deserialize<'de> for GeneratedField {
6758 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6759 where
6760 D: serde::Deserializer<'de>,
6761 {
6762 struct GeneratedVisitor;
6763
6764 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6765 type Value = GeneratedField;
6766
6767 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6768 write!(formatter, "expected one of: {:?}", &FIELDS)
6769 }
6770
6771 #[allow(unused_variables)]
6772 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6773 where
6774 E: serde::de::Error,
6775 {
6776 match value {
6777 "base" => Ok(GeneratedField::Base),
6778 "percentileIndex" | "percentile_index" => Ok(GeneratedField::PercentileIndex),
6779 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6780 }
6781 }
6782 }
6783 deserializer.deserialize_identifier(GeneratedVisitor)
6784 }
6785 }
6786 struct GeneratedVisitor;
6787 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6788 type Value = LocalApproxPercentileNode;
6789
6790 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6791 formatter.write_str("struct stream_plan.LocalApproxPercentileNode")
6792 }
6793
6794 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalApproxPercentileNode, V::Error>
6795 where
6796 V: serde::de::MapAccess<'de>,
6797 {
6798 let mut base__ = None;
6799 let mut percentile_index__ = None;
6800 while let Some(k) = map_.next_key()? {
6801 match k {
6802 GeneratedField::Base => {
6803 if base__.is_some() {
6804 return Err(serde::de::Error::duplicate_field("base"));
6805 }
6806 base__ =
6807 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6808 ;
6809 }
6810 GeneratedField::PercentileIndex => {
6811 if percentile_index__.is_some() {
6812 return Err(serde::de::Error::duplicate_field("percentileIndex"));
6813 }
6814 percentile_index__ =
6815 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6816 ;
6817 }
6818 }
6819 }
6820 Ok(LocalApproxPercentileNode {
6821 base: base__.unwrap_or_default(),
6822 percentile_index: percentile_index__.unwrap_or_default(),
6823 })
6824 }
6825 }
6826 deserializer.deserialize_struct("stream_plan.LocalApproxPercentileNode", FIELDS, GeneratedVisitor)
6827 }
6828}
6829impl serde::Serialize for LocalityProviderNode {
6830 #[allow(deprecated)]
6831 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6832 where
6833 S: serde::Serializer,
6834 {
6835 use serde::ser::SerializeStruct;
6836 let mut len = 0;
6837 if !self.locality_columns.is_empty() {
6838 len += 1;
6839 }
6840 if self.state_table.is_some() {
6841 len += 1;
6842 }
6843 if self.progress_table.is_some() {
6844 len += 1;
6845 }
6846 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalityProviderNode", len)?;
6847 if !self.locality_columns.is_empty() {
6848 struct_ser.serialize_field("localityColumns", &self.locality_columns)?;
6849 }
6850 if let Some(v) = self.state_table.as_ref() {
6851 struct_ser.serialize_field("stateTable", v)?;
6852 }
6853 if let Some(v) = self.progress_table.as_ref() {
6854 struct_ser.serialize_field("progressTable", v)?;
6855 }
6856 struct_ser.end()
6857 }
6858}
6859impl<'de> serde::Deserialize<'de> for LocalityProviderNode {
6860 #[allow(deprecated)]
6861 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6862 where
6863 D: serde::Deserializer<'de>,
6864 {
6865 const FIELDS: &[&str] = &[
6866 "locality_columns",
6867 "localityColumns",
6868 "state_table",
6869 "stateTable",
6870 "progress_table",
6871 "progressTable",
6872 ];
6873
6874 #[allow(clippy::enum_variant_names)]
6875 enum GeneratedField {
6876 LocalityColumns,
6877 StateTable,
6878 ProgressTable,
6879 }
6880 impl<'de> serde::Deserialize<'de> for GeneratedField {
6881 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6882 where
6883 D: serde::Deserializer<'de>,
6884 {
6885 struct GeneratedVisitor;
6886
6887 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6888 type Value = GeneratedField;
6889
6890 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6891 write!(formatter, "expected one of: {:?}", &FIELDS)
6892 }
6893
6894 #[allow(unused_variables)]
6895 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6896 where
6897 E: serde::de::Error,
6898 {
6899 match value {
6900 "localityColumns" | "locality_columns" => Ok(GeneratedField::LocalityColumns),
6901 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
6902 "progressTable" | "progress_table" => Ok(GeneratedField::ProgressTable),
6903 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6904 }
6905 }
6906 }
6907 deserializer.deserialize_identifier(GeneratedVisitor)
6908 }
6909 }
6910 struct GeneratedVisitor;
6911 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6912 type Value = LocalityProviderNode;
6913
6914 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6915 formatter.write_str("struct stream_plan.LocalityProviderNode")
6916 }
6917
6918 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalityProviderNode, V::Error>
6919 where
6920 V: serde::de::MapAccess<'de>,
6921 {
6922 let mut locality_columns__ = None;
6923 let mut state_table__ = None;
6924 let mut progress_table__ = None;
6925 while let Some(k) = map_.next_key()? {
6926 match k {
6927 GeneratedField::LocalityColumns => {
6928 if locality_columns__.is_some() {
6929 return Err(serde::de::Error::duplicate_field("localityColumns"));
6930 }
6931 locality_columns__ =
6932 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6933 .into_iter().map(|x| x.0).collect())
6934 ;
6935 }
6936 GeneratedField::StateTable => {
6937 if state_table__.is_some() {
6938 return Err(serde::de::Error::duplicate_field("stateTable"));
6939 }
6940 state_table__ = map_.next_value()?;
6941 }
6942 GeneratedField::ProgressTable => {
6943 if progress_table__.is_some() {
6944 return Err(serde::de::Error::duplicate_field("progressTable"));
6945 }
6946 progress_table__ = map_.next_value()?;
6947 }
6948 }
6949 }
6950 Ok(LocalityProviderNode {
6951 locality_columns: locality_columns__.unwrap_or_default(),
6952 state_table: state_table__,
6953 progress_table: progress_table__,
6954 })
6955 }
6956 }
6957 deserializer.deserialize_struct("stream_plan.LocalityProviderNode", FIELDS, GeneratedVisitor)
6958 }
6959}
6960impl serde::Serialize for LookupNode {
6961 #[allow(deprecated)]
6962 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6963 where
6964 S: serde::Serializer,
6965 {
6966 use serde::ser::SerializeStruct;
6967 let mut len = 0;
6968 if !self.arrange_key.is_empty() {
6969 len += 1;
6970 }
6971 if !self.stream_key.is_empty() {
6972 len += 1;
6973 }
6974 if self.use_current_epoch {
6975 len += 1;
6976 }
6977 if !self.column_mapping.is_empty() {
6978 len += 1;
6979 }
6980 if self.arrangement_table_info.is_some() {
6981 len += 1;
6982 }
6983 if self.arrangement_table_id.is_some() {
6984 len += 1;
6985 }
6986 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupNode", len)?;
6987 if !self.arrange_key.is_empty() {
6988 struct_ser.serialize_field("arrangeKey", &self.arrange_key)?;
6989 }
6990 if !self.stream_key.is_empty() {
6991 struct_ser.serialize_field("streamKey", &self.stream_key)?;
6992 }
6993 if self.use_current_epoch {
6994 struct_ser.serialize_field("useCurrentEpoch", &self.use_current_epoch)?;
6995 }
6996 if !self.column_mapping.is_empty() {
6997 struct_ser.serialize_field("columnMapping", &self.column_mapping)?;
6998 }
6999 if let Some(v) = self.arrangement_table_info.as_ref() {
7000 struct_ser.serialize_field("arrangementTableInfo", v)?;
7001 }
7002 if let Some(v) = self.arrangement_table_id.as_ref() {
7003 match v {
7004 lookup_node::ArrangementTableId::TableId(v) => {
7005 struct_ser.serialize_field("tableId", v)?;
7006 }
7007 lookup_node::ArrangementTableId::IndexId(v) => {
7008 struct_ser.serialize_field("indexId", v)?;
7009 }
7010 }
7011 }
7012 struct_ser.end()
7013 }
7014}
7015impl<'de> serde::Deserialize<'de> for LookupNode {
7016 #[allow(deprecated)]
7017 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7018 where
7019 D: serde::Deserializer<'de>,
7020 {
7021 const FIELDS: &[&str] = &[
7022 "arrange_key",
7023 "arrangeKey",
7024 "stream_key",
7025 "streamKey",
7026 "use_current_epoch",
7027 "useCurrentEpoch",
7028 "column_mapping",
7029 "columnMapping",
7030 "arrangement_table_info",
7031 "arrangementTableInfo",
7032 "table_id",
7033 "tableId",
7034 "index_id",
7035 "indexId",
7036 ];
7037
7038 #[allow(clippy::enum_variant_names)]
7039 enum GeneratedField {
7040 ArrangeKey,
7041 StreamKey,
7042 UseCurrentEpoch,
7043 ColumnMapping,
7044 ArrangementTableInfo,
7045 TableId,
7046 IndexId,
7047 }
7048 impl<'de> serde::Deserialize<'de> for GeneratedField {
7049 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7050 where
7051 D: serde::Deserializer<'de>,
7052 {
7053 struct GeneratedVisitor;
7054
7055 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7056 type Value = GeneratedField;
7057
7058 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7059 write!(formatter, "expected one of: {:?}", &FIELDS)
7060 }
7061
7062 #[allow(unused_variables)]
7063 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7064 where
7065 E: serde::de::Error,
7066 {
7067 match value {
7068 "arrangeKey" | "arrange_key" => Ok(GeneratedField::ArrangeKey),
7069 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
7070 "useCurrentEpoch" | "use_current_epoch" => Ok(GeneratedField::UseCurrentEpoch),
7071 "columnMapping" | "column_mapping" => Ok(GeneratedField::ColumnMapping),
7072 "arrangementTableInfo" | "arrangement_table_info" => Ok(GeneratedField::ArrangementTableInfo),
7073 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7074 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
7075 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7076 }
7077 }
7078 }
7079 deserializer.deserialize_identifier(GeneratedVisitor)
7080 }
7081 }
7082 struct GeneratedVisitor;
7083 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7084 type Value = LookupNode;
7085
7086 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7087 formatter.write_str("struct stream_plan.LookupNode")
7088 }
7089
7090 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupNode, V::Error>
7091 where
7092 V: serde::de::MapAccess<'de>,
7093 {
7094 let mut arrange_key__ = None;
7095 let mut stream_key__ = None;
7096 let mut use_current_epoch__ = None;
7097 let mut column_mapping__ = None;
7098 let mut arrangement_table_info__ = None;
7099 let mut arrangement_table_id__ = None;
7100 while let Some(k) = map_.next_key()? {
7101 match k {
7102 GeneratedField::ArrangeKey => {
7103 if arrange_key__.is_some() {
7104 return Err(serde::de::Error::duplicate_field("arrangeKey"));
7105 }
7106 arrange_key__ =
7107 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7108 .into_iter().map(|x| x.0).collect())
7109 ;
7110 }
7111 GeneratedField::StreamKey => {
7112 if stream_key__.is_some() {
7113 return Err(serde::de::Error::duplicate_field("streamKey"));
7114 }
7115 stream_key__ =
7116 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7117 .into_iter().map(|x| x.0).collect())
7118 ;
7119 }
7120 GeneratedField::UseCurrentEpoch => {
7121 if use_current_epoch__.is_some() {
7122 return Err(serde::de::Error::duplicate_field("useCurrentEpoch"));
7123 }
7124 use_current_epoch__ = Some(map_.next_value()?);
7125 }
7126 GeneratedField::ColumnMapping => {
7127 if column_mapping__.is_some() {
7128 return Err(serde::de::Error::duplicate_field("columnMapping"));
7129 }
7130 column_mapping__ =
7131 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7132 .into_iter().map(|x| x.0).collect())
7133 ;
7134 }
7135 GeneratedField::ArrangementTableInfo => {
7136 if arrangement_table_info__.is_some() {
7137 return Err(serde::de::Error::duplicate_field("arrangementTableInfo"));
7138 }
7139 arrangement_table_info__ = map_.next_value()?;
7140 }
7141 GeneratedField::TableId => {
7142 if arrangement_table_id__.is_some() {
7143 return Err(serde::de::Error::duplicate_field("tableId"));
7144 }
7145 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::TableId(x.0));
7146 }
7147 GeneratedField::IndexId => {
7148 if arrangement_table_id__.is_some() {
7149 return Err(serde::de::Error::duplicate_field("indexId"));
7150 }
7151 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::IndexId(x.0));
7152 }
7153 }
7154 }
7155 Ok(LookupNode {
7156 arrange_key: arrange_key__.unwrap_or_default(),
7157 stream_key: stream_key__.unwrap_or_default(),
7158 use_current_epoch: use_current_epoch__.unwrap_or_default(),
7159 column_mapping: column_mapping__.unwrap_or_default(),
7160 arrangement_table_info: arrangement_table_info__,
7161 arrangement_table_id: arrangement_table_id__,
7162 })
7163 }
7164 }
7165 deserializer.deserialize_struct("stream_plan.LookupNode", FIELDS, GeneratedVisitor)
7166 }
7167}
7168impl serde::Serialize for LookupUnionNode {
7169 #[allow(deprecated)]
7170 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7171 where
7172 S: serde::Serializer,
7173 {
7174 use serde::ser::SerializeStruct;
7175 let mut len = 0;
7176 if !self.order.is_empty() {
7177 len += 1;
7178 }
7179 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupUnionNode", len)?;
7180 if !self.order.is_empty() {
7181 struct_ser.serialize_field("order", &self.order)?;
7182 }
7183 struct_ser.end()
7184 }
7185}
7186impl<'de> serde::Deserialize<'de> for LookupUnionNode {
7187 #[allow(deprecated)]
7188 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7189 where
7190 D: serde::Deserializer<'de>,
7191 {
7192 const FIELDS: &[&str] = &[
7193 "order",
7194 ];
7195
7196 #[allow(clippy::enum_variant_names)]
7197 enum GeneratedField {
7198 Order,
7199 }
7200 impl<'de> serde::Deserialize<'de> for GeneratedField {
7201 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7202 where
7203 D: serde::Deserializer<'de>,
7204 {
7205 struct GeneratedVisitor;
7206
7207 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7208 type Value = GeneratedField;
7209
7210 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7211 write!(formatter, "expected one of: {:?}", &FIELDS)
7212 }
7213
7214 #[allow(unused_variables)]
7215 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7216 where
7217 E: serde::de::Error,
7218 {
7219 match value {
7220 "order" => Ok(GeneratedField::Order),
7221 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7222 }
7223 }
7224 }
7225 deserializer.deserialize_identifier(GeneratedVisitor)
7226 }
7227 }
7228 struct GeneratedVisitor;
7229 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7230 type Value = LookupUnionNode;
7231
7232 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7233 formatter.write_str("struct stream_plan.LookupUnionNode")
7234 }
7235
7236 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupUnionNode, V::Error>
7237 where
7238 V: serde::de::MapAccess<'de>,
7239 {
7240 let mut order__ = None;
7241 while let Some(k) = map_.next_key()? {
7242 match k {
7243 GeneratedField::Order => {
7244 if order__.is_some() {
7245 return Err(serde::de::Error::duplicate_field("order"));
7246 }
7247 order__ =
7248 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7249 .into_iter().map(|x| x.0).collect())
7250 ;
7251 }
7252 }
7253 }
7254 Ok(LookupUnionNode {
7255 order: order__.unwrap_or_default(),
7256 })
7257 }
7258 }
7259 deserializer.deserialize_struct("stream_plan.LookupUnionNode", FIELDS, GeneratedVisitor)
7260 }
7261}
7262impl serde::Serialize for MaterializeNode {
7263 #[allow(deprecated)]
7264 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7265 where
7266 S: serde::Serializer,
7267 {
7268 use serde::ser::SerializeStruct;
7269 let mut len = 0;
7270 if self.table_id != 0 {
7271 len += 1;
7272 }
7273 if !self.column_orders.is_empty() {
7274 len += 1;
7275 }
7276 if self.table.is_some() {
7277 len += 1;
7278 }
7279 if self.staging_table.is_some() {
7280 len += 1;
7281 }
7282 if self.refresh_progress_table.is_some() {
7283 len += 1;
7284 }
7285 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializeNode", len)?;
7286 if self.table_id != 0 {
7287 struct_ser.serialize_field("tableId", &self.table_id)?;
7288 }
7289 if !self.column_orders.is_empty() {
7290 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
7291 }
7292 if let Some(v) = self.table.as_ref() {
7293 struct_ser.serialize_field("table", v)?;
7294 }
7295 if let Some(v) = self.staging_table.as_ref() {
7296 struct_ser.serialize_field("stagingTable", v)?;
7297 }
7298 if let Some(v) = self.refresh_progress_table.as_ref() {
7299 struct_ser.serialize_field("refreshProgressTable", v)?;
7300 }
7301 struct_ser.end()
7302 }
7303}
7304impl<'de> serde::Deserialize<'de> for MaterializeNode {
7305 #[allow(deprecated)]
7306 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7307 where
7308 D: serde::Deserializer<'de>,
7309 {
7310 const FIELDS: &[&str] = &[
7311 "table_id",
7312 "tableId",
7313 "column_orders",
7314 "columnOrders",
7315 "table",
7316 "staging_table",
7317 "stagingTable",
7318 "refresh_progress_table",
7319 "refreshProgressTable",
7320 ];
7321
7322 #[allow(clippy::enum_variant_names)]
7323 enum GeneratedField {
7324 TableId,
7325 ColumnOrders,
7326 Table,
7327 StagingTable,
7328 RefreshProgressTable,
7329 }
7330 impl<'de> serde::Deserialize<'de> for GeneratedField {
7331 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7332 where
7333 D: serde::Deserializer<'de>,
7334 {
7335 struct GeneratedVisitor;
7336
7337 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7338 type Value = GeneratedField;
7339
7340 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7341 write!(formatter, "expected one of: {:?}", &FIELDS)
7342 }
7343
7344 #[allow(unused_variables)]
7345 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7346 where
7347 E: serde::de::Error,
7348 {
7349 match value {
7350 "tableId" | "table_id" => Ok(GeneratedField::TableId),
7351 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
7352 "table" => Ok(GeneratedField::Table),
7353 "stagingTable" | "staging_table" => Ok(GeneratedField::StagingTable),
7354 "refreshProgressTable" | "refresh_progress_table" => Ok(GeneratedField::RefreshProgressTable),
7355 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7356 }
7357 }
7358 }
7359 deserializer.deserialize_identifier(GeneratedVisitor)
7360 }
7361 }
7362 struct GeneratedVisitor;
7363 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7364 type Value = MaterializeNode;
7365
7366 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7367 formatter.write_str("struct stream_plan.MaterializeNode")
7368 }
7369
7370 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializeNode, V::Error>
7371 where
7372 V: serde::de::MapAccess<'de>,
7373 {
7374 let mut table_id__ = None;
7375 let mut column_orders__ = None;
7376 let mut table__ = None;
7377 let mut staging_table__ = None;
7378 let mut refresh_progress_table__ = None;
7379 while let Some(k) = map_.next_key()? {
7380 match k {
7381 GeneratedField::TableId => {
7382 if table_id__.is_some() {
7383 return Err(serde::de::Error::duplicate_field("tableId"));
7384 }
7385 table_id__ =
7386 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7387 ;
7388 }
7389 GeneratedField::ColumnOrders => {
7390 if column_orders__.is_some() {
7391 return Err(serde::de::Error::duplicate_field("columnOrders"));
7392 }
7393 column_orders__ = Some(map_.next_value()?);
7394 }
7395 GeneratedField::Table => {
7396 if table__.is_some() {
7397 return Err(serde::de::Error::duplicate_field("table"));
7398 }
7399 table__ = map_.next_value()?;
7400 }
7401 GeneratedField::StagingTable => {
7402 if staging_table__.is_some() {
7403 return Err(serde::de::Error::duplicate_field("stagingTable"));
7404 }
7405 staging_table__ = map_.next_value()?;
7406 }
7407 GeneratedField::RefreshProgressTable => {
7408 if refresh_progress_table__.is_some() {
7409 return Err(serde::de::Error::duplicate_field("refreshProgressTable"));
7410 }
7411 refresh_progress_table__ = map_.next_value()?;
7412 }
7413 }
7414 }
7415 Ok(MaterializeNode {
7416 table_id: table_id__.unwrap_or_default(),
7417 column_orders: column_orders__.unwrap_or_default(),
7418 table: table__,
7419 staging_table: staging_table__,
7420 refresh_progress_table: refresh_progress_table__,
7421 })
7422 }
7423 }
7424 deserializer.deserialize_struct("stream_plan.MaterializeNode", FIELDS, GeneratedVisitor)
7425 }
7426}
7427impl serde::Serialize for MaterializedExprsNode {
7428 #[allow(deprecated)]
7429 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7430 where
7431 S: serde::Serializer,
7432 {
7433 use serde::ser::SerializeStruct;
7434 let mut len = 0;
7435 if !self.exprs.is_empty() {
7436 len += 1;
7437 }
7438 if self.state_table.is_some() {
7439 len += 1;
7440 }
7441 if self.state_clean_col_idx.is_some() {
7442 len += 1;
7443 }
7444 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializedExprsNode", len)?;
7445 if !self.exprs.is_empty() {
7446 struct_ser.serialize_field("exprs", &self.exprs)?;
7447 }
7448 if let Some(v) = self.state_table.as_ref() {
7449 struct_ser.serialize_field("stateTable", v)?;
7450 }
7451 if let Some(v) = self.state_clean_col_idx.as_ref() {
7452 struct_ser.serialize_field("stateCleanColIdx", v)?;
7453 }
7454 struct_ser.end()
7455 }
7456}
7457impl<'de> serde::Deserialize<'de> for MaterializedExprsNode {
7458 #[allow(deprecated)]
7459 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7460 where
7461 D: serde::Deserializer<'de>,
7462 {
7463 const FIELDS: &[&str] = &[
7464 "exprs",
7465 "state_table",
7466 "stateTable",
7467 "state_clean_col_idx",
7468 "stateCleanColIdx",
7469 ];
7470
7471 #[allow(clippy::enum_variant_names)]
7472 enum GeneratedField {
7473 Exprs,
7474 StateTable,
7475 StateCleanColIdx,
7476 }
7477 impl<'de> serde::Deserialize<'de> for GeneratedField {
7478 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7479 where
7480 D: serde::Deserializer<'de>,
7481 {
7482 struct GeneratedVisitor;
7483
7484 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7485 type Value = GeneratedField;
7486
7487 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7488 write!(formatter, "expected one of: {:?}", &FIELDS)
7489 }
7490
7491 #[allow(unused_variables)]
7492 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7493 where
7494 E: serde::de::Error,
7495 {
7496 match value {
7497 "exprs" => Ok(GeneratedField::Exprs),
7498 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7499 "stateCleanColIdx" | "state_clean_col_idx" => Ok(GeneratedField::StateCleanColIdx),
7500 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7501 }
7502 }
7503 }
7504 deserializer.deserialize_identifier(GeneratedVisitor)
7505 }
7506 }
7507 struct GeneratedVisitor;
7508 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7509 type Value = MaterializedExprsNode;
7510
7511 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7512 formatter.write_str("struct stream_plan.MaterializedExprsNode")
7513 }
7514
7515 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializedExprsNode, V::Error>
7516 where
7517 V: serde::de::MapAccess<'de>,
7518 {
7519 let mut exprs__ = None;
7520 let mut state_table__ = None;
7521 let mut state_clean_col_idx__ = None;
7522 while let Some(k) = map_.next_key()? {
7523 match k {
7524 GeneratedField::Exprs => {
7525 if exprs__.is_some() {
7526 return Err(serde::de::Error::duplicate_field("exprs"));
7527 }
7528 exprs__ = Some(map_.next_value()?);
7529 }
7530 GeneratedField::StateTable => {
7531 if state_table__.is_some() {
7532 return Err(serde::de::Error::duplicate_field("stateTable"));
7533 }
7534 state_table__ = map_.next_value()?;
7535 }
7536 GeneratedField::StateCleanColIdx => {
7537 if state_clean_col_idx__.is_some() {
7538 return Err(serde::de::Error::duplicate_field("stateCleanColIdx"));
7539 }
7540 state_clean_col_idx__ =
7541 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
7542 ;
7543 }
7544 }
7545 }
7546 Ok(MaterializedExprsNode {
7547 exprs: exprs__.unwrap_or_default(),
7548 state_table: state_table__,
7549 state_clean_col_idx: state_clean_col_idx__,
7550 })
7551 }
7552 }
7553 deserializer.deserialize_struct("stream_plan.MaterializedExprsNode", FIELDS, GeneratedVisitor)
7554 }
7555}
7556impl serde::Serialize for MergeNode {
7557 #[allow(deprecated)]
7558 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7559 where
7560 S: serde::Serializer,
7561 {
7562 use serde::ser::SerializeStruct;
7563 let mut len = 0;
7564 if !self.upstream_actor_id.is_empty() {
7565 len += 1;
7566 }
7567 if self.upstream_fragment_id != 0 {
7568 len += 1;
7569 }
7570 if self.upstream_dispatcher_type != 0 {
7571 len += 1;
7572 }
7573 if !self.fields.is_empty() {
7574 len += 1;
7575 }
7576 let mut struct_ser = serializer.serialize_struct("stream_plan.MergeNode", len)?;
7577 if !self.upstream_actor_id.is_empty() {
7578 struct_ser.serialize_field("upstreamActorId", &self.upstream_actor_id)?;
7579 }
7580 if self.upstream_fragment_id != 0 {
7581 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
7582 }
7583 if self.upstream_dispatcher_type != 0 {
7584 let v = DispatcherType::try_from(self.upstream_dispatcher_type)
7585 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.upstream_dispatcher_type)))?;
7586 struct_ser.serialize_field("upstreamDispatcherType", &v)?;
7587 }
7588 if !self.fields.is_empty() {
7589 struct_ser.serialize_field("fields", &self.fields)?;
7590 }
7591 struct_ser.end()
7592 }
7593}
7594impl<'de> serde::Deserialize<'de> for MergeNode {
7595 #[allow(deprecated)]
7596 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7597 where
7598 D: serde::Deserializer<'de>,
7599 {
7600 const FIELDS: &[&str] = &[
7601 "upstream_actor_id",
7602 "upstreamActorId",
7603 "upstream_fragment_id",
7604 "upstreamFragmentId",
7605 "upstream_dispatcher_type",
7606 "upstreamDispatcherType",
7607 "fields",
7608 ];
7609
7610 #[allow(clippy::enum_variant_names)]
7611 enum GeneratedField {
7612 UpstreamActorId,
7613 UpstreamFragmentId,
7614 UpstreamDispatcherType,
7615 Fields,
7616 }
7617 impl<'de> serde::Deserialize<'de> for GeneratedField {
7618 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7619 where
7620 D: serde::Deserializer<'de>,
7621 {
7622 struct GeneratedVisitor;
7623
7624 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7625 type Value = GeneratedField;
7626
7627 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7628 write!(formatter, "expected one of: {:?}", &FIELDS)
7629 }
7630
7631 #[allow(unused_variables)]
7632 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7633 where
7634 E: serde::de::Error,
7635 {
7636 match value {
7637 "upstreamActorId" | "upstream_actor_id" => Ok(GeneratedField::UpstreamActorId),
7638 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
7639 "upstreamDispatcherType" | "upstream_dispatcher_type" => Ok(GeneratedField::UpstreamDispatcherType),
7640 "fields" => Ok(GeneratedField::Fields),
7641 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7642 }
7643 }
7644 }
7645 deserializer.deserialize_identifier(GeneratedVisitor)
7646 }
7647 }
7648 struct GeneratedVisitor;
7649 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7650 type Value = MergeNode;
7651
7652 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7653 formatter.write_str("struct stream_plan.MergeNode")
7654 }
7655
7656 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeNode, V::Error>
7657 where
7658 V: serde::de::MapAccess<'de>,
7659 {
7660 let mut upstream_actor_id__ = None;
7661 let mut upstream_fragment_id__ = None;
7662 let mut upstream_dispatcher_type__ = None;
7663 let mut fields__ = None;
7664 while let Some(k) = map_.next_key()? {
7665 match k {
7666 GeneratedField::UpstreamActorId => {
7667 if upstream_actor_id__.is_some() {
7668 return Err(serde::de::Error::duplicate_field("upstreamActorId"));
7669 }
7670 upstream_actor_id__ =
7671 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7672 .into_iter().map(|x| x.0).collect())
7673 ;
7674 }
7675 GeneratedField::UpstreamFragmentId => {
7676 if upstream_fragment_id__.is_some() {
7677 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
7678 }
7679 upstream_fragment_id__ =
7680 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7681 ;
7682 }
7683 GeneratedField::UpstreamDispatcherType => {
7684 if upstream_dispatcher_type__.is_some() {
7685 return Err(serde::de::Error::duplicate_field("upstreamDispatcherType"));
7686 }
7687 upstream_dispatcher_type__ = Some(map_.next_value::<DispatcherType>()? as i32);
7688 }
7689 GeneratedField::Fields => {
7690 if fields__.is_some() {
7691 return Err(serde::de::Error::duplicate_field("fields"));
7692 }
7693 fields__ = Some(map_.next_value()?);
7694 }
7695 }
7696 }
7697 Ok(MergeNode {
7698 upstream_actor_id: upstream_actor_id__.unwrap_or_default(),
7699 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
7700 upstream_dispatcher_type: upstream_dispatcher_type__.unwrap_or_default(),
7701 fields: fields__.unwrap_or_default(),
7702 })
7703 }
7704 }
7705 deserializer.deserialize_struct("stream_plan.MergeNode", FIELDS, GeneratedVisitor)
7706 }
7707}
7708impl serde::Serialize for NoOpNode {
7709 #[allow(deprecated)]
7710 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7711 where
7712 S: serde::Serializer,
7713 {
7714 use serde::ser::SerializeStruct;
7715 let len = 0;
7716 let struct_ser = serializer.serialize_struct("stream_plan.NoOpNode", len)?;
7717 struct_ser.end()
7718 }
7719}
7720impl<'de> serde::Deserialize<'de> for NoOpNode {
7721 #[allow(deprecated)]
7722 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7723 where
7724 D: serde::Deserializer<'de>,
7725 {
7726 const FIELDS: &[&str] = &[
7727 ];
7728
7729 #[allow(clippy::enum_variant_names)]
7730 enum GeneratedField {
7731 }
7732 impl<'de> serde::Deserialize<'de> for GeneratedField {
7733 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7734 where
7735 D: serde::Deserializer<'de>,
7736 {
7737 struct GeneratedVisitor;
7738
7739 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7740 type Value = GeneratedField;
7741
7742 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7743 write!(formatter, "expected one of: {:?}", &FIELDS)
7744 }
7745
7746 #[allow(unused_variables)]
7747 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7748 where
7749 E: serde::de::Error,
7750 {
7751 Err(serde::de::Error::unknown_field(value, FIELDS))
7752 }
7753 }
7754 deserializer.deserialize_identifier(GeneratedVisitor)
7755 }
7756 }
7757 struct GeneratedVisitor;
7758 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7759 type Value = NoOpNode;
7760
7761 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7762 formatter.write_str("struct stream_plan.NoOpNode")
7763 }
7764
7765 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NoOpNode, V::Error>
7766 where
7767 V: serde::de::MapAccess<'de>,
7768 {
7769 while map_.next_key::<GeneratedField>()?.is_some() {
7770 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7771 }
7772 Ok(NoOpNode {
7773 })
7774 }
7775 }
7776 deserializer.deserialize_struct("stream_plan.NoOpNode", FIELDS, GeneratedVisitor)
7777 }
7778}
7779impl serde::Serialize for NowModeGenerateSeries {
7780 #[allow(deprecated)]
7781 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7782 where
7783 S: serde::Serializer,
7784 {
7785 use serde::ser::SerializeStruct;
7786 let mut len = 0;
7787 if self.start_timestamp.is_some() {
7788 len += 1;
7789 }
7790 if self.interval.is_some() {
7791 len += 1;
7792 }
7793 let mut struct_ser = serializer.serialize_struct("stream_plan.NowModeGenerateSeries", len)?;
7794 if let Some(v) = self.start_timestamp.as_ref() {
7795 struct_ser.serialize_field("startTimestamp", v)?;
7796 }
7797 if let Some(v) = self.interval.as_ref() {
7798 struct_ser.serialize_field("interval", v)?;
7799 }
7800 struct_ser.end()
7801 }
7802}
7803impl<'de> serde::Deserialize<'de> for NowModeGenerateSeries {
7804 #[allow(deprecated)]
7805 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7806 where
7807 D: serde::Deserializer<'de>,
7808 {
7809 const FIELDS: &[&str] = &[
7810 "start_timestamp",
7811 "startTimestamp",
7812 "interval",
7813 ];
7814
7815 #[allow(clippy::enum_variant_names)]
7816 enum GeneratedField {
7817 StartTimestamp,
7818 Interval,
7819 }
7820 impl<'de> serde::Deserialize<'de> for GeneratedField {
7821 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7822 where
7823 D: serde::Deserializer<'de>,
7824 {
7825 struct GeneratedVisitor;
7826
7827 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7828 type Value = GeneratedField;
7829
7830 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7831 write!(formatter, "expected one of: {:?}", &FIELDS)
7832 }
7833
7834 #[allow(unused_variables)]
7835 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7836 where
7837 E: serde::de::Error,
7838 {
7839 match value {
7840 "startTimestamp" | "start_timestamp" => Ok(GeneratedField::StartTimestamp),
7841 "interval" => Ok(GeneratedField::Interval),
7842 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7843 }
7844 }
7845 }
7846 deserializer.deserialize_identifier(GeneratedVisitor)
7847 }
7848 }
7849 struct GeneratedVisitor;
7850 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7851 type Value = NowModeGenerateSeries;
7852
7853 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7854 formatter.write_str("struct stream_plan.NowModeGenerateSeries")
7855 }
7856
7857 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeGenerateSeries, V::Error>
7858 where
7859 V: serde::de::MapAccess<'de>,
7860 {
7861 let mut start_timestamp__ = None;
7862 let mut interval__ = None;
7863 while let Some(k) = map_.next_key()? {
7864 match k {
7865 GeneratedField::StartTimestamp => {
7866 if start_timestamp__.is_some() {
7867 return Err(serde::de::Error::duplicate_field("startTimestamp"));
7868 }
7869 start_timestamp__ = map_.next_value()?;
7870 }
7871 GeneratedField::Interval => {
7872 if interval__.is_some() {
7873 return Err(serde::de::Error::duplicate_field("interval"));
7874 }
7875 interval__ = map_.next_value()?;
7876 }
7877 }
7878 }
7879 Ok(NowModeGenerateSeries {
7880 start_timestamp: start_timestamp__,
7881 interval: interval__,
7882 })
7883 }
7884 }
7885 deserializer.deserialize_struct("stream_plan.NowModeGenerateSeries", FIELDS, GeneratedVisitor)
7886 }
7887}
7888impl serde::Serialize for NowModeUpdateCurrent {
7889 #[allow(deprecated)]
7890 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7891 where
7892 S: serde::Serializer,
7893 {
7894 use serde::ser::SerializeStruct;
7895 let len = 0;
7896 let struct_ser = serializer.serialize_struct("stream_plan.NowModeUpdateCurrent", len)?;
7897 struct_ser.end()
7898 }
7899}
7900impl<'de> serde::Deserialize<'de> for NowModeUpdateCurrent {
7901 #[allow(deprecated)]
7902 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7903 where
7904 D: serde::Deserializer<'de>,
7905 {
7906 const FIELDS: &[&str] = &[
7907 ];
7908
7909 #[allow(clippy::enum_variant_names)]
7910 enum GeneratedField {
7911 }
7912 impl<'de> serde::Deserialize<'de> for GeneratedField {
7913 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7914 where
7915 D: serde::Deserializer<'de>,
7916 {
7917 struct GeneratedVisitor;
7918
7919 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7920 type Value = GeneratedField;
7921
7922 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7923 write!(formatter, "expected one of: {:?}", &FIELDS)
7924 }
7925
7926 #[allow(unused_variables)]
7927 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7928 where
7929 E: serde::de::Error,
7930 {
7931 Err(serde::de::Error::unknown_field(value, FIELDS))
7932 }
7933 }
7934 deserializer.deserialize_identifier(GeneratedVisitor)
7935 }
7936 }
7937 struct GeneratedVisitor;
7938 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7939 type Value = NowModeUpdateCurrent;
7940
7941 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7942 formatter.write_str("struct stream_plan.NowModeUpdateCurrent")
7943 }
7944
7945 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeUpdateCurrent, V::Error>
7946 where
7947 V: serde::de::MapAccess<'de>,
7948 {
7949 while map_.next_key::<GeneratedField>()?.is_some() {
7950 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7951 }
7952 Ok(NowModeUpdateCurrent {
7953 })
7954 }
7955 }
7956 deserializer.deserialize_struct("stream_plan.NowModeUpdateCurrent", FIELDS, GeneratedVisitor)
7957 }
7958}
7959impl serde::Serialize for NowNode {
7960 #[allow(deprecated)]
7961 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7962 where
7963 S: serde::Serializer,
7964 {
7965 use serde::ser::SerializeStruct;
7966 let mut len = 0;
7967 if self.state_table.is_some() {
7968 len += 1;
7969 }
7970 if self.mode.is_some() {
7971 len += 1;
7972 }
7973 let mut struct_ser = serializer.serialize_struct("stream_plan.NowNode", len)?;
7974 if let Some(v) = self.state_table.as_ref() {
7975 struct_ser.serialize_field("stateTable", v)?;
7976 }
7977 if let Some(v) = self.mode.as_ref() {
7978 match v {
7979 now_node::Mode::UpdateCurrent(v) => {
7980 struct_ser.serialize_field("updateCurrent", v)?;
7981 }
7982 now_node::Mode::GenerateSeries(v) => {
7983 struct_ser.serialize_field("generateSeries", v)?;
7984 }
7985 }
7986 }
7987 struct_ser.end()
7988 }
7989}
7990impl<'de> serde::Deserialize<'de> for NowNode {
7991 #[allow(deprecated)]
7992 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7993 where
7994 D: serde::Deserializer<'de>,
7995 {
7996 const FIELDS: &[&str] = &[
7997 "state_table",
7998 "stateTable",
7999 "update_current",
8000 "updateCurrent",
8001 "generate_series",
8002 "generateSeries",
8003 ];
8004
8005 #[allow(clippy::enum_variant_names)]
8006 enum GeneratedField {
8007 StateTable,
8008 UpdateCurrent,
8009 GenerateSeries,
8010 }
8011 impl<'de> serde::Deserialize<'de> for GeneratedField {
8012 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8013 where
8014 D: serde::Deserializer<'de>,
8015 {
8016 struct GeneratedVisitor;
8017
8018 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8019 type Value = GeneratedField;
8020
8021 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8022 write!(formatter, "expected one of: {:?}", &FIELDS)
8023 }
8024
8025 #[allow(unused_variables)]
8026 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8027 where
8028 E: serde::de::Error,
8029 {
8030 match value {
8031 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
8032 "updateCurrent" | "update_current" => Ok(GeneratedField::UpdateCurrent),
8033 "generateSeries" | "generate_series" => Ok(GeneratedField::GenerateSeries),
8034 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8035 }
8036 }
8037 }
8038 deserializer.deserialize_identifier(GeneratedVisitor)
8039 }
8040 }
8041 struct GeneratedVisitor;
8042 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8043 type Value = NowNode;
8044
8045 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8046 formatter.write_str("struct stream_plan.NowNode")
8047 }
8048
8049 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowNode, V::Error>
8050 where
8051 V: serde::de::MapAccess<'de>,
8052 {
8053 let mut state_table__ = None;
8054 let mut mode__ = None;
8055 while let Some(k) = map_.next_key()? {
8056 match k {
8057 GeneratedField::StateTable => {
8058 if state_table__.is_some() {
8059 return Err(serde::de::Error::duplicate_field("stateTable"));
8060 }
8061 state_table__ = map_.next_value()?;
8062 }
8063 GeneratedField::UpdateCurrent => {
8064 if mode__.is_some() {
8065 return Err(serde::de::Error::duplicate_field("updateCurrent"));
8066 }
8067 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::UpdateCurrent)
8068;
8069 }
8070 GeneratedField::GenerateSeries => {
8071 if mode__.is_some() {
8072 return Err(serde::de::Error::duplicate_field("generateSeries"));
8073 }
8074 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::GenerateSeries)
8075;
8076 }
8077 }
8078 }
8079 Ok(NowNode {
8080 state_table: state_table__,
8081 mode: mode__,
8082 })
8083 }
8084 }
8085 deserializer.deserialize_struct("stream_plan.NowNode", FIELDS, GeneratedVisitor)
8086 }
8087}
8088impl serde::Serialize for OverWindowCachePolicy {
8089 #[allow(deprecated)]
8090 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8091 where
8092 S: serde::Serializer,
8093 {
8094 let variant = match self {
8095 Self::Unspecified => "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
8096 Self::Full => "OVER_WINDOW_CACHE_POLICY_FULL",
8097 Self::Recent => "OVER_WINDOW_CACHE_POLICY_RECENT",
8098 Self::RecentFirstN => "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
8099 Self::RecentLastN => "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
8100 };
8101 serializer.serialize_str(variant)
8102 }
8103}
8104impl<'de> serde::Deserialize<'de> for OverWindowCachePolicy {
8105 #[allow(deprecated)]
8106 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8107 where
8108 D: serde::Deserializer<'de>,
8109 {
8110 const FIELDS: &[&str] = &[
8111 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
8112 "OVER_WINDOW_CACHE_POLICY_FULL",
8113 "OVER_WINDOW_CACHE_POLICY_RECENT",
8114 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
8115 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
8116 ];
8117
8118 struct GeneratedVisitor;
8119
8120 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8121 type Value = OverWindowCachePolicy;
8122
8123 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8124 write!(formatter, "expected one of: {:?}", &FIELDS)
8125 }
8126
8127 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8128 where
8129 E: serde::de::Error,
8130 {
8131 i32::try_from(v)
8132 .ok()
8133 .and_then(|x| x.try_into().ok())
8134 .ok_or_else(|| {
8135 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8136 })
8137 }
8138
8139 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8140 where
8141 E: serde::de::Error,
8142 {
8143 i32::try_from(v)
8144 .ok()
8145 .and_then(|x| x.try_into().ok())
8146 .ok_or_else(|| {
8147 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8148 })
8149 }
8150
8151 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8152 where
8153 E: serde::de::Error,
8154 {
8155 match value {
8156 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED" => Ok(OverWindowCachePolicy::Unspecified),
8157 "OVER_WINDOW_CACHE_POLICY_FULL" => Ok(OverWindowCachePolicy::Full),
8158 "OVER_WINDOW_CACHE_POLICY_RECENT" => Ok(OverWindowCachePolicy::Recent),
8159 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N" => Ok(OverWindowCachePolicy::RecentFirstN),
8160 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N" => Ok(OverWindowCachePolicy::RecentLastN),
8161 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8162 }
8163 }
8164 }
8165 deserializer.deserialize_any(GeneratedVisitor)
8166 }
8167}
8168impl serde::Serialize for OverWindowNode {
8169 #[allow(deprecated)]
8170 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8171 where
8172 S: serde::Serializer,
8173 {
8174 use serde::ser::SerializeStruct;
8175 let mut len = 0;
8176 if !self.calls.is_empty() {
8177 len += 1;
8178 }
8179 if !self.partition_by.is_empty() {
8180 len += 1;
8181 }
8182 if !self.order_by.is_empty() {
8183 len += 1;
8184 }
8185 if self.state_table.is_some() {
8186 len += 1;
8187 }
8188 if self.cache_policy != 0 {
8189 len += 1;
8190 }
8191 let mut struct_ser = serializer.serialize_struct("stream_plan.OverWindowNode", len)?;
8192 if !self.calls.is_empty() {
8193 struct_ser.serialize_field("calls", &self.calls)?;
8194 }
8195 if !self.partition_by.is_empty() {
8196 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
8197 }
8198 if !self.order_by.is_empty() {
8199 struct_ser.serialize_field("orderBy", &self.order_by)?;
8200 }
8201 if let Some(v) = self.state_table.as_ref() {
8202 struct_ser.serialize_field("stateTable", v)?;
8203 }
8204 if self.cache_policy != 0 {
8205 let v = OverWindowCachePolicy::try_from(self.cache_policy)
8206 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cache_policy)))?;
8207 struct_ser.serialize_field("cachePolicy", &v)?;
8208 }
8209 struct_ser.end()
8210 }
8211}
8212impl<'de> serde::Deserialize<'de> for OverWindowNode {
8213 #[allow(deprecated)]
8214 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8215 where
8216 D: serde::Deserializer<'de>,
8217 {
8218 const FIELDS: &[&str] = &[
8219 "calls",
8220 "partition_by",
8221 "partitionBy",
8222 "order_by",
8223 "orderBy",
8224 "state_table",
8225 "stateTable",
8226 "cache_policy",
8227 "cachePolicy",
8228 ];
8229
8230 #[allow(clippy::enum_variant_names)]
8231 enum GeneratedField {
8232 Calls,
8233 PartitionBy,
8234 OrderBy,
8235 StateTable,
8236 CachePolicy,
8237 }
8238 impl<'de> serde::Deserialize<'de> for GeneratedField {
8239 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8240 where
8241 D: serde::Deserializer<'de>,
8242 {
8243 struct GeneratedVisitor;
8244
8245 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8246 type Value = GeneratedField;
8247
8248 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8249 write!(formatter, "expected one of: {:?}", &FIELDS)
8250 }
8251
8252 #[allow(unused_variables)]
8253 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8254 where
8255 E: serde::de::Error,
8256 {
8257 match value {
8258 "calls" => Ok(GeneratedField::Calls),
8259 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
8260 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
8261 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
8262 "cachePolicy" | "cache_policy" => Ok(GeneratedField::CachePolicy),
8263 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8264 }
8265 }
8266 }
8267 deserializer.deserialize_identifier(GeneratedVisitor)
8268 }
8269 }
8270 struct GeneratedVisitor;
8271 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8272 type Value = OverWindowNode;
8273
8274 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8275 formatter.write_str("struct stream_plan.OverWindowNode")
8276 }
8277
8278 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverWindowNode, V::Error>
8279 where
8280 V: serde::de::MapAccess<'de>,
8281 {
8282 let mut calls__ = None;
8283 let mut partition_by__ = None;
8284 let mut order_by__ = None;
8285 let mut state_table__ = None;
8286 let mut cache_policy__ = None;
8287 while let Some(k) = map_.next_key()? {
8288 match k {
8289 GeneratedField::Calls => {
8290 if calls__.is_some() {
8291 return Err(serde::de::Error::duplicate_field("calls"));
8292 }
8293 calls__ = Some(map_.next_value()?);
8294 }
8295 GeneratedField::PartitionBy => {
8296 if partition_by__.is_some() {
8297 return Err(serde::de::Error::duplicate_field("partitionBy"));
8298 }
8299 partition_by__ =
8300 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8301 .into_iter().map(|x| x.0).collect())
8302 ;
8303 }
8304 GeneratedField::OrderBy => {
8305 if order_by__.is_some() {
8306 return Err(serde::de::Error::duplicate_field("orderBy"));
8307 }
8308 order_by__ = Some(map_.next_value()?);
8309 }
8310 GeneratedField::StateTable => {
8311 if state_table__.is_some() {
8312 return Err(serde::de::Error::duplicate_field("stateTable"));
8313 }
8314 state_table__ = map_.next_value()?;
8315 }
8316 GeneratedField::CachePolicy => {
8317 if cache_policy__.is_some() {
8318 return Err(serde::de::Error::duplicate_field("cachePolicy"));
8319 }
8320 cache_policy__ = Some(map_.next_value::<OverWindowCachePolicy>()? as i32);
8321 }
8322 }
8323 }
8324 Ok(OverWindowNode {
8325 calls: calls__.unwrap_or_default(),
8326 partition_by: partition_by__.unwrap_or_default(),
8327 order_by: order_by__.unwrap_or_default(),
8328 state_table: state_table__,
8329 cache_policy: cache_policy__.unwrap_or_default(),
8330 })
8331 }
8332 }
8333 deserializer.deserialize_struct("stream_plan.OverWindowNode", FIELDS, GeneratedVisitor)
8334 }
8335}
8336impl serde::Serialize for PauseMutation {
8337 #[allow(deprecated)]
8338 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8339 where
8340 S: serde::Serializer,
8341 {
8342 use serde::ser::SerializeStruct;
8343 let len = 0;
8344 let struct_ser = serializer.serialize_struct("stream_plan.PauseMutation", len)?;
8345 struct_ser.end()
8346 }
8347}
8348impl<'de> serde::Deserialize<'de> for PauseMutation {
8349 #[allow(deprecated)]
8350 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8351 where
8352 D: serde::Deserializer<'de>,
8353 {
8354 const FIELDS: &[&str] = &[
8355 ];
8356
8357 #[allow(clippy::enum_variant_names)]
8358 enum GeneratedField {
8359 }
8360 impl<'de> serde::Deserialize<'de> for GeneratedField {
8361 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8362 where
8363 D: serde::Deserializer<'de>,
8364 {
8365 struct GeneratedVisitor;
8366
8367 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8368 type Value = GeneratedField;
8369
8370 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8371 write!(formatter, "expected one of: {:?}", &FIELDS)
8372 }
8373
8374 #[allow(unused_variables)]
8375 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8376 where
8377 E: serde::de::Error,
8378 {
8379 Err(serde::de::Error::unknown_field(value, FIELDS))
8380 }
8381 }
8382 deserializer.deserialize_identifier(GeneratedVisitor)
8383 }
8384 }
8385 struct GeneratedVisitor;
8386 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8387 type Value = PauseMutation;
8388
8389 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8390 formatter.write_str("struct stream_plan.PauseMutation")
8391 }
8392
8393 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseMutation, V::Error>
8394 where
8395 V: serde::de::MapAccess<'de>,
8396 {
8397 while map_.next_key::<GeneratedField>()?.is_some() {
8398 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8399 }
8400 Ok(PauseMutation {
8401 })
8402 }
8403 }
8404 deserializer.deserialize_struct("stream_plan.PauseMutation", FIELDS, GeneratedVisitor)
8405 }
8406}
8407impl serde::Serialize for ProjectNode {
8408 #[allow(deprecated)]
8409 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8410 where
8411 S: serde::Serializer,
8412 {
8413 use serde::ser::SerializeStruct;
8414 let mut len = 0;
8415 if !self.select_list.is_empty() {
8416 len += 1;
8417 }
8418 if !self.watermark_input_cols.is_empty() {
8419 len += 1;
8420 }
8421 if !self.watermark_output_cols.is_empty() {
8422 len += 1;
8423 }
8424 if !self.nondecreasing_exprs.is_empty() {
8425 len += 1;
8426 }
8427 if self.noop_update_hint {
8428 len += 1;
8429 }
8430 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectNode", len)?;
8431 if !self.select_list.is_empty() {
8432 struct_ser.serialize_field("selectList", &self.select_list)?;
8433 }
8434 if !self.watermark_input_cols.is_empty() {
8435 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
8436 }
8437 if !self.watermark_output_cols.is_empty() {
8438 struct_ser.serialize_field("watermarkOutputCols", &self.watermark_output_cols)?;
8439 }
8440 if !self.nondecreasing_exprs.is_empty() {
8441 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
8442 }
8443 if self.noop_update_hint {
8444 struct_ser.serialize_field("noopUpdateHint", &self.noop_update_hint)?;
8445 }
8446 struct_ser.end()
8447 }
8448}
8449impl<'de> serde::Deserialize<'de> for ProjectNode {
8450 #[allow(deprecated)]
8451 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8452 where
8453 D: serde::Deserializer<'de>,
8454 {
8455 const FIELDS: &[&str] = &[
8456 "select_list",
8457 "selectList",
8458 "watermark_input_cols",
8459 "watermarkInputCols",
8460 "watermark_output_cols",
8461 "watermarkOutputCols",
8462 "nondecreasing_exprs",
8463 "nondecreasingExprs",
8464 "noop_update_hint",
8465 "noopUpdateHint",
8466 ];
8467
8468 #[allow(clippy::enum_variant_names)]
8469 enum GeneratedField {
8470 SelectList,
8471 WatermarkInputCols,
8472 WatermarkOutputCols,
8473 NondecreasingExprs,
8474 NoopUpdateHint,
8475 }
8476 impl<'de> serde::Deserialize<'de> for GeneratedField {
8477 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8478 where
8479 D: serde::Deserializer<'de>,
8480 {
8481 struct GeneratedVisitor;
8482
8483 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8484 type Value = GeneratedField;
8485
8486 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8487 write!(formatter, "expected one of: {:?}", &FIELDS)
8488 }
8489
8490 #[allow(unused_variables)]
8491 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8492 where
8493 E: serde::de::Error,
8494 {
8495 match value {
8496 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
8497 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
8498 "watermarkOutputCols" | "watermark_output_cols" => Ok(GeneratedField::WatermarkOutputCols),
8499 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
8500 "noopUpdateHint" | "noop_update_hint" => Ok(GeneratedField::NoopUpdateHint),
8501 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8502 }
8503 }
8504 }
8505 deserializer.deserialize_identifier(GeneratedVisitor)
8506 }
8507 }
8508 struct GeneratedVisitor;
8509 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8510 type Value = ProjectNode;
8511
8512 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8513 formatter.write_str("struct stream_plan.ProjectNode")
8514 }
8515
8516 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
8517 where
8518 V: serde::de::MapAccess<'de>,
8519 {
8520 let mut select_list__ = None;
8521 let mut watermark_input_cols__ = None;
8522 let mut watermark_output_cols__ = None;
8523 let mut nondecreasing_exprs__ = None;
8524 let mut noop_update_hint__ = None;
8525 while let Some(k) = map_.next_key()? {
8526 match k {
8527 GeneratedField::SelectList => {
8528 if select_list__.is_some() {
8529 return Err(serde::de::Error::duplicate_field("selectList"));
8530 }
8531 select_list__ = Some(map_.next_value()?);
8532 }
8533 GeneratedField::WatermarkInputCols => {
8534 if watermark_input_cols__.is_some() {
8535 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
8536 }
8537 watermark_input_cols__ =
8538 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8539 .into_iter().map(|x| x.0).collect())
8540 ;
8541 }
8542 GeneratedField::WatermarkOutputCols => {
8543 if watermark_output_cols__.is_some() {
8544 return Err(serde::de::Error::duplicate_field("watermarkOutputCols"));
8545 }
8546 watermark_output_cols__ =
8547 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8548 .into_iter().map(|x| x.0).collect())
8549 ;
8550 }
8551 GeneratedField::NondecreasingExprs => {
8552 if nondecreasing_exprs__.is_some() {
8553 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
8554 }
8555 nondecreasing_exprs__ =
8556 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8557 .into_iter().map(|x| x.0).collect())
8558 ;
8559 }
8560 GeneratedField::NoopUpdateHint => {
8561 if noop_update_hint__.is_some() {
8562 return Err(serde::de::Error::duplicate_field("noopUpdateHint"));
8563 }
8564 noop_update_hint__ = Some(map_.next_value()?);
8565 }
8566 }
8567 }
8568 Ok(ProjectNode {
8569 select_list: select_list__.unwrap_or_default(),
8570 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
8571 watermark_output_cols: watermark_output_cols__.unwrap_or_default(),
8572 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
8573 noop_update_hint: noop_update_hint__.unwrap_or_default(),
8574 })
8575 }
8576 }
8577 deserializer.deserialize_struct("stream_plan.ProjectNode", FIELDS, GeneratedVisitor)
8578 }
8579}
8580impl serde::Serialize for ProjectSetNode {
8581 #[allow(deprecated)]
8582 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8583 where
8584 S: serde::Serializer,
8585 {
8586 use serde::ser::SerializeStruct;
8587 let mut len = 0;
8588 if !self.select_list.is_empty() {
8589 len += 1;
8590 }
8591 if !self.watermark_input_cols.is_empty() {
8592 len += 1;
8593 }
8594 if !self.watermark_expr_indices.is_empty() {
8595 len += 1;
8596 }
8597 if !self.nondecreasing_exprs.is_empty() {
8598 len += 1;
8599 }
8600 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectSetNode", len)?;
8601 if !self.select_list.is_empty() {
8602 struct_ser.serialize_field("selectList", &self.select_list)?;
8603 }
8604 if !self.watermark_input_cols.is_empty() {
8605 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
8606 }
8607 if !self.watermark_expr_indices.is_empty() {
8608 struct_ser.serialize_field("watermarkExprIndices", &self.watermark_expr_indices)?;
8609 }
8610 if !self.nondecreasing_exprs.is_empty() {
8611 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
8612 }
8613 struct_ser.end()
8614 }
8615}
8616impl<'de> serde::Deserialize<'de> for ProjectSetNode {
8617 #[allow(deprecated)]
8618 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8619 where
8620 D: serde::Deserializer<'de>,
8621 {
8622 const FIELDS: &[&str] = &[
8623 "select_list",
8624 "selectList",
8625 "watermark_input_cols",
8626 "watermarkInputCols",
8627 "watermark_expr_indices",
8628 "watermarkExprIndices",
8629 "nondecreasing_exprs",
8630 "nondecreasingExprs",
8631 ];
8632
8633 #[allow(clippy::enum_variant_names)]
8634 enum GeneratedField {
8635 SelectList,
8636 WatermarkInputCols,
8637 WatermarkExprIndices,
8638 NondecreasingExprs,
8639 }
8640 impl<'de> serde::Deserialize<'de> for GeneratedField {
8641 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8642 where
8643 D: serde::Deserializer<'de>,
8644 {
8645 struct GeneratedVisitor;
8646
8647 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8648 type Value = GeneratedField;
8649
8650 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8651 write!(formatter, "expected one of: {:?}", &FIELDS)
8652 }
8653
8654 #[allow(unused_variables)]
8655 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8656 where
8657 E: serde::de::Error,
8658 {
8659 match value {
8660 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
8661 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
8662 "watermarkExprIndices" | "watermark_expr_indices" => Ok(GeneratedField::WatermarkExprIndices),
8663 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
8664 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8665 }
8666 }
8667 }
8668 deserializer.deserialize_identifier(GeneratedVisitor)
8669 }
8670 }
8671 struct GeneratedVisitor;
8672 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8673 type Value = ProjectSetNode;
8674
8675 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8676 formatter.write_str("struct stream_plan.ProjectSetNode")
8677 }
8678
8679 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
8680 where
8681 V: serde::de::MapAccess<'de>,
8682 {
8683 let mut select_list__ = None;
8684 let mut watermark_input_cols__ = None;
8685 let mut watermark_expr_indices__ = None;
8686 let mut nondecreasing_exprs__ = None;
8687 while let Some(k) = map_.next_key()? {
8688 match k {
8689 GeneratedField::SelectList => {
8690 if select_list__.is_some() {
8691 return Err(serde::de::Error::duplicate_field("selectList"));
8692 }
8693 select_list__ = Some(map_.next_value()?);
8694 }
8695 GeneratedField::WatermarkInputCols => {
8696 if watermark_input_cols__.is_some() {
8697 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
8698 }
8699 watermark_input_cols__ =
8700 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8701 .into_iter().map(|x| x.0).collect())
8702 ;
8703 }
8704 GeneratedField::WatermarkExprIndices => {
8705 if watermark_expr_indices__.is_some() {
8706 return Err(serde::de::Error::duplicate_field("watermarkExprIndices"));
8707 }
8708 watermark_expr_indices__ =
8709 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8710 .into_iter().map(|x| x.0).collect())
8711 ;
8712 }
8713 GeneratedField::NondecreasingExprs => {
8714 if nondecreasing_exprs__.is_some() {
8715 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
8716 }
8717 nondecreasing_exprs__ =
8718 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8719 .into_iter().map(|x| x.0).collect())
8720 ;
8721 }
8722 }
8723 }
8724 Ok(ProjectSetNode {
8725 select_list: select_list__.unwrap_or_default(),
8726 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
8727 watermark_expr_indices: watermark_expr_indices__.unwrap_or_default(),
8728 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
8729 })
8730 }
8731 }
8732 deserializer.deserialize_struct("stream_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
8733 }
8734}
8735impl serde::Serialize for RefreshStartMutation {
8736 #[allow(deprecated)]
8737 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8738 where
8739 S: serde::Serializer,
8740 {
8741 use serde::ser::SerializeStruct;
8742 let mut len = 0;
8743 if self.table_id != 0 {
8744 len += 1;
8745 }
8746 if self.associated_source_id != 0 {
8747 len += 1;
8748 }
8749 let mut struct_ser = serializer.serialize_struct("stream_plan.RefreshStartMutation", len)?;
8750 if self.table_id != 0 {
8751 struct_ser.serialize_field("tableId", &self.table_id)?;
8752 }
8753 if self.associated_source_id != 0 {
8754 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
8755 }
8756 struct_ser.end()
8757 }
8758}
8759impl<'de> serde::Deserialize<'de> for RefreshStartMutation {
8760 #[allow(deprecated)]
8761 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8762 where
8763 D: serde::Deserializer<'de>,
8764 {
8765 const FIELDS: &[&str] = &[
8766 "table_id",
8767 "tableId",
8768 "associated_source_id",
8769 "associatedSourceId",
8770 ];
8771
8772 #[allow(clippy::enum_variant_names)]
8773 enum GeneratedField {
8774 TableId,
8775 AssociatedSourceId,
8776 }
8777 impl<'de> serde::Deserialize<'de> for GeneratedField {
8778 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8779 where
8780 D: serde::Deserializer<'de>,
8781 {
8782 struct GeneratedVisitor;
8783
8784 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8785 type Value = GeneratedField;
8786
8787 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8788 write!(formatter, "expected one of: {:?}", &FIELDS)
8789 }
8790
8791 #[allow(unused_variables)]
8792 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8793 where
8794 E: serde::de::Error,
8795 {
8796 match value {
8797 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8798 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
8799 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8800 }
8801 }
8802 }
8803 deserializer.deserialize_identifier(GeneratedVisitor)
8804 }
8805 }
8806 struct GeneratedVisitor;
8807 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8808 type Value = RefreshStartMutation;
8809
8810 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8811 formatter.write_str("struct stream_plan.RefreshStartMutation")
8812 }
8813
8814 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshStartMutation, V::Error>
8815 where
8816 V: serde::de::MapAccess<'de>,
8817 {
8818 let mut table_id__ = None;
8819 let mut associated_source_id__ = None;
8820 while let Some(k) = map_.next_key()? {
8821 match k {
8822 GeneratedField::TableId => {
8823 if table_id__.is_some() {
8824 return Err(serde::de::Error::duplicate_field("tableId"));
8825 }
8826 table_id__ =
8827 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8828 ;
8829 }
8830 GeneratedField::AssociatedSourceId => {
8831 if associated_source_id__.is_some() {
8832 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
8833 }
8834 associated_source_id__ =
8835 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8836 ;
8837 }
8838 }
8839 }
8840 Ok(RefreshStartMutation {
8841 table_id: table_id__.unwrap_or_default(),
8842 associated_source_id: associated_source_id__.unwrap_or_default(),
8843 })
8844 }
8845 }
8846 deserializer.deserialize_struct("stream_plan.RefreshStartMutation", FIELDS, GeneratedVisitor)
8847 }
8848}
8849impl serde::Serialize for ResumeMutation {
8850 #[allow(deprecated)]
8851 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8852 where
8853 S: serde::Serializer,
8854 {
8855 use serde::ser::SerializeStruct;
8856 let len = 0;
8857 let struct_ser = serializer.serialize_struct("stream_plan.ResumeMutation", len)?;
8858 struct_ser.end()
8859 }
8860}
8861impl<'de> serde::Deserialize<'de> for ResumeMutation {
8862 #[allow(deprecated)]
8863 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8864 where
8865 D: serde::Deserializer<'de>,
8866 {
8867 const FIELDS: &[&str] = &[
8868 ];
8869
8870 #[allow(clippy::enum_variant_names)]
8871 enum GeneratedField {
8872 }
8873 impl<'de> serde::Deserialize<'de> for GeneratedField {
8874 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8875 where
8876 D: serde::Deserializer<'de>,
8877 {
8878 struct GeneratedVisitor;
8879
8880 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8881 type Value = GeneratedField;
8882
8883 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8884 write!(formatter, "expected one of: {:?}", &FIELDS)
8885 }
8886
8887 #[allow(unused_variables)]
8888 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8889 where
8890 E: serde::de::Error,
8891 {
8892 Err(serde::de::Error::unknown_field(value, FIELDS))
8893 }
8894 }
8895 deserializer.deserialize_identifier(GeneratedVisitor)
8896 }
8897 }
8898 struct GeneratedVisitor;
8899 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8900 type Value = ResumeMutation;
8901
8902 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8903 formatter.write_str("struct stream_plan.ResumeMutation")
8904 }
8905
8906 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeMutation, V::Error>
8907 where
8908 V: serde::de::MapAccess<'de>,
8909 {
8910 while map_.next_key::<GeneratedField>()?.is_some() {
8911 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8912 }
8913 Ok(ResumeMutation {
8914 })
8915 }
8916 }
8917 deserializer.deserialize_struct("stream_plan.ResumeMutation", FIELDS, GeneratedVisitor)
8918 }
8919}
8920impl serde::Serialize for RowIdGenNode {
8921 #[allow(deprecated)]
8922 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8923 where
8924 S: serde::Serializer,
8925 {
8926 use serde::ser::SerializeStruct;
8927 let mut len = 0;
8928 if self.row_id_index != 0 {
8929 len += 1;
8930 }
8931 let mut struct_ser = serializer.serialize_struct("stream_plan.RowIdGenNode", len)?;
8932 if self.row_id_index != 0 {
8933 #[allow(clippy::needless_borrow)]
8934 #[allow(clippy::needless_borrows_for_generic_args)]
8935 struct_ser.serialize_field("rowIdIndex", ToString::to_string(&self.row_id_index).as_str())?;
8936 }
8937 struct_ser.end()
8938 }
8939}
8940impl<'de> serde::Deserialize<'de> for RowIdGenNode {
8941 #[allow(deprecated)]
8942 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8943 where
8944 D: serde::Deserializer<'de>,
8945 {
8946 const FIELDS: &[&str] = &[
8947 "row_id_index",
8948 "rowIdIndex",
8949 ];
8950
8951 #[allow(clippy::enum_variant_names)]
8952 enum GeneratedField {
8953 RowIdIndex,
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<'de> serde::de::Visitor<'de> 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 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
8976 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8977 }
8978 }
8979 }
8980 deserializer.deserialize_identifier(GeneratedVisitor)
8981 }
8982 }
8983 struct GeneratedVisitor;
8984 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8985 type Value = RowIdGenNode;
8986
8987 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8988 formatter.write_str("struct stream_plan.RowIdGenNode")
8989 }
8990
8991 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowIdGenNode, V::Error>
8992 where
8993 V: serde::de::MapAccess<'de>,
8994 {
8995 let mut row_id_index__ = None;
8996 while let Some(k) = map_.next_key()? {
8997 match k {
8998 GeneratedField::RowIdIndex => {
8999 if row_id_index__.is_some() {
9000 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
9001 }
9002 row_id_index__ =
9003 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9004 ;
9005 }
9006 }
9007 }
9008 Ok(RowIdGenNode {
9009 row_id_index: row_id_index__.unwrap_or_default(),
9010 })
9011 }
9012 }
9013 deserializer.deserialize_struct("stream_plan.RowIdGenNode", FIELDS, GeneratedVisitor)
9014 }
9015}
9016impl serde::Serialize for RowMergeNode {
9017 #[allow(deprecated)]
9018 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9019 where
9020 S: serde::Serializer,
9021 {
9022 use serde::ser::SerializeStruct;
9023 let mut len = 0;
9024 if self.lhs_mapping.is_some() {
9025 len += 1;
9026 }
9027 if self.rhs_mapping.is_some() {
9028 len += 1;
9029 }
9030 let mut struct_ser = serializer.serialize_struct("stream_plan.RowMergeNode", len)?;
9031 if let Some(v) = self.lhs_mapping.as_ref() {
9032 struct_ser.serialize_field("lhsMapping", v)?;
9033 }
9034 if let Some(v) = self.rhs_mapping.as_ref() {
9035 struct_ser.serialize_field("rhsMapping", v)?;
9036 }
9037 struct_ser.end()
9038 }
9039}
9040impl<'de> serde::Deserialize<'de> for RowMergeNode {
9041 #[allow(deprecated)]
9042 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9043 where
9044 D: serde::Deserializer<'de>,
9045 {
9046 const FIELDS: &[&str] = &[
9047 "lhs_mapping",
9048 "lhsMapping",
9049 "rhs_mapping",
9050 "rhsMapping",
9051 ];
9052
9053 #[allow(clippy::enum_variant_names)]
9054 enum GeneratedField {
9055 LhsMapping,
9056 RhsMapping,
9057 }
9058 impl<'de> serde::Deserialize<'de> for GeneratedField {
9059 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9060 where
9061 D: serde::Deserializer<'de>,
9062 {
9063 struct GeneratedVisitor;
9064
9065 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9066 type Value = GeneratedField;
9067
9068 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9069 write!(formatter, "expected one of: {:?}", &FIELDS)
9070 }
9071
9072 #[allow(unused_variables)]
9073 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9074 where
9075 E: serde::de::Error,
9076 {
9077 match value {
9078 "lhsMapping" | "lhs_mapping" => Ok(GeneratedField::LhsMapping),
9079 "rhsMapping" | "rhs_mapping" => Ok(GeneratedField::RhsMapping),
9080 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9081 }
9082 }
9083 }
9084 deserializer.deserialize_identifier(GeneratedVisitor)
9085 }
9086 }
9087 struct GeneratedVisitor;
9088 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9089 type Value = RowMergeNode;
9090
9091 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9092 formatter.write_str("struct stream_plan.RowMergeNode")
9093 }
9094
9095 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowMergeNode, V::Error>
9096 where
9097 V: serde::de::MapAccess<'de>,
9098 {
9099 let mut lhs_mapping__ = None;
9100 let mut rhs_mapping__ = None;
9101 while let Some(k) = map_.next_key()? {
9102 match k {
9103 GeneratedField::LhsMapping => {
9104 if lhs_mapping__.is_some() {
9105 return Err(serde::de::Error::duplicate_field("lhsMapping"));
9106 }
9107 lhs_mapping__ = map_.next_value()?;
9108 }
9109 GeneratedField::RhsMapping => {
9110 if rhs_mapping__.is_some() {
9111 return Err(serde::de::Error::duplicate_field("rhsMapping"));
9112 }
9113 rhs_mapping__ = map_.next_value()?;
9114 }
9115 }
9116 }
9117 Ok(RowMergeNode {
9118 lhs_mapping: lhs_mapping__,
9119 rhs_mapping: rhs_mapping__,
9120 })
9121 }
9122 }
9123 deserializer.deserialize_struct("stream_plan.RowMergeNode", FIELDS, GeneratedVisitor)
9124 }
9125}
9126impl serde::Serialize for SimpleAggNode {
9127 #[allow(deprecated)]
9128 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9129 where
9130 S: serde::Serializer,
9131 {
9132 use serde::ser::SerializeStruct;
9133 let mut len = 0;
9134 if !self.agg_calls.is_empty() {
9135 len += 1;
9136 }
9137 if !self.agg_call_states.is_empty() {
9138 len += 1;
9139 }
9140 if self.intermediate_state_table.is_some() {
9141 len += 1;
9142 }
9143 if self.is_append_only {
9144 len += 1;
9145 }
9146 if !self.distinct_dedup_tables.is_empty() {
9147 len += 1;
9148 }
9149 if self.row_count_index != 0 {
9150 len += 1;
9151 }
9152 if self.version != 0 {
9153 len += 1;
9154 }
9155 if self.must_output_per_barrier {
9156 len += 1;
9157 }
9158 let mut struct_ser = serializer.serialize_struct("stream_plan.SimpleAggNode", len)?;
9159 if !self.agg_calls.is_empty() {
9160 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
9161 }
9162 if !self.agg_call_states.is_empty() {
9163 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
9164 }
9165 if let Some(v) = self.intermediate_state_table.as_ref() {
9166 struct_ser.serialize_field("intermediateStateTable", v)?;
9167 }
9168 if self.is_append_only {
9169 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
9170 }
9171 if !self.distinct_dedup_tables.is_empty() {
9172 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
9173 }
9174 if self.row_count_index != 0 {
9175 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
9176 }
9177 if self.version != 0 {
9178 let v = AggNodeVersion::try_from(self.version)
9179 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
9180 struct_ser.serialize_field("version", &v)?;
9181 }
9182 if self.must_output_per_barrier {
9183 struct_ser.serialize_field("mustOutputPerBarrier", &self.must_output_per_barrier)?;
9184 }
9185 struct_ser.end()
9186 }
9187}
9188impl<'de> serde::Deserialize<'de> for SimpleAggNode {
9189 #[allow(deprecated)]
9190 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9191 where
9192 D: serde::Deserializer<'de>,
9193 {
9194 const FIELDS: &[&str] = &[
9195 "agg_calls",
9196 "aggCalls",
9197 "agg_call_states",
9198 "aggCallStates",
9199 "intermediate_state_table",
9200 "intermediateStateTable",
9201 "is_append_only",
9202 "isAppendOnly",
9203 "distinct_dedup_tables",
9204 "distinctDedupTables",
9205 "row_count_index",
9206 "rowCountIndex",
9207 "version",
9208 "must_output_per_barrier",
9209 "mustOutputPerBarrier",
9210 ];
9211
9212 #[allow(clippy::enum_variant_names)]
9213 enum GeneratedField {
9214 AggCalls,
9215 AggCallStates,
9216 IntermediateStateTable,
9217 IsAppendOnly,
9218 DistinctDedupTables,
9219 RowCountIndex,
9220 Version,
9221 MustOutputPerBarrier,
9222 }
9223 impl<'de> serde::Deserialize<'de> for GeneratedField {
9224 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9225 where
9226 D: serde::Deserializer<'de>,
9227 {
9228 struct GeneratedVisitor;
9229
9230 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9231 type Value = GeneratedField;
9232
9233 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9234 write!(formatter, "expected one of: {:?}", &FIELDS)
9235 }
9236
9237 #[allow(unused_variables)]
9238 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9239 where
9240 E: serde::de::Error,
9241 {
9242 match value {
9243 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
9244 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
9245 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
9246 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
9247 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
9248 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
9249 "version" => Ok(GeneratedField::Version),
9250 "mustOutputPerBarrier" | "must_output_per_barrier" => Ok(GeneratedField::MustOutputPerBarrier),
9251 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9252 }
9253 }
9254 }
9255 deserializer.deserialize_identifier(GeneratedVisitor)
9256 }
9257 }
9258 struct GeneratedVisitor;
9259 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9260 type Value = SimpleAggNode;
9261
9262 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9263 formatter.write_str("struct stream_plan.SimpleAggNode")
9264 }
9265
9266 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SimpleAggNode, V::Error>
9267 where
9268 V: serde::de::MapAccess<'de>,
9269 {
9270 let mut agg_calls__ = None;
9271 let mut agg_call_states__ = None;
9272 let mut intermediate_state_table__ = None;
9273 let mut is_append_only__ = None;
9274 let mut distinct_dedup_tables__ = None;
9275 let mut row_count_index__ = None;
9276 let mut version__ = None;
9277 let mut must_output_per_barrier__ = None;
9278 while let Some(k) = map_.next_key()? {
9279 match k {
9280 GeneratedField::AggCalls => {
9281 if agg_calls__.is_some() {
9282 return Err(serde::de::Error::duplicate_field("aggCalls"));
9283 }
9284 agg_calls__ = Some(map_.next_value()?);
9285 }
9286 GeneratedField::AggCallStates => {
9287 if agg_call_states__.is_some() {
9288 return Err(serde::de::Error::duplicate_field("aggCallStates"));
9289 }
9290 agg_call_states__ = Some(map_.next_value()?);
9291 }
9292 GeneratedField::IntermediateStateTable => {
9293 if intermediate_state_table__.is_some() {
9294 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
9295 }
9296 intermediate_state_table__ = map_.next_value()?;
9297 }
9298 GeneratedField::IsAppendOnly => {
9299 if is_append_only__.is_some() {
9300 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
9301 }
9302 is_append_only__ = Some(map_.next_value()?);
9303 }
9304 GeneratedField::DistinctDedupTables => {
9305 if distinct_dedup_tables__.is_some() {
9306 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
9307 }
9308 distinct_dedup_tables__ = Some(
9309 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
9310 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
9311 );
9312 }
9313 GeneratedField::RowCountIndex => {
9314 if row_count_index__.is_some() {
9315 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
9316 }
9317 row_count_index__ =
9318 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9319 ;
9320 }
9321 GeneratedField::Version => {
9322 if version__.is_some() {
9323 return Err(serde::de::Error::duplicate_field("version"));
9324 }
9325 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
9326 }
9327 GeneratedField::MustOutputPerBarrier => {
9328 if must_output_per_barrier__.is_some() {
9329 return Err(serde::de::Error::duplicate_field("mustOutputPerBarrier"));
9330 }
9331 must_output_per_barrier__ = Some(map_.next_value()?);
9332 }
9333 }
9334 }
9335 Ok(SimpleAggNode {
9336 agg_calls: agg_calls__.unwrap_or_default(),
9337 agg_call_states: agg_call_states__.unwrap_or_default(),
9338 intermediate_state_table: intermediate_state_table__,
9339 is_append_only: is_append_only__.unwrap_or_default(),
9340 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
9341 row_count_index: row_count_index__.unwrap_or_default(),
9342 version: version__.unwrap_or_default(),
9343 must_output_per_barrier: must_output_per_barrier__.unwrap_or_default(),
9344 })
9345 }
9346 }
9347 deserializer.deserialize_struct("stream_plan.SimpleAggNode", FIELDS, GeneratedVisitor)
9348 }
9349}
9350impl serde::Serialize for SinkAddColumns {
9351 #[allow(deprecated)]
9352 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9353 where
9354 S: serde::Serializer,
9355 {
9356 use serde::ser::SerializeStruct;
9357 let mut len = 0;
9358 if !self.fields.is_empty() {
9359 len += 1;
9360 }
9361 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkAddColumns", len)?;
9362 if !self.fields.is_empty() {
9363 struct_ser.serialize_field("fields", &self.fields)?;
9364 }
9365 struct_ser.end()
9366 }
9367}
9368impl<'de> serde::Deserialize<'de> for SinkAddColumns {
9369 #[allow(deprecated)]
9370 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9371 where
9372 D: serde::Deserializer<'de>,
9373 {
9374 const FIELDS: &[&str] = &[
9375 "fields",
9376 ];
9377
9378 #[allow(clippy::enum_variant_names)]
9379 enum GeneratedField {
9380 Fields,
9381 }
9382 impl<'de> serde::Deserialize<'de> for GeneratedField {
9383 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9384 where
9385 D: serde::Deserializer<'de>,
9386 {
9387 struct GeneratedVisitor;
9388
9389 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9390 type Value = GeneratedField;
9391
9392 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9393 write!(formatter, "expected one of: {:?}", &FIELDS)
9394 }
9395
9396 #[allow(unused_variables)]
9397 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9398 where
9399 E: serde::de::Error,
9400 {
9401 match value {
9402 "fields" => Ok(GeneratedField::Fields),
9403 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9404 }
9405 }
9406 }
9407 deserializer.deserialize_identifier(GeneratedVisitor)
9408 }
9409 }
9410 struct GeneratedVisitor;
9411 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9412 type Value = SinkAddColumns;
9413
9414 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9415 formatter.write_str("struct stream_plan.SinkAddColumns")
9416 }
9417
9418 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkAddColumns, V::Error>
9419 where
9420 V: serde::de::MapAccess<'de>,
9421 {
9422 let mut fields__ = None;
9423 while let Some(k) = map_.next_key()? {
9424 match k {
9425 GeneratedField::Fields => {
9426 if fields__.is_some() {
9427 return Err(serde::de::Error::duplicate_field("fields"));
9428 }
9429 fields__ = Some(map_.next_value()?);
9430 }
9431 }
9432 }
9433 Ok(SinkAddColumns {
9434 fields: fields__.unwrap_or_default(),
9435 })
9436 }
9437 }
9438 deserializer.deserialize_struct("stream_plan.SinkAddColumns", FIELDS, GeneratedVisitor)
9439 }
9440}
9441impl serde::Serialize for SinkDesc {
9442 #[allow(deprecated)]
9443 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9444 where
9445 S: serde::Serializer,
9446 {
9447 use serde::ser::SerializeStruct;
9448 let mut len = 0;
9449 if self.id != 0 {
9450 len += 1;
9451 }
9452 if !self.name.is_empty() {
9453 len += 1;
9454 }
9455 if !self.definition.is_empty() {
9456 len += 1;
9457 }
9458 if !self.plan_pk.is_empty() {
9459 len += 1;
9460 }
9461 if !self.downstream_pk.is_empty() {
9462 len += 1;
9463 }
9464 if !self.distribution_key.is_empty() {
9465 len += 1;
9466 }
9467 if !self.properties.is_empty() {
9468 len += 1;
9469 }
9470 if self.sink_type != 0 {
9471 len += 1;
9472 }
9473 if !self.column_catalogs.is_empty() {
9474 len += 1;
9475 }
9476 if !self.db_name.is_empty() {
9477 len += 1;
9478 }
9479 if !self.sink_from_name.is_empty() {
9480 len += 1;
9481 }
9482 if self.format_desc.is_some() {
9483 len += 1;
9484 }
9485 if self.target_table.is_some() {
9486 len += 1;
9487 }
9488 if self.extra_partition_col_idx.is_some() {
9489 len += 1;
9490 }
9491 if !self.secret_refs.is_empty() {
9492 len += 1;
9493 }
9494 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDesc", len)?;
9495 if self.id != 0 {
9496 struct_ser.serialize_field("id", &self.id)?;
9497 }
9498 if !self.name.is_empty() {
9499 struct_ser.serialize_field("name", &self.name)?;
9500 }
9501 if !self.definition.is_empty() {
9502 struct_ser.serialize_field("definition", &self.definition)?;
9503 }
9504 if !self.plan_pk.is_empty() {
9505 struct_ser.serialize_field("planPk", &self.plan_pk)?;
9506 }
9507 if !self.downstream_pk.is_empty() {
9508 struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
9509 }
9510 if !self.distribution_key.is_empty() {
9511 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
9512 }
9513 if !self.properties.is_empty() {
9514 struct_ser.serialize_field("properties", &self.properties)?;
9515 }
9516 if self.sink_type != 0 {
9517 let v = super::catalog::SinkType::try_from(self.sink_type)
9518 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
9519 struct_ser.serialize_field("sinkType", &v)?;
9520 }
9521 if !self.column_catalogs.is_empty() {
9522 struct_ser.serialize_field("columnCatalogs", &self.column_catalogs)?;
9523 }
9524 if !self.db_name.is_empty() {
9525 struct_ser.serialize_field("dbName", &self.db_name)?;
9526 }
9527 if !self.sink_from_name.is_empty() {
9528 struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
9529 }
9530 if let Some(v) = self.format_desc.as_ref() {
9531 struct_ser.serialize_field("formatDesc", v)?;
9532 }
9533 if let Some(v) = self.target_table.as_ref() {
9534 struct_ser.serialize_field("targetTable", v)?;
9535 }
9536 if let Some(v) = self.extra_partition_col_idx.as_ref() {
9537 #[allow(clippy::needless_borrow)]
9538 #[allow(clippy::needless_borrows_for_generic_args)]
9539 struct_ser.serialize_field("extraPartitionColIdx", ToString::to_string(&v).as_str())?;
9540 }
9541 if !self.secret_refs.is_empty() {
9542 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
9543 }
9544 struct_ser.end()
9545 }
9546}
9547impl<'de> serde::Deserialize<'de> for SinkDesc {
9548 #[allow(deprecated)]
9549 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9550 where
9551 D: serde::Deserializer<'de>,
9552 {
9553 const FIELDS: &[&str] = &[
9554 "id",
9555 "name",
9556 "definition",
9557 "plan_pk",
9558 "planPk",
9559 "downstream_pk",
9560 "downstreamPk",
9561 "distribution_key",
9562 "distributionKey",
9563 "properties",
9564 "sink_type",
9565 "sinkType",
9566 "column_catalogs",
9567 "columnCatalogs",
9568 "db_name",
9569 "dbName",
9570 "sink_from_name",
9571 "sinkFromName",
9572 "format_desc",
9573 "formatDesc",
9574 "target_table",
9575 "targetTable",
9576 "extra_partition_col_idx",
9577 "extraPartitionColIdx",
9578 "secret_refs",
9579 "secretRefs",
9580 ];
9581
9582 #[allow(clippy::enum_variant_names)]
9583 enum GeneratedField {
9584 Id,
9585 Name,
9586 Definition,
9587 PlanPk,
9588 DownstreamPk,
9589 DistributionKey,
9590 Properties,
9591 SinkType,
9592 ColumnCatalogs,
9593 DbName,
9594 SinkFromName,
9595 FormatDesc,
9596 TargetTable,
9597 ExtraPartitionColIdx,
9598 SecretRefs,
9599 }
9600 impl<'de> serde::Deserialize<'de> for GeneratedField {
9601 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9602 where
9603 D: serde::Deserializer<'de>,
9604 {
9605 struct GeneratedVisitor;
9606
9607 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9608 type Value = GeneratedField;
9609
9610 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9611 write!(formatter, "expected one of: {:?}", &FIELDS)
9612 }
9613
9614 #[allow(unused_variables)]
9615 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9616 where
9617 E: serde::de::Error,
9618 {
9619 match value {
9620 "id" => Ok(GeneratedField::Id),
9621 "name" => Ok(GeneratedField::Name),
9622 "definition" => Ok(GeneratedField::Definition),
9623 "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
9624 "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
9625 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
9626 "properties" => Ok(GeneratedField::Properties),
9627 "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
9628 "columnCatalogs" | "column_catalogs" => Ok(GeneratedField::ColumnCatalogs),
9629 "dbName" | "db_name" => Ok(GeneratedField::DbName),
9630 "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
9631 "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
9632 "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
9633 "extraPartitionColIdx" | "extra_partition_col_idx" => Ok(GeneratedField::ExtraPartitionColIdx),
9634 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
9635 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9636 }
9637 }
9638 }
9639 deserializer.deserialize_identifier(GeneratedVisitor)
9640 }
9641 }
9642 struct GeneratedVisitor;
9643 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9644 type Value = SinkDesc;
9645
9646 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9647 formatter.write_str("struct stream_plan.SinkDesc")
9648 }
9649
9650 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDesc, V::Error>
9651 where
9652 V: serde::de::MapAccess<'de>,
9653 {
9654 let mut id__ = None;
9655 let mut name__ = None;
9656 let mut definition__ = None;
9657 let mut plan_pk__ = None;
9658 let mut downstream_pk__ = None;
9659 let mut distribution_key__ = None;
9660 let mut properties__ = None;
9661 let mut sink_type__ = None;
9662 let mut column_catalogs__ = None;
9663 let mut db_name__ = None;
9664 let mut sink_from_name__ = None;
9665 let mut format_desc__ = None;
9666 let mut target_table__ = None;
9667 let mut extra_partition_col_idx__ = None;
9668 let mut secret_refs__ = None;
9669 while let Some(k) = map_.next_key()? {
9670 match k {
9671 GeneratedField::Id => {
9672 if id__.is_some() {
9673 return Err(serde::de::Error::duplicate_field("id"));
9674 }
9675 id__ =
9676 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9677 ;
9678 }
9679 GeneratedField::Name => {
9680 if name__.is_some() {
9681 return Err(serde::de::Error::duplicate_field("name"));
9682 }
9683 name__ = Some(map_.next_value()?);
9684 }
9685 GeneratedField::Definition => {
9686 if definition__.is_some() {
9687 return Err(serde::de::Error::duplicate_field("definition"));
9688 }
9689 definition__ = Some(map_.next_value()?);
9690 }
9691 GeneratedField::PlanPk => {
9692 if plan_pk__.is_some() {
9693 return Err(serde::de::Error::duplicate_field("planPk"));
9694 }
9695 plan_pk__ = Some(map_.next_value()?);
9696 }
9697 GeneratedField::DownstreamPk => {
9698 if downstream_pk__.is_some() {
9699 return Err(serde::de::Error::duplicate_field("downstreamPk"));
9700 }
9701 downstream_pk__ =
9702 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9703 .into_iter().map(|x| x.0).collect())
9704 ;
9705 }
9706 GeneratedField::DistributionKey => {
9707 if distribution_key__.is_some() {
9708 return Err(serde::de::Error::duplicate_field("distributionKey"));
9709 }
9710 distribution_key__ =
9711 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9712 .into_iter().map(|x| x.0).collect())
9713 ;
9714 }
9715 GeneratedField::Properties => {
9716 if properties__.is_some() {
9717 return Err(serde::de::Error::duplicate_field("properties"));
9718 }
9719 properties__ = Some(
9720 map_.next_value::<std::collections::BTreeMap<_, _>>()?
9721 );
9722 }
9723 GeneratedField::SinkType => {
9724 if sink_type__.is_some() {
9725 return Err(serde::de::Error::duplicate_field("sinkType"));
9726 }
9727 sink_type__ = Some(map_.next_value::<super::catalog::SinkType>()? as i32);
9728 }
9729 GeneratedField::ColumnCatalogs => {
9730 if column_catalogs__.is_some() {
9731 return Err(serde::de::Error::duplicate_field("columnCatalogs"));
9732 }
9733 column_catalogs__ = Some(map_.next_value()?);
9734 }
9735 GeneratedField::DbName => {
9736 if db_name__.is_some() {
9737 return Err(serde::de::Error::duplicate_field("dbName"));
9738 }
9739 db_name__ = Some(map_.next_value()?);
9740 }
9741 GeneratedField::SinkFromName => {
9742 if sink_from_name__.is_some() {
9743 return Err(serde::de::Error::duplicate_field("sinkFromName"));
9744 }
9745 sink_from_name__ = Some(map_.next_value()?);
9746 }
9747 GeneratedField::FormatDesc => {
9748 if format_desc__.is_some() {
9749 return Err(serde::de::Error::duplicate_field("formatDesc"));
9750 }
9751 format_desc__ = map_.next_value()?;
9752 }
9753 GeneratedField::TargetTable => {
9754 if target_table__.is_some() {
9755 return Err(serde::de::Error::duplicate_field("targetTable"));
9756 }
9757 target_table__ =
9758 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9759 ;
9760 }
9761 GeneratedField::ExtraPartitionColIdx => {
9762 if extra_partition_col_idx__.is_some() {
9763 return Err(serde::de::Error::duplicate_field("extraPartitionColIdx"));
9764 }
9765 extra_partition_col_idx__ =
9766 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9767 ;
9768 }
9769 GeneratedField::SecretRefs => {
9770 if secret_refs__.is_some() {
9771 return Err(serde::de::Error::duplicate_field("secretRefs"));
9772 }
9773 secret_refs__ = Some(
9774 map_.next_value::<std::collections::BTreeMap<_, _>>()?
9775 );
9776 }
9777 }
9778 }
9779 Ok(SinkDesc {
9780 id: id__.unwrap_or_default(),
9781 name: name__.unwrap_or_default(),
9782 definition: definition__.unwrap_or_default(),
9783 plan_pk: plan_pk__.unwrap_or_default(),
9784 downstream_pk: downstream_pk__.unwrap_or_default(),
9785 distribution_key: distribution_key__.unwrap_or_default(),
9786 properties: properties__.unwrap_or_default(),
9787 sink_type: sink_type__.unwrap_or_default(),
9788 column_catalogs: column_catalogs__.unwrap_or_default(),
9789 db_name: db_name__.unwrap_or_default(),
9790 sink_from_name: sink_from_name__.unwrap_or_default(),
9791 format_desc: format_desc__,
9792 target_table: target_table__,
9793 extra_partition_col_idx: extra_partition_col_idx__,
9794 secret_refs: secret_refs__.unwrap_or_default(),
9795 })
9796 }
9797 }
9798 deserializer.deserialize_struct("stream_plan.SinkDesc", FIELDS, GeneratedVisitor)
9799 }
9800}
9801impl serde::Serialize for SinkLogStoreType {
9802 #[allow(deprecated)]
9803 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9804 where
9805 S: serde::Serializer,
9806 {
9807 let variant = match self {
9808 Self::Unspecified => "SINK_LOG_STORE_TYPE_UNSPECIFIED",
9809 Self::KvLogStore => "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
9810 Self::InMemoryLogStore => "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
9811 };
9812 serializer.serialize_str(variant)
9813 }
9814}
9815impl<'de> serde::Deserialize<'de> for SinkLogStoreType {
9816 #[allow(deprecated)]
9817 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9818 where
9819 D: serde::Deserializer<'de>,
9820 {
9821 const FIELDS: &[&str] = &[
9822 "SINK_LOG_STORE_TYPE_UNSPECIFIED",
9823 "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
9824 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
9825 ];
9826
9827 struct GeneratedVisitor;
9828
9829 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9830 type Value = SinkLogStoreType;
9831
9832 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9833 write!(formatter, "expected one of: {:?}", &FIELDS)
9834 }
9835
9836 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9837 where
9838 E: serde::de::Error,
9839 {
9840 i32::try_from(v)
9841 .ok()
9842 .and_then(|x| x.try_into().ok())
9843 .ok_or_else(|| {
9844 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9845 })
9846 }
9847
9848 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9849 where
9850 E: serde::de::Error,
9851 {
9852 i32::try_from(v)
9853 .ok()
9854 .and_then(|x| x.try_into().ok())
9855 .ok_or_else(|| {
9856 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9857 })
9858 }
9859
9860 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9861 where
9862 E: serde::de::Error,
9863 {
9864 match value {
9865 "SINK_LOG_STORE_TYPE_UNSPECIFIED" => Ok(SinkLogStoreType::Unspecified),
9866 "SINK_LOG_STORE_TYPE_KV_LOG_STORE" => Ok(SinkLogStoreType::KvLogStore),
9867 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE" => Ok(SinkLogStoreType::InMemoryLogStore),
9868 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9869 }
9870 }
9871 }
9872 deserializer.deserialize_any(GeneratedVisitor)
9873 }
9874}
9875impl serde::Serialize for SinkNode {
9876 #[allow(deprecated)]
9877 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9878 where
9879 S: serde::Serializer,
9880 {
9881 use serde::ser::SerializeStruct;
9882 let mut len = 0;
9883 if self.sink_desc.is_some() {
9884 len += 1;
9885 }
9886 if self.table.is_some() {
9887 len += 1;
9888 }
9889 if self.log_store_type != 0 {
9890 len += 1;
9891 }
9892 if self.rate_limit.is_some() {
9893 len += 1;
9894 }
9895 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkNode", len)?;
9896 if let Some(v) = self.sink_desc.as_ref() {
9897 struct_ser.serialize_field("sinkDesc", v)?;
9898 }
9899 if let Some(v) = self.table.as_ref() {
9900 struct_ser.serialize_field("table", v)?;
9901 }
9902 if self.log_store_type != 0 {
9903 let v = SinkLogStoreType::try_from(self.log_store_type)
9904 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.log_store_type)))?;
9905 struct_ser.serialize_field("logStoreType", &v)?;
9906 }
9907 if let Some(v) = self.rate_limit.as_ref() {
9908 struct_ser.serialize_field("rateLimit", v)?;
9909 }
9910 struct_ser.end()
9911 }
9912}
9913impl<'de> serde::Deserialize<'de> for SinkNode {
9914 #[allow(deprecated)]
9915 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9916 where
9917 D: serde::Deserializer<'de>,
9918 {
9919 const FIELDS: &[&str] = &[
9920 "sink_desc",
9921 "sinkDesc",
9922 "table",
9923 "log_store_type",
9924 "logStoreType",
9925 "rate_limit",
9926 "rateLimit",
9927 ];
9928
9929 #[allow(clippy::enum_variant_names)]
9930 enum GeneratedField {
9931 SinkDesc,
9932 Table,
9933 LogStoreType,
9934 RateLimit,
9935 }
9936 impl<'de> serde::Deserialize<'de> for GeneratedField {
9937 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9938 where
9939 D: serde::Deserializer<'de>,
9940 {
9941 struct GeneratedVisitor;
9942
9943 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9944 type Value = GeneratedField;
9945
9946 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9947 write!(formatter, "expected one of: {:?}", &FIELDS)
9948 }
9949
9950 #[allow(unused_variables)]
9951 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9952 where
9953 E: serde::de::Error,
9954 {
9955 match value {
9956 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
9957 "table" => Ok(GeneratedField::Table),
9958 "logStoreType" | "log_store_type" => Ok(GeneratedField::LogStoreType),
9959 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
9960 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9961 }
9962 }
9963 }
9964 deserializer.deserialize_identifier(GeneratedVisitor)
9965 }
9966 }
9967 struct GeneratedVisitor;
9968 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9969 type Value = SinkNode;
9970
9971 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9972 formatter.write_str("struct stream_plan.SinkNode")
9973 }
9974
9975 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkNode, V::Error>
9976 where
9977 V: serde::de::MapAccess<'de>,
9978 {
9979 let mut sink_desc__ = None;
9980 let mut table__ = None;
9981 let mut log_store_type__ = None;
9982 let mut rate_limit__ = None;
9983 while let Some(k) = map_.next_key()? {
9984 match k {
9985 GeneratedField::SinkDesc => {
9986 if sink_desc__.is_some() {
9987 return Err(serde::de::Error::duplicate_field("sinkDesc"));
9988 }
9989 sink_desc__ = map_.next_value()?;
9990 }
9991 GeneratedField::Table => {
9992 if table__.is_some() {
9993 return Err(serde::de::Error::duplicate_field("table"));
9994 }
9995 table__ = map_.next_value()?;
9996 }
9997 GeneratedField::LogStoreType => {
9998 if log_store_type__.is_some() {
9999 return Err(serde::de::Error::duplicate_field("logStoreType"));
10000 }
10001 log_store_type__ = Some(map_.next_value::<SinkLogStoreType>()? as i32);
10002 }
10003 GeneratedField::RateLimit => {
10004 if rate_limit__.is_some() {
10005 return Err(serde::de::Error::duplicate_field("rateLimit"));
10006 }
10007 rate_limit__ =
10008 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10009 ;
10010 }
10011 }
10012 }
10013 Ok(SinkNode {
10014 sink_desc: sink_desc__,
10015 table: table__,
10016 log_store_type: log_store_type__.unwrap_or_default(),
10017 rate_limit: rate_limit__,
10018 })
10019 }
10020 }
10021 deserializer.deserialize_struct("stream_plan.SinkNode", FIELDS, GeneratedVisitor)
10022 }
10023}
10024impl serde::Serialize for SortNode {
10025 #[allow(deprecated)]
10026 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10027 where
10028 S: serde::Serializer,
10029 {
10030 use serde::ser::SerializeStruct;
10031 let mut len = 0;
10032 if self.state_table.is_some() {
10033 len += 1;
10034 }
10035 if self.sort_column_index != 0 {
10036 len += 1;
10037 }
10038 let mut struct_ser = serializer.serialize_struct("stream_plan.SortNode", len)?;
10039 if let Some(v) = self.state_table.as_ref() {
10040 struct_ser.serialize_field("stateTable", v)?;
10041 }
10042 if self.sort_column_index != 0 {
10043 struct_ser.serialize_field("sortColumnIndex", &self.sort_column_index)?;
10044 }
10045 struct_ser.end()
10046 }
10047}
10048impl<'de> serde::Deserialize<'de> for SortNode {
10049 #[allow(deprecated)]
10050 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10051 where
10052 D: serde::Deserializer<'de>,
10053 {
10054 const FIELDS: &[&str] = &[
10055 "state_table",
10056 "stateTable",
10057 "sort_column_index",
10058 "sortColumnIndex",
10059 ];
10060
10061 #[allow(clippy::enum_variant_names)]
10062 enum GeneratedField {
10063 StateTable,
10064 SortColumnIndex,
10065 }
10066 impl<'de> serde::Deserialize<'de> for GeneratedField {
10067 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10068 where
10069 D: serde::Deserializer<'de>,
10070 {
10071 struct GeneratedVisitor;
10072
10073 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10074 type Value = GeneratedField;
10075
10076 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10077 write!(formatter, "expected one of: {:?}", &FIELDS)
10078 }
10079
10080 #[allow(unused_variables)]
10081 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10082 where
10083 E: serde::de::Error,
10084 {
10085 match value {
10086 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
10087 "sortColumnIndex" | "sort_column_index" => Ok(GeneratedField::SortColumnIndex),
10088 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10089 }
10090 }
10091 }
10092 deserializer.deserialize_identifier(GeneratedVisitor)
10093 }
10094 }
10095 struct GeneratedVisitor;
10096 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10097 type Value = SortNode;
10098
10099 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10100 formatter.write_str("struct stream_plan.SortNode")
10101 }
10102
10103 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
10104 where
10105 V: serde::de::MapAccess<'de>,
10106 {
10107 let mut state_table__ = None;
10108 let mut sort_column_index__ = None;
10109 while let Some(k) = map_.next_key()? {
10110 match k {
10111 GeneratedField::StateTable => {
10112 if state_table__.is_some() {
10113 return Err(serde::de::Error::duplicate_field("stateTable"));
10114 }
10115 state_table__ = map_.next_value()?;
10116 }
10117 GeneratedField::SortColumnIndex => {
10118 if sort_column_index__.is_some() {
10119 return Err(serde::de::Error::duplicate_field("sortColumnIndex"));
10120 }
10121 sort_column_index__ =
10122 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10123 ;
10124 }
10125 }
10126 }
10127 Ok(SortNode {
10128 state_table: state_table__,
10129 sort_column_index: sort_column_index__.unwrap_or_default(),
10130 })
10131 }
10132 }
10133 deserializer.deserialize_struct("stream_plan.SortNode", FIELDS, GeneratedVisitor)
10134 }
10135}
10136impl serde::Serialize for SourceBackfillNode {
10137 #[allow(deprecated)]
10138 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10139 where
10140 S: serde::Serializer,
10141 {
10142 use serde::ser::SerializeStruct;
10143 let mut len = 0;
10144 if self.upstream_source_id != 0 {
10145 len += 1;
10146 }
10147 if self.row_id_index.is_some() {
10148 len += 1;
10149 }
10150 if !self.columns.is_empty() {
10151 len += 1;
10152 }
10153 if self.info.is_some() {
10154 len += 1;
10155 }
10156 if !self.source_name.is_empty() {
10157 len += 1;
10158 }
10159 if !self.with_properties.is_empty() {
10160 len += 1;
10161 }
10162 if self.rate_limit.is_some() {
10163 len += 1;
10164 }
10165 if self.state_table.is_some() {
10166 len += 1;
10167 }
10168 if !self.secret_refs.is_empty() {
10169 len += 1;
10170 }
10171 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceBackfillNode", len)?;
10172 if self.upstream_source_id != 0 {
10173 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
10174 }
10175 if let Some(v) = self.row_id_index.as_ref() {
10176 struct_ser.serialize_field("rowIdIndex", v)?;
10177 }
10178 if !self.columns.is_empty() {
10179 struct_ser.serialize_field("columns", &self.columns)?;
10180 }
10181 if let Some(v) = self.info.as_ref() {
10182 struct_ser.serialize_field("info", v)?;
10183 }
10184 if !self.source_name.is_empty() {
10185 struct_ser.serialize_field("sourceName", &self.source_name)?;
10186 }
10187 if !self.with_properties.is_empty() {
10188 struct_ser.serialize_field("withProperties", &self.with_properties)?;
10189 }
10190 if let Some(v) = self.rate_limit.as_ref() {
10191 struct_ser.serialize_field("rateLimit", v)?;
10192 }
10193 if let Some(v) = self.state_table.as_ref() {
10194 struct_ser.serialize_field("stateTable", v)?;
10195 }
10196 if !self.secret_refs.is_empty() {
10197 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
10198 }
10199 struct_ser.end()
10200 }
10201}
10202impl<'de> serde::Deserialize<'de> for SourceBackfillNode {
10203 #[allow(deprecated)]
10204 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10205 where
10206 D: serde::Deserializer<'de>,
10207 {
10208 const FIELDS: &[&str] = &[
10209 "upstream_source_id",
10210 "upstreamSourceId",
10211 "row_id_index",
10212 "rowIdIndex",
10213 "columns",
10214 "info",
10215 "source_name",
10216 "sourceName",
10217 "with_properties",
10218 "withProperties",
10219 "rate_limit",
10220 "rateLimit",
10221 "state_table",
10222 "stateTable",
10223 "secret_refs",
10224 "secretRefs",
10225 ];
10226
10227 #[allow(clippy::enum_variant_names)]
10228 enum GeneratedField {
10229 UpstreamSourceId,
10230 RowIdIndex,
10231 Columns,
10232 Info,
10233 SourceName,
10234 WithProperties,
10235 RateLimit,
10236 StateTable,
10237 SecretRefs,
10238 }
10239 impl<'de> serde::Deserialize<'de> for GeneratedField {
10240 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10241 where
10242 D: serde::Deserializer<'de>,
10243 {
10244 struct GeneratedVisitor;
10245
10246 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10247 type Value = GeneratedField;
10248
10249 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10250 write!(formatter, "expected one of: {:?}", &FIELDS)
10251 }
10252
10253 #[allow(unused_variables)]
10254 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10255 where
10256 E: serde::de::Error,
10257 {
10258 match value {
10259 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
10260 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
10261 "columns" => Ok(GeneratedField::Columns),
10262 "info" => Ok(GeneratedField::Info),
10263 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
10264 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
10265 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
10266 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
10267 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
10268 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10269 }
10270 }
10271 }
10272 deserializer.deserialize_identifier(GeneratedVisitor)
10273 }
10274 }
10275 struct GeneratedVisitor;
10276 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10277 type Value = SourceBackfillNode;
10278
10279 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10280 formatter.write_str("struct stream_plan.SourceBackfillNode")
10281 }
10282
10283 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceBackfillNode, V::Error>
10284 where
10285 V: serde::de::MapAccess<'de>,
10286 {
10287 let mut upstream_source_id__ = None;
10288 let mut row_id_index__ = None;
10289 let mut columns__ = None;
10290 let mut info__ = None;
10291 let mut source_name__ = None;
10292 let mut with_properties__ = None;
10293 let mut rate_limit__ = None;
10294 let mut state_table__ = None;
10295 let mut secret_refs__ = None;
10296 while let Some(k) = map_.next_key()? {
10297 match k {
10298 GeneratedField::UpstreamSourceId => {
10299 if upstream_source_id__.is_some() {
10300 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
10301 }
10302 upstream_source_id__ =
10303 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10304 ;
10305 }
10306 GeneratedField::RowIdIndex => {
10307 if row_id_index__.is_some() {
10308 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
10309 }
10310 row_id_index__ =
10311 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10312 ;
10313 }
10314 GeneratedField::Columns => {
10315 if columns__.is_some() {
10316 return Err(serde::de::Error::duplicate_field("columns"));
10317 }
10318 columns__ = Some(map_.next_value()?);
10319 }
10320 GeneratedField::Info => {
10321 if info__.is_some() {
10322 return Err(serde::de::Error::duplicate_field("info"));
10323 }
10324 info__ = map_.next_value()?;
10325 }
10326 GeneratedField::SourceName => {
10327 if source_name__.is_some() {
10328 return Err(serde::de::Error::duplicate_field("sourceName"));
10329 }
10330 source_name__ = Some(map_.next_value()?);
10331 }
10332 GeneratedField::WithProperties => {
10333 if with_properties__.is_some() {
10334 return Err(serde::de::Error::duplicate_field("withProperties"));
10335 }
10336 with_properties__ = Some(
10337 map_.next_value::<std::collections::BTreeMap<_, _>>()?
10338 );
10339 }
10340 GeneratedField::RateLimit => {
10341 if rate_limit__.is_some() {
10342 return Err(serde::de::Error::duplicate_field("rateLimit"));
10343 }
10344 rate_limit__ =
10345 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10346 ;
10347 }
10348 GeneratedField::StateTable => {
10349 if state_table__.is_some() {
10350 return Err(serde::de::Error::duplicate_field("stateTable"));
10351 }
10352 state_table__ = map_.next_value()?;
10353 }
10354 GeneratedField::SecretRefs => {
10355 if secret_refs__.is_some() {
10356 return Err(serde::de::Error::duplicate_field("secretRefs"));
10357 }
10358 secret_refs__ = Some(
10359 map_.next_value::<std::collections::BTreeMap<_, _>>()?
10360 );
10361 }
10362 }
10363 }
10364 Ok(SourceBackfillNode {
10365 upstream_source_id: upstream_source_id__.unwrap_or_default(),
10366 row_id_index: row_id_index__,
10367 columns: columns__.unwrap_or_default(),
10368 info: info__,
10369 source_name: source_name__.unwrap_or_default(),
10370 with_properties: with_properties__.unwrap_or_default(),
10371 rate_limit: rate_limit__,
10372 state_table: state_table__,
10373 secret_refs: secret_refs__.unwrap_or_default(),
10374 })
10375 }
10376 }
10377 deserializer.deserialize_struct("stream_plan.SourceBackfillNode", FIELDS, GeneratedVisitor)
10378 }
10379}
10380impl serde::Serialize for SourceChangeSplitMutation {
10381 #[allow(deprecated)]
10382 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10383 where
10384 S: serde::Serializer,
10385 {
10386 use serde::ser::SerializeStruct;
10387 let mut len = 0;
10388 if !self.actor_splits.is_empty() {
10389 len += 1;
10390 }
10391 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceChangeSplitMutation", len)?;
10392 if !self.actor_splits.is_empty() {
10393 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
10394 }
10395 struct_ser.end()
10396 }
10397}
10398impl<'de> serde::Deserialize<'de> for SourceChangeSplitMutation {
10399 #[allow(deprecated)]
10400 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10401 where
10402 D: serde::Deserializer<'de>,
10403 {
10404 const FIELDS: &[&str] = &[
10405 "actor_splits",
10406 "actorSplits",
10407 ];
10408
10409 #[allow(clippy::enum_variant_names)]
10410 enum GeneratedField {
10411 ActorSplits,
10412 }
10413 impl<'de> serde::Deserialize<'de> for GeneratedField {
10414 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10415 where
10416 D: serde::Deserializer<'de>,
10417 {
10418 struct GeneratedVisitor;
10419
10420 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10421 type Value = GeneratedField;
10422
10423 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10424 write!(formatter, "expected one of: {:?}", &FIELDS)
10425 }
10426
10427 #[allow(unused_variables)]
10428 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10429 where
10430 E: serde::de::Error,
10431 {
10432 match value {
10433 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
10434 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10435 }
10436 }
10437 }
10438 deserializer.deserialize_identifier(GeneratedVisitor)
10439 }
10440 }
10441 struct GeneratedVisitor;
10442 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10443 type Value = SourceChangeSplitMutation;
10444
10445 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10446 formatter.write_str("struct stream_plan.SourceChangeSplitMutation")
10447 }
10448
10449 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceChangeSplitMutation, V::Error>
10450 where
10451 V: serde::de::MapAccess<'de>,
10452 {
10453 let mut actor_splits__ = None;
10454 while let Some(k) = map_.next_key()? {
10455 match k {
10456 GeneratedField::ActorSplits => {
10457 if actor_splits__.is_some() {
10458 return Err(serde::de::Error::duplicate_field("actorSplits"));
10459 }
10460 actor_splits__ = Some(
10461 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10462 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
10463 );
10464 }
10465 }
10466 }
10467 Ok(SourceChangeSplitMutation {
10468 actor_splits: actor_splits__.unwrap_or_default(),
10469 })
10470 }
10471 }
10472 deserializer.deserialize_struct("stream_plan.SourceChangeSplitMutation", FIELDS, GeneratedVisitor)
10473 }
10474}
10475impl serde::Serialize for SourceNode {
10476 #[allow(deprecated)]
10477 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10478 where
10479 S: serde::Serializer,
10480 {
10481 use serde::ser::SerializeStruct;
10482 let mut len = 0;
10483 if self.source_inner.is_some() {
10484 len += 1;
10485 }
10486 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceNode", len)?;
10487 if let Some(v) = self.source_inner.as_ref() {
10488 struct_ser.serialize_field("sourceInner", v)?;
10489 }
10490 struct_ser.end()
10491 }
10492}
10493impl<'de> serde::Deserialize<'de> for SourceNode {
10494 #[allow(deprecated)]
10495 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10496 where
10497 D: serde::Deserializer<'de>,
10498 {
10499 const FIELDS: &[&str] = &[
10500 "source_inner",
10501 "sourceInner",
10502 ];
10503
10504 #[allow(clippy::enum_variant_names)]
10505 enum GeneratedField {
10506 SourceInner,
10507 }
10508 impl<'de> serde::Deserialize<'de> for GeneratedField {
10509 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10510 where
10511 D: serde::Deserializer<'de>,
10512 {
10513 struct GeneratedVisitor;
10514
10515 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10516 type Value = GeneratedField;
10517
10518 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10519 write!(formatter, "expected one of: {:?}", &FIELDS)
10520 }
10521
10522 #[allow(unused_variables)]
10523 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10524 where
10525 E: serde::de::Error,
10526 {
10527 match value {
10528 "sourceInner" | "source_inner" => Ok(GeneratedField::SourceInner),
10529 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10530 }
10531 }
10532 }
10533 deserializer.deserialize_identifier(GeneratedVisitor)
10534 }
10535 }
10536 struct GeneratedVisitor;
10537 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10538 type Value = SourceNode;
10539
10540 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10541 formatter.write_str("struct stream_plan.SourceNode")
10542 }
10543
10544 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
10545 where
10546 V: serde::de::MapAccess<'de>,
10547 {
10548 let mut source_inner__ = None;
10549 while let Some(k) = map_.next_key()? {
10550 match k {
10551 GeneratedField::SourceInner => {
10552 if source_inner__.is_some() {
10553 return Err(serde::de::Error::duplicate_field("sourceInner"));
10554 }
10555 source_inner__ = map_.next_value()?;
10556 }
10557 }
10558 }
10559 Ok(SourceNode {
10560 source_inner: source_inner__,
10561 })
10562 }
10563 }
10564 deserializer.deserialize_struct("stream_plan.SourceNode", FIELDS, GeneratedVisitor)
10565 }
10566}
10567impl serde::Serialize for StartFragmentBackfillMutation {
10568 #[allow(deprecated)]
10569 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10570 where
10571 S: serde::Serializer,
10572 {
10573 use serde::ser::SerializeStruct;
10574 let mut len = 0;
10575 if !self.fragment_ids.is_empty() {
10576 len += 1;
10577 }
10578 let mut struct_ser = serializer.serialize_struct("stream_plan.StartFragmentBackfillMutation", len)?;
10579 if !self.fragment_ids.is_empty() {
10580 struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
10581 }
10582 struct_ser.end()
10583 }
10584}
10585impl<'de> serde::Deserialize<'de> for StartFragmentBackfillMutation {
10586 #[allow(deprecated)]
10587 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10588 where
10589 D: serde::Deserializer<'de>,
10590 {
10591 const FIELDS: &[&str] = &[
10592 "fragment_ids",
10593 "fragmentIds",
10594 ];
10595
10596 #[allow(clippy::enum_variant_names)]
10597 enum GeneratedField {
10598 FragmentIds,
10599 }
10600 impl<'de> serde::Deserialize<'de> for GeneratedField {
10601 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10602 where
10603 D: serde::Deserializer<'de>,
10604 {
10605 struct GeneratedVisitor;
10606
10607 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10608 type Value = GeneratedField;
10609
10610 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10611 write!(formatter, "expected one of: {:?}", &FIELDS)
10612 }
10613
10614 #[allow(unused_variables)]
10615 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10616 where
10617 E: serde::de::Error,
10618 {
10619 match value {
10620 "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
10621 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10622 }
10623 }
10624 }
10625 deserializer.deserialize_identifier(GeneratedVisitor)
10626 }
10627 }
10628 struct GeneratedVisitor;
10629 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10630 type Value = StartFragmentBackfillMutation;
10631
10632 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10633 formatter.write_str("struct stream_plan.StartFragmentBackfillMutation")
10634 }
10635
10636 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StartFragmentBackfillMutation, V::Error>
10637 where
10638 V: serde::de::MapAccess<'de>,
10639 {
10640 let mut fragment_ids__ = None;
10641 while let Some(k) = map_.next_key()? {
10642 match k {
10643 GeneratedField::FragmentIds => {
10644 if fragment_ids__.is_some() {
10645 return Err(serde::de::Error::duplicate_field("fragmentIds"));
10646 }
10647 fragment_ids__ =
10648 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10649 .into_iter().map(|x| x.0).collect())
10650 ;
10651 }
10652 }
10653 }
10654 Ok(StartFragmentBackfillMutation {
10655 fragment_ids: fragment_ids__.unwrap_or_default(),
10656 })
10657 }
10658 }
10659 deserializer.deserialize_struct("stream_plan.StartFragmentBackfillMutation", FIELDS, GeneratedVisitor)
10660 }
10661}
10662impl serde::Serialize for StopMutation {
10663 #[allow(deprecated)]
10664 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10665 where
10666 S: serde::Serializer,
10667 {
10668 use serde::ser::SerializeStruct;
10669 let mut len = 0;
10670 if !self.actors.is_empty() {
10671 len += 1;
10672 }
10673 if !self.dropped_sink_fragments.is_empty() {
10674 len += 1;
10675 }
10676 let mut struct_ser = serializer.serialize_struct("stream_plan.StopMutation", len)?;
10677 if !self.actors.is_empty() {
10678 struct_ser.serialize_field("actors", &self.actors)?;
10679 }
10680 if !self.dropped_sink_fragments.is_empty() {
10681 struct_ser.serialize_field("droppedSinkFragments", &self.dropped_sink_fragments)?;
10682 }
10683 struct_ser.end()
10684 }
10685}
10686impl<'de> serde::Deserialize<'de> for StopMutation {
10687 #[allow(deprecated)]
10688 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10689 where
10690 D: serde::Deserializer<'de>,
10691 {
10692 const FIELDS: &[&str] = &[
10693 "actors",
10694 "dropped_sink_fragments",
10695 "droppedSinkFragments",
10696 ];
10697
10698 #[allow(clippy::enum_variant_names)]
10699 enum GeneratedField {
10700 Actors,
10701 DroppedSinkFragments,
10702 }
10703 impl<'de> serde::Deserialize<'de> for GeneratedField {
10704 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10705 where
10706 D: serde::Deserializer<'de>,
10707 {
10708 struct GeneratedVisitor;
10709
10710 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10711 type Value = GeneratedField;
10712
10713 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10714 write!(formatter, "expected one of: {:?}", &FIELDS)
10715 }
10716
10717 #[allow(unused_variables)]
10718 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10719 where
10720 E: serde::de::Error,
10721 {
10722 match value {
10723 "actors" => Ok(GeneratedField::Actors),
10724 "droppedSinkFragments" | "dropped_sink_fragments" => Ok(GeneratedField::DroppedSinkFragments),
10725 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10726 }
10727 }
10728 }
10729 deserializer.deserialize_identifier(GeneratedVisitor)
10730 }
10731 }
10732 struct GeneratedVisitor;
10733 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10734 type Value = StopMutation;
10735
10736 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10737 formatter.write_str("struct stream_plan.StopMutation")
10738 }
10739
10740 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopMutation, V::Error>
10741 where
10742 V: serde::de::MapAccess<'de>,
10743 {
10744 let mut actors__ = None;
10745 let mut dropped_sink_fragments__ = None;
10746 while let Some(k) = map_.next_key()? {
10747 match k {
10748 GeneratedField::Actors => {
10749 if actors__.is_some() {
10750 return Err(serde::de::Error::duplicate_field("actors"));
10751 }
10752 actors__ =
10753 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10754 .into_iter().map(|x| x.0).collect())
10755 ;
10756 }
10757 GeneratedField::DroppedSinkFragments => {
10758 if dropped_sink_fragments__.is_some() {
10759 return Err(serde::de::Error::duplicate_field("droppedSinkFragments"));
10760 }
10761 dropped_sink_fragments__ =
10762 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10763 .into_iter().map(|x| x.0).collect())
10764 ;
10765 }
10766 }
10767 }
10768 Ok(StopMutation {
10769 actors: actors__.unwrap_or_default(),
10770 dropped_sink_fragments: dropped_sink_fragments__.unwrap_or_default(),
10771 })
10772 }
10773 }
10774 deserializer.deserialize_struct("stream_plan.StopMutation", FIELDS, GeneratedVisitor)
10775 }
10776}
10777impl serde::Serialize for StreamActor {
10778 #[allow(deprecated)]
10779 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10780 where
10781 S: serde::Serializer,
10782 {
10783 use serde::ser::SerializeStruct;
10784 let mut len = 0;
10785 if self.actor_id != 0 {
10786 len += 1;
10787 }
10788 if self.fragment_id != 0 {
10789 len += 1;
10790 }
10791 if !self.dispatcher.is_empty() {
10792 len += 1;
10793 }
10794 if self.vnode_bitmap.is_some() {
10795 len += 1;
10796 }
10797 if !self.mview_definition.is_empty() {
10798 len += 1;
10799 }
10800 if self.expr_context.is_some() {
10801 len += 1;
10802 }
10803 if !self.config_override.is_empty() {
10804 len += 1;
10805 }
10806 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamActor", len)?;
10807 if self.actor_id != 0 {
10808 struct_ser.serialize_field("actorId", &self.actor_id)?;
10809 }
10810 if self.fragment_id != 0 {
10811 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
10812 }
10813 if !self.dispatcher.is_empty() {
10814 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
10815 }
10816 if let Some(v) = self.vnode_bitmap.as_ref() {
10817 struct_ser.serialize_field("vnodeBitmap", v)?;
10818 }
10819 if !self.mview_definition.is_empty() {
10820 struct_ser.serialize_field("mviewDefinition", &self.mview_definition)?;
10821 }
10822 if let Some(v) = self.expr_context.as_ref() {
10823 struct_ser.serialize_field("exprContext", v)?;
10824 }
10825 if !self.config_override.is_empty() {
10826 struct_ser.serialize_field("configOverride", &self.config_override)?;
10827 }
10828 struct_ser.end()
10829 }
10830}
10831impl<'de> serde::Deserialize<'de> for StreamActor {
10832 #[allow(deprecated)]
10833 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10834 where
10835 D: serde::Deserializer<'de>,
10836 {
10837 const FIELDS: &[&str] = &[
10838 "actor_id",
10839 "actorId",
10840 "fragment_id",
10841 "fragmentId",
10842 "dispatcher",
10843 "vnode_bitmap",
10844 "vnodeBitmap",
10845 "mview_definition",
10846 "mviewDefinition",
10847 "expr_context",
10848 "exprContext",
10849 "config_override",
10850 "configOverride",
10851 ];
10852
10853 #[allow(clippy::enum_variant_names)]
10854 enum GeneratedField {
10855 ActorId,
10856 FragmentId,
10857 Dispatcher,
10858 VnodeBitmap,
10859 MviewDefinition,
10860 ExprContext,
10861 ConfigOverride,
10862 }
10863 impl<'de> serde::Deserialize<'de> for GeneratedField {
10864 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10865 where
10866 D: serde::Deserializer<'de>,
10867 {
10868 struct GeneratedVisitor;
10869
10870 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10871 type Value = GeneratedField;
10872
10873 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10874 write!(formatter, "expected one of: {:?}", &FIELDS)
10875 }
10876
10877 #[allow(unused_variables)]
10878 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10879 where
10880 E: serde::de::Error,
10881 {
10882 match value {
10883 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
10884 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
10885 "dispatcher" => Ok(GeneratedField::Dispatcher),
10886 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
10887 "mviewDefinition" | "mview_definition" => Ok(GeneratedField::MviewDefinition),
10888 "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
10889 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
10890 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10891 }
10892 }
10893 }
10894 deserializer.deserialize_identifier(GeneratedVisitor)
10895 }
10896 }
10897 struct GeneratedVisitor;
10898 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10899 type Value = StreamActor;
10900
10901 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10902 formatter.write_str("struct stream_plan.StreamActor")
10903 }
10904
10905 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamActor, V::Error>
10906 where
10907 V: serde::de::MapAccess<'de>,
10908 {
10909 let mut actor_id__ = None;
10910 let mut fragment_id__ = None;
10911 let mut dispatcher__ = None;
10912 let mut vnode_bitmap__ = None;
10913 let mut mview_definition__ = None;
10914 let mut expr_context__ = None;
10915 let mut config_override__ = None;
10916 while let Some(k) = map_.next_key()? {
10917 match k {
10918 GeneratedField::ActorId => {
10919 if actor_id__.is_some() {
10920 return Err(serde::de::Error::duplicate_field("actorId"));
10921 }
10922 actor_id__ =
10923 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10924 ;
10925 }
10926 GeneratedField::FragmentId => {
10927 if fragment_id__.is_some() {
10928 return Err(serde::de::Error::duplicate_field("fragmentId"));
10929 }
10930 fragment_id__ =
10931 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10932 ;
10933 }
10934 GeneratedField::Dispatcher => {
10935 if dispatcher__.is_some() {
10936 return Err(serde::de::Error::duplicate_field("dispatcher"));
10937 }
10938 dispatcher__ = Some(map_.next_value()?);
10939 }
10940 GeneratedField::VnodeBitmap => {
10941 if vnode_bitmap__.is_some() {
10942 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
10943 }
10944 vnode_bitmap__ = map_.next_value()?;
10945 }
10946 GeneratedField::MviewDefinition => {
10947 if mview_definition__.is_some() {
10948 return Err(serde::de::Error::duplicate_field("mviewDefinition"));
10949 }
10950 mview_definition__ = Some(map_.next_value()?);
10951 }
10952 GeneratedField::ExprContext => {
10953 if expr_context__.is_some() {
10954 return Err(serde::de::Error::duplicate_field("exprContext"));
10955 }
10956 expr_context__ = map_.next_value()?;
10957 }
10958 GeneratedField::ConfigOverride => {
10959 if config_override__.is_some() {
10960 return Err(serde::de::Error::duplicate_field("configOverride"));
10961 }
10962 config_override__ = Some(map_.next_value()?);
10963 }
10964 }
10965 }
10966 Ok(StreamActor {
10967 actor_id: actor_id__.unwrap_or_default(),
10968 fragment_id: fragment_id__.unwrap_or_default(),
10969 dispatcher: dispatcher__.unwrap_or_default(),
10970 vnode_bitmap: vnode_bitmap__,
10971 mview_definition: mview_definition__.unwrap_or_default(),
10972 expr_context: expr_context__,
10973 config_override: config_override__.unwrap_or_default(),
10974 })
10975 }
10976 }
10977 deserializer.deserialize_struct("stream_plan.StreamActor", FIELDS, GeneratedVisitor)
10978 }
10979}
10980impl serde::Serialize for StreamCdcScanNode {
10981 #[allow(deprecated)]
10982 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10983 where
10984 S: serde::Serializer,
10985 {
10986 use serde::ser::SerializeStruct;
10987 let mut len = 0;
10988 if self.table_id != 0 {
10989 len += 1;
10990 }
10991 if !self.upstream_column_ids.is_empty() {
10992 len += 1;
10993 }
10994 if !self.output_indices.is_empty() {
10995 len += 1;
10996 }
10997 if self.state_table.is_some() {
10998 len += 1;
10999 }
11000 if self.cdc_table_desc.is_some() {
11001 len += 1;
11002 }
11003 if self.rate_limit.is_some() {
11004 len += 1;
11005 }
11006 if self.disable_backfill {
11007 len += 1;
11008 }
11009 if self.options.is_some() {
11010 len += 1;
11011 }
11012 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanNode", len)?;
11013 if self.table_id != 0 {
11014 struct_ser.serialize_field("tableId", &self.table_id)?;
11015 }
11016 if !self.upstream_column_ids.is_empty() {
11017 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
11018 }
11019 if !self.output_indices.is_empty() {
11020 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
11021 }
11022 if let Some(v) = self.state_table.as_ref() {
11023 struct_ser.serialize_field("stateTable", v)?;
11024 }
11025 if let Some(v) = self.cdc_table_desc.as_ref() {
11026 struct_ser.serialize_field("cdcTableDesc", v)?;
11027 }
11028 if let Some(v) = self.rate_limit.as_ref() {
11029 struct_ser.serialize_field("rateLimit", v)?;
11030 }
11031 if self.disable_backfill {
11032 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
11033 }
11034 if let Some(v) = self.options.as_ref() {
11035 struct_ser.serialize_field("options", v)?;
11036 }
11037 struct_ser.end()
11038 }
11039}
11040impl<'de> serde::Deserialize<'de> for StreamCdcScanNode {
11041 #[allow(deprecated)]
11042 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11043 where
11044 D: serde::Deserializer<'de>,
11045 {
11046 const FIELDS: &[&str] = &[
11047 "table_id",
11048 "tableId",
11049 "upstream_column_ids",
11050 "upstreamColumnIds",
11051 "output_indices",
11052 "outputIndices",
11053 "state_table",
11054 "stateTable",
11055 "cdc_table_desc",
11056 "cdcTableDesc",
11057 "rate_limit",
11058 "rateLimit",
11059 "disable_backfill",
11060 "disableBackfill",
11061 "options",
11062 ];
11063
11064 #[allow(clippy::enum_variant_names)]
11065 enum GeneratedField {
11066 TableId,
11067 UpstreamColumnIds,
11068 OutputIndices,
11069 StateTable,
11070 CdcTableDesc,
11071 RateLimit,
11072 DisableBackfill,
11073 Options,
11074 }
11075 impl<'de> serde::Deserialize<'de> for GeneratedField {
11076 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11077 where
11078 D: serde::Deserializer<'de>,
11079 {
11080 struct GeneratedVisitor;
11081
11082 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11083 type Value = GeneratedField;
11084
11085 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11086 write!(formatter, "expected one of: {:?}", &FIELDS)
11087 }
11088
11089 #[allow(unused_variables)]
11090 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11091 where
11092 E: serde::de::Error,
11093 {
11094 match value {
11095 "tableId" | "table_id" => Ok(GeneratedField::TableId),
11096 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
11097 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
11098 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11099 "cdcTableDesc" | "cdc_table_desc" => Ok(GeneratedField::CdcTableDesc),
11100 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11101 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
11102 "options" => Ok(GeneratedField::Options),
11103 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11104 }
11105 }
11106 }
11107 deserializer.deserialize_identifier(GeneratedVisitor)
11108 }
11109 }
11110 struct GeneratedVisitor;
11111 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11112 type Value = StreamCdcScanNode;
11113
11114 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11115 formatter.write_str("struct stream_plan.StreamCdcScanNode")
11116 }
11117
11118 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanNode, V::Error>
11119 where
11120 V: serde::de::MapAccess<'de>,
11121 {
11122 let mut table_id__ = None;
11123 let mut upstream_column_ids__ = None;
11124 let mut output_indices__ = None;
11125 let mut state_table__ = None;
11126 let mut cdc_table_desc__ = None;
11127 let mut rate_limit__ = None;
11128 let mut disable_backfill__ = None;
11129 let mut options__ = None;
11130 while let Some(k) = map_.next_key()? {
11131 match k {
11132 GeneratedField::TableId => {
11133 if table_id__.is_some() {
11134 return Err(serde::de::Error::duplicate_field("tableId"));
11135 }
11136 table_id__ =
11137 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11138 ;
11139 }
11140 GeneratedField::UpstreamColumnIds => {
11141 if upstream_column_ids__.is_some() {
11142 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
11143 }
11144 upstream_column_ids__ =
11145 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11146 .into_iter().map(|x| x.0).collect())
11147 ;
11148 }
11149 GeneratedField::OutputIndices => {
11150 if output_indices__.is_some() {
11151 return Err(serde::de::Error::duplicate_field("outputIndices"));
11152 }
11153 output_indices__ =
11154 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11155 .into_iter().map(|x| x.0).collect())
11156 ;
11157 }
11158 GeneratedField::StateTable => {
11159 if state_table__.is_some() {
11160 return Err(serde::de::Error::duplicate_field("stateTable"));
11161 }
11162 state_table__ = map_.next_value()?;
11163 }
11164 GeneratedField::CdcTableDesc => {
11165 if cdc_table_desc__.is_some() {
11166 return Err(serde::de::Error::duplicate_field("cdcTableDesc"));
11167 }
11168 cdc_table_desc__ = map_.next_value()?;
11169 }
11170 GeneratedField::RateLimit => {
11171 if rate_limit__.is_some() {
11172 return Err(serde::de::Error::duplicate_field("rateLimit"));
11173 }
11174 rate_limit__ =
11175 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11176 ;
11177 }
11178 GeneratedField::DisableBackfill => {
11179 if disable_backfill__.is_some() {
11180 return Err(serde::de::Error::duplicate_field("disableBackfill"));
11181 }
11182 disable_backfill__ = Some(map_.next_value()?);
11183 }
11184 GeneratedField::Options => {
11185 if options__.is_some() {
11186 return Err(serde::de::Error::duplicate_field("options"));
11187 }
11188 options__ = map_.next_value()?;
11189 }
11190 }
11191 }
11192 Ok(StreamCdcScanNode {
11193 table_id: table_id__.unwrap_or_default(),
11194 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
11195 output_indices: output_indices__.unwrap_or_default(),
11196 state_table: state_table__,
11197 cdc_table_desc: cdc_table_desc__,
11198 rate_limit: rate_limit__,
11199 disable_backfill: disable_backfill__.unwrap_or_default(),
11200 options: options__,
11201 })
11202 }
11203 }
11204 deserializer.deserialize_struct("stream_plan.StreamCdcScanNode", FIELDS, GeneratedVisitor)
11205 }
11206}
11207impl serde::Serialize for StreamCdcScanOptions {
11208 #[allow(deprecated)]
11209 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11210 where
11211 S: serde::Serializer,
11212 {
11213 use serde::ser::SerializeStruct;
11214 let mut len = 0;
11215 if self.disable_backfill {
11216 len += 1;
11217 }
11218 if self.snapshot_barrier_interval != 0 {
11219 len += 1;
11220 }
11221 if self.snapshot_batch_size != 0 {
11222 len += 1;
11223 }
11224 if self.backfill_parallelism != 0 {
11225 len += 1;
11226 }
11227 if self.backfill_num_rows_per_split != 0 {
11228 len += 1;
11229 }
11230 if self.backfill_as_even_splits {
11231 len += 1;
11232 }
11233 if self.backfill_split_pk_column_index != 0 {
11234 len += 1;
11235 }
11236 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanOptions", len)?;
11237 if self.disable_backfill {
11238 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
11239 }
11240 if self.snapshot_barrier_interval != 0 {
11241 struct_ser.serialize_field("snapshotBarrierInterval", &self.snapshot_barrier_interval)?;
11242 }
11243 if self.snapshot_batch_size != 0 {
11244 struct_ser.serialize_field("snapshotBatchSize", &self.snapshot_batch_size)?;
11245 }
11246 if self.backfill_parallelism != 0 {
11247 struct_ser.serialize_field("backfillParallelism", &self.backfill_parallelism)?;
11248 }
11249 if self.backfill_num_rows_per_split != 0 {
11250 #[allow(clippy::needless_borrow)]
11251 #[allow(clippy::needless_borrows_for_generic_args)]
11252 struct_ser.serialize_field("backfillNumRowsPerSplit", ToString::to_string(&self.backfill_num_rows_per_split).as_str())?;
11253 }
11254 if self.backfill_as_even_splits {
11255 struct_ser.serialize_field("backfillAsEvenSplits", &self.backfill_as_even_splits)?;
11256 }
11257 if self.backfill_split_pk_column_index != 0 {
11258 struct_ser.serialize_field("backfillSplitPkColumnIndex", &self.backfill_split_pk_column_index)?;
11259 }
11260 struct_ser.end()
11261 }
11262}
11263impl<'de> serde::Deserialize<'de> for StreamCdcScanOptions {
11264 #[allow(deprecated)]
11265 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11266 where
11267 D: serde::Deserializer<'de>,
11268 {
11269 const FIELDS: &[&str] = &[
11270 "disable_backfill",
11271 "disableBackfill",
11272 "snapshot_barrier_interval",
11273 "snapshotBarrierInterval",
11274 "snapshot_batch_size",
11275 "snapshotBatchSize",
11276 "backfill_parallelism",
11277 "backfillParallelism",
11278 "backfill_num_rows_per_split",
11279 "backfillNumRowsPerSplit",
11280 "backfill_as_even_splits",
11281 "backfillAsEvenSplits",
11282 "backfill_split_pk_column_index",
11283 "backfillSplitPkColumnIndex",
11284 ];
11285
11286 #[allow(clippy::enum_variant_names)]
11287 enum GeneratedField {
11288 DisableBackfill,
11289 SnapshotBarrierInterval,
11290 SnapshotBatchSize,
11291 BackfillParallelism,
11292 BackfillNumRowsPerSplit,
11293 BackfillAsEvenSplits,
11294 BackfillSplitPkColumnIndex,
11295 }
11296 impl<'de> serde::Deserialize<'de> for GeneratedField {
11297 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11298 where
11299 D: serde::Deserializer<'de>,
11300 {
11301 struct GeneratedVisitor;
11302
11303 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11304 type Value = GeneratedField;
11305
11306 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11307 write!(formatter, "expected one of: {:?}", &FIELDS)
11308 }
11309
11310 #[allow(unused_variables)]
11311 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11312 where
11313 E: serde::de::Error,
11314 {
11315 match value {
11316 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
11317 "snapshotBarrierInterval" | "snapshot_barrier_interval" => Ok(GeneratedField::SnapshotBarrierInterval),
11318 "snapshotBatchSize" | "snapshot_batch_size" => Ok(GeneratedField::SnapshotBatchSize),
11319 "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
11320 "backfillNumRowsPerSplit" | "backfill_num_rows_per_split" => Ok(GeneratedField::BackfillNumRowsPerSplit),
11321 "backfillAsEvenSplits" | "backfill_as_even_splits" => Ok(GeneratedField::BackfillAsEvenSplits),
11322 "backfillSplitPkColumnIndex" | "backfill_split_pk_column_index" => Ok(GeneratedField::BackfillSplitPkColumnIndex),
11323 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11324 }
11325 }
11326 }
11327 deserializer.deserialize_identifier(GeneratedVisitor)
11328 }
11329 }
11330 struct GeneratedVisitor;
11331 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11332 type Value = StreamCdcScanOptions;
11333
11334 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11335 formatter.write_str("struct stream_plan.StreamCdcScanOptions")
11336 }
11337
11338 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanOptions, V::Error>
11339 where
11340 V: serde::de::MapAccess<'de>,
11341 {
11342 let mut disable_backfill__ = None;
11343 let mut snapshot_barrier_interval__ = None;
11344 let mut snapshot_batch_size__ = None;
11345 let mut backfill_parallelism__ = None;
11346 let mut backfill_num_rows_per_split__ = None;
11347 let mut backfill_as_even_splits__ = None;
11348 let mut backfill_split_pk_column_index__ = None;
11349 while let Some(k) = map_.next_key()? {
11350 match k {
11351 GeneratedField::DisableBackfill => {
11352 if disable_backfill__.is_some() {
11353 return Err(serde::de::Error::duplicate_field("disableBackfill"));
11354 }
11355 disable_backfill__ = Some(map_.next_value()?);
11356 }
11357 GeneratedField::SnapshotBarrierInterval => {
11358 if snapshot_barrier_interval__.is_some() {
11359 return Err(serde::de::Error::duplicate_field("snapshotBarrierInterval"));
11360 }
11361 snapshot_barrier_interval__ =
11362 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11363 ;
11364 }
11365 GeneratedField::SnapshotBatchSize => {
11366 if snapshot_batch_size__.is_some() {
11367 return Err(serde::de::Error::duplicate_field("snapshotBatchSize"));
11368 }
11369 snapshot_batch_size__ =
11370 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11371 ;
11372 }
11373 GeneratedField::BackfillParallelism => {
11374 if backfill_parallelism__.is_some() {
11375 return Err(serde::de::Error::duplicate_field("backfillParallelism"));
11376 }
11377 backfill_parallelism__ =
11378 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11379 ;
11380 }
11381 GeneratedField::BackfillNumRowsPerSplit => {
11382 if backfill_num_rows_per_split__.is_some() {
11383 return Err(serde::de::Error::duplicate_field("backfillNumRowsPerSplit"));
11384 }
11385 backfill_num_rows_per_split__ =
11386 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11387 ;
11388 }
11389 GeneratedField::BackfillAsEvenSplits => {
11390 if backfill_as_even_splits__.is_some() {
11391 return Err(serde::de::Error::duplicate_field("backfillAsEvenSplits"));
11392 }
11393 backfill_as_even_splits__ = Some(map_.next_value()?);
11394 }
11395 GeneratedField::BackfillSplitPkColumnIndex => {
11396 if backfill_split_pk_column_index__.is_some() {
11397 return Err(serde::de::Error::duplicate_field("backfillSplitPkColumnIndex"));
11398 }
11399 backfill_split_pk_column_index__ =
11400 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11401 ;
11402 }
11403 }
11404 }
11405 Ok(StreamCdcScanOptions {
11406 disable_backfill: disable_backfill__.unwrap_or_default(),
11407 snapshot_barrier_interval: snapshot_barrier_interval__.unwrap_or_default(),
11408 snapshot_batch_size: snapshot_batch_size__.unwrap_or_default(),
11409 backfill_parallelism: backfill_parallelism__.unwrap_or_default(),
11410 backfill_num_rows_per_split: backfill_num_rows_per_split__.unwrap_or_default(),
11411 backfill_as_even_splits: backfill_as_even_splits__.unwrap_or_default(),
11412 backfill_split_pk_column_index: backfill_split_pk_column_index__.unwrap_or_default(),
11413 })
11414 }
11415 }
11416 deserializer.deserialize_struct("stream_plan.StreamCdcScanOptions", FIELDS, GeneratedVisitor)
11417 }
11418}
11419impl serde::Serialize for StreamContext {
11420 #[allow(deprecated)]
11421 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11422 where
11423 S: serde::Serializer,
11424 {
11425 use serde::ser::SerializeStruct;
11426 let mut len = 0;
11427 if !self.timezone.is_empty() {
11428 len += 1;
11429 }
11430 if !self.config_override.is_empty() {
11431 len += 1;
11432 }
11433 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamContext", len)?;
11434 if !self.timezone.is_empty() {
11435 struct_ser.serialize_field("timezone", &self.timezone)?;
11436 }
11437 if !self.config_override.is_empty() {
11438 struct_ser.serialize_field("configOverride", &self.config_override)?;
11439 }
11440 struct_ser.end()
11441 }
11442}
11443impl<'de> serde::Deserialize<'de> for StreamContext {
11444 #[allow(deprecated)]
11445 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11446 where
11447 D: serde::Deserializer<'de>,
11448 {
11449 const FIELDS: &[&str] = &[
11450 "timezone",
11451 "config_override",
11452 "configOverride",
11453 ];
11454
11455 #[allow(clippy::enum_variant_names)]
11456 enum GeneratedField {
11457 Timezone,
11458 ConfigOverride,
11459 }
11460 impl<'de> serde::Deserialize<'de> for GeneratedField {
11461 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11462 where
11463 D: serde::Deserializer<'de>,
11464 {
11465 struct GeneratedVisitor;
11466
11467 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11468 type Value = GeneratedField;
11469
11470 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11471 write!(formatter, "expected one of: {:?}", &FIELDS)
11472 }
11473
11474 #[allow(unused_variables)]
11475 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11476 where
11477 E: serde::de::Error,
11478 {
11479 match value {
11480 "timezone" => Ok(GeneratedField::Timezone),
11481 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
11482 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11483 }
11484 }
11485 }
11486 deserializer.deserialize_identifier(GeneratedVisitor)
11487 }
11488 }
11489 struct GeneratedVisitor;
11490 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11491 type Value = StreamContext;
11492
11493 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11494 formatter.write_str("struct stream_plan.StreamContext")
11495 }
11496
11497 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamContext, V::Error>
11498 where
11499 V: serde::de::MapAccess<'de>,
11500 {
11501 let mut timezone__ = None;
11502 let mut config_override__ = None;
11503 while let Some(k) = map_.next_key()? {
11504 match k {
11505 GeneratedField::Timezone => {
11506 if timezone__.is_some() {
11507 return Err(serde::de::Error::duplicate_field("timezone"));
11508 }
11509 timezone__ = Some(map_.next_value()?);
11510 }
11511 GeneratedField::ConfigOverride => {
11512 if config_override__.is_some() {
11513 return Err(serde::de::Error::duplicate_field("configOverride"));
11514 }
11515 config_override__ = Some(map_.next_value()?);
11516 }
11517 }
11518 }
11519 Ok(StreamContext {
11520 timezone: timezone__.unwrap_or_default(),
11521 config_override: config_override__.unwrap_or_default(),
11522 })
11523 }
11524 }
11525 deserializer.deserialize_struct("stream_plan.StreamContext", FIELDS, GeneratedVisitor)
11526 }
11527}
11528impl serde::Serialize for StreamFragmentGraph {
11529 #[allow(deprecated)]
11530 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11531 where
11532 S: serde::Serializer,
11533 {
11534 use serde::ser::SerializeStruct;
11535 let mut len = 0;
11536 if !self.fragments.is_empty() {
11537 len += 1;
11538 }
11539 if !self.edges.is_empty() {
11540 len += 1;
11541 }
11542 if !self.dependent_table_ids.is_empty() {
11543 len += 1;
11544 }
11545 if self.table_ids_cnt != 0 {
11546 len += 1;
11547 }
11548 if self.ctx.is_some() {
11549 len += 1;
11550 }
11551 if self.parallelism.is_some() {
11552 len += 1;
11553 }
11554 if self.max_parallelism != 0 {
11555 len += 1;
11556 }
11557 if self.backfill_order.is_some() {
11558 len += 1;
11559 }
11560 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph", len)?;
11561 if !self.fragments.is_empty() {
11562 struct_ser.serialize_field("fragments", &self.fragments)?;
11563 }
11564 if !self.edges.is_empty() {
11565 struct_ser.serialize_field("edges", &self.edges)?;
11566 }
11567 if !self.dependent_table_ids.is_empty() {
11568 struct_ser.serialize_field("dependentTableIds", &self.dependent_table_ids)?;
11569 }
11570 if self.table_ids_cnt != 0 {
11571 struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
11572 }
11573 if let Some(v) = self.ctx.as_ref() {
11574 struct_ser.serialize_field("ctx", v)?;
11575 }
11576 if let Some(v) = self.parallelism.as_ref() {
11577 struct_ser.serialize_field("parallelism", v)?;
11578 }
11579 if self.max_parallelism != 0 {
11580 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
11581 }
11582 if let Some(v) = self.backfill_order.as_ref() {
11583 struct_ser.serialize_field("backfillOrder", v)?;
11584 }
11585 struct_ser.end()
11586 }
11587}
11588impl<'de> serde::Deserialize<'de> for StreamFragmentGraph {
11589 #[allow(deprecated)]
11590 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11591 where
11592 D: serde::Deserializer<'de>,
11593 {
11594 const FIELDS: &[&str] = &[
11595 "fragments",
11596 "edges",
11597 "dependent_table_ids",
11598 "dependentTableIds",
11599 "table_ids_cnt",
11600 "tableIdsCnt",
11601 "ctx",
11602 "parallelism",
11603 "max_parallelism",
11604 "maxParallelism",
11605 "backfill_order",
11606 "backfillOrder",
11607 ];
11608
11609 #[allow(clippy::enum_variant_names)]
11610 enum GeneratedField {
11611 Fragments,
11612 Edges,
11613 DependentTableIds,
11614 TableIdsCnt,
11615 Ctx,
11616 Parallelism,
11617 MaxParallelism,
11618 BackfillOrder,
11619 }
11620 impl<'de> serde::Deserialize<'de> for GeneratedField {
11621 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11622 where
11623 D: serde::Deserializer<'de>,
11624 {
11625 struct GeneratedVisitor;
11626
11627 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11628 type Value = GeneratedField;
11629
11630 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11631 write!(formatter, "expected one of: {:?}", &FIELDS)
11632 }
11633
11634 #[allow(unused_variables)]
11635 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11636 where
11637 E: serde::de::Error,
11638 {
11639 match value {
11640 "fragments" => Ok(GeneratedField::Fragments),
11641 "edges" => Ok(GeneratedField::Edges),
11642 "dependentTableIds" | "dependent_table_ids" => Ok(GeneratedField::DependentTableIds),
11643 "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
11644 "ctx" => Ok(GeneratedField::Ctx),
11645 "parallelism" => Ok(GeneratedField::Parallelism),
11646 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
11647 "backfillOrder" | "backfill_order" => Ok(GeneratedField::BackfillOrder),
11648 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11649 }
11650 }
11651 }
11652 deserializer.deserialize_identifier(GeneratedVisitor)
11653 }
11654 }
11655 struct GeneratedVisitor;
11656 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11657 type Value = StreamFragmentGraph;
11658
11659 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11660 formatter.write_str("struct stream_plan.StreamFragmentGraph")
11661 }
11662
11663 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFragmentGraph, V::Error>
11664 where
11665 V: serde::de::MapAccess<'de>,
11666 {
11667 let mut fragments__ = None;
11668 let mut edges__ = None;
11669 let mut dependent_table_ids__ = None;
11670 let mut table_ids_cnt__ = None;
11671 let mut ctx__ = None;
11672 let mut parallelism__ = None;
11673 let mut max_parallelism__ = None;
11674 let mut backfill_order__ = None;
11675 while let Some(k) = map_.next_key()? {
11676 match k {
11677 GeneratedField::Fragments => {
11678 if fragments__.is_some() {
11679 return Err(serde::de::Error::duplicate_field("fragments"));
11680 }
11681 fragments__ = Some(
11682 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11683 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
11684 );
11685 }
11686 GeneratedField::Edges => {
11687 if edges__.is_some() {
11688 return Err(serde::de::Error::duplicate_field("edges"));
11689 }
11690 edges__ = Some(map_.next_value()?);
11691 }
11692 GeneratedField::DependentTableIds => {
11693 if dependent_table_ids__.is_some() {
11694 return Err(serde::de::Error::duplicate_field("dependentTableIds"));
11695 }
11696 dependent_table_ids__ =
11697 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11698 .into_iter().map(|x| x.0).collect())
11699 ;
11700 }
11701 GeneratedField::TableIdsCnt => {
11702 if table_ids_cnt__.is_some() {
11703 return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
11704 }
11705 table_ids_cnt__ =
11706 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11707 ;
11708 }
11709 GeneratedField::Ctx => {
11710 if ctx__.is_some() {
11711 return Err(serde::de::Error::duplicate_field("ctx"));
11712 }
11713 ctx__ = map_.next_value()?;
11714 }
11715 GeneratedField::Parallelism => {
11716 if parallelism__.is_some() {
11717 return Err(serde::de::Error::duplicate_field("parallelism"));
11718 }
11719 parallelism__ = map_.next_value()?;
11720 }
11721 GeneratedField::MaxParallelism => {
11722 if max_parallelism__.is_some() {
11723 return Err(serde::de::Error::duplicate_field("maxParallelism"));
11724 }
11725 max_parallelism__ =
11726 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11727 ;
11728 }
11729 GeneratedField::BackfillOrder => {
11730 if backfill_order__.is_some() {
11731 return Err(serde::de::Error::duplicate_field("backfillOrder"));
11732 }
11733 backfill_order__ = map_.next_value()?;
11734 }
11735 }
11736 }
11737 Ok(StreamFragmentGraph {
11738 fragments: fragments__.unwrap_or_default(),
11739 edges: edges__.unwrap_or_default(),
11740 dependent_table_ids: dependent_table_ids__.unwrap_or_default(),
11741 table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
11742 ctx: ctx__,
11743 parallelism: parallelism__,
11744 max_parallelism: max_parallelism__.unwrap_or_default(),
11745 backfill_order: backfill_order__,
11746 })
11747 }
11748 }
11749 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph", FIELDS, GeneratedVisitor)
11750 }
11751}
11752impl serde::Serialize for stream_fragment_graph::Parallelism {
11753 #[allow(deprecated)]
11754 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11755 where
11756 S: serde::Serializer,
11757 {
11758 use serde::ser::SerializeStruct;
11759 let mut len = 0;
11760 if self.parallelism != 0 {
11761 len += 1;
11762 }
11763 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.Parallelism", len)?;
11764 if self.parallelism != 0 {
11765 #[allow(clippy::needless_borrow)]
11766 #[allow(clippy::needless_borrows_for_generic_args)]
11767 struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
11768 }
11769 struct_ser.end()
11770 }
11771}
11772impl<'de> serde::Deserialize<'de> for stream_fragment_graph::Parallelism {
11773 #[allow(deprecated)]
11774 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11775 where
11776 D: serde::Deserializer<'de>,
11777 {
11778 const FIELDS: &[&str] = &[
11779 "parallelism",
11780 ];
11781
11782 #[allow(clippy::enum_variant_names)]
11783 enum GeneratedField {
11784 Parallelism,
11785 }
11786 impl<'de> serde::Deserialize<'de> for GeneratedField {
11787 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11788 where
11789 D: serde::Deserializer<'de>,
11790 {
11791 struct GeneratedVisitor;
11792
11793 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11794 type Value = GeneratedField;
11795
11796 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11797 write!(formatter, "expected one of: {:?}", &FIELDS)
11798 }
11799
11800 #[allow(unused_variables)]
11801 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11802 where
11803 E: serde::de::Error,
11804 {
11805 match value {
11806 "parallelism" => Ok(GeneratedField::Parallelism),
11807 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11808 }
11809 }
11810 }
11811 deserializer.deserialize_identifier(GeneratedVisitor)
11812 }
11813 }
11814 struct GeneratedVisitor;
11815 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11816 type Value = stream_fragment_graph::Parallelism;
11817
11818 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11819 formatter.write_str("struct stream_plan.StreamFragmentGraph.Parallelism")
11820 }
11821
11822 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::Parallelism, V::Error>
11823 where
11824 V: serde::de::MapAccess<'de>,
11825 {
11826 let mut parallelism__ = None;
11827 while let Some(k) = map_.next_key()? {
11828 match k {
11829 GeneratedField::Parallelism => {
11830 if parallelism__.is_some() {
11831 return Err(serde::de::Error::duplicate_field("parallelism"));
11832 }
11833 parallelism__ =
11834 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11835 ;
11836 }
11837 }
11838 }
11839 Ok(stream_fragment_graph::Parallelism {
11840 parallelism: parallelism__.unwrap_or_default(),
11841 })
11842 }
11843 }
11844 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.Parallelism", FIELDS, GeneratedVisitor)
11845 }
11846}
11847impl serde::Serialize for stream_fragment_graph::StreamFragment {
11848 #[allow(deprecated)]
11849 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11850 where
11851 S: serde::Serializer,
11852 {
11853 use serde::ser::SerializeStruct;
11854 let mut len = 0;
11855 if self.fragment_id != 0 {
11856 len += 1;
11857 }
11858 if self.node.is_some() {
11859 len += 1;
11860 }
11861 if self.fragment_type_mask != 0 {
11862 len += 1;
11863 }
11864 if self.requires_singleton {
11865 len += 1;
11866 }
11867 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", len)?;
11868 if self.fragment_id != 0 {
11869 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
11870 }
11871 if let Some(v) = self.node.as_ref() {
11872 struct_ser.serialize_field("node", v)?;
11873 }
11874 if self.fragment_type_mask != 0 {
11875 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
11876 }
11877 if self.requires_singleton {
11878 struct_ser.serialize_field("requiresSingleton", &self.requires_singleton)?;
11879 }
11880 struct_ser.end()
11881 }
11882}
11883impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragment {
11884 #[allow(deprecated)]
11885 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11886 where
11887 D: serde::Deserializer<'de>,
11888 {
11889 const FIELDS: &[&str] = &[
11890 "fragment_id",
11891 "fragmentId",
11892 "node",
11893 "fragment_type_mask",
11894 "fragmentTypeMask",
11895 "requires_singleton",
11896 "requiresSingleton",
11897 ];
11898
11899 #[allow(clippy::enum_variant_names)]
11900 enum GeneratedField {
11901 FragmentId,
11902 Node,
11903 FragmentTypeMask,
11904 RequiresSingleton,
11905 }
11906 impl<'de> serde::Deserialize<'de> for GeneratedField {
11907 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11908 where
11909 D: serde::Deserializer<'de>,
11910 {
11911 struct GeneratedVisitor;
11912
11913 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11914 type Value = GeneratedField;
11915
11916 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11917 write!(formatter, "expected one of: {:?}", &FIELDS)
11918 }
11919
11920 #[allow(unused_variables)]
11921 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11922 where
11923 E: serde::de::Error,
11924 {
11925 match value {
11926 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
11927 "node" => Ok(GeneratedField::Node),
11928 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
11929 "requiresSingleton" | "requires_singleton" => Ok(GeneratedField::RequiresSingleton),
11930 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11931 }
11932 }
11933 }
11934 deserializer.deserialize_identifier(GeneratedVisitor)
11935 }
11936 }
11937 struct GeneratedVisitor;
11938 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11939 type Value = stream_fragment_graph::StreamFragment;
11940
11941 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11942 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragment")
11943 }
11944
11945 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragment, V::Error>
11946 where
11947 V: serde::de::MapAccess<'de>,
11948 {
11949 let mut fragment_id__ = None;
11950 let mut node__ = None;
11951 let mut fragment_type_mask__ = None;
11952 let mut requires_singleton__ = None;
11953 while let Some(k) = map_.next_key()? {
11954 match k {
11955 GeneratedField::FragmentId => {
11956 if fragment_id__.is_some() {
11957 return Err(serde::de::Error::duplicate_field("fragmentId"));
11958 }
11959 fragment_id__ =
11960 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11961 ;
11962 }
11963 GeneratedField::Node => {
11964 if node__.is_some() {
11965 return Err(serde::de::Error::duplicate_field("node"));
11966 }
11967 node__ = map_.next_value()?;
11968 }
11969 GeneratedField::FragmentTypeMask => {
11970 if fragment_type_mask__.is_some() {
11971 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
11972 }
11973 fragment_type_mask__ =
11974 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11975 ;
11976 }
11977 GeneratedField::RequiresSingleton => {
11978 if requires_singleton__.is_some() {
11979 return Err(serde::de::Error::duplicate_field("requiresSingleton"));
11980 }
11981 requires_singleton__ = Some(map_.next_value()?);
11982 }
11983 }
11984 }
11985 Ok(stream_fragment_graph::StreamFragment {
11986 fragment_id: fragment_id__.unwrap_or_default(),
11987 node: node__,
11988 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
11989 requires_singleton: requires_singleton__.unwrap_or_default(),
11990 })
11991 }
11992 }
11993 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", FIELDS, GeneratedVisitor)
11994 }
11995}
11996impl serde::Serialize for stream_fragment_graph::StreamFragmentEdge {
11997 #[allow(deprecated)]
11998 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11999 where
12000 S: serde::Serializer,
12001 {
12002 use serde::ser::SerializeStruct;
12003 let mut len = 0;
12004 if self.dispatch_strategy.is_some() {
12005 len += 1;
12006 }
12007 if self.link_id != 0 {
12008 len += 1;
12009 }
12010 if self.upstream_id != 0 {
12011 len += 1;
12012 }
12013 if self.downstream_id != 0 {
12014 len += 1;
12015 }
12016 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", len)?;
12017 if let Some(v) = self.dispatch_strategy.as_ref() {
12018 struct_ser.serialize_field("dispatchStrategy", v)?;
12019 }
12020 if self.link_id != 0 {
12021 #[allow(clippy::needless_borrow)]
12022 #[allow(clippy::needless_borrows_for_generic_args)]
12023 struct_ser.serialize_field("linkId", ToString::to_string(&self.link_id).as_str())?;
12024 }
12025 if self.upstream_id != 0 {
12026 struct_ser.serialize_field("upstreamId", &self.upstream_id)?;
12027 }
12028 if self.downstream_id != 0 {
12029 struct_ser.serialize_field("downstreamId", &self.downstream_id)?;
12030 }
12031 struct_ser.end()
12032 }
12033}
12034impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragmentEdge {
12035 #[allow(deprecated)]
12036 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12037 where
12038 D: serde::Deserializer<'de>,
12039 {
12040 const FIELDS: &[&str] = &[
12041 "dispatch_strategy",
12042 "dispatchStrategy",
12043 "link_id",
12044 "linkId",
12045 "upstream_id",
12046 "upstreamId",
12047 "downstream_id",
12048 "downstreamId",
12049 ];
12050
12051 #[allow(clippy::enum_variant_names)]
12052 enum GeneratedField {
12053 DispatchStrategy,
12054 LinkId,
12055 UpstreamId,
12056 DownstreamId,
12057 }
12058 impl<'de> serde::Deserialize<'de> for GeneratedField {
12059 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12060 where
12061 D: serde::Deserializer<'de>,
12062 {
12063 struct GeneratedVisitor;
12064
12065 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12066 type Value = GeneratedField;
12067
12068 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12069 write!(formatter, "expected one of: {:?}", &FIELDS)
12070 }
12071
12072 #[allow(unused_variables)]
12073 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12074 where
12075 E: serde::de::Error,
12076 {
12077 match value {
12078 "dispatchStrategy" | "dispatch_strategy" => Ok(GeneratedField::DispatchStrategy),
12079 "linkId" | "link_id" => Ok(GeneratedField::LinkId),
12080 "upstreamId" | "upstream_id" => Ok(GeneratedField::UpstreamId),
12081 "downstreamId" | "downstream_id" => Ok(GeneratedField::DownstreamId),
12082 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12083 }
12084 }
12085 }
12086 deserializer.deserialize_identifier(GeneratedVisitor)
12087 }
12088 }
12089 struct GeneratedVisitor;
12090 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12091 type Value = stream_fragment_graph::StreamFragmentEdge;
12092
12093 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12094 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragmentEdge")
12095 }
12096
12097 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragmentEdge, V::Error>
12098 where
12099 V: serde::de::MapAccess<'de>,
12100 {
12101 let mut dispatch_strategy__ = None;
12102 let mut link_id__ = None;
12103 let mut upstream_id__ = None;
12104 let mut downstream_id__ = None;
12105 while let Some(k) = map_.next_key()? {
12106 match k {
12107 GeneratedField::DispatchStrategy => {
12108 if dispatch_strategy__.is_some() {
12109 return Err(serde::de::Error::duplicate_field("dispatchStrategy"));
12110 }
12111 dispatch_strategy__ = map_.next_value()?;
12112 }
12113 GeneratedField::LinkId => {
12114 if link_id__.is_some() {
12115 return Err(serde::de::Error::duplicate_field("linkId"));
12116 }
12117 link_id__ =
12118 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12119 ;
12120 }
12121 GeneratedField::UpstreamId => {
12122 if upstream_id__.is_some() {
12123 return Err(serde::de::Error::duplicate_field("upstreamId"));
12124 }
12125 upstream_id__ =
12126 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12127 ;
12128 }
12129 GeneratedField::DownstreamId => {
12130 if downstream_id__.is_some() {
12131 return Err(serde::de::Error::duplicate_field("downstreamId"));
12132 }
12133 downstream_id__ =
12134 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12135 ;
12136 }
12137 }
12138 }
12139 Ok(stream_fragment_graph::StreamFragmentEdge {
12140 dispatch_strategy: dispatch_strategy__,
12141 link_id: link_id__.unwrap_or_default(),
12142 upstream_id: upstream_id__.unwrap_or_default(),
12143 downstream_id: downstream_id__.unwrap_or_default(),
12144 })
12145 }
12146 }
12147 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", FIELDS, GeneratedVisitor)
12148 }
12149}
12150impl serde::Serialize for StreamFsFetch {
12151 #[allow(deprecated)]
12152 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12153 where
12154 S: serde::Serializer,
12155 {
12156 use serde::ser::SerializeStruct;
12157 let mut len = 0;
12158 if self.source_id != 0 {
12159 len += 1;
12160 }
12161 if self.state_table.is_some() {
12162 len += 1;
12163 }
12164 if self.row_id_index.is_some() {
12165 len += 1;
12166 }
12167 if !self.columns.is_empty() {
12168 len += 1;
12169 }
12170 if !self.with_properties.is_empty() {
12171 len += 1;
12172 }
12173 if self.info.is_some() {
12174 len += 1;
12175 }
12176 if !self.source_name.is_empty() {
12177 len += 1;
12178 }
12179 if self.rate_limit.is_some() {
12180 len += 1;
12181 }
12182 if !self.secret_refs.is_empty() {
12183 len += 1;
12184 }
12185 if self.refresh_mode.is_some() {
12186 len += 1;
12187 }
12188 if self.associated_table_id.is_some() {
12189 len += 1;
12190 }
12191 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetch", len)?;
12192 if self.source_id != 0 {
12193 struct_ser.serialize_field("sourceId", &self.source_id)?;
12194 }
12195 if let Some(v) = self.state_table.as_ref() {
12196 struct_ser.serialize_field("stateTable", v)?;
12197 }
12198 if let Some(v) = self.row_id_index.as_ref() {
12199 struct_ser.serialize_field("rowIdIndex", v)?;
12200 }
12201 if !self.columns.is_empty() {
12202 struct_ser.serialize_field("columns", &self.columns)?;
12203 }
12204 if !self.with_properties.is_empty() {
12205 struct_ser.serialize_field("withProperties", &self.with_properties)?;
12206 }
12207 if let Some(v) = self.info.as_ref() {
12208 struct_ser.serialize_field("info", v)?;
12209 }
12210 if !self.source_name.is_empty() {
12211 struct_ser.serialize_field("sourceName", &self.source_name)?;
12212 }
12213 if let Some(v) = self.rate_limit.as_ref() {
12214 struct_ser.serialize_field("rateLimit", v)?;
12215 }
12216 if !self.secret_refs.is_empty() {
12217 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
12218 }
12219 if let Some(v) = self.refresh_mode.as_ref() {
12220 struct_ser.serialize_field("refreshMode", v)?;
12221 }
12222 if let Some(v) = self.associated_table_id.as_ref() {
12223 struct_ser.serialize_field("associatedTableId", v)?;
12224 }
12225 struct_ser.end()
12226 }
12227}
12228impl<'de> serde::Deserialize<'de> for StreamFsFetch {
12229 #[allow(deprecated)]
12230 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12231 where
12232 D: serde::Deserializer<'de>,
12233 {
12234 const FIELDS: &[&str] = &[
12235 "source_id",
12236 "sourceId",
12237 "state_table",
12238 "stateTable",
12239 "row_id_index",
12240 "rowIdIndex",
12241 "columns",
12242 "with_properties",
12243 "withProperties",
12244 "info",
12245 "source_name",
12246 "sourceName",
12247 "rate_limit",
12248 "rateLimit",
12249 "secret_refs",
12250 "secretRefs",
12251 "refresh_mode",
12252 "refreshMode",
12253 "associated_table_id",
12254 "associatedTableId",
12255 ];
12256
12257 #[allow(clippy::enum_variant_names)]
12258 enum GeneratedField {
12259 SourceId,
12260 StateTable,
12261 RowIdIndex,
12262 Columns,
12263 WithProperties,
12264 Info,
12265 SourceName,
12266 RateLimit,
12267 SecretRefs,
12268 RefreshMode,
12269 AssociatedTableId,
12270 }
12271 impl<'de> serde::Deserialize<'de> for GeneratedField {
12272 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12273 where
12274 D: serde::Deserializer<'de>,
12275 {
12276 struct GeneratedVisitor;
12277
12278 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12279 type Value = GeneratedField;
12280
12281 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12282 write!(formatter, "expected one of: {:?}", &FIELDS)
12283 }
12284
12285 #[allow(unused_variables)]
12286 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12287 where
12288 E: serde::de::Error,
12289 {
12290 match value {
12291 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
12292 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
12293 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
12294 "columns" => Ok(GeneratedField::Columns),
12295 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
12296 "info" => Ok(GeneratedField::Info),
12297 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
12298 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
12299 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
12300 "refreshMode" | "refresh_mode" => Ok(GeneratedField::RefreshMode),
12301 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
12302 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12303 }
12304 }
12305 }
12306 deserializer.deserialize_identifier(GeneratedVisitor)
12307 }
12308 }
12309 struct GeneratedVisitor;
12310 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12311 type Value = StreamFsFetch;
12312
12313 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12314 formatter.write_str("struct stream_plan.StreamFsFetch")
12315 }
12316
12317 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetch, V::Error>
12318 where
12319 V: serde::de::MapAccess<'de>,
12320 {
12321 let mut source_id__ = None;
12322 let mut state_table__ = None;
12323 let mut row_id_index__ = None;
12324 let mut columns__ = None;
12325 let mut with_properties__ = None;
12326 let mut info__ = None;
12327 let mut source_name__ = None;
12328 let mut rate_limit__ = None;
12329 let mut secret_refs__ = None;
12330 let mut refresh_mode__ = None;
12331 let mut associated_table_id__ = None;
12332 while let Some(k) = map_.next_key()? {
12333 match k {
12334 GeneratedField::SourceId => {
12335 if source_id__.is_some() {
12336 return Err(serde::de::Error::duplicate_field("sourceId"));
12337 }
12338 source_id__ =
12339 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12340 ;
12341 }
12342 GeneratedField::StateTable => {
12343 if state_table__.is_some() {
12344 return Err(serde::de::Error::duplicate_field("stateTable"));
12345 }
12346 state_table__ = map_.next_value()?;
12347 }
12348 GeneratedField::RowIdIndex => {
12349 if row_id_index__.is_some() {
12350 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
12351 }
12352 row_id_index__ =
12353 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12354 ;
12355 }
12356 GeneratedField::Columns => {
12357 if columns__.is_some() {
12358 return Err(serde::de::Error::duplicate_field("columns"));
12359 }
12360 columns__ = Some(map_.next_value()?);
12361 }
12362 GeneratedField::WithProperties => {
12363 if with_properties__.is_some() {
12364 return Err(serde::de::Error::duplicate_field("withProperties"));
12365 }
12366 with_properties__ = Some(
12367 map_.next_value::<std::collections::BTreeMap<_, _>>()?
12368 );
12369 }
12370 GeneratedField::Info => {
12371 if info__.is_some() {
12372 return Err(serde::de::Error::duplicate_field("info"));
12373 }
12374 info__ = map_.next_value()?;
12375 }
12376 GeneratedField::SourceName => {
12377 if source_name__.is_some() {
12378 return Err(serde::de::Error::duplicate_field("sourceName"));
12379 }
12380 source_name__ = Some(map_.next_value()?);
12381 }
12382 GeneratedField::RateLimit => {
12383 if rate_limit__.is_some() {
12384 return Err(serde::de::Error::duplicate_field("rateLimit"));
12385 }
12386 rate_limit__ =
12387 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12388 ;
12389 }
12390 GeneratedField::SecretRefs => {
12391 if secret_refs__.is_some() {
12392 return Err(serde::de::Error::duplicate_field("secretRefs"));
12393 }
12394 secret_refs__ = Some(
12395 map_.next_value::<std::collections::BTreeMap<_, _>>()?
12396 );
12397 }
12398 GeneratedField::RefreshMode => {
12399 if refresh_mode__.is_some() {
12400 return Err(serde::de::Error::duplicate_field("refreshMode"));
12401 }
12402 refresh_mode__ = map_.next_value()?;
12403 }
12404 GeneratedField::AssociatedTableId => {
12405 if associated_table_id__.is_some() {
12406 return Err(serde::de::Error::duplicate_field("associatedTableId"));
12407 }
12408 associated_table_id__ =
12409 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12410 ;
12411 }
12412 }
12413 }
12414 Ok(StreamFsFetch {
12415 source_id: source_id__.unwrap_or_default(),
12416 state_table: state_table__,
12417 row_id_index: row_id_index__,
12418 columns: columns__.unwrap_or_default(),
12419 with_properties: with_properties__.unwrap_or_default(),
12420 info: info__,
12421 source_name: source_name__.unwrap_or_default(),
12422 rate_limit: rate_limit__,
12423 secret_refs: secret_refs__.unwrap_or_default(),
12424 refresh_mode: refresh_mode__,
12425 associated_table_id: associated_table_id__,
12426 })
12427 }
12428 }
12429 deserializer.deserialize_struct("stream_plan.StreamFsFetch", FIELDS, GeneratedVisitor)
12430 }
12431}
12432impl serde::Serialize for StreamFsFetchNode {
12433 #[allow(deprecated)]
12434 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12435 where
12436 S: serde::Serializer,
12437 {
12438 use serde::ser::SerializeStruct;
12439 let mut len = 0;
12440 if self.node_inner.is_some() {
12441 len += 1;
12442 }
12443 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetchNode", len)?;
12444 if let Some(v) = self.node_inner.as_ref() {
12445 struct_ser.serialize_field("nodeInner", v)?;
12446 }
12447 struct_ser.end()
12448 }
12449}
12450impl<'de> serde::Deserialize<'de> for StreamFsFetchNode {
12451 #[allow(deprecated)]
12452 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12453 where
12454 D: serde::Deserializer<'de>,
12455 {
12456 const FIELDS: &[&str] = &[
12457 "node_inner",
12458 "nodeInner",
12459 ];
12460
12461 #[allow(clippy::enum_variant_names)]
12462 enum GeneratedField {
12463 NodeInner,
12464 }
12465 impl<'de> serde::Deserialize<'de> for GeneratedField {
12466 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12467 where
12468 D: serde::Deserializer<'de>,
12469 {
12470 struct GeneratedVisitor;
12471
12472 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12473 type Value = GeneratedField;
12474
12475 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12476 write!(formatter, "expected one of: {:?}", &FIELDS)
12477 }
12478
12479 #[allow(unused_variables)]
12480 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12481 where
12482 E: serde::de::Error,
12483 {
12484 match value {
12485 "nodeInner" | "node_inner" => Ok(GeneratedField::NodeInner),
12486 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12487 }
12488 }
12489 }
12490 deserializer.deserialize_identifier(GeneratedVisitor)
12491 }
12492 }
12493 struct GeneratedVisitor;
12494 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12495 type Value = StreamFsFetchNode;
12496
12497 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12498 formatter.write_str("struct stream_plan.StreamFsFetchNode")
12499 }
12500
12501 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetchNode, V::Error>
12502 where
12503 V: serde::de::MapAccess<'de>,
12504 {
12505 let mut node_inner__ = None;
12506 while let Some(k) = map_.next_key()? {
12507 match k {
12508 GeneratedField::NodeInner => {
12509 if node_inner__.is_some() {
12510 return Err(serde::de::Error::duplicate_field("nodeInner"));
12511 }
12512 node_inner__ = map_.next_value()?;
12513 }
12514 }
12515 }
12516 Ok(StreamFsFetchNode {
12517 node_inner: node_inner__,
12518 })
12519 }
12520 }
12521 deserializer.deserialize_struct("stream_plan.StreamFsFetchNode", FIELDS, GeneratedVisitor)
12522 }
12523}
12524impl serde::Serialize for StreamMessage {
12525 #[allow(deprecated)]
12526 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12527 where
12528 S: serde::Serializer,
12529 {
12530 use serde::ser::SerializeStruct;
12531 let mut len = 0;
12532 if self.stream_message.is_some() {
12533 len += 1;
12534 }
12535 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessage", len)?;
12536 if let Some(v) = self.stream_message.as_ref() {
12537 match v {
12538 stream_message::StreamMessage::StreamChunk(v) => {
12539 struct_ser.serialize_field("streamChunk", v)?;
12540 }
12541 stream_message::StreamMessage::Barrier(v) => {
12542 struct_ser.serialize_field("barrier", v)?;
12543 }
12544 stream_message::StreamMessage::Watermark(v) => {
12545 struct_ser.serialize_field("watermark", v)?;
12546 }
12547 }
12548 }
12549 struct_ser.end()
12550 }
12551}
12552impl<'de> serde::Deserialize<'de> for StreamMessage {
12553 #[allow(deprecated)]
12554 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12555 where
12556 D: serde::Deserializer<'de>,
12557 {
12558 const FIELDS: &[&str] = &[
12559 "stream_chunk",
12560 "streamChunk",
12561 "barrier",
12562 "watermark",
12563 ];
12564
12565 #[allow(clippy::enum_variant_names)]
12566 enum GeneratedField {
12567 StreamChunk,
12568 Barrier,
12569 Watermark,
12570 }
12571 impl<'de> serde::Deserialize<'de> for GeneratedField {
12572 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12573 where
12574 D: serde::Deserializer<'de>,
12575 {
12576 struct GeneratedVisitor;
12577
12578 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12579 type Value = GeneratedField;
12580
12581 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12582 write!(formatter, "expected one of: {:?}", &FIELDS)
12583 }
12584
12585 #[allow(unused_variables)]
12586 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12587 where
12588 E: serde::de::Error,
12589 {
12590 match value {
12591 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
12592 "barrier" => Ok(GeneratedField::Barrier),
12593 "watermark" => Ok(GeneratedField::Watermark),
12594 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12595 }
12596 }
12597 }
12598 deserializer.deserialize_identifier(GeneratedVisitor)
12599 }
12600 }
12601 struct GeneratedVisitor;
12602 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12603 type Value = StreamMessage;
12604
12605 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12606 formatter.write_str("struct stream_plan.StreamMessage")
12607 }
12608
12609 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessage, V::Error>
12610 where
12611 V: serde::de::MapAccess<'de>,
12612 {
12613 let mut stream_message__ = None;
12614 while let Some(k) = map_.next_key()? {
12615 match k {
12616 GeneratedField::StreamChunk => {
12617 if stream_message__.is_some() {
12618 return Err(serde::de::Error::duplicate_field("streamChunk"));
12619 }
12620 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::StreamChunk)
12621;
12622 }
12623 GeneratedField::Barrier => {
12624 if stream_message__.is_some() {
12625 return Err(serde::de::Error::duplicate_field("barrier"));
12626 }
12627 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Barrier)
12628;
12629 }
12630 GeneratedField::Watermark => {
12631 if stream_message__.is_some() {
12632 return Err(serde::de::Error::duplicate_field("watermark"));
12633 }
12634 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Watermark)
12635;
12636 }
12637 }
12638 }
12639 Ok(StreamMessage {
12640 stream_message: stream_message__,
12641 })
12642 }
12643 }
12644 deserializer.deserialize_struct("stream_plan.StreamMessage", FIELDS, GeneratedVisitor)
12645 }
12646}
12647impl serde::Serialize for StreamMessageBatch {
12648 #[allow(deprecated)]
12649 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12650 where
12651 S: serde::Serializer,
12652 {
12653 use serde::ser::SerializeStruct;
12654 let mut len = 0;
12655 if self.stream_message_batch.is_some() {
12656 len += 1;
12657 }
12658 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch", len)?;
12659 if let Some(v) = self.stream_message_batch.as_ref() {
12660 match v {
12661 stream_message_batch::StreamMessageBatch::StreamChunk(v) => {
12662 struct_ser.serialize_field("streamChunk", v)?;
12663 }
12664 stream_message_batch::StreamMessageBatch::BarrierBatch(v) => {
12665 struct_ser.serialize_field("barrierBatch", v)?;
12666 }
12667 stream_message_batch::StreamMessageBatch::Watermark(v) => {
12668 struct_ser.serialize_field("watermark", v)?;
12669 }
12670 }
12671 }
12672 struct_ser.end()
12673 }
12674}
12675impl<'de> serde::Deserialize<'de> for StreamMessageBatch {
12676 #[allow(deprecated)]
12677 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12678 where
12679 D: serde::Deserializer<'de>,
12680 {
12681 const FIELDS: &[&str] = &[
12682 "stream_chunk",
12683 "streamChunk",
12684 "barrier_batch",
12685 "barrierBatch",
12686 "watermark",
12687 ];
12688
12689 #[allow(clippy::enum_variant_names)]
12690 enum GeneratedField {
12691 StreamChunk,
12692 BarrierBatch,
12693 Watermark,
12694 }
12695 impl<'de> serde::Deserialize<'de> for GeneratedField {
12696 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12697 where
12698 D: serde::Deserializer<'de>,
12699 {
12700 struct GeneratedVisitor;
12701
12702 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12703 type Value = GeneratedField;
12704
12705 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12706 write!(formatter, "expected one of: {:?}", &FIELDS)
12707 }
12708
12709 #[allow(unused_variables)]
12710 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12711 where
12712 E: serde::de::Error,
12713 {
12714 match value {
12715 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
12716 "barrierBatch" | "barrier_batch" => Ok(GeneratedField::BarrierBatch),
12717 "watermark" => Ok(GeneratedField::Watermark),
12718 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12719 }
12720 }
12721 }
12722 deserializer.deserialize_identifier(GeneratedVisitor)
12723 }
12724 }
12725 struct GeneratedVisitor;
12726 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12727 type Value = StreamMessageBatch;
12728
12729 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12730 formatter.write_str("struct stream_plan.StreamMessageBatch")
12731 }
12732
12733 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessageBatch, V::Error>
12734 where
12735 V: serde::de::MapAccess<'de>,
12736 {
12737 let mut stream_message_batch__ = None;
12738 while let Some(k) = map_.next_key()? {
12739 match k {
12740 GeneratedField::StreamChunk => {
12741 if stream_message_batch__.is_some() {
12742 return Err(serde::de::Error::duplicate_field("streamChunk"));
12743 }
12744 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::StreamChunk)
12745;
12746 }
12747 GeneratedField::BarrierBatch => {
12748 if stream_message_batch__.is_some() {
12749 return Err(serde::de::Error::duplicate_field("barrierBatch"));
12750 }
12751 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::BarrierBatch)
12752;
12753 }
12754 GeneratedField::Watermark => {
12755 if stream_message_batch__.is_some() {
12756 return Err(serde::de::Error::duplicate_field("watermark"));
12757 }
12758 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::Watermark)
12759;
12760 }
12761 }
12762 }
12763 Ok(StreamMessageBatch {
12764 stream_message_batch: stream_message_batch__,
12765 })
12766 }
12767 }
12768 deserializer.deserialize_struct("stream_plan.StreamMessageBatch", FIELDS, GeneratedVisitor)
12769 }
12770}
12771impl serde::Serialize for stream_message_batch::BarrierBatch {
12772 #[allow(deprecated)]
12773 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12774 where
12775 S: serde::Serializer,
12776 {
12777 use serde::ser::SerializeStruct;
12778 let mut len = 0;
12779 if !self.barriers.is_empty() {
12780 len += 1;
12781 }
12782 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", len)?;
12783 if !self.barriers.is_empty() {
12784 struct_ser.serialize_field("barriers", &self.barriers)?;
12785 }
12786 struct_ser.end()
12787 }
12788}
12789impl<'de> serde::Deserialize<'de> for stream_message_batch::BarrierBatch {
12790 #[allow(deprecated)]
12791 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12792 where
12793 D: serde::Deserializer<'de>,
12794 {
12795 const FIELDS: &[&str] = &[
12796 "barriers",
12797 ];
12798
12799 #[allow(clippy::enum_variant_names)]
12800 enum GeneratedField {
12801 Barriers,
12802 }
12803 impl<'de> serde::Deserialize<'de> for GeneratedField {
12804 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12805 where
12806 D: serde::Deserializer<'de>,
12807 {
12808 struct GeneratedVisitor;
12809
12810 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12811 type Value = GeneratedField;
12812
12813 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12814 write!(formatter, "expected one of: {:?}", &FIELDS)
12815 }
12816
12817 #[allow(unused_variables)]
12818 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12819 where
12820 E: serde::de::Error,
12821 {
12822 match value {
12823 "barriers" => Ok(GeneratedField::Barriers),
12824 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12825 }
12826 }
12827 }
12828 deserializer.deserialize_identifier(GeneratedVisitor)
12829 }
12830 }
12831 struct GeneratedVisitor;
12832 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12833 type Value = stream_message_batch::BarrierBatch;
12834
12835 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12836 formatter.write_str("struct stream_plan.StreamMessageBatch.BarrierBatch")
12837 }
12838
12839 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_message_batch::BarrierBatch, V::Error>
12840 where
12841 V: serde::de::MapAccess<'de>,
12842 {
12843 let mut barriers__ = None;
12844 while let Some(k) = map_.next_key()? {
12845 match k {
12846 GeneratedField::Barriers => {
12847 if barriers__.is_some() {
12848 return Err(serde::de::Error::duplicate_field("barriers"));
12849 }
12850 barriers__ = Some(map_.next_value()?);
12851 }
12852 }
12853 }
12854 Ok(stream_message_batch::BarrierBatch {
12855 barriers: barriers__.unwrap_or_default(),
12856 })
12857 }
12858 }
12859 deserializer.deserialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", FIELDS, GeneratedVisitor)
12860 }
12861}
12862impl serde::Serialize for StreamNode {
12863 #[allow(deprecated)]
12864 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12865 where
12866 S: serde::Serializer,
12867 {
12868 use serde::ser::SerializeStruct;
12869 let mut len = 0;
12870 if self.operator_id != 0 {
12871 len += 1;
12872 }
12873 if !self.input.is_empty() {
12874 len += 1;
12875 }
12876 if !self.stream_key.is_empty() {
12877 len += 1;
12878 }
12879 if self.stream_kind != 0 {
12880 len += 1;
12881 }
12882 if !self.identity.is_empty() {
12883 len += 1;
12884 }
12885 if !self.fields.is_empty() {
12886 len += 1;
12887 }
12888 if self.node_body.is_some() {
12889 len += 1;
12890 }
12891 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamNode", len)?;
12892 if self.operator_id != 0 {
12893 #[allow(clippy::needless_borrow)]
12894 #[allow(clippy::needless_borrows_for_generic_args)]
12895 struct_ser.serialize_field("operatorId", ToString::to_string(&self.operator_id).as_str())?;
12896 }
12897 if !self.input.is_empty() {
12898 struct_ser.serialize_field("input", &self.input)?;
12899 }
12900 if !self.stream_key.is_empty() {
12901 struct_ser.serialize_field("streamKey", &self.stream_key)?;
12902 }
12903 if self.stream_kind != 0 {
12904 let v = stream_node::StreamKind::try_from(self.stream_kind)
12905 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_kind)))?;
12906 struct_ser.serialize_field("streamKind", &v)?;
12907 }
12908 if !self.identity.is_empty() {
12909 struct_ser.serialize_field("identity", &self.identity)?;
12910 }
12911 if !self.fields.is_empty() {
12912 struct_ser.serialize_field("fields", &self.fields)?;
12913 }
12914 if let Some(v) = self.node_body.as_ref() {
12915 match v {
12916 stream_node::NodeBody::Source(v) => {
12917 struct_ser.serialize_field("source", v)?;
12918 }
12919 stream_node::NodeBody::Project(v) => {
12920 struct_ser.serialize_field("project", v)?;
12921 }
12922 stream_node::NodeBody::Filter(v) => {
12923 struct_ser.serialize_field("filter", v)?;
12924 }
12925 stream_node::NodeBody::Materialize(v) => {
12926 struct_ser.serialize_field("materialize", v)?;
12927 }
12928 stream_node::NodeBody::StatelessSimpleAgg(v) => {
12929 struct_ser.serialize_field("statelessSimpleAgg", v)?;
12930 }
12931 stream_node::NodeBody::SimpleAgg(v) => {
12932 struct_ser.serialize_field("simpleAgg", v)?;
12933 }
12934 stream_node::NodeBody::HashAgg(v) => {
12935 struct_ser.serialize_field("hashAgg", v)?;
12936 }
12937 stream_node::NodeBody::AppendOnlyTopN(v) => {
12938 struct_ser.serialize_field("appendOnlyTopN", v)?;
12939 }
12940 stream_node::NodeBody::HashJoin(v) => {
12941 struct_ser.serialize_field("hashJoin", v)?;
12942 }
12943 stream_node::NodeBody::TopN(v) => {
12944 struct_ser.serialize_field("topN", v)?;
12945 }
12946 stream_node::NodeBody::HopWindow(v) => {
12947 struct_ser.serialize_field("hopWindow", v)?;
12948 }
12949 stream_node::NodeBody::Merge(v) => {
12950 struct_ser.serialize_field("merge", v)?;
12951 }
12952 stream_node::NodeBody::Exchange(v) => {
12953 struct_ser.serialize_field("exchange", v)?;
12954 }
12955 stream_node::NodeBody::StreamScan(v) => {
12956 struct_ser.serialize_field("streamScan", v)?;
12957 }
12958 stream_node::NodeBody::BatchPlan(v) => {
12959 struct_ser.serialize_field("batchPlan", v)?;
12960 }
12961 stream_node::NodeBody::Lookup(v) => {
12962 struct_ser.serialize_field("lookup", v)?;
12963 }
12964 stream_node::NodeBody::Arrange(v) => {
12965 struct_ser.serialize_field("arrange", v)?;
12966 }
12967 stream_node::NodeBody::LookupUnion(v) => {
12968 struct_ser.serialize_field("lookupUnion", v)?;
12969 }
12970 stream_node::NodeBody::Union(v) => {
12971 struct_ser.serialize_field("union", v)?;
12972 }
12973 stream_node::NodeBody::DeltaIndexJoin(v) => {
12974 struct_ser.serialize_field("deltaIndexJoin", v)?;
12975 }
12976 stream_node::NodeBody::Sink(v) => {
12977 struct_ser.serialize_field("sink", v)?;
12978 }
12979 stream_node::NodeBody::Expand(v) => {
12980 struct_ser.serialize_field("expand", v)?;
12981 }
12982 stream_node::NodeBody::DynamicFilter(v) => {
12983 struct_ser.serialize_field("dynamicFilter", v)?;
12984 }
12985 stream_node::NodeBody::ProjectSet(v) => {
12986 struct_ser.serialize_field("projectSet", v)?;
12987 }
12988 stream_node::NodeBody::GroupTopN(v) => {
12989 struct_ser.serialize_field("groupTopN", v)?;
12990 }
12991 stream_node::NodeBody::Sort(v) => {
12992 struct_ser.serialize_field("sort", v)?;
12993 }
12994 stream_node::NodeBody::WatermarkFilter(v) => {
12995 struct_ser.serialize_field("watermarkFilter", v)?;
12996 }
12997 stream_node::NodeBody::Dml(v) => {
12998 struct_ser.serialize_field("dml", v)?;
12999 }
13000 stream_node::NodeBody::RowIdGen(v) => {
13001 struct_ser.serialize_field("rowIdGen", v)?;
13002 }
13003 stream_node::NodeBody::Now(v) => {
13004 struct_ser.serialize_field("now", v)?;
13005 }
13006 stream_node::NodeBody::AppendOnlyGroupTopN(v) => {
13007 struct_ser.serialize_field("appendOnlyGroupTopN", v)?;
13008 }
13009 stream_node::NodeBody::TemporalJoin(v) => {
13010 struct_ser.serialize_field("temporalJoin", v)?;
13011 }
13012 stream_node::NodeBody::BarrierRecv(v) => {
13013 struct_ser.serialize_field("barrierRecv", v)?;
13014 }
13015 stream_node::NodeBody::Values(v) => {
13016 struct_ser.serialize_field("values", v)?;
13017 }
13018 stream_node::NodeBody::AppendOnlyDedup(v) => {
13019 struct_ser.serialize_field("appendOnlyDedup", v)?;
13020 }
13021 stream_node::NodeBody::NoOp(v) => {
13022 struct_ser.serialize_field("noOp", v)?;
13023 }
13024 stream_node::NodeBody::EowcOverWindow(v) => {
13025 struct_ser.serialize_field("eowcOverWindow", v)?;
13026 }
13027 stream_node::NodeBody::OverWindow(v) => {
13028 struct_ser.serialize_field("overWindow", v)?;
13029 }
13030 stream_node::NodeBody::StreamFsFetch(v) => {
13031 struct_ser.serialize_field("streamFsFetch", v)?;
13032 }
13033 stream_node::NodeBody::StreamCdcScan(v) => {
13034 struct_ser.serialize_field("streamCdcScan", v)?;
13035 }
13036 stream_node::NodeBody::CdcFilter(v) => {
13037 struct_ser.serialize_field("cdcFilter", v)?;
13038 }
13039 stream_node::NodeBody::SourceBackfill(v) => {
13040 struct_ser.serialize_field("sourceBackfill", v)?;
13041 }
13042 stream_node::NodeBody::Changelog(v) => {
13043 struct_ser.serialize_field("changelog", v)?;
13044 }
13045 stream_node::NodeBody::LocalApproxPercentile(v) => {
13046 struct_ser.serialize_field("localApproxPercentile", v)?;
13047 }
13048 stream_node::NodeBody::GlobalApproxPercentile(v) => {
13049 struct_ser.serialize_field("globalApproxPercentile", v)?;
13050 }
13051 stream_node::NodeBody::RowMerge(v) => {
13052 struct_ser.serialize_field("rowMerge", v)?;
13053 }
13054 stream_node::NodeBody::AsOfJoin(v) => {
13055 struct_ser.serialize_field("asOfJoin", v)?;
13056 }
13057 stream_node::NodeBody::SyncLogStore(v) => {
13058 struct_ser.serialize_field("syncLogStore", v)?;
13059 }
13060 stream_node::NodeBody::MaterializedExprs(v) => {
13061 struct_ser.serialize_field("materializedExprs", v)?;
13062 }
13063 stream_node::NodeBody::VectorIndexWrite(v) => {
13064 struct_ser.serialize_field("vectorIndexWrite", v)?;
13065 }
13066 stream_node::NodeBody::UpstreamSinkUnion(v) => {
13067 struct_ser.serialize_field("upstreamSinkUnion", v)?;
13068 }
13069 stream_node::NodeBody::LocalityProvider(v) => {
13070 struct_ser.serialize_field("localityProvider", v)?;
13071 }
13072 stream_node::NodeBody::EowcGapFill(v) => {
13073 struct_ser.serialize_field("eowcGapFill", v)?;
13074 }
13075 stream_node::NodeBody::GapFill(v) => {
13076 struct_ser.serialize_field("gapFill", v)?;
13077 }
13078 stream_node::NodeBody::VectorIndexLookupJoin(v) => {
13079 struct_ser.serialize_field("vectorIndexLookupJoin", v)?;
13080 }
13081 }
13082 }
13083 struct_ser.end()
13084 }
13085}
13086impl<'de> serde::Deserialize<'de> for StreamNode {
13087 #[allow(deprecated)]
13088 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13089 where
13090 D: serde::Deserializer<'de>,
13091 {
13092 const FIELDS: &[&str] = &[
13093 "operator_id",
13094 "operatorId",
13095 "input",
13096 "stream_key",
13097 "streamKey",
13098 "stream_kind",
13099 "streamKind",
13100 "identity",
13101 "fields",
13102 "source",
13103 "project",
13104 "filter",
13105 "materialize",
13106 "stateless_simple_agg",
13107 "statelessSimpleAgg",
13108 "simple_agg",
13109 "simpleAgg",
13110 "hash_agg",
13111 "hashAgg",
13112 "append_only_top_n",
13113 "appendOnlyTopN",
13114 "hash_join",
13115 "hashJoin",
13116 "top_n",
13117 "topN",
13118 "hop_window",
13119 "hopWindow",
13120 "merge",
13121 "exchange",
13122 "stream_scan",
13123 "streamScan",
13124 "batch_plan",
13125 "batchPlan",
13126 "lookup",
13127 "arrange",
13128 "lookup_union",
13129 "lookupUnion",
13130 "union",
13131 "delta_index_join",
13132 "deltaIndexJoin",
13133 "sink",
13134 "expand",
13135 "dynamic_filter",
13136 "dynamicFilter",
13137 "project_set",
13138 "projectSet",
13139 "group_top_n",
13140 "groupTopN",
13141 "sort",
13142 "watermark_filter",
13143 "watermarkFilter",
13144 "dml",
13145 "row_id_gen",
13146 "rowIdGen",
13147 "now",
13148 "append_only_group_top_n",
13149 "appendOnlyGroupTopN",
13150 "temporal_join",
13151 "temporalJoin",
13152 "barrier_recv",
13153 "barrierRecv",
13154 "values",
13155 "append_only_dedup",
13156 "appendOnlyDedup",
13157 "no_op",
13158 "noOp",
13159 "eowc_over_window",
13160 "eowcOverWindow",
13161 "over_window",
13162 "overWindow",
13163 "stream_fs_fetch",
13164 "streamFsFetch",
13165 "stream_cdc_scan",
13166 "streamCdcScan",
13167 "cdc_filter",
13168 "cdcFilter",
13169 "source_backfill",
13170 "sourceBackfill",
13171 "changelog",
13172 "local_approx_percentile",
13173 "localApproxPercentile",
13174 "global_approx_percentile",
13175 "globalApproxPercentile",
13176 "row_merge",
13177 "rowMerge",
13178 "as_of_join",
13179 "asOfJoin",
13180 "sync_log_store",
13181 "syncLogStore",
13182 "materialized_exprs",
13183 "materializedExprs",
13184 "vector_index_write",
13185 "vectorIndexWrite",
13186 "upstream_sink_union",
13187 "upstreamSinkUnion",
13188 "locality_provider",
13189 "localityProvider",
13190 "eowc_gap_fill",
13191 "eowcGapFill",
13192 "gap_fill",
13193 "gapFill",
13194 "vector_index_lookup_join",
13195 "vectorIndexLookupJoin",
13196 ];
13197
13198 #[allow(clippy::enum_variant_names)]
13199 enum GeneratedField {
13200 OperatorId,
13201 Input,
13202 StreamKey,
13203 StreamKind,
13204 Identity,
13205 Fields,
13206 Source,
13207 Project,
13208 Filter,
13209 Materialize,
13210 StatelessSimpleAgg,
13211 SimpleAgg,
13212 HashAgg,
13213 AppendOnlyTopN,
13214 HashJoin,
13215 TopN,
13216 HopWindow,
13217 Merge,
13218 Exchange,
13219 StreamScan,
13220 BatchPlan,
13221 Lookup,
13222 Arrange,
13223 LookupUnion,
13224 Union,
13225 DeltaIndexJoin,
13226 Sink,
13227 Expand,
13228 DynamicFilter,
13229 ProjectSet,
13230 GroupTopN,
13231 Sort,
13232 WatermarkFilter,
13233 Dml,
13234 RowIdGen,
13235 Now,
13236 AppendOnlyGroupTopN,
13237 TemporalJoin,
13238 BarrierRecv,
13239 Values,
13240 AppendOnlyDedup,
13241 NoOp,
13242 EowcOverWindow,
13243 OverWindow,
13244 StreamFsFetch,
13245 StreamCdcScan,
13246 CdcFilter,
13247 SourceBackfill,
13248 Changelog,
13249 LocalApproxPercentile,
13250 GlobalApproxPercentile,
13251 RowMerge,
13252 AsOfJoin,
13253 SyncLogStore,
13254 MaterializedExprs,
13255 VectorIndexWrite,
13256 UpstreamSinkUnion,
13257 LocalityProvider,
13258 EowcGapFill,
13259 GapFill,
13260 VectorIndexLookupJoin,
13261 }
13262 impl<'de> serde::Deserialize<'de> for GeneratedField {
13263 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13264 where
13265 D: serde::Deserializer<'de>,
13266 {
13267 struct GeneratedVisitor;
13268
13269 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13270 type Value = GeneratedField;
13271
13272 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13273 write!(formatter, "expected one of: {:?}", &FIELDS)
13274 }
13275
13276 #[allow(unused_variables)]
13277 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13278 where
13279 E: serde::de::Error,
13280 {
13281 match value {
13282 "operatorId" | "operator_id" => Ok(GeneratedField::OperatorId),
13283 "input" => Ok(GeneratedField::Input),
13284 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
13285 "streamKind" | "stream_kind" => Ok(GeneratedField::StreamKind),
13286 "identity" => Ok(GeneratedField::Identity),
13287 "fields" => Ok(GeneratedField::Fields),
13288 "source" => Ok(GeneratedField::Source),
13289 "project" => Ok(GeneratedField::Project),
13290 "filter" => Ok(GeneratedField::Filter),
13291 "materialize" => Ok(GeneratedField::Materialize),
13292 "statelessSimpleAgg" | "stateless_simple_agg" => Ok(GeneratedField::StatelessSimpleAgg),
13293 "simpleAgg" | "simple_agg" => Ok(GeneratedField::SimpleAgg),
13294 "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
13295 "appendOnlyTopN" | "append_only_top_n" => Ok(GeneratedField::AppendOnlyTopN),
13296 "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
13297 "topN" | "top_n" => Ok(GeneratedField::TopN),
13298 "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
13299 "merge" => Ok(GeneratedField::Merge),
13300 "exchange" => Ok(GeneratedField::Exchange),
13301 "streamScan" | "stream_scan" => Ok(GeneratedField::StreamScan),
13302 "batchPlan" | "batch_plan" => Ok(GeneratedField::BatchPlan),
13303 "lookup" => Ok(GeneratedField::Lookup),
13304 "arrange" => Ok(GeneratedField::Arrange),
13305 "lookupUnion" | "lookup_union" => Ok(GeneratedField::LookupUnion),
13306 "union" => Ok(GeneratedField::Union),
13307 "deltaIndexJoin" | "delta_index_join" => Ok(GeneratedField::DeltaIndexJoin),
13308 "sink" => Ok(GeneratedField::Sink),
13309 "expand" => Ok(GeneratedField::Expand),
13310 "dynamicFilter" | "dynamic_filter" => Ok(GeneratedField::DynamicFilter),
13311 "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
13312 "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
13313 "sort" => Ok(GeneratedField::Sort),
13314 "watermarkFilter" | "watermark_filter" => Ok(GeneratedField::WatermarkFilter),
13315 "dml" => Ok(GeneratedField::Dml),
13316 "rowIdGen" | "row_id_gen" => Ok(GeneratedField::RowIdGen),
13317 "now" => Ok(GeneratedField::Now),
13318 "appendOnlyGroupTopN" | "append_only_group_top_n" => Ok(GeneratedField::AppendOnlyGroupTopN),
13319 "temporalJoin" | "temporal_join" => Ok(GeneratedField::TemporalJoin),
13320 "barrierRecv" | "barrier_recv" => Ok(GeneratedField::BarrierRecv),
13321 "values" => Ok(GeneratedField::Values),
13322 "appendOnlyDedup" | "append_only_dedup" => Ok(GeneratedField::AppendOnlyDedup),
13323 "noOp" | "no_op" => Ok(GeneratedField::NoOp),
13324 "eowcOverWindow" | "eowc_over_window" => Ok(GeneratedField::EowcOverWindow),
13325 "overWindow" | "over_window" => Ok(GeneratedField::OverWindow),
13326 "streamFsFetch" | "stream_fs_fetch" => Ok(GeneratedField::StreamFsFetch),
13327 "streamCdcScan" | "stream_cdc_scan" => Ok(GeneratedField::StreamCdcScan),
13328 "cdcFilter" | "cdc_filter" => Ok(GeneratedField::CdcFilter),
13329 "sourceBackfill" | "source_backfill" => Ok(GeneratedField::SourceBackfill),
13330 "changelog" => Ok(GeneratedField::Changelog),
13331 "localApproxPercentile" | "local_approx_percentile" => Ok(GeneratedField::LocalApproxPercentile),
13332 "globalApproxPercentile" | "global_approx_percentile" => Ok(GeneratedField::GlobalApproxPercentile),
13333 "rowMerge" | "row_merge" => Ok(GeneratedField::RowMerge),
13334 "asOfJoin" | "as_of_join" => Ok(GeneratedField::AsOfJoin),
13335 "syncLogStore" | "sync_log_store" => Ok(GeneratedField::SyncLogStore),
13336 "materializedExprs" | "materialized_exprs" => Ok(GeneratedField::MaterializedExprs),
13337 "vectorIndexWrite" | "vector_index_write" => Ok(GeneratedField::VectorIndexWrite),
13338 "upstreamSinkUnion" | "upstream_sink_union" => Ok(GeneratedField::UpstreamSinkUnion),
13339 "localityProvider" | "locality_provider" => Ok(GeneratedField::LocalityProvider),
13340 "eowcGapFill" | "eowc_gap_fill" => Ok(GeneratedField::EowcGapFill),
13341 "gapFill" | "gap_fill" => Ok(GeneratedField::GapFill),
13342 "vectorIndexLookupJoin" | "vector_index_lookup_join" => Ok(GeneratedField::VectorIndexLookupJoin),
13343 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13344 }
13345 }
13346 }
13347 deserializer.deserialize_identifier(GeneratedVisitor)
13348 }
13349 }
13350 struct GeneratedVisitor;
13351 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13352 type Value = StreamNode;
13353
13354 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13355 formatter.write_str("struct stream_plan.StreamNode")
13356 }
13357
13358 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamNode, V::Error>
13359 where
13360 V: serde::de::MapAccess<'de>,
13361 {
13362 let mut operator_id__ = None;
13363 let mut input__ = None;
13364 let mut stream_key__ = None;
13365 let mut stream_kind__ = None;
13366 let mut identity__ = None;
13367 let mut fields__ = None;
13368 let mut node_body__ = None;
13369 while let Some(k) = map_.next_key()? {
13370 match k {
13371 GeneratedField::OperatorId => {
13372 if operator_id__.is_some() {
13373 return Err(serde::de::Error::duplicate_field("operatorId"));
13374 }
13375 operator_id__ =
13376 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13377 ;
13378 }
13379 GeneratedField::Input => {
13380 if input__.is_some() {
13381 return Err(serde::de::Error::duplicate_field("input"));
13382 }
13383 input__ = Some(map_.next_value()?);
13384 }
13385 GeneratedField::StreamKey => {
13386 if stream_key__.is_some() {
13387 return Err(serde::de::Error::duplicate_field("streamKey"));
13388 }
13389 stream_key__ =
13390 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13391 .into_iter().map(|x| x.0).collect())
13392 ;
13393 }
13394 GeneratedField::StreamKind => {
13395 if stream_kind__.is_some() {
13396 return Err(serde::de::Error::duplicate_field("streamKind"));
13397 }
13398 stream_kind__ = Some(map_.next_value::<stream_node::StreamKind>()? as i32);
13399 }
13400 GeneratedField::Identity => {
13401 if identity__.is_some() {
13402 return Err(serde::de::Error::duplicate_field("identity"));
13403 }
13404 identity__ = Some(map_.next_value()?);
13405 }
13406 GeneratedField::Fields => {
13407 if fields__.is_some() {
13408 return Err(serde::de::Error::duplicate_field("fields"));
13409 }
13410 fields__ = Some(map_.next_value()?);
13411 }
13412 GeneratedField::Source => {
13413 if node_body__.is_some() {
13414 return Err(serde::de::Error::duplicate_field("source"));
13415 }
13416 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Source)
13417;
13418 }
13419 GeneratedField::Project => {
13420 if node_body__.is_some() {
13421 return Err(serde::de::Error::duplicate_field("project"));
13422 }
13423 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Project)
13424;
13425 }
13426 GeneratedField::Filter => {
13427 if node_body__.is_some() {
13428 return Err(serde::de::Error::duplicate_field("filter"));
13429 }
13430 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Filter)
13431;
13432 }
13433 GeneratedField::Materialize => {
13434 if node_body__.is_some() {
13435 return Err(serde::de::Error::duplicate_field("materialize"));
13436 }
13437 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Materialize)
13438;
13439 }
13440 GeneratedField::StatelessSimpleAgg => {
13441 if node_body__.is_some() {
13442 return Err(serde::de::Error::duplicate_field("statelessSimpleAgg"));
13443 }
13444 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StatelessSimpleAgg)
13445;
13446 }
13447 GeneratedField::SimpleAgg => {
13448 if node_body__.is_some() {
13449 return Err(serde::de::Error::duplicate_field("simpleAgg"));
13450 }
13451 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SimpleAgg)
13452;
13453 }
13454 GeneratedField::HashAgg => {
13455 if node_body__.is_some() {
13456 return Err(serde::de::Error::duplicate_field("hashAgg"));
13457 }
13458 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashAgg)
13459;
13460 }
13461 GeneratedField::AppendOnlyTopN => {
13462 if node_body__.is_some() {
13463 return Err(serde::de::Error::duplicate_field("appendOnlyTopN"));
13464 }
13465 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyTopN)
13466;
13467 }
13468 GeneratedField::HashJoin => {
13469 if node_body__.is_some() {
13470 return Err(serde::de::Error::duplicate_field("hashJoin"));
13471 }
13472 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashJoin)
13473;
13474 }
13475 GeneratedField::TopN => {
13476 if node_body__.is_some() {
13477 return Err(serde::de::Error::duplicate_field("topN"));
13478 }
13479 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TopN)
13480;
13481 }
13482 GeneratedField::HopWindow => {
13483 if node_body__.is_some() {
13484 return Err(serde::de::Error::duplicate_field("hopWindow"));
13485 }
13486 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HopWindow)
13487;
13488 }
13489 GeneratedField::Merge => {
13490 if node_body__.is_some() {
13491 return Err(serde::de::Error::duplicate_field("merge"));
13492 }
13493 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Merge)
13494;
13495 }
13496 GeneratedField::Exchange => {
13497 if node_body__.is_some() {
13498 return Err(serde::de::Error::duplicate_field("exchange"));
13499 }
13500 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Exchange)
13501;
13502 }
13503 GeneratedField::StreamScan => {
13504 if node_body__.is_some() {
13505 return Err(serde::de::Error::duplicate_field("streamScan"));
13506 }
13507 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamScan)
13508;
13509 }
13510 GeneratedField::BatchPlan => {
13511 if node_body__.is_some() {
13512 return Err(serde::de::Error::duplicate_field("batchPlan"));
13513 }
13514 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BatchPlan)
13515;
13516 }
13517 GeneratedField::Lookup => {
13518 if node_body__.is_some() {
13519 return Err(serde::de::Error::duplicate_field("lookup"));
13520 }
13521 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Lookup)
13522;
13523 }
13524 GeneratedField::Arrange => {
13525 if node_body__.is_some() {
13526 return Err(serde::de::Error::duplicate_field("arrange"));
13527 }
13528 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Arrange)
13529;
13530 }
13531 GeneratedField::LookupUnion => {
13532 if node_body__.is_some() {
13533 return Err(serde::de::Error::duplicate_field("lookupUnion"));
13534 }
13535 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LookupUnion)
13536;
13537 }
13538 GeneratedField::Union => {
13539 if node_body__.is_some() {
13540 return Err(serde::de::Error::duplicate_field("union"));
13541 }
13542 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Union)
13543;
13544 }
13545 GeneratedField::DeltaIndexJoin => {
13546 if node_body__.is_some() {
13547 return Err(serde::de::Error::duplicate_field("deltaIndexJoin"));
13548 }
13549 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DeltaIndexJoin)
13550;
13551 }
13552 GeneratedField::Sink => {
13553 if node_body__.is_some() {
13554 return Err(serde::de::Error::duplicate_field("sink"));
13555 }
13556 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sink)
13557;
13558 }
13559 GeneratedField::Expand => {
13560 if node_body__.is_some() {
13561 return Err(serde::de::Error::duplicate_field("expand"));
13562 }
13563 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Expand)
13564;
13565 }
13566 GeneratedField::DynamicFilter => {
13567 if node_body__.is_some() {
13568 return Err(serde::de::Error::duplicate_field("dynamicFilter"));
13569 }
13570 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DynamicFilter)
13571;
13572 }
13573 GeneratedField::ProjectSet => {
13574 if node_body__.is_some() {
13575 return Err(serde::de::Error::duplicate_field("projectSet"));
13576 }
13577 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::ProjectSet)
13578;
13579 }
13580 GeneratedField::GroupTopN => {
13581 if node_body__.is_some() {
13582 return Err(serde::de::Error::duplicate_field("groupTopN"));
13583 }
13584 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GroupTopN)
13585;
13586 }
13587 GeneratedField::Sort => {
13588 if node_body__.is_some() {
13589 return Err(serde::de::Error::duplicate_field("sort"));
13590 }
13591 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sort)
13592;
13593 }
13594 GeneratedField::WatermarkFilter => {
13595 if node_body__.is_some() {
13596 return Err(serde::de::Error::duplicate_field("watermarkFilter"));
13597 }
13598 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::WatermarkFilter)
13599;
13600 }
13601 GeneratedField::Dml => {
13602 if node_body__.is_some() {
13603 return Err(serde::de::Error::duplicate_field("dml"));
13604 }
13605 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Dml)
13606;
13607 }
13608 GeneratedField::RowIdGen => {
13609 if node_body__.is_some() {
13610 return Err(serde::de::Error::duplicate_field("rowIdGen"));
13611 }
13612 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowIdGen)
13613;
13614 }
13615 GeneratedField::Now => {
13616 if node_body__.is_some() {
13617 return Err(serde::de::Error::duplicate_field("now"));
13618 }
13619 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Now)
13620;
13621 }
13622 GeneratedField::AppendOnlyGroupTopN => {
13623 if node_body__.is_some() {
13624 return Err(serde::de::Error::duplicate_field("appendOnlyGroupTopN"));
13625 }
13626 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyGroupTopN)
13627;
13628 }
13629 GeneratedField::TemporalJoin => {
13630 if node_body__.is_some() {
13631 return Err(serde::de::Error::duplicate_field("temporalJoin"));
13632 }
13633 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TemporalJoin)
13634;
13635 }
13636 GeneratedField::BarrierRecv => {
13637 if node_body__.is_some() {
13638 return Err(serde::de::Error::duplicate_field("barrierRecv"));
13639 }
13640 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BarrierRecv)
13641;
13642 }
13643 GeneratedField::Values => {
13644 if node_body__.is_some() {
13645 return Err(serde::de::Error::duplicate_field("values"));
13646 }
13647 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Values)
13648;
13649 }
13650 GeneratedField::AppendOnlyDedup => {
13651 if node_body__.is_some() {
13652 return Err(serde::de::Error::duplicate_field("appendOnlyDedup"));
13653 }
13654 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyDedup)
13655;
13656 }
13657 GeneratedField::NoOp => {
13658 if node_body__.is_some() {
13659 return Err(serde::de::Error::duplicate_field("noOp"));
13660 }
13661 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::NoOp)
13662;
13663 }
13664 GeneratedField::EowcOverWindow => {
13665 if node_body__.is_some() {
13666 return Err(serde::de::Error::duplicate_field("eowcOverWindow"));
13667 }
13668 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcOverWindow)
13669;
13670 }
13671 GeneratedField::OverWindow => {
13672 if node_body__.is_some() {
13673 return Err(serde::de::Error::duplicate_field("overWindow"));
13674 }
13675 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::OverWindow)
13676;
13677 }
13678 GeneratedField::StreamFsFetch => {
13679 if node_body__.is_some() {
13680 return Err(serde::de::Error::duplicate_field("streamFsFetch"));
13681 }
13682 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamFsFetch)
13683;
13684 }
13685 GeneratedField::StreamCdcScan => {
13686 if node_body__.is_some() {
13687 return Err(serde::de::Error::duplicate_field("streamCdcScan"));
13688 }
13689 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamCdcScan)
13690;
13691 }
13692 GeneratedField::CdcFilter => {
13693 if node_body__.is_some() {
13694 return Err(serde::de::Error::duplicate_field("cdcFilter"));
13695 }
13696 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CdcFilter)
13697;
13698 }
13699 GeneratedField::SourceBackfill => {
13700 if node_body__.is_some() {
13701 return Err(serde::de::Error::duplicate_field("sourceBackfill"));
13702 }
13703 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SourceBackfill)
13704;
13705 }
13706 GeneratedField::Changelog => {
13707 if node_body__.is_some() {
13708 return Err(serde::de::Error::duplicate_field("changelog"));
13709 }
13710 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Changelog)
13711;
13712 }
13713 GeneratedField::LocalApproxPercentile => {
13714 if node_body__.is_some() {
13715 return Err(serde::de::Error::duplicate_field("localApproxPercentile"));
13716 }
13717 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalApproxPercentile)
13718;
13719 }
13720 GeneratedField::GlobalApproxPercentile => {
13721 if node_body__.is_some() {
13722 return Err(serde::de::Error::duplicate_field("globalApproxPercentile"));
13723 }
13724 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GlobalApproxPercentile)
13725;
13726 }
13727 GeneratedField::RowMerge => {
13728 if node_body__.is_some() {
13729 return Err(serde::de::Error::duplicate_field("rowMerge"));
13730 }
13731 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowMerge)
13732;
13733 }
13734 GeneratedField::AsOfJoin => {
13735 if node_body__.is_some() {
13736 return Err(serde::de::Error::duplicate_field("asOfJoin"));
13737 }
13738 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AsOfJoin)
13739;
13740 }
13741 GeneratedField::SyncLogStore => {
13742 if node_body__.is_some() {
13743 return Err(serde::de::Error::duplicate_field("syncLogStore"));
13744 }
13745 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SyncLogStore)
13746;
13747 }
13748 GeneratedField::MaterializedExprs => {
13749 if node_body__.is_some() {
13750 return Err(serde::de::Error::duplicate_field("materializedExprs"));
13751 }
13752 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MaterializedExprs)
13753;
13754 }
13755 GeneratedField::VectorIndexWrite => {
13756 if node_body__.is_some() {
13757 return Err(serde::de::Error::duplicate_field("vectorIndexWrite"));
13758 }
13759 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexWrite)
13760;
13761 }
13762 GeneratedField::UpstreamSinkUnion => {
13763 if node_body__.is_some() {
13764 return Err(serde::de::Error::duplicate_field("upstreamSinkUnion"));
13765 }
13766 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::UpstreamSinkUnion)
13767;
13768 }
13769 GeneratedField::LocalityProvider => {
13770 if node_body__.is_some() {
13771 return Err(serde::de::Error::duplicate_field("localityProvider"));
13772 }
13773 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalityProvider)
13774;
13775 }
13776 GeneratedField::EowcGapFill => {
13777 if node_body__.is_some() {
13778 return Err(serde::de::Error::duplicate_field("eowcGapFill"));
13779 }
13780 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcGapFill)
13781;
13782 }
13783 GeneratedField::GapFill => {
13784 if node_body__.is_some() {
13785 return Err(serde::de::Error::duplicate_field("gapFill"));
13786 }
13787 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GapFill)
13788;
13789 }
13790 GeneratedField::VectorIndexLookupJoin => {
13791 if node_body__.is_some() {
13792 return Err(serde::de::Error::duplicate_field("vectorIndexLookupJoin"));
13793 }
13794 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexLookupJoin)
13795;
13796 }
13797 }
13798 }
13799 Ok(StreamNode {
13800 operator_id: operator_id__.unwrap_or_default(),
13801 input: input__.unwrap_or_default(),
13802 stream_key: stream_key__.unwrap_or_default(),
13803 stream_kind: stream_kind__.unwrap_or_default(),
13804 identity: identity__.unwrap_or_default(),
13805 fields: fields__.unwrap_or_default(),
13806 node_body: node_body__,
13807 })
13808 }
13809 }
13810 deserializer.deserialize_struct("stream_plan.StreamNode", FIELDS, GeneratedVisitor)
13811 }
13812}
13813impl serde::Serialize for stream_node::StreamKind {
13814 #[allow(deprecated)]
13815 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13816 where
13817 S: serde::Serializer,
13818 {
13819 let variant = match self {
13820 Self::Retract => "STREAM_KIND_RETRACT",
13821 Self::AppendOnly => "STREAM_KIND_APPEND_ONLY",
13822 Self::Upsert => "STREAM_KIND_UPSERT",
13823 };
13824 serializer.serialize_str(variant)
13825 }
13826}
13827impl<'de> serde::Deserialize<'de> for stream_node::StreamKind {
13828 #[allow(deprecated)]
13829 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13830 where
13831 D: serde::Deserializer<'de>,
13832 {
13833 const FIELDS: &[&str] = &[
13834 "STREAM_KIND_RETRACT",
13835 "STREAM_KIND_APPEND_ONLY",
13836 "STREAM_KIND_UPSERT",
13837 ];
13838
13839 struct GeneratedVisitor;
13840
13841 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13842 type Value = stream_node::StreamKind;
13843
13844 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13845 write!(formatter, "expected one of: {:?}", &FIELDS)
13846 }
13847
13848 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13849 where
13850 E: serde::de::Error,
13851 {
13852 i32::try_from(v)
13853 .ok()
13854 .and_then(|x| x.try_into().ok())
13855 .ok_or_else(|| {
13856 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13857 })
13858 }
13859
13860 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13861 where
13862 E: serde::de::Error,
13863 {
13864 i32::try_from(v)
13865 .ok()
13866 .and_then(|x| x.try_into().ok())
13867 .ok_or_else(|| {
13868 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13869 })
13870 }
13871
13872 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13873 where
13874 E: serde::de::Error,
13875 {
13876 match value {
13877 "STREAM_KIND_RETRACT" => Ok(stream_node::StreamKind::Retract),
13878 "STREAM_KIND_APPEND_ONLY" => Ok(stream_node::StreamKind::AppendOnly),
13879 "STREAM_KIND_UPSERT" => Ok(stream_node::StreamKind::Upsert),
13880 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13881 }
13882 }
13883 }
13884 deserializer.deserialize_any(GeneratedVisitor)
13885 }
13886}
13887impl serde::Serialize for StreamScanNode {
13888 #[allow(deprecated)]
13889 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13890 where
13891 S: serde::Serializer,
13892 {
13893 use serde::ser::SerializeStruct;
13894 let mut len = 0;
13895 if self.table_id != 0 {
13896 len += 1;
13897 }
13898 if !self.upstream_column_ids.is_empty() {
13899 len += 1;
13900 }
13901 if !self.output_indices.is_empty() {
13902 len += 1;
13903 }
13904 if self.stream_scan_type != 0 {
13905 len += 1;
13906 }
13907 if self.state_table.is_some() {
13908 len += 1;
13909 }
13910 if self.table_desc.is_some() {
13911 len += 1;
13912 }
13913 if self.rate_limit.is_some() {
13914 len += 1;
13915 }
13916 if self.snapshot_read_barrier_interval != 0 {
13917 len += 1;
13918 }
13919 if self.arrangement_table.is_some() {
13920 len += 1;
13921 }
13922 if self.snapshot_backfill_epoch.is_some() {
13923 len += 1;
13924 }
13925 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamScanNode", len)?;
13926 if self.table_id != 0 {
13927 struct_ser.serialize_field("tableId", &self.table_id)?;
13928 }
13929 if !self.upstream_column_ids.is_empty() {
13930 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
13931 }
13932 if !self.output_indices.is_empty() {
13933 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
13934 }
13935 if self.stream_scan_type != 0 {
13936 let v = StreamScanType::try_from(self.stream_scan_type)
13937 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_scan_type)))?;
13938 struct_ser.serialize_field("streamScanType", &v)?;
13939 }
13940 if let Some(v) = self.state_table.as_ref() {
13941 struct_ser.serialize_field("stateTable", v)?;
13942 }
13943 if let Some(v) = self.table_desc.as_ref() {
13944 struct_ser.serialize_field("tableDesc", v)?;
13945 }
13946 if let Some(v) = self.rate_limit.as_ref() {
13947 struct_ser.serialize_field("rateLimit", v)?;
13948 }
13949 if self.snapshot_read_barrier_interval != 0 {
13950 struct_ser.serialize_field("snapshotReadBarrierInterval", &self.snapshot_read_barrier_interval)?;
13951 }
13952 if let Some(v) = self.arrangement_table.as_ref() {
13953 struct_ser.serialize_field("arrangementTable", v)?;
13954 }
13955 if let Some(v) = self.snapshot_backfill_epoch.as_ref() {
13956 #[allow(clippy::needless_borrow)]
13957 #[allow(clippy::needless_borrows_for_generic_args)]
13958 struct_ser.serialize_field("snapshotBackfillEpoch", ToString::to_string(&v).as_str())?;
13959 }
13960 struct_ser.end()
13961 }
13962}
13963impl<'de> serde::Deserialize<'de> for StreamScanNode {
13964 #[allow(deprecated)]
13965 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13966 where
13967 D: serde::Deserializer<'de>,
13968 {
13969 const FIELDS: &[&str] = &[
13970 "table_id",
13971 "tableId",
13972 "upstream_column_ids",
13973 "upstreamColumnIds",
13974 "output_indices",
13975 "outputIndices",
13976 "stream_scan_type",
13977 "streamScanType",
13978 "state_table",
13979 "stateTable",
13980 "table_desc",
13981 "tableDesc",
13982 "rate_limit",
13983 "rateLimit",
13984 "snapshot_read_barrier_interval",
13985 "snapshotReadBarrierInterval",
13986 "arrangement_table",
13987 "arrangementTable",
13988 "snapshot_backfill_epoch",
13989 "snapshotBackfillEpoch",
13990 ];
13991
13992 #[allow(clippy::enum_variant_names)]
13993 enum GeneratedField {
13994 TableId,
13995 UpstreamColumnIds,
13996 OutputIndices,
13997 StreamScanType,
13998 StateTable,
13999 TableDesc,
14000 RateLimit,
14001 SnapshotReadBarrierInterval,
14002 ArrangementTable,
14003 SnapshotBackfillEpoch,
14004 }
14005 impl<'de> serde::Deserialize<'de> for GeneratedField {
14006 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14007 where
14008 D: serde::Deserializer<'de>,
14009 {
14010 struct GeneratedVisitor;
14011
14012 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14013 type Value = GeneratedField;
14014
14015 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14016 write!(formatter, "expected one of: {:?}", &FIELDS)
14017 }
14018
14019 #[allow(unused_variables)]
14020 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14021 where
14022 E: serde::de::Error,
14023 {
14024 match value {
14025 "tableId" | "table_id" => Ok(GeneratedField::TableId),
14026 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
14027 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
14028 "streamScanType" | "stream_scan_type" => Ok(GeneratedField::StreamScanType),
14029 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
14030 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
14031 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
14032 "snapshotReadBarrierInterval" | "snapshot_read_barrier_interval" => Ok(GeneratedField::SnapshotReadBarrierInterval),
14033 "arrangementTable" | "arrangement_table" => Ok(GeneratedField::ArrangementTable),
14034 "snapshotBackfillEpoch" | "snapshot_backfill_epoch" => Ok(GeneratedField::SnapshotBackfillEpoch),
14035 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14036 }
14037 }
14038 }
14039 deserializer.deserialize_identifier(GeneratedVisitor)
14040 }
14041 }
14042 struct GeneratedVisitor;
14043 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14044 type Value = StreamScanNode;
14045
14046 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14047 formatter.write_str("struct stream_plan.StreamScanNode")
14048 }
14049
14050 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamScanNode, V::Error>
14051 where
14052 V: serde::de::MapAccess<'de>,
14053 {
14054 let mut table_id__ = None;
14055 let mut upstream_column_ids__ = None;
14056 let mut output_indices__ = None;
14057 let mut stream_scan_type__ = None;
14058 let mut state_table__ = None;
14059 let mut table_desc__ = None;
14060 let mut rate_limit__ = None;
14061 let mut snapshot_read_barrier_interval__ = None;
14062 let mut arrangement_table__ = None;
14063 let mut snapshot_backfill_epoch__ = None;
14064 while let Some(k) = map_.next_key()? {
14065 match k {
14066 GeneratedField::TableId => {
14067 if table_id__.is_some() {
14068 return Err(serde::de::Error::duplicate_field("tableId"));
14069 }
14070 table_id__ =
14071 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14072 ;
14073 }
14074 GeneratedField::UpstreamColumnIds => {
14075 if upstream_column_ids__.is_some() {
14076 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
14077 }
14078 upstream_column_ids__ =
14079 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14080 .into_iter().map(|x| x.0).collect())
14081 ;
14082 }
14083 GeneratedField::OutputIndices => {
14084 if output_indices__.is_some() {
14085 return Err(serde::de::Error::duplicate_field("outputIndices"));
14086 }
14087 output_indices__ =
14088 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14089 .into_iter().map(|x| x.0).collect())
14090 ;
14091 }
14092 GeneratedField::StreamScanType => {
14093 if stream_scan_type__.is_some() {
14094 return Err(serde::de::Error::duplicate_field("streamScanType"));
14095 }
14096 stream_scan_type__ = Some(map_.next_value::<StreamScanType>()? as i32);
14097 }
14098 GeneratedField::StateTable => {
14099 if state_table__.is_some() {
14100 return Err(serde::de::Error::duplicate_field("stateTable"));
14101 }
14102 state_table__ = map_.next_value()?;
14103 }
14104 GeneratedField::TableDesc => {
14105 if table_desc__.is_some() {
14106 return Err(serde::de::Error::duplicate_field("tableDesc"));
14107 }
14108 table_desc__ = map_.next_value()?;
14109 }
14110 GeneratedField::RateLimit => {
14111 if rate_limit__.is_some() {
14112 return Err(serde::de::Error::duplicate_field("rateLimit"));
14113 }
14114 rate_limit__ =
14115 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14116 ;
14117 }
14118 GeneratedField::SnapshotReadBarrierInterval => {
14119 if snapshot_read_barrier_interval__.is_some() {
14120 return Err(serde::de::Error::duplicate_field("snapshotReadBarrierInterval"));
14121 }
14122 snapshot_read_barrier_interval__ =
14123 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14124 ;
14125 }
14126 GeneratedField::ArrangementTable => {
14127 if arrangement_table__.is_some() {
14128 return Err(serde::de::Error::duplicate_field("arrangementTable"));
14129 }
14130 arrangement_table__ = map_.next_value()?;
14131 }
14132 GeneratedField::SnapshotBackfillEpoch => {
14133 if snapshot_backfill_epoch__.is_some() {
14134 return Err(serde::de::Error::duplicate_field("snapshotBackfillEpoch"));
14135 }
14136 snapshot_backfill_epoch__ =
14137 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14138 ;
14139 }
14140 }
14141 }
14142 Ok(StreamScanNode {
14143 table_id: table_id__.unwrap_or_default(),
14144 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
14145 output_indices: output_indices__.unwrap_or_default(),
14146 stream_scan_type: stream_scan_type__.unwrap_or_default(),
14147 state_table: state_table__,
14148 table_desc: table_desc__,
14149 rate_limit: rate_limit__,
14150 snapshot_read_barrier_interval: snapshot_read_barrier_interval__.unwrap_or_default(),
14151 arrangement_table: arrangement_table__,
14152 snapshot_backfill_epoch: snapshot_backfill_epoch__,
14153 })
14154 }
14155 }
14156 deserializer.deserialize_struct("stream_plan.StreamScanNode", FIELDS, GeneratedVisitor)
14157 }
14158}
14159impl serde::Serialize for StreamScanType {
14160 #[allow(deprecated)]
14161 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14162 where
14163 S: serde::Serializer,
14164 {
14165 let variant = match self {
14166 Self::Unspecified => "STREAM_SCAN_TYPE_UNSPECIFIED",
14167 Self::Chain => "STREAM_SCAN_TYPE_CHAIN",
14168 Self::Rearrange => "STREAM_SCAN_TYPE_REARRANGE",
14169 Self::Backfill => "STREAM_SCAN_TYPE_BACKFILL",
14170 Self::UpstreamOnly => "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
14171 Self::ArrangementBackfill => "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
14172 Self::SnapshotBackfill => "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
14173 Self::CrossDbSnapshotBackfill => "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
14174 };
14175 serializer.serialize_str(variant)
14176 }
14177}
14178impl<'de> serde::Deserialize<'de> for StreamScanType {
14179 #[allow(deprecated)]
14180 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14181 where
14182 D: serde::Deserializer<'de>,
14183 {
14184 const FIELDS: &[&str] = &[
14185 "STREAM_SCAN_TYPE_UNSPECIFIED",
14186 "STREAM_SCAN_TYPE_CHAIN",
14187 "STREAM_SCAN_TYPE_REARRANGE",
14188 "STREAM_SCAN_TYPE_BACKFILL",
14189 "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
14190 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
14191 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
14192 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
14193 ];
14194
14195 struct GeneratedVisitor;
14196
14197 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14198 type Value = StreamScanType;
14199
14200 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14201 write!(formatter, "expected one of: {:?}", &FIELDS)
14202 }
14203
14204 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14205 where
14206 E: serde::de::Error,
14207 {
14208 i32::try_from(v)
14209 .ok()
14210 .and_then(|x| x.try_into().ok())
14211 .ok_or_else(|| {
14212 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14213 })
14214 }
14215
14216 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14217 where
14218 E: serde::de::Error,
14219 {
14220 i32::try_from(v)
14221 .ok()
14222 .and_then(|x| x.try_into().ok())
14223 .ok_or_else(|| {
14224 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14225 })
14226 }
14227
14228 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14229 where
14230 E: serde::de::Error,
14231 {
14232 match value {
14233 "STREAM_SCAN_TYPE_UNSPECIFIED" => Ok(StreamScanType::Unspecified),
14234 "STREAM_SCAN_TYPE_CHAIN" => Ok(StreamScanType::Chain),
14235 "STREAM_SCAN_TYPE_REARRANGE" => Ok(StreamScanType::Rearrange),
14236 "STREAM_SCAN_TYPE_BACKFILL" => Ok(StreamScanType::Backfill),
14237 "STREAM_SCAN_TYPE_UPSTREAM_ONLY" => Ok(StreamScanType::UpstreamOnly),
14238 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL" => Ok(StreamScanType::ArrangementBackfill),
14239 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL" => Ok(StreamScanType::SnapshotBackfill),
14240 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL" => Ok(StreamScanType::CrossDbSnapshotBackfill),
14241 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14242 }
14243 }
14244 }
14245 deserializer.deserialize_any(GeneratedVisitor)
14246 }
14247}
14248impl serde::Serialize for StreamSource {
14249 #[allow(deprecated)]
14250 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14251 where
14252 S: serde::Serializer,
14253 {
14254 use serde::ser::SerializeStruct;
14255 let mut len = 0;
14256 if self.source_id != 0 {
14257 len += 1;
14258 }
14259 if self.state_table.is_some() {
14260 len += 1;
14261 }
14262 if self.row_id_index.is_some() {
14263 len += 1;
14264 }
14265 if !self.columns.is_empty() {
14266 len += 1;
14267 }
14268 if !self.with_properties.is_empty() {
14269 len += 1;
14270 }
14271 if self.info.is_some() {
14272 len += 1;
14273 }
14274 if !self.source_name.is_empty() {
14275 len += 1;
14276 }
14277 if self.rate_limit.is_some() {
14278 len += 1;
14279 }
14280 if !self.secret_refs.is_empty() {
14281 len += 1;
14282 }
14283 if self.downstream_columns.is_some() {
14284 len += 1;
14285 }
14286 if self.refresh_mode.is_some() {
14287 len += 1;
14288 }
14289 if self.associated_table_id.is_some() {
14290 len += 1;
14291 }
14292 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamSource", len)?;
14293 if self.source_id != 0 {
14294 struct_ser.serialize_field("sourceId", &self.source_id)?;
14295 }
14296 if let Some(v) = self.state_table.as_ref() {
14297 struct_ser.serialize_field("stateTable", v)?;
14298 }
14299 if let Some(v) = self.row_id_index.as_ref() {
14300 struct_ser.serialize_field("rowIdIndex", v)?;
14301 }
14302 if !self.columns.is_empty() {
14303 struct_ser.serialize_field("columns", &self.columns)?;
14304 }
14305 if !self.with_properties.is_empty() {
14306 struct_ser.serialize_field("withProperties", &self.with_properties)?;
14307 }
14308 if let Some(v) = self.info.as_ref() {
14309 struct_ser.serialize_field("info", v)?;
14310 }
14311 if !self.source_name.is_empty() {
14312 struct_ser.serialize_field("sourceName", &self.source_name)?;
14313 }
14314 if let Some(v) = self.rate_limit.as_ref() {
14315 struct_ser.serialize_field("rateLimit", v)?;
14316 }
14317 if !self.secret_refs.is_empty() {
14318 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
14319 }
14320 if let Some(v) = self.downstream_columns.as_ref() {
14321 struct_ser.serialize_field("downstreamColumns", v)?;
14322 }
14323 if let Some(v) = self.refresh_mode.as_ref() {
14324 struct_ser.serialize_field("refreshMode", v)?;
14325 }
14326 if let Some(v) = self.associated_table_id.as_ref() {
14327 struct_ser.serialize_field("associatedTableId", v)?;
14328 }
14329 struct_ser.end()
14330 }
14331}
14332impl<'de> serde::Deserialize<'de> for StreamSource {
14333 #[allow(deprecated)]
14334 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14335 where
14336 D: serde::Deserializer<'de>,
14337 {
14338 const FIELDS: &[&str] = &[
14339 "source_id",
14340 "sourceId",
14341 "state_table",
14342 "stateTable",
14343 "row_id_index",
14344 "rowIdIndex",
14345 "columns",
14346 "with_properties",
14347 "withProperties",
14348 "info",
14349 "source_name",
14350 "sourceName",
14351 "rate_limit",
14352 "rateLimit",
14353 "secret_refs",
14354 "secretRefs",
14355 "downstream_columns",
14356 "downstreamColumns",
14357 "refresh_mode",
14358 "refreshMode",
14359 "associated_table_id",
14360 "associatedTableId",
14361 ];
14362
14363 #[allow(clippy::enum_variant_names)]
14364 enum GeneratedField {
14365 SourceId,
14366 StateTable,
14367 RowIdIndex,
14368 Columns,
14369 WithProperties,
14370 Info,
14371 SourceName,
14372 RateLimit,
14373 SecretRefs,
14374 DownstreamColumns,
14375 RefreshMode,
14376 AssociatedTableId,
14377 }
14378 impl<'de> serde::Deserialize<'de> for GeneratedField {
14379 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14380 where
14381 D: serde::Deserializer<'de>,
14382 {
14383 struct GeneratedVisitor;
14384
14385 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14386 type Value = GeneratedField;
14387
14388 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14389 write!(formatter, "expected one of: {:?}", &FIELDS)
14390 }
14391
14392 #[allow(unused_variables)]
14393 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14394 where
14395 E: serde::de::Error,
14396 {
14397 match value {
14398 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
14399 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
14400 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
14401 "columns" => Ok(GeneratedField::Columns),
14402 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
14403 "info" => Ok(GeneratedField::Info),
14404 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
14405 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
14406 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
14407 "downstreamColumns" | "downstream_columns" => Ok(GeneratedField::DownstreamColumns),
14408 "refreshMode" | "refresh_mode" => Ok(GeneratedField::RefreshMode),
14409 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
14410 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14411 }
14412 }
14413 }
14414 deserializer.deserialize_identifier(GeneratedVisitor)
14415 }
14416 }
14417 struct GeneratedVisitor;
14418 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14419 type Value = StreamSource;
14420
14421 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14422 formatter.write_str("struct stream_plan.StreamSource")
14423 }
14424
14425 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSource, V::Error>
14426 where
14427 V: serde::de::MapAccess<'de>,
14428 {
14429 let mut source_id__ = None;
14430 let mut state_table__ = None;
14431 let mut row_id_index__ = None;
14432 let mut columns__ = None;
14433 let mut with_properties__ = None;
14434 let mut info__ = None;
14435 let mut source_name__ = None;
14436 let mut rate_limit__ = None;
14437 let mut secret_refs__ = None;
14438 let mut downstream_columns__ = None;
14439 let mut refresh_mode__ = None;
14440 let mut associated_table_id__ = None;
14441 while let Some(k) = map_.next_key()? {
14442 match k {
14443 GeneratedField::SourceId => {
14444 if source_id__.is_some() {
14445 return Err(serde::de::Error::duplicate_field("sourceId"));
14446 }
14447 source_id__ =
14448 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14449 ;
14450 }
14451 GeneratedField::StateTable => {
14452 if state_table__.is_some() {
14453 return Err(serde::de::Error::duplicate_field("stateTable"));
14454 }
14455 state_table__ = map_.next_value()?;
14456 }
14457 GeneratedField::RowIdIndex => {
14458 if row_id_index__.is_some() {
14459 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
14460 }
14461 row_id_index__ =
14462 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14463 ;
14464 }
14465 GeneratedField::Columns => {
14466 if columns__.is_some() {
14467 return Err(serde::de::Error::duplicate_field("columns"));
14468 }
14469 columns__ = Some(map_.next_value()?);
14470 }
14471 GeneratedField::WithProperties => {
14472 if with_properties__.is_some() {
14473 return Err(serde::de::Error::duplicate_field("withProperties"));
14474 }
14475 with_properties__ = Some(
14476 map_.next_value::<std::collections::BTreeMap<_, _>>()?
14477 );
14478 }
14479 GeneratedField::Info => {
14480 if info__.is_some() {
14481 return Err(serde::de::Error::duplicate_field("info"));
14482 }
14483 info__ = map_.next_value()?;
14484 }
14485 GeneratedField::SourceName => {
14486 if source_name__.is_some() {
14487 return Err(serde::de::Error::duplicate_field("sourceName"));
14488 }
14489 source_name__ = Some(map_.next_value()?);
14490 }
14491 GeneratedField::RateLimit => {
14492 if rate_limit__.is_some() {
14493 return Err(serde::de::Error::duplicate_field("rateLimit"));
14494 }
14495 rate_limit__ =
14496 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14497 ;
14498 }
14499 GeneratedField::SecretRefs => {
14500 if secret_refs__.is_some() {
14501 return Err(serde::de::Error::duplicate_field("secretRefs"));
14502 }
14503 secret_refs__ = Some(
14504 map_.next_value::<std::collections::BTreeMap<_, _>>()?
14505 );
14506 }
14507 GeneratedField::DownstreamColumns => {
14508 if downstream_columns__.is_some() {
14509 return Err(serde::de::Error::duplicate_field("downstreamColumns"));
14510 }
14511 downstream_columns__ = map_.next_value()?;
14512 }
14513 GeneratedField::RefreshMode => {
14514 if refresh_mode__.is_some() {
14515 return Err(serde::de::Error::duplicate_field("refreshMode"));
14516 }
14517 refresh_mode__ = map_.next_value()?;
14518 }
14519 GeneratedField::AssociatedTableId => {
14520 if associated_table_id__.is_some() {
14521 return Err(serde::de::Error::duplicate_field("associatedTableId"));
14522 }
14523 associated_table_id__ =
14524 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14525 ;
14526 }
14527 }
14528 }
14529 Ok(StreamSource {
14530 source_id: source_id__.unwrap_or_default(),
14531 state_table: state_table__,
14532 row_id_index: row_id_index__,
14533 columns: columns__.unwrap_or_default(),
14534 with_properties: with_properties__.unwrap_or_default(),
14535 info: info__,
14536 source_name: source_name__.unwrap_or_default(),
14537 rate_limit: rate_limit__,
14538 secret_refs: secret_refs__.unwrap_or_default(),
14539 downstream_columns: downstream_columns__,
14540 refresh_mode: refresh_mode__,
14541 associated_table_id: associated_table_id__,
14542 })
14543 }
14544 }
14545 deserializer.deserialize_struct("stream_plan.StreamSource", FIELDS, GeneratedVisitor)
14546 }
14547}
14548impl serde::Serialize for SubscriptionUpstreamInfo {
14549 #[allow(deprecated)]
14550 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14551 where
14552 S: serde::Serializer,
14553 {
14554 use serde::ser::SerializeStruct;
14555 let mut len = 0;
14556 if self.subscriber_id != 0 {
14557 len += 1;
14558 }
14559 if self.upstream_mv_table_id != 0 {
14560 len += 1;
14561 }
14562 let mut struct_ser = serializer.serialize_struct("stream_plan.SubscriptionUpstreamInfo", len)?;
14563 if self.subscriber_id != 0 {
14564 struct_ser.serialize_field("subscriberId", &self.subscriber_id)?;
14565 }
14566 if self.upstream_mv_table_id != 0 {
14567 struct_ser.serialize_field("upstreamMvTableId", &self.upstream_mv_table_id)?;
14568 }
14569 struct_ser.end()
14570 }
14571}
14572impl<'de> serde::Deserialize<'de> for SubscriptionUpstreamInfo {
14573 #[allow(deprecated)]
14574 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14575 where
14576 D: serde::Deserializer<'de>,
14577 {
14578 const FIELDS: &[&str] = &[
14579 "subscriber_id",
14580 "subscriberId",
14581 "upstream_mv_table_id",
14582 "upstreamMvTableId",
14583 ];
14584
14585 #[allow(clippy::enum_variant_names)]
14586 enum GeneratedField {
14587 SubscriberId,
14588 UpstreamMvTableId,
14589 }
14590 impl<'de> serde::Deserialize<'de> for GeneratedField {
14591 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14592 where
14593 D: serde::Deserializer<'de>,
14594 {
14595 struct GeneratedVisitor;
14596
14597 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14598 type Value = GeneratedField;
14599
14600 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14601 write!(formatter, "expected one of: {:?}", &FIELDS)
14602 }
14603
14604 #[allow(unused_variables)]
14605 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14606 where
14607 E: serde::de::Error,
14608 {
14609 match value {
14610 "subscriberId" | "subscriber_id" => Ok(GeneratedField::SubscriberId),
14611 "upstreamMvTableId" | "upstream_mv_table_id" => Ok(GeneratedField::UpstreamMvTableId),
14612 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14613 }
14614 }
14615 }
14616 deserializer.deserialize_identifier(GeneratedVisitor)
14617 }
14618 }
14619 struct GeneratedVisitor;
14620 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14621 type Value = SubscriptionUpstreamInfo;
14622
14623 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14624 formatter.write_str("struct stream_plan.SubscriptionUpstreamInfo")
14625 }
14626
14627 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscriptionUpstreamInfo, V::Error>
14628 where
14629 V: serde::de::MapAccess<'de>,
14630 {
14631 let mut subscriber_id__ = None;
14632 let mut upstream_mv_table_id__ = None;
14633 while let Some(k) = map_.next_key()? {
14634 match k {
14635 GeneratedField::SubscriberId => {
14636 if subscriber_id__.is_some() {
14637 return Err(serde::de::Error::duplicate_field("subscriberId"));
14638 }
14639 subscriber_id__ =
14640 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14641 ;
14642 }
14643 GeneratedField::UpstreamMvTableId => {
14644 if upstream_mv_table_id__.is_some() {
14645 return Err(serde::de::Error::duplicate_field("upstreamMvTableId"));
14646 }
14647 upstream_mv_table_id__ =
14648 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14649 ;
14650 }
14651 }
14652 }
14653 Ok(SubscriptionUpstreamInfo {
14654 subscriber_id: subscriber_id__.unwrap_or_default(),
14655 upstream_mv_table_id: upstream_mv_table_id__.unwrap_or_default(),
14656 })
14657 }
14658 }
14659 deserializer.deserialize_struct("stream_plan.SubscriptionUpstreamInfo", FIELDS, GeneratedVisitor)
14660 }
14661}
14662impl serde::Serialize for SyncLogStoreNode {
14663 #[allow(deprecated)]
14664 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14665 where
14666 S: serde::Serializer,
14667 {
14668 use serde::ser::SerializeStruct;
14669 let mut len = 0;
14670 if self.log_store_table.is_some() {
14671 len += 1;
14672 }
14673 if self.pause_duration_ms.is_some() {
14674 len += 1;
14675 }
14676 if self.buffer_size.is_some() {
14677 len += 1;
14678 }
14679 if self.aligned {
14680 len += 1;
14681 }
14682 let mut struct_ser = serializer.serialize_struct("stream_plan.SyncLogStoreNode", len)?;
14683 if let Some(v) = self.log_store_table.as_ref() {
14684 struct_ser.serialize_field("logStoreTable", v)?;
14685 }
14686 if let Some(v) = self.pause_duration_ms.as_ref() {
14687 struct_ser.serialize_field("pauseDurationMs", v)?;
14688 }
14689 if let Some(v) = self.buffer_size.as_ref() {
14690 struct_ser.serialize_field("bufferSize", v)?;
14691 }
14692 if self.aligned {
14693 struct_ser.serialize_field("aligned", &self.aligned)?;
14694 }
14695 struct_ser.end()
14696 }
14697}
14698impl<'de> serde::Deserialize<'de> for SyncLogStoreNode {
14699 #[allow(deprecated)]
14700 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14701 where
14702 D: serde::Deserializer<'de>,
14703 {
14704 const FIELDS: &[&str] = &[
14705 "log_store_table",
14706 "logStoreTable",
14707 "pause_duration_ms",
14708 "pauseDurationMs",
14709 "buffer_size",
14710 "bufferSize",
14711 "aligned",
14712 ];
14713
14714 #[allow(clippy::enum_variant_names)]
14715 enum GeneratedField {
14716 LogStoreTable,
14717 PauseDurationMs,
14718 BufferSize,
14719 Aligned,
14720 }
14721 impl<'de> serde::Deserialize<'de> for GeneratedField {
14722 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14723 where
14724 D: serde::Deserializer<'de>,
14725 {
14726 struct GeneratedVisitor;
14727
14728 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14729 type Value = GeneratedField;
14730
14731 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14732 write!(formatter, "expected one of: {:?}", &FIELDS)
14733 }
14734
14735 #[allow(unused_variables)]
14736 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14737 where
14738 E: serde::de::Error,
14739 {
14740 match value {
14741 "logStoreTable" | "log_store_table" => Ok(GeneratedField::LogStoreTable),
14742 "pauseDurationMs" | "pause_duration_ms" => Ok(GeneratedField::PauseDurationMs),
14743 "bufferSize" | "buffer_size" => Ok(GeneratedField::BufferSize),
14744 "aligned" => Ok(GeneratedField::Aligned),
14745 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14746 }
14747 }
14748 }
14749 deserializer.deserialize_identifier(GeneratedVisitor)
14750 }
14751 }
14752 struct GeneratedVisitor;
14753 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14754 type Value = SyncLogStoreNode;
14755
14756 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14757 formatter.write_str("struct stream_plan.SyncLogStoreNode")
14758 }
14759
14760 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SyncLogStoreNode, V::Error>
14761 where
14762 V: serde::de::MapAccess<'de>,
14763 {
14764 let mut log_store_table__ = None;
14765 let mut pause_duration_ms__ = None;
14766 let mut buffer_size__ = None;
14767 let mut aligned__ = None;
14768 while let Some(k) = map_.next_key()? {
14769 match k {
14770 GeneratedField::LogStoreTable => {
14771 if log_store_table__.is_some() {
14772 return Err(serde::de::Error::duplicate_field("logStoreTable"));
14773 }
14774 log_store_table__ = map_.next_value()?;
14775 }
14776 GeneratedField::PauseDurationMs => {
14777 if pause_duration_ms__.is_some() {
14778 return Err(serde::de::Error::duplicate_field("pauseDurationMs"));
14779 }
14780 pause_duration_ms__ =
14781 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14782 ;
14783 }
14784 GeneratedField::BufferSize => {
14785 if buffer_size__.is_some() {
14786 return Err(serde::de::Error::duplicate_field("bufferSize"));
14787 }
14788 buffer_size__ =
14789 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14790 ;
14791 }
14792 GeneratedField::Aligned => {
14793 if aligned__.is_some() {
14794 return Err(serde::de::Error::duplicate_field("aligned"));
14795 }
14796 aligned__ = Some(map_.next_value()?);
14797 }
14798 }
14799 }
14800 Ok(SyncLogStoreNode {
14801 log_store_table: log_store_table__,
14802 pause_duration_ms: pause_duration_ms__,
14803 buffer_size: buffer_size__,
14804 aligned: aligned__.unwrap_or_default(),
14805 })
14806 }
14807 }
14808 deserializer.deserialize_struct("stream_plan.SyncLogStoreNode", FIELDS, GeneratedVisitor)
14809 }
14810}
14811impl serde::Serialize for TemporalJoinNode {
14812 #[allow(deprecated)]
14813 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14814 where
14815 S: serde::Serializer,
14816 {
14817 use serde::ser::SerializeStruct;
14818 let mut len = 0;
14819 if self.join_type != 0 {
14820 len += 1;
14821 }
14822 if !self.left_key.is_empty() {
14823 len += 1;
14824 }
14825 if !self.right_key.is_empty() {
14826 len += 1;
14827 }
14828 if !self.null_safe.is_empty() {
14829 len += 1;
14830 }
14831 if self.condition.is_some() {
14832 len += 1;
14833 }
14834 if !self.output_indices.is_empty() {
14835 len += 1;
14836 }
14837 if self.table_desc.is_some() {
14838 len += 1;
14839 }
14840 if !self.table_output_indices.is_empty() {
14841 len += 1;
14842 }
14843 if self.memo_table.is_some() {
14844 len += 1;
14845 }
14846 if self.is_nested_loop {
14847 len += 1;
14848 }
14849 let mut struct_ser = serializer.serialize_struct("stream_plan.TemporalJoinNode", len)?;
14850 if self.join_type != 0 {
14851 let v = super::plan_common::JoinType::try_from(self.join_type)
14852 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
14853 struct_ser.serialize_field("joinType", &v)?;
14854 }
14855 if !self.left_key.is_empty() {
14856 struct_ser.serialize_field("leftKey", &self.left_key)?;
14857 }
14858 if !self.right_key.is_empty() {
14859 struct_ser.serialize_field("rightKey", &self.right_key)?;
14860 }
14861 if !self.null_safe.is_empty() {
14862 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
14863 }
14864 if let Some(v) = self.condition.as_ref() {
14865 struct_ser.serialize_field("condition", v)?;
14866 }
14867 if !self.output_indices.is_empty() {
14868 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
14869 }
14870 if let Some(v) = self.table_desc.as_ref() {
14871 struct_ser.serialize_field("tableDesc", v)?;
14872 }
14873 if !self.table_output_indices.is_empty() {
14874 struct_ser.serialize_field("tableOutputIndices", &self.table_output_indices)?;
14875 }
14876 if let Some(v) = self.memo_table.as_ref() {
14877 struct_ser.serialize_field("memoTable", v)?;
14878 }
14879 if self.is_nested_loop {
14880 struct_ser.serialize_field("isNestedLoop", &self.is_nested_loop)?;
14881 }
14882 struct_ser.end()
14883 }
14884}
14885impl<'de> serde::Deserialize<'de> for TemporalJoinNode {
14886 #[allow(deprecated)]
14887 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14888 where
14889 D: serde::Deserializer<'de>,
14890 {
14891 const FIELDS: &[&str] = &[
14892 "join_type",
14893 "joinType",
14894 "left_key",
14895 "leftKey",
14896 "right_key",
14897 "rightKey",
14898 "null_safe",
14899 "nullSafe",
14900 "condition",
14901 "output_indices",
14902 "outputIndices",
14903 "table_desc",
14904 "tableDesc",
14905 "table_output_indices",
14906 "tableOutputIndices",
14907 "memo_table",
14908 "memoTable",
14909 "is_nested_loop",
14910 "isNestedLoop",
14911 ];
14912
14913 #[allow(clippy::enum_variant_names)]
14914 enum GeneratedField {
14915 JoinType,
14916 LeftKey,
14917 RightKey,
14918 NullSafe,
14919 Condition,
14920 OutputIndices,
14921 TableDesc,
14922 TableOutputIndices,
14923 MemoTable,
14924 IsNestedLoop,
14925 }
14926 impl<'de> serde::Deserialize<'de> for GeneratedField {
14927 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14928 where
14929 D: serde::Deserializer<'de>,
14930 {
14931 struct GeneratedVisitor;
14932
14933 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14934 type Value = GeneratedField;
14935
14936 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14937 write!(formatter, "expected one of: {:?}", &FIELDS)
14938 }
14939
14940 #[allow(unused_variables)]
14941 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14942 where
14943 E: serde::de::Error,
14944 {
14945 match value {
14946 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
14947 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
14948 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
14949 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
14950 "condition" => Ok(GeneratedField::Condition),
14951 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
14952 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
14953 "tableOutputIndices" | "table_output_indices" => Ok(GeneratedField::TableOutputIndices),
14954 "memoTable" | "memo_table" => Ok(GeneratedField::MemoTable),
14955 "isNestedLoop" | "is_nested_loop" => Ok(GeneratedField::IsNestedLoop),
14956 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14957 }
14958 }
14959 }
14960 deserializer.deserialize_identifier(GeneratedVisitor)
14961 }
14962 }
14963 struct GeneratedVisitor;
14964 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14965 type Value = TemporalJoinNode;
14966
14967 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14968 formatter.write_str("struct stream_plan.TemporalJoinNode")
14969 }
14970
14971 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TemporalJoinNode, V::Error>
14972 where
14973 V: serde::de::MapAccess<'de>,
14974 {
14975 let mut join_type__ = None;
14976 let mut left_key__ = None;
14977 let mut right_key__ = None;
14978 let mut null_safe__ = None;
14979 let mut condition__ = None;
14980 let mut output_indices__ = None;
14981 let mut table_desc__ = None;
14982 let mut table_output_indices__ = None;
14983 let mut memo_table__ = None;
14984 let mut is_nested_loop__ = None;
14985 while let Some(k) = map_.next_key()? {
14986 match k {
14987 GeneratedField::JoinType => {
14988 if join_type__.is_some() {
14989 return Err(serde::de::Error::duplicate_field("joinType"));
14990 }
14991 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
14992 }
14993 GeneratedField::LeftKey => {
14994 if left_key__.is_some() {
14995 return Err(serde::de::Error::duplicate_field("leftKey"));
14996 }
14997 left_key__ =
14998 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14999 .into_iter().map(|x| x.0).collect())
15000 ;
15001 }
15002 GeneratedField::RightKey => {
15003 if right_key__.is_some() {
15004 return Err(serde::de::Error::duplicate_field("rightKey"));
15005 }
15006 right_key__ =
15007 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15008 .into_iter().map(|x| x.0).collect())
15009 ;
15010 }
15011 GeneratedField::NullSafe => {
15012 if null_safe__.is_some() {
15013 return Err(serde::de::Error::duplicate_field("nullSafe"));
15014 }
15015 null_safe__ = Some(map_.next_value()?);
15016 }
15017 GeneratedField::Condition => {
15018 if condition__.is_some() {
15019 return Err(serde::de::Error::duplicate_field("condition"));
15020 }
15021 condition__ = map_.next_value()?;
15022 }
15023 GeneratedField::OutputIndices => {
15024 if output_indices__.is_some() {
15025 return Err(serde::de::Error::duplicate_field("outputIndices"));
15026 }
15027 output_indices__ =
15028 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15029 .into_iter().map(|x| x.0).collect())
15030 ;
15031 }
15032 GeneratedField::TableDesc => {
15033 if table_desc__.is_some() {
15034 return Err(serde::de::Error::duplicate_field("tableDesc"));
15035 }
15036 table_desc__ = map_.next_value()?;
15037 }
15038 GeneratedField::TableOutputIndices => {
15039 if table_output_indices__.is_some() {
15040 return Err(serde::de::Error::duplicate_field("tableOutputIndices"));
15041 }
15042 table_output_indices__ =
15043 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15044 .into_iter().map(|x| x.0).collect())
15045 ;
15046 }
15047 GeneratedField::MemoTable => {
15048 if memo_table__.is_some() {
15049 return Err(serde::de::Error::duplicate_field("memoTable"));
15050 }
15051 memo_table__ = map_.next_value()?;
15052 }
15053 GeneratedField::IsNestedLoop => {
15054 if is_nested_loop__.is_some() {
15055 return Err(serde::de::Error::duplicate_field("isNestedLoop"));
15056 }
15057 is_nested_loop__ = Some(map_.next_value()?);
15058 }
15059 }
15060 }
15061 Ok(TemporalJoinNode {
15062 join_type: join_type__.unwrap_or_default(),
15063 left_key: left_key__.unwrap_or_default(),
15064 right_key: right_key__.unwrap_or_default(),
15065 null_safe: null_safe__.unwrap_or_default(),
15066 condition: condition__,
15067 output_indices: output_indices__.unwrap_or_default(),
15068 table_desc: table_desc__,
15069 table_output_indices: table_output_indices__.unwrap_or_default(),
15070 memo_table: memo_table__,
15071 is_nested_loop: is_nested_loop__.unwrap_or_default(),
15072 })
15073 }
15074 }
15075 deserializer.deserialize_struct("stream_plan.TemporalJoinNode", FIELDS, GeneratedVisitor)
15076 }
15077}
15078impl serde::Serialize for ThrottleMutation {
15079 #[allow(deprecated)]
15080 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15081 where
15082 S: serde::Serializer,
15083 {
15084 use serde::ser::SerializeStruct;
15085 let mut len = 0;
15086 if !self.actor_throttle.is_empty() {
15087 len += 1;
15088 }
15089 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation", len)?;
15090 if !self.actor_throttle.is_empty() {
15091 struct_ser.serialize_field("actorThrottle", &self.actor_throttle)?;
15092 }
15093 struct_ser.end()
15094 }
15095}
15096impl<'de> serde::Deserialize<'de> for ThrottleMutation {
15097 #[allow(deprecated)]
15098 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15099 where
15100 D: serde::Deserializer<'de>,
15101 {
15102 const FIELDS: &[&str] = &[
15103 "actor_throttle",
15104 "actorThrottle",
15105 ];
15106
15107 #[allow(clippy::enum_variant_names)]
15108 enum GeneratedField {
15109 ActorThrottle,
15110 }
15111 impl<'de> serde::Deserialize<'de> for GeneratedField {
15112 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15113 where
15114 D: serde::Deserializer<'de>,
15115 {
15116 struct GeneratedVisitor;
15117
15118 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15119 type Value = GeneratedField;
15120
15121 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15122 write!(formatter, "expected one of: {:?}", &FIELDS)
15123 }
15124
15125 #[allow(unused_variables)]
15126 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15127 where
15128 E: serde::de::Error,
15129 {
15130 match value {
15131 "actorThrottle" | "actor_throttle" => Ok(GeneratedField::ActorThrottle),
15132 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15133 }
15134 }
15135 }
15136 deserializer.deserialize_identifier(GeneratedVisitor)
15137 }
15138 }
15139 struct GeneratedVisitor;
15140 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15141 type Value = ThrottleMutation;
15142
15143 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15144 formatter.write_str("struct stream_plan.ThrottleMutation")
15145 }
15146
15147 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ThrottleMutation, V::Error>
15148 where
15149 V: serde::de::MapAccess<'de>,
15150 {
15151 let mut actor_throttle__ = None;
15152 while let Some(k) = map_.next_key()? {
15153 match k {
15154 GeneratedField::ActorThrottle => {
15155 if actor_throttle__.is_some() {
15156 return Err(serde::de::Error::duplicate_field("actorThrottle"));
15157 }
15158 actor_throttle__ = Some(
15159 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15160 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15161 );
15162 }
15163 }
15164 }
15165 Ok(ThrottleMutation {
15166 actor_throttle: actor_throttle__.unwrap_or_default(),
15167 })
15168 }
15169 }
15170 deserializer.deserialize_struct("stream_plan.ThrottleMutation", FIELDS, GeneratedVisitor)
15171 }
15172}
15173impl serde::Serialize for throttle_mutation::RateLimit {
15174 #[allow(deprecated)]
15175 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15176 where
15177 S: serde::Serializer,
15178 {
15179 use serde::ser::SerializeStruct;
15180 let mut len = 0;
15181 if self.rate_limit.is_some() {
15182 len += 1;
15183 }
15184 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation.RateLimit", len)?;
15185 if let Some(v) = self.rate_limit.as_ref() {
15186 struct_ser.serialize_field("rateLimit", v)?;
15187 }
15188 struct_ser.end()
15189 }
15190}
15191impl<'de> serde::Deserialize<'de> for throttle_mutation::RateLimit {
15192 #[allow(deprecated)]
15193 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15194 where
15195 D: serde::Deserializer<'de>,
15196 {
15197 const FIELDS: &[&str] = &[
15198 "rate_limit",
15199 "rateLimit",
15200 ];
15201
15202 #[allow(clippy::enum_variant_names)]
15203 enum GeneratedField {
15204 RateLimit,
15205 }
15206 impl<'de> serde::Deserialize<'de> for GeneratedField {
15207 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15208 where
15209 D: serde::Deserializer<'de>,
15210 {
15211 struct GeneratedVisitor;
15212
15213 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15214 type Value = GeneratedField;
15215
15216 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15217 write!(formatter, "expected one of: {:?}", &FIELDS)
15218 }
15219
15220 #[allow(unused_variables)]
15221 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15222 where
15223 E: serde::de::Error,
15224 {
15225 match value {
15226 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
15227 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15228 }
15229 }
15230 }
15231 deserializer.deserialize_identifier(GeneratedVisitor)
15232 }
15233 }
15234 struct GeneratedVisitor;
15235 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15236 type Value = throttle_mutation::RateLimit;
15237
15238 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15239 formatter.write_str("struct stream_plan.ThrottleMutation.RateLimit")
15240 }
15241
15242 fn visit_map<V>(self, mut map_: V) -> std::result::Result<throttle_mutation::RateLimit, V::Error>
15243 where
15244 V: serde::de::MapAccess<'de>,
15245 {
15246 let mut rate_limit__ = None;
15247 while let Some(k) = map_.next_key()? {
15248 match k {
15249 GeneratedField::RateLimit => {
15250 if rate_limit__.is_some() {
15251 return Err(serde::de::Error::duplicate_field("rateLimit"));
15252 }
15253 rate_limit__ =
15254 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15255 ;
15256 }
15257 }
15258 }
15259 Ok(throttle_mutation::RateLimit {
15260 rate_limit: rate_limit__,
15261 })
15262 }
15263 }
15264 deserializer.deserialize_struct("stream_plan.ThrottleMutation.RateLimit", FIELDS, GeneratedVisitor)
15265 }
15266}
15267impl serde::Serialize for TopNNode {
15268 #[allow(deprecated)]
15269 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15270 where
15271 S: serde::Serializer,
15272 {
15273 use serde::ser::SerializeStruct;
15274 let mut len = 0;
15275 if self.limit != 0 {
15276 len += 1;
15277 }
15278 if self.offset != 0 {
15279 len += 1;
15280 }
15281 if self.table.is_some() {
15282 len += 1;
15283 }
15284 if !self.order_by.is_empty() {
15285 len += 1;
15286 }
15287 if self.with_ties {
15288 len += 1;
15289 }
15290 let mut struct_ser = serializer.serialize_struct("stream_plan.TopNNode", len)?;
15291 if self.limit != 0 {
15292 #[allow(clippy::needless_borrow)]
15293 #[allow(clippy::needless_borrows_for_generic_args)]
15294 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
15295 }
15296 if self.offset != 0 {
15297 #[allow(clippy::needless_borrow)]
15298 #[allow(clippy::needless_borrows_for_generic_args)]
15299 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
15300 }
15301 if let Some(v) = self.table.as_ref() {
15302 struct_ser.serialize_field("table", v)?;
15303 }
15304 if !self.order_by.is_empty() {
15305 struct_ser.serialize_field("orderBy", &self.order_by)?;
15306 }
15307 if self.with_ties {
15308 struct_ser.serialize_field("withTies", &self.with_ties)?;
15309 }
15310 struct_ser.end()
15311 }
15312}
15313impl<'de> serde::Deserialize<'de> for TopNNode {
15314 #[allow(deprecated)]
15315 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15316 where
15317 D: serde::Deserializer<'de>,
15318 {
15319 const FIELDS: &[&str] = &[
15320 "limit",
15321 "offset",
15322 "table",
15323 "order_by",
15324 "orderBy",
15325 "with_ties",
15326 "withTies",
15327 ];
15328
15329 #[allow(clippy::enum_variant_names)]
15330 enum GeneratedField {
15331 Limit,
15332 Offset,
15333 Table,
15334 OrderBy,
15335 WithTies,
15336 }
15337 impl<'de> serde::Deserialize<'de> for GeneratedField {
15338 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15339 where
15340 D: serde::Deserializer<'de>,
15341 {
15342 struct GeneratedVisitor;
15343
15344 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15345 type Value = GeneratedField;
15346
15347 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15348 write!(formatter, "expected one of: {:?}", &FIELDS)
15349 }
15350
15351 #[allow(unused_variables)]
15352 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15353 where
15354 E: serde::de::Error,
15355 {
15356 match value {
15357 "limit" => Ok(GeneratedField::Limit),
15358 "offset" => Ok(GeneratedField::Offset),
15359 "table" => Ok(GeneratedField::Table),
15360 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
15361 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
15362 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15363 }
15364 }
15365 }
15366 deserializer.deserialize_identifier(GeneratedVisitor)
15367 }
15368 }
15369 struct GeneratedVisitor;
15370 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15371 type Value = TopNNode;
15372
15373 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15374 formatter.write_str("struct stream_plan.TopNNode")
15375 }
15376
15377 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
15378 where
15379 V: serde::de::MapAccess<'de>,
15380 {
15381 let mut limit__ = None;
15382 let mut offset__ = None;
15383 let mut table__ = None;
15384 let mut order_by__ = None;
15385 let mut with_ties__ = None;
15386 while let Some(k) = map_.next_key()? {
15387 match k {
15388 GeneratedField::Limit => {
15389 if limit__.is_some() {
15390 return Err(serde::de::Error::duplicate_field("limit"));
15391 }
15392 limit__ =
15393 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15394 ;
15395 }
15396 GeneratedField::Offset => {
15397 if offset__.is_some() {
15398 return Err(serde::de::Error::duplicate_field("offset"));
15399 }
15400 offset__ =
15401 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15402 ;
15403 }
15404 GeneratedField::Table => {
15405 if table__.is_some() {
15406 return Err(serde::de::Error::duplicate_field("table"));
15407 }
15408 table__ = map_.next_value()?;
15409 }
15410 GeneratedField::OrderBy => {
15411 if order_by__.is_some() {
15412 return Err(serde::de::Error::duplicate_field("orderBy"));
15413 }
15414 order_by__ = Some(map_.next_value()?);
15415 }
15416 GeneratedField::WithTies => {
15417 if with_ties__.is_some() {
15418 return Err(serde::de::Error::duplicate_field("withTies"));
15419 }
15420 with_ties__ = Some(map_.next_value()?);
15421 }
15422 }
15423 }
15424 Ok(TopNNode {
15425 limit: limit__.unwrap_or_default(),
15426 offset: offset__.unwrap_or_default(),
15427 table: table__,
15428 order_by: order_by__.unwrap_or_default(),
15429 with_ties: with_ties__.unwrap_or_default(),
15430 })
15431 }
15432 }
15433 deserializer.deserialize_struct("stream_plan.TopNNode", FIELDS, GeneratedVisitor)
15434 }
15435}
15436impl serde::Serialize for UnionNode {
15437 #[allow(deprecated)]
15438 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15439 where
15440 S: serde::Serializer,
15441 {
15442 use serde::ser::SerializeStruct;
15443 let len = 0;
15444 let struct_ser = serializer.serialize_struct("stream_plan.UnionNode", len)?;
15445 struct_ser.end()
15446 }
15447}
15448impl<'de> serde::Deserialize<'de> for UnionNode {
15449 #[allow(deprecated)]
15450 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15451 where
15452 D: serde::Deserializer<'de>,
15453 {
15454 const FIELDS: &[&str] = &[
15455 ];
15456
15457 #[allow(clippy::enum_variant_names)]
15458 enum GeneratedField {
15459 }
15460 impl<'de> serde::Deserialize<'de> for GeneratedField {
15461 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15462 where
15463 D: serde::Deserializer<'de>,
15464 {
15465 struct GeneratedVisitor;
15466
15467 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15468 type Value = GeneratedField;
15469
15470 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15471 write!(formatter, "expected one of: {:?}", &FIELDS)
15472 }
15473
15474 #[allow(unused_variables)]
15475 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15476 where
15477 E: serde::de::Error,
15478 {
15479 Err(serde::de::Error::unknown_field(value, FIELDS))
15480 }
15481 }
15482 deserializer.deserialize_identifier(GeneratedVisitor)
15483 }
15484 }
15485 struct GeneratedVisitor;
15486 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15487 type Value = UnionNode;
15488
15489 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15490 formatter.write_str("struct stream_plan.UnionNode")
15491 }
15492
15493 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
15494 where
15495 V: serde::de::MapAccess<'de>,
15496 {
15497 while map_.next_key::<GeneratedField>()?.is_some() {
15498 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15499 }
15500 Ok(UnionNode {
15501 })
15502 }
15503 }
15504 deserializer.deserialize_struct("stream_plan.UnionNode", FIELDS, GeneratedVisitor)
15505 }
15506}
15507impl serde::Serialize for UpdateMutation {
15508 #[allow(deprecated)]
15509 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15510 where
15511 S: serde::Serializer,
15512 {
15513 use serde::ser::SerializeStruct;
15514 let mut len = 0;
15515 if !self.dispatcher_update.is_empty() {
15516 len += 1;
15517 }
15518 if !self.merge_update.is_empty() {
15519 len += 1;
15520 }
15521 if !self.actor_vnode_bitmap_update.is_empty() {
15522 len += 1;
15523 }
15524 if !self.dropped_actors.is_empty() {
15525 len += 1;
15526 }
15527 if !self.actor_splits.is_empty() {
15528 len += 1;
15529 }
15530 if !self.actor_new_dispatchers.is_empty() {
15531 len += 1;
15532 }
15533 if self.actor_cdc_table_snapshot_splits.is_some() {
15534 len += 1;
15535 }
15536 if !self.sink_add_columns.is_empty() {
15537 len += 1;
15538 }
15539 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation", len)?;
15540 if !self.dispatcher_update.is_empty() {
15541 struct_ser.serialize_field("dispatcherUpdate", &self.dispatcher_update)?;
15542 }
15543 if !self.merge_update.is_empty() {
15544 struct_ser.serialize_field("mergeUpdate", &self.merge_update)?;
15545 }
15546 if !self.actor_vnode_bitmap_update.is_empty() {
15547 struct_ser.serialize_field("actorVnodeBitmapUpdate", &self.actor_vnode_bitmap_update)?;
15548 }
15549 if !self.dropped_actors.is_empty() {
15550 struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
15551 }
15552 if !self.actor_splits.is_empty() {
15553 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
15554 }
15555 if !self.actor_new_dispatchers.is_empty() {
15556 struct_ser.serialize_field("actorNewDispatchers", &self.actor_new_dispatchers)?;
15557 }
15558 if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
15559 struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
15560 }
15561 if !self.sink_add_columns.is_empty() {
15562 struct_ser.serialize_field("sinkAddColumns", &self.sink_add_columns)?;
15563 }
15564 struct_ser.end()
15565 }
15566}
15567impl<'de> serde::Deserialize<'de> for UpdateMutation {
15568 #[allow(deprecated)]
15569 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15570 where
15571 D: serde::Deserializer<'de>,
15572 {
15573 const FIELDS: &[&str] = &[
15574 "dispatcher_update",
15575 "dispatcherUpdate",
15576 "merge_update",
15577 "mergeUpdate",
15578 "actor_vnode_bitmap_update",
15579 "actorVnodeBitmapUpdate",
15580 "dropped_actors",
15581 "droppedActors",
15582 "actor_splits",
15583 "actorSplits",
15584 "actor_new_dispatchers",
15585 "actorNewDispatchers",
15586 "actor_cdc_table_snapshot_splits",
15587 "actorCdcTableSnapshotSplits",
15588 "sink_add_columns",
15589 "sinkAddColumns",
15590 ];
15591
15592 #[allow(clippy::enum_variant_names)]
15593 enum GeneratedField {
15594 DispatcherUpdate,
15595 MergeUpdate,
15596 ActorVnodeBitmapUpdate,
15597 DroppedActors,
15598 ActorSplits,
15599 ActorNewDispatchers,
15600 ActorCdcTableSnapshotSplits,
15601 SinkAddColumns,
15602 }
15603 impl<'de> serde::Deserialize<'de> for GeneratedField {
15604 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15605 where
15606 D: serde::Deserializer<'de>,
15607 {
15608 struct GeneratedVisitor;
15609
15610 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15611 type Value = GeneratedField;
15612
15613 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15614 write!(formatter, "expected one of: {:?}", &FIELDS)
15615 }
15616
15617 #[allow(unused_variables)]
15618 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15619 where
15620 E: serde::de::Error,
15621 {
15622 match value {
15623 "dispatcherUpdate" | "dispatcher_update" => Ok(GeneratedField::DispatcherUpdate),
15624 "mergeUpdate" | "merge_update" => Ok(GeneratedField::MergeUpdate),
15625 "actorVnodeBitmapUpdate" | "actor_vnode_bitmap_update" => Ok(GeneratedField::ActorVnodeBitmapUpdate),
15626 "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
15627 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
15628 "actorNewDispatchers" | "actor_new_dispatchers" => Ok(GeneratedField::ActorNewDispatchers),
15629 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
15630 "sinkAddColumns" | "sink_add_columns" => Ok(GeneratedField::SinkAddColumns),
15631 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15632 }
15633 }
15634 }
15635 deserializer.deserialize_identifier(GeneratedVisitor)
15636 }
15637 }
15638 struct GeneratedVisitor;
15639 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15640 type Value = UpdateMutation;
15641
15642 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15643 formatter.write_str("struct stream_plan.UpdateMutation")
15644 }
15645
15646 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateMutation, V::Error>
15647 where
15648 V: serde::de::MapAccess<'de>,
15649 {
15650 let mut dispatcher_update__ = None;
15651 let mut merge_update__ = None;
15652 let mut actor_vnode_bitmap_update__ = None;
15653 let mut dropped_actors__ = None;
15654 let mut actor_splits__ = None;
15655 let mut actor_new_dispatchers__ = None;
15656 let mut actor_cdc_table_snapshot_splits__ = None;
15657 let mut sink_add_columns__ = None;
15658 while let Some(k) = map_.next_key()? {
15659 match k {
15660 GeneratedField::DispatcherUpdate => {
15661 if dispatcher_update__.is_some() {
15662 return Err(serde::de::Error::duplicate_field("dispatcherUpdate"));
15663 }
15664 dispatcher_update__ = Some(map_.next_value()?);
15665 }
15666 GeneratedField::MergeUpdate => {
15667 if merge_update__.is_some() {
15668 return Err(serde::de::Error::duplicate_field("mergeUpdate"));
15669 }
15670 merge_update__ = Some(map_.next_value()?);
15671 }
15672 GeneratedField::ActorVnodeBitmapUpdate => {
15673 if actor_vnode_bitmap_update__.is_some() {
15674 return Err(serde::de::Error::duplicate_field("actorVnodeBitmapUpdate"));
15675 }
15676 actor_vnode_bitmap_update__ = Some(
15677 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15678 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15679 );
15680 }
15681 GeneratedField::DroppedActors => {
15682 if dropped_actors__.is_some() {
15683 return Err(serde::de::Error::duplicate_field("droppedActors"));
15684 }
15685 dropped_actors__ =
15686 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15687 .into_iter().map(|x| x.0).collect())
15688 ;
15689 }
15690 GeneratedField::ActorSplits => {
15691 if actor_splits__.is_some() {
15692 return Err(serde::de::Error::duplicate_field("actorSplits"));
15693 }
15694 actor_splits__ = Some(
15695 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15696 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15697 );
15698 }
15699 GeneratedField::ActorNewDispatchers => {
15700 if actor_new_dispatchers__.is_some() {
15701 return Err(serde::de::Error::duplicate_field("actorNewDispatchers"));
15702 }
15703 actor_new_dispatchers__ = Some(
15704 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15705 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15706 );
15707 }
15708 GeneratedField::ActorCdcTableSnapshotSplits => {
15709 if actor_cdc_table_snapshot_splits__.is_some() {
15710 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
15711 }
15712 actor_cdc_table_snapshot_splits__ = map_.next_value()?;
15713 }
15714 GeneratedField::SinkAddColumns => {
15715 if sink_add_columns__.is_some() {
15716 return Err(serde::de::Error::duplicate_field("sinkAddColumns"));
15717 }
15718 sink_add_columns__ = Some(
15719 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15720 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15721 );
15722 }
15723 }
15724 }
15725 Ok(UpdateMutation {
15726 dispatcher_update: dispatcher_update__.unwrap_or_default(),
15727 merge_update: merge_update__.unwrap_or_default(),
15728 actor_vnode_bitmap_update: actor_vnode_bitmap_update__.unwrap_or_default(),
15729 dropped_actors: dropped_actors__.unwrap_or_default(),
15730 actor_splits: actor_splits__.unwrap_or_default(),
15731 actor_new_dispatchers: actor_new_dispatchers__.unwrap_or_default(),
15732 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
15733 sink_add_columns: sink_add_columns__.unwrap_or_default(),
15734 })
15735 }
15736 }
15737 deserializer.deserialize_struct("stream_plan.UpdateMutation", FIELDS, GeneratedVisitor)
15738 }
15739}
15740impl serde::Serialize for update_mutation::DispatcherUpdate {
15741 #[allow(deprecated)]
15742 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15743 where
15744 S: serde::Serializer,
15745 {
15746 use serde::ser::SerializeStruct;
15747 let mut len = 0;
15748 if self.actor_id != 0 {
15749 len += 1;
15750 }
15751 if self.dispatcher_id != 0 {
15752 len += 1;
15753 }
15754 if self.hash_mapping.is_some() {
15755 len += 1;
15756 }
15757 if !self.added_downstream_actor_id.is_empty() {
15758 len += 1;
15759 }
15760 if !self.removed_downstream_actor_id.is_empty() {
15761 len += 1;
15762 }
15763 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", len)?;
15764 if self.actor_id != 0 {
15765 struct_ser.serialize_field("actorId", &self.actor_id)?;
15766 }
15767 if self.dispatcher_id != 0 {
15768 #[allow(clippy::needless_borrow)]
15769 #[allow(clippy::needless_borrows_for_generic_args)]
15770 struct_ser.serialize_field("dispatcherId", ToString::to_string(&self.dispatcher_id).as_str())?;
15771 }
15772 if let Some(v) = self.hash_mapping.as_ref() {
15773 struct_ser.serialize_field("hashMapping", v)?;
15774 }
15775 if !self.added_downstream_actor_id.is_empty() {
15776 struct_ser.serialize_field("addedDownstreamActorId", &self.added_downstream_actor_id)?;
15777 }
15778 if !self.removed_downstream_actor_id.is_empty() {
15779 struct_ser.serialize_field("removedDownstreamActorId", &self.removed_downstream_actor_id)?;
15780 }
15781 struct_ser.end()
15782 }
15783}
15784impl<'de> serde::Deserialize<'de> for update_mutation::DispatcherUpdate {
15785 #[allow(deprecated)]
15786 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15787 where
15788 D: serde::Deserializer<'de>,
15789 {
15790 const FIELDS: &[&str] = &[
15791 "actor_id",
15792 "actorId",
15793 "dispatcher_id",
15794 "dispatcherId",
15795 "hash_mapping",
15796 "hashMapping",
15797 "added_downstream_actor_id",
15798 "addedDownstreamActorId",
15799 "removed_downstream_actor_id",
15800 "removedDownstreamActorId",
15801 ];
15802
15803 #[allow(clippy::enum_variant_names)]
15804 enum GeneratedField {
15805 ActorId,
15806 DispatcherId,
15807 HashMapping,
15808 AddedDownstreamActorId,
15809 RemovedDownstreamActorId,
15810 }
15811 impl<'de> serde::Deserialize<'de> for GeneratedField {
15812 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15813 where
15814 D: serde::Deserializer<'de>,
15815 {
15816 struct GeneratedVisitor;
15817
15818 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15819 type Value = GeneratedField;
15820
15821 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15822 write!(formatter, "expected one of: {:?}", &FIELDS)
15823 }
15824
15825 #[allow(unused_variables)]
15826 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15827 where
15828 E: serde::de::Error,
15829 {
15830 match value {
15831 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
15832 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
15833 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
15834 "addedDownstreamActorId" | "added_downstream_actor_id" => Ok(GeneratedField::AddedDownstreamActorId),
15835 "removedDownstreamActorId" | "removed_downstream_actor_id" => Ok(GeneratedField::RemovedDownstreamActorId),
15836 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15837 }
15838 }
15839 }
15840 deserializer.deserialize_identifier(GeneratedVisitor)
15841 }
15842 }
15843 struct GeneratedVisitor;
15844 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15845 type Value = update_mutation::DispatcherUpdate;
15846
15847 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15848 formatter.write_str("struct stream_plan.UpdateMutation.DispatcherUpdate")
15849 }
15850
15851 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::DispatcherUpdate, V::Error>
15852 where
15853 V: serde::de::MapAccess<'de>,
15854 {
15855 let mut actor_id__ = None;
15856 let mut dispatcher_id__ = None;
15857 let mut hash_mapping__ = None;
15858 let mut added_downstream_actor_id__ = None;
15859 let mut removed_downstream_actor_id__ = None;
15860 while let Some(k) = map_.next_key()? {
15861 match k {
15862 GeneratedField::ActorId => {
15863 if actor_id__.is_some() {
15864 return Err(serde::de::Error::duplicate_field("actorId"));
15865 }
15866 actor_id__ =
15867 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15868 ;
15869 }
15870 GeneratedField::DispatcherId => {
15871 if dispatcher_id__.is_some() {
15872 return Err(serde::de::Error::duplicate_field("dispatcherId"));
15873 }
15874 dispatcher_id__ =
15875 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15876 ;
15877 }
15878 GeneratedField::HashMapping => {
15879 if hash_mapping__.is_some() {
15880 return Err(serde::de::Error::duplicate_field("hashMapping"));
15881 }
15882 hash_mapping__ = map_.next_value()?;
15883 }
15884 GeneratedField::AddedDownstreamActorId => {
15885 if added_downstream_actor_id__.is_some() {
15886 return Err(serde::de::Error::duplicate_field("addedDownstreamActorId"));
15887 }
15888 added_downstream_actor_id__ =
15889 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15890 .into_iter().map(|x| x.0).collect())
15891 ;
15892 }
15893 GeneratedField::RemovedDownstreamActorId => {
15894 if removed_downstream_actor_id__.is_some() {
15895 return Err(serde::de::Error::duplicate_field("removedDownstreamActorId"));
15896 }
15897 removed_downstream_actor_id__ =
15898 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15899 .into_iter().map(|x| x.0).collect())
15900 ;
15901 }
15902 }
15903 }
15904 Ok(update_mutation::DispatcherUpdate {
15905 actor_id: actor_id__.unwrap_or_default(),
15906 dispatcher_id: dispatcher_id__.unwrap_or_default(),
15907 hash_mapping: hash_mapping__,
15908 added_downstream_actor_id: added_downstream_actor_id__.unwrap_or_default(),
15909 removed_downstream_actor_id: removed_downstream_actor_id__.unwrap_or_default(),
15910 })
15911 }
15912 }
15913 deserializer.deserialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", FIELDS, GeneratedVisitor)
15914 }
15915}
15916impl serde::Serialize for update_mutation::MergeUpdate {
15917 #[allow(deprecated)]
15918 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15919 where
15920 S: serde::Serializer,
15921 {
15922 use serde::ser::SerializeStruct;
15923 let mut len = 0;
15924 if self.actor_id != 0 {
15925 len += 1;
15926 }
15927 if self.upstream_fragment_id != 0 {
15928 len += 1;
15929 }
15930 if self.new_upstream_fragment_id.is_some() {
15931 len += 1;
15932 }
15933 if !self.added_upstream_actors.is_empty() {
15934 len += 1;
15935 }
15936 if !self.removed_upstream_actor_id.is_empty() {
15937 len += 1;
15938 }
15939 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.MergeUpdate", len)?;
15940 if self.actor_id != 0 {
15941 struct_ser.serialize_field("actorId", &self.actor_id)?;
15942 }
15943 if self.upstream_fragment_id != 0 {
15944 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
15945 }
15946 if let Some(v) = self.new_upstream_fragment_id.as_ref() {
15947 struct_ser.serialize_field("newUpstreamFragmentId", v)?;
15948 }
15949 if !self.added_upstream_actors.is_empty() {
15950 struct_ser.serialize_field("addedUpstreamActors", &self.added_upstream_actors)?;
15951 }
15952 if !self.removed_upstream_actor_id.is_empty() {
15953 struct_ser.serialize_field("removedUpstreamActorId", &self.removed_upstream_actor_id)?;
15954 }
15955 struct_ser.end()
15956 }
15957}
15958impl<'de> serde::Deserialize<'de> for update_mutation::MergeUpdate {
15959 #[allow(deprecated)]
15960 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15961 where
15962 D: serde::Deserializer<'de>,
15963 {
15964 const FIELDS: &[&str] = &[
15965 "actor_id",
15966 "actorId",
15967 "upstream_fragment_id",
15968 "upstreamFragmentId",
15969 "new_upstream_fragment_id",
15970 "newUpstreamFragmentId",
15971 "added_upstream_actors",
15972 "addedUpstreamActors",
15973 "removed_upstream_actor_id",
15974 "removedUpstreamActorId",
15975 ];
15976
15977 #[allow(clippy::enum_variant_names)]
15978 enum GeneratedField {
15979 ActorId,
15980 UpstreamFragmentId,
15981 NewUpstreamFragmentId,
15982 AddedUpstreamActors,
15983 RemovedUpstreamActorId,
15984 }
15985 impl<'de> serde::Deserialize<'de> for GeneratedField {
15986 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15987 where
15988 D: serde::Deserializer<'de>,
15989 {
15990 struct GeneratedVisitor;
15991
15992 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15993 type Value = GeneratedField;
15994
15995 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15996 write!(formatter, "expected one of: {:?}", &FIELDS)
15997 }
15998
15999 #[allow(unused_variables)]
16000 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16001 where
16002 E: serde::de::Error,
16003 {
16004 match value {
16005 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
16006 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
16007 "newUpstreamFragmentId" | "new_upstream_fragment_id" => Ok(GeneratedField::NewUpstreamFragmentId),
16008 "addedUpstreamActors" | "added_upstream_actors" => Ok(GeneratedField::AddedUpstreamActors),
16009 "removedUpstreamActorId" | "removed_upstream_actor_id" => Ok(GeneratedField::RemovedUpstreamActorId),
16010 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16011 }
16012 }
16013 }
16014 deserializer.deserialize_identifier(GeneratedVisitor)
16015 }
16016 }
16017 struct GeneratedVisitor;
16018 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16019 type Value = update_mutation::MergeUpdate;
16020
16021 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16022 formatter.write_str("struct stream_plan.UpdateMutation.MergeUpdate")
16023 }
16024
16025 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::MergeUpdate, V::Error>
16026 where
16027 V: serde::de::MapAccess<'de>,
16028 {
16029 let mut actor_id__ = None;
16030 let mut upstream_fragment_id__ = None;
16031 let mut new_upstream_fragment_id__ = None;
16032 let mut added_upstream_actors__ = None;
16033 let mut removed_upstream_actor_id__ = None;
16034 while let Some(k) = map_.next_key()? {
16035 match k {
16036 GeneratedField::ActorId => {
16037 if actor_id__.is_some() {
16038 return Err(serde::de::Error::duplicate_field("actorId"));
16039 }
16040 actor_id__ =
16041 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16042 ;
16043 }
16044 GeneratedField::UpstreamFragmentId => {
16045 if upstream_fragment_id__.is_some() {
16046 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
16047 }
16048 upstream_fragment_id__ =
16049 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16050 ;
16051 }
16052 GeneratedField::NewUpstreamFragmentId => {
16053 if new_upstream_fragment_id__.is_some() {
16054 return Err(serde::de::Error::duplicate_field("newUpstreamFragmentId"));
16055 }
16056 new_upstream_fragment_id__ =
16057 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16058 ;
16059 }
16060 GeneratedField::AddedUpstreamActors => {
16061 if added_upstream_actors__.is_some() {
16062 return Err(serde::de::Error::duplicate_field("addedUpstreamActors"));
16063 }
16064 added_upstream_actors__ = Some(map_.next_value()?);
16065 }
16066 GeneratedField::RemovedUpstreamActorId => {
16067 if removed_upstream_actor_id__.is_some() {
16068 return Err(serde::de::Error::duplicate_field("removedUpstreamActorId"));
16069 }
16070 removed_upstream_actor_id__ =
16071 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16072 .into_iter().map(|x| x.0).collect())
16073 ;
16074 }
16075 }
16076 }
16077 Ok(update_mutation::MergeUpdate {
16078 actor_id: actor_id__.unwrap_or_default(),
16079 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
16080 new_upstream_fragment_id: new_upstream_fragment_id__,
16081 added_upstream_actors: added_upstream_actors__.unwrap_or_default(),
16082 removed_upstream_actor_id: removed_upstream_actor_id__.unwrap_or_default(),
16083 })
16084 }
16085 }
16086 deserializer.deserialize_struct("stream_plan.UpdateMutation.MergeUpdate", FIELDS, GeneratedVisitor)
16087 }
16088}
16089impl serde::Serialize for UpstreamSinkInfo {
16090 #[allow(deprecated)]
16091 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16092 where
16093 S: serde::Serializer,
16094 {
16095 use serde::ser::SerializeStruct;
16096 let mut len = 0;
16097 if self.upstream_fragment_id != 0 {
16098 len += 1;
16099 }
16100 if !self.sink_output_schema.is_empty() {
16101 len += 1;
16102 }
16103 if !self.project_exprs.is_empty() {
16104 len += 1;
16105 }
16106 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkInfo", len)?;
16107 if self.upstream_fragment_id != 0 {
16108 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
16109 }
16110 if !self.sink_output_schema.is_empty() {
16111 struct_ser.serialize_field("sinkOutputSchema", &self.sink_output_schema)?;
16112 }
16113 if !self.project_exprs.is_empty() {
16114 struct_ser.serialize_field("projectExprs", &self.project_exprs)?;
16115 }
16116 struct_ser.end()
16117 }
16118}
16119impl<'de> serde::Deserialize<'de> for UpstreamSinkInfo {
16120 #[allow(deprecated)]
16121 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16122 where
16123 D: serde::Deserializer<'de>,
16124 {
16125 const FIELDS: &[&str] = &[
16126 "upstream_fragment_id",
16127 "upstreamFragmentId",
16128 "sink_output_schema",
16129 "sinkOutputSchema",
16130 "project_exprs",
16131 "projectExprs",
16132 ];
16133
16134 #[allow(clippy::enum_variant_names)]
16135 enum GeneratedField {
16136 UpstreamFragmentId,
16137 SinkOutputSchema,
16138 ProjectExprs,
16139 }
16140 impl<'de> serde::Deserialize<'de> for GeneratedField {
16141 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16142 where
16143 D: serde::Deserializer<'de>,
16144 {
16145 struct GeneratedVisitor;
16146
16147 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16148 type Value = GeneratedField;
16149
16150 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16151 write!(formatter, "expected one of: {:?}", &FIELDS)
16152 }
16153
16154 #[allow(unused_variables)]
16155 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16156 where
16157 E: serde::de::Error,
16158 {
16159 match value {
16160 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
16161 "sinkOutputSchema" | "sink_output_schema" => Ok(GeneratedField::SinkOutputSchema),
16162 "projectExprs" | "project_exprs" => Ok(GeneratedField::ProjectExprs),
16163 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16164 }
16165 }
16166 }
16167 deserializer.deserialize_identifier(GeneratedVisitor)
16168 }
16169 }
16170 struct GeneratedVisitor;
16171 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16172 type Value = UpstreamSinkInfo;
16173
16174 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16175 formatter.write_str("struct stream_plan.UpstreamSinkInfo")
16176 }
16177
16178 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkInfo, V::Error>
16179 where
16180 V: serde::de::MapAccess<'de>,
16181 {
16182 let mut upstream_fragment_id__ = None;
16183 let mut sink_output_schema__ = None;
16184 let mut project_exprs__ = None;
16185 while let Some(k) = map_.next_key()? {
16186 match k {
16187 GeneratedField::UpstreamFragmentId => {
16188 if upstream_fragment_id__.is_some() {
16189 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
16190 }
16191 upstream_fragment_id__ =
16192 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16193 ;
16194 }
16195 GeneratedField::SinkOutputSchema => {
16196 if sink_output_schema__.is_some() {
16197 return Err(serde::de::Error::duplicate_field("sinkOutputSchema"));
16198 }
16199 sink_output_schema__ = Some(map_.next_value()?);
16200 }
16201 GeneratedField::ProjectExprs => {
16202 if project_exprs__.is_some() {
16203 return Err(serde::de::Error::duplicate_field("projectExprs"));
16204 }
16205 project_exprs__ = Some(map_.next_value()?);
16206 }
16207 }
16208 }
16209 Ok(UpstreamSinkInfo {
16210 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
16211 sink_output_schema: sink_output_schema__.unwrap_or_default(),
16212 project_exprs: project_exprs__.unwrap_or_default(),
16213 })
16214 }
16215 }
16216 deserializer.deserialize_struct("stream_plan.UpstreamSinkInfo", FIELDS, GeneratedVisitor)
16217 }
16218}
16219impl serde::Serialize for UpstreamSinkUnionNode {
16220 #[allow(deprecated)]
16221 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16222 where
16223 S: serde::Serializer,
16224 {
16225 use serde::ser::SerializeStruct;
16226 let mut len = 0;
16227 if !self.init_upstreams.is_empty() {
16228 len += 1;
16229 }
16230 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkUnionNode", len)?;
16231 if !self.init_upstreams.is_empty() {
16232 struct_ser.serialize_field("initUpstreams", &self.init_upstreams)?;
16233 }
16234 struct_ser.end()
16235 }
16236}
16237impl<'de> serde::Deserialize<'de> for UpstreamSinkUnionNode {
16238 #[allow(deprecated)]
16239 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16240 where
16241 D: serde::Deserializer<'de>,
16242 {
16243 const FIELDS: &[&str] = &[
16244 "init_upstreams",
16245 "initUpstreams",
16246 ];
16247
16248 #[allow(clippy::enum_variant_names)]
16249 enum GeneratedField {
16250 InitUpstreams,
16251 }
16252 impl<'de> serde::Deserialize<'de> for GeneratedField {
16253 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16254 where
16255 D: serde::Deserializer<'de>,
16256 {
16257 struct GeneratedVisitor;
16258
16259 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16260 type Value = GeneratedField;
16261
16262 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16263 write!(formatter, "expected one of: {:?}", &FIELDS)
16264 }
16265
16266 #[allow(unused_variables)]
16267 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16268 where
16269 E: serde::de::Error,
16270 {
16271 match value {
16272 "initUpstreams" | "init_upstreams" => Ok(GeneratedField::InitUpstreams),
16273 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16274 }
16275 }
16276 }
16277 deserializer.deserialize_identifier(GeneratedVisitor)
16278 }
16279 }
16280 struct GeneratedVisitor;
16281 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16282 type Value = UpstreamSinkUnionNode;
16283
16284 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16285 formatter.write_str("struct stream_plan.UpstreamSinkUnionNode")
16286 }
16287
16288 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkUnionNode, V::Error>
16289 where
16290 V: serde::de::MapAccess<'de>,
16291 {
16292 let mut init_upstreams__ = None;
16293 while let Some(k) = map_.next_key()? {
16294 match k {
16295 GeneratedField::InitUpstreams => {
16296 if init_upstreams__.is_some() {
16297 return Err(serde::de::Error::duplicate_field("initUpstreams"));
16298 }
16299 init_upstreams__ = Some(map_.next_value()?);
16300 }
16301 }
16302 }
16303 Ok(UpstreamSinkUnionNode {
16304 init_upstreams: init_upstreams__.unwrap_or_default(),
16305 })
16306 }
16307 }
16308 deserializer.deserialize_struct("stream_plan.UpstreamSinkUnionNode", FIELDS, GeneratedVisitor)
16309 }
16310}
16311impl serde::Serialize for ValuesNode {
16312 #[allow(deprecated)]
16313 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16314 where
16315 S: serde::Serializer,
16316 {
16317 use serde::ser::SerializeStruct;
16318 let mut len = 0;
16319 if !self.tuples.is_empty() {
16320 len += 1;
16321 }
16322 if !self.fields.is_empty() {
16323 len += 1;
16324 }
16325 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode", len)?;
16326 if !self.tuples.is_empty() {
16327 struct_ser.serialize_field("tuples", &self.tuples)?;
16328 }
16329 if !self.fields.is_empty() {
16330 struct_ser.serialize_field("fields", &self.fields)?;
16331 }
16332 struct_ser.end()
16333 }
16334}
16335impl<'de> serde::Deserialize<'de> for ValuesNode {
16336 #[allow(deprecated)]
16337 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16338 where
16339 D: serde::Deserializer<'de>,
16340 {
16341 const FIELDS: &[&str] = &[
16342 "tuples",
16343 "fields",
16344 ];
16345
16346 #[allow(clippy::enum_variant_names)]
16347 enum GeneratedField {
16348 Tuples,
16349 Fields,
16350 }
16351 impl<'de> serde::Deserialize<'de> for GeneratedField {
16352 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16353 where
16354 D: serde::Deserializer<'de>,
16355 {
16356 struct GeneratedVisitor;
16357
16358 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16359 type Value = GeneratedField;
16360
16361 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16362 write!(formatter, "expected one of: {:?}", &FIELDS)
16363 }
16364
16365 #[allow(unused_variables)]
16366 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16367 where
16368 E: serde::de::Error,
16369 {
16370 match value {
16371 "tuples" => Ok(GeneratedField::Tuples),
16372 "fields" => Ok(GeneratedField::Fields),
16373 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16374 }
16375 }
16376 }
16377 deserializer.deserialize_identifier(GeneratedVisitor)
16378 }
16379 }
16380 struct GeneratedVisitor;
16381 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16382 type Value = ValuesNode;
16383
16384 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16385 formatter.write_str("struct stream_plan.ValuesNode")
16386 }
16387
16388 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
16389 where
16390 V: serde::de::MapAccess<'de>,
16391 {
16392 let mut tuples__ = None;
16393 let mut fields__ = None;
16394 while let Some(k) = map_.next_key()? {
16395 match k {
16396 GeneratedField::Tuples => {
16397 if tuples__.is_some() {
16398 return Err(serde::de::Error::duplicate_field("tuples"));
16399 }
16400 tuples__ = Some(map_.next_value()?);
16401 }
16402 GeneratedField::Fields => {
16403 if fields__.is_some() {
16404 return Err(serde::de::Error::duplicate_field("fields"));
16405 }
16406 fields__ = Some(map_.next_value()?);
16407 }
16408 }
16409 }
16410 Ok(ValuesNode {
16411 tuples: tuples__.unwrap_or_default(),
16412 fields: fields__.unwrap_or_default(),
16413 })
16414 }
16415 }
16416 deserializer.deserialize_struct("stream_plan.ValuesNode", FIELDS, GeneratedVisitor)
16417 }
16418}
16419impl serde::Serialize for values_node::ExprTuple {
16420 #[allow(deprecated)]
16421 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16422 where
16423 S: serde::Serializer,
16424 {
16425 use serde::ser::SerializeStruct;
16426 let mut len = 0;
16427 if !self.cells.is_empty() {
16428 len += 1;
16429 }
16430 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode.ExprTuple", len)?;
16431 if !self.cells.is_empty() {
16432 struct_ser.serialize_field("cells", &self.cells)?;
16433 }
16434 struct_ser.end()
16435 }
16436}
16437impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
16438 #[allow(deprecated)]
16439 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16440 where
16441 D: serde::Deserializer<'de>,
16442 {
16443 const FIELDS: &[&str] = &[
16444 "cells",
16445 ];
16446
16447 #[allow(clippy::enum_variant_names)]
16448 enum GeneratedField {
16449 Cells,
16450 }
16451 impl<'de> serde::Deserialize<'de> for GeneratedField {
16452 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16453 where
16454 D: serde::Deserializer<'de>,
16455 {
16456 struct GeneratedVisitor;
16457
16458 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16459 type Value = GeneratedField;
16460
16461 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16462 write!(formatter, "expected one of: {:?}", &FIELDS)
16463 }
16464
16465 #[allow(unused_variables)]
16466 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16467 where
16468 E: serde::de::Error,
16469 {
16470 match value {
16471 "cells" => Ok(GeneratedField::Cells),
16472 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16473 }
16474 }
16475 }
16476 deserializer.deserialize_identifier(GeneratedVisitor)
16477 }
16478 }
16479 struct GeneratedVisitor;
16480 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16481 type Value = values_node::ExprTuple;
16482
16483 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16484 formatter.write_str("struct stream_plan.ValuesNode.ExprTuple")
16485 }
16486
16487 fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
16488 where
16489 V: serde::de::MapAccess<'de>,
16490 {
16491 let mut cells__ = None;
16492 while let Some(k) = map_.next_key()? {
16493 match k {
16494 GeneratedField::Cells => {
16495 if cells__.is_some() {
16496 return Err(serde::de::Error::duplicate_field("cells"));
16497 }
16498 cells__ = Some(map_.next_value()?);
16499 }
16500 }
16501 }
16502 Ok(values_node::ExprTuple {
16503 cells: cells__.unwrap_or_default(),
16504 })
16505 }
16506 }
16507 deserializer.deserialize_struct("stream_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
16508 }
16509}
16510impl serde::Serialize for VectorIndexLookupJoinNode {
16511 #[allow(deprecated)]
16512 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16513 where
16514 S: serde::Serializer,
16515 {
16516 use serde::ser::SerializeStruct;
16517 let mut len = 0;
16518 if self.reader_desc.is_some() {
16519 len += 1;
16520 }
16521 if self.vector_column_idx != 0 {
16522 len += 1;
16523 }
16524 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexLookupJoinNode", len)?;
16525 if let Some(v) = self.reader_desc.as_ref() {
16526 struct_ser.serialize_field("readerDesc", v)?;
16527 }
16528 if self.vector_column_idx != 0 {
16529 struct_ser.serialize_field("vectorColumnIdx", &self.vector_column_idx)?;
16530 }
16531 struct_ser.end()
16532 }
16533}
16534impl<'de> serde::Deserialize<'de> for VectorIndexLookupJoinNode {
16535 #[allow(deprecated)]
16536 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16537 where
16538 D: serde::Deserializer<'de>,
16539 {
16540 const FIELDS: &[&str] = &[
16541 "reader_desc",
16542 "readerDesc",
16543 "vector_column_idx",
16544 "vectorColumnIdx",
16545 ];
16546
16547 #[allow(clippy::enum_variant_names)]
16548 enum GeneratedField {
16549 ReaderDesc,
16550 VectorColumnIdx,
16551 }
16552 impl<'de> serde::Deserialize<'de> for GeneratedField {
16553 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16554 where
16555 D: serde::Deserializer<'de>,
16556 {
16557 struct GeneratedVisitor;
16558
16559 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16560 type Value = GeneratedField;
16561
16562 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16563 write!(formatter, "expected one of: {:?}", &FIELDS)
16564 }
16565
16566 #[allow(unused_variables)]
16567 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16568 where
16569 E: serde::de::Error,
16570 {
16571 match value {
16572 "readerDesc" | "reader_desc" => Ok(GeneratedField::ReaderDesc),
16573 "vectorColumnIdx" | "vector_column_idx" => Ok(GeneratedField::VectorColumnIdx),
16574 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16575 }
16576 }
16577 }
16578 deserializer.deserialize_identifier(GeneratedVisitor)
16579 }
16580 }
16581 struct GeneratedVisitor;
16582 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16583 type Value = VectorIndexLookupJoinNode;
16584
16585 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16586 formatter.write_str("struct stream_plan.VectorIndexLookupJoinNode")
16587 }
16588
16589 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexLookupJoinNode, V::Error>
16590 where
16591 V: serde::de::MapAccess<'de>,
16592 {
16593 let mut reader_desc__ = None;
16594 let mut vector_column_idx__ = None;
16595 while let Some(k) = map_.next_key()? {
16596 match k {
16597 GeneratedField::ReaderDesc => {
16598 if reader_desc__.is_some() {
16599 return Err(serde::de::Error::duplicate_field("readerDesc"));
16600 }
16601 reader_desc__ = map_.next_value()?;
16602 }
16603 GeneratedField::VectorColumnIdx => {
16604 if vector_column_idx__.is_some() {
16605 return Err(serde::de::Error::duplicate_field("vectorColumnIdx"));
16606 }
16607 vector_column_idx__ =
16608 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16609 ;
16610 }
16611 }
16612 }
16613 Ok(VectorIndexLookupJoinNode {
16614 reader_desc: reader_desc__,
16615 vector_column_idx: vector_column_idx__.unwrap_or_default(),
16616 })
16617 }
16618 }
16619 deserializer.deserialize_struct("stream_plan.VectorIndexLookupJoinNode", FIELDS, GeneratedVisitor)
16620 }
16621}
16622impl serde::Serialize for VectorIndexWriteNode {
16623 #[allow(deprecated)]
16624 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16625 where
16626 S: serde::Serializer,
16627 {
16628 use serde::ser::SerializeStruct;
16629 let mut len = 0;
16630 if self.table.is_some() {
16631 len += 1;
16632 }
16633 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexWriteNode", len)?;
16634 if let Some(v) = self.table.as_ref() {
16635 struct_ser.serialize_field("table", v)?;
16636 }
16637 struct_ser.end()
16638 }
16639}
16640impl<'de> serde::Deserialize<'de> for VectorIndexWriteNode {
16641 #[allow(deprecated)]
16642 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16643 where
16644 D: serde::Deserializer<'de>,
16645 {
16646 const FIELDS: &[&str] = &[
16647 "table",
16648 ];
16649
16650 #[allow(clippy::enum_variant_names)]
16651 enum GeneratedField {
16652 Table,
16653 }
16654 impl<'de> serde::Deserialize<'de> for GeneratedField {
16655 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16656 where
16657 D: serde::Deserializer<'de>,
16658 {
16659 struct GeneratedVisitor;
16660
16661 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16662 type Value = GeneratedField;
16663
16664 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16665 write!(formatter, "expected one of: {:?}", &FIELDS)
16666 }
16667
16668 #[allow(unused_variables)]
16669 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16670 where
16671 E: serde::de::Error,
16672 {
16673 match value {
16674 "table" => Ok(GeneratedField::Table),
16675 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16676 }
16677 }
16678 }
16679 deserializer.deserialize_identifier(GeneratedVisitor)
16680 }
16681 }
16682 struct GeneratedVisitor;
16683 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16684 type Value = VectorIndexWriteNode;
16685
16686 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16687 formatter.write_str("struct stream_plan.VectorIndexWriteNode")
16688 }
16689
16690 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexWriteNode, V::Error>
16691 where
16692 V: serde::de::MapAccess<'de>,
16693 {
16694 let mut table__ = None;
16695 while let Some(k) = map_.next_key()? {
16696 match k {
16697 GeneratedField::Table => {
16698 if table__.is_some() {
16699 return Err(serde::de::Error::duplicate_field("table"));
16700 }
16701 table__ = map_.next_value()?;
16702 }
16703 }
16704 }
16705 Ok(VectorIndexWriteNode {
16706 table: table__,
16707 })
16708 }
16709 }
16710 deserializer.deserialize_struct("stream_plan.VectorIndexWriteNode", FIELDS, GeneratedVisitor)
16711 }
16712}
16713impl serde::Serialize for Watermark {
16714 #[allow(deprecated)]
16715 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16716 where
16717 S: serde::Serializer,
16718 {
16719 use serde::ser::SerializeStruct;
16720 let mut len = 0;
16721 if self.column.is_some() {
16722 len += 1;
16723 }
16724 if self.val.is_some() {
16725 len += 1;
16726 }
16727 let mut struct_ser = serializer.serialize_struct("stream_plan.Watermark", len)?;
16728 if let Some(v) = self.column.as_ref() {
16729 struct_ser.serialize_field("column", v)?;
16730 }
16731 if let Some(v) = self.val.as_ref() {
16732 struct_ser.serialize_field("val", v)?;
16733 }
16734 struct_ser.end()
16735 }
16736}
16737impl<'de> serde::Deserialize<'de> for Watermark {
16738 #[allow(deprecated)]
16739 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16740 where
16741 D: serde::Deserializer<'de>,
16742 {
16743 const FIELDS: &[&str] = &[
16744 "column",
16745 "val",
16746 ];
16747
16748 #[allow(clippy::enum_variant_names)]
16749 enum GeneratedField {
16750 Column,
16751 Val,
16752 }
16753 impl<'de> serde::Deserialize<'de> for GeneratedField {
16754 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16755 where
16756 D: serde::Deserializer<'de>,
16757 {
16758 struct GeneratedVisitor;
16759
16760 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16761 type Value = GeneratedField;
16762
16763 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16764 write!(formatter, "expected one of: {:?}", &FIELDS)
16765 }
16766
16767 #[allow(unused_variables)]
16768 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16769 where
16770 E: serde::de::Error,
16771 {
16772 match value {
16773 "column" => Ok(GeneratedField::Column),
16774 "val" => Ok(GeneratedField::Val),
16775 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16776 }
16777 }
16778 }
16779 deserializer.deserialize_identifier(GeneratedVisitor)
16780 }
16781 }
16782 struct GeneratedVisitor;
16783 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16784 type Value = Watermark;
16785
16786 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16787 formatter.write_str("struct stream_plan.Watermark")
16788 }
16789
16790 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Watermark, V::Error>
16791 where
16792 V: serde::de::MapAccess<'de>,
16793 {
16794 let mut column__ = None;
16795 let mut val__ = None;
16796 while let Some(k) = map_.next_key()? {
16797 match k {
16798 GeneratedField::Column => {
16799 if column__.is_some() {
16800 return Err(serde::de::Error::duplicate_field("column"));
16801 }
16802 column__ = map_.next_value()?;
16803 }
16804 GeneratedField::Val => {
16805 if val__.is_some() {
16806 return Err(serde::de::Error::duplicate_field("val"));
16807 }
16808 val__ = map_.next_value()?;
16809 }
16810 }
16811 }
16812 Ok(Watermark {
16813 column: column__,
16814 val: val__,
16815 })
16816 }
16817 }
16818 deserializer.deserialize_struct("stream_plan.Watermark", FIELDS, GeneratedVisitor)
16819 }
16820}
16821impl serde::Serialize for WatermarkFilterNode {
16822 #[allow(deprecated)]
16823 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16824 where
16825 S: serde::Serializer,
16826 {
16827 use serde::ser::SerializeStruct;
16828 let mut len = 0;
16829 if !self.watermark_descs.is_empty() {
16830 len += 1;
16831 }
16832 if !self.tables.is_empty() {
16833 len += 1;
16834 }
16835 let mut struct_ser = serializer.serialize_struct("stream_plan.WatermarkFilterNode", len)?;
16836 if !self.watermark_descs.is_empty() {
16837 struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
16838 }
16839 if !self.tables.is_empty() {
16840 struct_ser.serialize_field("tables", &self.tables)?;
16841 }
16842 struct_ser.end()
16843 }
16844}
16845impl<'de> serde::Deserialize<'de> for WatermarkFilterNode {
16846 #[allow(deprecated)]
16847 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16848 where
16849 D: serde::Deserializer<'de>,
16850 {
16851 const FIELDS: &[&str] = &[
16852 "watermark_descs",
16853 "watermarkDescs",
16854 "tables",
16855 ];
16856
16857 #[allow(clippy::enum_variant_names)]
16858 enum GeneratedField {
16859 WatermarkDescs,
16860 Tables,
16861 }
16862 impl<'de> serde::Deserialize<'de> for GeneratedField {
16863 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16864 where
16865 D: serde::Deserializer<'de>,
16866 {
16867 struct GeneratedVisitor;
16868
16869 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16870 type Value = GeneratedField;
16871
16872 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16873 write!(formatter, "expected one of: {:?}", &FIELDS)
16874 }
16875
16876 #[allow(unused_variables)]
16877 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16878 where
16879 E: serde::de::Error,
16880 {
16881 match value {
16882 "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
16883 "tables" => Ok(GeneratedField::Tables),
16884 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16885 }
16886 }
16887 }
16888 deserializer.deserialize_identifier(GeneratedVisitor)
16889 }
16890 }
16891 struct GeneratedVisitor;
16892 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16893 type Value = WatermarkFilterNode;
16894
16895 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16896 formatter.write_str("struct stream_plan.WatermarkFilterNode")
16897 }
16898
16899 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkFilterNode, V::Error>
16900 where
16901 V: serde::de::MapAccess<'de>,
16902 {
16903 let mut watermark_descs__ = None;
16904 let mut tables__ = None;
16905 while let Some(k) = map_.next_key()? {
16906 match k {
16907 GeneratedField::WatermarkDescs => {
16908 if watermark_descs__.is_some() {
16909 return Err(serde::de::Error::duplicate_field("watermarkDescs"));
16910 }
16911 watermark_descs__ = Some(map_.next_value()?);
16912 }
16913 GeneratedField::Tables => {
16914 if tables__.is_some() {
16915 return Err(serde::de::Error::duplicate_field("tables"));
16916 }
16917 tables__ = Some(map_.next_value()?);
16918 }
16919 }
16920 }
16921 Ok(WatermarkFilterNode {
16922 watermark_descs: watermark_descs__.unwrap_or_default(),
16923 tables: tables__.unwrap_or_default(),
16924 })
16925 }
16926 }
16927 deserializer.deserialize_struct("stream_plan.WatermarkFilterNode", FIELDS, GeneratedVisitor)
16928 }
16929}