1use crate::stream_plan::*;
2impl serde::Serialize for ActorMapping {
3 #[allow(deprecated)]
4 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5 where
6 S: serde::Serializer,
7 {
8 use serde::ser::SerializeStruct;
9 let mut len = 0;
10 if !self.original_indices.is_empty() {
11 len += 1;
12 }
13 if !self.data.is_empty() {
14 len += 1;
15 }
16 let mut struct_ser = serializer.serialize_struct("stream_plan.ActorMapping", len)?;
17 if !self.original_indices.is_empty() {
18 struct_ser.serialize_field("originalIndices", &self.original_indices)?;
19 }
20 if !self.data.is_empty() {
21 struct_ser.serialize_field("data", &self.data)?;
22 }
23 struct_ser.end()
24 }
25}
26impl<'de> serde::Deserialize<'de> for ActorMapping {
27 #[allow(deprecated)]
28 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
29 where
30 D: serde::Deserializer<'de>,
31 {
32 const FIELDS: &[&str] = &[
33 "original_indices",
34 "originalIndices",
35 "data",
36 ];
37
38 #[allow(clippy::enum_variant_names)]
39 enum GeneratedField {
40 OriginalIndices,
41 Data,
42 }
43 impl<'de> serde::Deserialize<'de> for GeneratedField {
44 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
45 where
46 D: serde::Deserializer<'de>,
47 {
48 struct GeneratedVisitor;
49
50 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
51 type Value = GeneratedField;
52
53 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
54 write!(formatter, "expected one of: {:?}", &FIELDS)
55 }
56
57 #[allow(unused_variables)]
58 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
59 where
60 E: serde::de::Error,
61 {
62 match value {
63 "originalIndices" | "original_indices" => Ok(GeneratedField::OriginalIndices),
64 "data" => Ok(GeneratedField::Data),
65 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
66 }
67 }
68 }
69 deserializer.deserialize_identifier(GeneratedVisitor)
70 }
71 }
72 struct GeneratedVisitor;
73 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
74 type Value = ActorMapping;
75
76 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
77 formatter.write_str("struct stream_plan.ActorMapping")
78 }
79
80 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorMapping, V::Error>
81 where
82 V: serde::de::MapAccess<'de>,
83 {
84 let mut original_indices__ = None;
85 let mut data__ = None;
86 while let Some(k) = map_.next_key()? {
87 match k {
88 GeneratedField::OriginalIndices => {
89 if original_indices__.is_some() {
90 return Err(serde::de::Error::duplicate_field("originalIndices"));
91 }
92 original_indices__ =
93 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
94 .into_iter().map(|x| x.0).collect())
95 ;
96 }
97 GeneratedField::Data => {
98 if data__.is_some() {
99 return Err(serde::de::Error::duplicate_field("data"));
100 }
101 data__ =
102 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
103 .into_iter().map(|x| x.0).collect())
104 ;
105 }
106 }
107 }
108 Ok(ActorMapping {
109 original_indices: original_indices__.unwrap_or_default(),
110 data: data__.unwrap_or_default(),
111 })
112 }
113 }
114 deserializer.deserialize_struct("stream_plan.ActorMapping", FIELDS, GeneratedVisitor)
115 }
116}
117impl serde::Serialize for AddMutation {
118 #[allow(deprecated)]
119 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
120 where
121 S: serde::Serializer,
122 {
123 use serde::ser::SerializeStruct;
124 let mut len = 0;
125 if !self.actor_dispatchers.is_empty() {
126 len += 1;
127 }
128 if !self.added_actors.is_empty() {
129 len += 1;
130 }
131 if !self.actor_splits.is_empty() {
132 len += 1;
133 }
134 if self.pause {
135 len += 1;
136 }
137 if !self.subscriptions_to_add.is_empty() {
138 len += 1;
139 }
140 if !self.backfill_nodes_to_pause.is_empty() {
141 len += 1;
142 }
143 if self.actor_cdc_table_snapshot_splits.is_some() {
144 len += 1;
145 }
146 if !self.new_upstream_sinks.is_empty() {
147 len += 1;
148 }
149 let mut struct_ser = serializer.serialize_struct("stream_plan.AddMutation", len)?;
150 if !self.actor_dispatchers.is_empty() {
151 struct_ser.serialize_field("actorDispatchers", &self.actor_dispatchers)?;
152 }
153 if !self.added_actors.is_empty() {
154 struct_ser.serialize_field("addedActors", &self.added_actors)?;
155 }
156 if !self.actor_splits.is_empty() {
157 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
158 }
159 if self.pause {
160 struct_ser.serialize_field("pause", &self.pause)?;
161 }
162 if !self.subscriptions_to_add.is_empty() {
163 struct_ser.serialize_field("subscriptionsToAdd", &self.subscriptions_to_add)?;
164 }
165 if !self.backfill_nodes_to_pause.is_empty() {
166 struct_ser.serialize_field("backfillNodesToPause", &self.backfill_nodes_to_pause)?;
167 }
168 if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
169 struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
170 }
171 if !self.new_upstream_sinks.is_empty() {
172 struct_ser.serialize_field("newUpstreamSinks", &self.new_upstream_sinks)?;
173 }
174 struct_ser.end()
175 }
176}
177impl<'de> serde::Deserialize<'de> for AddMutation {
178 #[allow(deprecated)]
179 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
180 where
181 D: serde::Deserializer<'de>,
182 {
183 const FIELDS: &[&str] = &[
184 "actor_dispatchers",
185 "actorDispatchers",
186 "added_actors",
187 "addedActors",
188 "actor_splits",
189 "actorSplits",
190 "pause",
191 "subscriptions_to_add",
192 "subscriptionsToAdd",
193 "backfill_nodes_to_pause",
194 "backfillNodesToPause",
195 "actor_cdc_table_snapshot_splits",
196 "actorCdcTableSnapshotSplits",
197 "new_upstream_sinks",
198 "newUpstreamSinks",
199 ];
200
201 #[allow(clippy::enum_variant_names)]
202 enum GeneratedField {
203 ActorDispatchers,
204 AddedActors,
205 ActorSplits,
206 Pause,
207 SubscriptionsToAdd,
208 BackfillNodesToPause,
209 ActorCdcTableSnapshotSplits,
210 NewUpstreamSinks,
211 }
212 impl<'de> serde::Deserialize<'de> for GeneratedField {
213 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
214 where
215 D: serde::Deserializer<'de>,
216 {
217 struct GeneratedVisitor;
218
219 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
220 type Value = GeneratedField;
221
222 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
223 write!(formatter, "expected one of: {:?}", &FIELDS)
224 }
225
226 #[allow(unused_variables)]
227 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
228 where
229 E: serde::de::Error,
230 {
231 match value {
232 "actorDispatchers" | "actor_dispatchers" => Ok(GeneratedField::ActorDispatchers),
233 "addedActors" | "added_actors" => Ok(GeneratedField::AddedActors),
234 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
235 "pause" => Ok(GeneratedField::Pause),
236 "subscriptionsToAdd" | "subscriptions_to_add" => Ok(GeneratedField::SubscriptionsToAdd),
237 "backfillNodesToPause" | "backfill_nodes_to_pause" => Ok(GeneratedField::BackfillNodesToPause),
238 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
239 "newUpstreamSinks" | "new_upstream_sinks" => Ok(GeneratedField::NewUpstreamSinks),
240 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
241 }
242 }
243 }
244 deserializer.deserialize_identifier(GeneratedVisitor)
245 }
246 }
247 struct GeneratedVisitor;
248 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
249 type Value = AddMutation;
250
251 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
252 formatter.write_str("struct stream_plan.AddMutation")
253 }
254
255 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddMutation, V::Error>
256 where
257 V: serde::de::MapAccess<'de>,
258 {
259 let mut actor_dispatchers__ = None;
260 let mut added_actors__ = None;
261 let mut actor_splits__ = None;
262 let mut pause__ = None;
263 let mut subscriptions_to_add__ = None;
264 let mut backfill_nodes_to_pause__ = None;
265 let mut actor_cdc_table_snapshot_splits__ = None;
266 let mut new_upstream_sinks__ = None;
267 while let Some(k) = map_.next_key()? {
268 match k {
269 GeneratedField::ActorDispatchers => {
270 if actor_dispatchers__.is_some() {
271 return Err(serde::de::Error::duplicate_field("actorDispatchers"));
272 }
273 actor_dispatchers__ = Some(
274 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
275 .into_iter().map(|(k,v)| (k.0, v)).collect()
276 );
277 }
278 GeneratedField::AddedActors => {
279 if added_actors__.is_some() {
280 return Err(serde::de::Error::duplicate_field("addedActors"));
281 }
282 added_actors__ =
283 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
284 .into_iter().map(|x| x.0).collect())
285 ;
286 }
287 GeneratedField::ActorSplits => {
288 if actor_splits__.is_some() {
289 return Err(serde::de::Error::duplicate_field("actorSplits"));
290 }
291 actor_splits__ = Some(
292 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
293 .into_iter().map(|(k,v)| (k.0, v)).collect()
294 );
295 }
296 GeneratedField::Pause => {
297 if pause__.is_some() {
298 return Err(serde::de::Error::duplicate_field("pause"));
299 }
300 pause__ = Some(map_.next_value()?);
301 }
302 GeneratedField::SubscriptionsToAdd => {
303 if subscriptions_to_add__.is_some() {
304 return Err(serde::de::Error::duplicate_field("subscriptionsToAdd"));
305 }
306 subscriptions_to_add__ = Some(map_.next_value()?);
307 }
308 GeneratedField::BackfillNodesToPause => {
309 if backfill_nodes_to_pause__.is_some() {
310 return Err(serde::de::Error::duplicate_field("backfillNodesToPause"));
311 }
312 backfill_nodes_to_pause__ =
313 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
314 .into_iter().map(|x| x.0).collect())
315 ;
316 }
317 GeneratedField::ActorCdcTableSnapshotSplits => {
318 if actor_cdc_table_snapshot_splits__.is_some() {
319 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
320 }
321 actor_cdc_table_snapshot_splits__ = map_.next_value()?;
322 }
323 GeneratedField::NewUpstreamSinks => {
324 if new_upstream_sinks__.is_some() {
325 return Err(serde::de::Error::duplicate_field("newUpstreamSinks"));
326 }
327 new_upstream_sinks__ = Some(
328 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
329 .into_iter().map(|(k,v)| (k.0, v)).collect()
330 );
331 }
332 }
333 }
334 Ok(AddMutation {
335 actor_dispatchers: actor_dispatchers__.unwrap_or_default(),
336 added_actors: added_actors__.unwrap_or_default(),
337 actor_splits: actor_splits__.unwrap_or_default(),
338 pause: pause__.unwrap_or_default(),
339 subscriptions_to_add: subscriptions_to_add__.unwrap_or_default(),
340 backfill_nodes_to_pause: backfill_nodes_to_pause__.unwrap_or_default(),
341 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
342 new_upstream_sinks: new_upstream_sinks__.unwrap_or_default(),
343 })
344 }
345 }
346 deserializer.deserialize_struct("stream_plan.AddMutation", FIELDS, GeneratedVisitor)
347 }
348}
349impl serde::Serialize for add_mutation::NewUpstreamSink {
350 #[allow(deprecated)]
351 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
352 where
353 S: serde::Serializer,
354 {
355 use serde::ser::SerializeStruct;
356 let mut len = 0;
357 if self.info.is_some() {
358 len += 1;
359 }
360 if !self.upstream_actors.is_empty() {
361 len += 1;
362 }
363 let mut struct_ser = serializer.serialize_struct("stream_plan.AddMutation.NewUpstreamSink", len)?;
364 if let Some(v) = self.info.as_ref() {
365 struct_ser.serialize_field("info", v)?;
366 }
367 if !self.upstream_actors.is_empty() {
368 struct_ser.serialize_field("upstreamActors", &self.upstream_actors)?;
369 }
370 struct_ser.end()
371 }
372}
373impl<'de> serde::Deserialize<'de> for add_mutation::NewUpstreamSink {
374 #[allow(deprecated)]
375 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
376 where
377 D: serde::Deserializer<'de>,
378 {
379 const FIELDS: &[&str] = &[
380 "info",
381 "upstream_actors",
382 "upstreamActors",
383 ];
384
385 #[allow(clippy::enum_variant_names)]
386 enum GeneratedField {
387 Info,
388 UpstreamActors,
389 }
390 impl<'de> serde::Deserialize<'de> for GeneratedField {
391 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
392 where
393 D: serde::Deserializer<'de>,
394 {
395 struct GeneratedVisitor;
396
397 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
398 type Value = GeneratedField;
399
400 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
401 write!(formatter, "expected one of: {:?}", &FIELDS)
402 }
403
404 #[allow(unused_variables)]
405 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
406 where
407 E: serde::de::Error,
408 {
409 match value {
410 "info" => Ok(GeneratedField::Info),
411 "upstreamActors" | "upstream_actors" => Ok(GeneratedField::UpstreamActors),
412 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
413 }
414 }
415 }
416 deserializer.deserialize_identifier(GeneratedVisitor)
417 }
418 }
419 struct GeneratedVisitor;
420 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
421 type Value = add_mutation::NewUpstreamSink;
422
423 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
424 formatter.write_str("struct stream_plan.AddMutation.NewUpstreamSink")
425 }
426
427 fn visit_map<V>(self, mut map_: V) -> std::result::Result<add_mutation::NewUpstreamSink, V::Error>
428 where
429 V: serde::de::MapAccess<'de>,
430 {
431 let mut info__ = None;
432 let mut upstream_actors__ = None;
433 while let Some(k) = map_.next_key()? {
434 match k {
435 GeneratedField::Info => {
436 if info__.is_some() {
437 return Err(serde::de::Error::duplicate_field("info"));
438 }
439 info__ = map_.next_value()?;
440 }
441 GeneratedField::UpstreamActors => {
442 if upstream_actors__.is_some() {
443 return Err(serde::de::Error::duplicate_field("upstreamActors"));
444 }
445 upstream_actors__ = Some(map_.next_value()?);
446 }
447 }
448 }
449 Ok(add_mutation::NewUpstreamSink {
450 info: info__,
451 upstream_actors: upstream_actors__.unwrap_or_default(),
452 })
453 }
454 }
455 deserializer.deserialize_struct("stream_plan.AddMutation.NewUpstreamSink", FIELDS, GeneratedVisitor)
456 }
457}
458impl serde::Serialize for AggCallState {
459 #[allow(deprecated)]
460 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
461 where
462 S: serde::Serializer,
463 {
464 use serde::ser::SerializeStruct;
465 let mut len = 0;
466 if self.inner.is_some() {
467 len += 1;
468 }
469 let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState", len)?;
470 if let Some(v) = self.inner.as_ref() {
471 match v {
472 agg_call_state::Inner::ValueState(v) => {
473 struct_ser.serialize_field("valueState", v)?;
474 }
475 agg_call_state::Inner::MaterializedInputState(v) => {
476 struct_ser.serialize_field("materializedInputState", v)?;
477 }
478 }
479 }
480 struct_ser.end()
481 }
482}
483impl<'de> serde::Deserialize<'de> for AggCallState {
484 #[allow(deprecated)]
485 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
486 where
487 D: serde::Deserializer<'de>,
488 {
489 const FIELDS: &[&str] = &[
490 "value_state",
491 "valueState",
492 "materialized_input_state",
493 "materializedInputState",
494 ];
495
496 #[allow(clippy::enum_variant_names)]
497 enum GeneratedField {
498 ValueState,
499 MaterializedInputState,
500 }
501 impl<'de> serde::Deserialize<'de> for GeneratedField {
502 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
503 where
504 D: serde::Deserializer<'de>,
505 {
506 struct GeneratedVisitor;
507
508 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
509 type Value = GeneratedField;
510
511 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
512 write!(formatter, "expected one of: {:?}", &FIELDS)
513 }
514
515 #[allow(unused_variables)]
516 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
517 where
518 E: serde::de::Error,
519 {
520 match value {
521 "valueState" | "value_state" => Ok(GeneratedField::ValueState),
522 "materializedInputState" | "materialized_input_state" => Ok(GeneratedField::MaterializedInputState),
523 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
524 }
525 }
526 }
527 deserializer.deserialize_identifier(GeneratedVisitor)
528 }
529 }
530 struct GeneratedVisitor;
531 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
532 type Value = AggCallState;
533
534 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
535 formatter.write_str("struct stream_plan.AggCallState")
536 }
537
538 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AggCallState, V::Error>
539 where
540 V: serde::de::MapAccess<'de>,
541 {
542 let mut inner__ = None;
543 while let Some(k) = map_.next_key()? {
544 match k {
545 GeneratedField::ValueState => {
546 if inner__.is_some() {
547 return Err(serde::de::Error::duplicate_field("valueState"));
548 }
549 inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::ValueState)
550;
551 }
552 GeneratedField::MaterializedInputState => {
553 if inner__.is_some() {
554 return Err(serde::de::Error::duplicate_field("materializedInputState"));
555 }
556 inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::MaterializedInputState)
557;
558 }
559 }
560 }
561 Ok(AggCallState {
562 inner: inner__,
563 })
564 }
565 }
566 deserializer.deserialize_struct("stream_plan.AggCallState", FIELDS, GeneratedVisitor)
567 }
568}
569impl serde::Serialize for agg_call_state::MaterializedInputState {
570 #[allow(deprecated)]
571 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
572 where
573 S: serde::Serializer,
574 {
575 use serde::ser::SerializeStruct;
576 let mut len = 0;
577 if self.table.is_some() {
578 len += 1;
579 }
580 if !self.included_upstream_indices.is_empty() {
581 len += 1;
582 }
583 if !self.table_value_indices.is_empty() {
584 len += 1;
585 }
586 if !self.order_columns.is_empty() {
587 len += 1;
588 }
589 let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState.MaterializedInputState", len)?;
590 if let Some(v) = self.table.as_ref() {
591 struct_ser.serialize_field("table", v)?;
592 }
593 if !self.included_upstream_indices.is_empty() {
594 struct_ser.serialize_field("includedUpstreamIndices", &self.included_upstream_indices)?;
595 }
596 if !self.table_value_indices.is_empty() {
597 struct_ser.serialize_field("tableValueIndices", &self.table_value_indices)?;
598 }
599 if !self.order_columns.is_empty() {
600 struct_ser.serialize_field("orderColumns", &self.order_columns)?;
601 }
602 struct_ser.end()
603 }
604}
605impl<'de> serde::Deserialize<'de> for agg_call_state::MaterializedInputState {
606 #[allow(deprecated)]
607 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
608 where
609 D: serde::Deserializer<'de>,
610 {
611 const FIELDS: &[&str] = &[
612 "table",
613 "included_upstream_indices",
614 "includedUpstreamIndices",
615 "table_value_indices",
616 "tableValueIndices",
617 "order_columns",
618 "orderColumns",
619 ];
620
621 #[allow(clippy::enum_variant_names)]
622 enum GeneratedField {
623 Table,
624 IncludedUpstreamIndices,
625 TableValueIndices,
626 OrderColumns,
627 }
628 impl<'de> serde::Deserialize<'de> for GeneratedField {
629 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
630 where
631 D: serde::Deserializer<'de>,
632 {
633 struct GeneratedVisitor;
634
635 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
636 type Value = GeneratedField;
637
638 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
639 write!(formatter, "expected one of: {:?}", &FIELDS)
640 }
641
642 #[allow(unused_variables)]
643 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
644 where
645 E: serde::de::Error,
646 {
647 match value {
648 "table" => Ok(GeneratedField::Table),
649 "includedUpstreamIndices" | "included_upstream_indices" => Ok(GeneratedField::IncludedUpstreamIndices),
650 "tableValueIndices" | "table_value_indices" => Ok(GeneratedField::TableValueIndices),
651 "orderColumns" | "order_columns" => Ok(GeneratedField::OrderColumns),
652 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
653 }
654 }
655 }
656 deserializer.deserialize_identifier(GeneratedVisitor)
657 }
658 }
659 struct GeneratedVisitor;
660 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
661 type Value = agg_call_state::MaterializedInputState;
662
663 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
664 formatter.write_str("struct stream_plan.AggCallState.MaterializedInputState")
665 }
666
667 fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::MaterializedInputState, V::Error>
668 where
669 V: serde::de::MapAccess<'de>,
670 {
671 let mut table__ = None;
672 let mut included_upstream_indices__ = None;
673 let mut table_value_indices__ = None;
674 let mut order_columns__ = None;
675 while let Some(k) = map_.next_key()? {
676 match k {
677 GeneratedField::Table => {
678 if table__.is_some() {
679 return Err(serde::de::Error::duplicate_field("table"));
680 }
681 table__ = map_.next_value()?;
682 }
683 GeneratedField::IncludedUpstreamIndices => {
684 if included_upstream_indices__.is_some() {
685 return Err(serde::de::Error::duplicate_field("includedUpstreamIndices"));
686 }
687 included_upstream_indices__ =
688 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
689 .into_iter().map(|x| x.0).collect())
690 ;
691 }
692 GeneratedField::TableValueIndices => {
693 if table_value_indices__.is_some() {
694 return Err(serde::de::Error::duplicate_field("tableValueIndices"));
695 }
696 table_value_indices__ =
697 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
698 .into_iter().map(|x| x.0).collect())
699 ;
700 }
701 GeneratedField::OrderColumns => {
702 if order_columns__.is_some() {
703 return Err(serde::de::Error::duplicate_field("orderColumns"));
704 }
705 order_columns__ = Some(map_.next_value()?);
706 }
707 }
708 }
709 Ok(agg_call_state::MaterializedInputState {
710 table: table__,
711 included_upstream_indices: included_upstream_indices__.unwrap_or_default(),
712 table_value_indices: table_value_indices__.unwrap_or_default(),
713 order_columns: order_columns__.unwrap_or_default(),
714 })
715 }
716 }
717 deserializer.deserialize_struct("stream_plan.AggCallState.MaterializedInputState", FIELDS, GeneratedVisitor)
718 }
719}
720impl serde::Serialize for agg_call_state::ValueState {
721 #[allow(deprecated)]
722 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
723 where
724 S: serde::Serializer,
725 {
726 use serde::ser::SerializeStruct;
727 let len = 0;
728 let struct_ser = serializer.serialize_struct("stream_plan.AggCallState.ValueState", len)?;
729 struct_ser.end()
730 }
731}
732impl<'de> serde::Deserialize<'de> for agg_call_state::ValueState {
733 #[allow(deprecated)]
734 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
735 where
736 D: serde::Deserializer<'de>,
737 {
738 const FIELDS: &[&str] = &[
739 ];
740
741 #[allow(clippy::enum_variant_names)]
742 enum GeneratedField {
743 }
744 impl<'de> serde::Deserialize<'de> for GeneratedField {
745 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
746 where
747 D: serde::Deserializer<'de>,
748 {
749 struct GeneratedVisitor;
750
751 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
752 type Value = GeneratedField;
753
754 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
755 write!(formatter, "expected one of: {:?}", &FIELDS)
756 }
757
758 #[allow(unused_variables)]
759 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
760 where
761 E: serde::de::Error,
762 {
763 Err(serde::de::Error::unknown_field(value, FIELDS))
764 }
765 }
766 deserializer.deserialize_identifier(GeneratedVisitor)
767 }
768 }
769 struct GeneratedVisitor;
770 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
771 type Value = agg_call_state::ValueState;
772
773 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
774 formatter.write_str("struct stream_plan.AggCallState.ValueState")
775 }
776
777 fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::ValueState, V::Error>
778 where
779 V: serde::de::MapAccess<'de>,
780 {
781 while map_.next_key::<GeneratedField>()?.is_some() {
782 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
783 }
784 Ok(agg_call_state::ValueState {
785 })
786 }
787 }
788 deserializer.deserialize_struct("stream_plan.AggCallState.ValueState", FIELDS, GeneratedVisitor)
789 }
790}
791impl serde::Serialize for AggNodeVersion {
792 #[allow(deprecated)]
793 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
794 where
795 S: serde::Serializer,
796 {
797 let variant = match self {
798 Self::Unspecified => "AGG_NODE_VERSION_UNSPECIFIED",
799 Self::Issue12140 => "AGG_NODE_VERSION_ISSUE_12140",
800 Self::Issue13465 => "AGG_NODE_VERSION_ISSUE_13465",
801 };
802 serializer.serialize_str(variant)
803 }
804}
805impl<'de> serde::Deserialize<'de> for AggNodeVersion {
806 #[allow(deprecated)]
807 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
808 where
809 D: serde::Deserializer<'de>,
810 {
811 const FIELDS: &[&str] = &[
812 "AGG_NODE_VERSION_UNSPECIFIED",
813 "AGG_NODE_VERSION_ISSUE_12140",
814 "AGG_NODE_VERSION_ISSUE_13465",
815 ];
816
817 struct GeneratedVisitor;
818
819 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
820 type Value = AggNodeVersion;
821
822 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
823 write!(formatter, "expected one of: {:?}", &FIELDS)
824 }
825
826 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
827 where
828 E: serde::de::Error,
829 {
830 i32::try_from(v)
831 .ok()
832 .and_then(|x| x.try_into().ok())
833 .ok_or_else(|| {
834 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
835 })
836 }
837
838 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
839 where
840 E: serde::de::Error,
841 {
842 i32::try_from(v)
843 .ok()
844 .and_then(|x| x.try_into().ok())
845 .ok_or_else(|| {
846 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
847 })
848 }
849
850 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
851 where
852 E: serde::de::Error,
853 {
854 match value {
855 "AGG_NODE_VERSION_UNSPECIFIED" => Ok(AggNodeVersion::Unspecified),
856 "AGG_NODE_VERSION_ISSUE_12140" => Ok(AggNodeVersion::Issue12140),
857 "AGG_NODE_VERSION_ISSUE_13465" => Ok(AggNodeVersion::Issue13465),
858 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
859 }
860 }
861 }
862 deserializer.deserialize_any(GeneratedVisitor)
863 }
864}
865impl serde::Serialize for ArrangeNode {
866 #[allow(deprecated)]
867 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
868 where
869 S: serde::Serializer,
870 {
871 use serde::ser::SerializeStruct;
872 let mut len = 0;
873 if self.table_info.is_some() {
874 len += 1;
875 }
876 if !self.distribution_key.is_empty() {
877 len += 1;
878 }
879 if self.table.is_some() {
880 len += 1;
881 }
882 let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangeNode", len)?;
883 if let Some(v) = self.table_info.as_ref() {
884 struct_ser.serialize_field("tableInfo", v)?;
885 }
886 if !self.distribution_key.is_empty() {
887 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
888 }
889 if let Some(v) = self.table.as_ref() {
890 struct_ser.serialize_field("table", v)?;
891 }
892 struct_ser.end()
893 }
894}
895impl<'de> serde::Deserialize<'de> for ArrangeNode {
896 #[allow(deprecated)]
897 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
898 where
899 D: serde::Deserializer<'de>,
900 {
901 const FIELDS: &[&str] = &[
902 "table_info",
903 "tableInfo",
904 "distribution_key",
905 "distributionKey",
906 "table",
907 ];
908
909 #[allow(clippy::enum_variant_names)]
910 enum GeneratedField {
911 TableInfo,
912 DistributionKey,
913 Table,
914 }
915 impl<'de> serde::Deserialize<'de> for GeneratedField {
916 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
917 where
918 D: serde::Deserializer<'de>,
919 {
920 struct GeneratedVisitor;
921
922 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
923 type Value = GeneratedField;
924
925 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
926 write!(formatter, "expected one of: {:?}", &FIELDS)
927 }
928
929 #[allow(unused_variables)]
930 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
931 where
932 E: serde::de::Error,
933 {
934 match value {
935 "tableInfo" | "table_info" => Ok(GeneratedField::TableInfo),
936 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
937 "table" => Ok(GeneratedField::Table),
938 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
939 }
940 }
941 }
942 deserializer.deserialize_identifier(GeneratedVisitor)
943 }
944 }
945 struct GeneratedVisitor;
946 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
947 type Value = ArrangeNode;
948
949 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
950 formatter.write_str("struct stream_plan.ArrangeNode")
951 }
952
953 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangeNode, V::Error>
954 where
955 V: serde::de::MapAccess<'de>,
956 {
957 let mut table_info__ = None;
958 let mut distribution_key__ = None;
959 let mut table__ = None;
960 while let Some(k) = map_.next_key()? {
961 match k {
962 GeneratedField::TableInfo => {
963 if table_info__.is_some() {
964 return Err(serde::de::Error::duplicate_field("tableInfo"));
965 }
966 table_info__ = map_.next_value()?;
967 }
968 GeneratedField::DistributionKey => {
969 if distribution_key__.is_some() {
970 return Err(serde::de::Error::duplicate_field("distributionKey"));
971 }
972 distribution_key__ =
973 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
974 .into_iter().map(|x| x.0).collect())
975 ;
976 }
977 GeneratedField::Table => {
978 if table__.is_some() {
979 return Err(serde::de::Error::duplicate_field("table"));
980 }
981 table__ = map_.next_value()?;
982 }
983 }
984 }
985 Ok(ArrangeNode {
986 table_info: table_info__,
987 distribution_key: distribution_key__.unwrap_or_default(),
988 table: table__,
989 })
990 }
991 }
992 deserializer.deserialize_struct("stream_plan.ArrangeNode", FIELDS, GeneratedVisitor)
993 }
994}
995impl serde::Serialize for ArrangementInfo {
996 #[allow(deprecated)]
997 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
998 where
999 S: serde::Serializer,
1000 {
1001 use serde::ser::SerializeStruct;
1002 let mut len = 0;
1003 if !self.arrange_key_orders.is_empty() {
1004 len += 1;
1005 }
1006 if !self.column_descs.is_empty() {
1007 len += 1;
1008 }
1009 if self.table_desc.is_some() {
1010 len += 1;
1011 }
1012 if !self.output_col_idx.is_empty() {
1013 len += 1;
1014 }
1015 let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangementInfo", len)?;
1016 if !self.arrange_key_orders.is_empty() {
1017 struct_ser.serialize_field("arrangeKeyOrders", &self.arrange_key_orders)?;
1018 }
1019 if !self.column_descs.is_empty() {
1020 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
1021 }
1022 if let Some(v) = self.table_desc.as_ref() {
1023 struct_ser.serialize_field("tableDesc", v)?;
1024 }
1025 if !self.output_col_idx.is_empty() {
1026 struct_ser.serialize_field("outputColIdx", &self.output_col_idx)?;
1027 }
1028 struct_ser.end()
1029 }
1030}
1031impl<'de> serde::Deserialize<'de> for ArrangementInfo {
1032 #[allow(deprecated)]
1033 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1034 where
1035 D: serde::Deserializer<'de>,
1036 {
1037 const FIELDS: &[&str] = &[
1038 "arrange_key_orders",
1039 "arrangeKeyOrders",
1040 "column_descs",
1041 "columnDescs",
1042 "table_desc",
1043 "tableDesc",
1044 "output_col_idx",
1045 "outputColIdx",
1046 ];
1047
1048 #[allow(clippy::enum_variant_names)]
1049 enum GeneratedField {
1050 ArrangeKeyOrders,
1051 ColumnDescs,
1052 TableDesc,
1053 OutputColIdx,
1054 }
1055 impl<'de> serde::Deserialize<'de> for GeneratedField {
1056 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1057 where
1058 D: serde::Deserializer<'de>,
1059 {
1060 struct GeneratedVisitor;
1061
1062 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1063 type Value = GeneratedField;
1064
1065 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1066 write!(formatter, "expected one of: {:?}", &FIELDS)
1067 }
1068
1069 #[allow(unused_variables)]
1070 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1071 where
1072 E: serde::de::Error,
1073 {
1074 match value {
1075 "arrangeKeyOrders" | "arrange_key_orders" => Ok(GeneratedField::ArrangeKeyOrders),
1076 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
1077 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
1078 "outputColIdx" | "output_col_idx" => Ok(GeneratedField::OutputColIdx),
1079 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1080 }
1081 }
1082 }
1083 deserializer.deserialize_identifier(GeneratedVisitor)
1084 }
1085 }
1086 struct GeneratedVisitor;
1087 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1088 type Value = ArrangementInfo;
1089
1090 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1091 formatter.write_str("struct stream_plan.ArrangementInfo")
1092 }
1093
1094 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangementInfo, V::Error>
1095 where
1096 V: serde::de::MapAccess<'de>,
1097 {
1098 let mut arrange_key_orders__ = None;
1099 let mut column_descs__ = None;
1100 let mut table_desc__ = None;
1101 let mut output_col_idx__ = None;
1102 while let Some(k) = map_.next_key()? {
1103 match k {
1104 GeneratedField::ArrangeKeyOrders => {
1105 if arrange_key_orders__.is_some() {
1106 return Err(serde::de::Error::duplicate_field("arrangeKeyOrders"));
1107 }
1108 arrange_key_orders__ = Some(map_.next_value()?);
1109 }
1110 GeneratedField::ColumnDescs => {
1111 if column_descs__.is_some() {
1112 return Err(serde::de::Error::duplicate_field("columnDescs"));
1113 }
1114 column_descs__ = Some(map_.next_value()?);
1115 }
1116 GeneratedField::TableDesc => {
1117 if table_desc__.is_some() {
1118 return Err(serde::de::Error::duplicate_field("tableDesc"));
1119 }
1120 table_desc__ = map_.next_value()?;
1121 }
1122 GeneratedField::OutputColIdx => {
1123 if output_col_idx__.is_some() {
1124 return Err(serde::de::Error::duplicate_field("outputColIdx"));
1125 }
1126 output_col_idx__ =
1127 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1128 .into_iter().map(|x| x.0).collect())
1129 ;
1130 }
1131 }
1132 }
1133 Ok(ArrangementInfo {
1134 arrange_key_orders: arrange_key_orders__.unwrap_or_default(),
1135 column_descs: column_descs__.unwrap_or_default(),
1136 table_desc: table_desc__,
1137 output_col_idx: output_col_idx__.unwrap_or_default(),
1138 })
1139 }
1140 }
1141 deserializer.deserialize_struct("stream_plan.ArrangementInfo", FIELDS, GeneratedVisitor)
1142 }
1143}
1144impl serde::Serialize for AsOfJoinNode {
1145 #[allow(deprecated)]
1146 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1147 where
1148 S: serde::Serializer,
1149 {
1150 use serde::ser::SerializeStruct;
1151 let mut len = 0;
1152 if self.join_type != 0 {
1153 len += 1;
1154 }
1155 if !self.left_key.is_empty() {
1156 len += 1;
1157 }
1158 if !self.right_key.is_empty() {
1159 len += 1;
1160 }
1161 if self.left_table.is_some() {
1162 len += 1;
1163 }
1164 if self.right_table.is_some() {
1165 len += 1;
1166 }
1167 if !self.output_indices.is_empty() {
1168 len += 1;
1169 }
1170 if !self.left_deduped_input_pk_indices.is_empty() {
1171 len += 1;
1172 }
1173 if !self.right_deduped_input_pk_indices.is_empty() {
1174 len += 1;
1175 }
1176 if !self.null_safe.is_empty() {
1177 len += 1;
1178 }
1179 if self.asof_desc.is_some() {
1180 len += 1;
1181 }
1182 if self.join_encoding_type != 0 {
1183 len += 1;
1184 }
1185 let mut struct_ser = serializer.serialize_struct("stream_plan.AsOfJoinNode", len)?;
1186 if self.join_type != 0 {
1187 let v = super::plan_common::AsOfJoinType::try_from(self.join_type)
1188 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
1189 struct_ser.serialize_field("joinType", &v)?;
1190 }
1191 if !self.left_key.is_empty() {
1192 struct_ser.serialize_field("leftKey", &self.left_key)?;
1193 }
1194 if !self.right_key.is_empty() {
1195 struct_ser.serialize_field("rightKey", &self.right_key)?;
1196 }
1197 if let Some(v) = self.left_table.as_ref() {
1198 struct_ser.serialize_field("leftTable", v)?;
1199 }
1200 if let Some(v) = self.right_table.as_ref() {
1201 struct_ser.serialize_field("rightTable", v)?;
1202 }
1203 if !self.output_indices.is_empty() {
1204 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
1205 }
1206 if !self.left_deduped_input_pk_indices.is_empty() {
1207 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
1208 }
1209 if !self.right_deduped_input_pk_indices.is_empty() {
1210 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
1211 }
1212 if !self.null_safe.is_empty() {
1213 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
1214 }
1215 if let Some(v) = self.asof_desc.as_ref() {
1216 struct_ser.serialize_field("asofDesc", v)?;
1217 }
1218 if self.join_encoding_type != 0 {
1219 let v = JoinEncodingType::try_from(self.join_encoding_type)
1220 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
1221 struct_ser.serialize_field("joinEncodingType", &v)?;
1222 }
1223 struct_ser.end()
1224 }
1225}
1226impl<'de> serde::Deserialize<'de> for AsOfJoinNode {
1227 #[allow(deprecated)]
1228 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1229 where
1230 D: serde::Deserializer<'de>,
1231 {
1232 const FIELDS: &[&str] = &[
1233 "join_type",
1234 "joinType",
1235 "left_key",
1236 "leftKey",
1237 "right_key",
1238 "rightKey",
1239 "left_table",
1240 "leftTable",
1241 "right_table",
1242 "rightTable",
1243 "output_indices",
1244 "outputIndices",
1245 "left_deduped_input_pk_indices",
1246 "leftDedupedInputPkIndices",
1247 "right_deduped_input_pk_indices",
1248 "rightDedupedInputPkIndices",
1249 "null_safe",
1250 "nullSafe",
1251 "asof_desc",
1252 "asofDesc",
1253 "join_encoding_type",
1254 "joinEncodingType",
1255 ];
1256
1257 #[allow(clippy::enum_variant_names)]
1258 enum GeneratedField {
1259 JoinType,
1260 LeftKey,
1261 RightKey,
1262 LeftTable,
1263 RightTable,
1264 OutputIndices,
1265 LeftDedupedInputPkIndices,
1266 RightDedupedInputPkIndices,
1267 NullSafe,
1268 AsofDesc,
1269 JoinEncodingType,
1270 }
1271 impl<'de> serde::Deserialize<'de> for GeneratedField {
1272 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1273 where
1274 D: serde::Deserializer<'de>,
1275 {
1276 struct GeneratedVisitor;
1277
1278 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1279 type Value = GeneratedField;
1280
1281 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1282 write!(formatter, "expected one of: {:?}", &FIELDS)
1283 }
1284
1285 #[allow(unused_variables)]
1286 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1287 where
1288 E: serde::de::Error,
1289 {
1290 match value {
1291 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
1292 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
1293 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
1294 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
1295 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
1296 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
1297 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
1298 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
1299 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
1300 "asofDesc" | "asof_desc" => Ok(GeneratedField::AsofDesc),
1301 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
1302 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1303 }
1304 }
1305 }
1306 deserializer.deserialize_identifier(GeneratedVisitor)
1307 }
1308 }
1309 struct GeneratedVisitor;
1310 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1311 type Value = AsOfJoinNode;
1312
1313 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1314 formatter.write_str("struct stream_plan.AsOfJoinNode")
1315 }
1316
1317 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AsOfJoinNode, V::Error>
1318 where
1319 V: serde::de::MapAccess<'de>,
1320 {
1321 let mut join_type__ = None;
1322 let mut left_key__ = None;
1323 let mut right_key__ = None;
1324 let mut left_table__ = None;
1325 let mut right_table__ = None;
1326 let mut output_indices__ = None;
1327 let mut left_deduped_input_pk_indices__ = None;
1328 let mut right_deduped_input_pk_indices__ = None;
1329 let mut null_safe__ = None;
1330 let mut asof_desc__ = None;
1331 let mut join_encoding_type__ = None;
1332 while let Some(k) = map_.next_key()? {
1333 match k {
1334 GeneratedField::JoinType => {
1335 if join_type__.is_some() {
1336 return Err(serde::de::Error::duplicate_field("joinType"));
1337 }
1338 join_type__ = Some(map_.next_value::<super::plan_common::AsOfJoinType>()? as i32);
1339 }
1340 GeneratedField::LeftKey => {
1341 if left_key__.is_some() {
1342 return Err(serde::de::Error::duplicate_field("leftKey"));
1343 }
1344 left_key__ =
1345 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1346 .into_iter().map(|x| x.0).collect())
1347 ;
1348 }
1349 GeneratedField::RightKey => {
1350 if right_key__.is_some() {
1351 return Err(serde::de::Error::duplicate_field("rightKey"));
1352 }
1353 right_key__ =
1354 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1355 .into_iter().map(|x| x.0).collect())
1356 ;
1357 }
1358 GeneratedField::LeftTable => {
1359 if left_table__.is_some() {
1360 return Err(serde::de::Error::duplicate_field("leftTable"));
1361 }
1362 left_table__ = map_.next_value()?;
1363 }
1364 GeneratedField::RightTable => {
1365 if right_table__.is_some() {
1366 return Err(serde::de::Error::duplicate_field("rightTable"));
1367 }
1368 right_table__ = map_.next_value()?;
1369 }
1370 GeneratedField::OutputIndices => {
1371 if output_indices__.is_some() {
1372 return Err(serde::de::Error::duplicate_field("outputIndices"));
1373 }
1374 output_indices__ =
1375 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1376 .into_iter().map(|x| x.0).collect())
1377 ;
1378 }
1379 GeneratedField::LeftDedupedInputPkIndices => {
1380 if left_deduped_input_pk_indices__.is_some() {
1381 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
1382 }
1383 left_deduped_input_pk_indices__ =
1384 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1385 .into_iter().map(|x| x.0).collect())
1386 ;
1387 }
1388 GeneratedField::RightDedupedInputPkIndices => {
1389 if right_deduped_input_pk_indices__.is_some() {
1390 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
1391 }
1392 right_deduped_input_pk_indices__ =
1393 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1394 .into_iter().map(|x| x.0).collect())
1395 ;
1396 }
1397 GeneratedField::NullSafe => {
1398 if null_safe__.is_some() {
1399 return Err(serde::de::Error::duplicate_field("nullSafe"));
1400 }
1401 null_safe__ = Some(map_.next_value()?);
1402 }
1403 GeneratedField::AsofDesc => {
1404 if asof_desc__.is_some() {
1405 return Err(serde::de::Error::duplicate_field("asofDesc"));
1406 }
1407 asof_desc__ = map_.next_value()?;
1408 }
1409 GeneratedField::JoinEncodingType => {
1410 if join_encoding_type__.is_some() {
1411 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
1412 }
1413 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
1414 }
1415 }
1416 }
1417 Ok(AsOfJoinNode {
1418 join_type: join_type__.unwrap_or_default(),
1419 left_key: left_key__.unwrap_or_default(),
1420 right_key: right_key__.unwrap_or_default(),
1421 left_table: left_table__,
1422 right_table: right_table__,
1423 output_indices: output_indices__.unwrap_or_default(),
1424 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
1425 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
1426 null_safe: null_safe__.unwrap_or_default(),
1427 asof_desc: asof_desc__,
1428 join_encoding_type: join_encoding_type__.unwrap_or_default(),
1429 })
1430 }
1431 }
1432 deserializer.deserialize_struct("stream_plan.AsOfJoinNode", FIELDS, GeneratedVisitor)
1433 }
1434}
1435impl serde::Serialize for BackfillOrder {
1436 #[allow(deprecated)]
1437 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1438 where
1439 S: serde::Serializer,
1440 {
1441 use serde::ser::SerializeStruct;
1442 let mut len = 0;
1443 if !self.order.is_empty() {
1444 len += 1;
1445 }
1446 let mut struct_ser = serializer.serialize_struct("stream_plan.BackfillOrder", len)?;
1447 if !self.order.is_empty() {
1448 struct_ser.serialize_field("order", &self.order)?;
1449 }
1450 struct_ser.end()
1451 }
1452}
1453impl<'de> serde::Deserialize<'de> for BackfillOrder {
1454 #[allow(deprecated)]
1455 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1456 where
1457 D: serde::Deserializer<'de>,
1458 {
1459 const FIELDS: &[&str] = &[
1460 "order",
1461 ];
1462
1463 #[allow(clippy::enum_variant_names)]
1464 enum GeneratedField {
1465 Order,
1466 }
1467 impl<'de> serde::Deserialize<'de> for GeneratedField {
1468 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1469 where
1470 D: serde::Deserializer<'de>,
1471 {
1472 struct GeneratedVisitor;
1473
1474 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1475 type Value = GeneratedField;
1476
1477 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1478 write!(formatter, "expected one of: {:?}", &FIELDS)
1479 }
1480
1481 #[allow(unused_variables)]
1482 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1483 where
1484 E: serde::de::Error,
1485 {
1486 match value {
1487 "order" => Ok(GeneratedField::Order),
1488 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1489 }
1490 }
1491 }
1492 deserializer.deserialize_identifier(GeneratedVisitor)
1493 }
1494 }
1495 struct GeneratedVisitor;
1496 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1497 type Value = BackfillOrder;
1498
1499 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1500 formatter.write_str("struct stream_plan.BackfillOrder")
1501 }
1502
1503 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BackfillOrder, V::Error>
1504 where
1505 V: serde::de::MapAccess<'de>,
1506 {
1507 let mut order__ = None;
1508 while let Some(k) = map_.next_key()? {
1509 match k {
1510 GeneratedField::Order => {
1511 if order__.is_some() {
1512 return Err(serde::de::Error::duplicate_field("order"));
1513 }
1514 order__ = Some(
1515 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1516 .into_iter().map(|(k,v)| (k.0, v)).collect()
1517 );
1518 }
1519 }
1520 }
1521 Ok(BackfillOrder {
1522 order: order__.unwrap_or_default(),
1523 })
1524 }
1525 }
1526 deserializer.deserialize_struct("stream_plan.BackfillOrder", FIELDS, GeneratedVisitor)
1527 }
1528}
1529impl serde::Serialize for Barrier {
1530 #[allow(deprecated)]
1531 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1532 where
1533 S: serde::Serializer,
1534 {
1535 use serde::ser::SerializeStruct;
1536 let mut len = 0;
1537 if self.epoch.is_some() {
1538 len += 1;
1539 }
1540 if self.mutation.is_some() {
1541 len += 1;
1542 }
1543 if !self.tracing_context.is_empty() {
1544 len += 1;
1545 }
1546 if self.kind != 0 {
1547 len += 1;
1548 }
1549 if !self.passed_actors.is_empty() {
1550 len += 1;
1551 }
1552 let mut struct_ser = serializer.serialize_struct("stream_plan.Barrier", len)?;
1553 if let Some(v) = self.epoch.as_ref() {
1554 struct_ser.serialize_field("epoch", v)?;
1555 }
1556 if let Some(v) = self.mutation.as_ref() {
1557 struct_ser.serialize_field("mutation", v)?;
1558 }
1559 if !self.tracing_context.is_empty() {
1560 struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
1561 }
1562 if self.kind != 0 {
1563 let v = barrier::BarrierKind::try_from(self.kind)
1564 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
1565 struct_ser.serialize_field("kind", &v)?;
1566 }
1567 if !self.passed_actors.is_empty() {
1568 struct_ser.serialize_field("passedActors", &self.passed_actors)?;
1569 }
1570 struct_ser.end()
1571 }
1572}
1573impl<'de> serde::Deserialize<'de> for Barrier {
1574 #[allow(deprecated)]
1575 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1576 where
1577 D: serde::Deserializer<'de>,
1578 {
1579 const FIELDS: &[&str] = &[
1580 "epoch",
1581 "mutation",
1582 "tracing_context",
1583 "tracingContext",
1584 "kind",
1585 "passed_actors",
1586 "passedActors",
1587 ];
1588
1589 #[allow(clippy::enum_variant_names)]
1590 enum GeneratedField {
1591 Epoch,
1592 Mutation,
1593 TracingContext,
1594 Kind,
1595 PassedActors,
1596 }
1597 impl<'de> serde::Deserialize<'de> for GeneratedField {
1598 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1599 where
1600 D: serde::Deserializer<'de>,
1601 {
1602 struct GeneratedVisitor;
1603
1604 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1605 type Value = GeneratedField;
1606
1607 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1608 write!(formatter, "expected one of: {:?}", &FIELDS)
1609 }
1610
1611 #[allow(unused_variables)]
1612 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1613 where
1614 E: serde::de::Error,
1615 {
1616 match value {
1617 "epoch" => Ok(GeneratedField::Epoch),
1618 "mutation" => Ok(GeneratedField::Mutation),
1619 "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
1620 "kind" => Ok(GeneratedField::Kind),
1621 "passedActors" | "passed_actors" => Ok(GeneratedField::PassedActors),
1622 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1623 }
1624 }
1625 }
1626 deserializer.deserialize_identifier(GeneratedVisitor)
1627 }
1628 }
1629 struct GeneratedVisitor;
1630 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1631 type Value = Barrier;
1632
1633 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1634 formatter.write_str("struct stream_plan.Barrier")
1635 }
1636
1637 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Barrier, V::Error>
1638 where
1639 V: serde::de::MapAccess<'de>,
1640 {
1641 let mut epoch__ = None;
1642 let mut mutation__ = None;
1643 let mut tracing_context__ = None;
1644 let mut kind__ = None;
1645 let mut passed_actors__ = None;
1646 while let Some(k) = map_.next_key()? {
1647 match k {
1648 GeneratedField::Epoch => {
1649 if epoch__.is_some() {
1650 return Err(serde::de::Error::duplicate_field("epoch"));
1651 }
1652 epoch__ = map_.next_value()?;
1653 }
1654 GeneratedField::Mutation => {
1655 if mutation__.is_some() {
1656 return Err(serde::de::Error::duplicate_field("mutation"));
1657 }
1658 mutation__ = map_.next_value()?;
1659 }
1660 GeneratedField::TracingContext => {
1661 if tracing_context__.is_some() {
1662 return Err(serde::de::Error::duplicate_field("tracingContext"));
1663 }
1664 tracing_context__ = Some(
1665 map_.next_value::<std::collections::HashMap<_, _>>()?
1666 );
1667 }
1668 GeneratedField::Kind => {
1669 if kind__.is_some() {
1670 return Err(serde::de::Error::duplicate_field("kind"));
1671 }
1672 kind__ = Some(map_.next_value::<barrier::BarrierKind>()? as i32);
1673 }
1674 GeneratedField::PassedActors => {
1675 if passed_actors__.is_some() {
1676 return Err(serde::de::Error::duplicate_field("passedActors"));
1677 }
1678 passed_actors__ =
1679 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1680 .into_iter().map(|x| x.0).collect())
1681 ;
1682 }
1683 }
1684 }
1685 Ok(Barrier {
1686 epoch: epoch__,
1687 mutation: mutation__,
1688 tracing_context: tracing_context__.unwrap_or_default(),
1689 kind: kind__.unwrap_or_default(),
1690 passed_actors: passed_actors__.unwrap_or_default(),
1691 })
1692 }
1693 }
1694 deserializer.deserialize_struct("stream_plan.Barrier", FIELDS, GeneratedVisitor)
1695 }
1696}
1697impl serde::Serialize for barrier::BarrierKind {
1698 #[allow(deprecated)]
1699 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1700 where
1701 S: serde::Serializer,
1702 {
1703 let variant = match self {
1704 Self::Unspecified => "BARRIER_KIND_UNSPECIFIED",
1705 Self::Initial => "BARRIER_KIND_INITIAL",
1706 Self::Barrier => "BARRIER_KIND_BARRIER",
1707 Self::Checkpoint => "BARRIER_KIND_CHECKPOINT",
1708 };
1709 serializer.serialize_str(variant)
1710 }
1711}
1712impl<'de> serde::Deserialize<'de> for barrier::BarrierKind {
1713 #[allow(deprecated)]
1714 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1715 where
1716 D: serde::Deserializer<'de>,
1717 {
1718 const FIELDS: &[&str] = &[
1719 "BARRIER_KIND_UNSPECIFIED",
1720 "BARRIER_KIND_INITIAL",
1721 "BARRIER_KIND_BARRIER",
1722 "BARRIER_KIND_CHECKPOINT",
1723 ];
1724
1725 struct GeneratedVisitor;
1726
1727 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1728 type Value = barrier::BarrierKind;
1729
1730 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1731 write!(formatter, "expected one of: {:?}", &FIELDS)
1732 }
1733
1734 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1735 where
1736 E: serde::de::Error,
1737 {
1738 i32::try_from(v)
1739 .ok()
1740 .and_then(|x| x.try_into().ok())
1741 .ok_or_else(|| {
1742 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1743 })
1744 }
1745
1746 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1747 where
1748 E: serde::de::Error,
1749 {
1750 i32::try_from(v)
1751 .ok()
1752 .and_then(|x| x.try_into().ok())
1753 .ok_or_else(|| {
1754 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1755 })
1756 }
1757
1758 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1759 where
1760 E: serde::de::Error,
1761 {
1762 match value {
1763 "BARRIER_KIND_UNSPECIFIED" => Ok(barrier::BarrierKind::Unspecified),
1764 "BARRIER_KIND_INITIAL" => Ok(barrier::BarrierKind::Initial),
1765 "BARRIER_KIND_BARRIER" => Ok(barrier::BarrierKind::Barrier),
1766 "BARRIER_KIND_CHECKPOINT" => Ok(barrier::BarrierKind::Checkpoint),
1767 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1768 }
1769 }
1770 }
1771 deserializer.deserialize_any(GeneratedVisitor)
1772 }
1773}
1774impl serde::Serialize for BarrierMutation {
1775 #[allow(deprecated)]
1776 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1777 where
1778 S: serde::Serializer,
1779 {
1780 use serde::ser::SerializeStruct;
1781 let mut len = 0;
1782 if self.mutation.is_some() {
1783 len += 1;
1784 }
1785 let mut struct_ser = serializer.serialize_struct("stream_plan.BarrierMutation", len)?;
1786 if let Some(v) = self.mutation.as_ref() {
1787 match v {
1788 barrier_mutation::Mutation::Add(v) => {
1789 struct_ser.serialize_field("add", v)?;
1790 }
1791 barrier_mutation::Mutation::Stop(v) => {
1792 struct_ser.serialize_field("stop", v)?;
1793 }
1794 barrier_mutation::Mutation::Update(v) => {
1795 struct_ser.serialize_field("update", v)?;
1796 }
1797 barrier_mutation::Mutation::Splits(v) => {
1798 struct_ser.serialize_field("splits", v)?;
1799 }
1800 barrier_mutation::Mutation::Pause(v) => {
1801 struct_ser.serialize_field("pause", v)?;
1802 }
1803 barrier_mutation::Mutation::Resume(v) => {
1804 struct_ser.serialize_field("resume", v)?;
1805 }
1806 barrier_mutation::Mutation::Throttle(v) => {
1807 struct_ser.serialize_field("throttle", v)?;
1808 }
1809 barrier_mutation::Mutation::DropSubscriptions(v) => {
1810 struct_ser.serialize_field("dropSubscriptions", v)?;
1811 }
1812 barrier_mutation::Mutation::ConnectorPropsChange(v) => {
1813 struct_ser.serialize_field("connectorPropsChange", v)?;
1814 }
1815 barrier_mutation::Mutation::StartFragmentBackfill(v) => {
1816 struct_ser.serialize_field("startFragmentBackfill", v)?;
1817 }
1818 barrier_mutation::Mutation::RefreshStart(v) => {
1819 struct_ser.serialize_field("refreshStart", v)?;
1820 }
1821 barrier_mutation::Mutation::LoadFinish(v) => {
1822 struct_ser.serialize_field("loadFinish", v)?;
1823 }
1824 barrier_mutation::Mutation::Combined(v) => {
1825 struct_ser.serialize_field("combined", v)?;
1826 }
1827 }
1828 }
1829 struct_ser.end()
1830 }
1831}
1832impl<'de> serde::Deserialize<'de> for BarrierMutation {
1833 #[allow(deprecated)]
1834 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1835 where
1836 D: serde::Deserializer<'de>,
1837 {
1838 const FIELDS: &[&str] = &[
1839 "add",
1840 "stop",
1841 "update",
1842 "splits",
1843 "pause",
1844 "resume",
1845 "throttle",
1846 "drop_subscriptions",
1847 "dropSubscriptions",
1848 "connector_props_change",
1849 "connectorPropsChange",
1850 "start_fragment_backfill",
1851 "startFragmentBackfill",
1852 "refresh_start",
1853 "refreshStart",
1854 "load_finish",
1855 "loadFinish",
1856 "combined",
1857 ];
1858
1859 #[allow(clippy::enum_variant_names)]
1860 enum GeneratedField {
1861 Add,
1862 Stop,
1863 Update,
1864 Splits,
1865 Pause,
1866 Resume,
1867 Throttle,
1868 DropSubscriptions,
1869 ConnectorPropsChange,
1870 StartFragmentBackfill,
1871 RefreshStart,
1872 LoadFinish,
1873 Combined,
1874 }
1875 impl<'de> serde::Deserialize<'de> for GeneratedField {
1876 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1877 where
1878 D: serde::Deserializer<'de>,
1879 {
1880 struct GeneratedVisitor;
1881
1882 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1883 type Value = GeneratedField;
1884
1885 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1886 write!(formatter, "expected one of: {:?}", &FIELDS)
1887 }
1888
1889 #[allow(unused_variables)]
1890 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1891 where
1892 E: serde::de::Error,
1893 {
1894 match value {
1895 "add" => Ok(GeneratedField::Add),
1896 "stop" => Ok(GeneratedField::Stop),
1897 "update" => Ok(GeneratedField::Update),
1898 "splits" => Ok(GeneratedField::Splits),
1899 "pause" => Ok(GeneratedField::Pause),
1900 "resume" => Ok(GeneratedField::Resume),
1901 "throttle" => Ok(GeneratedField::Throttle),
1902 "dropSubscriptions" | "drop_subscriptions" => Ok(GeneratedField::DropSubscriptions),
1903 "connectorPropsChange" | "connector_props_change" => Ok(GeneratedField::ConnectorPropsChange),
1904 "startFragmentBackfill" | "start_fragment_backfill" => Ok(GeneratedField::StartFragmentBackfill),
1905 "refreshStart" | "refresh_start" => Ok(GeneratedField::RefreshStart),
1906 "loadFinish" | "load_finish" => Ok(GeneratedField::LoadFinish),
1907 "combined" => Ok(GeneratedField::Combined),
1908 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1909 }
1910 }
1911 }
1912 deserializer.deserialize_identifier(GeneratedVisitor)
1913 }
1914 }
1915 struct GeneratedVisitor;
1916 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1917 type Value = BarrierMutation;
1918
1919 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1920 formatter.write_str("struct stream_plan.BarrierMutation")
1921 }
1922
1923 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierMutation, V::Error>
1924 where
1925 V: serde::de::MapAccess<'de>,
1926 {
1927 let mut mutation__ = None;
1928 while let Some(k) = map_.next_key()? {
1929 match k {
1930 GeneratedField::Add => {
1931 if mutation__.is_some() {
1932 return Err(serde::de::Error::duplicate_field("add"));
1933 }
1934 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Add)
1935;
1936 }
1937 GeneratedField::Stop => {
1938 if mutation__.is_some() {
1939 return Err(serde::de::Error::duplicate_field("stop"));
1940 }
1941 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Stop)
1942;
1943 }
1944 GeneratedField::Update => {
1945 if mutation__.is_some() {
1946 return Err(serde::de::Error::duplicate_field("update"));
1947 }
1948 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Update)
1949;
1950 }
1951 GeneratedField::Splits => {
1952 if mutation__.is_some() {
1953 return Err(serde::de::Error::duplicate_field("splits"));
1954 }
1955 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Splits)
1956;
1957 }
1958 GeneratedField::Pause => {
1959 if mutation__.is_some() {
1960 return Err(serde::de::Error::duplicate_field("pause"));
1961 }
1962 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Pause)
1963;
1964 }
1965 GeneratedField::Resume => {
1966 if mutation__.is_some() {
1967 return Err(serde::de::Error::duplicate_field("resume"));
1968 }
1969 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Resume)
1970;
1971 }
1972 GeneratedField::Throttle => {
1973 if mutation__.is_some() {
1974 return Err(serde::de::Error::duplicate_field("throttle"));
1975 }
1976 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Throttle)
1977;
1978 }
1979 GeneratedField::DropSubscriptions => {
1980 if mutation__.is_some() {
1981 return Err(serde::de::Error::duplicate_field("dropSubscriptions"));
1982 }
1983 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::DropSubscriptions)
1984;
1985 }
1986 GeneratedField::ConnectorPropsChange => {
1987 if mutation__.is_some() {
1988 return Err(serde::de::Error::duplicate_field("connectorPropsChange"));
1989 }
1990 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ConnectorPropsChange)
1991;
1992 }
1993 GeneratedField::StartFragmentBackfill => {
1994 if mutation__.is_some() {
1995 return Err(serde::de::Error::duplicate_field("startFragmentBackfill"));
1996 }
1997 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::StartFragmentBackfill)
1998;
1999 }
2000 GeneratedField::RefreshStart => {
2001 if mutation__.is_some() {
2002 return Err(serde::de::Error::duplicate_field("refreshStart"));
2003 }
2004 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::RefreshStart)
2005;
2006 }
2007 GeneratedField::LoadFinish => {
2008 if mutation__.is_some() {
2009 return Err(serde::de::Error::duplicate_field("loadFinish"));
2010 }
2011 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::LoadFinish)
2012;
2013 }
2014 GeneratedField::Combined => {
2015 if mutation__.is_some() {
2016 return Err(serde::de::Error::duplicate_field("combined"));
2017 }
2018 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Combined)
2019;
2020 }
2021 }
2022 }
2023 Ok(BarrierMutation {
2024 mutation: mutation__,
2025 })
2026 }
2027 }
2028 deserializer.deserialize_struct("stream_plan.BarrierMutation", FIELDS, GeneratedVisitor)
2029 }
2030}
2031impl serde::Serialize for BarrierRecvNode {
2032 #[allow(deprecated)]
2033 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2034 where
2035 S: serde::Serializer,
2036 {
2037 use serde::ser::SerializeStruct;
2038 let len = 0;
2039 let struct_ser = serializer.serialize_struct("stream_plan.BarrierRecvNode", len)?;
2040 struct_ser.end()
2041 }
2042}
2043impl<'de> serde::Deserialize<'de> for BarrierRecvNode {
2044 #[allow(deprecated)]
2045 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2046 where
2047 D: serde::Deserializer<'de>,
2048 {
2049 const FIELDS: &[&str] = &[
2050 ];
2051
2052 #[allow(clippy::enum_variant_names)]
2053 enum GeneratedField {
2054 }
2055 impl<'de> serde::Deserialize<'de> for GeneratedField {
2056 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2057 where
2058 D: serde::Deserializer<'de>,
2059 {
2060 struct GeneratedVisitor;
2061
2062 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2063 type Value = GeneratedField;
2064
2065 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2066 write!(formatter, "expected one of: {:?}", &FIELDS)
2067 }
2068
2069 #[allow(unused_variables)]
2070 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2071 where
2072 E: serde::de::Error,
2073 {
2074 Err(serde::de::Error::unknown_field(value, FIELDS))
2075 }
2076 }
2077 deserializer.deserialize_identifier(GeneratedVisitor)
2078 }
2079 }
2080 struct GeneratedVisitor;
2081 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2082 type Value = BarrierRecvNode;
2083
2084 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2085 formatter.write_str("struct stream_plan.BarrierRecvNode")
2086 }
2087
2088 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierRecvNode, V::Error>
2089 where
2090 V: serde::de::MapAccess<'de>,
2091 {
2092 while map_.next_key::<GeneratedField>()?.is_some() {
2093 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2094 }
2095 Ok(BarrierRecvNode {
2096 })
2097 }
2098 }
2099 deserializer.deserialize_struct("stream_plan.BarrierRecvNode", FIELDS, GeneratedVisitor)
2100 }
2101}
2102impl serde::Serialize for BatchPlanNode {
2103 #[allow(deprecated)]
2104 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2105 where
2106 S: serde::Serializer,
2107 {
2108 use serde::ser::SerializeStruct;
2109 let mut len = 0;
2110 if self.table_desc.is_some() {
2111 len += 1;
2112 }
2113 if !self.column_ids.is_empty() {
2114 len += 1;
2115 }
2116 let mut struct_ser = serializer.serialize_struct("stream_plan.BatchPlanNode", len)?;
2117 if let Some(v) = self.table_desc.as_ref() {
2118 struct_ser.serialize_field("tableDesc", v)?;
2119 }
2120 if !self.column_ids.is_empty() {
2121 struct_ser.serialize_field("columnIds", &self.column_ids)?;
2122 }
2123 struct_ser.end()
2124 }
2125}
2126impl<'de> serde::Deserialize<'de> for BatchPlanNode {
2127 #[allow(deprecated)]
2128 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2129 where
2130 D: serde::Deserializer<'de>,
2131 {
2132 const FIELDS: &[&str] = &[
2133 "table_desc",
2134 "tableDesc",
2135 "column_ids",
2136 "columnIds",
2137 ];
2138
2139 #[allow(clippy::enum_variant_names)]
2140 enum GeneratedField {
2141 TableDesc,
2142 ColumnIds,
2143 }
2144 impl<'de> serde::Deserialize<'de> for GeneratedField {
2145 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2146 where
2147 D: serde::Deserializer<'de>,
2148 {
2149 struct GeneratedVisitor;
2150
2151 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2152 type Value = GeneratedField;
2153
2154 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2155 write!(formatter, "expected one of: {:?}", &FIELDS)
2156 }
2157
2158 #[allow(unused_variables)]
2159 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2160 where
2161 E: serde::de::Error,
2162 {
2163 match value {
2164 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
2165 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
2166 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2167 }
2168 }
2169 }
2170 deserializer.deserialize_identifier(GeneratedVisitor)
2171 }
2172 }
2173 struct GeneratedVisitor;
2174 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2175 type Value = BatchPlanNode;
2176
2177 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2178 formatter.write_str("struct stream_plan.BatchPlanNode")
2179 }
2180
2181 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BatchPlanNode, V::Error>
2182 where
2183 V: serde::de::MapAccess<'de>,
2184 {
2185 let mut table_desc__ = None;
2186 let mut column_ids__ = None;
2187 while let Some(k) = map_.next_key()? {
2188 match k {
2189 GeneratedField::TableDesc => {
2190 if table_desc__.is_some() {
2191 return Err(serde::de::Error::duplicate_field("tableDesc"));
2192 }
2193 table_desc__ = map_.next_value()?;
2194 }
2195 GeneratedField::ColumnIds => {
2196 if column_ids__.is_some() {
2197 return Err(serde::de::Error::duplicate_field("columnIds"));
2198 }
2199 column_ids__ =
2200 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2201 .into_iter().map(|x| x.0).collect())
2202 ;
2203 }
2204 }
2205 }
2206 Ok(BatchPlanNode {
2207 table_desc: table_desc__,
2208 column_ids: column_ids__.unwrap_or_default(),
2209 })
2210 }
2211 }
2212 deserializer.deserialize_struct("stream_plan.BatchPlanNode", FIELDS, GeneratedVisitor)
2213 }
2214}
2215impl serde::Serialize for CdcFilterNode {
2216 #[allow(deprecated)]
2217 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2218 where
2219 S: serde::Serializer,
2220 {
2221 use serde::ser::SerializeStruct;
2222 let mut len = 0;
2223 if self.search_condition.is_some() {
2224 len += 1;
2225 }
2226 if self.upstream_source_id != 0 {
2227 len += 1;
2228 }
2229 let mut struct_ser = serializer.serialize_struct("stream_plan.CdcFilterNode", len)?;
2230 if let Some(v) = self.search_condition.as_ref() {
2231 struct_ser.serialize_field("searchCondition", v)?;
2232 }
2233 if self.upstream_source_id != 0 {
2234 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
2235 }
2236 struct_ser.end()
2237 }
2238}
2239impl<'de> serde::Deserialize<'de> for CdcFilterNode {
2240 #[allow(deprecated)]
2241 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2242 where
2243 D: serde::Deserializer<'de>,
2244 {
2245 const FIELDS: &[&str] = &[
2246 "search_condition",
2247 "searchCondition",
2248 "upstream_source_id",
2249 "upstreamSourceId",
2250 ];
2251
2252 #[allow(clippy::enum_variant_names)]
2253 enum GeneratedField {
2254 SearchCondition,
2255 UpstreamSourceId,
2256 }
2257 impl<'de> serde::Deserialize<'de> for GeneratedField {
2258 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2259 where
2260 D: serde::Deserializer<'de>,
2261 {
2262 struct GeneratedVisitor;
2263
2264 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2265 type Value = GeneratedField;
2266
2267 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2268 write!(formatter, "expected one of: {:?}", &FIELDS)
2269 }
2270
2271 #[allow(unused_variables)]
2272 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2273 where
2274 E: serde::de::Error,
2275 {
2276 match value {
2277 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
2278 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
2279 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2280 }
2281 }
2282 }
2283 deserializer.deserialize_identifier(GeneratedVisitor)
2284 }
2285 }
2286 struct GeneratedVisitor;
2287 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2288 type Value = CdcFilterNode;
2289
2290 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2291 formatter.write_str("struct stream_plan.CdcFilterNode")
2292 }
2293
2294 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcFilterNode, V::Error>
2295 where
2296 V: serde::de::MapAccess<'de>,
2297 {
2298 let mut search_condition__ = None;
2299 let mut upstream_source_id__ = None;
2300 while let Some(k) = map_.next_key()? {
2301 match k {
2302 GeneratedField::SearchCondition => {
2303 if search_condition__.is_some() {
2304 return Err(serde::de::Error::duplicate_field("searchCondition"));
2305 }
2306 search_condition__ = map_.next_value()?;
2307 }
2308 GeneratedField::UpstreamSourceId => {
2309 if upstream_source_id__.is_some() {
2310 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
2311 }
2312 upstream_source_id__ =
2313 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2314 ;
2315 }
2316 }
2317 }
2318 Ok(CdcFilterNode {
2319 search_condition: search_condition__,
2320 upstream_source_id: upstream_source_id__.unwrap_or_default(),
2321 })
2322 }
2323 }
2324 deserializer.deserialize_struct("stream_plan.CdcFilterNode", FIELDS, GeneratedVisitor)
2325 }
2326}
2327impl serde::Serialize for ChangeLogNode {
2328 #[allow(deprecated)]
2329 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2330 where
2331 S: serde::Serializer,
2332 {
2333 use serde::ser::SerializeStruct;
2334 let mut len = 0;
2335 if self.need_op {
2336 len += 1;
2337 }
2338 let mut struct_ser = serializer.serialize_struct("stream_plan.ChangeLogNode", len)?;
2339 if self.need_op {
2340 struct_ser.serialize_field("needOp", &self.need_op)?;
2341 }
2342 struct_ser.end()
2343 }
2344}
2345impl<'de> serde::Deserialize<'de> for ChangeLogNode {
2346 #[allow(deprecated)]
2347 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2348 where
2349 D: serde::Deserializer<'de>,
2350 {
2351 const FIELDS: &[&str] = &[
2352 "need_op",
2353 "needOp",
2354 ];
2355
2356 #[allow(clippy::enum_variant_names)]
2357 enum GeneratedField {
2358 NeedOp,
2359 }
2360 impl<'de> serde::Deserialize<'de> for GeneratedField {
2361 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2362 where
2363 D: serde::Deserializer<'de>,
2364 {
2365 struct GeneratedVisitor;
2366
2367 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2368 type Value = GeneratedField;
2369
2370 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2371 write!(formatter, "expected one of: {:?}", &FIELDS)
2372 }
2373
2374 #[allow(unused_variables)]
2375 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2376 where
2377 E: serde::de::Error,
2378 {
2379 match value {
2380 "needOp" | "need_op" => Ok(GeneratedField::NeedOp),
2381 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2382 }
2383 }
2384 }
2385 deserializer.deserialize_identifier(GeneratedVisitor)
2386 }
2387 }
2388 struct GeneratedVisitor;
2389 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2390 type Value = ChangeLogNode;
2391
2392 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2393 formatter.write_str("struct stream_plan.ChangeLogNode")
2394 }
2395
2396 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ChangeLogNode, V::Error>
2397 where
2398 V: serde::de::MapAccess<'de>,
2399 {
2400 let mut need_op__ = None;
2401 while let Some(k) = map_.next_key()? {
2402 match k {
2403 GeneratedField::NeedOp => {
2404 if need_op__.is_some() {
2405 return Err(serde::de::Error::duplicate_field("needOp"));
2406 }
2407 need_op__ = Some(map_.next_value()?);
2408 }
2409 }
2410 }
2411 Ok(ChangeLogNode {
2412 need_op: need_op__.unwrap_or_default(),
2413 })
2414 }
2415 }
2416 deserializer.deserialize_struct("stream_plan.ChangeLogNode", FIELDS, GeneratedVisitor)
2417 }
2418}
2419impl serde::Serialize for CombinedMutation {
2420 #[allow(deprecated)]
2421 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2422 where
2423 S: serde::Serializer,
2424 {
2425 use serde::ser::SerializeStruct;
2426 let mut len = 0;
2427 if !self.mutations.is_empty() {
2428 len += 1;
2429 }
2430 let mut struct_ser = serializer.serialize_struct("stream_plan.CombinedMutation", len)?;
2431 if !self.mutations.is_empty() {
2432 struct_ser.serialize_field("mutations", &self.mutations)?;
2433 }
2434 struct_ser.end()
2435 }
2436}
2437impl<'de> serde::Deserialize<'de> for CombinedMutation {
2438 #[allow(deprecated)]
2439 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2440 where
2441 D: serde::Deserializer<'de>,
2442 {
2443 const FIELDS: &[&str] = &[
2444 "mutations",
2445 ];
2446
2447 #[allow(clippy::enum_variant_names)]
2448 enum GeneratedField {
2449 Mutations,
2450 }
2451 impl<'de> serde::Deserialize<'de> for GeneratedField {
2452 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2453 where
2454 D: serde::Deserializer<'de>,
2455 {
2456 struct GeneratedVisitor;
2457
2458 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2459 type Value = GeneratedField;
2460
2461 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2462 write!(formatter, "expected one of: {:?}", &FIELDS)
2463 }
2464
2465 #[allow(unused_variables)]
2466 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2467 where
2468 E: serde::de::Error,
2469 {
2470 match value {
2471 "mutations" => Ok(GeneratedField::Mutations),
2472 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2473 }
2474 }
2475 }
2476 deserializer.deserialize_identifier(GeneratedVisitor)
2477 }
2478 }
2479 struct GeneratedVisitor;
2480 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2481 type Value = CombinedMutation;
2482
2483 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2484 formatter.write_str("struct stream_plan.CombinedMutation")
2485 }
2486
2487 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CombinedMutation, V::Error>
2488 where
2489 V: serde::de::MapAccess<'de>,
2490 {
2491 let mut mutations__ = None;
2492 while let Some(k) = map_.next_key()? {
2493 match k {
2494 GeneratedField::Mutations => {
2495 if mutations__.is_some() {
2496 return Err(serde::de::Error::duplicate_field("mutations"));
2497 }
2498 mutations__ = Some(map_.next_value()?);
2499 }
2500 }
2501 }
2502 Ok(CombinedMutation {
2503 mutations: mutations__.unwrap_or_default(),
2504 })
2505 }
2506 }
2507 deserializer.deserialize_struct("stream_plan.CombinedMutation", FIELDS, GeneratedVisitor)
2508 }
2509}
2510impl serde::Serialize for ConnectorPropsChangeMutation {
2511 #[allow(deprecated)]
2512 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2513 where
2514 S: serde::Serializer,
2515 {
2516 use serde::ser::SerializeStruct;
2517 let mut len = 0;
2518 if !self.connector_props_infos.is_empty() {
2519 len += 1;
2520 }
2521 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation", len)?;
2522 if !self.connector_props_infos.is_empty() {
2523 struct_ser.serialize_field("connectorPropsInfos", &self.connector_props_infos)?;
2524 }
2525 struct_ser.end()
2526 }
2527}
2528impl<'de> serde::Deserialize<'de> for ConnectorPropsChangeMutation {
2529 #[allow(deprecated)]
2530 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2531 where
2532 D: serde::Deserializer<'de>,
2533 {
2534 const FIELDS: &[&str] = &[
2535 "connector_props_infos",
2536 "connectorPropsInfos",
2537 ];
2538
2539 #[allow(clippy::enum_variant_names)]
2540 enum GeneratedField {
2541 ConnectorPropsInfos,
2542 }
2543 impl<'de> serde::Deserialize<'de> for GeneratedField {
2544 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2545 where
2546 D: serde::Deserializer<'de>,
2547 {
2548 struct GeneratedVisitor;
2549
2550 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2551 type Value = GeneratedField;
2552
2553 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2554 write!(formatter, "expected one of: {:?}", &FIELDS)
2555 }
2556
2557 #[allow(unused_variables)]
2558 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2559 where
2560 E: serde::de::Error,
2561 {
2562 match value {
2563 "connectorPropsInfos" | "connector_props_infos" => Ok(GeneratedField::ConnectorPropsInfos),
2564 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2565 }
2566 }
2567 }
2568 deserializer.deserialize_identifier(GeneratedVisitor)
2569 }
2570 }
2571 struct GeneratedVisitor;
2572 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2573 type Value = ConnectorPropsChangeMutation;
2574
2575 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2576 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation")
2577 }
2578
2579 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectorPropsChangeMutation, V::Error>
2580 where
2581 V: serde::de::MapAccess<'de>,
2582 {
2583 let mut connector_props_infos__ = None;
2584 while let Some(k) = map_.next_key()? {
2585 match k {
2586 GeneratedField::ConnectorPropsInfos => {
2587 if connector_props_infos__.is_some() {
2588 return Err(serde::de::Error::duplicate_field("connectorPropsInfos"));
2589 }
2590 connector_props_infos__ = Some(
2591 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
2592 .into_iter().map(|(k,v)| (k.0, v)).collect()
2593 );
2594 }
2595 }
2596 }
2597 Ok(ConnectorPropsChangeMutation {
2598 connector_props_infos: connector_props_infos__.unwrap_or_default(),
2599 })
2600 }
2601 }
2602 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation", FIELDS, GeneratedVisitor)
2603 }
2604}
2605impl serde::Serialize for connector_props_change_mutation::ConnectorPropsInfo {
2606 #[allow(deprecated)]
2607 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2608 where
2609 S: serde::Serializer,
2610 {
2611 use serde::ser::SerializeStruct;
2612 let mut len = 0;
2613 if !self.connector_props_info.is_empty() {
2614 len += 1;
2615 }
2616 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", len)?;
2617 if !self.connector_props_info.is_empty() {
2618 struct_ser.serialize_field("connectorPropsInfo", &self.connector_props_info)?;
2619 }
2620 struct_ser.end()
2621 }
2622}
2623impl<'de> serde::Deserialize<'de> for connector_props_change_mutation::ConnectorPropsInfo {
2624 #[allow(deprecated)]
2625 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2626 where
2627 D: serde::Deserializer<'de>,
2628 {
2629 const FIELDS: &[&str] = &[
2630 "connector_props_info",
2631 "connectorPropsInfo",
2632 ];
2633
2634 #[allow(clippy::enum_variant_names)]
2635 enum GeneratedField {
2636 ConnectorPropsInfo,
2637 }
2638 impl<'de> serde::Deserialize<'de> for GeneratedField {
2639 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2640 where
2641 D: serde::Deserializer<'de>,
2642 {
2643 struct GeneratedVisitor;
2644
2645 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2646 type Value = GeneratedField;
2647
2648 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2649 write!(formatter, "expected one of: {:?}", &FIELDS)
2650 }
2651
2652 #[allow(unused_variables)]
2653 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2654 where
2655 E: serde::de::Error,
2656 {
2657 match value {
2658 "connectorPropsInfo" | "connector_props_info" => Ok(GeneratedField::ConnectorPropsInfo),
2659 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2660 }
2661 }
2662 }
2663 deserializer.deserialize_identifier(GeneratedVisitor)
2664 }
2665 }
2666 struct GeneratedVisitor;
2667 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2668 type Value = connector_props_change_mutation::ConnectorPropsInfo;
2669
2670 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2671 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo")
2672 }
2673
2674 fn visit_map<V>(self, mut map_: V) -> std::result::Result<connector_props_change_mutation::ConnectorPropsInfo, V::Error>
2675 where
2676 V: serde::de::MapAccess<'de>,
2677 {
2678 let mut connector_props_info__ = None;
2679 while let Some(k) = map_.next_key()? {
2680 match k {
2681 GeneratedField::ConnectorPropsInfo => {
2682 if connector_props_info__.is_some() {
2683 return Err(serde::de::Error::duplicate_field("connectorPropsInfo"));
2684 }
2685 connector_props_info__ = Some(
2686 map_.next_value::<std::collections::HashMap<_, _>>()?
2687 );
2688 }
2689 }
2690 }
2691 Ok(connector_props_change_mutation::ConnectorPropsInfo {
2692 connector_props_info: connector_props_info__.unwrap_or_default(),
2693 })
2694 }
2695 }
2696 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", FIELDS, GeneratedVisitor)
2697 }
2698}
2699impl serde::Serialize for DedupNode {
2700 #[allow(deprecated)]
2701 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2702 where
2703 S: serde::Serializer,
2704 {
2705 use serde::ser::SerializeStruct;
2706 let mut len = 0;
2707 if self.state_table.is_some() {
2708 len += 1;
2709 }
2710 if !self.dedup_column_indices.is_empty() {
2711 len += 1;
2712 }
2713 let mut struct_ser = serializer.serialize_struct("stream_plan.DedupNode", len)?;
2714 if let Some(v) = self.state_table.as_ref() {
2715 struct_ser.serialize_field("stateTable", v)?;
2716 }
2717 if !self.dedup_column_indices.is_empty() {
2718 struct_ser.serialize_field("dedupColumnIndices", &self.dedup_column_indices)?;
2719 }
2720 struct_ser.end()
2721 }
2722}
2723impl<'de> serde::Deserialize<'de> for DedupNode {
2724 #[allow(deprecated)]
2725 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2726 where
2727 D: serde::Deserializer<'de>,
2728 {
2729 const FIELDS: &[&str] = &[
2730 "state_table",
2731 "stateTable",
2732 "dedup_column_indices",
2733 "dedupColumnIndices",
2734 ];
2735
2736 #[allow(clippy::enum_variant_names)]
2737 enum GeneratedField {
2738 StateTable,
2739 DedupColumnIndices,
2740 }
2741 impl<'de> serde::Deserialize<'de> for GeneratedField {
2742 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2743 where
2744 D: serde::Deserializer<'de>,
2745 {
2746 struct GeneratedVisitor;
2747
2748 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2749 type Value = GeneratedField;
2750
2751 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2752 write!(formatter, "expected one of: {:?}", &FIELDS)
2753 }
2754
2755 #[allow(unused_variables)]
2756 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2757 where
2758 E: serde::de::Error,
2759 {
2760 match value {
2761 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
2762 "dedupColumnIndices" | "dedup_column_indices" => Ok(GeneratedField::DedupColumnIndices),
2763 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2764 }
2765 }
2766 }
2767 deserializer.deserialize_identifier(GeneratedVisitor)
2768 }
2769 }
2770 struct GeneratedVisitor;
2771 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2772 type Value = DedupNode;
2773
2774 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2775 formatter.write_str("struct stream_plan.DedupNode")
2776 }
2777
2778 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DedupNode, V::Error>
2779 where
2780 V: serde::de::MapAccess<'de>,
2781 {
2782 let mut state_table__ = None;
2783 let mut dedup_column_indices__ = None;
2784 while let Some(k) = map_.next_key()? {
2785 match k {
2786 GeneratedField::StateTable => {
2787 if state_table__.is_some() {
2788 return Err(serde::de::Error::duplicate_field("stateTable"));
2789 }
2790 state_table__ = map_.next_value()?;
2791 }
2792 GeneratedField::DedupColumnIndices => {
2793 if dedup_column_indices__.is_some() {
2794 return Err(serde::de::Error::duplicate_field("dedupColumnIndices"));
2795 }
2796 dedup_column_indices__ =
2797 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2798 .into_iter().map(|x| x.0).collect())
2799 ;
2800 }
2801 }
2802 }
2803 Ok(DedupNode {
2804 state_table: state_table__,
2805 dedup_column_indices: dedup_column_indices__.unwrap_or_default(),
2806 })
2807 }
2808 }
2809 deserializer.deserialize_struct("stream_plan.DedupNode", FIELDS, GeneratedVisitor)
2810 }
2811}
2812impl serde::Serialize for DeltaExpression {
2813 #[allow(deprecated)]
2814 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2815 where
2816 S: serde::Serializer,
2817 {
2818 use serde::ser::SerializeStruct;
2819 let mut len = 0;
2820 if self.delta_type != 0 {
2821 len += 1;
2822 }
2823 if self.delta.is_some() {
2824 len += 1;
2825 }
2826 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaExpression", len)?;
2827 if self.delta_type != 0 {
2828 let v = super::expr::expr_node::Type::try_from(self.delta_type)
2829 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.delta_type)))?;
2830 struct_ser.serialize_field("deltaType", &v)?;
2831 }
2832 if let Some(v) = self.delta.as_ref() {
2833 struct_ser.serialize_field("delta", v)?;
2834 }
2835 struct_ser.end()
2836 }
2837}
2838impl<'de> serde::Deserialize<'de> for DeltaExpression {
2839 #[allow(deprecated)]
2840 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2841 where
2842 D: serde::Deserializer<'de>,
2843 {
2844 const FIELDS: &[&str] = &[
2845 "delta_type",
2846 "deltaType",
2847 "delta",
2848 ];
2849
2850 #[allow(clippy::enum_variant_names)]
2851 enum GeneratedField {
2852 DeltaType,
2853 Delta,
2854 }
2855 impl<'de> serde::Deserialize<'de> for GeneratedField {
2856 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2857 where
2858 D: serde::Deserializer<'de>,
2859 {
2860 struct GeneratedVisitor;
2861
2862 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2863 type Value = GeneratedField;
2864
2865 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2866 write!(formatter, "expected one of: {:?}", &FIELDS)
2867 }
2868
2869 #[allow(unused_variables)]
2870 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2871 where
2872 E: serde::de::Error,
2873 {
2874 match value {
2875 "deltaType" | "delta_type" => Ok(GeneratedField::DeltaType),
2876 "delta" => Ok(GeneratedField::Delta),
2877 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2878 }
2879 }
2880 }
2881 deserializer.deserialize_identifier(GeneratedVisitor)
2882 }
2883 }
2884 struct GeneratedVisitor;
2885 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2886 type Value = DeltaExpression;
2887
2888 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2889 formatter.write_str("struct stream_plan.DeltaExpression")
2890 }
2891
2892 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaExpression, V::Error>
2893 where
2894 V: serde::de::MapAccess<'de>,
2895 {
2896 let mut delta_type__ = None;
2897 let mut delta__ = None;
2898 while let Some(k) = map_.next_key()? {
2899 match k {
2900 GeneratedField::DeltaType => {
2901 if delta_type__.is_some() {
2902 return Err(serde::de::Error::duplicate_field("deltaType"));
2903 }
2904 delta_type__ = Some(map_.next_value::<super::expr::expr_node::Type>()? as i32);
2905 }
2906 GeneratedField::Delta => {
2907 if delta__.is_some() {
2908 return Err(serde::de::Error::duplicate_field("delta"));
2909 }
2910 delta__ = map_.next_value()?;
2911 }
2912 }
2913 }
2914 Ok(DeltaExpression {
2915 delta_type: delta_type__.unwrap_or_default(),
2916 delta: delta__,
2917 })
2918 }
2919 }
2920 deserializer.deserialize_struct("stream_plan.DeltaExpression", FIELDS, GeneratedVisitor)
2921 }
2922}
2923impl serde::Serialize for DeltaIndexJoinNode {
2924 #[allow(deprecated)]
2925 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2926 where
2927 S: serde::Serializer,
2928 {
2929 use serde::ser::SerializeStruct;
2930 let mut len = 0;
2931 if self.join_type != 0 {
2932 len += 1;
2933 }
2934 if !self.left_key.is_empty() {
2935 len += 1;
2936 }
2937 if !self.right_key.is_empty() {
2938 len += 1;
2939 }
2940 if self.condition.is_some() {
2941 len += 1;
2942 }
2943 if self.left_table_id != 0 {
2944 len += 1;
2945 }
2946 if self.right_table_id != 0 {
2947 len += 1;
2948 }
2949 if self.left_info.is_some() {
2950 len += 1;
2951 }
2952 if self.right_info.is_some() {
2953 len += 1;
2954 }
2955 if !self.output_indices.is_empty() {
2956 len += 1;
2957 }
2958 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaIndexJoinNode", len)?;
2959 if self.join_type != 0 {
2960 let v = super::plan_common::JoinType::try_from(self.join_type)
2961 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
2962 struct_ser.serialize_field("joinType", &v)?;
2963 }
2964 if !self.left_key.is_empty() {
2965 struct_ser.serialize_field("leftKey", &self.left_key)?;
2966 }
2967 if !self.right_key.is_empty() {
2968 struct_ser.serialize_field("rightKey", &self.right_key)?;
2969 }
2970 if let Some(v) = self.condition.as_ref() {
2971 struct_ser.serialize_field("condition", v)?;
2972 }
2973 if self.left_table_id != 0 {
2974 struct_ser.serialize_field("leftTableId", &self.left_table_id)?;
2975 }
2976 if self.right_table_id != 0 {
2977 struct_ser.serialize_field("rightTableId", &self.right_table_id)?;
2978 }
2979 if let Some(v) = self.left_info.as_ref() {
2980 struct_ser.serialize_field("leftInfo", v)?;
2981 }
2982 if let Some(v) = self.right_info.as_ref() {
2983 struct_ser.serialize_field("rightInfo", v)?;
2984 }
2985 if !self.output_indices.is_empty() {
2986 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
2987 }
2988 struct_ser.end()
2989 }
2990}
2991impl<'de> serde::Deserialize<'de> for DeltaIndexJoinNode {
2992 #[allow(deprecated)]
2993 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2994 where
2995 D: serde::Deserializer<'de>,
2996 {
2997 const FIELDS: &[&str] = &[
2998 "join_type",
2999 "joinType",
3000 "left_key",
3001 "leftKey",
3002 "right_key",
3003 "rightKey",
3004 "condition",
3005 "left_table_id",
3006 "leftTableId",
3007 "right_table_id",
3008 "rightTableId",
3009 "left_info",
3010 "leftInfo",
3011 "right_info",
3012 "rightInfo",
3013 "output_indices",
3014 "outputIndices",
3015 ];
3016
3017 #[allow(clippy::enum_variant_names)]
3018 enum GeneratedField {
3019 JoinType,
3020 LeftKey,
3021 RightKey,
3022 Condition,
3023 LeftTableId,
3024 RightTableId,
3025 LeftInfo,
3026 RightInfo,
3027 OutputIndices,
3028 }
3029 impl<'de> serde::Deserialize<'de> for GeneratedField {
3030 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3031 where
3032 D: serde::Deserializer<'de>,
3033 {
3034 struct GeneratedVisitor;
3035
3036 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3037 type Value = GeneratedField;
3038
3039 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3040 write!(formatter, "expected one of: {:?}", &FIELDS)
3041 }
3042
3043 #[allow(unused_variables)]
3044 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3045 where
3046 E: serde::de::Error,
3047 {
3048 match value {
3049 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
3050 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
3051 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
3052 "condition" => Ok(GeneratedField::Condition),
3053 "leftTableId" | "left_table_id" => Ok(GeneratedField::LeftTableId),
3054 "rightTableId" | "right_table_id" => Ok(GeneratedField::RightTableId),
3055 "leftInfo" | "left_info" => Ok(GeneratedField::LeftInfo),
3056 "rightInfo" | "right_info" => Ok(GeneratedField::RightInfo),
3057 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
3058 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3059 }
3060 }
3061 }
3062 deserializer.deserialize_identifier(GeneratedVisitor)
3063 }
3064 }
3065 struct GeneratedVisitor;
3066 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3067 type Value = DeltaIndexJoinNode;
3068
3069 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3070 formatter.write_str("struct stream_plan.DeltaIndexJoinNode")
3071 }
3072
3073 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaIndexJoinNode, V::Error>
3074 where
3075 V: serde::de::MapAccess<'de>,
3076 {
3077 let mut join_type__ = None;
3078 let mut left_key__ = None;
3079 let mut right_key__ = None;
3080 let mut condition__ = None;
3081 let mut left_table_id__ = None;
3082 let mut right_table_id__ = None;
3083 let mut left_info__ = None;
3084 let mut right_info__ = None;
3085 let mut output_indices__ = None;
3086 while let Some(k) = map_.next_key()? {
3087 match k {
3088 GeneratedField::JoinType => {
3089 if join_type__.is_some() {
3090 return Err(serde::de::Error::duplicate_field("joinType"));
3091 }
3092 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
3093 }
3094 GeneratedField::LeftKey => {
3095 if left_key__.is_some() {
3096 return Err(serde::de::Error::duplicate_field("leftKey"));
3097 }
3098 left_key__ =
3099 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3100 .into_iter().map(|x| x.0).collect())
3101 ;
3102 }
3103 GeneratedField::RightKey => {
3104 if right_key__.is_some() {
3105 return Err(serde::de::Error::duplicate_field("rightKey"));
3106 }
3107 right_key__ =
3108 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3109 .into_iter().map(|x| x.0).collect())
3110 ;
3111 }
3112 GeneratedField::Condition => {
3113 if condition__.is_some() {
3114 return Err(serde::de::Error::duplicate_field("condition"));
3115 }
3116 condition__ = map_.next_value()?;
3117 }
3118 GeneratedField::LeftTableId => {
3119 if left_table_id__.is_some() {
3120 return Err(serde::de::Error::duplicate_field("leftTableId"));
3121 }
3122 left_table_id__ =
3123 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3124 ;
3125 }
3126 GeneratedField::RightTableId => {
3127 if right_table_id__.is_some() {
3128 return Err(serde::de::Error::duplicate_field("rightTableId"));
3129 }
3130 right_table_id__ =
3131 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3132 ;
3133 }
3134 GeneratedField::LeftInfo => {
3135 if left_info__.is_some() {
3136 return Err(serde::de::Error::duplicate_field("leftInfo"));
3137 }
3138 left_info__ = map_.next_value()?;
3139 }
3140 GeneratedField::RightInfo => {
3141 if right_info__.is_some() {
3142 return Err(serde::de::Error::duplicate_field("rightInfo"));
3143 }
3144 right_info__ = map_.next_value()?;
3145 }
3146 GeneratedField::OutputIndices => {
3147 if output_indices__.is_some() {
3148 return Err(serde::de::Error::duplicate_field("outputIndices"));
3149 }
3150 output_indices__ =
3151 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3152 .into_iter().map(|x| x.0).collect())
3153 ;
3154 }
3155 }
3156 }
3157 Ok(DeltaIndexJoinNode {
3158 join_type: join_type__.unwrap_or_default(),
3159 left_key: left_key__.unwrap_or_default(),
3160 right_key: right_key__.unwrap_or_default(),
3161 condition: condition__,
3162 left_table_id: left_table_id__.unwrap_or_default(),
3163 right_table_id: right_table_id__.unwrap_or_default(),
3164 left_info: left_info__,
3165 right_info: right_info__,
3166 output_indices: output_indices__.unwrap_or_default(),
3167 })
3168 }
3169 }
3170 deserializer.deserialize_struct("stream_plan.DeltaIndexJoinNode", FIELDS, GeneratedVisitor)
3171 }
3172}
3173impl serde::Serialize for DispatchOutputMapping {
3174 #[allow(deprecated)]
3175 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3176 where
3177 S: serde::Serializer,
3178 {
3179 use serde::ser::SerializeStruct;
3180 let mut len = 0;
3181 if !self.indices.is_empty() {
3182 len += 1;
3183 }
3184 if !self.types.is_empty() {
3185 len += 1;
3186 }
3187 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping", len)?;
3188 if !self.indices.is_empty() {
3189 struct_ser.serialize_field("indices", &self.indices)?;
3190 }
3191 if !self.types.is_empty() {
3192 struct_ser.serialize_field("types", &self.types)?;
3193 }
3194 struct_ser.end()
3195 }
3196}
3197impl<'de> serde::Deserialize<'de> for DispatchOutputMapping {
3198 #[allow(deprecated)]
3199 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3200 where
3201 D: serde::Deserializer<'de>,
3202 {
3203 const FIELDS: &[&str] = &[
3204 "indices",
3205 "types",
3206 ];
3207
3208 #[allow(clippy::enum_variant_names)]
3209 enum GeneratedField {
3210 Indices,
3211 Types,
3212 }
3213 impl<'de> serde::Deserialize<'de> for GeneratedField {
3214 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3215 where
3216 D: serde::Deserializer<'de>,
3217 {
3218 struct GeneratedVisitor;
3219
3220 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3221 type Value = GeneratedField;
3222
3223 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3224 write!(formatter, "expected one of: {:?}", &FIELDS)
3225 }
3226
3227 #[allow(unused_variables)]
3228 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3229 where
3230 E: serde::de::Error,
3231 {
3232 match value {
3233 "indices" => Ok(GeneratedField::Indices),
3234 "types" => Ok(GeneratedField::Types),
3235 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3236 }
3237 }
3238 }
3239 deserializer.deserialize_identifier(GeneratedVisitor)
3240 }
3241 }
3242 struct GeneratedVisitor;
3243 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3244 type Value = DispatchOutputMapping;
3245
3246 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3247 formatter.write_str("struct stream_plan.DispatchOutputMapping")
3248 }
3249
3250 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchOutputMapping, V::Error>
3251 where
3252 V: serde::de::MapAccess<'de>,
3253 {
3254 let mut indices__ = None;
3255 let mut types__ = None;
3256 while let Some(k) = map_.next_key()? {
3257 match k {
3258 GeneratedField::Indices => {
3259 if indices__.is_some() {
3260 return Err(serde::de::Error::duplicate_field("indices"));
3261 }
3262 indices__ =
3263 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3264 .into_iter().map(|x| x.0).collect())
3265 ;
3266 }
3267 GeneratedField::Types => {
3268 if types__.is_some() {
3269 return Err(serde::de::Error::duplicate_field("types"));
3270 }
3271 types__ = Some(map_.next_value()?);
3272 }
3273 }
3274 }
3275 Ok(DispatchOutputMapping {
3276 indices: indices__.unwrap_or_default(),
3277 types: types__.unwrap_or_default(),
3278 })
3279 }
3280 }
3281 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping", FIELDS, GeneratedVisitor)
3282 }
3283}
3284impl serde::Serialize for dispatch_output_mapping::TypePair {
3285 #[allow(deprecated)]
3286 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3287 where
3288 S: serde::Serializer,
3289 {
3290 use serde::ser::SerializeStruct;
3291 let mut len = 0;
3292 if self.upstream.is_some() {
3293 len += 1;
3294 }
3295 if self.downstream.is_some() {
3296 len += 1;
3297 }
3298 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping.TypePair", len)?;
3299 if let Some(v) = self.upstream.as_ref() {
3300 struct_ser.serialize_field("upstream", v)?;
3301 }
3302 if let Some(v) = self.downstream.as_ref() {
3303 struct_ser.serialize_field("downstream", v)?;
3304 }
3305 struct_ser.end()
3306 }
3307}
3308impl<'de> serde::Deserialize<'de> for dispatch_output_mapping::TypePair {
3309 #[allow(deprecated)]
3310 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3311 where
3312 D: serde::Deserializer<'de>,
3313 {
3314 const FIELDS: &[&str] = &[
3315 "upstream",
3316 "downstream",
3317 ];
3318
3319 #[allow(clippy::enum_variant_names)]
3320 enum GeneratedField {
3321 Upstream,
3322 Downstream,
3323 }
3324 impl<'de> serde::Deserialize<'de> for GeneratedField {
3325 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3326 where
3327 D: serde::Deserializer<'de>,
3328 {
3329 struct GeneratedVisitor;
3330
3331 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3332 type Value = GeneratedField;
3333
3334 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3335 write!(formatter, "expected one of: {:?}", &FIELDS)
3336 }
3337
3338 #[allow(unused_variables)]
3339 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3340 where
3341 E: serde::de::Error,
3342 {
3343 match value {
3344 "upstream" => Ok(GeneratedField::Upstream),
3345 "downstream" => Ok(GeneratedField::Downstream),
3346 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3347 }
3348 }
3349 }
3350 deserializer.deserialize_identifier(GeneratedVisitor)
3351 }
3352 }
3353 struct GeneratedVisitor;
3354 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3355 type Value = dispatch_output_mapping::TypePair;
3356
3357 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3358 formatter.write_str("struct stream_plan.DispatchOutputMapping.TypePair")
3359 }
3360
3361 fn visit_map<V>(self, mut map_: V) -> std::result::Result<dispatch_output_mapping::TypePair, V::Error>
3362 where
3363 V: serde::de::MapAccess<'de>,
3364 {
3365 let mut upstream__ = None;
3366 let mut downstream__ = None;
3367 while let Some(k) = map_.next_key()? {
3368 match k {
3369 GeneratedField::Upstream => {
3370 if upstream__.is_some() {
3371 return Err(serde::de::Error::duplicate_field("upstream"));
3372 }
3373 upstream__ = map_.next_value()?;
3374 }
3375 GeneratedField::Downstream => {
3376 if downstream__.is_some() {
3377 return Err(serde::de::Error::duplicate_field("downstream"));
3378 }
3379 downstream__ = map_.next_value()?;
3380 }
3381 }
3382 }
3383 Ok(dispatch_output_mapping::TypePair {
3384 upstream: upstream__,
3385 downstream: downstream__,
3386 })
3387 }
3388 }
3389 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping.TypePair", FIELDS, GeneratedVisitor)
3390 }
3391}
3392impl serde::Serialize for DispatchStrategy {
3393 #[allow(deprecated)]
3394 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3395 where
3396 S: serde::Serializer,
3397 {
3398 use serde::ser::SerializeStruct;
3399 let mut len = 0;
3400 if self.r#type != 0 {
3401 len += 1;
3402 }
3403 if !self.dist_key_indices.is_empty() {
3404 len += 1;
3405 }
3406 if self.output_mapping.is_some() {
3407 len += 1;
3408 }
3409 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchStrategy", len)?;
3410 if self.r#type != 0 {
3411 let v = DispatcherType::try_from(self.r#type)
3412 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3413 struct_ser.serialize_field("type", &v)?;
3414 }
3415 if !self.dist_key_indices.is_empty() {
3416 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3417 }
3418 if let Some(v) = self.output_mapping.as_ref() {
3419 struct_ser.serialize_field("outputMapping", v)?;
3420 }
3421 struct_ser.end()
3422 }
3423}
3424impl<'de> serde::Deserialize<'de> for DispatchStrategy {
3425 #[allow(deprecated)]
3426 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3427 where
3428 D: serde::Deserializer<'de>,
3429 {
3430 const FIELDS: &[&str] = &[
3431 "type",
3432 "dist_key_indices",
3433 "distKeyIndices",
3434 "output_mapping",
3435 "outputMapping",
3436 ];
3437
3438 #[allow(clippy::enum_variant_names)]
3439 enum GeneratedField {
3440 Type,
3441 DistKeyIndices,
3442 OutputMapping,
3443 }
3444 impl<'de> serde::Deserialize<'de> for GeneratedField {
3445 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3446 where
3447 D: serde::Deserializer<'de>,
3448 {
3449 struct GeneratedVisitor;
3450
3451 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3452 type Value = GeneratedField;
3453
3454 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3455 write!(formatter, "expected one of: {:?}", &FIELDS)
3456 }
3457
3458 #[allow(unused_variables)]
3459 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3460 where
3461 E: serde::de::Error,
3462 {
3463 match value {
3464 "type" => Ok(GeneratedField::Type),
3465 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3466 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3467 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3468 }
3469 }
3470 }
3471 deserializer.deserialize_identifier(GeneratedVisitor)
3472 }
3473 }
3474 struct GeneratedVisitor;
3475 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3476 type Value = DispatchStrategy;
3477
3478 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3479 formatter.write_str("struct stream_plan.DispatchStrategy")
3480 }
3481
3482 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchStrategy, V::Error>
3483 where
3484 V: serde::de::MapAccess<'de>,
3485 {
3486 let mut r#type__ = None;
3487 let mut dist_key_indices__ = None;
3488 let mut output_mapping__ = None;
3489 while let Some(k) = map_.next_key()? {
3490 match k {
3491 GeneratedField::Type => {
3492 if r#type__.is_some() {
3493 return Err(serde::de::Error::duplicate_field("type"));
3494 }
3495 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3496 }
3497 GeneratedField::DistKeyIndices => {
3498 if dist_key_indices__.is_some() {
3499 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3500 }
3501 dist_key_indices__ =
3502 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3503 .into_iter().map(|x| x.0).collect())
3504 ;
3505 }
3506 GeneratedField::OutputMapping => {
3507 if output_mapping__.is_some() {
3508 return Err(serde::de::Error::duplicate_field("outputMapping"));
3509 }
3510 output_mapping__ = map_.next_value()?;
3511 }
3512 }
3513 }
3514 Ok(DispatchStrategy {
3515 r#type: r#type__.unwrap_or_default(),
3516 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3517 output_mapping: output_mapping__,
3518 })
3519 }
3520 }
3521 deserializer.deserialize_struct("stream_plan.DispatchStrategy", FIELDS, GeneratedVisitor)
3522 }
3523}
3524impl serde::Serialize for Dispatcher {
3525 #[allow(deprecated)]
3526 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3527 where
3528 S: serde::Serializer,
3529 {
3530 use serde::ser::SerializeStruct;
3531 let mut len = 0;
3532 if self.r#type != 0 {
3533 len += 1;
3534 }
3535 if !self.dist_key_indices.is_empty() {
3536 len += 1;
3537 }
3538 if self.output_mapping.is_some() {
3539 len += 1;
3540 }
3541 if self.hash_mapping.is_some() {
3542 len += 1;
3543 }
3544 if self.dispatcher_id != 0 {
3545 len += 1;
3546 }
3547 if !self.downstream_actor_id.is_empty() {
3548 len += 1;
3549 }
3550 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatcher", len)?;
3551 if self.r#type != 0 {
3552 let v = DispatcherType::try_from(self.r#type)
3553 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3554 struct_ser.serialize_field("type", &v)?;
3555 }
3556 if !self.dist_key_indices.is_empty() {
3557 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3558 }
3559 if let Some(v) = self.output_mapping.as_ref() {
3560 struct_ser.serialize_field("outputMapping", v)?;
3561 }
3562 if let Some(v) = self.hash_mapping.as_ref() {
3563 struct_ser.serialize_field("hashMapping", v)?;
3564 }
3565 if self.dispatcher_id != 0 {
3566 #[allow(clippy::needless_borrow)]
3567 #[allow(clippy::needless_borrows_for_generic_args)]
3568 struct_ser.serialize_field("dispatcherId", ToString::to_string(&self.dispatcher_id).as_str())?;
3569 }
3570 if !self.downstream_actor_id.is_empty() {
3571 struct_ser.serialize_field("downstreamActorId", &self.downstream_actor_id)?;
3572 }
3573 struct_ser.end()
3574 }
3575}
3576impl<'de> serde::Deserialize<'de> for Dispatcher {
3577 #[allow(deprecated)]
3578 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3579 where
3580 D: serde::Deserializer<'de>,
3581 {
3582 const FIELDS: &[&str] = &[
3583 "type",
3584 "dist_key_indices",
3585 "distKeyIndices",
3586 "output_mapping",
3587 "outputMapping",
3588 "hash_mapping",
3589 "hashMapping",
3590 "dispatcher_id",
3591 "dispatcherId",
3592 "downstream_actor_id",
3593 "downstreamActorId",
3594 ];
3595
3596 #[allow(clippy::enum_variant_names)]
3597 enum GeneratedField {
3598 Type,
3599 DistKeyIndices,
3600 OutputMapping,
3601 HashMapping,
3602 DispatcherId,
3603 DownstreamActorId,
3604 }
3605 impl<'de> serde::Deserialize<'de> for GeneratedField {
3606 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3607 where
3608 D: serde::Deserializer<'de>,
3609 {
3610 struct GeneratedVisitor;
3611
3612 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3613 type Value = GeneratedField;
3614
3615 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3616 write!(formatter, "expected one of: {:?}", &FIELDS)
3617 }
3618
3619 #[allow(unused_variables)]
3620 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3621 where
3622 E: serde::de::Error,
3623 {
3624 match value {
3625 "type" => Ok(GeneratedField::Type),
3626 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3627 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3628 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
3629 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
3630 "downstreamActorId" | "downstream_actor_id" => Ok(GeneratedField::DownstreamActorId),
3631 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3632 }
3633 }
3634 }
3635 deserializer.deserialize_identifier(GeneratedVisitor)
3636 }
3637 }
3638 struct GeneratedVisitor;
3639 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3640 type Value = Dispatcher;
3641
3642 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3643 formatter.write_str("struct stream_plan.Dispatcher")
3644 }
3645
3646 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatcher, V::Error>
3647 where
3648 V: serde::de::MapAccess<'de>,
3649 {
3650 let mut r#type__ = None;
3651 let mut dist_key_indices__ = None;
3652 let mut output_mapping__ = None;
3653 let mut hash_mapping__ = None;
3654 let mut dispatcher_id__ = None;
3655 let mut downstream_actor_id__ = None;
3656 while let Some(k) = map_.next_key()? {
3657 match k {
3658 GeneratedField::Type => {
3659 if r#type__.is_some() {
3660 return Err(serde::de::Error::duplicate_field("type"));
3661 }
3662 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3663 }
3664 GeneratedField::DistKeyIndices => {
3665 if dist_key_indices__.is_some() {
3666 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3667 }
3668 dist_key_indices__ =
3669 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3670 .into_iter().map(|x| x.0).collect())
3671 ;
3672 }
3673 GeneratedField::OutputMapping => {
3674 if output_mapping__.is_some() {
3675 return Err(serde::de::Error::duplicate_field("outputMapping"));
3676 }
3677 output_mapping__ = map_.next_value()?;
3678 }
3679 GeneratedField::HashMapping => {
3680 if hash_mapping__.is_some() {
3681 return Err(serde::de::Error::duplicate_field("hashMapping"));
3682 }
3683 hash_mapping__ = map_.next_value()?;
3684 }
3685 GeneratedField::DispatcherId => {
3686 if dispatcher_id__.is_some() {
3687 return Err(serde::de::Error::duplicate_field("dispatcherId"));
3688 }
3689 dispatcher_id__ =
3690 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3691 ;
3692 }
3693 GeneratedField::DownstreamActorId => {
3694 if downstream_actor_id__.is_some() {
3695 return Err(serde::de::Error::duplicate_field("downstreamActorId"));
3696 }
3697 downstream_actor_id__ =
3698 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3699 .into_iter().map(|x| x.0).collect())
3700 ;
3701 }
3702 }
3703 }
3704 Ok(Dispatcher {
3705 r#type: r#type__.unwrap_or_default(),
3706 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3707 output_mapping: output_mapping__,
3708 hash_mapping: hash_mapping__,
3709 dispatcher_id: dispatcher_id__.unwrap_or_default(),
3710 downstream_actor_id: downstream_actor_id__.unwrap_or_default(),
3711 })
3712 }
3713 }
3714 deserializer.deserialize_struct("stream_plan.Dispatcher", FIELDS, GeneratedVisitor)
3715 }
3716}
3717impl serde::Serialize for DispatcherType {
3718 #[allow(deprecated)]
3719 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3720 where
3721 S: serde::Serializer,
3722 {
3723 let variant = match self {
3724 Self::Unspecified => "DISPATCHER_TYPE_UNSPECIFIED",
3725 Self::Hash => "DISPATCHER_TYPE_HASH",
3726 Self::Broadcast => "DISPATCHER_TYPE_BROADCAST",
3727 Self::Simple => "DISPATCHER_TYPE_SIMPLE",
3728 Self::NoShuffle => "DISPATCHER_TYPE_NO_SHUFFLE",
3729 };
3730 serializer.serialize_str(variant)
3731 }
3732}
3733impl<'de> serde::Deserialize<'de> for DispatcherType {
3734 #[allow(deprecated)]
3735 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3736 where
3737 D: serde::Deserializer<'de>,
3738 {
3739 const FIELDS: &[&str] = &[
3740 "DISPATCHER_TYPE_UNSPECIFIED",
3741 "DISPATCHER_TYPE_HASH",
3742 "DISPATCHER_TYPE_BROADCAST",
3743 "DISPATCHER_TYPE_SIMPLE",
3744 "DISPATCHER_TYPE_NO_SHUFFLE",
3745 ];
3746
3747 struct GeneratedVisitor;
3748
3749 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3750 type Value = DispatcherType;
3751
3752 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3753 write!(formatter, "expected one of: {:?}", &FIELDS)
3754 }
3755
3756 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3757 where
3758 E: serde::de::Error,
3759 {
3760 i32::try_from(v)
3761 .ok()
3762 .and_then(|x| x.try_into().ok())
3763 .ok_or_else(|| {
3764 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3765 })
3766 }
3767
3768 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3769 where
3770 E: serde::de::Error,
3771 {
3772 i32::try_from(v)
3773 .ok()
3774 .and_then(|x| x.try_into().ok())
3775 .ok_or_else(|| {
3776 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3777 })
3778 }
3779
3780 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3781 where
3782 E: serde::de::Error,
3783 {
3784 match value {
3785 "DISPATCHER_TYPE_UNSPECIFIED" => Ok(DispatcherType::Unspecified),
3786 "DISPATCHER_TYPE_HASH" => Ok(DispatcherType::Hash),
3787 "DISPATCHER_TYPE_BROADCAST" => Ok(DispatcherType::Broadcast),
3788 "DISPATCHER_TYPE_SIMPLE" => Ok(DispatcherType::Simple),
3789 "DISPATCHER_TYPE_NO_SHUFFLE" => Ok(DispatcherType::NoShuffle),
3790 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3791 }
3792 }
3793 }
3794 deserializer.deserialize_any(GeneratedVisitor)
3795 }
3796}
3797impl serde::Serialize for Dispatchers {
3798 #[allow(deprecated)]
3799 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3800 where
3801 S: serde::Serializer,
3802 {
3803 use serde::ser::SerializeStruct;
3804 let mut len = 0;
3805 if !self.dispatchers.is_empty() {
3806 len += 1;
3807 }
3808 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatchers", len)?;
3809 if !self.dispatchers.is_empty() {
3810 struct_ser.serialize_field("dispatchers", &self.dispatchers)?;
3811 }
3812 struct_ser.end()
3813 }
3814}
3815impl<'de> serde::Deserialize<'de> for Dispatchers {
3816 #[allow(deprecated)]
3817 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3818 where
3819 D: serde::Deserializer<'de>,
3820 {
3821 const FIELDS: &[&str] = &[
3822 "dispatchers",
3823 ];
3824
3825 #[allow(clippy::enum_variant_names)]
3826 enum GeneratedField {
3827 Dispatchers,
3828 }
3829 impl<'de> serde::Deserialize<'de> for GeneratedField {
3830 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3831 where
3832 D: serde::Deserializer<'de>,
3833 {
3834 struct GeneratedVisitor;
3835
3836 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3837 type Value = GeneratedField;
3838
3839 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3840 write!(formatter, "expected one of: {:?}", &FIELDS)
3841 }
3842
3843 #[allow(unused_variables)]
3844 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3845 where
3846 E: serde::de::Error,
3847 {
3848 match value {
3849 "dispatchers" => Ok(GeneratedField::Dispatchers),
3850 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3851 }
3852 }
3853 }
3854 deserializer.deserialize_identifier(GeneratedVisitor)
3855 }
3856 }
3857 struct GeneratedVisitor;
3858 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3859 type Value = Dispatchers;
3860
3861 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3862 formatter.write_str("struct stream_plan.Dispatchers")
3863 }
3864
3865 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatchers, V::Error>
3866 where
3867 V: serde::de::MapAccess<'de>,
3868 {
3869 let mut dispatchers__ = None;
3870 while let Some(k) = map_.next_key()? {
3871 match k {
3872 GeneratedField::Dispatchers => {
3873 if dispatchers__.is_some() {
3874 return Err(serde::de::Error::duplicate_field("dispatchers"));
3875 }
3876 dispatchers__ = Some(map_.next_value()?);
3877 }
3878 }
3879 }
3880 Ok(Dispatchers {
3881 dispatchers: dispatchers__.unwrap_or_default(),
3882 })
3883 }
3884 }
3885 deserializer.deserialize_struct("stream_plan.Dispatchers", FIELDS, GeneratedVisitor)
3886 }
3887}
3888impl serde::Serialize for DmlNode {
3889 #[allow(deprecated)]
3890 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3891 where
3892 S: serde::Serializer,
3893 {
3894 use serde::ser::SerializeStruct;
3895 let mut len = 0;
3896 if self.table_id != 0 {
3897 len += 1;
3898 }
3899 if self.table_version_id != 0 {
3900 len += 1;
3901 }
3902 if !self.column_descs.is_empty() {
3903 len += 1;
3904 }
3905 if self.rate_limit.is_some() {
3906 len += 1;
3907 }
3908 let mut struct_ser = serializer.serialize_struct("stream_plan.DmlNode", len)?;
3909 if self.table_id != 0 {
3910 struct_ser.serialize_field("tableId", &self.table_id)?;
3911 }
3912 if self.table_version_id != 0 {
3913 #[allow(clippy::needless_borrow)]
3914 #[allow(clippy::needless_borrows_for_generic_args)]
3915 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
3916 }
3917 if !self.column_descs.is_empty() {
3918 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
3919 }
3920 if let Some(v) = self.rate_limit.as_ref() {
3921 struct_ser.serialize_field("rateLimit", v)?;
3922 }
3923 struct_ser.end()
3924 }
3925}
3926impl<'de> serde::Deserialize<'de> for DmlNode {
3927 #[allow(deprecated)]
3928 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3929 where
3930 D: serde::Deserializer<'de>,
3931 {
3932 const FIELDS: &[&str] = &[
3933 "table_id",
3934 "tableId",
3935 "table_version_id",
3936 "tableVersionId",
3937 "column_descs",
3938 "columnDescs",
3939 "rate_limit",
3940 "rateLimit",
3941 ];
3942
3943 #[allow(clippy::enum_variant_names)]
3944 enum GeneratedField {
3945 TableId,
3946 TableVersionId,
3947 ColumnDescs,
3948 RateLimit,
3949 }
3950 impl<'de> serde::Deserialize<'de> for GeneratedField {
3951 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3952 where
3953 D: serde::Deserializer<'de>,
3954 {
3955 struct GeneratedVisitor;
3956
3957 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3958 type Value = GeneratedField;
3959
3960 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3961 write!(formatter, "expected one of: {:?}", &FIELDS)
3962 }
3963
3964 #[allow(unused_variables)]
3965 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3966 where
3967 E: serde::de::Error,
3968 {
3969 match value {
3970 "tableId" | "table_id" => Ok(GeneratedField::TableId),
3971 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
3972 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
3973 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
3974 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3975 }
3976 }
3977 }
3978 deserializer.deserialize_identifier(GeneratedVisitor)
3979 }
3980 }
3981 struct GeneratedVisitor;
3982 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3983 type Value = DmlNode;
3984
3985 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3986 formatter.write_str("struct stream_plan.DmlNode")
3987 }
3988
3989 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DmlNode, V::Error>
3990 where
3991 V: serde::de::MapAccess<'de>,
3992 {
3993 let mut table_id__ = None;
3994 let mut table_version_id__ = None;
3995 let mut column_descs__ = None;
3996 let mut rate_limit__ = None;
3997 while let Some(k) = map_.next_key()? {
3998 match k {
3999 GeneratedField::TableId => {
4000 if table_id__.is_some() {
4001 return Err(serde::de::Error::duplicate_field("tableId"));
4002 }
4003 table_id__ =
4004 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4005 ;
4006 }
4007 GeneratedField::TableVersionId => {
4008 if table_version_id__.is_some() {
4009 return Err(serde::de::Error::duplicate_field("tableVersionId"));
4010 }
4011 table_version_id__ =
4012 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4013 ;
4014 }
4015 GeneratedField::ColumnDescs => {
4016 if column_descs__.is_some() {
4017 return Err(serde::de::Error::duplicate_field("columnDescs"));
4018 }
4019 column_descs__ = Some(map_.next_value()?);
4020 }
4021 GeneratedField::RateLimit => {
4022 if rate_limit__.is_some() {
4023 return Err(serde::de::Error::duplicate_field("rateLimit"));
4024 }
4025 rate_limit__ =
4026 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4027 ;
4028 }
4029 }
4030 }
4031 Ok(DmlNode {
4032 table_id: table_id__.unwrap_or_default(),
4033 table_version_id: table_version_id__.unwrap_or_default(),
4034 column_descs: column_descs__.unwrap_or_default(),
4035 rate_limit: rate_limit__,
4036 })
4037 }
4038 }
4039 deserializer.deserialize_struct("stream_plan.DmlNode", FIELDS, GeneratedVisitor)
4040 }
4041}
4042impl serde::Serialize for DropSubscriptionsMutation {
4043 #[allow(deprecated)]
4044 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4045 where
4046 S: serde::Serializer,
4047 {
4048 use serde::ser::SerializeStruct;
4049 let mut len = 0;
4050 if !self.info.is_empty() {
4051 len += 1;
4052 }
4053 let mut struct_ser = serializer.serialize_struct("stream_plan.DropSubscriptionsMutation", len)?;
4054 if !self.info.is_empty() {
4055 struct_ser.serialize_field("info", &self.info)?;
4056 }
4057 struct_ser.end()
4058 }
4059}
4060impl<'de> serde::Deserialize<'de> for DropSubscriptionsMutation {
4061 #[allow(deprecated)]
4062 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4063 where
4064 D: serde::Deserializer<'de>,
4065 {
4066 const FIELDS: &[&str] = &[
4067 "info",
4068 ];
4069
4070 #[allow(clippy::enum_variant_names)]
4071 enum GeneratedField {
4072 Info,
4073 }
4074 impl<'de> serde::Deserialize<'de> for GeneratedField {
4075 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4076 where
4077 D: serde::Deserializer<'de>,
4078 {
4079 struct GeneratedVisitor;
4080
4081 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4082 type Value = GeneratedField;
4083
4084 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4085 write!(formatter, "expected one of: {:?}", &FIELDS)
4086 }
4087
4088 #[allow(unused_variables)]
4089 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4090 where
4091 E: serde::de::Error,
4092 {
4093 match value {
4094 "info" => Ok(GeneratedField::Info),
4095 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4096 }
4097 }
4098 }
4099 deserializer.deserialize_identifier(GeneratedVisitor)
4100 }
4101 }
4102 struct GeneratedVisitor;
4103 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4104 type Value = DropSubscriptionsMutation;
4105
4106 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4107 formatter.write_str("struct stream_plan.DropSubscriptionsMutation")
4108 }
4109
4110 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionsMutation, V::Error>
4111 where
4112 V: serde::de::MapAccess<'de>,
4113 {
4114 let mut info__ = None;
4115 while let Some(k) = map_.next_key()? {
4116 match k {
4117 GeneratedField::Info => {
4118 if info__.is_some() {
4119 return Err(serde::de::Error::duplicate_field("info"));
4120 }
4121 info__ = Some(map_.next_value()?);
4122 }
4123 }
4124 }
4125 Ok(DropSubscriptionsMutation {
4126 info: info__.unwrap_or_default(),
4127 })
4128 }
4129 }
4130 deserializer.deserialize_struct("stream_plan.DropSubscriptionsMutation", FIELDS, GeneratedVisitor)
4131 }
4132}
4133impl serde::Serialize for DynamicFilterNode {
4134 #[allow(deprecated)]
4135 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4136 where
4137 S: serde::Serializer,
4138 {
4139 use serde::ser::SerializeStruct;
4140 let mut len = 0;
4141 if self.left_key != 0 {
4142 len += 1;
4143 }
4144 if self.condition.is_some() {
4145 len += 1;
4146 }
4147 if self.left_table.is_some() {
4148 len += 1;
4149 }
4150 if self.right_table.is_some() {
4151 len += 1;
4152 }
4153 if self.condition_always_relax {
4154 len += 1;
4155 }
4156 let mut struct_ser = serializer.serialize_struct("stream_plan.DynamicFilterNode", len)?;
4157 if self.left_key != 0 {
4158 struct_ser.serialize_field("leftKey", &self.left_key)?;
4159 }
4160 if let Some(v) = self.condition.as_ref() {
4161 struct_ser.serialize_field("condition", v)?;
4162 }
4163 if let Some(v) = self.left_table.as_ref() {
4164 struct_ser.serialize_field("leftTable", v)?;
4165 }
4166 if let Some(v) = self.right_table.as_ref() {
4167 struct_ser.serialize_field("rightTable", v)?;
4168 }
4169 if self.condition_always_relax {
4170 struct_ser.serialize_field("conditionAlwaysRelax", &self.condition_always_relax)?;
4171 }
4172 struct_ser.end()
4173 }
4174}
4175impl<'de> serde::Deserialize<'de> for DynamicFilterNode {
4176 #[allow(deprecated)]
4177 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4178 where
4179 D: serde::Deserializer<'de>,
4180 {
4181 const FIELDS: &[&str] = &[
4182 "left_key",
4183 "leftKey",
4184 "condition",
4185 "left_table",
4186 "leftTable",
4187 "right_table",
4188 "rightTable",
4189 "condition_always_relax",
4190 "conditionAlwaysRelax",
4191 ];
4192
4193 #[allow(clippy::enum_variant_names)]
4194 enum GeneratedField {
4195 LeftKey,
4196 Condition,
4197 LeftTable,
4198 RightTable,
4199 ConditionAlwaysRelax,
4200 }
4201 impl<'de> serde::Deserialize<'de> for GeneratedField {
4202 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4203 where
4204 D: serde::Deserializer<'de>,
4205 {
4206 struct GeneratedVisitor;
4207
4208 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4209 type Value = GeneratedField;
4210
4211 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4212 write!(formatter, "expected one of: {:?}", &FIELDS)
4213 }
4214
4215 #[allow(unused_variables)]
4216 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4217 where
4218 E: serde::de::Error,
4219 {
4220 match value {
4221 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
4222 "condition" => Ok(GeneratedField::Condition),
4223 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
4224 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
4225 "conditionAlwaysRelax" | "condition_always_relax" => Ok(GeneratedField::ConditionAlwaysRelax),
4226 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4227 }
4228 }
4229 }
4230 deserializer.deserialize_identifier(GeneratedVisitor)
4231 }
4232 }
4233 struct GeneratedVisitor;
4234 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4235 type Value = DynamicFilterNode;
4236
4237 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4238 formatter.write_str("struct stream_plan.DynamicFilterNode")
4239 }
4240
4241 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DynamicFilterNode, V::Error>
4242 where
4243 V: serde::de::MapAccess<'de>,
4244 {
4245 let mut left_key__ = None;
4246 let mut condition__ = None;
4247 let mut left_table__ = None;
4248 let mut right_table__ = None;
4249 let mut condition_always_relax__ = None;
4250 while let Some(k) = map_.next_key()? {
4251 match k {
4252 GeneratedField::LeftKey => {
4253 if left_key__.is_some() {
4254 return Err(serde::de::Error::duplicate_field("leftKey"));
4255 }
4256 left_key__ =
4257 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4258 ;
4259 }
4260 GeneratedField::Condition => {
4261 if condition__.is_some() {
4262 return Err(serde::de::Error::duplicate_field("condition"));
4263 }
4264 condition__ = map_.next_value()?;
4265 }
4266 GeneratedField::LeftTable => {
4267 if left_table__.is_some() {
4268 return Err(serde::de::Error::duplicate_field("leftTable"));
4269 }
4270 left_table__ = map_.next_value()?;
4271 }
4272 GeneratedField::RightTable => {
4273 if right_table__.is_some() {
4274 return Err(serde::de::Error::duplicate_field("rightTable"));
4275 }
4276 right_table__ = map_.next_value()?;
4277 }
4278 GeneratedField::ConditionAlwaysRelax => {
4279 if condition_always_relax__.is_some() {
4280 return Err(serde::de::Error::duplicate_field("conditionAlwaysRelax"));
4281 }
4282 condition_always_relax__ = Some(map_.next_value()?);
4283 }
4284 }
4285 }
4286 Ok(DynamicFilterNode {
4287 left_key: left_key__.unwrap_or_default(),
4288 condition: condition__,
4289 left_table: left_table__,
4290 right_table: right_table__,
4291 condition_always_relax: condition_always_relax__.unwrap_or_default(),
4292 })
4293 }
4294 }
4295 deserializer.deserialize_struct("stream_plan.DynamicFilterNode", FIELDS, GeneratedVisitor)
4296 }
4297}
4298impl serde::Serialize for EowcOverWindowNode {
4299 #[allow(deprecated)]
4300 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4301 where
4302 S: serde::Serializer,
4303 {
4304 use serde::ser::SerializeStruct;
4305 let mut len = 0;
4306 if !self.calls.is_empty() {
4307 len += 1;
4308 }
4309 if !self.partition_by.is_empty() {
4310 len += 1;
4311 }
4312 if !self.order_by.is_empty() {
4313 len += 1;
4314 }
4315 if self.state_table.is_some() {
4316 len += 1;
4317 }
4318 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcOverWindowNode", len)?;
4319 if !self.calls.is_empty() {
4320 struct_ser.serialize_field("calls", &self.calls)?;
4321 }
4322 if !self.partition_by.is_empty() {
4323 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
4324 }
4325 if !self.order_by.is_empty() {
4326 struct_ser.serialize_field("orderBy", &self.order_by)?;
4327 }
4328 if let Some(v) = self.state_table.as_ref() {
4329 struct_ser.serialize_field("stateTable", v)?;
4330 }
4331 struct_ser.end()
4332 }
4333}
4334impl<'de> serde::Deserialize<'de> for EowcOverWindowNode {
4335 #[allow(deprecated)]
4336 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4337 where
4338 D: serde::Deserializer<'de>,
4339 {
4340 const FIELDS: &[&str] = &[
4341 "calls",
4342 "partition_by",
4343 "partitionBy",
4344 "order_by",
4345 "orderBy",
4346 "state_table",
4347 "stateTable",
4348 ];
4349
4350 #[allow(clippy::enum_variant_names)]
4351 enum GeneratedField {
4352 Calls,
4353 PartitionBy,
4354 OrderBy,
4355 StateTable,
4356 }
4357 impl<'de> serde::Deserialize<'de> for GeneratedField {
4358 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4359 where
4360 D: serde::Deserializer<'de>,
4361 {
4362 struct GeneratedVisitor;
4363
4364 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4365 type Value = GeneratedField;
4366
4367 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4368 write!(formatter, "expected one of: {:?}", &FIELDS)
4369 }
4370
4371 #[allow(unused_variables)]
4372 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4373 where
4374 E: serde::de::Error,
4375 {
4376 match value {
4377 "calls" => Ok(GeneratedField::Calls),
4378 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
4379 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
4380 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
4381 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4382 }
4383 }
4384 }
4385 deserializer.deserialize_identifier(GeneratedVisitor)
4386 }
4387 }
4388 struct GeneratedVisitor;
4389 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4390 type Value = EowcOverWindowNode;
4391
4392 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4393 formatter.write_str("struct stream_plan.EowcOverWindowNode")
4394 }
4395
4396 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcOverWindowNode, V::Error>
4397 where
4398 V: serde::de::MapAccess<'de>,
4399 {
4400 let mut calls__ = None;
4401 let mut partition_by__ = None;
4402 let mut order_by__ = None;
4403 let mut state_table__ = None;
4404 while let Some(k) = map_.next_key()? {
4405 match k {
4406 GeneratedField::Calls => {
4407 if calls__.is_some() {
4408 return Err(serde::de::Error::duplicate_field("calls"));
4409 }
4410 calls__ = Some(map_.next_value()?);
4411 }
4412 GeneratedField::PartitionBy => {
4413 if partition_by__.is_some() {
4414 return Err(serde::de::Error::duplicate_field("partitionBy"));
4415 }
4416 partition_by__ =
4417 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4418 .into_iter().map(|x| x.0).collect())
4419 ;
4420 }
4421 GeneratedField::OrderBy => {
4422 if order_by__.is_some() {
4423 return Err(serde::de::Error::duplicate_field("orderBy"));
4424 }
4425 order_by__ = Some(map_.next_value()?);
4426 }
4427 GeneratedField::StateTable => {
4428 if state_table__.is_some() {
4429 return Err(serde::de::Error::duplicate_field("stateTable"));
4430 }
4431 state_table__ = map_.next_value()?;
4432 }
4433 }
4434 }
4435 Ok(EowcOverWindowNode {
4436 calls: calls__.unwrap_or_default(),
4437 partition_by: partition_by__.unwrap_or_default(),
4438 order_by: order_by__.unwrap_or_default(),
4439 state_table: state_table__,
4440 })
4441 }
4442 }
4443 deserializer.deserialize_struct("stream_plan.EowcOverWindowNode", FIELDS, GeneratedVisitor)
4444 }
4445}
4446impl serde::Serialize for ExchangeNode {
4447 #[allow(deprecated)]
4448 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4449 where
4450 S: serde::Serializer,
4451 {
4452 use serde::ser::SerializeStruct;
4453 let mut len = 0;
4454 if self.strategy.is_some() {
4455 len += 1;
4456 }
4457 let mut struct_ser = serializer.serialize_struct("stream_plan.ExchangeNode", len)?;
4458 if let Some(v) = self.strategy.as_ref() {
4459 struct_ser.serialize_field("strategy", v)?;
4460 }
4461 struct_ser.end()
4462 }
4463}
4464impl<'de> serde::Deserialize<'de> for ExchangeNode {
4465 #[allow(deprecated)]
4466 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4467 where
4468 D: serde::Deserializer<'de>,
4469 {
4470 const FIELDS: &[&str] = &[
4471 "strategy",
4472 ];
4473
4474 #[allow(clippy::enum_variant_names)]
4475 enum GeneratedField {
4476 Strategy,
4477 }
4478 impl<'de> serde::Deserialize<'de> for GeneratedField {
4479 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4480 where
4481 D: serde::Deserializer<'de>,
4482 {
4483 struct GeneratedVisitor;
4484
4485 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4486 type Value = GeneratedField;
4487
4488 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4489 write!(formatter, "expected one of: {:?}", &FIELDS)
4490 }
4491
4492 #[allow(unused_variables)]
4493 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4494 where
4495 E: serde::de::Error,
4496 {
4497 match value {
4498 "strategy" => Ok(GeneratedField::Strategy),
4499 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4500 }
4501 }
4502 }
4503 deserializer.deserialize_identifier(GeneratedVisitor)
4504 }
4505 }
4506 struct GeneratedVisitor;
4507 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4508 type Value = ExchangeNode;
4509
4510 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4511 formatter.write_str("struct stream_plan.ExchangeNode")
4512 }
4513
4514 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExchangeNode, V::Error>
4515 where
4516 V: serde::de::MapAccess<'de>,
4517 {
4518 let mut strategy__ = None;
4519 while let Some(k) = map_.next_key()? {
4520 match k {
4521 GeneratedField::Strategy => {
4522 if strategy__.is_some() {
4523 return Err(serde::de::Error::duplicate_field("strategy"));
4524 }
4525 strategy__ = map_.next_value()?;
4526 }
4527 }
4528 }
4529 Ok(ExchangeNode {
4530 strategy: strategy__,
4531 })
4532 }
4533 }
4534 deserializer.deserialize_struct("stream_plan.ExchangeNode", FIELDS, GeneratedVisitor)
4535 }
4536}
4537impl serde::Serialize for ExpandNode {
4538 #[allow(deprecated)]
4539 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4540 where
4541 S: serde::Serializer,
4542 {
4543 use serde::ser::SerializeStruct;
4544 let mut len = 0;
4545 if !self.column_subsets.is_empty() {
4546 len += 1;
4547 }
4548 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode", len)?;
4549 if !self.column_subsets.is_empty() {
4550 struct_ser.serialize_field("columnSubsets", &self.column_subsets)?;
4551 }
4552 struct_ser.end()
4553 }
4554}
4555impl<'de> serde::Deserialize<'de> for ExpandNode {
4556 #[allow(deprecated)]
4557 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4558 where
4559 D: serde::Deserializer<'de>,
4560 {
4561 const FIELDS: &[&str] = &[
4562 "column_subsets",
4563 "columnSubsets",
4564 ];
4565
4566 #[allow(clippy::enum_variant_names)]
4567 enum GeneratedField {
4568 ColumnSubsets,
4569 }
4570 impl<'de> serde::Deserialize<'de> for GeneratedField {
4571 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4572 where
4573 D: serde::Deserializer<'de>,
4574 {
4575 struct GeneratedVisitor;
4576
4577 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4578 type Value = GeneratedField;
4579
4580 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4581 write!(formatter, "expected one of: {:?}", &FIELDS)
4582 }
4583
4584 #[allow(unused_variables)]
4585 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4586 where
4587 E: serde::de::Error,
4588 {
4589 match value {
4590 "columnSubsets" | "column_subsets" => Ok(GeneratedField::ColumnSubsets),
4591 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4592 }
4593 }
4594 }
4595 deserializer.deserialize_identifier(GeneratedVisitor)
4596 }
4597 }
4598 struct GeneratedVisitor;
4599 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4600 type Value = ExpandNode;
4601
4602 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4603 formatter.write_str("struct stream_plan.ExpandNode")
4604 }
4605
4606 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpandNode, V::Error>
4607 where
4608 V: serde::de::MapAccess<'de>,
4609 {
4610 let mut column_subsets__ = None;
4611 while let Some(k) = map_.next_key()? {
4612 match k {
4613 GeneratedField::ColumnSubsets => {
4614 if column_subsets__.is_some() {
4615 return Err(serde::de::Error::duplicate_field("columnSubsets"));
4616 }
4617 column_subsets__ = Some(map_.next_value()?);
4618 }
4619 }
4620 }
4621 Ok(ExpandNode {
4622 column_subsets: column_subsets__.unwrap_or_default(),
4623 })
4624 }
4625 }
4626 deserializer.deserialize_struct("stream_plan.ExpandNode", FIELDS, GeneratedVisitor)
4627 }
4628}
4629impl serde::Serialize for expand_node::Subset {
4630 #[allow(deprecated)]
4631 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4632 where
4633 S: serde::Serializer,
4634 {
4635 use serde::ser::SerializeStruct;
4636 let mut len = 0;
4637 if !self.column_indices.is_empty() {
4638 len += 1;
4639 }
4640 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode.Subset", len)?;
4641 if !self.column_indices.is_empty() {
4642 struct_ser.serialize_field("columnIndices", &self.column_indices)?;
4643 }
4644 struct_ser.end()
4645 }
4646}
4647impl<'de> serde::Deserialize<'de> for expand_node::Subset {
4648 #[allow(deprecated)]
4649 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4650 where
4651 D: serde::Deserializer<'de>,
4652 {
4653 const FIELDS: &[&str] = &[
4654 "column_indices",
4655 "columnIndices",
4656 ];
4657
4658 #[allow(clippy::enum_variant_names)]
4659 enum GeneratedField {
4660 ColumnIndices,
4661 }
4662 impl<'de> serde::Deserialize<'de> for GeneratedField {
4663 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4664 where
4665 D: serde::Deserializer<'de>,
4666 {
4667 struct GeneratedVisitor;
4668
4669 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4670 type Value = GeneratedField;
4671
4672 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4673 write!(formatter, "expected one of: {:?}", &FIELDS)
4674 }
4675
4676 #[allow(unused_variables)]
4677 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4678 where
4679 E: serde::de::Error,
4680 {
4681 match value {
4682 "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
4683 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4684 }
4685 }
4686 }
4687 deserializer.deserialize_identifier(GeneratedVisitor)
4688 }
4689 }
4690 struct GeneratedVisitor;
4691 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4692 type Value = expand_node::Subset;
4693
4694 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4695 formatter.write_str("struct stream_plan.ExpandNode.Subset")
4696 }
4697
4698 fn visit_map<V>(self, mut map_: V) -> std::result::Result<expand_node::Subset, V::Error>
4699 where
4700 V: serde::de::MapAccess<'de>,
4701 {
4702 let mut column_indices__ = None;
4703 while let Some(k) = map_.next_key()? {
4704 match k {
4705 GeneratedField::ColumnIndices => {
4706 if column_indices__.is_some() {
4707 return Err(serde::de::Error::duplicate_field("columnIndices"));
4708 }
4709 column_indices__ =
4710 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4711 .into_iter().map(|x| x.0).collect())
4712 ;
4713 }
4714 }
4715 }
4716 Ok(expand_node::Subset {
4717 column_indices: column_indices__.unwrap_or_default(),
4718 })
4719 }
4720 }
4721 deserializer.deserialize_struct("stream_plan.ExpandNode.Subset", FIELDS, GeneratedVisitor)
4722 }
4723}
4724impl serde::Serialize for FilterNode {
4725 #[allow(deprecated)]
4726 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4727 where
4728 S: serde::Serializer,
4729 {
4730 use serde::ser::SerializeStruct;
4731 let mut len = 0;
4732 if self.search_condition.is_some() {
4733 len += 1;
4734 }
4735 let mut struct_ser = serializer.serialize_struct("stream_plan.FilterNode", len)?;
4736 if let Some(v) = self.search_condition.as_ref() {
4737 struct_ser.serialize_field("searchCondition", v)?;
4738 }
4739 struct_ser.end()
4740 }
4741}
4742impl<'de> serde::Deserialize<'de> for FilterNode {
4743 #[allow(deprecated)]
4744 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4745 where
4746 D: serde::Deserializer<'de>,
4747 {
4748 const FIELDS: &[&str] = &[
4749 "search_condition",
4750 "searchCondition",
4751 ];
4752
4753 #[allow(clippy::enum_variant_names)]
4754 enum GeneratedField {
4755 SearchCondition,
4756 }
4757 impl<'de> serde::Deserialize<'de> for GeneratedField {
4758 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4759 where
4760 D: serde::Deserializer<'de>,
4761 {
4762 struct GeneratedVisitor;
4763
4764 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4765 type Value = GeneratedField;
4766
4767 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4768 write!(formatter, "expected one of: {:?}", &FIELDS)
4769 }
4770
4771 #[allow(unused_variables)]
4772 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4773 where
4774 E: serde::de::Error,
4775 {
4776 match value {
4777 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
4778 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4779 }
4780 }
4781 }
4782 deserializer.deserialize_identifier(GeneratedVisitor)
4783 }
4784 }
4785 struct GeneratedVisitor;
4786 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4787 type Value = FilterNode;
4788
4789 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4790 formatter.write_str("struct stream_plan.FilterNode")
4791 }
4792
4793 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FilterNode, V::Error>
4794 where
4795 V: serde::de::MapAccess<'de>,
4796 {
4797 let mut search_condition__ = None;
4798 while let Some(k) = map_.next_key()? {
4799 match k {
4800 GeneratedField::SearchCondition => {
4801 if search_condition__.is_some() {
4802 return Err(serde::de::Error::duplicate_field("searchCondition"));
4803 }
4804 search_condition__ = map_.next_value()?;
4805 }
4806 }
4807 }
4808 Ok(FilterNode {
4809 search_condition: search_condition__,
4810 })
4811 }
4812 }
4813 deserializer.deserialize_struct("stream_plan.FilterNode", FIELDS, GeneratedVisitor)
4814 }
4815}
4816impl serde::Serialize for GlobalApproxPercentileNode {
4817 #[allow(deprecated)]
4818 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4819 where
4820 S: serde::Serializer,
4821 {
4822 use serde::ser::SerializeStruct;
4823 let mut len = 0;
4824 if self.base != 0. {
4825 len += 1;
4826 }
4827 if self.quantile != 0. {
4828 len += 1;
4829 }
4830 if self.bucket_state_table.is_some() {
4831 len += 1;
4832 }
4833 if self.count_state_table.is_some() {
4834 len += 1;
4835 }
4836 let mut struct_ser = serializer.serialize_struct("stream_plan.GlobalApproxPercentileNode", len)?;
4837 if self.base != 0. {
4838 struct_ser.serialize_field("base", &self.base)?;
4839 }
4840 if self.quantile != 0. {
4841 struct_ser.serialize_field("quantile", &self.quantile)?;
4842 }
4843 if let Some(v) = self.bucket_state_table.as_ref() {
4844 struct_ser.serialize_field("bucketStateTable", v)?;
4845 }
4846 if let Some(v) = self.count_state_table.as_ref() {
4847 struct_ser.serialize_field("countStateTable", v)?;
4848 }
4849 struct_ser.end()
4850 }
4851}
4852impl<'de> serde::Deserialize<'de> for GlobalApproxPercentileNode {
4853 #[allow(deprecated)]
4854 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4855 where
4856 D: serde::Deserializer<'de>,
4857 {
4858 const FIELDS: &[&str] = &[
4859 "base",
4860 "quantile",
4861 "bucket_state_table",
4862 "bucketStateTable",
4863 "count_state_table",
4864 "countStateTable",
4865 ];
4866
4867 #[allow(clippy::enum_variant_names)]
4868 enum GeneratedField {
4869 Base,
4870 Quantile,
4871 BucketStateTable,
4872 CountStateTable,
4873 }
4874 impl<'de> serde::Deserialize<'de> for GeneratedField {
4875 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4876 where
4877 D: serde::Deserializer<'de>,
4878 {
4879 struct GeneratedVisitor;
4880
4881 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4882 type Value = GeneratedField;
4883
4884 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4885 write!(formatter, "expected one of: {:?}", &FIELDS)
4886 }
4887
4888 #[allow(unused_variables)]
4889 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4890 where
4891 E: serde::de::Error,
4892 {
4893 match value {
4894 "base" => Ok(GeneratedField::Base),
4895 "quantile" => Ok(GeneratedField::Quantile),
4896 "bucketStateTable" | "bucket_state_table" => Ok(GeneratedField::BucketStateTable),
4897 "countStateTable" | "count_state_table" => Ok(GeneratedField::CountStateTable),
4898 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4899 }
4900 }
4901 }
4902 deserializer.deserialize_identifier(GeneratedVisitor)
4903 }
4904 }
4905 struct GeneratedVisitor;
4906 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4907 type Value = GlobalApproxPercentileNode;
4908
4909 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4910 formatter.write_str("struct stream_plan.GlobalApproxPercentileNode")
4911 }
4912
4913 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GlobalApproxPercentileNode, V::Error>
4914 where
4915 V: serde::de::MapAccess<'de>,
4916 {
4917 let mut base__ = None;
4918 let mut quantile__ = None;
4919 let mut bucket_state_table__ = None;
4920 let mut count_state_table__ = None;
4921 while let Some(k) = map_.next_key()? {
4922 match k {
4923 GeneratedField::Base => {
4924 if base__.is_some() {
4925 return Err(serde::de::Error::duplicate_field("base"));
4926 }
4927 base__ =
4928 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4929 ;
4930 }
4931 GeneratedField::Quantile => {
4932 if quantile__.is_some() {
4933 return Err(serde::de::Error::duplicate_field("quantile"));
4934 }
4935 quantile__ =
4936 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4937 ;
4938 }
4939 GeneratedField::BucketStateTable => {
4940 if bucket_state_table__.is_some() {
4941 return Err(serde::de::Error::duplicate_field("bucketStateTable"));
4942 }
4943 bucket_state_table__ = map_.next_value()?;
4944 }
4945 GeneratedField::CountStateTable => {
4946 if count_state_table__.is_some() {
4947 return Err(serde::de::Error::duplicate_field("countStateTable"));
4948 }
4949 count_state_table__ = map_.next_value()?;
4950 }
4951 }
4952 }
4953 Ok(GlobalApproxPercentileNode {
4954 base: base__.unwrap_or_default(),
4955 quantile: quantile__.unwrap_or_default(),
4956 bucket_state_table: bucket_state_table__,
4957 count_state_table: count_state_table__,
4958 })
4959 }
4960 }
4961 deserializer.deserialize_struct("stream_plan.GlobalApproxPercentileNode", FIELDS, GeneratedVisitor)
4962 }
4963}
4964impl serde::Serialize for GroupTopNNode {
4965 #[allow(deprecated)]
4966 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4967 where
4968 S: serde::Serializer,
4969 {
4970 use serde::ser::SerializeStruct;
4971 let mut len = 0;
4972 if self.limit != 0 {
4973 len += 1;
4974 }
4975 if self.offset != 0 {
4976 len += 1;
4977 }
4978 if !self.group_key.is_empty() {
4979 len += 1;
4980 }
4981 if self.table.is_some() {
4982 len += 1;
4983 }
4984 if !self.order_by.is_empty() {
4985 len += 1;
4986 }
4987 if self.with_ties {
4988 len += 1;
4989 }
4990 let mut struct_ser = serializer.serialize_struct("stream_plan.GroupTopNNode", len)?;
4991 if self.limit != 0 {
4992 #[allow(clippy::needless_borrow)]
4993 #[allow(clippy::needless_borrows_for_generic_args)]
4994 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
4995 }
4996 if self.offset != 0 {
4997 #[allow(clippy::needless_borrow)]
4998 #[allow(clippy::needless_borrows_for_generic_args)]
4999 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
5000 }
5001 if !self.group_key.is_empty() {
5002 struct_ser.serialize_field("groupKey", &self.group_key)?;
5003 }
5004 if let Some(v) = self.table.as_ref() {
5005 struct_ser.serialize_field("table", v)?;
5006 }
5007 if !self.order_by.is_empty() {
5008 struct_ser.serialize_field("orderBy", &self.order_by)?;
5009 }
5010 if self.with_ties {
5011 struct_ser.serialize_field("withTies", &self.with_ties)?;
5012 }
5013 struct_ser.end()
5014 }
5015}
5016impl<'de> serde::Deserialize<'de> for GroupTopNNode {
5017 #[allow(deprecated)]
5018 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5019 where
5020 D: serde::Deserializer<'de>,
5021 {
5022 const FIELDS: &[&str] = &[
5023 "limit",
5024 "offset",
5025 "group_key",
5026 "groupKey",
5027 "table",
5028 "order_by",
5029 "orderBy",
5030 "with_ties",
5031 "withTies",
5032 ];
5033
5034 #[allow(clippy::enum_variant_names)]
5035 enum GeneratedField {
5036 Limit,
5037 Offset,
5038 GroupKey,
5039 Table,
5040 OrderBy,
5041 WithTies,
5042 }
5043 impl<'de> serde::Deserialize<'de> for GeneratedField {
5044 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5045 where
5046 D: serde::Deserializer<'de>,
5047 {
5048 struct GeneratedVisitor;
5049
5050 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5051 type Value = GeneratedField;
5052
5053 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5054 write!(formatter, "expected one of: {:?}", &FIELDS)
5055 }
5056
5057 #[allow(unused_variables)]
5058 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5059 where
5060 E: serde::de::Error,
5061 {
5062 match value {
5063 "limit" => Ok(GeneratedField::Limit),
5064 "offset" => Ok(GeneratedField::Offset),
5065 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5066 "table" => Ok(GeneratedField::Table),
5067 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
5068 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
5069 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5070 }
5071 }
5072 }
5073 deserializer.deserialize_identifier(GeneratedVisitor)
5074 }
5075 }
5076 struct GeneratedVisitor;
5077 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5078 type Value = GroupTopNNode;
5079
5080 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5081 formatter.write_str("struct stream_plan.GroupTopNNode")
5082 }
5083
5084 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupTopNNode, V::Error>
5085 where
5086 V: serde::de::MapAccess<'de>,
5087 {
5088 let mut limit__ = None;
5089 let mut offset__ = None;
5090 let mut group_key__ = None;
5091 let mut table__ = None;
5092 let mut order_by__ = None;
5093 let mut with_ties__ = None;
5094 while let Some(k) = map_.next_key()? {
5095 match k {
5096 GeneratedField::Limit => {
5097 if limit__.is_some() {
5098 return Err(serde::de::Error::duplicate_field("limit"));
5099 }
5100 limit__ =
5101 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5102 ;
5103 }
5104 GeneratedField::Offset => {
5105 if offset__.is_some() {
5106 return Err(serde::de::Error::duplicate_field("offset"));
5107 }
5108 offset__ =
5109 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5110 ;
5111 }
5112 GeneratedField::GroupKey => {
5113 if group_key__.is_some() {
5114 return Err(serde::de::Error::duplicate_field("groupKey"));
5115 }
5116 group_key__ =
5117 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5118 .into_iter().map(|x| x.0).collect())
5119 ;
5120 }
5121 GeneratedField::Table => {
5122 if table__.is_some() {
5123 return Err(serde::de::Error::duplicate_field("table"));
5124 }
5125 table__ = map_.next_value()?;
5126 }
5127 GeneratedField::OrderBy => {
5128 if order_by__.is_some() {
5129 return Err(serde::de::Error::duplicate_field("orderBy"));
5130 }
5131 order_by__ = Some(map_.next_value()?);
5132 }
5133 GeneratedField::WithTies => {
5134 if with_ties__.is_some() {
5135 return Err(serde::de::Error::duplicate_field("withTies"));
5136 }
5137 with_ties__ = Some(map_.next_value()?);
5138 }
5139 }
5140 }
5141 Ok(GroupTopNNode {
5142 limit: limit__.unwrap_or_default(),
5143 offset: offset__.unwrap_or_default(),
5144 group_key: group_key__.unwrap_or_default(),
5145 table: table__,
5146 order_by: order_by__.unwrap_or_default(),
5147 with_ties: with_ties__.unwrap_or_default(),
5148 })
5149 }
5150 }
5151 deserializer.deserialize_struct("stream_plan.GroupTopNNode", FIELDS, GeneratedVisitor)
5152 }
5153}
5154impl serde::Serialize for HashAggNode {
5155 #[allow(deprecated)]
5156 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5157 where
5158 S: serde::Serializer,
5159 {
5160 use serde::ser::SerializeStruct;
5161 let mut len = 0;
5162 if !self.group_key.is_empty() {
5163 len += 1;
5164 }
5165 if !self.agg_calls.is_empty() {
5166 len += 1;
5167 }
5168 if !self.agg_call_states.is_empty() {
5169 len += 1;
5170 }
5171 if self.intermediate_state_table.is_some() {
5172 len += 1;
5173 }
5174 if self.is_append_only {
5175 len += 1;
5176 }
5177 if !self.distinct_dedup_tables.is_empty() {
5178 len += 1;
5179 }
5180 if self.row_count_index != 0 {
5181 len += 1;
5182 }
5183 if self.emit_on_window_close {
5184 len += 1;
5185 }
5186 if self.version != 0 {
5187 len += 1;
5188 }
5189 let mut struct_ser = serializer.serialize_struct("stream_plan.HashAggNode", len)?;
5190 if !self.group_key.is_empty() {
5191 struct_ser.serialize_field("groupKey", &self.group_key)?;
5192 }
5193 if !self.agg_calls.is_empty() {
5194 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
5195 }
5196 if !self.agg_call_states.is_empty() {
5197 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
5198 }
5199 if let Some(v) = self.intermediate_state_table.as_ref() {
5200 struct_ser.serialize_field("intermediateStateTable", v)?;
5201 }
5202 if self.is_append_only {
5203 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5204 }
5205 if !self.distinct_dedup_tables.is_empty() {
5206 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
5207 }
5208 if self.row_count_index != 0 {
5209 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
5210 }
5211 if self.emit_on_window_close {
5212 struct_ser.serialize_field("emitOnWindowClose", &self.emit_on_window_close)?;
5213 }
5214 if self.version != 0 {
5215 let v = AggNodeVersion::try_from(self.version)
5216 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
5217 struct_ser.serialize_field("version", &v)?;
5218 }
5219 struct_ser.end()
5220 }
5221}
5222impl<'de> serde::Deserialize<'de> for HashAggNode {
5223 #[allow(deprecated)]
5224 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5225 where
5226 D: serde::Deserializer<'de>,
5227 {
5228 const FIELDS: &[&str] = &[
5229 "group_key",
5230 "groupKey",
5231 "agg_calls",
5232 "aggCalls",
5233 "agg_call_states",
5234 "aggCallStates",
5235 "intermediate_state_table",
5236 "intermediateStateTable",
5237 "is_append_only",
5238 "isAppendOnly",
5239 "distinct_dedup_tables",
5240 "distinctDedupTables",
5241 "row_count_index",
5242 "rowCountIndex",
5243 "emit_on_window_close",
5244 "emitOnWindowClose",
5245 "version",
5246 ];
5247
5248 #[allow(clippy::enum_variant_names)]
5249 enum GeneratedField {
5250 GroupKey,
5251 AggCalls,
5252 AggCallStates,
5253 IntermediateStateTable,
5254 IsAppendOnly,
5255 DistinctDedupTables,
5256 RowCountIndex,
5257 EmitOnWindowClose,
5258 Version,
5259 }
5260 impl<'de> serde::Deserialize<'de> for GeneratedField {
5261 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5262 where
5263 D: serde::Deserializer<'de>,
5264 {
5265 struct GeneratedVisitor;
5266
5267 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5268 type Value = GeneratedField;
5269
5270 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5271 write!(formatter, "expected one of: {:?}", &FIELDS)
5272 }
5273
5274 #[allow(unused_variables)]
5275 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5276 where
5277 E: serde::de::Error,
5278 {
5279 match value {
5280 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5281 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
5282 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
5283 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
5284 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5285 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
5286 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
5287 "emitOnWindowClose" | "emit_on_window_close" => Ok(GeneratedField::EmitOnWindowClose),
5288 "version" => Ok(GeneratedField::Version),
5289 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5290 }
5291 }
5292 }
5293 deserializer.deserialize_identifier(GeneratedVisitor)
5294 }
5295 }
5296 struct GeneratedVisitor;
5297 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5298 type Value = HashAggNode;
5299
5300 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5301 formatter.write_str("struct stream_plan.HashAggNode")
5302 }
5303
5304 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashAggNode, V::Error>
5305 where
5306 V: serde::de::MapAccess<'de>,
5307 {
5308 let mut group_key__ = None;
5309 let mut agg_calls__ = None;
5310 let mut agg_call_states__ = None;
5311 let mut intermediate_state_table__ = None;
5312 let mut is_append_only__ = None;
5313 let mut distinct_dedup_tables__ = None;
5314 let mut row_count_index__ = None;
5315 let mut emit_on_window_close__ = None;
5316 let mut version__ = None;
5317 while let Some(k) = map_.next_key()? {
5318 match k {
5319 GeneratedField::GroupKey => {
5320 if group_key__.is_some() {
5321 return Err(serde::de::Error::duplicate_field("groupKey"));
5322 }
5323 group_key__ =
5324 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5325 .into_iter().map(|x| x.0).collect())
5326 ;
5327 }
5328 GeneratedField::AggCalls => {
5329 if agg_calls__.is_some() {
5330 return Err(serde::de::Error::duplicate_field("aggCalls"));
5331 }
5332 agg_calls__ = Some(map_.next_value()?);
5333 }
5334 GeneratedField::AggCallStates => {
5335 if agg_call_states__.is_some() {
5336 return Err(serde::de::Error::duplicate_field("aggCallStates"));
5337 }
5338 agg_call_states__ = Some(map_.next_value()?);
5339 }
5340 GeneratedField::IntermediateStateTable => {
5341 if intermediate_state_table__.is_some() {
5342 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
5343 }
5344 intermediate_state_table__ = map_.next_value()?;
5345 }
5346 GeneratedField::IsAppendOnly => {
5347 if is_append_only__.is_some() {
5348 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
5349 }
5350 is_append_only__ = Some(map_.next_value()?);
5351 }
5352 GeneratedField::DistinctDedupTables => {
5353 if distinct_dedup_tables__.is_some() {
5354 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
5355 }
5356 distinct_dedup_tables__ = Some(
5357 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5358 .into_iter().map(|(k,v)| (k.0, v)).collect()
5359 );
5360 }
5361 GeneratedField::RowCountIndex => {
5362 if row_count_index__.is_some() {
5363 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
5364 }
5365 row_count_index__ =
5366 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5367 ;
5368 }
5369 GeneratedField::EmitOnWindowClose => {
5370 if emit_on_window_close__.is_some() {
5371 return Err(serde::de::Error::duplicate_field("emitOnWindowClose"));
5372 }
5373 emit_on_window_close__ = Some(map_.next_value()?);
5374 }
5375 GeneratedField::Version => {
5376 if version__.is_some() {
5377 return Err(serde::de::Error::duplicate_field("version"));
5378 }
5379 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
5380 }
5381 }
5382 }
5383 Ok(HashAggNode {
5384 group_key: group_key__.unwrap_or_default(),
5385 agg_calls: agg_calls__.unwrap_or_default(),
5386 agg_call_states: agg_call_states__.unwrap_or_default(),
5387 intermediate_state_table: intermediate_state_table__,
5388 is_append_only: is_append_only__.unwrap_or_default(),
5389 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
5390 row_count_index: row_count_index__.unwrap_or_default(),
5391 emit_on_window_close: emit_on_window_close__.unwrap_or_default(),
5392 version: version__.unwrap_or_default(),
5393 })
5394 }
5395 }
5396 deserializer.deserialize_struct("stream_plan.HashAggNode", FIELDS, GeneratedVisitor)
5397 }
5398}
5399impl serde::Serialize for HashJoinNode {
5400 #[allow(deprecated)]
5401 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5402 where
5403 S: serde::Serializer,
5404 {
5405 use serde::ser::SerializeStruct;
5406 let mut len = 0;
5407 if self.join_type != 0 {
5408 len += 1;
5409 }
5410 if !self.left_key.is_empty() {
5411 len += 1;
5412 }
5413 if !self.right_key.is_empty() {
5414 len += 1;
5415 }
5416 if self.condition.is_some() {
5417 len += 1;
5418 }
5419 if !self.inequality_pairs.is_empty() {
5420 len += 1;
5421 }
5422 if self.left_table.is_some() {
5423 len += 1;
5424 }
5425 if self.right_table.is_some() {
5426 len += 1;
5427 }
5428 if self.left_degree_table.is_some() {
5429 len += 1;
5430 }
5431 if self.right_degree_table.is_some() {
5432 len += 1;
5433 }
5434 if !self.output_indices.is_empty() {
5435 len += 1;
5436 }
5437 if !self.left_deduped_input_pk_indices.is_empty() {
5438 len += 1;
5439 }
5440 if !self.right_deduped_input_pk_indices.is_empty() {
5441 len += 1;
5442 }
5443 if !self.null_safe.is_empty() {
5444 len += 1;
5445 }
5446 if self.is_append_only {
5447 len += 1;
5448 }
5449 if self.join_encoding_type != 0 {
5450 len += 1;
5451 }
5452 let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinNode", len)?;
5453 if self.join_type != 0 {
5454 let v = super::plan_common::JoinType::try_from(self.join_type)
5455 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
5456 struct_ser.serialize_field("joinType", &v)?;
5457 }
5458 if !self.left_key.is_empty() {
5459 struct_ser.serialize_field("leftKey", &self.left_key)?;
5460 }
5461 if !self.right_key.is_empty() {
5462 struct_ser.serialize_field("rightKey", &self.right_key)?;
5463 }
5464 if let Some(v) = self.condition.as_ref() {
5465 struct_ser.serialize_field("condition", v)?;
5466 }
5467 if !self.inequality_pairs.is_empty() {
5468 struct_ser.serialize_field("inequalityPairs", &self.inequality_pairs)?;
5469 }
5470 if let Some(v) = self.left_table.as_ref() {
5471 struct_ser.serialize_field("leftTable", v)?;
5472 }
5473 if let Some(v) = self.right_table.as_ref() {
5474 struct_ser.serialize_field("rightTable", v)?;
5475 }
5476 if let Some(v) = self.left_degree_table.as_ref() {
5477 struct_ser.serialize_field("leftDegreeTable", v)?;
5478 }
5479 if let Some(v) = self.right_degree_table.as_ref() {
5480 struct_ser.serialize_field("rightDegreeTable", v)?;
5481 }
5482 if !self.output_indices.is_empty() {
5483 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
5484 }
5485 if !self.left_deduped_input_pk_indices.is_empty() {
5486 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
5487 }
5488 if !self.right_deduped_input_pk_indices.is_empty() {
5489 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
5490 }
5491 if !self.null_safe.is_empty() {
5492 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
5493 }
5494 if self.is_append_only {
5495 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5496 }
5497 if self.join_encoding_type != 0 {
5498 let v = JoinEncodingType::try_from(self.join_encoding_type)
5499 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
5500 struct_ser.serialize_field("joinEncodingType", &v)?;
5501 }
5502 struct_ser.end()
5503 }
5504}
5505impl<'de> serde::Deserialize<'de> for HashJoinNode {
5506 #[allow(deprecated)]
5507 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5508 where
5509 D: serde::Deserializer<'de>,
5510 {
5511 const FIELDS: &[&str] = &[
5512 "join_type",
5513 "joinType",
5514 "left_key",
5515 "leftKey",
5516 "right_key",
5517 "rightKey",
5518 "condition",
5519 "inequality_pairs",
5520 "inequalityPairs",
5521 "left_table",
5522 "leftTable",
5523 "right_table",
5524 "rightTable",
5525 "left_degree_table",
5526 "leftDegreeTable",
5527 "right_degree_table",
5528 "rightDegreeTable",
5529 "output_indices",
5530 "outputIndices",
5531 "left_deduped_input_pk_indices",
5532 "leftDedupedInputPkIndices",
5533 "right_deduped_input_pk_indices",
5534 "rightDedupedInputPkIndices",
5535 "null_safe",
5536 "nullSafe",
5537 "is_append_only",
5538 "isAppendOnly",
5539 "join_encoding_type",
5540 "joinEncodingType",
5541 ];
5542
5543 #[allow(clippy::enum_variant_names)]
5544 enum GeneratedField {
5545 JoinType,
5546 LeftKey,
5547 RightKey,
5548 Condition,
5549 InequalityPairs,
5550 LeftTable,
5551 RightTable,
5552 LeftDegreeTable,
5553 RightDegreeTable,
5554 OutputIndices,
5555 LeftDedupedInputPkIndices,
5556 RightDedupedInputPkIndices,
5557 NullSafe,
5558 IsAppendOnly,
5559 JoinEncodingType,
5560 }
5561 impl<'de> serde::Deserialize<'de> for GeneratedField {
5562 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5563 where
5564 D: serde::Deserializer<'de>,
5565 {
5566 struct GeneratedVisitor;
5567
5568 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5569 type Value = GeneratedField;
5570
5571 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5572 write!(formatter, "expected one of: {:?}", &FIELDS)
5573 }
5574
5575 #[allow(unused_variables)]
5576 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5577 where
5578 E: serde::de::Error,
5579 {
5580 match value {
5581 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
5582 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
5583 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
5584 "condition" => Ok(GeneratedField::Condition),
5585 "inequalityPairs" | "inequality_pairs" => Ok(GeneratedField::InequalityPairs),
5586 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
5587 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
5588 "leftDegreeTable" | "left_degree_table" => Ok(GeneratedField::LeftDegreeTable),
5589 "rightDegreeTable" | "right_degree_table" => Ok(GeneratedField::RightDegreeTable),
5590 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
5591 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
5592 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
5593 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
5594 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5595 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
5596 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5597 }
5598 }
5599 }
5600 deserializer.deserialize_identifier(GeneratedVisitor)
5601 }
5602 }
5603 struct GeneratedVisitor;
5604 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5605 type Value = HashJoinNode;
5606
5607 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5608 formatter.write_str("struct stream_plan.HashJoinNode")
5609 }
5610
5611 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinNode, V::Error>
5612 where
5613 V: serde::de::MapAccess<'de>,
5614 {
5615 let mut join_type__ = None;
5616 let mut left_key__ = None;
5617 let mut right_key__ = None;
5618 let mut condition__ = None;
5619 let mut inequality_pairs__ = None;
5620 let mut left_table__ = None;
5621 let mut right_table__ = None;
5622 let mut left_degree_table__ = None;
5623 let mut right_degree_table__ = None;
5624 let mut output_indices__ = None;
5625 let mut left_deduped_input_pk_indices__ = None;
5626 let mut right_deduped_input_pk_indices__ = None;
5627 let mut null_safe__ = None;
5628 let mut is_append_only__ = None;
5629 let mut join_encoding_type__ = None;
5630 while let Some(k) = map_.next_key()? {
5631 match k {
5632 GeneratedField::JoinType => {
5633 if join_type__.is_some() {
5634 return Err(serde::de::Error::duplicate_field("joinType"));
5635 }
5636 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
5637 }
5638 GeneratedField::LeftKey => {
5639 if left_key__.is_some() {
5640 return Err(serde::de::Error::duplicate_field("leftKey"));
5641 }
5642 left_key__ =
5643 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5644 .into_iter().map(|x| x.0).collect())
5645 ;
5646 }
5647 GeneratedField::RightKey => {
5648 if right_key__.is_some() {
5649 return Err(serde::de::Error::duplicate_field("rightKey"));
5650 }
5651 right_key__ =
5652 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5653 .into_iter().map(|x| x.0).collect())
5654 ;
5655 }
5656 GeneratedField::Condition => {
5657 if condition__.is_some() {
5658 return Err(serde::de::Error::duplicate_field("condition"));
5659 }
5660 condition__ = map_.next_value()?;
5661 }
5662 GeneratedField::InequalityPairs => {
5663 if inequality_pairs__.is_some() {
5664 return Err(serde::de::Error::duplicate_field("inequalityPairs"));
5665 }
5666 inequality_pairs__ = Some(map_.next_value()?);
5667 }
5668 GeneratedField::LeftTable => {
5669 if left_table__.is_some() {
5670 return Err(serde::de::Error::duplicate_field("leftTable"));
5671 }
5672 left_table__ = map_.next_value()?;
5673 }
5674 GeneratedField::RightTable => {
5675 if right_table__.is_some() {
5676 return Err(serde::de::Error::duplicate_field("rightTable"));
5677 }
5678 right_table__ = map_.next_value()?;
5679 }
5680 GeneratedField::LeftDegreeTable => {
5681 if left_degree_table__.is_some() {
5682 return Err(serde::de::Error::duplicate_field("leftDegreeTable"));
5683 }
5684 left_degree_table__ = map_.next_value()?;
5685 }
5686 GeneratedField::RightDegreeTable => {
5687 if right_degree_table__.is_some() {
5688 return Err(serde::de::Error::duplicate_field("rightDegreeTable"));
5689 }
5690 right_degree_table__ = map_.next_value()?;
5691 }
5692 GeneratedField::OutputIndices => {
5693 if output_indices__.is_some() {
5694 return Err(serde::de::Error::duplicate_field("outputIndices"));
5695 }
5696 output_indices__ =
5697 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5698 .into_iter().map(|x| x.0).collect())
5699 ;
5700 }
5701 GeneratedField::LeftDedupedInputPkIndices => {
5702 if left_deduped_input_pk_indices__.is_some() {
5703 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
5704 }
5705 left_deduped_input_pk_indices__ =
5706 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5707 .into_iter().map(|x| x.0).collect())
5708 ;
5709 }
5710 GeneratedField::RightDedupedInputPkIndices => {
5711 if right_deduped_input_pk_indices__.is_some() {
5712 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
5713 }
5714 right_deduped_input_pk_indices__ =
5715 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5716 .into_iter().map(|x| x.0).collect())
5717 ;
5718 }
5719 GeneratedField::NullSafe => {
5720 if null_safe__.is_some() {
5721 return Err(serde::de::Error::duplicate_field("nullSafe"));
5722 }
5723 null_safe__ = Some(map_.next_value()?);
5724 }
5725 GeneratedField::IsAppendOnly => {
5726 if is_append_only__.is_some() {
5727 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
5728 }
5729 is_append_only__ = Some(map_.next_value()?);
5730 }
5731 GeneratedField::JoinEncodingType => {
5732 if join_encoding_type__.is_some() {
5733 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
5734 }
5735 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
5736 }
5737 }
5738 }
5739 Ok(HashJoinNode {
5740 join_type: join_type__.unwrap_or_default(),
5741 left_key: left_key__.unwrap_or_default(),
5742 right_key: right_key__.unwrap_or_default(),
5743 condition: condition__,
5744 inequality_pairs: inequality_pairs__.unwrap_or_default(),
5745 left_table: left_table__,
5746 right_table: right_table__,
5747 left_degree_table: left_degree_table__,
5748 right_degree_table: right_degree_table__,
5749 output_indices: output_indices__.unwrap_or_default(),
5750 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
5751 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
5752 null_safe: null_safe__.unwrap_or_default(),
5753 is_append_only: is_append_only__.unwrap_or_default(),
5754 join_encoding_type: join_encoding_type__.unwrap_or_default(),
5755 })
5756 }
5757 }
5758 deserializer.deserialize_struct("stream_plan.HashJoinNode", FIELDS, GeneratedVisitor)
5759 }
5760}
5761impl serde::Serialize for HopWindowNode {
5762 #[allow(deprecated)]
5763 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5764 where
5765 S: serde::Serializer,
5766 {
5767 use serde::ser::SerializeStruct;
5768 let mut len = 0;
5769 if self.time_col != 0 {
5770 len += 1;
5771 }
5772 if self.window_slide.is_some() {
5773 len += 1;
5774 }
5775 if self.window_size.is_some() {
5776 len += 1;
5777 }
5778 if !self.output_indices.is_empty() {
5779 len += 1;
5780 }
5781 if !self.window_start_exprs.is_empty() {
5782 len += 1;
5783 }
5784 if !self.window_end_exprs.is_empty() {
5785 len += 1;
5786 }
5787 let mut struct_ser = serializer.serialize_struct("stream_plan.HopWindowNode", len)?;
5788 if self.time_col != 0 {
5789 struct_ser.serialize_field("timeCol", &self.time_col)?;
5790 }
5791 if let Some(v) = self.window_slide.as_ref() {
5792 struct_ser.serialize_field("windowSlide", v)?;
5793 }
5794 if let Some(v) = self.window_size.as_ref() {
5795 struct_ser.serialize_field("windowSize", v)?;
5796 }
5797 if !self.output_indices.is_empty() {
5798 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
5799 }
5800 if !self.window_start_exprs.is_empty() {
5801 struct_ser.serialize_field("windowStartExprs", &self.window_start_exprs)?;
5802 }
5803 if !self.window_end_exprs.is_empty() {
5804 struct_ser.serialize_field("windowEndExprs", &self.window_end_exprs)?;
5805 }
5806 struct_ser.end()
5807 }
5808}
5809impl<'de> serde::Deserialize<'de> for HopWindowNode {
5810 #[allow(deprecated)]
5811 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5812 where
5813 D: serde::Deserializer<'de>,
5814 {
5815 const FIELDS: &[&str] = &[
5816 "time_col",
5817 "timeCol",
5818 "window_slide",
5819 "windowSlide",
5820 "window_size",
5821 "windowSize",
5822 "output_indices",
5823 "outputIndices",
5824 "window_start_exprs",
5825 "windowStartExprs",
5826 "window_end_exprs",
5827 "windowEndExprs",
5828 ];
5829
5830 #[allow(clippy::enum_variant_names)]
5831 enum GeneratedField {
5832 TimeCol,
5833 WindowSlide,
5834 WindowSize,
5835 OutputIndices,
5836 WindowStartExprs,
5837 WindowEndExprs,
5838 }
5839 impl<'de> serde::Deserialize<'de> for GeneratedField {
5840 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5841 where
5842 D: serde::Deserializer<'de>,
5843 {
5844 struct GeneratedVisitor;
5845
5846 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5847 type Value = GeneratedField;
5848
5849 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5850 write!(formatter, "expected one of: {:?}", &FIELDS)
5851 }
5852
5853 #[allow(unused_variables)]
5854 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5855 where
5856 E: serde::de::Error,
5857 {
5858 match value {
5859 "timeCol" | "time_col" => Ok(GeneratedField::TimeCol),
5860 "windowSlide" | "window_slide" => Ok(GeneratedField::WindowSlide),
5861 "windowSize" | "window_size" => Ok(GeneratedField::WindowSize),
5862 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
5863 "windowStartExprs" | "window_start_exprs" => Ok(GeneratedField::WindowStartExprs),
5864 "windowEndExprs" | "window_end_exprs" => Ok(GeneratedField::WindowEndExprs),
5865 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5866 }
5867 }
5868 }
5869 deserializer.deserialize_identifier(GeneratedVisitor)
5870 }
5871 }
5872 struct GeneratedVisitor;
5873 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5874 type Value = HopWindowNode;
5875
5876 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5877 formatter.write_str("struct stream_plan.HopWindowNode")
5878 }
5879
5880 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HopWindowNode, V::Error>
5881 where
5882 V: serde::de::MapAccess<'de>,
5883 {
5884 let mut time_col__ = None;
5885 let mut window_slide__ = None;
5886 let mut window_size__ = None;
5887 let mut output_indices__ = None;
5888 let mut window_start_exprs__ = None;
5889 let mut window_end_exprs__ = None;
5890 while let Some(k) = map_.next_key()? {
5891 match k {
5892 GeneratedField::TimeCol => {
5893 if time_col__.is_some() {
5894 return Err(serde::de::Error::duplicate_field("timeCol"));
5895 }
5896 time_col__ =
5897 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5898 ;
5899 }
5900 GeneratedField::WindowSlide => {
5901 if window_slide__.is_some() {
5902 return Err(serde::de::Error::duplicate_field("windowSlide"));
5903 }
5904 window_slide__ = map_.next_value()?;
5905 }
5906 GeneratedField::WindowSize => {
5907 if window_size__.is_some() {
5908 return Err(serde::de::Error::duplicate_field("windowSize"));
5909 }
5910 window_size__ = map_.next_value()?;
5911 }
5912 GeneratedField::OutputIndices => {
5913 if output_indices__.is_some() {
5914 return Err(serde::de::Error::duplicate_field("outputIndices"));
5915 }
5916 output_indices__ =
5917 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5918 .into_iter().map(|x| x.0).collect())
5919 ;
5920 }
5921 GeneratedField::WindowStartExprs => {
5922 if window_start_exprs__.is_some() {
5923 return Err(serde::de::Error::duplicate_field("windowStartExprs"));
5924 }
5925 window_start_exprs__ = Some(map_.next_value()?);
5926 }
5927 GeneratedField::WindowEndExprs => {
5928 if window_end_exprs__.is_some() {
5929 return Err(serde::de::Error::duplicate_field("windowEndExprs"));
5930 }
5931 window_end_exprs__ = Some(map_.next_value()?);
5932 }
5933 }
5934 }
5935 Ok(HopWindowNode {
5936 time_col: time_col__.unwrap_or_default(),
5937 window_slide: window_slide__,
5938 window_size: window_size__,
5939 output_indices: output_indices__.unwrap_or_default(),
5940 window_start_exprs: window_start_exprs__.unwrap_or_default(),
5941 window_end_exprs: window_end_exprs__.unwrap_or_default(),
5942 })
5943 }
5944 }
5945 deserializer.deserialize_struct("stream_plan.HopWindowNode", FIELDS, GeneratedVisitor)
5946 }
5947}
5948impl serde::Serialize for InequalityPair {
5949 #[allow(deprecated)]
5950 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5951 where
5952 S: serde::Serializer,
5953 {
5954 use serde::ser::SerializeStruct;
5955 let mut len = 0;
5956 if self.key_required_larger != 0 {
5957 len += 1;
5958 }
5959 if self.key_required_smaller != 0 {
5960 len += 1;
5961 }
5962 if self.clean_state {
5963 len += 1;
5964 }
5965 if self.delta_expression.is_some() {
5966 len += 1;
5967 }
5968 let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPair", len)?;
5969 if self.key_required_larger != 0 {
5970 struct_ser.serialize_field("keyRequiredLarger", &self.key_required_larger)?;
5971 }
5972 if self.key_required_smaller != 0 {
5973 struct_ser.serialize_field("keyRequiredSmaller", &self.key_required_smaller)?;
5974 }
5975 if self.clean_state {
5976 struct_ser.serialize_field("cleanState", &self.clean_state)?;
5977 }
5978 if let Some(v) = self.delta_expression.as_ref() {
5979 struct_ser.serialize_field("deltaExpression", v)?;
5980 }
5981 struct_ser.end()
5982 }
5983}
5984impl<'de> serde::Deserialize<'de> for InequalityPair {
5985 #[allow(deprecated)]
5986 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5987 where
5988 D: serde::Deserializer<'de>,
5989 {
5990 const FIELDS: &[&str] = &[
5991 "key_required_larger",
5992 "keyRequiredLarger",
5993 "key_required_smaller",
5994 "keyRequiredSmaller",
5995 "clean_state",
5996 "cleanState",
5997 "delta_expression",
5998 "deltaExpression",
5999 ];
6000
6001 #[allow(clippy::enum_variant_names)]
6002 enum GeneratedField {
6003 KeyRequiredLarger,
6004 KeyRequiredSmaller,
6005 CleanState,
6006 DeltaExpression,
6007 }
6008 impl<'de> serde::Deserialize<'de> for GeneratedField {
6009 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6010 where
6011 D: serde::Deserializer<'de>,
6012 {
6013 struct GeneratedVisitor;
6014
6015 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6016 type Value = GeneratedField;
6017
6018 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6019 write!(formatter, "expected one of: {:?}", &FIELDS)
6020 }
6021
6022 #[allow(unused_variables)]
6023 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6024 where
6025 E: serde::de::Error,
6026 {
6027 match value {
6028 "keyRequiredLarger" | "key_required_larger" => Ok(GeneratedField::KeyRequiredLarger),
6029 "keyRequiredSmaller" | "key_required_smaller" => Ok(GeneratedField::KeyRequiredSmaller),
6030 "cleanState" | "clean_state" => Ok(GeneratedField::CleanState),
6031 "deltaExpression" | "delta_expression" => Ok(GeneratedField::DeltaExpression),
6032 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6033 }
6034 }
6035 }
6036 deserializer.deserialize_identifier(GeneratedVisitor)
6037 }
6038 }
6039 struct GeneratedVisitor;
6040 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6041 type Value = InequalityPair;
6042
6043 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6044 formatter.write_str("struct stream_plan.InequalityPair")
6045 }
6046
6047 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPair, V::Error>
6048 where
6049 V: serde::de::MapAccess<'de>,
6050 {
6051 let mut key_required_larger__ = None;
6052 let mut key_required_smaller__ = None;
6053 let mut clean_state__ = None;
6054 let mut delta_expression__ = None;
6055 while let Some(k) = map_.next_key()? {
6056 match k {
6057 GeneratedField::KeyRequiredLarger => {
6058 if key_required_larger__.is_some() {
6059 return Err(serde::de::Error::duplicate_field("keyRequiredLarger"));
6060 }
6061 key_required_larger__ =
6062 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6063 ;
6064 }
6065 GeneratedField::KeyRequiredSmaller => {
6066 if key_required_smaller__.is_some() {
6067 return Err(serde::de::Error::duplicate_field("keyRequiredSmaller"));
6068 }
6069 key_required_smaller__ =
6070 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6071 ;
6072 }
6073 GeneratedField::CleanState => {
6074 if clean_state__.is_some() {
6075 return Err(serde::de::Error::duplicate_field("cleanState"));
6076 }
6077 clean_state__ = Some(map_.next_value()?);
6078 }
6079 GeneratedField::DeltaExpression => {
6080 if delta_expression__.is_some() {
6081 return Err(serde::de::Error::duplicate_field("deltaExpression"));
6082 }
6083 delta_expression__ = map_.next_value()?;
6084 }
6085 }
6086 }
6087 Ok(InequalityPair {
6088 key_required_larger: key_required_larger__.unwrap_or_default(),
6089 key_required_smaller: key_required_smaller__.unwrap_or_default(),
6090 clean_state: clean_state__.unwrap_or_default(),
6091 delta_expression: delta_expression__,
6092 })
6093 }
6094 }
6095 deserializer.deserialize_struct("stream_plan.InequalityPair", FIELDS, GeneratedVisitor)
6096 }
6097}
6098impl serde::Serialize for JoinEncodingType {
6099 #[allow(deprecated)]
6100 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6101 where
6102 S: serde::Serializer,
6103 {
6104 let variant = match self {
6105 Self::Unspecified => "UNSPECIFIED",
6106 Self::MemoryOptimized => "MEMORY_OPTIMIZED",
6107 Self::CpuOptimized => "CPU_OPTIMIZED",
6108 };
6109 serializer.serialize_str(variant)
6110 }
6111}
6112impl<'de> serde::Deserialize<'de> for JoinEncodingType {
6113 #[allow(deprecated)]
6114 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6115 where
6116 D: serde::Deserializer<'de>,
6117 {
6118 const FIELDS: &[&str] = &[
6119 "UNSPECIFIED",
6120 "MEMORY_OPTIMIZED",
6121 "CPU_OPTIMIZED",
6122 ];
6123
6124 struct GeneratedVisitor;
6125
6126 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6127 type Value = JoinEncodingType;
6128
6129 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6130 write!(formatter, "expected one of: {:?}", &FIELDS)
6131 }
6132
6133 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6134 where
6135 E: serde::de::Error,
6136 {
6137 i32::try_from(v)
6138 .ok()
6139 .and_then(|x| x.try_into().ok())
6140 .ok_or_else(|| {
6141 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6142 })
6143 }
6144
6145 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6146 where
6147 E: serde::de::Error,
6148 {
6149 i32::try_from(v)
6150 .ok()
6151 .and_then(|x| x.try_into().ok())
6152 .ok_or_else(|| {
6153 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6154 })
6155 }
6156
6157 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6158 where
6159 E: serde::de::Error,
6160 {
6161 match value {
6162 "UNSPECIFIED" => Ok(JoinEncodingType::Unspecified),
6163 "MEMORY_OPTIMIZED" => Ok(JoinEncodingType::MemoryOptimized),
6164 "CPU_OPTIMIZED" => Ok(JoinEncodingType::CpuOptimized),
6165 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6166 }
6167 }
6168 }
6169 deserializer.deserialize_any(GeneratedVisitor)
6170 }
6171}
6172impl serde::Serialize for LoadFinishMutation {
6173 #[allow(deprecated)]
6174 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6175 where
6176 S: serde::Serializer,
6177 {
6178 use serde::ser::SerializeStruct;
6179 let mut len = 0;
6180 if self.associated_source_id != 0 {
6181 len += 1;
6182 }
6183 let mut struct_ser = serializer.serialize_struct("stream_plan.LoadFinishMutation", len)?;
6184 if self.associated_source_id != 0 {
6185 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
6186 }
6187 struct_ser.end()
6188 }
6189}
6190impl<'de> serde::Deserialize<'de> for LoadFinishMutation {
6191 #[allow(deprecated)]
6192 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6193 where
6194 D: serde::Deserializer<'de>,
6195 {
6196 const FIELDS: &[&str] = &[
6197 "associated_source_id",
6198 "associatedSourceId",
6199 ];
6200
6201 #[allow(clippy::enum_variant_names)]
6202 enum GeneratedField {
6203 AssociatedSourceId,
6204 }
6205 impl<'de> serde::Deserialize<'de> for GeneratedField {
6206 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6207 where
6208 D: serde::Deserializer<'de>,
6209 {
6210 struct GeneratedVisitor;
6211
6212 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6213 type Value = GeneratedField;
6214
6215 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6216 write!(formatter, "expected one of: {:?}", &FIELDS)
6217 }
6218
6219 #[allow(unused_variables)]
6220 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6221 where
6222 E: serde::de::Error,
6223 {
6224 match value {
6225 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
6226 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6227 }
6228 }
6229 }
6230 deserializer.deserialize_identifier(GeneratedVisitor)
6231 }
6232 }
6233 struct GeneratedVisitor;
6234 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6235 type Value = LoadFinishMutation;
6236
6237 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6238 formatter.write_str("struct stream_plan.LoadFinishMutation")
6239 }
6240
6241 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LoadFinishMutation, V::Error>
6242 where
6243 V: serde::de::MapAccess<'de>,
6244 {
6245 let mut associated_source_id__ = None;
6246 while let Some(k) = map_.next_key()? {
6247 match k {
6248 GeneratedField::AssociatedSourceId => {
6249 if associated_source_id__.is_some() {
6250 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
6251 }
6252 associated_source_id__ =
6253 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6254 ;
6255 }
6256 }
6257 }
6258 Ok(LoadFinishMutation {
6259 associated_source_id: associated_source_id__.unwrap_or_default(),
6260 })
6261 }
6262 }
6263 deserializer.deserialize_struct("stream_plan.LoadFinishMutation", FIELDS, GeneratedVisitor)
6264 }
6265}
6266impl serde::Serialize for LocalApproxPercentileNode {
6267 #[allow(deprecated)]
6268 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6269 where
6270 S: serde::Serializer,
6271 {
6272 use serde::ser::SerializeStruct;
6273 let mut len = 0;
6274 if self.base != 0. {
6275 len += 1;
6276 }
6277 if self.percentile_index != 0 {
6278 len += 1;
6279 }
6280 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalApproxPercentileNode", len)?;
6281 if self.base != 0. {
6282 struct_ser.serialize_field("base", &self.base)?;
6283 }
6284 if self.percentile_index != 0 {
6285 struct_ser.serialize_field("percentileIndex", &self.percentile_index)?;
6286 }
6287 struct_ser.end()
6288 }
6289}
6290impl<'de> serde::Deserialize<'de> for LocalApproxPercentileNode {
6291 #[allow(deprecated)]
6292 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6293 where
6294 D: serde::Deserializer<'de>,
6295 {
6296 const FIELDS: &[&str] = &[
6297 "base",
6298 "percentile_index",
6299 "percentileIndex",
6300 ];
6301
6302 #[allow(clippy::enum_variant_names)]
6303 enum GeneratedField {
6304 Base,
6305 PercentileIndex,
6306 }
6307 impl<'de> serde::Deserialize<'de> for GeneratedField {
6308 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6309 where
6310 D: serde::Deserializer<'de>,
6311 {
6312 struct GeneratedVisitor;
6313
6314 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6315 type Value = GeneratedField;
6316
6317 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6318 write!(formatter, "expected one of: {:?}", &FIELDS)
6319 }
6320
6321 #[allow(unused_variables)]
6322 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6323 where
6324 E: serde::de::Error,
6325 {
6326 match value {
6327 "base" => Ok(GeneratedField::Base),
6328 "percentileIndex" | "percentile_index" => Ok(GeneratedField::PercentileIndex),
6329 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6330 }
6331 }
6332 }
6333 deserializer.deserialize_identifier(GeneratedVisitor)
6334 }
6335 }
6336 struct GeneratedVisitor;
6337 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6338 type Value = LocalApproxPercentileNode;
6339
6340 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6341 formatter.write_str("struct stream_plan.LocalApproxPercentileNode")
6342 }
6343
6344 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalApproxPercentileNode, V::Error>
6345 where
6346 V: serde::de::MapAccess<'de>,
6347 {
6348 let mut base__ = None;
6349 let mut percentile_index__ = None;
6350 while let Some(k) = map_.next_key()? {
6351 match k {
6352 GeneratedField::Base => {
6353 if base__.is_some() {
6354 return Err(serde::de::Error::duplicate_field("base"));
6355 }
6356 base__ =
6357 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6358 ;
6359 }
6360 GeneratedField::PercentileIndex => {
6361 if percentile_index__.is_some() {
6362 return Err(serde::de::Error::duplicate_field("percentileIndex"));
6363 }
6364 percentile_index__ =
6365 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6366 ;
6367 }
6368 }
6369 }
6370 Ok(LocalApproxPercentileNode {
6371 base: base__.unwrap_or_default(),
6372 percentile_index: percentile_index__.unwrap_or_default(),
6373 })
6374 }
6375 }
6376 deserializer.deserialize_struct("stream_plan.LocalApproxPercentileNode", FIELDS, GeneratedVisitor)
6377 }
6378}
6379impl serde::Serialize for LookupNode {
6380 #[allow(deprecated)]
6381 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6382 where
6383 S: serde::Serializer,
6384 {
6385 use serde::ser::SerializeStruct;
6386 let mut len = 0;
6387 if !self.arrange_key.is_empty() {
6388 len += 1;
6389 }
6390 if !self.stream_key.is_empty() {
6391 len += 1;
6392 }
6393 if self.use_current_epoch {
6394 len += 1;
6395 }
6396 if !self.column_mapping.is_empty() {
6397 len += 1;
6398 }
6399 if self.arrangement_table_info.is_some() {
6400 len += 1;
6401 }
6402 if self.arrangement_table_id.is_some() {
6403 len += 1;
6404 }
6405 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupNode", len)?;
6406 if !self.arrange_key.is_empty() {
6407 struct_ser.serialize_field("arrangeKey", &self.arrange_key)?;
6408 }
6409 if !self.stream_key.is_empty() {
6410 struct_ser.serialize_field("streamKey", &self.stream_key)?;
6411 }
6412 if self.use_current_epoch {
6413 struct_ser.serialize_field("useCurrentEpoch", &self.use_current_epoch)?;
6414 }
6415 if !self.column_mapping.is_empty() {
6416 struct_ser.serialize_field("columnMapping", &self.column_mapping)?;
6417 }
6418 if let Some(v) = self.arrangement_table_info.as_ref() {
6419 struct_ser.serialize_field("arrangementTableInfo", v)?;
6420 }
6421 if let Some(v) = self.arrangement_table_id.as_ref() {
6422 match v {
6423 lookup_node::ArrangementTableId::TableId(v) => {
6424 struct_ser.serialize_field("tableId", v)?;
6425 }
6426 lookup_node::ArrangementTableId::IndexId(v) => {
6427 struct_ser.serialize_field("indexId", v)?;
6428 }
6429 }
6430 }
6431 struct_ser.end()
6432 }
6433}
6434impl<'de> serde::Deserialize<'de> for LookupNode {
6435 #[allow(deprecated)]
6436 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6437 where
6438 D: serde::Deserializer<'de>,
6439 {
6440 const FIELDS: &[&str] = &[
6441 "arrange_key",
6442 "arrangeKey",
6443 "stream_key",
6444 "streamKey",
6445 "use_current_epoch",
6446 "useCurrentEpoch",
6447 "column_mapping",
6448 "columnMapping",
6449 "arrangement_table_info",
6450 "arrangementTableInfo",
6451 "table_id",
6452 "tableId",
6453 "index_id",
6454 "indexId",
6455 ];
6456
6457 #[allow(clippy::enum_variant_names)]
6458 enum GeneratedField {
6459 ArrangeKey,
6460 StreamKey,
6461 UseCurrentEpoch,
6462 ColumnMapping,
6463 ArrangementTableInfo,
6464 TableId,
6465 IndexId,
6466 }
6467 impl<'de> serde::Deserialize<'de> for GeneratedField {
6468 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6469 where
6470 D: serde::Deserializer<'de>,
6471 {
6472 struct GeneratedVisitor;
6473
6474 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6475 type Value = GeneratedField;
6476
6477 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6478 write!(formatter, "expected one of: {:?}", &FIELDS)
6479 }
6480
6481 #[allow(unused_variables)]
6482 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6483 where
6484 E: serde::de::Error,
6485 {
6486 match value {
6487 "arrangeKey" | "arrange_key" => Ok(GeneratedField::ArrangeKey),
6488 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
6489 "useCurrentEpoch" | "use_current_epoch" => Ok(GeneratedField::UseCurrentEpoch),
6490 "columnMapping" | "column_mapping" => Ok(GeneratedField::ColumnMapping),
6491 "arrangementTableInfo" | "arrangement_table_info" => Ok(GeneratedField::ArrangementTableInfo),
6492 "tableId" | "table_id" => Ok(GeneratedField::TableId),
6493 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
6494 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6495 }
6496 }
6497 }
6498 deserializer.deserialize_identifier(GeneratedVisitor)
6499 }
6500 }
6501 struct GeneratedVisitor;
6502 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6503 type Value = LookupNode;
6504
6505 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6506 formatter.write_str("struct stream_plan.LookupNode")
6507 }
6508
6509 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupNode, V::Error>
6510 where
6511 V: serde::de::MapAccess<'de>,
6512 {
6513 let mut arrange_key__ = None;
6514 let mut stream_key__ = None;
6515 let mut use_current_epoch__ = None;
6516 let mut column_mapping__ = None;
6517 let mut arrangement_table_info__ = None;
6518 let mut arrangement_table_id__ = None;
6519 while let Some(k) = map_.next_key()? {
6520 match k {
6521 GeneratedField::ArrangeKey => {
6522 if arrange_key__.is_some() {
6523 return Err(serde::de::Error::duplicate_field("arrangeKey"));
6524 }
6525 arrange_key__ =
6526 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6527 .into_iter().map(|x| x.0).collect())
6528 ;
6529 }
6530 GeneratedField::StreamKey => {
6531 if stream_key__.is_some() {
6532 return Err(serde::de::Error::duplicate_field("streamKey"));
6533 }
6534 stream_key__ =
6535 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6536 .into_iter().map(|x| x.0).collect())
6537 ;
6538 }
6539 GeneratedField::UseCurrentEpoch => {
6540 if use_current_epoch__.is_some() {
6541 return Err(serde::de::Error::duplicate_field("useCurrentEpoch"));
6542 }
6543 use_current_epoch__ = Some(map_.next_value()?);
6544 }
6545 GeneratedField::ColumnMapping => {
6546 if column_mapping__.is_some() {
6547 return Err(serde::de::Error::duplicate_field("columnMapping"));
6548 }
6549 column_mapping__ =
6550 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6551 .into_iter().map(|x| x.0).collect())
6552 ;
6553 }
6554 GeneratedField::ArrangementTableInfo => {
6555 if arrangement_table_info__.is_some() {
6556 return Err(serde::de::Error::duplicate_field("arrangementTableInfo"));
6557 }
6558 arrangement_table_info__ = map_.next_value()?;
6559 }
6560 GeneratedField::TableId => {
6561 if arrangement_table_id__.is_some() {
6562 return Err(serde::de::Error::duplicate_field("tableId"));
6563 }
6564 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::TableId(x.0));
6565 }
6566 GeneratedField::IndexId => {
6567 if arrangement_table_id__.is_some() {
6568 return Err(serde::de::Error::duplicate_field("indexId"));
6569 }
6570 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::IndexId(x.0));
6571 }
6572 }
6573 }
6574 Ok(LookupNode {
6575 arrange_key: arrange_key__.unwrap_or_default(),
6576 stream_key: stream_key__.unwrap_or_default(),
6577 use_current_epoch: use_current_epoch__.unwrap_or_default(),
6578 column_mapping: column_mapping__.unwrap_or_default(),
6579 arrangement_table_info: arrangement_table_info__,
6580 arrangement_table_id: arrangement_table_id__,
6581 })
6582 }
6583 }
6584 deserializer.deserialize_struct("stream_plan.LookupNode", FIELDS, GeneratedVisitor)
6585 }
6586}
6587impl serde::Serialize for LookupUnionNode {
6588 #[allow(deprecated)]
6589 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6590 where
6591 S: serde::Serializer,
6592 {
6593 use serde::ser::SerializeStruct;
6594 let mut len = 0;
6595 if !self.order.is_empty() {
6596 len += 1;
6597 }
6598 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupUnionNode", len)?;
6599 if !self.order.is_empty() {
6600 struct_ser.serialize_field("order", &self.order)?;
6601 }
6602 struct_ser.end()
6603 }
6604}
6605impl<'de> serde::Deserialize<'de> for LookupUnionNode {
6606 #[allow(deprecated)]
6607 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6608 where
6609 D: serde::Deserializer<'de>,
6610 {
6611 const FIELDS: &[&str] = &[
6612 "order",
6613 ];
6614
6615 #[allow(clippy::enum_variant_names)]
6616 enum GeneratedField {
6617 Order,
6618 }
6619 impl<'de> serde::Deserialize<'de> for GeneratedField {
6620 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6621 where
6622 D: serde::Deserializer<'de>,
6623 {
6624 struct GeneratedVisitor;
6625
6626 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6627 type Value = GeneratedField;
6628
6629 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6630 write!(formatter, "expected one of: {:?}", &FIELDS)
6631 }
6632
6633 #[allow(unused_variables)]
6634 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6635 where
6636 E: serde::de::Error,
6637 {
6638 match value {
6639 "order" => Ok(GeneratedField::Order),
6640 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6641 }
6642 }
6643 }
6644 deserializer.deserialize_identifier(GeneratedVisitor)
6645 }
6646 }
6647 struct GeneratedVisitor;
6648 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6649 type Value = LookupUnionNode;
6650
6651 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6652 formatter.write_str("struct stream_plan.LookupUnionNode")
6653 }
6654
6655 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupUnionNode, V::Error>
6656 where
6657 V: serde::de::MapAccess<'de>,
6658 {
6659 let mut order__ = None;
6660 while let Some(k) = map_.next_key()? {
6661 match k {
6662 GeneratedField::Order => {
6663 if order__.is_some() {
6664 return Err(serde::de::Error::duplicate_field("order"));
6665 }
6666 order__ =
6667 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6668 .into_iter().map(|x| x.0).collect())
6669 ;
6670 }
6671 }
6672 }
6673 Ok(LookupUnionNode {
6674 order: order__.unwrap_or_default(),
6675 })
6676 }
6677 }
6678 deserializer.deserialize_struct("stream_plan.LookupUnionNode", FIELDS, GeneratedVisitor)
6679 }
6680}
6681impl serde::Serialize for MaterializeNode {
6682 #[allow(deprecated)]
6683 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6684 where
6685 S: serde::Serializer,
6686 {
6687 use serde::ser::SerializeStruct;
6688 let mut len = 0;
6689 if self.table_id != 0 {
6690 len += 1;
6691 }
6692 if !self.column_orders.is_empty() {
6693 len += 1;
6694 }
6695 if self.table.is_some() {
6696 len += 1;
6697 }
6698 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializeNode", len)?;
6699 if self.table_id != 0 {
6700 struct_ser.serialize_field("tableId", &self.table_id)?;
6701 }
6702 if !self.column_orders.is_empty() {
6703 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
6704 }
6705 if let Some(v) = self.table.as_ref() {
6706 struct_ser.serialize_field("table", v)?;
6707 }
6708 struct_ser.end()
6709 }
6710}
6711impl<'de> serde::Deserialize<'de> for MaterializeNode {
6712 #[allow(deprecated)]
6713 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6714 where
6715 D: serde::Deserializer<'de>,
6716 {
6717 const FIELDS: &[&str] = &[
6718 "table_id",
6719 "tableId",
6720 "column_orders",
6721 "columnOrders",
6722 "table",
6723 ];
6724
6725 #[allow(clippy::enum_variant_names)]
6726 enum GeneratedField {
6727 TableId,
6728 ColumnOrders,
6729 Table,
6730 }
6731 impl<'de> serde::Deserialize<'de> for GeneratedField {
6732 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6733 where
6734 D: serde::Deserializer<'de>,
6735 {
6736 struct GeneratedVisitor;
6737
6738 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6739 type Value = GeneratedField;
6740
6741 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6742 write!(formatter, "expected one of: {:?}", &FIELDS)
6743 }
6744
6745 #[allow(unused_variables)]
6746 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6747 where
6748 E: serde::de::Error,
6749 {
6750 match value {
6751 "tableId" | "table_id" => Ok(GeneratedField::TableId),
6752 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
6753 "table" => Ok(GeneratedField::Table),
6754 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6755 }
6756 }
6757 }
6758 deserializer.deserialize_identifier(GeneratedVisitor)
6759 }
6760 }
6761 struct GeneratedVisitor;
6762 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6763 type Value = MaterializeNode;
6764
6765 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6766 formatter.write_str("struct stream_plan.MaterializeNode")
6767 }
6768
6769 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializeNode, V::Error>
6770 where
6771 V: serde::de::MapAccess<'de>,
6772 {
6773 let mut table_id__ = None;
6774 let mut column_orders__ = None;
6775 let mut table__ = None;
6776 while let Some(k) = map_.next_key()? {
6777 match k {
6778 GeneratedField::TableId => {
6779 if table_id__.is_some() {
6780 return Err(serde::de::Error::duplicate_field("tableId"));
6781 }
6782 table_id__ =
6783 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6784 ;
6785 }
6786 GeneratedField::ColumnOrders => {
6787 if column_orders__.is_some() {
6788 return Err(serde::de::Error::duplicate_field("columnOrders"));
6789 }
6790 column_orders__ = Some(map_.next_value()?);
6791 }
6792 GeneratedField::Table => {
6793 if table__.is_some() {
6794 return Err(serde::de::Error::duplicate_field("table"));
6795 }
6796 table__ = map_.next_value()?;
6797 }
6798 }
6799 }
6800 Ok(MaterializeNode {
6801 table_id: table_id__.unwrap_or_default(),
6802 column_orders: column_orders__.unwrap_or_default(),
6803 table: table__,
6804 })
6805 }
6806 }
6807 deserializer.deserialize_struct("stream_plan.MaterializeNode", FIELDS, GeneratedVisitor)
6808 }
6809}
6810impl serde::Serialize for MaterializedExprsNode {
6811 #[allow(deprecated)]
6812 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6813 where
6814 S: serde::Serializer,
6815 {
6816 use serde::ser::SerializeStruct;
6817 let mut len = 0;
6818 if !self.exprs.is_empty() {
6819 len += 1;
6820 }
6821 if self.state_table.is_some() {
6822 len += 1;
6823 }
6824 if self.state_clean_col_idx.is_some() {
6825 len += 1;
6826 }
6827 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializedExprsNode", len)?;
6828 if !self.exprs.is_empty() {
6829 struct_ser.serialize_field("exprs", &self.exprs)?;
6830 }
6831 if let Some(v) = self.state_table.as_ref() {
6832 struct_ser.serialize_field("stateTable", v)?;
6833 }
6834 if let Some(v) = self.state_clean_col_idx.as_ref() {
6835 struct_ser.serialize_field("stateCleanColIdx", v)?;
6836 }
6837 struct_ser.end()
6838 }
6839}
6840impl<'de> serde::Deserialize<'de> for MaterializedExprsNode {
6841 #[allow(deprecated)]
6842 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6843 where
6844 D: serde::Deserializer<'de>,
6845 {
6846 const FIELDS: &[&str] = &[
6847 "exprs",
6848 "state_table",
6849 "stateTable",
6850 "state_clean_col_idx",
6851 "stateCleanColIdx",
6852 ];
6853
6854 #[allow(clippy::enum_variant_names)]
6855 enum GeneratedField {
6856 Exprs,
6857 StateTable,
6858 StateCleanColIdx,
6859 }
6860 impl<'de> serde::Deserialize<'de> for GeneratedField {
6861 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6862 where
6863 D: serde::Deserializer<'de>,
6864 {
6865 struct GeneratedVisitor;
6866
6867 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6868 type Value = GeneratedField;
6869
6870 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6871 write!(formatter, "expected one of: {:?}", &FIELDS)
6872 }
6873
6874 #[allow(unused_variables)]
6875 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6876 where
6877 E: serde::de::Error,
6878 {
6879 match value {
6880 "exprs" => Ok(GeneratedField::Exprs),
6881 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
6882 "stateCleanColIdx" | "state_clean_col_idx" => Ok(GeneratedField::StateCleanColIdx),
6883 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6884 }
6885 }
6886 }
6887 deserializer.deserialize_identifier(GeneratedVisitor)
6888 }
6889 }
6890 struct GeneratedVisitor;
6891 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6892 type Value = MaterializedExprsNode;
6893
6894 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6895 formatter.write_str("struct stream_plan.MaterializedExprsNode")
6896 }
6897
6898 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializedExprsNode, V::Error>
6899 where
6900 V: serde::de::MapAccess<'de>,
6901 {
6902 let mut exprs__ = None;
6903 let mut state_table__ = None;
6904 let mut state_clean_col_idx__ = None;
6905 while let Some(k) = map_.next_key()? {
6906 match k {
6907 GeneratedField::Exprs => {
6908 if exprs__.is_some() {
6909 return Err(serde::de::Error::duplicate_field("exprs"));
6910 }
6911 exprs__ = Some(map_.next_value()?);
6912 }
6913 GeneratedField::StateTable => {
6914 if state_table__.is_some() {
6915 return Err(serde::de::Error::duplicate_field("stateTable"));
6916 }
6917 state_table__ = map_.next_value()?;
6918 }
6919 GeneratedField::StateCleanColIdx => {
6920 if state_clean_col_idx__.is_some() {
6921 return Err(serde::de::Error::duplicate_field("stateCleanColIdx"));
6922 }
6923 state_clean_col_idx__ =
6924 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6925 ;
6926 }
6927 }
6928 }
6929 Ok(MaterializedExprsNode {
6930 exprs: exprs__.unwrap_or_default(),
6931 state_table: state_table__,
6932 state_clean_col_idx: state_clean_col_idx__,
6933 })
6934 }
6935 }
6936 deserializer.deserialize_struct("stream_plan.MaterializedExprsNode", FIELDS, GeneratedVisitor)
6937 }
6938}
6939impl serde::Serialize for MergeNode {
6940 #[allow(deprecated)]
6941 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6942 where
6943 S: serde::Serializer,
6944 {
6945 use serde::ser::SerializeStruct;
6946 let mut len = 0;
6947 if !self.upstream_actor_id.is_empty() {
6948 len += 1;
6949 }
6950 if self.upstream_fragment_id != 0 {
6951 len += 1;
6952 }
6953 if self.upstream_dispatcher_type != 0 {
6954 len += 1;
6955 }
6956 if !self.fields.is_empty() {
6957 len += 1;
6958 }
6959 let mut struct_ser = serializer.serialize_struct("stream_plan.MergeNode", len)?;
6960 if !self.upstream_actor_id.is_empty() {
6961 struct_ser.serialize_field("upstreamActorId", &self.upstream_actor_id)?;
6962 }
6963 if self.upstream_fragment_id != 0 {
6964 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
6965 }
6966 if self.upstream_dispatcher_type != 0 {
6967 let v = DispatcherType::try_from(self.upstream_dispatcher_type)
6968 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.upstream_dispatcher_type)))?;
6969 struct_ser.serialize_field("upstreamDispatcherType", &v)?;
6970 }
6971 if !self.fields.is_empty() {
6972 struct_ser.serialize_field("fields", &self.fields)?;
6973 }
6974 struct_ser.end()
6975 }
6976}
6977impl<'de> serde::Deserialize<'de> for MergeNode {
6978 #[allow(deprecated)]
6979 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6980 where
6981 D: serde::Deserializer<'de>,
6982 {
6983 const FIELDS: &[&str] = &[
6984 "upstream_actor_id",
6985 "upstreamActorId",
6986 "upstream_fragment_id",
6987 "upstreamFragmentId",
6988 "upstream_dispatcher_type",
6989 "upstreamDispatcherType",
6990 "fields",
6991 ];
6992
6993 #[allow(clippy::enum_variant_names)]
6994 enum GeneratedField {
6995 UpstreamActorId,
6996 UpstreamFragmentId,
6997 UpstreamDispatcherType,
6998 Fields,
6999 }
7000 impl<'de> serde::Deserialize<'de> for GeneratedField {
7001 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7002 where
7003 D: serde::Deserializer<'de>,
7004 {
7005 struct GeneratedVisitor;
7006
7007 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7008 type Value = GeneratedField;
7009
7010 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7011 write!(formatter, "expected one of: {:?}", &FIELDS)
7012 }
7013
7014 #[allow(unused_variables)]
7015 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7016 where
7017 E: serde::de::Error,
7018 {
7019 match value {
7020 "upstreamActorId" | "upstream_actor_id" => Ok(GeneratedField::UpstreamActorId),
7021 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
7022 "upstreamDispatcherType" | "upstream_dispatcher_type" => Ok(GeneratedField::UpstreamDispatcherType),
7023 "fields" => Ok(GeneratedField::Fields),
7024 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7025 }
7026 }
7027 }
7028 deserializer.deserialize_identifier(GeneratedVisitor)
7029 }
7030 }
7031 struct GeneratedVisitor;
7032 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7033 type Value = MergeNode;
7034
7035 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7036 formatter.write_str("struct stream_plan.MergeNode")
7037 }
7038
7039 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeNode, V::Error>
7040 where
7041 V: serde::de::MapAccess<'de>,
7042 {
7043 let mut upstream_actor_id__ = None;
7044 let mut upstream_fragment_id__ = None;
7045 let mut upstream_dispatcher_type__ = None;
7046 let mut fields__ = None;
7047 while let Some(k) = map_.next_key()? {
7048 match k {
7049 GeneratedField::UpstreamActorId => {
7050 if upstream_actor_id__.is_some() {
7051 return Err(serde::de::Error::duplicate_field("upstreamActorId"));
7052 }
7053 upstream_actor_id__ =
7054 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7055 .into_iter().map(|x| x.0).collect())
7056 ;
7057 }
7058 GeneratedField::UpstreamFragmentId => {
7059 if upstream_fragment_id__.is_some() {
7060 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
7061 }
7062 upstream_fragment_id__ =
7063 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7064 ;
7065 }
7066 GeneratedField::UpstreamDispatcherType => {
7067 if upstream_dispatcher_type__.is_some() {
7068 return Err(serde::de::Error::duplicate_field("upstreamDispatcherType"));
7069 }
7070 upstream_dispatcher_type__ = Some(map_.next_value::<DispatcherType>()? as i32);
7071 }
7072 GeneratedField::Fields => {
7073 if fields__.is_some() {
7074 return Err(serde::de::Error::duplicate_field("fields"));
7075 }
7076 fields__ = Some(map_.next_value()?);
7077 }
7078 }
7079 }
7080 Ok(MergeNode {
7081 upstream_actor_id: upstream_actor_id__.unwrap_or_default(),
7082 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
7083 upstream_dispatcher_type: upstream_dispatcher_type__.unwrap_or_default(),
7084 fields: fields__.unwrap_or_default(),
7085 })
7086 }
7087 }
7088 deserializer.deserialize_struct("stream_plan.MergeNode", FIELDS, GeneratedVisitor)
7089 }
7090}
7091impl serde::Serialize for NoOpNode {
7092 #[allow(deprecated)]
7093 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7094 where
7095 S: serde::Serializer,
7096 {
7097 use serde::ser::SerializeStruct;
7098 let len = 0;
7099 let struct_ser = serializer.serialize_struct("stream_plan.NoOpNode", len)?;
7100 struct_ser.end()
7101 }
7102}
7103impl<'de> serde::Deserialize<'de> for NoOpNode {
7104 #[allow(deprecated)]
7105 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7106 where
7107 D: serde::Deserializer<'de>,
7108 {
7109 const FIELDS: &[&str] = &[
7110 ];
7111
7112 #[allow(clippy::enum_variant_names)]
7113 enum GeneratedField {
7114 }
7115 impl<'de> serde::Deserialize<'de> for GeneratedField {
7116 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7117 where
7118 D: serde::Deserializer<'de>,
7119 {
7120 struct GeneratedVisitor;
7121
7122 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7123 type Value = GeneratedField;
7124
7125 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7126 write!(formatter, "expected one of: {:?}", &FIELDS)
7127 }
7128
7129 #[allow(unused_variables)]
7130 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7131 where
7132 E: serde::de::Error,
7133 {
7134 Err(serde::de::Error::unknown_field(value, FIELDS))
7135 }
7136 }
7137 deserializer.deserialize_identifier(GeneratedVisitor)
7138 }
7139 }
7140 struct GeneratedVisitor;
7141 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7142 type Value = NoOpNode;
7143
7144 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7145 formatter.write_str("struct stream_plan.NoOpNode")
7146 }
7147
7148 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NoOpNode, V::Error>
7149 where
7150 V: serde::de::MapAccess<'de>,
7151 {
7152 while map_.next_key::<GeneratedField>()?.is_some() {
7153 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7154 }
7155 Ok(NoOpNode {
7156 })
7157 }
7158 }
7159 deserializer.deserialize_struct("stream_plan.NoOpNode", FIELDS, GeneratedVisitor)
7160 }
7161}
7162impl serde::Serialize for NowModeGenerateSeries {
7163 #[allow(deprecated)]
7164 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7165 where
7166 S: serde::Serializer,
7167 {
7168 use serde::ser::SerializeStruct;
7169 let mut len = 0;
7170 if self.start_timestamp.is_some() {
7171 len += 1;
7172 }
7173 if self.interval.is_some() {
7174 len += 1;
7175 }
7176 let mut struct_ser = serializer.serialize_struct("stream_plan.NowModeGenerateSeries", len)?;
7177 if let Some(v) = self.start_timestamp.as_ref() {
7178 struct_ser.serialize_field("startTimestamp", v)?;
7179 }
7180 if let Some(v) = self.interval.as_ref() {
7181 struct_ser.serialize_field("interval", v)?;
7182 }
7183 struct_ser.end()
7184 }
7185}
7186impl<'de> serde::Deserialize<'de> for NowModeGenerateSeries {
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 "start_timestamp",
7194 "startTimestamp",
7195 "interval",
7196 ];
7197
7198 #[allow(clippy::enum_variant_names)]
7199 enum GeneratedField {
7200 StartTimestamp,
7201 Interval,
7202 }
7203 impl<'de> serde::Deserialize<'de> for GeneratedField {
7204 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7205 where
7206 D: serde::Deserializer<'de>,
7207 {
7208 struct GeneratedVisitor;
7209
7210 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7211 type Value = GeneratedField;
7212
7213 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7214 write!(formatter, "expected one of: {:?}", &FIELDS)
7215 }
7216
7217 #[allow(unused_variables)]
7218 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7219 where
7220 E: serde::de::Error,
7221 {
7222 match value {
7223 "startTimestamp" | "start_timestamp" => Ok(GeneratedField::StartTimestamp),
7224 "interval" => Ok(GeneratedField::Interval),
7225 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7226 }
7227 }
7228 }
7229 deserializer.deserialize_identifier(GeneratedVisitor)
7230 }
7231 }
7232 struct GeneratedVisitor;
7233 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7234 type Value = NowModeGenerateSeries;
7235
7236 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7237 formatter.write_str("struct stream_plan.NowModeGenerateSeries")
7238 }
7239
7240 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeGenerateSeries, V::Error>
7241 where
7242 V: serde::de::MapAccess<'de>,
7243 {
7244 let mut start_timestamp__ = None;
7245 let mut interval__ = None;
7246 while let Some(k) = map_.next_key()? {
7247 match k {
7248 GeneratedField::StartTimestamp => {
7249 if start_timestamp__.is_some() {
7250 return Err(serde::de::Error::duplicate_field("startTimestamp"));
7251 }
7252 start_timestamp__ = map_.next_value()?;
7253 }
7254 GeneratedField::Interval => {
7255 if interval__.is_some() {
7256 return Err(serde::de::Error::duplicate_field("interval"));
7257 }
7258 interval__ = map_.next_value()?;
7259 }
7260 }
7261 }
7262 Ok(NowModeGenerateSeries {
7263 start_timestamp: start_timestamp__,
7264 interval: interval__,
7265 })
7266 }
7267 }
7268 deserializer.deserialize_struct("stream_plan.NowModeGenerateSeries", FIELDS, GeneratedVisitor)
7269 }
7270}
7271impl serde::Serialize for NowModeUpdateCurrent {
7272 #[allow(deprecated)]
7273 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7274 where
7275 S: serde::Serializer,
7276 {
7277 use serde::ser::SerializeStruct;
7278 let len = 0;
7279 let struct_ser = serializer.serialize_struct("stream_plan.NowModeUpdateCurrent", len)?;
7280 struct_ser.end()
7281 }
7282}
7283impl<'de> serde::Deserialize<'de> for NowModeUpdateCurrent {
7284 #[allow(deprecated)]
7285 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7286 where
7287 D: serde::Deserializer<'de>,
7288 {
7289 const FIELDS: &[&str] = &[
7290 ];
7291
7292 #[allow(clippy::enum_variant_names)]
7293 enum GeneratedField {
7294 }
7295 impl<'de> serde::Deserialize<'de> for GeneratedField {
7296 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7297 where
7298 D: serde::Deserializer<'de>,
7299 {
7300 struct GeneratedVisitor;
7301
7302 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7303 type Value = GeneratedField;
7304
7305 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7306 write!(formatter, "expected one of: {:?}", &FIELDS)
7307 }
7308
7309 #[allow(unused_variables)]
7310 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7311 where
7312 E: serde::de::Error,
7313 {
7314 Err(serde::de::Error::unknown_field(value, FIELDS))
7315 }
7316 }
7317 deserializer.deserialize_identifier(GeneratedVisitor)
7318 }
7319 }
7320 struct GeneratedVisitor;
7321 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7322 type Value = NowModeUpdateCurrent;
7323
7324 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7325 formatter.write_str("struct stream_plan.NowModeUpdateCurrent")
7326 }
7327
7328 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeUpdateCurrent, V::Error>
7329 where
7330 V: serde::de::MapAccess<'de>,
7331 {
7332 while map_.next_key::<GeneratedField>()?.is_some() {
7333 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7334 }
7335 Ok(NowModeUpdateCurrent {
7336 })
7337 }
7338 }
7339 deserializer.deserialize_struct("stream_plan.NowModeUpdateCurrent", FIELDS, GeneratedVisitor)
7340 }
7341}
7342impl serde::Serialize for NowNode {
7343 #[allow(deprecated)]
7344 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7345 where
7346 S: serde::Serializer,
7347 {
7348 use serde::ser::SerializeStruct;
7349 let mut len = 0;
7350 if self.state_table.is_some() {
7351 len += 1;
7352 }
7353 if self.mode.is_some() {
7354 len += 1;
7355 }
7356 let mut struct_ser = serializer.serialize_struct("stream_plan.NowNode", len)?;
7357 if let Some(v) = self.state_table.as_ref() {
7358 struct_ser.serialize_field("stateTable", v)?;
7359 }
7360 if let Some(v) = self.mode.as_ref() {
7361 match v {
7362 now_node::Mode::UpdateCurrent(v) => {
7363 struct_ser.serialize_field("updateCurrent", v)?;
7364 }
7365 now_node::Mode::GenerateSeries(v) => {
7366 struct_ser.serialize_field("generateSeries", v)?;
7367 }
7368 }
7369 }
7370 struct_ser.end()
7371 }
7372}
7373impl<'de> serde::Deserialize<'de> for NowNode {
7374 #[allow(deprecated)]
7375 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7376 where
7377 D: serde::Deserializer<'de>,
7378 {
7379 const FIELDS: &[&str] = &[
7380 "state_table",
7381 "stateTable",
7382 "update_current",
7383 "updateCurrent",
7384 "generate_series",
7385 "generateSeries",
7386 ];
7387
7388 #[allow(clippy::enum_variant_names)]
7389 enum GeneratedField {
7390 StateTable,
7391 UpdateCurrent,
7392 GenerateSeries,
7393 }
7394 impl<'de> serde::Deserialize<'de> for GeneratedField {
7395 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7396 where
7397 D: serde::Deserializer<'de>,
7398 {
7399 struct GeneratedVisitor;
7400
7401 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7402 type Value = GeneratedField;
7403
7404 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7405 write!(formatter, "expected one of: {:?}", &FIELDS)
7406 }
7407
7408 #[allow(unused_variables)]
7409 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7410 where
7411 E: serde::de::Error,
7412 {
7413 match value {
7414 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7415 "updateCurrent" | "update_current" => Ok(GeneratedField::UpdateCurrent),
7416 "generateSeries" | "generate_series" => Ok(GeneratedField::GenerateSeries),
7417 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7418 }
7419 }
7420 }
7421 deserializer.deserialize_identifier(GeneratedVisitor)
7422 }
7423 }
7424 struct GeneratedVisitor;
7425 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7426 type Value = NowNode;
7427
7428 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7429 formatter.write_str("struct stream_plan.NowNode")
7430 }
7431
7432 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowNode, V::Error>
7433 where
7434 V: serde::de::MapAccess<'de>,
7435 {
7436 let mut state_table__ = None;
7437 let mut mode__ = None;
7438 while let Some(k) = map_.next_key()? {
7439 match k {
7440 GeneratedField::StateTable => {
7441 if state_table__.is_some() {
7442 return Err(serde::de::Error::duplicate_field("stateTable"));
7443 }
7444 state_table__ = map_.next_value()?;
7445 }
7446 GeneratedField::UpdateCurrent => {
7447 if mode__.is_some() {
7448 return Err(serde::de::Error::duplicate_field("updateCurrent"));
7449 }
7450 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::UpdateCurrent)
7451;
7452 }
7453 GeneratedField::GenerateSeries => {
7454 if mode__.is_some() {
7455 return Err(serde::de::Error::duplicate_field("generateSeries"));
7456 }
7457 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::GenerateSeries)
7458;
7459 }
7460 }
7461 }
7462 Ok(NowNode {
7463 state_table: state_table__,
7464 mode: mode__,
7465 })
7466 }
7467 }
7468 deserializer.deserialize_struct("stream_plan.NowNode", FIELDS, GeneratedVisitor)
7469 }
7470}
7471impl serde::Serialize for OverWindowCachePolicy {
7472 #[allow(deprecated)]
7473 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7474 where
7475 S: serde::Serializer,
7476 {
7477 let variant = match self {
7478 Self::Unspecified => "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
7479 Self::Full => "OVER_WINDOW_CACHE_POLICY_FULL",
7480 Self::Recent => "OVER_WINDOW_CACHE_POLICY_RECENT",
7481 Self::RecentFirstN => "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
7482 Self::RecentLastN => "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
7483 };
7484 serializer.serialize_str(variant)
7485 }
7486}
7487impl<'de> serde::Deserialize<'de> for OverWindowCachePolicy {
7488 #[allow(deprecated)]
7489 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7490 where
7491 D: serde::Deserializer<'de>,
7492 {
7493 const FIELDS: &[&str] = &[
7494 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
7495 "OVER_WINDOW_CACHE_POLICY_FULL",
7496 "OVER_WINDOW_CACHE_POLICY_RECENT",
7497 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
7498 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
7499 ];
7500
7501 struct GeneratedVisitor;
7502
7503 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7504 type Value = OverWindowCachePolicy;
7505
7506 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7507 write!(formatter, "expected one of: {:?}", &FIELDS)
7508 }
7509
7510 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
7511 where
7512 E: serde::de::Error,
7513 {
7514 i32::try_from(v)
7515 .ok()
7516 .and_then(|x| x.try_into().ok())
7517 .ok_or_else(|| {
7518 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
7519 })
7520 }
7521
7522 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
7523 where
7524 E: serde::de::Error,
7525 {
7526 i32::try_from(v)
7527 .ok()
7528 .and_then(|x| x.try_into().ok())
7529 .ok_or_else(|| {
7530 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
7531 })
7532 }
7533
7534 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
7535 where
7536 E: serde::de::Error,
7537 {
7538 match value {
7539 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED" => Ok(OverWindowCachePolicy::Unspecified),
7540 "OVER_WINDOW_CACHE_POLICY_FULL" => Ok(OverWindowCachePolicy::Full),
7541 "OVER_WINDOW_CACHE_POLICY_RECENT" => Ok(OverWindowCachePolicy::Recent),
7542 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N" => Ok(OverWindowCachePolicy::RecentFirstN),
7543 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N" => Ok(OverWindowCachePolicy::RecentLastN),
7544 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
7545 }
7546 }
7547 }
7548 deserializer.deserialize_any(GeneratedVisitor)
7549 }
7550}
7551impl serde::Serialize for OverWindowNode {
7552 #[allow(deprecated)]
7553 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7554 where
7555 S: serde::Serializer,
7556 {
7557 use serde::ser::SerializeStruct;
7558 let mut len = 0;
7559 if !self.calls.is_empty() {
7560 len += 1;
7561 }
7562 if !self.partition_by.is_empty() {
7563 len += 1;
7564 }
7565 if !self.order_by.is_empty() {
7566 len += 1;
7567 }
7568 if self.state_table.is_some() {
7569 len += 1;
7570 }
7571 if self.cache_policy != 0 {
7572 len += 1;
7573 }
7574 let mut struct_ser = serializer.serialize_struct("stream_plan.OverWindowNode", len)?;
7575 if !self.calls.is_empty() {
7576 struct_ser.serialize_field("calls", &self.calls)?;
7577 }
7578 if !self.partition_by.is_empty() {
7579 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
7580 }
7581 if !self.order_by.is_empty() {
7582 struct_ser.serialize_field("orderBy", &self.order_by)?;
7583 }
7584 if let Some(v) = self.state_table.as_ref() {
7585 struct_ser.serialize_field("stateTable", v)?;
7586 }
7587 if self.cache_policy != 0 {
7588 let v = OverWindowCachePolicy::try_from(self.cache_policy)
7589 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cache_policy)))?;
7590 struct_ser.serialize_field("cachePolicy", &v)?;
7591 }
7592 struct_ser.end()
7593 }
7594}
7595impl<'de> serde::Deserialize<'de> for OverWindowNode {
7596 #[allow(deprecated)]
7597 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7598 where
7599 D: serde::Deserializer<'de>,
7600 {
7601 const FIELDS: &[&str] = &[
7602 "calls",
7603 "partition_by",
7604 "partitionBy",
7605 "order_by",
7606 "orderBy",
7607 "state_table",
7608 "stateTable",
7609 "cache_policy",
7610 "cachePolicy",
7611 ];
7612
7613 #[allow(clippy::enum_variant_names)]
7614 enum GeneratedField {
7615 Calls,
7616 PartitionBy,
7617 OrderBy,
7618 StateTable,
7619 CachePolicy,
7620 }
7621 impl<'de> serde::Deserialize<'de> for GeneratedField {
7622 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7623 where
7624 D: serde::Deserializer<'de>,
7625 {
7626 struct GeneratedVisitor;
7627
7628 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7629 type Value = GeneratedField;
7630
7631 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7632 write!(formatter, "expected one of: {:?}", &FIELDS)
7633 }
7634
7635 #[allow(unused_variables)]
7636 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7637 where
7638 E: serde::de::Error,
7639 {
7640 match value {
7641 "calls" => Ok(GeneratedField::Calls),
7642 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
7643 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
7644 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7645 "cachePolicy" | "cache_policy" => Ok(GeneratedField::CachePolicy),
7646 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7647 }
7648 }
7649 }
7650 deserializer.deserialize_identifier(GeneratedVisitor)
7651 }
7652 }
7653 struct GeneratedVisitor;
7654 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7655 type Value = OverWindowNode;
7656
7657 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7658 formatter.write_str("struct stream_plan.OverWindowNode")
7659 }
7660
7661 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverWindowNode, V::Error>
7662 where
7663 V: serde::de::MapAccess<'de>,
7664 {
7665 let mut calls__ = None;
7666 let mut partition_by__ = None;
7667 let mut order_by__ = None;
7668 let mut state_table__ = None;
7669 let mut cache_policy__ = None;
7670 while let Some(k) = map_.next_key()? {
7671 match k {
7672 GeneratedField::Calls => {
7673 if calls__.is_some() {
7674 return Err(serde::de::Error::duplicate_field("calls"));
7675 }
7676 calls__ = Some(map_.next_value()?);
7677 }
7678 GeneratedField::PartitionBy => {
7679 if partition_by__.is_some() {
7680 return Err(serde::de::Error::duplicate_field("partitionBy"));
7681 }
7682 partition_by__ =
7683 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7684 .into_iter().map(|x| x.0).collect())
7685 ;
7686 }
7687 GeneratedField::OrderBy => {
7688 if order_by__.is_some() {
7689 return Err(serde::de::Error::duplicate_field("orderBy"));
7690 }
7691 order_by__ = Some(map_.next_value()?);
7692 }
7693 GeneratedField::StateTable => {
7694 if state_table__.is_some() {
7695 return Err(serde::de::Error::duplicate_field("stateTable"));
7696 }
7697 state_table__ = map_.next_value()?;
7698 }
7699 GeneratedField::CachePolicy => {
7700 if cache_policy__.is_some() {
7701 return Err(serde::de::Error::duplicate_field("cachePolicy"));
7702 }
7703 cache_policy__ = Some(map_.next_value::<OverWindowCachePolicy>()? as i32);
7704 }
7705 }
7706 }
7707 Ok(OverWindowNode {
7708 calls: calls__.unwrap_or_default(),
7709 partition_by: partition_by__.unwrap_or_default(),
7710 order_by: order_by__.unwrap_or_default(),
7711 state_table: state_table__,
7712 cache_policy: cache_policy__.unwrap_or_default(),
7713 })
7714 }
7715 }
7716 deserializer.deserialize_struct("stream_plan.OverWindowNode", FIELDS, GeneratedVisitor)
7717 }
7718}
7719impl serde::Serialize for PauseMutation {
7720 #[allow(deprecated)]
7721 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7722 where
7723 S: serde::Serializer,
7724 {
7725 use serde::ser::SerializeStruct;
7726 let len = 0;
7727 let struct_ser = serializer.serialize_struct("stream_plan.PauseMutation", len)?;
7728 struct_ser.end()
7729 }
7730}
7731impl<'de> serde::Deserialize<'de> for PauseMutation {
7732 #[allow(deprecated)]
7733 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7734 where
7735 D: serde::Deserializer<'de>,
7736 {
7737 const FIELDS: &[&str] = &[
7738 ];
7739
7740 #[allow(clippy::enum_variant_names)]
7741 enum GeneratedField {
7742 }
7743 impl<'de> serde::Deserialize<'de> for GeneratedField {
7744 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7745 where
7746 D: serde::Deserializer<'de>,
7747 {
7748 struct GeneratedVisitor;
7749
7750 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7751 type Value = GeneratedField;
7752
7753 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7754 write!(formatter, "expected one of: {:?}", &FIELDS)
7755 }
7756
7757 #[allow(unused_variables)]
7758 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7759 where
7760 E: serde::de::Error,
7761 {
7762 Err(serde::de::Error::unknown_field(value, FIELDS))
7763 }
7764 }
7765 deserializer.deserialize_identifier(GeneratedVisitor)
7766 }
7767 }
7768 struct GeneratedVisitor;
7769 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7770 type Value = PauseMutation;
7771
7772 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7773 formatter.write_str("struct stream_plan.PauseMutation")
7774 }
7775
7776 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseMutation, V::Error>
7777 where
7778 V: serde::de::MapAccess<'de>,
7779 {
7780 while map_.next_key::<GeneratedField>()?.is_some() {
7781 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7782 }
7783 Ok(PauseMutation {
7784 })
7785 }
7786 }
7787 deserializer.deserialize_struct("stream_plan.PauseMutation", FIELDS, GeneratedVisitor)
7788 }
7789}
7790impl serde::Serialize for ProjectNode {
7791 #[allow(deprecated)]
7792 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7793 where
7794 S: serde::Serializer,
7795 {
7796 use serde::ser::SerializeStruct;
7797 let mut len = 0;
7798 if !self.select_list.is_empty() {
7799 len += 1;
7800 }
7801 if !self.watermark_input_cols.is_empty() {
7802 len += 1;
7803 }
7804 if !self.watermark_output_cols.is_empty() {
7805 len += 1;
7806 }
7807 if !self.nondecreasing_exprs.is_empty() {
7808 len += 1;
7809 }
7810 if self.noop_update_hint {
7811 len += 1;
7812 }
7813 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectNode", len)?;
7814 if !self.select_list.is_empty() {
7815 struct_ser.serialize_field("selectList", &self.select_list)?;
7816 }
7817 if !self.watermark_input_cols.is_empty() {
7818 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
7819 }
7820 if !self.watermark_output_cols.is_empty() {
7821 struct_ser.serialize_field("watermarkOutputCols", &self.watermark_output_cols)?;
7822 }
7823 if !self.nondecreasing_exprs.is_empty() {
7824 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
7825 }
7826 if self.noop_update_hint {
7827 struct_ser.serialize_field("noopUpdateHint", &self.noop_update_hint)?;
7828 }
7829 struct_ser.end()
7830 }
7831}
7832impl<'de> serde::Deserialize<'de> for ProjectNode {
7833 #[allow(deprecated)]
7834 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7835 where
7836 D: serde::Deserializer<'de>,
7837 {
7838 const FIELDS: &[&str] = &[
7839 "select_list",
7840 "selectList",
7841 "watermark_input_cols",
7842 "watermarkInputCols",
7843 "watermark_output_cols",
7844 "watermarkOutputCols",
7845 "nondecreasing_exprs",
7846 "nondecreasingExprs",
7847 "noop_update_hint",
7848 "noopUpdateHint",
7849 ];
7850
7851 #[allow(clippy::enum_variant_names)]
7852 enum GeneratedField {
7853 SelectList,
7854 WatermarkInputCols,
7855 WatermarkOutputCols,
7856 NondecreasingExprs,
7857 NoopUpdateHint,
7858 }
7859 impl<'de> serde::Deserialize<'de> for GeneratedField {
7860 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7861 where
7862 D: serde::Deserializer<'de>,
7863 {
7864 struct GeneratedVisitor;
7865
7866 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7867 type Value = GeneratedField;
7868
7869 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7870 write!(formatter, "expected one of: {:?}", &FIELDS)
7871 }
7872
7873 #[allow(unused_variables)]
7874 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7875 where
7876 E: serde::de::Error,
7877 {
7878 match value {
7879 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
7880 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
7881 "watermarkOutputCols" | "watermark_output_cols" => Ok(GeneratedField::WatermarkOutputCols),
7882 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
7883 "noopUpdateHint" | "noop_update_hint" => Ok(GeneratedField::NoopUpdateHint),
7884 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7885 }
7886 }
7887 }
7888 deserializer.deserialize_identifier(GeneratedVisitor)
7889 }
7890 }
7891 struct GeneratedVisitor;
7892 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7893 type Value = ProjectNode;
7894
7895 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7896 formatter.write_str("struct stream_plan.ProjectNode")
7897 }
7898
7899 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
7900 where
7901 V: serde::de::MapAccess<'de>,
7902 {
7903 let mut select_list__ = None;
7904 let mut watermark_input_cols__ = None;
7905 let mut watermark_output_cols__ = None;
7906 let mut nondecreasing_exprs__ = None;
7907 let mut noop_update_hint__ = None;
7908 while let Some(k) = map_.next_key()? {
7909 match k {
7910 GeneratedField::SelectList => {
7911 if select_list__.is_some() {
7912 return Err(serde::de::Error::duplicate_field("selectList"));
7913 }
7914 select_list__ = Some(map_.next_value()?);
7915 }
7916 GeneratedField::WatermarkInputCols => {
7917 if watermark_input_cols__.is_some() {
7918 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
7919 }
7920 watermark_input_cols__ =
7921 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7922 .into_iter().map(|x| x.0).collect())
7923 ;
7924 }
7925 GeneratedField::WatermarkOutputCols => {
7926 if watermark_output_cols__.is_some() {
7927 return Err(serde::de::Error::duplicate_field("watermarkOutputCols"));
7928 }
7929 watermark_output_cols__ =
7930 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7931 .into_iter().map(|x| x.0).collect())
7932 ;
7933 }
7934 GeneratedField::NondecreasingExprs => {
7935 if nondecreasing_exprs__.is_some() {
7936 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
7937 }
7938 nondecreasing_exprs__ =
7939 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7940 .into_iter().map(|x| x.0).collect())
7941 ;
7942 }
7943 GeneratedField::NoopUpdateHint => {
7944 if noop_update_hint__.is_some() {
7945 return Err(serde::de::Error::duplicate_field("noopUpdateHint"));
7946 }
7947 noop_update_hint__ = Some(map_.next_value()?);
7948 }
7949 }
7950 }
7951 Ok(ProjectNode {
7952 select_list: select_list__.unwrap_or_default(),
7953 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
7954 watermark_output_cols: watermark_output_cols__.unwrap_or_default(),
7955 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
7956 noop_update_hint: noop_update_hint__.unwrap_or_default(),
7957 })
7958 }
7959 }
7960 deserializer.deserialize_struct("stream_plan.ProjectNode", FIELDS, GeneratedVisitor)
7961 }
7962}
7963impl serde::Serialize for ProjectSetNode {
7964 #[allow(deprecated)]
7965 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7966 where
7967 S: serde::Serializer,
7968 {
7969 use serde::ser::SerializeStruct;
7970 let mut len = 0;
7971 if !self.select_list.is_empty() {
7972 len += 1;
7973 }
7974 if !self.watermark_input_cols.is_empty() {
7975 len += 1;
7976 }
7977 if !self.watermark_expr_indices.is_empty() {
7978 len += 1;
7979 }
7980 if !self.nondecreasing_exprs.is_empty() {
7981 len += 1;
7982 }
7983 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectSetNode", len)?;
7984 if !self.select_list.is_empty() {
7985 struct_ser.serialize_field("selectList", &self.select_list)?;
7986 }
7987 if !self.watermark_input_cols.is_empty() {
7988 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
7989 }
7990 if !self.watermark_expr_indices.is_empty() {
7991 struct_ser.serialize_field("watermarkExprIndices", &self.watermark_expr_indices)?;
7992 }
7993 if !self.nondecreasing_exprs.is_empty() {
7994 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
7995 }
7996 struct_ser.end()
7997 }
7998}
7999impl<'de> serde::Deserialize<'de> for ProjectSetNode {
8000 #[allow(deprecated)]
8001 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8002 where
8003 D: serde::Deserializer<'de>,
8004 {
8005 const FIELDS: &[&str] = &[
8006 "select_list",
8007 "selectList",
8008 "watermark_input_cols",
8009 "watermarkInputCols",
8010 "watermark_expr_indices",
8011 "watermarkExprIndices",
8012 "nondecreasing_exprs",
8013 "nondecreasingExprs",
8014 ];
8015
8016 #[allow(clippy::enum_variant_names)]
8017 enum GeneratedField {
8018 SelectList,
8019 WatermarkInputCols,
8020 WatermarkExprIndices,
8021 NondecreasingExprs,
8022 }
8023 impl<'de> serde::Deserialize<'de> for GeneratedField {
8024 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8025 where
8026 D: serde::Deserializer<'de>,
8027 {
8028 struct GeneratedVisitor;
8029
8030 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8031 type Value = GeneratedField;
8032
8033 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8034 write!(formatter, "expected one of: {:?}", &FIELDS)
8035 }
8036
8037 #[allow(unused_variables)]
8038 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8039 where
8040 E: serde::de::Error,
8041 {
8042 match value {
8043 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
8044 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
8045 "watermarkExprIndices" | "watermark_expr_indices" => Ok(GeneratedField::WatermarkExprIndices),
8046 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
8047 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8048 }
8049 }
8050 }
8051 deserializer.deserialize_identifier(GeneratedVisitor)
8052 }
8053 }
8054 struct GeneratedVisitor;
8055 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8056 type Value = ProjectSetNode;
8057
8058 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8059 formatter.write_str("struct stream_plan.ProjectSetNode")
8060 }
8061
8062 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
8063 where
8064 V: serde::de::MapAccess<'de>,
8065 {
8066 let mut select_list__ = None;
8067 let mut watermark_input_cols__ = None;
8068 let mut watermark_expr_indices__ = None;
8069 let mut nondecreasing_exprs__ = None;
8070 while let Some(k) = map_.next_key()? {
8071 match k {
8072 GeneratedField::SelectList => {
8073 if select_list__.is_some() {
8074 return Err(serde::de::Error::duplicate_field("selectList"));
8075 }
8076 select_list__ = Some(map_.next_value()?);
8077 }
8078 GeneratedField::WatermarkInputCols => {
8079 if watermark_input_cols__.is_some() {
8080 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
8081 }
8082 watermark_input_cols__ =
8083 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8084 .into_iter().map(|x| x.0).collect())
8085 ;
8086 }
8087 GeneratedField::WatermarkExprIndices => {
8088 if watermark_expr_indices__.is_some() {
8089 return Err(serde::de::Error::duplicate_field("watermarkExprIndices"));
8090 }
8091 watermark_expr_indices__ =
8092 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8093 .into_iter().map(|x| x.0).collect())
8094 ;
8095 }
8096 GeneratedField::NondecreasingExprs => {
8097 if nondecreasing_exprs__.is_some() {
8098 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
8099 }
8100 nondecreasing_exprs__ =
8101 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8102 .into_iter().map(|x| x.0).collect())
8103 ;
8104 }
8105 }
8106 }
8107 Ok(ProjectSetNode {
8108 select_list: select_list__.unwrap_or_default(),
8109 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
8110 watermark_expr_indices: watermark_expr_indices__.unwrap_or_default(),
8111 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
8112 })
8113 }
8114 }
8115 deserializer.deserialize_struct("stream_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
8116 }
8117}
8118impl serde::Serialize for RefreshStartMutation {
8119 #[allow(deprecated)]
8120 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8121 where
8122 S: serde::Serializer,
8123 {
8124 use serde::ser::SerializeStruct;
8125 let mut len = 0;
8126 if self.table_id != 0 {
8127 len += 1;
8128 }
8129 if self.associated_source_id != 0 {
8130 len += 1;
8131 }
8132 let mut struct_ser = serializer.serialize_struct("stream_plan.RefreshStartMutation", len)?;
8133 if self.table_id != 0 {
8134 struct_ser.serialize_field("tableId", &self.table_id)?;
8135 }
8136 if self.associated_source_id != 0 {
8137 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
8138 }
8139 struct_ser.end()
8140 }
8141}
8142impl<'de> serde::Deserialize<'de> for RefreshStartMutation {
8143 #[allow(deprecated)]
8144 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8145 where
8146 D: serde::Deserializer<'de>,
8147 {
8148 const FIELDS: &[&str] = &[
8149 "table_id",
8150 "tableId",
8151 "associated_source_id",
8152 "associatedSourceId",
8153 ];
8154
8155 #[allow(clippy::enum_variant_names)]
8156 enum GeneratedField {
8157 TableId,
8158 AssociatedSourceId,
8159 }
8160 impl<'de> serde::Deserialize<'de> for GeneratedField {
8161 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8162 where
8163 D: serde::Deserializer<'de>,
8164 {
8165 struct GeneratedVisitor;
8166
8167 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8168 type Value = GeneratedField;
8169
8170 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8171 write!(formatter, "expected one of: {:?}", &FIELDS)
8172 }
8173
8174 #[allow(unused_variables)]
8175 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8176 where
8177 E: serde::de::Error,
8178 {
8179 match value {
8180 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8181 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
8182 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8183 }
8184 }
8185 }
8186 deserializer.deserialize_identifier(GeneratedVisitor)
8187 }
8188 }
8189 struct GeneratedVisitor;
8190 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8191 type Value = RefreshStartMutation;
8192
8193 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8194 formatter.write_str("struct stream_plan.RefreshStartMutation")
8195 }
8196
8197 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshStartMutation, V::Error>
8198 where
8199 V: serde::de::MapAccess<'de>,
8200 {
8201 let mut table_id__ = None;
8202 let mut associated_source_id__ = None;
8203 while let Some(k) = map_.next_key()? {
8204 match k {
8205 GeneratedField::TableId => {
8206 if table_id__.is_some() {
8207 return Err(serde::de::Error::duplicate_field("tableId"));
8208 }
8209 table_id__ =
8210 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8211 ;
8212 }
8213 GeneratedField::AssociatedSourceId => {
8214 if associated_source_id__.is_some() {
8215 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
8216 }
8217 associated_source_id__ =
8218 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8219 ;
8220 }
8221 }
8222 }
8223 Ok(RefreshStartMutation {
8224 table_id: table_id__.unwrap_or_default(),
8225 associated_source_id: associated_source_id__.unwrap_or_default(),
8226 })
8227 }
8228 }
8229 deserializer.deserialize_struct("stream_plan.RefreshStartMutation", FIELDS, GeneratedVisitor)
8230 }
8231}
8232impl serde::Serialize for ResumeMutation {
8233 #[allow(deprecated)]
8234 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8235 where
8236 S: serde::Serializer,
8237 {
8238 use serde::ser::SerializeStruct;
8239 let len = 0;
8240 let struct_ser = serializer.serialize_struct("stream_plan.ResumeMutation", len)?;
8241 struct_ser.end()
8242 }
8243}
8244impl<'de> serde::Deserialize<'de> for ResumeMutation {
8245 #[allow(deprecated)]
8246 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8247 where
8248 D: serde::Deserializer<'de>,
8249 {
8250 const FIELDS: &[&str] = &[
8251 ];
8252
8253 #[allow(clippy::enum_variant_names)]
8254 enum GeneratedField {
8255 }
8256 impl<'de> serde::Deserialize<'de> for GeneratedField {
8257 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8258 where
8259 D: serde::Deserializer<'de>,
8260 {
8261 struct GeneratedVisitor;
8262
8263 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8264 type Value = GeneratedField;
8265
8266 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8267 write!(formatter, "expected one of: {:?}", &FIELDS)
8268 }
8269
8270 #[allow(unused_variables)]
8271 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8272 where
8273 E: serde::de::Error,
8274 {
8275 Err(serde::de::Error::unknown_field(value, FIELDS))
8276 }
8277 }
8278 deserializer.deserialize_identifier(GeneratedVisitor)
8279 }
8280 }
8281 struct GeneratedVisitor;
8282 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8283 type Value = ResumeMutation;
8284
8285 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8286 formatter.write_str("struct stream_plan.ResumeMutation")
8287 }
8288
8289 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeMutation, V::Error>
8290 where
8291 V: serde::de::MapAccess<'de>,
8292 {
8293 while map_.next_key::<GeneratedField>()?.is_some() {
8294 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8295 }
8296 Ok(ResumeMutation {
8297 })
8298 }
8299 }
8300 deserializer.deserialize_struct("stream_plan.ResumeMutation", FIELDS, GeneratedVisitor)
8301 }
8302}
8303impl serde::Serialize for RowIdGenNode {
8304 #[allow(deprecated)]
8305 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8306 where
8307 S: serde::Serializer,
8308 {
8309 use serde::ser::SerializeStruct;
8310 let mut len = 0;
8311 if self.row_id_index != 0 {
8312 len += 1;
8313 }
8314 let mut struct_ser = serializer.serialize_struct("stream_plan.RowIdGenNode", len)?;
8315 if self.row_id_index != 0 {
8316 #[allow(clippy::needless_borrow)]
8317 #[allow(clippy::needless_borrows_for_generic_args)]
8318 struct_ser.serialize_field("rowIdIndex", ToString::to_string(&self.row_id_index).as_str())?;
8319 }
8320 struct_ser.end()
8321 }
8322}
8323impl<'de> serde::Deserialize<'de> for RowIdGenNode {
8324 #[allow(deprecated)]
8325 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8326 where
8327 D: serde::Deserializer<'de>,
8328 {
8329 const FIELDS: &[&str] = &[
8330 "row_id_index",
8331 "rowIdIndex",
8332 ];
8333
8334 #[allow(clippy::enum_variant_names)]
8335 enum GeneratedField {
8336 RowIdIndex,
8337 }
8338 impl<'de> serde::Deserialize<'de> for GeneratedField {
8339 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8340 where
8341 D: serde::Deserializer<'de>,
8342 {
8343 struct GeneratedVisitor;
8344
8345 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8346 type Value = GeneratedField;
8347
8348 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8349 write!(formatter, "expected one of: {:?}", &FIELDS)
8350 }
8351
8352 #[allow(unused_variables)]
8353 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8354 where
8355 E: serde::de::Error,
8356 {
8357 match value {
8358 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
8359 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8360 }
8361 }
8362 }
8363 deserializer.deserialize_identifier(GeneratedVisitor)
8364 }
8365 }
8366 struct GeneratedVisitor;
8367 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8368 type Value = RowIdGenNode;
8369
8370 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8371 formatter.write_str("struct stream_plan.RowIdGenNode")
8372 }
8373
8374 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowIdGenNode, V::Error>
8375 where
8376 V: serde::de::MapAccess<'de>,
8377 {
8378 let mut row_id_index__ = None;
8379 while let Some(k) = map_.next_key()? {
8380 match k {
8381 GeneratedField::RowIdIndex => {
8382 if row_id_index__.is_some() {
8383 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
8384 }
8385 row_id_index__ =
8386 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8387 ;
8388 }
8389 }
8390 }
8391 Ok(RowIdGenNode {
8392 row_id_index: row_id_index__.unwrap_or_default(),
8393 })
8394 }
8395 }
8396 deserializer.deserialize_struct("stream_plan.RowIdGenNode", FIELDS, GeneratedVisitor)
8397 }
8398}
8399impl serde::Serialize for RowMergeNode {
8400 #[allow(deprecated)]
8401 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8402 where
8403 S: serde::Serializer,
8404 {
8405 use serde::ser::SerializeStruct;
8406 let mut len = 0;
8407 if self.lhs_mapping.is_some() {
8408 len += 1;
8409 }
8410 if self.rhs_mapping.is_some() {
8411 len += 1;
8412 }
8413 let mut struct_ser = serializer.serialize_struct("stream_plan.RowMergeNode", len)?;
8414 if let Some(v) = self.lhs_mapping.as_ref() {
8415 struct_ser.serialize_field("lhsMapping", v)?;
8416 }
8417 if let Some(v) = self.rhs_mapping.as_ref() {
8418 struct_ser.serialize_field("rhsMapping", v)?;
8419 }
8420 struct_ser.end()
8421 }
8422}
8423impl<'de> serde::Deserialize<'de> for RowMergeNode {
8424 #[allow(deprecated)]
8425 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8426 where
8427 D: serde::Deserializer<'de>,
8428 {
8429 const FIELDS: &[&str] = &[
8430 "lhs_mapping",
8431 "lhsMapping",
8432 "rhs_mapping",
8433 "rhsMapping",
8434 ];
8435
8436 #[allow(clippy::enum_variant_names)]
8437 enum GeneratedField {
8438 LhsMapping,
8439 RhsMapping,
8440 }
8441 impl<'de> serde::Deserialize<'de> for GeneratedField {
8442 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8443 where
8444 D: serde::Deserializer<'de>,
8445 {
8446 struct GeneratedVisitor;
8447
8448 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8449 type Value = GeneratedField;
8450
8451 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8452 write!(formatter, "expected one of: {:?}", &FIELDS)
8453 }
8454
8455 #[allow(unused_variables)]
8456 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8457 where
8458 E: serde::de::Error,
8459 {
8460 match value {
8461 "lhsMapping" | "lhs_mapping" => Ok(GeneratedField::LhsMapping),
8462 "rhsMapping" | "rhs_mapping" => Ok(GeneratedField::RhsMapping),
8463 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8464 }
8465 }
8466 }
8467 deserializer.deserialize_identifier(GeneratedVisitor)
8468 }
8469 }
8470 struct GeneratedVisitor;
8471 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8472 type Value = RowMergeNode;
8473
8474 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8475 formatter.write_str("struct stream_plan.RowMergeNode")
8476 }
8477
8478 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowMergeNode, V::Error>
8479 where
8480 V: serde::de::MapAccess<'de>,
8481 {
8482 let mut lhs_mapping__ = None;
8483 let mut rhs_mapping__ = None;
8484 while let Some(k) = map_.next_key()? {
8485 match k {
8486 GeneratedField::LhsMapping => {
8487 if lhs_mapping__.is_some() {
8488 return Err(serde::de::Error::duplicate_field("lhsMapping"));
8489 }
8490 lhs_mapping__ = map_.next_value()?;
8491 }
8492 GeneratedField::RhsMapping => {
8493 if rhs_mapping__.is_some() {
8494 return Err(serde::de::Error::duplicate_field("rhsMapping"));
8495 }
8496 rhs_mapping__ = map_.next_value()?;
8497 }
8498 }
8499 }
8500 Ok(RowMergeNode {
8501 lhs_mapping: lhs_mapping__,
8502 rhs_mapping: rhs_mapping__,
8503 })
8504 }
8505 }
8506 deserializer.deserialize_struct("stream_plan.RowMergeNode", FIELDS, GeneratedVisitor)
8507 }
8508}
8509impl serde::Serialize for SimpleAggNode {
8510 #[allow(deprecated)]
8511 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8512 where
8513 S: serde::Serializer,
8514 {
8515 use serde::ser::SerializeStruct;
8516 let mut len = 0;
8517 if !self.agg_calls.is_empty() {
8518 len += 1;
8519 }
8520 if !self.agg_call_states.is_empty() {
8521 len += 1;
8522 }
8523 if self.intermediate_state_table.is_some() {
8524 len += 1;
8525 }
8526 if self.is_append_only {
8527 len += 1;
8528 }
8529 if !self.distinct_dedup_tables.is_empty() {
8530 len += 1;
8531 }
8532 if self.row_count_index != 0 {
8533 len += 1;
8534 }
8535 if self.version != 0 {
8536 len += 1;
8537 }
8538 if self.must_output_per_barrier {
8539 len += 1;
8540 }
8541 let mut struct_ser = serializer.serialize_struct("stream_plan.SimpleAggNode", len)?;
8542 if !self.agg_calls.is_empty() {
8543 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
8544 }
8545 if !self.agg_call_states.is_empty() {
8546 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
8547 }
8548 if let Some(v) = self.intermediate_state_table.as_ref() {
8549 struct_ser.serialize_field("intermediateStateTable", v)?;
8550 }
8551 if self.is_append_only {
8552 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
8553 }
8554 if !self.distinct_dedup_tables.is_empty() {
8555 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
8556 }
8557 if self.row_count_index != 0 {
8558 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
8559 }
8560 if self.version != 0 {
8561 let v = AggNodeVersion::try_from(self.version)
8562 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
8563 struct_ser.serialize_field("version", &v)?;
8564 }
8565 if self.must_output_per_barrier {
8566 struct_ser.serialize_field("mustOutputPerBarrier", &self.must_output_per_barrier)?;
8567 }
8568 struct_ser.end()
8569 }
8570}
8571impl<'de> serde::Deserialize<'de> for SimpleAggNode {
8572 #[allow(deprecated)]
8573 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8574 where
8575 D: serde::Deserializer<'de>,
8576 {
8577 const FIELDS: &[&str] = &[
8578 "agg_calls",
8579 "aggCalls",
8580 "agg_call_states",
8581 "aggCallStates",
8582 "intermediate_state_table",
8583 "intermediateStateTable",
8584 "is_append_only",
8585 "isAppendOnly",
8586 "distinct_dedup_tables",
8587 "distinctDedupTables",
8588 "row_count_index",
8589 "rowCountIndex",
8590 "version",
8591 "must_output_per_barrier",
8592 "mustOutputPerBarrier",
8593 ];
8594
8595 #[allow(clippy::enum_variant_names)]
8596 enum GeneratedField {
8597 AggCalls,
8598 AggCallStates,
8599 IntermediateStateTable,
8600 IsAppendOnly,
8601 DistinctDedupTables,
8602 RowCountIndex,
8603 Version,
8604 MustOutputPerBarrier,
8605 }
8606 impl<'de> serde::Deserialize<'de> for GeneratedField {
8607 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8608 where
8609 D: serde::Deserializer<'de>,
8610 {
8611 struct GeneratedVisitor;
8612
8613 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8614 type Value = GeneratedField;
8615
8616 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8617 write!(formatter, "expected one of: {:?}", &FIELDS)
8618 }
8619
8620 #[allow(unused_variables)]
8621 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8622 where
8623 E: serde::de::Error,
8624 {
8625 match value {
8626 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
8627 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
8628 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
8629 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
8630 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
8631 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
8632 "version" => Ok(GeneratedField::Version),
8633 "mustOutputPerBarrier" | "must_output_per_barrier" => Ok(GeneratedField::MustOutputPerBarrier),
8634 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8635 }
8636 }
8637 }
8638 deserializer.deserialize_identifier(GeneratedVisitor)
8639 }
8640 }
8641 struct GeneratedVisitor;
8642 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8643 type Value = SimpleAggNode;
8644
8645 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8646 formatter.write_str("struct stream_plan.SimpleAggNode")
8647 }
8648
8649 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SimpleAggNode, V::Error>
8650 where
8651 V: serde::de::MapAccess<'de>,
8652 {
8653 let mut agg_calls__ = None;
8654 let mut agg_call_states__ = None;
8655 let mut intermediate_state_table__ = None;
8656 let mut is_append_only__ = None;
8657 let mut distinct_dedup_tables__ = None;
8658 let mut row_count_index__ = None;
8659 let mut version__ = None;
8660 let mut must_output_per_barrier__ = None;
8661 while let Some(k) = map_.next_key()? {
8662 match k {
8663 GeneratedField::AggCalls => {
8664 if agg_calls__.is_some() {
8665 return Err(serde::de::Error::duplicate_field("aggCalls"));
8666 }
8667 agg_calls__ = Some(map_.next_value()?);
8668 }
8669 GeneratedField::AggCallStates => {
8670 if agg_call_states__.is_some() {
8671 return Err(serde::de::Error::duplicate_field("aggCallStates"));
8672 }
8673 agg_call_states__ = Some(map_.next_value()?);
8674 }
8675 GeneratedField::IntermediateStateTable => {
8676 if intermediate_state_table__.is_some() {
8677 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
8678 }
8679 intermediate_state_table__ = map_.next_value()?;
8680 }
8681 GeneratedField::IsAppendOnly => {
8682 if is_append_only__.is_some() {
8683 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
8684 }
8685 is_append_only__ = Some(map_.next_value()?);
8686 }
8687 GeneratedField::DistinctDedupTables => {
8688 if distinct_dedup_tables__.is_some() {
8689 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
8690 }
8691 distinct_dedup_tables__ = Some(
8692 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8693 .into_iter().map(|(k,v)| (k.0, v)).collect()
8694 );
8695 }
8696 GeneratedField::RowCountIndex => {
8697 if row_count_index__.is_some() {
8698 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
8699 }
8700 row_count_index__ =
8701 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8702 ;
8703 }
8704 GeneratedField::Version => {
8705 if version__.is_some() {
8706 return Err(serde::de::Error::duplicate_field("version"));
8707 }
8708 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
8709 }
8710 GeneratedField::MustOutputPerBarrier => {
8711 if must_output_per_barrier__.is_some() {
8712 return Err(serde::de::Error::duplicate_field("mustOutputPerBarrier"));
8713 }
8714 must_output_per_barrier__ = Some(map_.next_value()?);
8715 }
8716 }
8717 }
8718 Ok(SimpleAggNode {
8719 agg_calls: agg_calls__.unwrap_or_default(),
8720 agg_call_states: agg_call_states__.unwrap_or_default(),
8721 intermediate_state_table: intermediate_state_table__,
8722 is_append_only: is_append_only__.unwrap_or_default(),
8723 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
8724 row_count_index: row_count_index__.unwrap_or_default(),
8725 version: version__.unwrap_or_default(),
8726 must_output_per_barrier: must_output_per_barrier__.unwrap_or_default(),
8727 })
8728 }
8729 }
8730 deserializer.deserialize_struct("stream_plan.SimpleAggNode", FIELDS, GeneratedVisitor)
8731 }
8732}
8733impl serde::Serialize for SinkAddColumns {
8734 #[allow(deprecated)]
8735 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8736 where
8737 S: serde::Serializer,
8738 {
8739 use serde::ser::SerializeStruct;
8740 let mut len = 0;
8741 if !self.fields.is_empty() {
8742 len += 1;
8743 }
8744 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkAddColumns", len)?;
8745 if !self.fields.is_empty() {
8746 struct_ser.serialize_field("fields", &self.fields)?;
8747 }
8748 struct_ser.end()
8749 }
8750}
8751impl<'de> serde::Deserialize<'de> for SinkAddColumns {
8752 #[allow(deprecated)]
8753 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8754 where
8755 D: serde::Deserializer<'de>,
8756 {
8757 const FIELDS: &[&str] = &[
8758 "fields",
8759 ];
8760
8761 #[allow(clippy::enum_variant_names)]
8762 enum GeneratedField {
8763 Fields,
8764 }
8765 impl<'de> serde::Deserialize<'de> for GeneratedField {
8766 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8767 where
8768 D: serde::Deserializer<'de>,
8769 {
8770 struct GeneratedVisitor;
8771
8772 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8773 type Value = GeneratedField;
8774
8775 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8776 write!(formatter, "expected one of: {:?}", &FIELDS)
8777 }
8778
8779 #[allow(unused_variables)]
8780 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8781 where
8782 E: serde::de::Error,
8783 {
8784 match value {
8785 "fields" => Ok(GeneratedField::Fields),
8786 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8787 }
8788 }
8789 }
8790 deserializer.deserialize_identifier(GeneratedVisitor)
8791 }
8792 }
8793 struct GeneratedVisitor;
8794 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8795 type Value = SinkAddColumns;
8796
8797 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8798 formatter.write_str("struct stream_plan.SinkAddColumns")
8799 }
8800
8801 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkAddColumns, V::Error>
8802 where
8803 V: serde::de::MapAccess<'de>,
8804 {
8805 let mut fields__ = None;
8806 while let Some(k) = map_.next_key()? {
8807 match k {
8808 GeneratedField::Fields => {
8809 if fields__.is_some() {
8810 return Err(serde::de::Error::duplicate_field("fields"));
8811 }
8812 fields__ = Some(map_.next_value()?);
8813 }
8814 }
8815 }
8816 Ok(SinkAddColumns {
8817 fields: fields__.unwrap_or_default(),
8818 })
8819 }
8820 }
8821 deserializer.deserialize_struct("stream_plan.SinkAddColumns", FIELDS, GeneratedVisitor)
8822 }
8823}
8824impl serde::Serialize for SinkDesc {
8825 #[allow(deprecated)]
8826 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8827 where
8828 S: serde::Serializer,
8829 {
8830 use serde::ser::SerializeStruct;
8831 let mut len = 0;
8832 if self.id != 0 {
8833 len += 1;
8834 }
8835 if !self.name.is_empty() {
8836 len += 1;
8837 }
8838 if !self.definition.is_empty() {
8839 len += 1;
8840 }
8841 if !self.plan_pk.is_empty() {
8842 len += 1;
8843 }
8844 if !self.downstream_pk.is_empty() {
8845 len += 1;
8846 }
8847 if !self.distribution_key.is_empty() {
8848 len += 1;
8849 }
8850 if !self.properties.is_empty() {
8851 len += 1;
8852 }
8853 if self.sink_type != 0 {
8854 len += 1;
8855 }
8856 if !self.column_catalogs.is_empty() {
8857 len += 1;
8858 }
8859 if !self.db_name.is_empty() {
8860 len += 1;
8861 }
8862 if !self.sink_from_name.is_empty() {
8863 len += 1;
8864 }
8865 if self.format_desc.is_some() {
8866 len += 1;
8867 }
8868 if self.target_table.is_some() {
8869 len += 1;
8870 }
8871 if self.extra_partition_col_idx.is_some() {
8872 len += 1;
8873 }
8874 if !self.secret_refs.is_empty() {
8875 len += 1;
8876 }
8877 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDesc", len)?;
8878 if self.id != 0 {
8879 struct_ser.serialize_field("id", &self.id)?;
8880 }
8881 if !self.name.is_empty() {
8882 struct_ser.serialize_field("name", &self.name)?;
8883 }
8884 if !self.definition.is_empty() {
8885 struct_ser.serialize_field("definition", &self.definition)?;
8886 }
8887 if !self.plan_pk.is_empty() {
8888 struct_ser.serialize_field("planPk", &self.plan_pk)?;
8889 }
8890 if !self.downstream_pk.is_empty() {
8891 struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
8892 }
8893 if !self.distribution_key.is_empty() {
8894 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
8895 }
8896 if !self.properties.is_empty() {
8897 struct_ser.serialize_field("properties", &self.properties)?;
8898 }
8899 if self.sink_type != 0 {
8900 let v = super::catalog::SinkType::try_from(self.sink_type)
8901 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
8902 struct_ser.serialize_field("sinkType", &v)?;
8903 }
8904 if !self.column_catalogs.is_empty() {
8905 struct_ser.serialize_field("columnCatalogs", &self.column_catalogs)?;
8906 }
8907 if !self.db_name.is_empty() {
8908 struct_ser.serialize_field("dbName", &self.db_name)?;
8909 }
8910 if !self.sink_from_name.is_empty() {
8911 struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
8912 }
8913 if let Some(v) = self.format_desc.as_ref() {
8914 struct_ser.serialize_field("formatDesc", v)?;
8915 }
8916 if let Some(v) = self.target_table.as_ref() {
8917 struct_ser.serialize_field("targetTable", v)?;
8918 }
8919 if let Some(v) = self.extra_partition_col_idx.as_ref() {
8920 #[allow(clippy::needless_borrow)]
8921 #[allow(clippy::needless_borrows_for_generic_args)]
8922 struct_ser.serialize_field("extraPartitionColIdx", ToString::to_string(&v).as_str())?;
8923 }
8924 if !self.secret_refs.is_empty() {
8925 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
8926 }
8927 struct_ser.end()
8928 }
8929}
8930impl<'de> serde::Deserialize<'de> for SinkDesc {
8931 #[allow(deprecated)]
8932 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8933 where
8934 D: serde::Deserializer<'de>,
8935 {
8936 const FIELDS: &[&str] = &[
8937 "id",
8938 "name",
8939 "definition",
8940 "plan_pk",
8941 "planPk",
8942 "downstream_pk",
8943 "downstreamPk",
8944 "distribution_key",
8945 "distributionKey",
8946 "properties",
8947 "sink_type",
8948 "sinkType",
8949 "column_catalogs",
8950 "columnCatalogs",
8951 "db_name",
8952 "dbName",
8953 "sink_from_name",
8954 "sinkFromName",
8955 "format_desc",
8956 "formatDesc",
8957 "target_table",
8958 "targetTable",
8959 "extra_partition_col_idx",
8960 "extraPartitionColIdx",
8961 "secret_refs",
8962 "secretRefs",
8963 ];
8964
8965 #[allow(clippy::enum_variant_names)]
8966 enum GeneratedField {
8967 Id,
8968 Name,
8969 Definition,
8970 PlanPk,
8971 DownstreamPk,
8972 DistributionKey,
8973 Properties,
8974 SinkType,
8975 ColumnCatalogs,
8976 DbName,
8977 SinkFromName,
8978 FormatDesc,
8979 TargetTable,
8980 ExtraPartitionColIdx,
8981 SecretRefs,
8982 }
8983 impl<'de> serde::Deserialize<'de> for GeneratedField {
8984 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8985 where
8986 D: serde::Deserializer<'de>,
8987 {
8988 struct GeneratedVisitor;
8989
8990 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8991 type Value = GeneratedField;
8992
8993 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8994 write!(formatter, "expected one of: {:?}", &FIELDS)
8995 }
8996
8997 #[allow(unused_variables)]
8998 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8999 where
9000 E: serde::de::Error,
9001 {
9002 match value {
9003 "id" => Ok(GeneratedField::Id),
9004 "name" => Ok(GeneratedField::Name),
9005 "definition" => Ok(GeneratedField::Definition),
9006 "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
9007 "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
9008 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
9009 "properties" => Ok(GeneratedField::Properties),
9010 "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
9011 "columnCatalogs" | "column_catalogs" => Ok(GeneratedField::ColumnCatalogs),
9012 "dbName" | "db_name" => Ok(GeneratedField::DbName),
9013 "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
9014 "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
9015 "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
9016 "extraPartitionColIdx" | "extra_partition_col_idx" => Ok(GeneratedField::ExtraPartitionColIdx),
9017 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
9018 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9019 }
9020 }
9021 }
9022 deserializer.deserialize_identifier(GeneratedVisitor)
9023 }
9024 }
9025 struct GeneratedVisitor;
9026 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9027 type Value = SinkDesc;
9028
9029 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9030 formatter.write_str("struct stream_plan.SinkDesc")
9031 }
9032
9033 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDesc, V::Error>
9034 where
9035 V: serde::de::MapAccess<'de>,
9036 {
9037 let mut id__ = None;
9038 let mut name__ = None;
9039 let mut definition__ = None;
9040 let mut plan_pk__ = None;
9041 let mut downstream_pk__ = None;
9042 let mut distribution_key__ = None;
9043 let mut properties__ = None;
9044 let mut sink_type__ = None;
9045 let mut column_catalogs__ = None;
9046 let mut db_name__ = None;
9047 let mut sink_from_name__ = None;
9048 let mut format_desc__ = None;
9049 let mut target_table__ = None;
9050 let mut extra_partition_col_idx__ = None;
9051 let mut secret_refs__ = None;
9052 while let Some(k) = map_.next_key()? {
9053 match k {
9054 GeneratedField::Id => {
9055 if id__.is_some() {
9056 return Err(serde::de::Error::duplicate_field("id"));
9057 }
9058 id__ =
9059 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9060 ;
9061 }
9062 GeneratedField::Name => {
9063 if name__.is_some() {
9064 return Err(serde::de::Error::duplicate_field("name"));
9065 }
9066 name__ = Some(map_.next_value()?);
9067 }
9068 GeneratedField::Definition => {
9069 if definition__.is_some() {
9070 return Err(serde::de::Error::duplicate_field("definition"));
9071 }
9072 definition__ = Some(map_.next_value()?);
9073 }
9074 GeneratedField::PlanPk => {
9075 if plan_pk__.is_some() {
9076 return Err(serde::de::Error::duplicate_field("planPk"));
9077 }
9078 plan_pk__ = Some(map_.next_value()?);
9079 }
9080 GeneratedField::DownstreamPk => {
9081 if downstream_pk__.is_some() {
9082 return Err(serde::de::Error::duplicate_field("downstreamPk"));
9083 }
9084 downstream_pk__ =
9085 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9086 .into_iter().map(|x| x.0).collect())
9087 ;
9088 }
9089 GeneratedField::DistributionKey => {
9090 if distribution_key__.is_some() {
9091 return Err(serde::de::Error::duplicate_field("distributionKey"));
9092 }
9093 distribution_key__ =
9094 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9095 .into_iter().map(|x| x.0).collect())
9096 ;
9097 }
9098 GeneratedField::Properties => {
9099 if properties__.is_some() {
9100 return Err(serde::de::Error::duplicate_field("properties"));
9101 }
9102 properties__ = Some(
9103 map_.next_value::<std::collections::BTreeMap<_, _>>()?
9104 );
9105 }
9106 GeneratedField::SinkType => {
9107 if sink_type__.is_some() {
9108 return Err(serde::de::Error::duplicate_field("sinkType"));
9109 }
9110 sink_type__ = Some(map_.next_value::<super::catalog::SinkType>()? as i32);
9111 }
9112 GeneratedField::ColumnCatalogs => {
9113 if column_catalogs__.is_some() {
9114 return Err(serde::de::Error::duplicate_field("columnCatalogs"));
9115 }
9116 column_catalogs__ = Some(map_.next_value()?);
9117 }
9118 GeneratedField::DbName => {
9119 if db_name__.is_some() {
9120 return Err(serde::de::Error::duplicate_field("dbName"));
9121 }
9122 db_name__ = Some(map_.next_value()?);
9123 }
9124 GeneratedField::SinkFromName => {
9125 if sink_from_name__.is_some() {
9126 return Err(serde::de::Error::duplicate_field("sinkFromName"));
9127 }
9128 sink_from_name__ = Some(map_.next_value()?);
9129 }
9130 GeneratedField::FormatDesc => {
9131 if format_desc__.is_some() {
9132 return Err(serde::de::Error::duplicate_field("formatDesc"));
9133 }
9134 format_desc__ = map_.next_value()?;
9135 }
9136 GeneratedField::TargetTable => {
9137 if target_table__.is_some() {
9138 return Err(serde::de::Error::duplicate_field("targetTable"));
9139 }
9140 target_table__ =
9141 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9142 ;
9143 }
9144 GeneratedField::ExtraPartitionColIdx => {
9145 if extra_partition_col_idx__.is_some() {
9146 return Err(serde::de::Error::duplicate_field("extraPartitionColIdx"));
9147 }
9148 extra_partition_col_idx__ =
9149 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9150 ;
9151 }
9152 GeneratedField::SecretRefs => {
9153 if secret_refs__.is_some() {
9154 return Err(serde::de::Error::duplicate_field("secretRefs"));
9155 }
9156 secret_refs__ = Some(
9157 map_.next_value::<std::collections::BTreeMap<_, _>>()?
9158 );
9159 }
9160 }
9161 }
9162 Ok(SinkDesc {
9163 id: id__.unwrap_or_default(),
9164 name: name__.unwrap_or_default(),
9165 definition: definition__.unwrap_or_default(),
9166 plan_pk: plan_pk__.unwrap_or_default(),
9167 downstream_pk: downstream_pk__.unwrap_or_default(),
9168 distribution_key: distribution_key__.unwrap_or_default(),
9169 properties: properties__.unwrap_or_default(),
9170 sink_type: sink_type__.unwrap_or_default(),
9171 column_catalogs: column_catalogs__.unwrap_or_default(),
9172 db_name: db_name__.unwrap_or_default(),
9173 sink_from_name: sink_from_name__.unwrap_or_default(),
9174 format_desc: format_desc__,
9175 target_table: target_table__,
9176 extra_partition_col_idx: extra_partition_col_idx__,
9177 secret_refs: secret_refs__.unwrap_or_default(),
9178 })
9179 }
9180 }
9181 deserializer.deserialize_struct("stream_plan.SinkDesc", FIELDS, GeneratedVisitor)
9182 }
9183}
9184impl serde::Serialize for SinkLogStoreType {
9185 #[allow(deprecated)]
9186 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9187 where
9188 S: serde::Serializer,
9189 {
9190 let variant = match self {
9191 Self::Unspecified => "SINK_LOG_STORE_TYPE_UNSPECIFIED",
9192 Self::KvLogStore => "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
9193 Self::InMemoryLogStore => "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
9194 };
9195 serializer.serialize_str(variant)
9196 }
9197}
9198impl<'de> serde::Deserialize<'de> for SinkLogStoreType {
9199 #[allow(deprecated)]
9200 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9201 where
9202 D: serde::Deserializer<'de>,
9203 {
9204 const FIELDS: &[&str] = &[
9205 "SINK_LOG_STORE_TYPE_UNSPECIFIED",
9206 "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
9207 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
9208 ];
9209
9210 struct GeneratedVisitor;
9211
9212 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9213 type Value = SinkLogStoreType;
9214
9215 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9216 write!(formatter, "expected one of: {:?}", &FIELDS)
9217 }
9218
9219 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9220 where
9221 E: serde::de::Error,
9222 {
9223 i32::try_from(v)
9224 .ok()
9225 .and_then(|x| x.try_into().ok())
9226 .ok_or_else(|| {
9227 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9228 })
9229 }
9230
9231 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9232 where
9233 E: serde::de::Error,
9234 {
9235 i32::try_from(v)
9236 .ok()
9237 .and_then(|x| x.try_into().ok())
9238 .ok_or_else(|| {
9239 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9240 })
9241 }
9242
9243 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9244 where
9245 E: serde::de::Error,
9246 {
9247 match value {
9248 "SINK_LOG_STORE_TYPE_UNSPECIFIED" => Ok(SinkLogStoreType::Unspecified),
9249 "SINK_LOG_STORE_TYPE_KV_LOG_STORE" => Ok(SinkLogStoreType::KvLogStore),
9250 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE" => Ok(SinkLogStoreType::InMemoryLogStore),
9251 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9252 }
9253 }
9254 }
9255 deserializer.deserialize_any(GeneratedVisitor)
9256 }
9257}
9258impl serde::Serialize for SinkNode {
9259 #[allow(deprecated)]
9260 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9261 where
9262 S: serde::Serializer,
9263 {
9264 use serde::ser::SerializeStruct;
9265 let mut len = 0;
9266 if self.sink_desc.is_some() {
9267 len += 1;
9268 }
9269 if self.table.is_some() {
9270 len += 1;
9271 }
9272 if self.log_store_type != 0 {
9273 len += 1;
9274 }
9275 if self.rate_limit.is_some() {
9276 len += 1;
9277 }
9278 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkNode", len)?;
9279 if let Some(v) = self.sink_desc.as_ref() {
9280 struct_ser.serialize_field("sinkDesc", v)?;
9281 }
9282 if let Some(v) = self.table.as_ref() {
9283 struct_ser.serialize_field("table", v)?;
9284 }
9285 if self.log_store_type != 0 {
9286 let v = SinkLogStoreType::try_from(self.log_store_type)
9287 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.log_store_type)))?;
9288 struct_ser.serialize_field("logStoreType", &v)?;
9289 }
9290 if let Some(v) = self.rate_limit.as_ref() {
9291 struct_ser.serialize_field("rateLimit", v)?;
9292 }
9293 struct_ser.end()
9294 }
9295}
9296impl<'de> serde::Deserialize<'de> for SinkNode {
9297 #[allow(deprecated)]
9298 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9299 where
9300 D: serde::Deserializer<'de>,
9301 {
9302 const FIELDS: &[&str] = &[
9303 "sink_desc",
9304 "sinkDesc",
9305 "table",
9306 "log_store_type",
9307 "logStoreType",
9308 "rate_limit",
9309 "rateLimit",
9310 ];
9311
9312 #[allow(clippy::enum_variant_names)]
9313 enum GeneratedField {
9314 SinkDesc,
9315 Table,
9316 LogStoreType,
9317 RateLimit,
9318 }
9319 impl<'de> serde::Deserialize<'de> for GeneratedField {
9320 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9321 where
9322 D: serde::Deserializer<'de>,
9323 {
9324 struct GeneratedVisitor;
9325
9326 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9327 type Value = GeneratedField;
9328
9329 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9330 write!(formatter, "expected one of: {:?}", &FIELDS)
9331 }
9332
9333 #[allow(unused_variables)]
9334 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9335 where
9336 E: serde::de::Error,
9337 {
9338 match value {
9339 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
9340 "table" => Ok(GeneratedField::Table),
9341 "logStoreType" | "log_store_type" => Ok(GeneratedField::LogStoreType),
9342 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
9343 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9344 }
9345 }
9346 }
9347 deserializer.deserialize_identifier(GeneratedVisitor)
9348 }
9349 }
9350 struct GeneratedVisitor;
9351 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9352 type Value = SinkNode;
9353
9354 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9355 formatter.write_str("struct stream_plan.SinkNode")
9356 }
9357
9358 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkNode, V::Error>
9359 where
9360 V: serde::de::MapAccess<'de>,
9361 {
9362 let mut sink_desc__ = None;
9363 let mut table__ = None;
9364 let mut log_store_type__ = None;
9365 let mut rate_limit__ = None;
9366 while let Some(k) = map_.next_key()? {
9367 match k {
9368 GeneratedField::SinkDesc => {
9369 if sink_desc__.is_some() {
9370 return Err(serde::de::Error::duplicate_field("sinkDesc"));
9371 }
9372 sink_desc__ = map_.next_value()?;
9373 }
9374 GeneratedField::Table => {
9375 if table__.is_some() {
9376 return Err(serde::de::Error::duplicate_field("table"));
9377 }
9378 table__ = map_.next_value()?;
9379 }
9380 GeneratedField::LogStoreType => {
9381 if log_store_type__.is_some() {
9382 return Err(serde::de::Error::duplicate_field("logStoreType"));
9383 }
9384 log_store_type__ = Some(map_.next_value::<SinkLogStoreType>()? as i32);
9385 }
9386 GeneratedField::RateLimit => {
9387 if rate_limit__.is_some() {
9388 return Err(serde::de::Error::duplicate_field("rateLimit"));
9389 }
9390 rate_limit__ =
9391 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9392 ;
9393 }
9394 }
9395 }
9396 Ok(SinkNode {
9397 sink_desc: sink_desc__,
9398 table: table__,
9399 log_store_type: log_store_type__.unwrap_or_default(),
9400 rate_limit: rate_limit__,
9401 })
9402 }
9403 }
9404 deserializer.deserialize_struct("stream_plan.SinkNode", FIELDS, GeneratedVisitor)
9405 }
9406}
9407impl serde::Serialize for SortNode {
9408 #[allow(deprecated)]
9409 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9410 where
9411 S: serde::Serializer,
9412 {
9413 use serde::ser::SerializeStruct;
9414 let mut len = 0;
9415 if self.state_table.is_some() {
9416 len += 1;
9417 }
9418 if self.sort_column_index != 0 {
9419 len += 1;
9420 }
9421 let mut struct_ser = serializer.serialize_struct("stream_plan.SortNode", len)?;
9422 if let Some(v) = self.state_table.as_ref() {
9423 struct_ser.serialize_field("stateTable", v)?;
9424 }
9425 if self.sort_column_index != 0 {
9426 struct_ser.serialize_field("sortColumnIndex", &self.sort_column_index)?;
9427 }
9428 struct_ser.end()
9429 }
9430}
9431impl<'de> serde::Deserialize<'de> for SortNode {
9432 #[allow(deprecated)]
9433 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9434 where
9435 D: serde::Deserializer<'de>,
9436 {
9437 const FIELDS: &[&str] = &[
9438 "state_table",
9439 "stateTable",
9440 "sort_column_index",
9441 "sortColumnIndex",
9442 ];
9443
9444 #[allow(clippy::enum_variant_names)]
9445 enum GeneratedField {
9446 StateTable,
9447 SortColumnIndex,
9448 }
9449 impl<'de> serde::Deserialize<'de> for GeneratedField {
9450 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9451 where
9452 D: serde::Deserializer<'de>,
9453 {
9454 struct GeneratedVisitor;
9455
9456 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9457 type Value = GeneratedField;
9458
9459 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9460 write!(formatter, "expected one of: {:?}", &FIELDS)
9461 }
9462
9463 #[allow(unused_variables)]
9464 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9465 where
9466 E: serde::de::Error,
9467 {
9468 match value {
9469 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9470 "sortColumnIndex" | "sort_column_index" => Ok(GeneratedField::SortColumnIndex),
9471 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9472 }
9473 }
9474 }
9475 deserializer.deserialize_identifier(GeneratedVisitor)
9476 }
9477 }
9478 struct GeneratedVisitor;
9479 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9480 type Value = SortNode;
9481
9482 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9483 formatter.write_str("struct stream_plan.SortNode")
9484 }
9485
9486 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
9487 where
9488 V: serde::de::MapAccess<'de>,
9489 {
9490 let mut state_table__ = None;
9491 let mut sort_column_index__ = None;
9492 while let Some(k) = map_.next_key()? {
9493 match k {
9494 GeneratedField::StateTable => {
9495 if state_table__.is_some() {
9496 return Err(serde::de::Error::duplicate_field("stateTable"));
9497 }
9498 state_table__ = map_.next_value()?;
9499 }
9500 GeneratedField::SortColumnIndex => {
9501 if sort_column_index__.is_some() {
9502 return Err(serde::de::Error::duplicate_field("sortColumnIndex"));
9503 }
9504 sort_column_index__ =
9505 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9506 ;
9507 }
9508 }
9509 }
9510 Ok(SortNode {
9511 state_table: state_table__,
9512 sort_column_index: sort_column_index__.unwrap_or_default(),
9513 })
9514 }
9515 }
9516 deserializer.deserialize_struct("stream_plan.SortNode", FIELDS, GeneratedVisitor)
9517 }
9518}
9519impl serde::Serialize for SourceBackfillNode {
9520 #[allow(deprecated)]
9521 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9522 where
9523 S: serde::Serializer,
9524 {
9525 use serde::ser::SerializeStruct;
9526 let mut len = 0;
9527 if self.upstream_source_id != 0 {
9528 len += 1;
9529 }
9530 if self.row_id_index.is_some() {
9531 len += 1;
9532 }
9533 if !self.columns.is_empty() {
9534 len += 1;
9535 }
9536 if self.info.is_some() {
9537 len += 1;
9538 }
9539 if !self.source_name.is_empty() {
9540 len += 1;
9541 }
9542 if !self.with_properties.is_empty() {
9543 len += 1;
9544 }
9545 if self.rate_limit.is_some() {
9546 len += 1;
9547 }
9548 if self.state_table.is_some() {
9549 len += 1;
9550 }
9551 if !self.secret_refs.is_empty() {
9552 len += 1;
9553 }
9554 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceBackfillNode", len)?;
9555 if self.upstream_source_id != 0 {
9556 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
9557 }
9558 if let Some(v) = self.row_id_index.as_ref() {
9559 struct_ser.serialize_field("rowIdIndex", v)?;
9560 }
9561 if !self.columns.is_empty() {
9562 struct_ser.serialize_field("columns", &self.columns)?;
9563 }
9564 if let Some(v) = self.info.as_ref() {
9565 struct_ser.serialize_field("info", v)?;
9566 }
9567 if !self.source_name.is_empty() {
9568 struct_ser.serialize_field("sourceName", &self.source_name)?;
9569 }
9570 if !self.with_properties.is_empty() {
9571 struct_ser.serialize_field("withProperties", &self.with_properties)?;
9572 }
9573 if let Some(v) = self.rate_limit.as_ref() {
9574 struct_ser.serialize_field("rateLimit", v)?;
9575 }
9576 if let Some(v) = self.state_table.as_ref() {
9577 struct_ser.serialize_field("stateTable", v)?;
9578 }
9579 if !self.secret_refs.is_empty() {
9580 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
9581 }
9582 struct_ser.end()
9583 }
9584}
9585impl<'de> serde::Deserialize<'de> for SourceBackfillNode {
9586 #[allow(deprecated)]
9587 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9588 where
9589 D: serde::Deserializer<'de>,
9590 {
9591 const FIELDS: &[&str] = &[
9592 "upstream_source_id",
9593 "upstreamSourceId",
9594 "row_id_index",
9595 "rowIdIndex",
9596 "columns",
9597 "info",
9598 "source_name",
9599 "sourceName",
9600 "with_properties",
9601 "withProperties",
9602 "rate_limit",
9603 "rateLimit",
9604 "state_table",
9605 "stateTable",
9606 "secret_refs",
9607 "secretRefs",
9608 ];
9609
9610 #[allow(clippy::enum_variant_names)]
9611 enum GeneratedField {
9612 UpstreamSourceId,
9613 RowIdIndex,
9614 Columns,
9615 Info,
9616 SourceName,
9617 WithProperties,
9618 RateLimit,
9619 StateTable,
9620 SecretRefs,
9621 }
9622 impl<'de> serde::Deserialize<'de> for GeneratedField {
9623 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9624 where
9625 D: serde::Deserializer<'de>,
9626 {
9627 struct GeneratedVisitor;
9628
9629 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9630 type Value = GeneratedField;
9631
9632 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9633 write!(formatter, "expected one of: {:?}", &FIELDS)
9634 }
9635
9636 #[allow(unused_variables)]
9637 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9638 where
9639 E: serde::de::Error,
9640 {
9641 match value {
9642 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
9643 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
9644 "columns" => Ok(GeneratedField::Columns),
9645 "info" => Ok(GeneratedField::Info),
9646 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
9647 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
9648 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
9649 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9650 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
9651 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9652 }
9653 }
9654 }
9655 deserializer.deserialize_identifier(GeneratedVisitor)
9656 }
9657 }
9658 struct GeneratedVisitor;
9659 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9660 type Value = SourceBackfillNode;
9661
9662 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9663 formatter.write_str("struct stream_plan.SourceBackfillNode")
9664 }
9665
9666 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceBackfillNode, V::Error>
9667 where
9668 V: serde::de::MapAccess<'de>,
9669 {
9670 let mut upstream_source_id__ = None;
9671 let mut row_id_index__ = None;
9672 let mut columns__ = None;
9673 let mut info__ = None;
9674 let mut source_name__ = None;
9675 let mut with_properties__ = None;
9676 let mut rate_limit__ = None;
9677 let mut state_table__ = None;
9678 let mut secret_refs__ = None;
9679 while let Some(k) = map_.next_key()? {
9680 match k {
9681 GeneratedField::UpstreamSourceId => {
9682 if upstream_source_id__.is_some() {
9683 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
9684 }
9685 upstream_source_id__ =
9686 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9687 ;
9688 }
9689 GeneratedField::RowIdIndex => {
9690 if row_id_index__.is_some() {
9691 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
9692 }
9693 row_id_index__ =
9694 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9695 ;
9696 }
9697 GeneratedField::Columns => {
9698 if columns__.is_some() {
9699 return Err(serde::de::Error::duplicate_field("columns"));
9700 }
9701 columns__ = Some(map_.next_value()?);
9702 }
9703 GeneratedField::Info => {
9704 if info__.is_some() {
9705 return Err(serde::de::Error::duplicate_field("info"));
9706 }
9707 info__ = map_.next_value()?;
9708 }
9709 GeneratedField::SourceName => {
9710 if source_name__.is_some() {
9711 return Err(serde::de::Error::duplicate_field("sourceName"));
9712 }
9713 source_name__ = Some(map_.next_value()?);
9714 }
9715 GeneratedField::WithProperties => {
9716 if with_properties__.is_some() {
9717 return Err(serde::de::Error::duplicate_field("withProperties"));
9718 }
9719 with_properties__ = Some(
9720 map_.next_value::<std::collections::BTreeMap<_, _>>()?
9721 );
9722 }
9723 GeneratedField::RateLimit => {
9724 if rate_limit__.is_some() {
9725 return Err(serde::de::Error::duplicate_field("rateLimit"));
9726 }
9727 rate_limit__ =
9728 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9729 ;
9730 }
9731 GeneratedField::StateTable => {
9732 if state_table__.is_some() {
9733 return Err(serde::de::Error::duplicate_field("stateTable"));
9734 }
9735 state_table__ = map_.next_value()?;
9736 }
9737 GeneratedField::SecretRefs => {
9738 if secret_refs__.is_some() {
9739 return Err(serde::de::Error::duplicate_field("secretRefs"));
9740 }
9741 secret_refs__ = Some(
9742 map_.next_value::<std::collections::BTreeMap<_, _>>()?
9743 );
9744 }
9745 }
9746 }
9747 Ok(SourceBackfillNode {
9748 upstream_source_id: upstream_source_id__.unwrap_or_default(),
9749 row_id_index: row_id_index__,
9750 columns: columns__.unwrap_or_default(),
9751 info: info__,
9752 source_name: source_name__.unwrap_or_default(),
9753 with_properties: with_properties__.unwrap_or_default(),
9754 rate_limit: rate_limit__,
9755 state_table: state_table__,
9756 secret_refs: secret_refs__.unwrap_or_default(),
9757 })
9758 }
9759 }
9760 deserializer.deserialize_struct("stream_plan.SourceBackfillNode", FIELDS, GeneratedVisitor)
9761 }
9762}
9763impl serde::Serialize for SourceChangeSplitMutation {
9764 #[allow(deprecated)]
9765 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9766 where
9767 S: serde::Serializer,
9768 {
9769 use serde::ser::SerializeStruct;
9770 let mut len = 0;
9771 if !self.actor_splits.is_empty() {
9772 len += 1;
9773 }
9774 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceChangeSplitMutation", len)?;
9775 if !self.actor_splits.is_empty() {
9776 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
9777 }
9778 struct_ser.end()
9779 }
9780}
9781impl<'de> serde::Deserialize<'de> for SourceChangeSplitMutation {
9782 #[allow(deprecated)]
9783 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9784 where
9785 D: serde::Deserializer<'de>,
9786 {
9787 const FIELDS: &[&str] = &[
9788 "actor_splits",
9789 "actorSplits",
9790 ];
9791
9792 #[allow(clippy::enum_variant_names)]
9793 enum GeneratedField {
9794 ActorSplits,
9795 }
9796 impl<'de> serde::Deserialize<'de> for GeneratedField {
9797 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9798 where
9799 D: serde::Deserializer<'de>,
9800 {
9801 struct GeneratedVisitor;
9802
9803 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9804 type Value = GeneratedField;
9805
9806 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9807 write!(formatter, "expected one of: {:?}", &FIELDS)
9808 }
9809
9810 #[allow(unused_variables)]
9811 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9812 where
9813 E: serde::de::Error,
9814 {
9815 match value {
9816 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
9817 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9818 }
9819 }
9820 }
9821 deserializer.deserialize_identifier(GeneratedVisitor)
9822 }
9823 }
9824 struct GeneratedVisitor;
9825 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9826 type Value = SourceChangeSplitMutation;
9827
9828 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9829 formatter.write_str("struct stream_plan.SourceChangeSplitMutation")
9830 }
9831
9832 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceChangeSplitMutation, V::Error>
9833 where
9834 V: serde::de::MapAccess<'de>,
9835 {
9836 let mut actor_splits__ = None;
9837 while let Some(k) = map_.next_key()? {
9838 match k {
9839 GeneratedField::ActorSplits => {
9840 if actor_splits__.is_some() {
9841 return Err(serde::de::Error::duplicate_field("actorSplits"));
9842 }
9843 actor_splits__ = Some(
9844 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
9845 .into_iter().map(|(k,v)| (k.0, v)).collect()
9846 );
9847 }
9848 }
9849 }
9850 Ok(SourceChangeSplitMutation {
9851 actor_splits: actor_splits__.unwrap_or_default(),
9852 })
9853 }
9854 }
9855 deserializer.deserialize_struct("stream_plan.SourceChangeSplitMutation", FIELDS, GeneratedVisitor)
9856 }
9857}
9858impl serde::Serialize for SourceNode {
9859 #[allow(deprecated)]
9860 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9861 where
9862 S: serde::Serializer,
9863 {
9864 use serde::ser::SerializeStruct;
9865 let mut len = 0;
9866 if self.source_inner.is_some() {
9867 len += 1;
9868 }
9869 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceNode", len)?;
9870 if let Some(v) = self.source_inner.as_ref() {
9871 struct_ser.serialize_field("sourceInner", v)?;
9872 }
9873 struct_ser.end()
9874 }
9875}
9876impl<'de> serde::Deserialize<'de> for SourceNode {
9877 #[allow(deprecated)]
9878 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9879 where
9880 D: serde::Deserializer<'de>,
9881 {
9882 const FIELDS: &[&str] = &[
9883 "source_inner",
9884 "sourceInner",
9885 ];
9886
9887 #[allow(clippy::enum_variant_names)]
9888 enum GeneratedField {
9889 SourceInner,
9890 }
9891 impl<'de> serde::Deserialize<'de> for GeneratedField {
9892 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9893 where
9894 D: serde::Deserializer<'de>,
9895 {
9896 struct GeneratedVisitor;
9897
9898 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9899 type Value = GeneratedField;
9900
9901 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9902 write!(formatter, "expected one of: {:?}", &FIELDS)
9903 }
9904
9905 #[allow(unused_variables)]
9906 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9907 where
9908 E: serde::de::Error,
9909 {
9910 match value {
9911 "sourceInner" | "source_inner" => Ok(GeneratedField::SourceInner),
9912 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9913 }
9914 }
9915 }
9916 deserializer.deserialize_identifier(GeneratedVisitor)
9917 }
9918 }
9919 struct GeneratedVisitor;
9920 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9921 type Value = SourceNode;
9922
9923 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9924 formatter.write_str("struct stream_plan.SourceNode")
9925 }
9926
9927 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
9928 where
9929 V: serde::de::MapAccess<'de>,
9930 {
9931 let mut source_inner__ = None;
9932 while let Some(k) = map_.next_key()? {
9933 match k {
9934 GeneratedField::SourceInner => {
9935 if source_inner__.is_some() {
9936 return Err(serde::de::Error::duplicate_field("sourceInner"));
9937 }
9938 source_inner__ = map_.next_value()?;
9939 }
9940 }
9941 }
9942 Ok(SourceNode {
9943 source_inner: source_inner__,
9944 })
9945 }
9946 }
9947 deserializer.deserialize_struct("stream_plan.SourceNode", FIELDS, GeneratedVisitor)
9948 }
9949}
9950impl serde::Serialize for StartFragmentBackfillMutation {
9951 #[allow(deprecated)]
9952 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9953 where
9954 S: serde::Serializer,
9955 {
9956 use serde::ser::SerializeStruct;
9957 let mut len = 0;
9958 if !self.fragment_ids.is_empty() {
9959 len += 1;
9960 }
9961 let mut struct_ser = serializer.serialize_struct("stream_plan.StartFragmentBackfillMutation", len)?;
9962 if !self.fragment_ids.is_empty() {
9963 struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
9964 }
9965 struct_ser.end()
9966 }
9967}
9968impl<'de> serde::Deserialize<'de> for StartFragmentBackfillMutation {
9969 #[allow(deprecated)]
9970 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9971 where
9972 D: serde::Deserializer<'de>,
9973 {
9974 const FIELDS: &[&str] = &[
9975 "fragment_ids",
9976 "fragmentIds",
9977 ];
9978
9979 #[allow(clippy::enum_variant_names)]
9980 enum GeneratedField {
9981 FragmentIds,
9982 }
9983 impl<'de> serde::Deserialize<'de> for GeneratedField {
9984 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9985 where
9986 D: serde::Deserializer<'de>,
9987 {
9988 struct GeneratedVisitor;
9989
9990 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9991 type Value = GeneratedField;
9992
9993 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9994 write!(formatter, "expected one of: {:?}", &FIELDS)
9995 }
9996
9997 #[allow(unused_variables)]
9998 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9999 where
10000 E: serde::de::Error,
10001 {
10002 match value {
10003 "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
10004 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10005 }
10006 }
10007 }
10008 deserializer.deserialize_identifier(GeneratedVisitor)
10009 }
10010 }
10011 struct GeneratedVisitor;
10012 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10013 type Value = StartFragmentBackfillMutation;
10014
10015 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10016 formatter.write_str("struct stream_plan.StartFragmentBackfillMutation")
10017 }
10018
10019 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StartFragmentBackfillMutation, V::Error>
10020 where
10021 V: serde::de::MapAccess<'de>,
10022 {
10023 let mut fragment_ids__ = None;
10024 while let Some(k) = map_.next_key()? {
10025 match k {
10026 GeneratedField::FragmentIds => {
10027 if fragment_ids__.is_some() {
10028 return Err(serde::de::Error::duplicate_field("fragmentIds"));
10029 }
10030 fragment_ids__ =
10031 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10032 .into_iter().map(|x| x.0).collect())
10033 ;
10034 }
10035 }
10036 }
10037 Ok(StartFragmentBackfillMutation {
10038 fragment_ids: fragment_ids__.unwrap_or_default(),
10039 })
10040 }
10041 }
10042 deserializer.deserialize_struct("stream_plan.StartFragmentBackfillMutation", FIELDS, GeneratedVisitor)
10043 }
10044}
10045impl serde::Serialize for StopMutation {
10046 #[allow(deprecated)]
10047 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10048 where
10049 S: serde::Serializer,
10050 {
10051 use serde::ser::SerializeStruct;
10052 let mut len = 0;
10053 if !self.actors.is_empty() {
10054 len += 1;
10055 }
10056 if !self.dropped_sink_fragments.is_empty() {
10057 len += 1;
10058 }
10059 let mut struct_ser = serializer.serialize_struct("stream_plan.StopMutation", len)?;
10060 if !self.actors.is_empty() {
10061 struct_ser.serialize_field("actors", &self.actors)?;
10062 }
10063 if !self.dropped_sink_fragments.is_empty() {
10064 struct_ser.serialize_field("droppedSinkFragments", &self.dropped_sink_fragments)?;
10065 }
10066 struct_ser.end()
10067 }
10068}
10069impl<'de> serde::Deserialize<'de> for StopMutation {
10070 #[allow(deprecated)]
10071 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10072 where
10073 D: serde::Deserializer<'de>,
10074 {
10075 const FIELDS: &[&str] = &[
10076 "actors",
10077 "dropped_sink_fragments",
10078 "droppedSinkFragments",
10079 ];
10080
10081 #[allow(clippy::enum_variant_names)]
10082 enum GeneratedField {
10083 Actors,
10084 DroppedSinkFragments,
10085 }
10086 impl<'de> serde::Deserialize<'de> for GeneratedField {
10087 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10088 where
10089 D: serde::Deserializer<'de>,
10090 {
10091 struct GeneratedVisitor;
10092
10093 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10094 type Value = GeneratedField;
10095
10096 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10097 write!(formatter, "expected one of: {:?}", &FIELDS)
10098 }
10099
10100 #[allow(unused_variables)]
10101 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10102 where
10103 E: serde::de::Error,
10104 {
10105 match value {
10106 "actors" => Ok(GeneratedField::Actors),
10107 "droppedSinkFragments" | "dropped_sink_fragments" => Ok(GeneratedField::DroppedSinkFragments),
10108 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10109 }
10110 }
10111 }
10112 deserializer.deserialize_identifier(GeneratedVisitor)
10113 }
10114 }
10115 struct GeneratedVisitor;
10116 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10117 type Value = StopMutation;
10118
10119 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10120 formatter.write_str("struct stream_plan.StopMutation")
10121 }
10122
10123 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopMutation, V::Error>
10124 where
10125 V: serde::de::MapAccess<'de>,
10126 {
10127 let mut actors__ = None;
10128 let mut dropped_sink_fragments__ = None;
10129 while let Some(k) = map_.next_key()? {
10130 match k {
10131 GeneratedField::Actors => {
10132 if actors__.is_some() {
10133 return Err(serde::de::Error::duplicate_field("actors"));
10134 }
10135 actors__ =
10136 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10137 .into_iter().map(|x| x.0).collect())
10138 ;
10139 }
10140 GeneratedField::DroppedSinkFragments => {
10141 if dropped_sink_fragments__.is_some() {
10142 return Err(serde::de::Error::duplicate_field("droppedSinkFragments"));
10143 }
10144 dropped_sink_fragments__ =
10145 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10146 .into_iter().map(|x| x.0).collect())
10147 ;
10148 }
10149 }
10150 }
10151 Ok(StopMutation {
10152 actors: actors__.unwrap_or_default(),
10153 dropped_sink_fragments: dropped_sink_fragments__.unwrap_or_default(),
10154 })
10155 }
10156 }
10157 deserializer.deserialize_struct("stream_plan.StopMutation", FIELDS, GeneratedVisitor)
10158 }
10159}
10160impl serde::Serialize for StreamActor {
10161 #[allow(deprecated)]
10162 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10163 where
10164 S: serde::Serializer,
10165 {
10166 use serde::ser::SerializeStruct;
10167 let mut len = 0;
10168 if self.actor_id != 0 {
10169 len += 1;
10170 }
10171 if self.fragment_id != 0 {
10172 len += 1;
10173 }
10174 if !self.dispatcher.is_empty() {
10175 len += 1;
10176 }
10177 if self.vnode_bitmap.is_some() {
10178 len += 1;
10179 }
10180 if !self.mview_definition.is_empty() {
10181 len += 1;
10182 }
10183 if self.expr_context.is_some() {
10184 len += 1;
10185 }
10186 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamActor", len)?;
10187 if self.actor_id != 0 {
10188 struct_ser.serialize_field("actorId", &self.actor_id)?;
10189 }
10190 if self.fragment_id != 0 {
10191 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
10192 }
10193 if !self.dispatcher.is_empty() {
10194 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
10195 }
10196 if let Some(v) = self.vnode_bitmap.as_ref() {
10197 struct_ser.serialize_field("vnodeBitmap", v)?;
10198 }
10199 if !self.mview_definition.is_empty() {
10200 struct_ser.serialize_field("mviewDefinition", &self.mview_definition)?;
10201 }
10202 if let Some(v) = self.expr_context.as_ref() {
10203 struct_ser.serialize_field("exprContext", v)?;
10204 }
10205 struct_ser.end()
10206 }
10207}
10208impl<'de> serde::Deserialize<'de> for StreamActor {
10209 #[allow(deprecated)]
10210 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10211 where
10212 D: serde::Deserializer<'de>,
10213 {
10214 const FIELDS: &[&str] = &[
10215 "actor_id",
10216 "actorId",
10217 "fragment_id",
10218 "fragmentId",
10219 "dispatcher",
10220 "vnode_bitmap",
10221 "vnodeBitmap",
10222 "mview_definition",
10223 "mviewDefinition",
10224 "expr_context",
10225 "exprContext",
10226 ];
10227
10228 #[allow(clippy::enum_variant_names)]
10229 enum GeneratedField {
10230 ActorId,
10231 FragmentId,
10232 Dispatcher,
10233 VnodeBitmap,
10234 MviewDefinition,
10235 ExprContext,
10236 }
10237 impl<'de> serde::Deserialize<'de> for GeneratedField {
10238 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10239 where
10240 D: serde::Deserializer<'de>,
10241 {
10242 struct GeneratedVisitor;
10243
10244 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10245 type Value = GeneratedField;
10246
10247 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10248 write!(formatter, "expected one of: {:?}", &FIELDS)
10249 }
10250
10251 #[allow(unused_variables)]
10252 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10253 where
10254 E: serde::de::Error,
10255 {
10256 match value {
10257 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
10258 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
10259 "dispatcher" => Ok(GeneratedField::Dispatcher),
10260 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
10261 "mviewDefinition" | "mview_definition" => Ok(GeneratedField::MviewDefinition),
10262 "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
10263 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10264 }
10265 }
10266 }
10267 deserializer.deserialize_identifier(GeneratedVisitor)
10268 }
10269 }
10270 struct GeneratedVisitor;
10271 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10272 type Value = StreamActor;
10273
10274 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10275 formatter.write_str("struct stream_plan.StreamActor")
10276 }
10277
10278 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamActor, V::Error>
10279 where
10280 V: serde::de::MapAccess<'de>,
10281 {
10282 let mut actor_id__ = None;
10283 let mut fragment_id__ = None;
10284 let mut dispatcher__ = None;
10285 let mut vnode_bitmap__ = None;
10286 let mut mview_definition__ = None;
10287 let mut expr_context__ = None;
10288 while let Some(k) = map_.next_key()? {
10289 match k {
10290 GeneratedField::ActorId => {
10291 if actor_id__.is_some() {
10292 return Err(serde::de::Error::duplicate_field("actorId"));
10293 }
10294 actor_id__ =
10295 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10296 ;
10297 }
10298 GeneratedField::FragmentId => {
10299 if fragment_id__.is_some() {
10300 return Err(serde::de::Error::duplicate_field("fragmentId"));
10301 }
10302 fragment_id__ =
10303 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10304 ;
10305 }
10306 GeneratedField::Dispatcher => {
10307 if dispatcher__.is_some() {
10308 return Err(serde::de::Error::duplicate_field("dispatcher"));
10309 }
10310 dispatcher__ = Some(map_.next_value()?);
10311 }
10312 GeneratedField::VnodeBitmap => {
10313 if vnode_bitmap__.is_some() {
10314 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
10315 }
10316 vnode_bitmap__ = map_.next_value()?;
10317 }
10318 GeneratedField::MviewDefinition => {
10319 if mview_definition__.is_some() {
10320 return Err(serde::de::Error::duplicate_field("mviewDefinition"));
10321 }
10322 mview_definition__ = Some(map_.next_value()?);
10323 }
10324 GeneratedField::ExprContext => {
10325 if expr_context__.is_some() {
10326 return Err(serde::de::Error::duplicate_field("exprContext"));
10327 }
10328 expr_context__ = map_.next_value()?;
10329 }
10330 }
10331 }
10332 Ok(StreamActor {
10333 actor_id: actor_id__.unwrap_or_default(),
10334 fragment_id: fragment_id__.unwrap_or_default(),
10335 dispatcher: dispatcher__.unwrap_or_default(),
10336 vnode_bitmap: vnode_bitmap__,
10337 mview_definition: mview_definition__.unwrap_or_default(),
10338 expr_context: expr_context__,
10339 })
10340 }
10341 }
10342 deserializer.deserialize_struct("stream_plan.StreamActor", FIELDS, GeneratedVisitor)
10343 }
10344}
10345impl serde::Serialize for StreamCdcScanNode {
10346 #[allow(deprecated)]
10347 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10348 where
10349 S: serde::Serializer,
10350 {
10351 use serde::ser::SerializeStruct;
10352 let mut len = 0;
10353 if self.table_id != 0 {
10354 len += 1;
10355 }
10356 if !self.upstream_column_ids.is_empty() {
10357 len += 1;
10358 }
10359 if !self.output_indices.is_empty() {
10360 len += 1;
10361 }
10362 if self.state_table.is_some() {
10363 len += 1;
10364 }
10365 if self.cdc_table_desc.is_some() {
10366 len += 1;
10367 }
10368 if self.rate_limit.is_some() {
10369 len += 1;
10370 }
10371 if self.disable_backfill {
10372 len += 1;
10373 }
10374 if self.options.is_some() {
10375 len += 1;
10376 }
10377 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanNode", len)?;
10378 if self.table_id != 0 {
10379 struct_ser.serialize_field("tableId", &self.table_id)?;
10380 }
10381 if !self.upstream_column_ids.is_empty() {
10382 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
10383 }
10384 if !self.output_indices.is_empty() {
10385 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
10386 }
10387 if let Some(v) = self.state_table.as_ref() {
10388 struct_ser.serialize_field("stateTable", v)?;
10389 }
10390 if let Some(v) = self.cdc_table_desc.as_ref() {
10391 struct_ser.serialize_field("cdcTableDesc", v)?;
10392 }
10393 if let Some(v) = self.rate_limit.as_ref() {
10394 struct_ser.serialize_field("rateLimit", v)?;
10395 }
10396 if self.disable_backfill {
10397 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
10398 }
10399 if let Some(v) = self.options.as_ref() {
10400 struct_ser.serialize_field("options", v)?;
10401 }
10402 struct_ser.end()
10403 }
10404}
10405impl<'de> serde::Deserialize<'de> for StreamCdcScanNode {
10406 #[allow(deprecated)]
10407 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10408 where
10409 D: serde::Deserializer<'de>,
10410 {
10411 const FIELDS: &[&str] = &[
10412 "table_id",
10413 "tableId",
10414 "upstream_column_ids",
10415 "upstreamColumnIds",
10416 "output_indices",
10417 "outputIndices",
10418 "state_table",
10419 "stateTable",
10420 "cdc_table_desc",
10421 "cdcTableDesc",
10422 "rate_limit",
10423 "rateLimit",
10424 "disable_backfill",
10425 "disableBackfill",
10426 "options",
10427 ];
10428
10429 #[allow(clippy::enum_variant_names)]
10430 enum GeneratedField {
10431 TableId,
10432 UpstreamColumnIds,
10433 OutputIndices,
10434 StateTable,
10435 CdcTableDesc,
10436 RateLimit,
10437 DisableBackfill,
10438 Options,
10439 }
10440 impl<'de> serde::Deserialize<'de> for GeneratedField {
10441 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10442 where
10443 D: serde::Deserializer<'de>,
10444 {
10445 struct GeneratedVisitor;
10446
10447 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10448 type Value = GeneratedField;
10449
10450 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10451 write!(formatter, "expected one of: {:?}", &FIELDS)
10452 }
10453
10454 #[allow(unused_variables)]
10455 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10456 where
10457 E: serde::de::Error,
10458 {
10459 match value {
10460 "tableId" | "table_id" => Ok(GeneratedField::TableId),
10461 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
10462 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
10463 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
10464 "cdcTableDesc" | "cdc_table_desc" => Ok(GeneratedField::CdcTableDesc),
10465 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
10466 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
10467 "options" => Ok(GeneratedField::Options),
10468 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10469 }
10470 }
10471 }
10472 deserializer.deserialize_identifier(GeneratedVisitor)
10473 }
10474 }
10475 struct GeneratedVisitor;
10476 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10477 type Value = StreamCdcScanNode;
10478
10479 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10480 formatter.write_str("struct stream_plan.StreamCdcScanNode")
10481 }
10482
10483 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanNode, V::Error>
10484 where
10485 V: serde::de::MapAccess<'de>,
10486 {
10487 let mut table_id__ = None;
10488 let mut upstream_column_ids__ = None;
10489 let mut output_indices__ = None;
10490 let mut state_table__ = None;
10491 let mut cdc_table_desc__ = None;
10492 let mut rate_limit__ = None;
10493 let mut disable_backfill__ = None;
10494 let mut options__ = None;
10495 while let Some(k) = map_.next_key()? {
10496 match k {
10497 GeneratedField::TableId => {
10498 if table_id__.is_some() {
10499 return Err(serde::de::Error::duplicate_field("tableId"));
10500 }
10501 table_id__ =
10502 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10503 ;
10504 }
10505 GeneratedField::UpstreamColumnIds => {
10506 if upstream_column_ids__.is_some() {
10507 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
10508 }
10509 upstream_column_ids__ =
10510 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10511 .into_iter().map(|x| x.0).collect())
10512 ;
10513 }
10514 GeneratedField::OutputIndices => {
10515 if output_indices__.is_some() {
10516 return Err(serde::de::Error::duplicate_field("outputIndices"));
10517 }
10518 output_indices__ =
10519 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10520 .into_iter().map(|x| x.0).collect())
10521 ;
10522 }
10523 GeneratedField::StateTable => {
10524 if state_table__.is_some() {
10525 return Err(serde::de::Error::duplicate_field("stateTable"));
10526 }
10527 state_table__ = map_.next_value()?;
10528 }
10529 GeneratedField::CdcTableDesc => {
10530 if cdc_table_desc__.is_some() {
10531 return Err(serde::de::Error::duplicate_field("cdcTableDesc"));
10532 }
10533 cdc_table_desc__ = map_.next_value()?;
10534 }
10535 GeneratedField::RateLimit => {
10536 if rate_limit__.is_some() {
10537 return Err(serde::de::Error::duplicate_field("rateLimit"));
10538 }
10539 rate_limit__ =
10540 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10541 ;
10542 }
10543 GeneratedField::DisableBackfill => {
10544 if disable_backfill__.is_some() {
10545 return Err(serde::de::Error::duplicate_field("disableBackfill"));
10546 }
10547 disable_backfill__ = Some(map_.next_value()?);
10548 }
10549 GeneratedField::Options => {
10550 if options__.is_some() {
10551 return Err(serde::de::Error::duplicate_field("options"));
10552 }
10553 options__ = map_.next_value()?;
10554 }
10555 }
10556 }
10557 Ok(StreamCdcScanNode {
10558 table_id: table_id__.unwrap_or_default(),
10559 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
10560 output_indices: output_indices__.unwrap_or_default(),
10561 state_table: state_table__,
10562 cdc_table_desc: cdc_table_desc__,
10563 rate_limit: rate_limit__,
10564 disable_backfill: disable_backfill__.unwrap_or_default(),
10565 options: options__,
10566 })
10567 }
10568 }
10569 deserializer.deserialize_struct("stream_plan.StreamCdcScanNode", FIELDS, GeneratedVisitor)
10570 }
10571}
10572impl serde::Serialize for StreamCdcScanOptions {
10573 #[allow(deprecated)]
10574 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10575 where
10576 S: serde::Serializer,
10577 {
10578 use serde::ser::SerializeStruct;
10579 let mut len = 0;
10580 if self.disable_backfill {
10581 len += 1;
10582 }
10583 if self.snapshot_barrier_interval != 0 {
10584 len += 1;
10585 }
10586 if self.snapshot_batch_size != 0 {
10587 len += 1;
10588 }
10589 if self.backfill_parallelism != 0 {
10590 len += 1;
10591 }
10592 if self.backfill_num_rows_per_split != 0 {
10593 len += 1;
10594 }
10595 if self.backfill_as_even_splits {
10596 len += 1;
10597 }
10598 if self.backfill_split_pk_column_index != 0 {
10599 len += 1;
10600 }
10601 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanOptions", len)?;
10602 if self.disable_backfill {
10603 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
10604 }
10605 if self.snapshot_barrier_interval != 0 {
10606 struct_ser.serialize_field("snapshotBarrierInterval", &self.snapshot_barrier_interval)?;
10607 }
10608 if self.snapshot_batch_size != 0 {
10609 struct_ser.serialize_field("snapshotBatchSize", &self.snapshot_batch_size)?;
10610 }
10611 if self.backfill_parallelism != 0 {
10612 struct_ser.serialize_field("backfillParallelism", &self.backfill_parallelism)?;
10613 }
10614 if self.backfill_num_rows_per_split != 0 {
10615 #[allow(clippy::needless_borrow)]
10616 #[allow(clippy::needless_borrows_for_generic_args)]
10617 struct_ser.serialize_field("backfillNumRowsPerSplit", ToString::to_string(&self.backfill_num_rows_per_split).as_str())?;
10618 }
10619 if self.backfill_as_even_splits {
10620 struct_ser.serialize_field("backfillAsEvenSplits", &self.backfill_as_even_splits)?;
10621 }
10622 if self.backfill_split_pk_column_index != 0 {
10623 struct_ser.serialize_field("backfillSplitPkColumnIndex", &self.backfill_split_pk_column_index)?;
10624 }
10625 struct_ser.end()
10626 }
10627}
10628impl<'de> serde::Deserialize<'de> for StreamCdcScanOptions {
10629 #[allow(deprecated)]
10630 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10631 where
10632 D: serde::Deserializer<'de>,
10633 {
10634 const FIELDS: &[&str] = &[
10635 "disable_backfill",
10636 "disableBackfill",
10637 "snapshot_barrier_interval",
10638 "snapshotBarrierInterval",
10639 "snapshot_batch_size",
10640 "snapshotBatchSize",
10641 "backfill_parallelism",
10642 "backfillParallelism",
10643 "backfill_num_rows_per_split",
10644 "backfillNumRowsPerSplit",
10645 "backfill_as_even_splits",
10646 "backfillAsEvenSplits",
10647 "backfill_split_pk_column_index",
10648 "backfillSplitPkColumnIndex",
10649 ];
10650
10651 #[allow(clippy::enum_variant_names)]
10652 enum GeneratedField {
10653 DisableBackfill,
10654 SnapshotBarrierInterval,
10655 SnapshotBatchSize,
10656 BackfillParallelism,
10657 BackfillNumRowsPerSplit,
10658 BackfillAsEvenSplits,
10659 BackfillSplitPkColumnIndex,
10660 }
10661 impl<'de> serde::Deserialize<'de> for GeneratedField {
10662 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10663 where
10664 D: serde::Deserializer<'de>,
10665 {
10666 struct GeneratedVisitor;
10667
10668 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10669 type Value = GeneratedField;
10670
10671 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10672 write!(formatter, "expected one of: {:?}", &FIELDS)
10673 }
10674
10675 #[allow(unused_variables)]
10676 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10677 where
10678 E: serde::de::Error,
10679 {
10680 match value {
10681 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
10682 "snapshotBarrierInterval" | "snapshot_barrier_interval" => Ok(GeneratedField::SnapshotBarrierInterval),
10683 "snapshotBatchSize" | "snapshot_batch_size" => Ok(GeneratedField::SnapshotBatchSize),
10684 "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
10685 "backfillNumRowsPerSplit" | "backfill_num_rows_per_split" => Ok(GeneratedField::BackfillNumRowsPerSplit),
10686 "backfillAsEvenSplits" | "backfill_as_even_splits" => Ok(GeneratedField::BackfillAsEvenSplits),
10687 "backfillSplitPkColumnIndex" | "backfill_split_pk_column_index" => Ok(GeneratedField::BackfillSplitPkColumnIndex),
10688 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10689 }
10690 }
10691 }
10692 deserializer.deserialize_identifier(GeneratedVisitor)
10693 }
10694 }
10695 struct GeneratedVisitor;
10696 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10697 type Value = StreamCdcScanOptions;
10698
10699 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10700 formatter.write_str("struct stream_plan.StreamCdcScanOptions")
10701 }
10702
10703 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanOptions, V::Error>
10704 where
10705 V: serde::de::MapAccess<'de>,
10706 {
10707 let mut disable_backfill__ = None;
10708 let mut snapshot_barrier_interval__ = None;
10709 let mut snapshot_batch_size__ = None;
10710 let mut backfill_parallelism__ = None;
10711 let mut backfill_num_rows_per_split__ = None;
10712 let mut backfill_as_even_splits__ = None;
10713 let mut backfill_split_pk_column_index__ = None;
10714 while let Some(k) = map_.next_key()? {
10715 match k {
10716 GeneratedField::DisableBackfill => {
10717 if disable_backfill__.is_some() {
10718 return Err(serde::de::Error::duplicate_field("disableBackfill"));
10719 }
10720 disable_backfill__ = Some(map_.next_value()?);
10721 }
10722 GeneratedField::SnapshotBarrierInterval => {
10723 if snapshot_barrier_interval__.is_some() {
10724 return Err(serde::de::Error::duplicate_field("snapshotBarrierInterval"));
10725 }
10726 snapshot_barrier_interval__ =
10727 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10728 ;
10729 }
10730 GeneratedField::SnapshotBatchSize => {
10731 if snapshot_batch_size__.is_some() {
10732 return Err(serde::de::Error::duplicate_field("snapshotBatchSize"));
10733 }
10734 snapshot_batch_size__ =
10735 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10736 ;
10737 }
10738 GeneratedField::BackfillParallelism => {
10739 if backfill_parallelism__.is_some() {
10740 return Err(serde::de::Error::duplicate_field("backfillParallelism"));
10741 }
10742 backfill_parallelism__ =
10743 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10744 ;
10745 }
10746 GeneratedField::BackfillNumRowsPerSplit => {
10747 if backfill_num_rows_per_split__.is_some() {
10748 return Err(serde::de::Error::duplicate_field("backfillNumRowsPerSplit"));
10749 }
10750 backfill_num_rows_per_split__ =
10751 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10752 ;
10753 }
10754 GeneratedField::BackfillAsEvenSplits => {
10755 if backfill_as_even_splits__.is_some() {
10756 return Err(serde::de::Error::duplicate_field("backfillAsEvenSplits"));
10757 }
10758 backfill_as_even_splits__ = Some(map_.next_value()?);
10759 }
10760 GeneratedField::BackfillSplitPkColumnIndex => {
10761 if backfill_split_pk_column_index__.is_some() {
10762 return Err(serde::de::Error::duplicate_field("backfillSplitPkColumnIndex"));
10763 }
10764 backfill_split_pk_column_index__ =
10765 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10766 ;
10767 }
10768 }
10769 }
10770 Ok(StreamCdcScanOptions {
10771 disable_backfill: disable_backfill__.unwrap_or_default(),
10772 snapshot_barrier_interval: snapshot_barrier_interval__.unwrap_or_default(),
10773 snapshot_batch_size: snapshot_batch_size__.unwrap_or_default(),
10774 backfill_parallelism: backfill_parallelism__.unwrap_or_default(),
10775 backfill_num_rows_per_split: backfill_num_rows_per_split__.unwrap_or_default(),
10776 backfill_as_even_splits: backfill_as_even_splits__.unwrap_or_default(),
10777 backfill_split_pk_column_index: backfill_split_pk_column_index__.unwrap_or_default(),
10778 })
10779 }
10780 }
10781 deserializer.deserialize_struct("stream_plan.StreamCdcScanOptions", FIELDS, GeneratedVisitor)
10782 }
10783}
10784impl serde::Serialize for StreamContext {
10785 #[allow(deprecated)]
10786 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10787 where
10788 S: serde::Serializer,
10789 {
10790 use serde::ser::SerializeStruct;
10791 let mut len = 0;
10792 if !self.timezone.is_empty() {
10793 len += 1;
10794 }
10795 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamContext", len)?;
10796 if !self.timezone.is_empty() {
10797 struct_ser.serialize_field("timezone", &self.timezone)?;
10798 }
10799 struct_ser.end()
10800 }
10801}
10802impl<'de> serde::Deserialize<'de> for StreamContext {
10803 #[allow(deprecated)]
10804 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10805 where
10806 D: serde::Deserializer<'de>,
10807 {
10808 const FIELDS: &[&str] = &[
10809 "timezone",
10810 ];
10811
10812 #[allow(clippy::enum_variant_names)]
10813 enum GeneratedField {
10814 Timezone,
10815 }
10816 impl<'de> serde::Deserialize<'de> for GeneratedField {
10817 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10818 where
10819 D: serde::Deserializer<'de>,
10820 {
10821 struct GeneratedVisitor;
10822
10823 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10824 type Value = GeneratedField;
10825
10826 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10827 write!(formatter, "expected one of: {:?}", &FIELDS)
10828 }
10829
10830 #[allow(unused_variables)]
10831 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10832 where
10833 E: serde::de::Error,
10834 {
10835 match value {
10836 "timezone" => Ok(GeneratedField::Timezone),
10837 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10838 }
10839 }
10840 }
10841 deserializer.deserialize_identifier(GeneratedVisitor)
10842 }
10843 }
10844 struct GeneratedVisitor;
10845 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10846 type Value = StreamContext;
10847
10848 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10849 formatter.write_str("struct stream_plan.StreamContext")
10850 }
10851
10852 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamContext, V::Error>
10853 where
10854 V: serde::de::MapAccess<'de>,
10855 {
10856 let mut timezone__ = None;
10857 while let Some(k) = map_.next_key()? {
10858 match k {
10859 GeneratedField::Timezone => {
10860 if timezone__.is_some() {
10861 return Err(serde::de::Error::duplicate_field("timezone"));
10862 }
10863 timezone__ = Some(map_.next_value()?);
10864 }
10865 }
10866 }
10867 Ok(StreamContext {
10868 timezone: timezone__.unwrap_or_default(),
10869 })
10870 }
10871 }
10872 deserializer.deserialize_struct("stream_plan.StreamContext", FIELDS, GeneratedVisitor)
10873 }
10874}
10875impl serde::Serialize for StreamFragmentGraph {
10876 #[allow(deprecated)]
10877 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10878 where
10879 S: serde::Serializer,
10880 {
10881 use serde::ser::SerializeStruct;
10882 let mut len = 0;
10883 if !self.fragments.is_empty() {
10884 len += 1;
10885 }
10886 if !self.edges.is_empty() {
10887 len += 1;
10888 }
10889 if !self.dependent_table_ids.is_empty() {
10890 len += 1;
10891 }
10892 if self.table_ids_cnt != 0 {
10893 len += 1;
10894 }
10895 if self.ctx.is_some() {
10896 len += 1;
10897 }
10898 if self.parallelism.is_some() {
10899 len += 1;
10900 }
10901 if self.max_parallelism != 0 {
10902 len += 1;
10903 }
10904 if self.backfill_order.is_some() {
10905 len += 1;
10906 }
10907 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph", len)?;
10908 if !self.fragments.is_empty() {
10909 struct_ser.serialize_field("fragments", &self.fragments)?;
10910 }
10911 if !self.edges.is_empty() {
10912 struct_ser.serialize_field("edges", &self.edges)?;
10913 }
10914 if !self.dependent_table_ids.is_empty() {
10915 struct_ser.serialize_field("dependentTableIds", &self.dependent_table_ids)?;
10916 }
10917 if self.table_ids_cnt != 0 {
10918 struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
10919 }
10920 if let Some(v) = self.ctx.as_ref() {
10921 struct_ser.serialize_field("ctx", v)?;
10922 }
10923 if let Some(v) = self.parallelism.as_ref() {
10924 struct_ser.serialize_field("parallelism", v)?;
10925 }
10926 if self.max_parallelism != 0 {
10927 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
10928 }
10929 if let Some(v) = self.backfill_order.as_ref() {
10930 struct_ser.serialize_field("backfillOrder", v)?;
10931 }
10932 struct_ser.end()
10933 }
10934}
10935impl<'de> serde::Deserialize<'de> for StreamFragmentGraph {
10936 #[allow(deprecated)]
10937 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10938 where
10939 D: serde::Deserializer<'de>,
10940 {
10941 const FIELDS: &[&str] = &[
10942 "fragments",
10943 "edges",
10944 "dependent_table_ids",
10945 "dependentTableIds",
10946 "table_ids_cnt",
10947 "tableIdsCnt",
10948 "ctx",
10949 "parallelism",
10950 "max_parallelism",
10951 "maxParallelism",
10952 "backfill_order",
10953 "backfillOrder",
10954 ];
10955
10956 #[allow(clippy::enum_variant_names)]
10957 enum GeneratedField {
10958 Fragments,
10959 Edges,
10960 DependentTableIds,
10961 TableIdsCnt,
10962 Ctx,
10963 Parallelism,
10964 MaxParallelism,
10965 BackfillOrder,
10966 }
10967 impl<'de> serde::Deserialize<'de> for GeneratedField {
10968 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10969 where
10970 D: serde::Deserializer<'de>,
10971 {
10972 struct GeneratedVisitor;
10973
10974 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10975 type Value = GeneratedField;
10976
10977 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10978 write!(formatter, "expected one of: {:?}", &FIELDS)
10979 }
10980
10981 #[allow(unused_variables)]
10982 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10983 where
10984 E: serde::de::Error,
10985 {
10986 match value {
10987 "fragments" => Ok(GeneratedField::Fragments),
10988 "edges" => Ok(GeneratedField::Edges),
10989 "dependentTableIds" | "dependent_table_ids" => Ok(GeneratedField::DependentTableIds),
10990 "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
10991 "ctx" => Ok(GeneratedField::Ctx),
10992 "parallelism" => Ok(GeneratedField::Parallelism),
10993 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
10994 "backfillOrder" | "backfill_order" => Ok(GeneratedField::BackfillOrder),
10995 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10996 }
10997 }
10998 }
10999 deserializer.deserialize_identifier(GeneratedVisitor)
11000 }
11001 }
11002 struct GeneratedVisitor;
11003 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11004 type Value = StreamFragmentGraph;
11005
11006 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11007 formatter.write_str("struct stream_plan.StreamFragmentGraph")
11008 }
11009
11010 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFragmentGraph, V::Error>
11011 where
11012 V: serde::de::MapAccess<'de>,
11013 {
11014 let mut fragments__ = None;
11015 let mut edges__ = None;
11016 let mut dependent_table_ids__ = None;
11017 let mut table_ids_cnt__ = None;
11018 let mut ctx__ = None;
11019 let mut parallelism__ = None;
11020 let mut max_parallelism__ = None;
11021 let mut backfill_order__ = None;
11022 while let Some(k) = map_.next_key()? {
11023 match k {
11024 GeneratedField::Fragments => {
11025 if fragments__.is_some() {
11026 return Err(serde::de::Error::duplicate_field("fragments"));
11027 }
11028 fragments__ = Some(
11029 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11030 .into_iter().map(|(k,v)| (k.0, v)).collect()
11031 );
11032 }
11033 GeneratedField::Edges => {
11034 if edges__.is_some() {
11035 return Err(serde::de::Error::duplicate_field("edges"));
11036 }
11037 edges__ = Some(map_.next_value()?);
11038 }
11039 GeneratedField::DependentTableIds => {
11040 if dependent_table_ids__.is_some() {
11041 return Err(serde::de::Error::duplicate_field("dependentTableIds"));
11042 }
11043 dependent_table_ids__ =
11044 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11045 .into_iter().map(|x| x.0).collect())
11046 ;
11047 }
11048 GeneratedField::TableIdsCnt => {
11049 if table_ids_cnt__.is_some() {
11050 return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
11051 }
11052 table_ids_cnt__ =
11053 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11054 ;
11055 }
11056 GeneratedField::Ctx => {
11057 if ctx__.is_some() {
11058 return Err(serde::de::Error::duplicate_field("ctx"));
11059 }
11060 ctx__ = map_.next_value()?;
11061 }
11062 GeneratedField::Parallelism => {
11063 if parallelism__.is_some() {
11064 return Err(serde::de::Error::duplicate_field("parallelism"));
11065 }
11066 parallelism__ = map_.next_value()?;
11067 }
11068 GeneratedField::MaxParallelism => {
11069 if max_parallelism__.is_some() {
11070 return Err(serde::de::Error::duplicate_field("maxParallelism"));
11071 }
11072 max_parallelism__ =
11073 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11074 ;
11075 }
11076 GeneratedField::BackfillOrder => {
11077 if backfill_order__.is_some() {
11078 return Err(serde::de::Error::duplicate_field("backfillOrder"));
11079 }
11080 backfill_order__ = map_.next_value()?;
11081 }
11082 }
11083 }
11084 Ok(StreamFragmentGraph {
11085 fragments: fragments__.unwrap_or_default(),
11086 edges: edges__.unwrap_or_default(),
11087 dependent_table_ids: dependent_table_ids__.unwrap_or_default(),
11088 table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
11089 ctx: ctx__,
11090 parallelism: parallelism__,
11091 max_parallelism: max_parallelism__.unwrap_or_default(),
11092 backfill_order: backfill_order__,
11093 })
11094 }
11095 }
11096 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph", FIELDS, GeneratedVisitor)
11097 }
11098}
11099impl serde::Serialize for stream_fragment_graph::Parallelism {
11100 #[allow(deprecated)]
11101 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11102 where
11103 S: serde::Serializer,
11104 {
11105 use serde::ser::SerializeStruct;
11106 let mut len = 0;
11107 if self.parallelism != 0 {
11108 len += 1;
11109 }
11110 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.Parallelism", len)?;
11111 if self.parallelism != 0 {
11112 #[allow(clippy::needless_borrow)]
11113 #[allow(clippy::needless_borrows_for_generic_args)]
11114 struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
11115 }
11116 struct_ser.end()
11117 }
11118}
11119impl<'de> serde::Deserialize<'de> for stream_fragment_graph::Parallelism {
11120 #[allow(deprecated)]
11121 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11122 where
11123 D: serde::Deserializer<'de>,
11124 {
11125 const FIELDS: &[&str] = &[
11126 "parallelism",
11127 ];
11128
11129 #[allow(clippy::enum_variant_names)]
11130 enum GeneratedField {
11131 Parallelism,
11132 }
11133 impl<'de> serde::Deserialize<'de> for GeneratedField {
11134 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11135 where
11136 D: serde::Deserializer<'de>,
11137 {
11138 struct GeneratedVisitor;
11139
11140 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11141 type Value = GeneratedField;
11142
11143 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11144 write!(formatter, "expected one of: {:?}", &FIELDS)
11145 }
11146
11147 #[allow(unused_variables)]
11148 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11149 where
11150 E: serde::de::Error,
11151 {
11152 match value {
11153 "parallelism" => Ok(GeneratedField::Parallelism),
11154 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11155 }
11156 }
11157 }
11158 deserializer.deserialize_identifier(GeneratedVisitor)
11159 }
11160 }
11161 struct GeneratedVisitor;
11162 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11163 type Value = stream_fragment_graph::Parallelism;
11164
11165 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11166 formatter.write_str("struct stream_plan.StreamFragmentGraph.Parallelism")
11167 }
11168
11169 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::Parallelism, V::Error>
11170 where
11171 V: serde::de::MapAccess<'de>,
11172 {
11173 let mut parallelism__ = None;
11174 while let Some(k) = map_.next_key()? {
11175 match k {
11176 GeneratedField::Parallelism => {
11177 if parallelism__.is_some() {
11178 return Err(serde::de::Error::duplicate_field("parallelism"));
11179 }
11180 parallelism__ =
11181 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11182 ;
11183 }
11184 }
11185 }
11186 Ok(stream_fragment_graph::Parallelism {
11187 parallelism: parallelism__.unwrap_or_default(),
11188 })
11189 }
11190 }
11191 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.Parallelism", FIELDS, GeneratedVisitor)
11192 }
11193}
11194impl serde::Serialize for stream_fragment_graph::StreamFragment {
11195 #[allow(deprecated)]
11196 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11197 where
11198 S: serde::Serializer,
11199 {
11200 use serde::ser::SerializeStruct;
11201 let mut len = 0;
11202 if self.fragment_id != 0 {
11203 len += 1;
11204 }
11205 if self.node.is_some() {
11206 len += 1;
11207 }
11208 if self.fragment_type_mask != 0 {
11209 len += 1;
11210 }
11211 if self.requires_singleton {
11212 len += 1;
11213 }
11214 if self.table_ids_cnt != 0 {
11215 len += 1;
11216 }
11217 if !self.upstream_table_ids.is_empty() {
11218 len += 1;
11219 }
11220 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", len)?;
11221 if self.fragment_id != 0 {
11222 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
11223 }
11224 if let Some(v) = self.node.as_ref() {
11225 struct_ser.serialize_field("node", v)?;
11226 }
11227 if self.fragment_type_mask != 0 {
11228 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
11229 }
11230 if self.requires_singleton {
11231 struct_ser.serialize_field("requiresSingleton", &self.requires_singleton)?;
11232 }
11233 if self.table_ids_cnt != 0 {
11234 struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
11235 }
11236 if !self.upstream_table_ids.is_empty() {
11237 struct_ser.serialize_field("upstreamTableIds", &self.upstream_table_ids)?;
11238 }
11239 struct_ser.end()
11240 }
11241}
11242impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragment {
11243 #[allow(deprecated)]
11244 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11245 where
11246 D: serde::Deserializer<'de>,
11247 {
11248 const FIELDS: &[&str] = &[
11249 "fragment_id",
11250 "fragmentId",
11251 "node",
11252 "fragment_type_mask",
11253 "fragmentTypeMask",
11254 "requires_singleton",
11255 "requiresSingleton",
11256 "table_ids_cnt",
11257 "tableIdsCnt",
11258 "upstream_table_ids",
11259 "upstreamTableIds",
11260 ];
11261
11262 #[allow(clippy::enum_variant_names)]
11263 enum GeneratedField {
11264 FragmentId,
11265 Node,
11266 FragmentTypeMask,
11267 RequiresSingleton,
11268 TableIdsCnt,
11269 UpstreamTableIds,
11270 }
11271 impl<'de> serde::Deserialize<'de> for GeneratedField {
11272 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11273 where
11274 D: serde::Deserializer<'de>,
11275 {
11276 struct GeneratedVisitor;
11277
11278 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11279 type Value = GeneratedField;
11280
11281 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11282 write!(formatter, "expected one of: {:?}", &FIELDS)
11283 }
11284
11285 #[allow(unused_variables)]
11286 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11287 where
11288 E: serde::de::Error,
11289 {
11290 match value {
11291 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
11292 "node" => Ok(GeneratedField::Node),
11293 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
11294 "requiresSingleton" | "requires_singleton" => Ok(GeneratedField::RequiresSingleton),
11295 "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
11296 "upstreamTableIds" | "upstream_table_ids" => Ok(GeneratedField::UpstreamTableIds),
11297 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11298 }
11299 }
11300 }
11301 deserializer.deserialize_identifier(GeneratedVisitor)
11302 }
11303 }
11304 struct GeneratedVisitor;
11305 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11306 type Value = stream_fragment_graph::StreamFragment;
11307
11308 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11309 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragment")
11310 }
11311
11312 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragment, V::Error>
11313 where
11314 V: serde::de::MapAccess<'de>,
11315 {
11316 let mut fragment_id__ = None;
11317 let mut node__ = None;
11318 let mut fragment_type_mask__ = None;
11319 let mut requires_singleton__ = None;
11320 let mut table_ids_cnt__ = None;
11321 let mut upstream_table_ids__ = None;
11322 while let Some(k) = map_.next_key()? {
11323 match k {
11324 GeneratedField::FragmentId => {
11325 if fragment_id__.is_some() {
11326 return Err(serde::de::Error::duplicate_field("fragmentId"));
11327 }
11328 fragment_id__ =
11329 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11330 ;
11331 }
11332 GeneratedField::Node => {
11333 if node__.is_some() {
11334 return Err(serde::de::Error::duplicate_field("node"));
11335 }
11336 node__ = map_.next_value()?;
11337 }
11338 GeneratedField::FragmentTypeMask => {
11339 if fragment_type_mask__.is_some() {
11340 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
11341 }
11342 fragment_type_mask__ =
11343 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11344 ;
11345 }
11346 GeneratedField::RequiresSingleton => {
11347 if requires_singleton__.is_some() {
11348 return Err(serde::de::Error::duplicate_field("requiresSingleton"));
11349 }
11350 requires_singleton__ = Some(map_.next_value()?);
11351 }
11352 GeneratedField::TableIdsCnt => {
11353 if table_ids_cnt__.is_some() {
11354 return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
11355 }
11356 table_ids_cnt__ =
11357 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11358 ;
11359 }
11360 GeneratedField::UpstreamTableIds => {
11361 if upstream_table_ids__.is_some() {
11362 return Err(serde::de::Error::duplicate_field("upstreamTableIds"));
11363 }
11364 upstream_table_ids__ =
11365 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11366 .into_iter().map(|x| x.0).collect())
11367 ;
11368 }
11369 }
11370 }
11371 Ok(stream_fragment_graph::StreamFragment {
11372 fragment_id: fragment_id__.unwrap_or_default(),
11373 node: node__,
11374 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
11375 requires_singleton: requires_singleton__.unwrap_or_default(),
11376 table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
11377 upstream_table_ids: upstream_table_ids__.unwrap_or_default(),
11378 })
11379 }
11380 }
11381 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", FIELDS, GeneratedVisitor)
11382 }
11383}
11384impl serde::Serialize for stream_fragment_graph::StreamFragmentEdge {
11385 #[allow(deprecated)]
11386 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11387 where
11388 S: serde::Serializer,
11389 {
11390 use serde::ser::SerializeStruct;
11391 let mut len = 0;
11392 if self.dispatch_strategy.is_some() {
11393 len += 1;
11394 }
11395 if self.link_id != 0 {
11396 len += 1;
11397 }
11398 if self.upstream_id != 0 {
11399 len += 1;
11400 }
11401 if self.downstream_id != 0 {
11402 len += 1;
11403 }
11404 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", len)?;
11405 if let Some(v) = self.dispatch_strategy.as_ref() {
11406 struct_ser.serialize_field("dispatchStrategy", v)?;
11407 }
11408 if self.link_id != 0 {
11409 #[allow(clippy::needless_borrow)]
11410 #[allow(clippy::needless_borrows_for_generic_args)]
11411 struct_ser.serialize_field("linkId", ToString::to_string(&self.link_id).as_str())?;
11412 }
11413 if self.upstream_id != 0 {
11414 struct_ser.serialize_field("upstreamId", &self.upstream_id)?;
11415 }
11416 if self.downstream_id != 0 {
11417 struct_ser.serialize_field("downstreamId", &self.downstream_id)?;
11418 }
11419 struct_ser.end()
11420 }
11421}
11422impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragmentEdge {
11423 #[allow(deprecated)]
11424 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11425 where
11426 D: serde::Deserializer<'de>,
11427 {
11428 const FIELDS: &[&str] = &[
11429 "dispatch_strategy",
11430 "dispatchStrategy",
11431 "link_id",
11432 "linkId",
11433 "upstream_id",
11434 "upstreamId",
11435 "downstream_id",
11436 "downstreamId",
11437 ];
11438
11439 #[allow(clippy::enum_variant_names)]
11440 enum GeneratedField {
11441 DispatchStrategy,
11442 LinkId,
11443 UpstreamId,
11444 DownstreamId,
11445 }
11446 impl<'de> serde::Deserialize<'de> for GeneratedField {
11447 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11448 where
11449 D: serde::Deserializer<'de>,
11450 {
11451 struct GeneratedVisitor;
11452
11453 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11454 type Value = GeneratedField;
11455
11456 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11457 write!(formatter, "expected one of: {:?}", &FIELDS)
11458 }
11459
11460 #[allow(unused_variables)]
11461 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11462 where
11463 E: serde::de::Error,
11464 {
11465 match value {
11466 "dispatchStrategy" | "dispatch_strategy" => Ok(GeneratedField::DispatchStrategy),
11467 "linkId" | "link_id" => Ok(GeneratedField::LinkId),
11468 "upstreamId" | "upstream_id" => Ok(GeneratedField::UpstreamId),
11469 "downstreamId" | "downstream_id" => Ok(GeneratedField::DownstreamId),
11470 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11471 }
11472 }
11473 }
11474 deserializer.deserialize_identifier(GeneratedVisitor)
11475 }
11476 }
11477 struct GeneratedVisitor;
11478 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11479 type Value = stream_fragment_graph::StreamFragmentEdge;
11480
11481 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11482 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragmentEdge")
11483 }
11484
11485 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragmentEdge, V::Error>
11486 where
11487 V: serde::de::MapAccess<'de>,
11488 {
11489 let mut dispatch_strategy__ = None;
11490 let mut link_id__ = None;
11491 let mut upstream_id__ = None;
11492 let mut downstream_id__ = None;
11493 while let Some(k) = map_.next_key()? {
11494 match k {
11495 GeneratedField::DispatchStrategy => {
11496 if dispatch_strategy__.is_some() {
11497 return Err(serde::de::Error::duplicate_field("dispatchStrategy"));
11498 }
11499 dispatch_strategy__ = map_.next_value()?;
11500 }
11501 GeneratedField::LinkId => {
11502 if link_id__.is_some() {
11503 return Err(serde::de::Error::duplicate_field("linkId"));
11504 }
11505 link_id__ =
11506 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11507 ;
11508 }
11509 GeneratedField::UpstreamId => {
11510 if upstream_id__.is_some() {
11511 return Err(serde::de::Error::duplicate_field("upstreamId"));
11512 }
11513 upstream_id__ =
11514 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11515 ;
11516 }
11517 GeneratedField::DownstreamId => {
11518 if downstream_id__.is_some() {
11519 return Err(serde::de::Error::duplicate_field("downstreamId"));
11520 }
11521 downstream_id__ =
11522 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11523 ;
11524 }
11525 }
11526 }
11527 Ok(stream_fragment_graph::StreamFragmentEdge {
11528 dispatch_strategy: dispatch_strategy__,
11529 link_id: link_id__.unwrap_or_default(),
11530 upstream_id: upstream_id__.unwrap_or_default(),
11531 downstream_id: downstream_id__.unwrap_or_default(),
11532 })
11533 }
11534 }
11535 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", FIELDS, GeneratedVisitor)
11536 }
11537}
11538impl serde::Serialize for StreamFsFetch {
11539 #[allow(deprecated)]
11540 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11541 where
11542 S: serde::Serializer,
11543 {
11544 use serde::ser::SerializeStruct;
11545 let mut len = 0;
11546 if self.source_id != 0 {
11547 len += 1;
11548 }
11549 if self.state_table.is_some() {
11550 len += 1;
11551 }
11552 if self.row_id_index.is_some() {
11553 len += 1;
11554 }
11555 if !self.columns.is_empty() {
11556 len += 1;
11557 }
11558 if !self.with_properties.is_empty() {
11559 len += 1;
11560 }
11561 if self.info.is_some() {
11562 len += 1;
11563 }
11564 if !self.source_name.is_empty() {
11565 len += 1;
11566 }
11567 if self.rate_limit.is_some() {
11568 len += 1;
11569 }
11570 if !self.secret_refs.is_empty() {
11571 len += 1;
11572 }
11573 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetch", len)?;
11574 if self.source_id != 0 {
11575 struct_ser.serialize_field("sourceId", &self.source_id)?;
11576 }
11577 if let Some(v) = self.state_table.as_ref() {
11578 struct_ser.serialize_field("stateTable", v)?;
11579 }
11580 if let Some(v) = self.row_id_index.as_ref() {
11581 struct_ser.serialize_field("rowIdIndex", v)?;
11582 }
11583 if !self.columns.is_empty() {
11584 struct_ser.serialize_field("columns", &self.columns)?;
11585 }
11586 if !self.with_properties.is_empty() {
11587 struct_ser.serialize_field("withProperties", &self.with_properties)?;
11588 }
11589 if let Some(v) = self.info.as_ref() {
11590 struct_ser.serialize_field("info", v)?;
11591 }
11592 if !self.source_name.is_empty() {
11593 struct_ser.serialize_field("sourceName", &self.source_name)?;
11594 }
11595 if let Some(v) = self.rate_limit.as_ref() {
11596 struct_ser.serialize_field("rateLimit", v)?;
11597 }
11598 if !self.secret_refs.is_empty() {
11599 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
11600 }
11601 struct_ser.end()
11602 }
11603}
11604impl<'de> serde::Deserialize<'de> for StreamFsFetch {
11605 #[allow(deprecated)]
11606 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11607 where
11608 D: serde::Deserializer<'de>,
11609 {
11610 const FIELDS: &[&str] = &[
11611 "source_id",
11612 "sourceId",
11613 "state_table",
11614 "stateTable",
11615 "row_id_index",
11616 "rowIdIndex",
11617 "columns",
11618 "with_properties",
11619 "withProperties",
11620 "info",
11621 "source_name",
11622 "sourceName",
11623 "rate_limit",
11624 "rateLimit",
11625 "secret_refs",
11626 "secretRefs",
11627 ];
11628
11629 #[allow(clippy::enum_variant_names)]
11630 enum GeneratedField {
11631 SourceId,
11632 StateTable,
11633 RowIdIndex,
11634 Columns,
11635 WithProperties,
11636 Info,
11637 SourceName,
11638 RateLimit,
11639 SecretRefs,
11640 }
11641 impl<'de> serde::Deserialize<'de> for GeneratedField {
11642 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11643 where
11644 D: serde::Deserializer<'de>,
11645 {
11646 struct GeneratedVisitor;
11647
11648 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11649 type Value = GeneratedField;
11650
11651 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11652 write!(formatter, "expected one of: {:?}", &FIELDS)
11653 }
11654
11655 #[allow(unused_variables)]
11656 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11657 where
11658 E: serde::de::Error,
11659 {
11660 match value {
11661 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
11662 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11663 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
11664 "columns" => Ok(GeneratedField::Columns),
11665 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
11666 "info" => Ok(GeneratedField::Info),
11667 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
11668 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11669 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
11670 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11671 }
11672 }
11673 }
11674 deserializer.deserialize_identifier(GeneratedVisitor)
11675 }
11676 }
11677 struct GeneratedVisitor;
11678 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11679 type Value = StreamFsFetch;
11680
11681 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11682 formatter.write_str("struct stream_plan.StreamFsFetch")
11683 }
11684
11685 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetch, V::Error>
11686 where
11687 V: serde::de::MapAccess<'de>,
11688 {
11689 let mut source_id__ = None;
11690 let mut state_table__ = None;
11691 let mut row_id_index__ = None;
11692 let mut columns__ = None;
11693 let mut with_properties__ = None;
11694 let mut info__ = None;
11695 let mut source_name__ = None;
11696 let mut rate_limit__ = None;
11697 let mut secret_refs__ = None;
11698 while let Some(k) = map_.next_key()? {
11699 match k {
11700 GeneratedField::SourceId => {
11701 if source_id__.is_some() {
11702 return Err(serde::de::Error::duplicate_field("sourceId"));
11703 }
11704 source_id__ =
11705 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11706 ;
11707 }
11708 GeneratedField::StateTable => {
11709 if state_table__.is_some() {
11710 return Err(serde::de::Error::duplicate_field("stateTable"));
11711 }
11712 state_table__ = map_.next_value()?;
11713 }
11714 GeneratedField::RowIdIndex => {
11715 if row_id_index__.is_some() {
11716 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
11717 }
11718 row_id_index__ =
11719 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11720 ;
11721 }
11722 GeneratedField::Columns => {
11723 if columns__.is_some() {
11724 return Err(serde::de::Error::duplicate_field("columns"));
11725 }
11726 columns__ = Some(map_.next_value()?);
11727 }
11728 GeneratedField::WithProperties => {
11729 if with_properties__.is_some() {
11730 return Err(serde::de::Error::duplicate_field("withProperties"));
11731 }
11732 with_properties__ = Some(
11733 map_.next_value::<std::collections::BTreeMap<_, _>>()?
11734 );
11735 }
11736 GeneratedField::Info => {
11737 if info__.is_some() {
11738 return Err(serde::de::Error::duplicate_field("info"));
11739 }
11740 info__ = map_.next_value()?;
11741 }
11742 GeneratedField::SourceName => {
11743 if source_name__.is_some() {
11744 return Err(serde::de::Error::duplicate_field("sourceName"));
11745 }
11746 source_name__ = Some(map_.next_value()?);
11747 }
11748 GeneratedField::RateLimit => {
11749 if rate_limit__.is_some() {
11750 return Err(serde::de::Error::duplicate_field("rateLimit"));
11751 }
11752 rate_limit__ =
11753 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11754 ;
11755 }
11756 GeneratedField::SecretRefs => {
11757 if secret_refs__.is_some() {
11758 return Err(serde::de::Error::duplicate_field("secretRefs"));
11759 }
11760 secret_refs__ = Some(
11761 map_.next_value::<std::collections::BTreeMap<_, _>>()?
11762 );
11763 }
11764 }
11765 }
11766 Ok(StreamFsFetch {
11767 source_id: source_id__.unwrap_or_default(),
11768 state_table: state_table__,
11769 row_id_index: row_id_index__,
11770 columns: columns__.unwrap_or_default(),
11771 with_properties: with_properties__.unwrap_or_default(),
11772 info: info__,
11773 source_name: source_name__.unwrap_or_default(),
11774 rate_limit: rate_limit__,
11775 secret_refs: secret_refs__.unwrap_or_default(),
11776 })
11777 }
11778 }
11779 deserializer.deserialize_struct("stream_plan.StreamFsFetch", FIELDS, GeneratedVisitor)
11780 }
11781}
11782impl serde::Serialize for StreamFsFetchNode {
11783 #[allow(deprecated)]
11784 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11785 where
11786 S: serde::Serializer,
11787 {
11788 use serde::ser::SerializeStruct;
11789 let mut len = 0;
11790 if self.node_inner.is_some() {
11791 len += 1;
11792 }
11793 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetchNode", len)?;
11794 if let Some(v) = self.node_inner.as_ref() {
11795 struct_ser.serialize_field("nodeInner", v)?;
11796 }
11797 struct_ser.end()
11798 }
11799}
11800impl<'de> serde::Deserialize<'de> for StreamFsFetchNode {
11801 #[allow(deprecated)]
11802 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11803 where
11804 D: serde::Deserializer<'de>,
11805 {
11806 const FIELDS: &[&str] = &[
11807 "node_inner",
11808 "nodeInner",
11809 ];
11810
11811 #[allow(clippy::enum_variant_names)]
11812 enum GeneratedField {
11813 NodeInner,
11814 }
11815 impl<'de> serde::Deserialize<'de> for GeneratedField {
11816 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11817 where
11818 D: serde::Deserializer<'de>,
11819 {
11820 struct GeneratedVisitor;
11821
11822 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11823 type Value = GeneratedField;
11824
11825 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11826 write!(formatter, "expected one of: {:?}", &FIELDS)
11827 }
11828
11829 #[allow(unused_variables)]
11830 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11831 where
11832 E: serde::de::Error,
11833 {
11834 match value {
11835 "nodeInner" | "node_inner" => Ok(GeneratedField::NodeInner),
11836 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11837 }
11838 }
11839 }
11840 deserializer.deserialize_identifier(GeneratedVisitor)
11841 }
11842 }
11843 struct GeneratedVisitor;
11844 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11845 type Value = StreamFsFetchNode;
11846
11847 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11848 formatter.write_str("struct stream_plan.StreamFsFetchNode")
11849 }
11850
11851 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetchNode, V::Error>
11852 where
11853 V: serde::de::MapAccess<'de>,
11854 {
11855 let mut node_inner__ = None;
11856 while let Some(k) = map_.next_key()? {
11857 match k {
11858 GeneratedField::NodeInner => {
11859 if node_inner__.is_some() {
11860 return Err(serde::de::Error::duplicate_field("nodeInner"));
11861 }
11862 node_inner__ = map_.next_value()?;
11863 }
11864 }
11865 }
11866 Ok(StreamFsFetchNode {
11867 node_inner: node_inner__,
11868 })
11869 }
11870 }
11871 deserializer.deserialize_struct("stream_plan.StreamFsFetchNode", FIELDS, GeneratedVisitor)
11872 }
11873}
11874impl serde::Serialize for StreamMessage {
11875 #[allow(deprecated)]
11876 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11877 where
11878 S: serde::Serializer,
11879 {
11880 use serde::ser::SerializeStruct;
11881 let mut len = 0;
11882 if self.stream_message.is_some() {
11883 len += 1;
11884 }
11885 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessage", len)?;
11886 if let Some(v) = self.stream_message.as_ref() {
11887 match v {
11888 stream_message::StreamMessage::StreamChunk(v) => {
11889 struct_ser.serialize_field("streamChunk", v)?;
11890 }
11891 stream_message::StreamMessage::Barrier(v) => {
11892 struct_ser.serialize_field("barrier", v)?;
11893 }
11894 stream_message::StreamMessage::Watermark(v) => {
11895 struct_ser.serialize_field("watermark", v)?;
11896 }
11897 }
11898 }
11899 struct_ser.end()
11900 }
11901}
11902impl<'de> serde::Deserialize<'de> for StreamMessage {
11903 #[allow(deprecated)]
11904 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11905 where
11906 D: serde::Deserializer<'de>,
11907 {
11908 const FIELDS: &[&str] = &[
11909 "stream_chunk",
11910 "streamChunk",
11911 "barrier",
11912 "watermark",
11913 ];
11914
11915 #[allow(clippy::enum_variant_names)]
11916 enum GeneratedField {
11917 StreamChunk,
11918 Barrier,
11919 Watermark,
11920 }
11921 impl<'de> serde::Deserialize<'de> for GeneratedField {
11922 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11923 where
11924 D: serde::Deserializer<'de>,
11925 {
11926 struct GeneratedVisitor;
11927
11928 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11929 type Value = GeneratedField;
11930
11931 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11932 write!(formatter, "expected one of: {:?}", &FIELDS)
11933 }
11934
11935 #[allow(unused_variables)]
11936 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11937 where
11938 E: serde::de::Error,
11939 {
11940 match value {
11941 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
11942 "barrier" => Ok(GeneratedField::Barrier),
11943 "watermark" => Ok(GeneratedField::Watermark),
11944 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11945 }
11946 }
11947 }
11948 deserializer.deserialize_identifier(GeneratedVisitor)
11949 }
11950 }
11951 struct GeneratedVisitor;
11952 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11953 type Value = StreamMessage;
11954
11955 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11956 formatter.write_str("struct stream_plan.StreamMessage")
11957 }
11958
11959 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessage, V::Error>
11960 where
11961 V: serde::de::MapAccess<'de>,
11962 {
11963 let mut stream_message__ = None;
11964 while let Some(k) = map_.next_key()? {
11965 match k {
11966 GeneratedField::StreamChunk => {
11967 if stream_message__.is_some() {
11968 return Err(serde::de::Error::duplicate_field("streamChunk"));
11969 }
11970 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::StreamChunk)
11971;
11972 }
11973 GeneratedField::Barrier => {
11974 if stream_message__.is_some() {
11975 return Err(serde::de::Error::duplicate_field("barrier"));
11976 }
11977 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Barrier)
11978;
11979 }
11980 GeneratedField::Watermark => {
11981 if stream_message__.is_some() {
11982 return Err(serde::de::Error::duplicate_field("watermark"));
11983 }
11984 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Watermark)
11985;
11986 }
11987 }
11988 }
11989 Ok(StreamMessage {
11990 stream_message: stream_message__,
11991 })
11992 }
11993 }
11994 deserializer.deserialize_struct("stream_plan.StreamMessage", FIELDS, GeneratedVisitor)
11995 }
11996}
11997impl serde::Serialize for StreamMessageBatch {
11998 #[allow(deprecated)]
11999 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12000 where
12001 S: serde::Serializer,
12002 {
12003 use serde::ser::SerializeStruct;
12004 let mut len = 0;
12005 if self.stream_message_batch.is_some() {
12006 len += 1;
12007 }
12008 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch", len)?;
12009 if let Some(v) = self.stream_message_batch.as_ref() {
12010 match v {
12011 stream_message_batch::StreamMessageBatch::StreamChunk(v) => {
12012 struct_ser.serialize_field("streamChunk", v)?;
12013 }
12014 stream_message_batch::StreamMessageBatch::BarrierBatch(v) => {
12015 struct_ser.serialize_field("barrierBatch", v)?;
12016 }
12017 stream_message_batch::StreamMessageBatch::Watermark(v) => {
12018 struct_ser.serialize_field("watermark", v)?;
12019 }
12020 }
12021 }
12022 struct_ser.end()
12023 }
12024}
12025impl<'de> serde::Deserialize<'de> for StreamMessageBatch {
12026 #[allow(deprecated)]
12027 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12028 where
12029 D: serde::Deserializer<'de>,
12030 {
12031 const FIELDS: &[&str] = &[
12032 "stream_chunk",
12033 "streamChunk",
12034 "barrier_batch",
12035 "barrierBatch",
12036 "watermark",
12037 ];
12038
12039 #[allow(clippy::enum_variant_names)]
12040 enum GeneratedField {
12041 StreamChunk,
12042 BarrierBatch,
12043 Watermark,
12044 }
12045 impl<'de> serde::Deserialize<'de> for GeneratedField {
12046 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12047 where
12048 D: serde::Deserializer<'de>,
12049 {
12050 struct GeneratedVisitor;
12051
12052 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12053 type Value = GeneratedField;
12054
12055 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12056 write!(formatter, "expected one of: {:?}", &FIELDS)
12057 }
12058
12059 #[allow(unused_variables)]
12060 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12061 where
12062 E: serde::de::Error,
12063 {
12064 match value {
12065 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
12066 "barrierBatch" | "barrier_batch" => Ok(GeneratedField::BarrierBatch),
12067 "watermark" => Ok(GeneratedField::Watermark),
12068 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12069 }
12070 }
12071 }
12072 deserializer.deserialize_identifier(GeneratedVisitor)
12073 }
12074 }
12075 struct GeneratedVisitor;
12076 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12077 type Value = StreamMessageBatch;
12078
12079 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12080 formatter.write_str("struct stream_plan.StreamMessageBatch")
12081 }
12082
12083 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessageBatch, V::Error>
12084 where
12085 V: serde::de::MapAccess<'de>,
12086 {
12087 let mut stream_message_batch__ = None;
12088 while let Some(k) = map_.next_key()? {
12089 match k {
12090 GeneratedField::StreamChunk => {
12091 if stream_message_batch__.is_some() {
12092 return Err(serde::de::Error::duplicate_field("streamChunk"));
12093 }
12094 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::StreamChunk)
12095;
12096 }
12097 GeneratedField::BarrierBatch => {
12098 if stream_message_batch__.is_some() {
12099 return Err(serde::de::Error::duplicate_field("barrierBatch"));
12100 }
12101 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::BarrierBatch)
12102;
12103 }
12104 GeneratedField::Watermark => {
12105 if stream_message_batch__.is_some() {
12106 return Err(serde::de::Error::duplicate_field("watermark"));
12107 }
12108 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::Watermark)
12109;
12110 }
12111 }
12112 }
12113 Ok(StreamMessageBatch {
12114 stream_message_batch: stream_message_batch__,
12115 })
12116 }
12117 }
12118 deserializer.deserialize_struct("stream_plan.StreamMessageBatch", FIELDS, GeneratedVisitor)
12119 }
12120}
12121impl serde::Serialize for stream_message_batch::BarrierBatch {
12122 #[allow(deprecated)]
12123 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12124 where
12125 S: serde::Serializer,
12126 {
12127 use serde::ser::SerializeStruct;
12128 let mut len = 0;
12129 if !self.barriers.is_empty() {
12130 len += 1;
12131 }
12132 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", len)?;
12133 if !self.barriers.is_empty() {
12134 struct_ser.serialize_field("barriers", &self.barriers)?;
12135 }
12136 struct_ser.end()
12137 }
12138}
12139impl<'de> serde::Deserialize<'de> for stream_message_batch::BarrierBatch {
12140 #[allow(deprecated)]
12141 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12142 where
12143 D: serde::Deserializer<'de>,
12144 {
12145 const FIELDS: &[&str] = &[
12146 "barriers",
12147 ];
12148
12149 #[allow(clippy::enum_variant_names)]
12150 enum GeneratedField {
12151 Barriers,
12152 }
12153 impl<'de> serde::Deserialize<'de> for GeneratedField {
12154 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12155 where
12156 D: serde::Deserializer<'de>,
12157 {
12158 struct GeneratedVisitor;
12159
12160 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12161 type Value = GeneratedField;
12162
12163 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12164 write!(formatter, "expected one of: {:?}", &FIELDS)
12165 }
12166
12167 #[allow(unused_variables)]
12168 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12169 where
12170 E: serde::de::Error,
12171 {
12172 match value {
12173 "barriers" => Ok(GeneratedField::Barriers),
12174 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12175 }
12176 }
12177 }
12178 deserializer.deserialize_identifier(GeneratedVisitor)
12179 }
12180 }
12181 struct GeneratedVisitor;
12182 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12183 type Value = stream_message_batch::BarrierBatch;
12184
12185 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12186 formatter.write_str("struct stream_plan.StreamMessageBatch.BarrierBatch")
12187 }
12188
12189 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_message_batch::BarrierBatch, V::Error>
12190 where
12191 V: serde::de::MapAccess<'de>,
12192 {
12193 let mut barriers__ = None;
12194 while let Some(k) = map_.next_key()? {
12195 match k {
12196 GeneratedField::Barriers => {
12197 if barriers__.is_some() {
12198 return Err(serde::de::Error::duplicate_field("barriers"));
12199 }
12200 barriers__ = Some(map_.next_value()?);
12201 }
12202 }
12203 }
12204 Ok(stream_message_batch::BarrierBatch {
12205 barriers: barriers__.unwrap_or_default(),
12206 })
12207 }
12208 }
12209 deserializer.deserialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", FIELDS, GeneratedVisitor)
12210 }
12211}
12212impl serde::Serialize for StreamNode {
12213 #[allow(deprecated)]
12214 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12215 where
12216 S: serde::Serializer,
12217 {
12218 use serde::ser::SerializeStruct;
12219 let mut len = 0;
12220 if self.operator_id != 0 {
12221 len += 1;
12222 }
12223 if !self.input.is_empty() {
12224 len += 1;
12225 }
12226 if !self.stream_key.is_empty() {
12227 len += 1;
12228 }
12229 if self.stream_kind != 0 {
12230 len += 1;
12231 }
12232 if !self.identity.is_empty() {
12233 len += 1;
12234 }
12235 if !self.fields.is_empty() {
12236 len += 1;
12237 }
12238 if self.node_body.is_some() {
12239 len += 1;
12240 }
12241 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamNode", len)?;
12242 if self.operator_id != 0 {
12243 #[allow(clippy::needless_borrow)]
12244 #[allow(clippy::needless_borrows_for_generic_args)]
12245 struct_ser.serialize_field("operatorId", ToString::to_string(&self.operator_id).as_str())?;
12246 }
12247 if !self.input.is_empty() {
12248 struct_ser.serialize_field("input", &self.input)?;
12249 }
12250 if !self.stream_key.is_empty() {
12251 struct_ser.serialize_field("streamKey", &self.stream_key)?;
12252 }
12253 if self.stream_kind != 0 {
12254 let v = stream_node::StreamKind::try_from(self.stream_kind)
12255 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_kind)))?;
12256 struct_ser.serialize_field("streamKind", &v)?;
12257 }
12258 if !self.identity.is_empty() {
12259 struct_ser.serialize_field("identity", &self.identity)?;
12260 }
12261 if !self.fields.is_empty() {
12262 struct_ser.serialize_field("fields", &self.fields)?;
12263 }
12264 if let Some(v) = self.node_body.as_ref() {
12265 match v {
12266 stream_node::NodeBody::Source(v) => {
12267 struct_ser.serialize_field("source", v)?;
12268 }
12269 stream_node::NodeBody::Project(v) => {
12270 struct_ser.serialize_field("project", v)?;
12271 }
12272 stream_node::NodeBody::Filter(v) => {
12273 struct_ser.serialize_field("filter", v)?;
12274 }
12275 stream_node::NodeBody::Materialize(v) => {
12276 struct_ser.serialize_field("materialize", v)?;
12277 }
12278 stream_node::NodeBody::StatelessSimpleAgg(v) => {
12279 struct_ser.serialize_field("statelessSimpleAgg", v)?;
12280 }
12281 stream_node::NodeBody::SimpleAgg(v) => {
12282 struct_ser.serialize_field("simpleAgg", v)?;
12283 }
12284 stream_node::NodeBody::HashAgg(v) => {
12285 struct_ser.serialize_field("hashAgg", v)?;
12286 }
12287 stream_node::NodeBody::AppendOnlyTopN(v) => {
12288 struct_ser.serialize_field("appendOnlyTopN", v)?;
12289 }
12290 stream_node::NodeBody::HashJoin(v) => {
12291 struct_ser.serialize_field("hashJoin", v)?;
12292 }
12293 stream_node::NodeBody::TopN(v) => {
12294 struct_ser.serialize_field("topN", v)?;
12295 }
12296 stream_node::NodeBody::HopWindow(v) => {
12297 struct_ser.serialize_field("hopWindow", v)?;
12298 }
12299 stream_node::NodeBody::Merge(v) => {
12300 struct_ser.serialize_field("merge", v)?;
12301 }
12302 stream_node::NodeBody::Exchange(v) => {
12303 struct_ser.serialize_field("exchange", v)?;
12304 }
12305 stream_node::NodeBody::StreamScan(v) => {
12306 struct_ser.serialize_field("streamScan", v)?;
12307 }
12308 stream_node::NodeBody::BatchPlan(v) => {
12309 struct_ser.serialize_field("batchPlan", v)?;
12310 }
12311 stream_node::NodeBody::Lookup(v) => {
12312 struct_ser.serialize_field("lookup", v)?;
12313 }
12314 stream_node::NodeBody::Arrange(v) => {
12315 struct_ser.serialize_field("arrange", v)?;
12316 }
12317 stream_node::NodeBody::LookupUnion(v) => {
12318 struct_ser.serialize_field("lookupUnion", v)?;
12319 }
12320 stream_node::NodeBody::Union(v) => {
12321 struct_ser.serialize_field("union", v)?;
12322 }
12323 stream_node::NodeBody::DeltaIndexJoin(v) => {
12324 struct_ser.serialize_field("deltaIndexJoin", v)?;
12325 }
12326 stream_node::NodeBody::Sink(v) => {
12327 struct_ser.serialize_field("sink", v)?;
12328 }
12329 stream_node::NodeBody::Expand(v) => {
12330 struct_ser.serialize_field("expand", v)?;
12331 }
12332 stream_node::NodeBody::DynamicFilter(v) => {
12333 struct_ser.serialize_field("dynamicFilter", v)?;
12334 }
12335 stream_node::NodeBody::ProjectSet(v) => {
12336 struct_ser.serialize_field("projectSet", v)?;
12337 }
12338 stream_node::NodeBody::GroupTopN(v) => {
12339 struct_ser.serialize_field("groupTopN", v)?;
12340 }
12341 stream_node::NodeBody::Sort(v) => {
12342 struct_ser.serialize_field("sort", v)?;
12343 }
12344 stream_node::NodeBody::WatermarkFilter(v) => {
12345 struct_ser.serialize_field("watermarkFilter", v)?;
12346 }
12347 stream_node::NodeBody::Dml(v) => {
12348 struct_ser.serialize_field("dml", v)?;
12349 }
12350 stream_node::NodeBody::RowIdGen(v) => {
12351 struct_ser.serialize_field("rowIdGen", v)?;
12352 }
12353 stream_node::NodeBody::Now(v) => {
12354 struct_ser.serialize_field("now", v)?;
12355 }
12356 stream_node::NodeBody::AppendOnlyGroupTopN(v) => {
12357 struct_ser.serialize_field("appendOnlyGroupTopN", v)?;
12358 }
12359 stream_node::NodeBody::TemporalJoin(v) => {
12360 struct_ser.serialize_field("temporalJoin", v)?;
12361 }
12362 stream_node::NodeBody::BarrierRecv(v) => {
12363 struct_ser.serialize_field("barrierRecv", v)?;
12364 }
12365 stream_node::NodeBody::Values(v) => {
12366 struct_ser.serialize_field("values", v)?;
12367 }
12368 stream_node::NodeBody::AppendOnlyDedup(v) => {
12369 struct_ser.serialize_field("appendOnlyDedup", v)?;
12370 }
12371 stream_node::NodeBody::NoOp(v) => {
12372 struct_ser.serialize_field("noOp", v)?;
12373 }
12374 stream_node::NodeBody::EowcOverWindow(v) => {
12375 struct_ser.serialize_field("eowcOverWindow", v)?;
12376 }
12377 stream_node::NodeBody::OverWindow(v) => {
12378 struct_ser.serialize_field("overWindow", v)?;
12379 }
12380 stream_node::NodeBody::StreamFsFetch(v) => {
12381 struct_ser.serialize_field("streamFsFetch", v)?;
12382 }
12383 stream_node::NodeBody::StreamCdcScan(v) => {
12384 struct_ser.serialize_field("streamCdcScan", v)?;
12385 }
12386 stream_node::NodeBody::CdcFilter(v) => {
12387 struct_ser.serialize_field("cdcFilter", v)?;
12388 }
12389 stream_node::NodeBody::SourceBackfill(v) => {
12390 struct_ser.serialize_field("sourceBackfill", v)?;
12391 }
12392 stream_node::NodeBody::Changelog(v) => {
12393 struct_ser.serialize_field("changelog", v)?;
12394 }
12395 stream_node::NodeBody::LocalApproxPercentile(v) => {
12396 struct_ser.serialize_field("localApproxPercentile", v)?;
12397 }
12398 stream_node::NodeBody::GlobalApproxPercentile(v) => {
12399 struct_ser.serialize_field("globalApproxPercentile", v)?;
12400 }
12401 stream_node::NodeBody::RowMerge(v) => {
12402 struct_ser.serialize_field("rowMerge", v)?;
12403 }
12404 stream_node::NodeBody::AsOfJoin(v) => {
12405 struct_ser.serialize_field("asOfJoin", v)?;
12406 }
12407 stream_node::NodeBody::SyncLogStore(v) => {
12408 struct_ser.serialize_field("syncLogStore", v)?;
12409 }
12410 stream_node::NodeBody::MaterializedExprs(v) => {
12411 struct_ser.serialize_field("materializedExprs", v)?;
12412 }
12413 stream_node::NodeBody::VectorIndexWrite(v) => {
12414 struct_ser.serialize_field("vectorIndexWrite", v)?;
12415 }
12416 stream_node::NodeBody::UpstreamSinkUnion(v) => {
12417 struct_ser.serialize_field("upstreamSinkUnion", v)?;
12418 }
12419 }
12420 }
12421 struct_ser.end()
12422 }
12423}
12424impl<'de> serde::Deserialize<'de> for StreamNode {
12425 #[allow(deprecated)]
12426 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12427 where
12428 D: serde::Deserializer<'de>,
12429 {
12430 const FIELDS: &[&str] = &[
12431 "operator_id",
12432 "operatorId",
12433 "input",
12434 "stream_key",
12435 "streamKey",
12436 "stream_kind",
12437 "streamKind",
12438 "identity",
12439 "fields",
12440 "source",
12441 "project",
12442 "filter",
12443 "materialize",
12444 "stateless_simple_agg",
12445 "statelessSimpleAgg",
12446 "simple_agg",
12447 "simpleAgg",
12448 "hash_agg",
12449 "hashAgg",
12450 "append_only_top_n",
12451 "appendOnlyTopN",
12452 "hash_join",
12453 "hashJoin",
12454 "top_n",
12455 "topN",
12456 "hop_window",
12457 "hopWindow",
12458 "merge",
12459 "exchange",
12460 "stream_scan",
12461 "streamScan",
12462 "batch_plan",
12463 "batchPlan",
12464 "lookup",
12465 "arrange",
12466 "lookup_union",
12467 "lookupUnion",
12468 "union",
12469 "delta_index_join",
12470 "deltaIndexJoin",
12471 "sink",
12472 "expand",
12473 "dynamic_filter",
12474 "dynamicFilter",
12475 "project_set",
12476 "projectSet",
12477 "group_top_n",
12478 "groupTopN",
12479 "sort",
12480 "watermark_filter",
12481 "watermarkFilter",
12482 "dml",
12483 "row_id_gen",
12484 "rowIdGen",
12485 "now",
12486 "append_only_group_top_n",
12487 "appendOnlyGroupTopN",
12488 "temporal_join",
12489 "temporalJoin",
12490 "barrier_recv",
12491 "barrierRecv",
12492 "values",
12493 "append_only_dedup",
12494 "appendOnlyDedup",
12495 "no_op",
12496 "noOp",
12497 "eowc_over_window",
12498 "eowcOverWindow",
12499 "over_window",
12500 "overWindow",
12501 "stream_fs_fetch",
12502 "streamFsFetch",
12503 "stream_cdc_scan",
12504 "streamCdcScan",
12505 "cdc_filter",
12506 "cdcFilter",
12507 "source_backfill",
12508 "sourceBackfill",
12509 "changelog",
12510 "local_approx_percentile",
12511 "localApproxPercentile",
12512 "global_approx_percentile",
12513 "globalApproxPercentile",
12514 "row_merge",
12515 "rowMerge",
12516 "as_of_join",
12517 "asOfJoin",
12518 "sync_log_store",
12519 "syncLogStore",
12520 "materialized_exprs",
12521 "materializedExprs",
12522 "vector_index_write",
12523 "vectorIndexWrite",
12524 "upstream_sink_union",
12525 "upstreamSinkUnion",
12526 ];
12527
12528 #[allow(clippy::enum_variant_names)]
12529 enum GeneratedField {
12530 OperatorId,
12531 Input,
12532 StreamKey,
12533 StreamKind,
12534 Identity,
12535 Fields,
12536 Source,
12537 Project,
12538 Filter,
12539 Materialize,
12540 StatelessSimpleAgg,
12541 SimpleAgg,
12542 HashAgg,
12543 AppendOnlyTopN,
12544 HashJoin,
12545 TopN,
12546 HopWindow,
12547 Merge,
12548 Exchange,
12549 StreamScan,
12550 BatchPlan,
12551 Lookup,
12552 Arrange,
12553 LookupUnion,
12554 Union,
12555 DeltaIndexJoin,
12556 Sink,
12557 Expand,
12558 DynamicFilter,
12559 ProjectSet,
12560 GroupTopN,
12561 Sort,
12562 WatermarkFilter,
12563 Dml,
12564 RowIdGen,
12565 Now,
12566 AppendOnlyGroupTopN,
12567 TemporalJoin,
12568 BarrierRecv,
12569 Values,
12570 AppendOnlyDedup,
12571 NoOp,
12572 EowcOverWindow,
12573 OverWindow,
12574 StreamFsFetch,
12575 StreamCdcScan,
12576 CdcFilter,
12577 SourceBackfill,
12578 Changelog,
12579 LocalApproxPercentile,
12580 GlobalApproxPercentile,
12581 RowMerge,
12582 AsOfJoin,
12583 SyncLogStore,
12584 MaterializedExprs,
12585 VectorIndexWrite,
12586 UpstreamSinkUnion,
12587 }
12588 impl<'de> serde::Deserialize<'de> for GeneratedField {
12589 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12590 where
12591 D: serde::Deserializer<'de>,
12592 {
12593 struct GeneratedVisitor;
12594
12595 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12596 type Value = GeneratedField;
12597
12598 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12599 write!(formatter, "expected one of: {:?}", &FIELDS)
12600 }
12601
12602 #[allow(unused_variables)]
12603 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12604 where
12605 E: serde::de::Error,
12606 {
12607 match value {
12608 "operatorId" | "operator_id" => Ok(GeneratedField::OperatorId),
12609 "input" => Ok(GeneratedField::Input),
12610 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
12611 "streamKind" | "stream_kind" => Ok(GeneratedField::StreamKind),
12612 "identity" => Ok(GeneratedField::Identity),
12613 "fields" => Ok(GeneratedField::Fields),
12614 "source" => Ok(GeneratedField::Source),
12615 "project" => Ok(GeneratedField::Project),
12616 "filter" => Ok(GeneratedField::Filter),
12617 "materialize" => Ok(GeneratedField::Materialize),
12618 "statelessSimpleAgg" | "stateless_simple_agg" => Ok(GeneratedField::StatelessSimpleAgg),
12619 "simpleAgg" | "simple_agg" => Ok(GeneratedField::SimpleAgg),
12620 "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
12621 "appendOnlyTopN" | "append_only_top_n" => Ok(GeneratedField::AppendOnlyTopN),
12622 "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
12623 "topN" | "top_n" => Ok(GeneratedField::TopN),
12624 "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
12625 "merge" => Ok(GeneratedField::Merge),
12626 "exchange" => Ok(GeneratedField::Exchange),
12627 "streamScan" | "stream_scan" => Ok(GeneratedField::StreamScan),
12628 "batchPlan" | "batch_plan" => Ok(GeneratedField::BatchPlan),
12629 "lookup" => Ok(GeneratedField::Lookup),
12630 "arrange" => Ok(GeneratedField::Arrange),
12631 "lookupUnion" | "lookup_union" => Ok(GeneratedField::LookupUnion),
12632 "union" => Ok(GeneratedField::Union),
12633 "deltaIndexJoin" | "delta_index_join" => Ok(GeneratedField::DeltaIndexJoin),
12634 "sink" => Ok(GeneratedField::Sink),
12635 "expand" => Ok(GeneratedField::Expand),
12636 "dynamicFilter" | "dynamic_filter" => Ok(GeneratedField::DynamicFilter),
12637 "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
12638 "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
12639 "sort" => Ok(GeneratedField::Sort),
12640 "watermarkFilter" | "watermark_filter" => Ok(GeneratedField::WatermarkFilter),
12641 "dml" => Ok(GeneratedField::Dml),
12642 "rowIdGen" | "row_id_gen" => Ok(GeneratedField::RowIdGen),
12643 "now" => Ok(GeneratedField::Now),
12644 "appendOnlyGroupTopN" | "append_only_group_top_n" => Ok(GeneratedField::AppendOnlyGroupTopN),
12645 "temporalJoin" | "temporal_join" => Ok(GeneratedField::TemporalJoin),
12646 "barrierRecv" | "barrier_recv" => Ok(GeneratedField::BarrierRecv),
12647 "values" => Ok(GeneratedField::Values),
12648 "appendOnlyDedup" | "append_only_dedup" => Ok(GeneratedField::AppendOnlyDedup),
12649 "noOp" | "no_op" => Ok(GeneratedField::NoOp),
12650 "eowcOverWindow" | "eowc_over_window" => Ok(GeneratedField::EowcOverWindow),
12651 "overWindow" | "over_window" => Ok(GeneratedField::OverWindow),
12652 "streamFsFetch" | "stream_fs_fetch" => Ok(GeneratedField::StreamFsFetch),
12653 "streamCdcScan" | "stream_cdc_scan" => Ok(GeneratedField::StreamCdcScan),
12654 "cdcFilter" | "cdc_filter" => Ok(GeneratedField::CdcFilter),
12655 "sourceBackfill" | "source_backfill" => Ok(GeneratedField::SourceBackfill),
12656 "changelog" => Ok(GeneratedField::Changelog),
12657 "localApproxPercentile" | "local_approx_percentile" => Ok(GeneratedField::LocalApproxPercentile),
12658 "globalApproxPercentile" | "global_approx_percentile" => Ok(GeneratedField::GlobalApproxPercentile),
12659 "rowMerge" | "row_merge" => Ok(GeneratedField::RowMerge),
12660 "asOfJoin" | "as_of_join" => Ok(GeneratedField::AsOfJoin),
12661 "syncLogStore" | "sync_log_store" => Ok(GeneratedField::SyncLogStore),
12662 "materializedExprs" | "materialized_exprs" => Ok(GeneratedField::MaterializedExprs),
12663 "vectorIndexWrite" | "vector_index_write" => Ok(GeneratedField::VectorIndexWrite),
12664 "upstreamSinkUnion" | "upstream_sink_union" => Ok(GeneratedField::UpstreamSinkUnion),
12665 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12666 }
12667 }
12668 }
12669 deserializer.deserialize_identifier(GeneratedVisitor)
12670 }
12671 }
12672 struct GeneratedVisitor;
12673 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12674 type Value = StreamNode;
12675
12676 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12677 formatter.write_str("struct stream_plan.StreamNode")
12678 }
12679
12680 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamNode, V::Error>
12681 where
12682 V: serde::de::MapAccess<'de>,
12683 {
12684 let mut operator_id__ = None;
12685 let mut input__ = None;
12686 let mut stream_key__ = None;
12687 let mut stream_kind__ = None;
12688 let mut identity__ = None;
12689 let mut fields__ = None;
12690 let mut node_body__ = None;
12691 while let Some(k) = map_.next_key()? {
12692 match k {
12693 GeneratedField::OperatorId => {
12694 if operator_id__.is_some() {
12695 return Err(serde::de::Error::duplicate_field("operatorId"));
12696 }
12697 operator_id__ =
12698 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12699 ;
12700 }
12701 GeneratedField::Input => {
12702 if input__.is_some() {
12703 return Err(serde::de::Error::duplicate_field("input"));
12704 }
12705 input__ = Some(map_.next_value()?);
12706 }
12707 GeneratedField::StreamKey => {
12708 if stream_key__.is_some() {
12709 return Err(serde::de::Error::duplicate_field("streamKey"));
12710 }
12711 stream_key__ =
12712 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12713 .into_iter().map(|x| x.0).collect())
12714 ;
12715 }
12716 GeneratedField::StreamKind => {
12717 if stream_kind__.is_some() {
12718 return Err(serde::de::Error::duplicate_field("streamKind"));
12719 }
12720 stream_kind__ = Some(map_.next_value::<stream_node::StreamKind>()? as i32);
12721 }
12722 GeneratedField::Identity => {
12723 if identity__.is_some() {
12724 return Err(serde::de::Error::duplicate_field("identity"));
12725 }
12726 identity__ = Some(map_.next_value()?);
12727 }
12728 GeneratedField::Fields => {
12729 if fields__.is_some() {
12730 return Err(serde::de::Error::duplicate_field("fields"));
12731 }
12732 fields__ = Some(map_.next_value()?);
12733 }
12734 GeneratedField::Source => {
12735 if node_body__.is_some() {
12736 return Err(serde::de::Error::duplicate_field("source"));
12737 }
12738 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Source)
12739;
12740 }
12741 GeneratedField::Project => {
12742 if node_body__.is_some() {
12743 return Err(serde::de::Error::duplicate_field("project"));
12744 }
12745 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Project)
12746;
12747 }
12748 GeneratedField::Filter => {
12749 if node_body__.is_some() {
12750 return Err(serde::de::Error::duplicate_field("filter"));
12751 }
12752 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Filter)
12753;
12754 }
12755 GeneratedField::Materialize => {
12756 if node_body__.is_some() {
12757 return Err(serde::de::Error::duplicate_field("materialize"));
12758 }
12759 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Materialize)
12760;
12761 }
12762 GeneratedField::StatelessSimpleAgg => {
12763 if node_body__.is_some() {
12764 return Err(serde::de::Error::duplicate_field("statelessSimpleAgg"));
12765 }
12766 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StatelessSimpleAgg)
12767;
12768 }
12769 GeneratedField::SimpleAgg => {
12770 if node_body__.is_some() {
12771 return Err(serde::de::Error::duplicate_field("simpleAgg"));
12772 }
12773 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SimpleAgg)
12774;
12775 }
12776 GeneratedField::HashAgg => {
12777 if node_body__.is_some() {
12778 return Err(serde::de::Error::duplicate_field("hashAgg"));
12779 }
12780 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashAgg)
12781;
12782 }
12783 GeneratedField::AppendOnlyTopN => {
12784 if node_body__.is_some() {
12785 return Err(serde::de::Error::duplicate_field("appendOnlyTopN"));
12786 }
12787 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyTopN)
12788;
12789 }
12790 GeneratedField::HashJoin => {
12791 if node_body__.is_some() {
12792 return Err(serde::de::Error::duplicate_field("hashJoin"));
12793 }
12794 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashJoin)
12795;
12796 }
12797 GeneratedField::TopN => {
12798 if node_body__.is_some() {
12799 return Err(serde::de::Error::duplicate_field("topN"));
12800 }
12801 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TopN)
12802;
12803 }
12804 GeneratedField::HopWindow => {
12805 if node_body__.is_some() {
12806 return Err(serde::de::Error::duplicate_field("hopWindow"));
12807 }
12808 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HopWindow)
12809;
12810 }
12811 GeneratedField::Merge => {
12812 if node_body__.is_some() {
12813 return Err(serde::de::Error::duplicate_field("merge"));
12814 }
12815 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Merge)
12816;
12817 }
12818 GeneratedField::Exchange => {
12819 if node_body__.is_some() {
12820 return Err(serde::de::Error::duplicate_field("exchange"));
12821 }
12822 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Exchange)
12823;
12824 }
12825 GeneratedField::StreamScan => {
12826 if node_body__.is_some() {
12827 return Err(serde::de::Error::duplicate_field("streamScan"));
12828 }
12829 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamScan)
12830;
12831 }
12832 GeneratedField::BatchPlan => {
12833 if node_body__.is_some() {
12834 return Err(serde::de::Error::duplicate_field("batchPlan"));
12835 }
12836 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BatchPlan)
12837;
12838 }
12839 GeneratedField::Lookup => {
12840 if node_body__.is_some() {
12841 return Err(serde::de::Error::duplicate_field("lookup"));
12842 }
12843 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Lookup)
12844;
12845 }
12846 GeneratedField::Arrange => {
12847 if node_body__.is_some() {
12848 return Err(serde::de::Error::duplicate_field("arrange"));
12849 }
12850 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Arrange)
12851;
12852 }
12853 GeneratedField::LookupUnion => {
12854 if node_body__.is_some() {
12855 return Err(serde::de::Error::duplicate_field("lookupUnion"));
12856 }
12857 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LookupUnion)
12858;
12859 }
12860 GeneratedField::Union => {
12861 if node_body__.is_some() {
12862 return Err(serde::de::Error::duplicate_field("union"));
12863 }
12864 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Union)
12865;
12866 }
12867 GeneratedField::DeltaIndexJoin => {
12868 if node_body__.is_some() {
12869 return Err(serde::de::Error::duplicate_field("deltaIndexJoin"));
12870 }
12871 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DeltaIndexJoin)
12872;
12873 }
12874 GeneratedField::Sink => {
12875 if node_body__.is_some() {
12876 return Err(serde::de::Error::duplicate_field("sink"));
12877 }
12878 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sink)
12879;
12880 }
12881 GeneratedField::Expand => {
12882 if node_body__.is_some() {
12883 return Err(serde::de::Error::duplicate_field("expand"));
12884 }
12885 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Expand)
12886;
12887 }
12888 GeneratedField::DynamicFilter => {
12889 if node_body__.is_some() {
12890 return Err(serde::de::Error::duplicate_field("dynamicFilter"));
12891 }
12892 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DynamicFilter)
12893;
12894 }
12895 GeneratedField::ProjectSet => {
12896 if node_body__.is_some() {
12897 return Err(serde::de::Error::duplicate_field("projectSet"));
12898 }
12899 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::ProjectSet)
12900;
12901 }
12902 GeneratedField::GroupTopN => {
12903 if node_body__.is_some() {
12904 return Err(serde::de::Error::duplicate_field("groupTopN"));
12905 }
12906 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GroupTopN)
12907;
12908 }
12909 GeneratedField::Sort => {
12910 if node_body__.is_some() {
12911 return Err(serde::de::Error::duplicate_field("sort"));
12912 }
12913 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sort)
12914;
12915 }
12916 GeneratedField::WatermarkFilter => {
12917 if node_body__.is_some() {
12918 return Err(serde::de::Error::duplicate_field("watermarkFilter"));
12919 }
12920 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::WatermarkFilter)
12921;
12922 }
12923 GeneratedField::Dml => {
12924 if node_body__.is_some() {
12925 return Err(serde::de::Error::duplicate_field("dml"));
12926 }
12927 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Dml)
12928;
12929 }
12930 GeneratedField::RowIdGen => {
12931 if node_body__.is_some() {
12932 return Err(serde::de::Error::duplicate_field("rowIdGen"));
12933 }
12934 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowIdGen)
12935;
12936 }
12937 GeneratedField::Now => {
12938 if node_body__.is_some() {
12939 return Err(serde::de::Error::duplicate_field("now"));
12940 }
12941 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Now)
12942;
12943 }
12944 GeneratedField::AppendOnlyGroupTopN => {
12945 if node_body__.is_some() {
12946 return Err(serde::de::Error::duplicate_field("appendOnlyGroupTopN"));
12947 }
12948 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyGroupTopN)
12949;
12950 }
12951 GeneratedField::TemporalJoin => {
12952 if node_body__.is_some() {
12953 return Err(serde::de::Error::duplicate_field("temporalJoin"));
12954 }
12955 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TemporalJoin)
12956;
12957 }
12958 GeneratedField::BarrierRecv => {
12959 if node_body__.is_some() {
12960 return Err(serde::de::Error::duplicate_field("barrierRecv"));
12961 }
12962 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BarrierRecv)
12963;
12964 }
12965 GeneratedField::Values => {
12966 if node_body__.is_some() {
12967 return Err(serde::de::Error::duplicate_field("values"));
12968 }
12969 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Values)
12970;
12971 }
12972 GeneratedField::AppendOnlyDedup => {
12973 if node_body__.is_some() {
12974 return Err(serde::de::Error::duplicate_field("appendOnlyDedup"));
12975 }
12976 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyDedup)
12977;
12978 }
12979 GeneratedField::NoOp => {
12980 if node_body__.is_some() {
12981 return Err(serde::de::Error::duplicate_field("noOp"));
12982 }
12983 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::NoOp)
12984;
12985 }
12986 GeneratedField::EowcOverWindow => {
12987 if node_body__.is_some() {
12988 return Err(serde::de::Error::duplicate_field("eowcOverWindow"));
12989 }
12990 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcOverWindow)
12991;
12992 }
12993 GeneratedField::OverWindow => {
12994 if node_body__.is_some() {
12995 return Err(serde::de::Error::duplicate_field("overWindow"));
12996 }
12997 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::OverWindow)
12998;
12999 }
13000 GeneratedField::StreamFsFetch => {
13001 if node_body__.is_some() {
13002 return Err(serde::de::Error::duplicate_field("streamFsFetch"));
13003 }
13004 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamFsFetch)
13005;
13006 }
13007 GeneratedField::StreamCdcScan => {
13008 if node_body__.is_some() {
13009 return Err(serde::de::Error::duplicate_field("streamCdcScan"));
13010 }
13011 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamCdcScan)
13012;
13013 }
13014 GeneratedField::CdcFilter => {
13015 if node_body__.is_some() {
13016 return Err(serde::de::Error::duplicate_field("cdcFilter"));
13017 }
13018 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CdcFilter)
13019;
13020 }
13021 GeneratedField::SourceBackfill => {
13022 if node_body__.is_some() {
13023 return Err(serde::de::Error::duplicate_field("sourceBackfill"));
13024 }
13025 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SourceBackfill)
13026;
13027 }
13028 GeneratedField::Changelog => {
13029 if node_body__.is_some() {
13030 return Err(serde::de::Error::duplicate_field("changelog"));
13031 }
13032 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Changelog)
13033;
13034 }
13035 GeneratedField::LocalApproxPercentile => {
13036 if node_body__.is_some() {
13037 return Err(serde::de::Error::duplicate_field("localApproxPercentile"));
13038 }
13039 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalApproxPercentile)
13040;
13041 }
13042 GeneratedField::GlobalApproxPercentile => {
13043 if node_body__.is_some() {
13044 return Err(serde::de::Error::duplicate_field("globalApproxPercentile"));
13045 }
13046 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GlobalApproxPercentile)
13047;
13048 }
13049 GeneratedField::RowMerge => {
13050 if node_body__.is_some() {
13051 return Err(serde::de::Error::duplicate_field("rowMerge"));
13052 }
13053 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowMerge)
13054;
13055 }
13056 GeneratedField::AsOfJoin => {
13057 if node_body__.is_some() {
13058 return Err(serde::de::Error::duplicate_field("asOfJoin"));
13059 }
13060 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AsOfJoin)
13061;
13062 }
13063 GeneratedField::SyncLogStore => {
13064 if node_body__.is_some() {
13065 return Err(serde::de::Error::duplicate_field("syncLogStore"));
13066 }
13067 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SyncLogStore)
13068;
13069 }
13070 GeneratedField::MaterializedExprs => {
13071 if node_body__.is_some() {
13072 return Err(serde::de::Error::duplicate_field("materializedExprs"));
13073 }
13074 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MaterializedExprs)
13075;
13076 }
13077 GeneratedField::VectorIndexWrite => {
13078 if node_body__.is_some() {
13079 return Err(serde::de::Error::duplicate_field("vectorIndexWrite"));
13080 }
13081 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexWrite)
13082;
13083 }
13084 GeneratedField::UpstreamSinkUnion => {
13085 if node_body__.is_some() {
13086 return Err(serde::de::Error::duplicate_field("upstreamSinkUnion"));
13087 }
13088 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::UpstreamSinkUnion)
13089;
13090 }
13091 }
13092 }
13093 Ok(StreamNode {
13094 operator_id: operator_id__.unwrap_or_default(),
13095 input: input__.unwrap_or_default(),
13096 stream_key: stream_key__.unwrap_or_default(),
13097 stream_kind: stream_kind__.unwrap_or_default(),
13098 identity: identity__.unwrap_or_default(),
13099 fields: fields__.unwrap_or_default(),
13100 node_body: node_body__,
13101 })
13102 }
13103 }
13104 deserializer.deserialize_struct("stream_plan.StreamNode", FIELDS, GeneratedVisitor)
13105 }
13106}
13107impl serde::Serialize for stream_node::StreamKind {
13108 #[allow(deprecated)]
13109 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13110 where
13111 S: serde::Serializer,
13112 {
13113 let variant = match self {
13114 Self::Retract => "STREAM_KIND_RETRACT",
13115 Self::AppendOnly => "STREAM_KIND_APPEND_ONLY",
13116 Self::Upsert => "STREAM_KIND_UPSERT",
13117 };
13118 serializer.serialize_str(variant)
13119 }
13120}
13121impl<'de> serde::Deserialize<'de> for stream_node::StreamKind {
13122 #[allow(deprecated)]
13123 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13124 where
13125 D: serde::Deserializer<'de>,
13126 {
13127 const FIELDS: &[&str] = &[
13128 "STREAM_KIND_RETRACT",
13129 "STREAM_KIND_APPEND_ONLY",
13130 "STREAM_KIND_UPSERT",
13131 ];
13132
13133 struct GeneratedVisitor;
13134
13135 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13136 type Value = stream_node::StreamKind;
13137
13138 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13139 write!(formatter, "expected one of: {:?}", &FIELDS)
13140 }
13141
13142 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13143 where
13144 E: serde::de::Error,
13145 {
13146 i32::try_from(v)
13147 .ok()
13148 .and_then(|x| x.try_into().ok())
13149 .ok_or_else(|| {
13150 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13151 })
13152 }
13153
13154 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13155 where
13156 E: serde::de::Error,
13157 {
13158 i32::try_from(v)
13159 .ok()
13160 .and_then(|x| x.try_into().ok())
13161 .ok_or_else(|| {
13162 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13163 })
13164 }
13165
13166 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13167 where
13168 E: serde::de::Error,
13169 {
13170 match value {
13171 "STREAM_KIND_RETRACT" => Ok(stream_node::StreamKind::Retract),
13172 "STREAM_KIND_APPEND_ONLY" => Ok(stream_node::StreamKind::AppendOnly),
13173 "STREAM_KIND_UPSERT" => Ok(stream_node::StreamKind::Upsert),
13174 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13175 }
13176 }
13177 }
13178 deserializer.deserialize_any(GeneratedVisitor)
13179 }
13180}
13181impl serde::Serialize for StreamScanNode {
13182 #[allow(deprecated)]
13183 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13184 where
13185 S: serde::Serializer,
13186 {
13187 use serde::ser::SerializeStruct;
13188 let mut len = 0;
13189 if self.table_id != 0 {
13190 len += 1;
13191 }
13192 if !self.upstream_column_ids.is_empty() {
13193 len += 1;
13194 }
13195 if !self.output_indices.is_empty() {
13196 len += 1;
13197 }
13198 if self.stream_scan_type != 0 {
13199 len += 1;
13200 }
13201 if self.state_table.is_some() {
13202 len += 1;
13203 }
13204 if self.table_desc.is_some() {
13205 len += 1;
13206 }
13207 if self.rate_limit.is_some() {
13208 len += 1;
13209 }
13210 if self.snapshot_read_barrier_interval != 0 {
13211 len += 1;
13212 }
13213 if self.arrangement_table.is_some() {
13214 len += 1;
13215 }
13216 if self.snapshot_backfill_epoch.is_some() {
13217 len += 1;
13218 }
13219 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamScanNode", len)?;
13220 if self.table_id != 0 {
13221 struct_ser.serialize_field("tableId", &self.table_id)?;
13222 }
13223 if !self.upstream_column_ids.is_empty() {
13224 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
13225 }
13226 if !self.output_indices.is_empty() {
13227 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
13228 }
13229 if self.stream_scan_type != 0 {
13230 let v = StreamScanType::try_from(self.stream_scan_type)
13231 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_scan_type)))?;
13232 struct_ser.serialize_field("streamScanType", &v)?;
13233 }
13234 if let Some(v) = self.state_table.as_ref() {
13235 struct_ser.serialize_field("stateTable", v)?;
13236 }
13237 if let Some(v) = self.table_desc.as_ref() {
13238 struct_ser.serialize_field("tableDesc", v)?;
13239 }
13240 if let Some(v) = self.rate_limit.as_ref() {
13241 struct_ser.serialize_field("rateLimit", v)?;
13242 }
13243 if self.snapshot_read_barrier_interval != 0 {
13244 struct_ser.serialize_field("snapshotReadBarrierInterval", &self.snapshot_read_barrier_interval)?;
13245 }
13246 if let Some(v) = self.arrangement_table.as_ref() {
13247 struct_ser.serialize_field("arrangementTable", v)?;
13248 }
13249 if let Some(v) = self.snapshot_backfill_epoch.as_ref() {
13250 #[allow(clippy::needless_borrow)]
13251 #[allow(clippy::needless_borrows_for_generic_args)]
13252 struct_ser.serialize_field("snapshotBackfillEpoch", ToString::to_string(&v).as_str())?;
13253 }
13254 struct_ser.end()
13255 }
13256}
13257impl<'de> serde::Deserialize<'de> for StreamScanNode {
13258 #[allow(deprecated)]
13259 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13260 where
13261 D: serde::Deserializer<'de>,
13262 {
13263 const FIELDS: &[&str] = &[
13264 "table_id",
13265 "tableId",
13266 "upstream_column_ids",
13267 "upstreamColumnIds",
13268 "output_indices",
13269 "outputIndices",
13270 "stream_scan_type",
13271 "streamScanType",
13272 "state_table",
13273 "stateTable",
13274 "table_desc",
13275 "tableDesc",
13276 "rate_limit",
13277 "rateLimit",
13278 "snapshot_read_barrier_interval",
13279 "snapshotReadBarrierInterval",
13280 "arrangement_table",
13281 "arrangementTable",
13282 "snapshot_backfill_epoch",
13283 "snapshotBackfillEpoch",
13284 ];
13285
13286 #[allow(clippy::enum_variant_names)]
13287 enum GeneratedField {
13288 TableId,
13289 UpstreamColumnIds,
13290 OutputIndices,
13291 StreamScanType,
13292 StateTable,
13293 TableDesc,
13294 RateLimit,
13295 SnapshotReadBarrierInterval,
13296 ArrangementTable,
13297 SnapshotBackfillEpoch,
13298 }
13299 impl<'de> serde::Deserialize<'de> for GeneratedField {
13300 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13301 where
13302 D: serde::Deserializer<'de>,
13303 {
13304 struct GeneratedVisitor;
13305
13306 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13307 type Value = GeneratedField;
13308
13309 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13310 write!(formatter, "expected one of: {:?}", &FIELDS)
13311 }
13312
13313 #[allow(unused_variables)]
13314 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13315 where
13316 E: serde::de::Error,
13317 {
13318 match value {
13319 "tableId" | "table_id" => Ok(GeneratedField::TableId),
13320 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
13321 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
13322 "streamScanType" | "stream_scan_type" => Ok(GeneratedField::StreamScanType),
13323 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
13324 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
13325 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
13326 "snapshotReadBarrierInterval" | "snapshot_read_barrier_interval" => Ok(GeneratedField::SnapshotReadBarrierInterval),
13327 "arrangementTable" | "arrangement_table" => Ok(GeneratedField::ArrangementTable),
13328 "snapshotBackfillEpoch" | "snapshot_backfill_epoch" => Ok(GeneratedField::SnapshotBackfillEpoch),
13329 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13330 }
13331 }
13332 }
13333 deserializer.deserialize_identifier(GeneratedVisitor)
13334 }
13335 }
13336 struct GeneratedVisitor;
13337 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13338 type Value = StreamScanNode;
13339
13340 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13341 formatter.write_str("struct stream_plan.StreamScanNode")
13342 }
13343
13344 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamScanNode, V::Error>
13345 where
13346 V: serde::de::MapAccess<'de>,
13347 {
13348 let mut table_id__ = None;
13349 let mut upstream_column_ids__ = None;
13350 let mut output_indices__ = None;
13351 let mut stream_scan_type__ = None;
13352 let mut state_table__ = None;
13353 let mut table_desc__ = None;
13354 let mut rate_limit__ = None;
13355 let mut snapshot_read_barrier_interval__ = None;
13356 let mut arrangement_table__ = None;
13357 let mut snapshot_backfill_epoch__ = None;
13358 while let Some(k) = map_.next_key()? {
13359 match k {
13360 GeneratedField::TableId => {
13361 if table_id__.is_some() {
13362 return Err(serde::de::Error::duplicate_field("tableId"));
13363 }
13364 table_id__ =
13365 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13366 ;
13367 }
13368 GeneratedField::UpstreamColumnIds => {
13369 if upstream_column_ids__.is_some() {
13370 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
13371 }
13372 upstream_column_ids__ =
13373 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13374 .into_iter().map(|x| x.0).collect())
13375 ;
13376 }
13377 GeneratedField::OutputIndices => {
13378 if output_indices__.is_some() {
13379 return Err(serde::de::Error::duplicate_field("outputIndices"));
13380 }
13381 output_indices__ =
13382 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13383 .into_iter().map(|x| x.0).collect())
13384 ;
13385 }
13386 GeneratedField::StreamScanType => {
13387 if stream_scan_type__.is_some() {
13388 return Err(serde::de::Error::duplicate_field("streamScanType"));
13389 }
13390 stream_scan_type__ = Some(map_.next_value::<StreamScanType>()? as i32);
13391 }
13392 GeneratedField::StateTable => {
13393 if state_table__.is_some() {
13394 return Err(serde::de::Error::duplicate_field("stateTable"));
13395 }
13396 state_table__ = map_.next_value()?;
13397 }
13398 GeneratedField::TableDesc => {
13399 if table_desc__.is_some() {
13400 return Err(serde::de::Error::duplicate_field("tableDesc"));
13401 }
13402 table_desc__ = map_.next_value()?;
13403 }
13404 GeneratedField::RateLimit => {
13405 if rate_limit__.is_some() {
13406 return Err(serde::de::Error::duplicate_field("rateLimit"));
13407 }
13408 rate_limit__ =
13409 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13410 ;
13411 }
13412 GeneratedField::SnapshotReadBarrierInterval => {
13413 if snapshot_read_barrier_interval__.is_some() {
13414 return Err(serde::de::Error::duplicate_field("snapshotReadBarrierInterval"));
13415 }
13416 snapshot_read_barrier_interval__ =
13417 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13418 ;
13419 }
13420 GeneratedField::ArrangementTable => {
13421 if arrangement_table__.is_some() {
13422 return Err(serde::de::Error::duplicate_field("arrangementTable"));
13423 }
13424 arrangement_table__ = map_.next_value()?;
13425 }
13426 GeneratedField::SnapshotBackfillEpoch => {
13427 if snapshot_backfill_epoch__.is_some() {
13428 return Err(serde::de::Error::duplicate_field("snapshotBackfillEpoch"));
13429 }
13430 snapshot_backfill_epoch__ =
13431 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13432 ;
13433 }
13434 }
13435 }
13436 Ok(StreamScanNode {
13437 table_id: table_id__.unwrap_or_default(),
13438 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
13439 output_indices: output_indices__.unwrap_or_default(),
13440 stream_scan_type: stream_scan_type__.unwrap_or_default(),
13441 state_table: state_table__,
13442 table_desc: table_desc__,
13443 rate_limit: rate_limit__,
13444 snapshot_read_barrier_interval: snapshot_read_barrier_interval__.unwrap_or_default(),
13445 arrangement_table: arrangement_table__,
13446 snapshot_backfill_epoch: snapshot_backfill_epoch__,
13447 })
13448 }
13449 }
13450 deserializer.deserialize_struct("stream_plan.StreamScanNode", FIELDS, GeneratedVisitor)
13451 }
13452}
13453impl serde::Serialize for StreamScanType {
13454 #[allow(deprecated)]
13455 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13456 where
13457 S: serde::Serializer,
13458 {
13459 let variant = match self {
13460 Self::Unspecified => "STREAM_SCAN_TYPE_UNSPECIFIED",
13461 Self::Chain => "STREAM_SCAN_TYPE_CHAIN",
13462 Self::Rearrange => "STREAM_SCAN_TYPE_REARRANGE",
13463 Self::Backfill => "STREAM_SCAN_TYPE_BACKFILL",
13464 Self::UpstreamOnly => "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
13465 Self::ArrangementBackfill => "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
13466 Self::SnapshotBackfill => "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
13467 Self::CrossDbSnapshotBackfill => "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
13468 };
13469 serializer.serialize_str(variant)
13470 }
13471}
13472impl<'de> serde::Deserialize<'de> for StreamScanType {
13473 #[allow(deprecated)]
13474 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13475 where
13476 D: serde::Deserializer<'de>,
13477 {
13478 const FIELDS: &[&str] = &[
13479 "STREAM_SCAN_TYPE_UNSPECIFIED",
13480 "STREAM_SCAN_TYPE_CHAIN",
13481 "STREAM_SCAN_TYPE_REARRANGE",
13482 "STREAM_SCAN_TYPE_BACKFILL",
13483 "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
13484 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
13485 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
13486 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
13487 ];
13488
13489 struct GeneratedVisitor;
13490
13491 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13492 type Value = StreamScanType;
13493
13494 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13495 write!(formatter, "expected one of: {:?}", &FIELDS)
13496 }
13497
13498 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13499 where
13500 E: serde::de::Error,
13501 {
13502 i32::try_from(v)
13503 .ok()
13504 .and_then(|x| x.try_into().ok())
13505 .ok_or_else(|| {
13506 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13507 })
13508 }
13509
13510 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13511 where
13512 E: serde::de::Error,
13513 {
13514 i32::try_from(v)
13515 .ok()
13516 .and_then(|x| x.try_into().ok())
13517 .ok_or_else(|| {
13518 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13519 })
13520 }
13521
13522 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13523 where
13524 E: serde::de::Error,
13525 {
13526 match value {
13527 "STREAM_SCAN_TYPE_UNSPECIFIED" => Ok(StreamScanType::Unspecified),
13528 "STREAM_SCAN_TYPE_CHAIN" => Ok(StreamScanType::Chain),
13529 "STREAM_SCAN_TYPE_REARRANGE" => Ok(StreamScanType::Rearrange),
13530 "STREAM_SCAN_TYPE_BACKFILL" => Ok(StreamScanType::Backfill),
13531 "STREAM_SCAN_TYPE_UPSTREAM_ONLY" => Ok(StreamScanType::UpstreamOnly),
13532 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL" => Ok(StreamScanType::ArrangementBackfill),
13533 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL" => Ok(StreamScanType::SnapshotBackfill),
13534 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL" => Ok(StreamScanType::CrossDbSnapshotBackfill),
13535 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13536 }
13537 }
13538 }
13539 deserializer.deserialize_any(GeneratedVisitor)
13540 }
13541}
13542impl serde::Serialize for StreamSource {
13543 #[allow(deprecated)]
13544 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13545 where
13546 S: serde::Serializer,
13547 {
13548 use serde::ser::SerializeStruct;
13549 let mut len = 0;
13550 if self.source_id != 0 {
13551 len += 1;
13552 }
13553 if self.state_table.is_some() {
13554 len += 1;
13555 }
13556 if self.row_id_index.is_some() {
13557 len += 1;
13558 }
13559 if !self.columns.is_empty() {
13560 len += 1;
13561 }
13562 if !self.with_properties.is_empty() {
13563 len += 1;
13564 }
13565 if self.info.is_some() {
13566 len += 1;
13567 }
13568 if !self.source_name.is_empty() {
13569 len += 1;
13570 }
13571 if self.rate_limit.is_some() {
13572 len += 1;
13573 }
13574 if !self.secret_refs.is_empty() {
13575 len += 1;
13576 }
13577 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamSource", len)?;
13578 if self.source_id != 0 {
13579 struct_ser.serialize_field("sourceId", &self.source_id)?;
13580 }
13581 if let Some(v) = self.state_table.as_ref() {
13582 struct_ser.serialize_field("stateTable", v)?;
13583 }
13584 if let Some(v) = self.row_id_index.as_ref() {
13585 struct_ser.serialize_field("rowIdIndex", v)?;
13586 }
13587 if !self.columns.is_empty() {
13588 struct_ser.serialize_field("columns", &self.columns)?;
13589 }
13590 if !self.with_properties.is_empty() {
13591 struct_ser.serialize_field("withProperties", &self.with_properties)?;
13592 }
13593 if let Some(v) = self.info.as_ref() {
13594 struct_ser.serialize_field("info", v)?;
13595 }
13596 if !self.source_name.is_empty() {
13597 struct_ser.serialize_field("sourceName", &self.source_name)?;
13598 }
13599 if let Some(v) = self.rate_limit.as_ref() {
13600 struct_ser.serialize_field("rateLimit", v)?;
13601 }
13602 if !self.secret_refs.is_empty() {
13603 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
13604 }
13605 struct_ser.end()
13606 }
13607}
13608impl<'de> serde::Deserialize<'de> for StreamSource {
13609 #[allow(deprecated)]
13610 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13611 where
13612 D: serde::Deserializer<'de>,
13613 {
13614 const FIELDS: &[&str] = &[
13615 "source_id",
13616 "sourceId",
13617 "state_table",
13618 "stateTable",
13619 "row_id_index",
13620 "rowIdIndex",
13621 "columns",
13622 "with_properties",
13623 "withProperties",
13624 "info",
13625 "source_name",
13626 "sourceName",
13627 "rate_limit",
13628 "rateLimit",
13629 "secret_refs",
13630 "secretRefs",
13631 ];
13632
13633 #[allow(clippy::enum_variant_names)]
13634 enum GeneratedField {
13635 SourceId,
13636 StateTable,
13637 RowIdIndex,
13638 Columns,
13639 WithProperties,
13640 Info,
13641 SourceName,
13642 RateLimit,
13643 SecretRefs,
13644 }
13645 impl<'de> serde::Deserialize<'de> for GeneratedField {
13646 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13647 where
13648 D: serde::Deserializer<'de>,
13649 {
13650 struct GeneratedVisitor;
13651
13652 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13653 type Value = GeneratedField;
13654
13655 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13656 write!(formatter, "expected one of: {:?}", &FIELDS)
13657 }
13658
13659 #[allow(unused_variables)]
13660 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13661 where
13662 E: serde::de::Error,
13663 {
13664 match value {
13665 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
13666 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
13667 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
13668 "columns" => Ok(GeneratedField::Columns),
13669 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
13670 "info" => Ok(GeneratedField::Info),
13671 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
13672 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
13673 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
13674 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13675 }
13676 }
13677 }
13678 deserializer.deserialize_identifier(GeneratedVisitor)
13679 }
13680 }
13681 struct GeneratedVisitor;
13682 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13683 type Value = StreamSource;
13684
13685 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13686 formatter.write_str("struct stream_plan.StreamSource")
13687 }
13688
13689 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSource, V::Error>
13690 where
13691 V: serde::de::MapAccess<'de>,
13692 {
13693 let mut source_id__ = None;
13694 let mut state_table__ = None;
13695 let mut row_id_index__ = None;
13696 let mut columns__ = None;
13697 let mut with_properties__ = None;
13698 let mut info__ = None;
13699 let mut source_name__ = None;
13700 let mut rate_limit__ = None;
13701 let mut secret_refs__ = None;
13702 while let Some(k) = map_.next_key()? {
13703 match k {
13704 GeneratedField::SourceId => {
13705 if source_id__.is_some() {
13706 return Err(serde::de::Error::duplicate_field("sourceId"));
13707 }
13708 source_id__ =
13709 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13710 ;
13711 }
13712 GeneratedField::StateTable => {
13713 if state_table__.is_some() {
13714 return Err(serde::de::Error::duplicate_field("stateTable"));
13715 }
13716 state_table__ = map_.next_value()?;
13717 }
13718 GeneratedField::RowIdIndex => {
13719 if row_id_index__.is_some() {
13720 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
13721 }
13722 row_id_index__ =
13723 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13724 ;
13725 }
13726 GeneratedField::Columns => {
13727 if columns__.is_some() {
13728 return Err(serde::de::Error::duplicate_field("columns"));
13729 }
13730 columns__ = Some(map_.next_value()?);
13731 }
13732 GeneratedField::WithProperties => {
13733 if with_properties__.is_some() {
13734 return Err(serde::de::Error::duplicate_field("withProperties"));
13735 }
13736 with_properties__ = Some(
13737 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13738 );
13739 }
13740 GeneratedField::Info => {
13741 if info__.is_some() {
13742 return Err(serde::de::Error::duplicate_field("info"));
13743 }
13744 info__ = map_.next_value()?;
13745 }
13746 GeneratedField::SourceName => {
13747 if source_name__.is_some() {
13748 return Err(serde::de::Error::duplicate_field("sourceName"));
13749 }
13750 source_name__ = Some(map_.next_value()?);
13751 }
13752 GeneratedField::RateLimit => {
13753 if rate_limit__.is_some() {
13754 return Err(serde::de::Error::duplicate_field("rateLimit"));
13755 }
13756 rate_limit__ =
13757 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13758 ;
13759 }
13760 GeneratedField::SecretRefs => {
13761 if secret_refs__.is_some() {
13762 return Err(serde::de::Error::duplicate_field("secretRefs"));
13763 }
13764 secret_refs__ = Some(
13765 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13766 );
13767 }
13768 }
13769 }
13770 Ok(StreamSource {
13771 source_id: source_id__.unwrap_or_default(),
13772 state_table: state_table__,
13773 row_id_index: row_id_index__,
13774 columns: columns__.unwrap_or_default(),
13775 with_properties: with_properties__.unwrap_or_default(),
13776 info: info__,
13777 source_name: source_name__.unwrap_or_default(),
13778 rate_limit: rate_limit__,
13779 secret_refs: secret_refs__.unwrap_or_default(),
13780 })
13781 }
13782 }
13783 deserializer.deserialize_struct("stream_plan.StreamSource", FIELDS, GeneratedVisitor)
13784 }
13785}
13786impl serde::Serialize for SubscriptionUpstreamInfo {
13787 #[allow(deprecated)]
13788 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13789 where
13790 S: serde::Serializer,
13791 {
13792 use serde::ser::SerializeStruct;
13793 let mut len = 0;
13794 if self.subscriber_id != 0 {
13795 len += 1;
13796 }
13797 if self.upstream_mv_table_id != 0 {
13798 len += 1;
13799 }
13800 let mut struct_ser = serializer.serialize_struct("stream_plan.SubscriptionUpstreamInfo", len)?;
13801 if self.subscriber_id != 0 {
13802 struct_ser.serialize_field("subscriberId", &self.subscriber_id)?;
13803 }
13804 if self.upstream_mv_table_id != 0 {
13805 struct_ser.serialize_field("upstreamMvTableId", &self.upstream_mv_table_id)?;
13806 }
13807 struct_ser.end()
13808 }
13809}
13810impl<'de> serde::Deserialize<'de> for SubscriptionUpstreamInfo {
13811 #[allow(deprecated)]
13812 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13813 where
13814 D: serde::Deserializer<'de>,
13815 {
13816 const FIELDS: &[&str] = &[
13817 "subscriber_id",
13818 "subscriberId",
13819 "upstream_mv_table_id",
13820 "upstreamMvTableId",
13821 ];
13822
13823 #[allow(clippy::enum_variant_names)]
13824 enum GeneratedField {
13825 SubscriberId,
13826 UpstreamMvTableId,
13827 }
13828 impl<'de> serde::Deserialize<'de> for GeneratedField {
13829 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13830 where
13831 D: serde::Deserializer<'de>,
13832 {
13833 struct GeneratedVisitor;
13834
13835 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13836 type Value = GeneratedField;
13837
13838 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13839 write!(formatter, "expected one of: {:?}", &FIELDS)
13840 }
13841
13842 #[allow(unused_variables)]
13843 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13844 where
13845 E: serde::de::Error,
13846 {
13847 match value {
13848 "subscriberId" | "subscriber_id" => Ok(GeneratedField::SubscriberId),
13849 "upstreamMvTableId" | "upstream_mv_table_id" => Ok(GeneratedField::UpstreamMvTableId),
13850 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13851 }
13852 }
13853 }
13854 deserializer.deserialize_identifier(GeneratedVisitor)
13855 }
13856 }
13857 struct GeneratedVisitor;
13858 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13859 type Value = SubscriptionUpstreamInfo;
13860
13861 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13862 formatter.write_str("struct stream_plan.SubscriptionUpstreamInfo")
13863 }
13864
13865 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscriptionUpstreamInfo, V::Error>
13866 where
13867 V: serde::de::MapAccess<'de>,
13868 {
13869 let mut subscriber_id__ = None;
13870 let mut upstream_mv_table_id__ = None;
13871 while let Some(k) = map_.next_key()? {
13872 match k {
13873 GeneratedField::SubscriberId => {
13874 if subscriber_id__.is_some() {
13875 return Err(serde::de::Error::duplicate_field("subscriberId"));
13876 }
13877 subscriber_id__ =
13878 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13879 ;
13880 }
13881 GeneratedField::UpstreamMvTableId => {
13882 if upstream_mv_table_id__.is_some() {
13883 return Err(serde::de::Error::duplicate_field("upstreamMvTableId"));
13884 }
13885 upstream_mv_table_id__ =
13886 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13887 ;
13888 }
13889 }
13890 }
13891 Ok(SubscriptionUpstreamInfo {
13892 subscriber_id: subscriber_id__.unwrap_or_default(),
13893 upstream_mv_table_id: upstream_mv_table_id__.unwrap_or_default(),
13894 })
13895 }
13896 }
13897 deserializer.deserialize_struct("stream_plan.SubscriptionUpstreamInfo", FIELDS, GeneratedVisitor)
13898 }
13899}
13900impl serde::Serialize for SyncLogStoreNode {
13901 #[allow(deprecated)]
13902 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13903 where
13904 S: serde::Serializer,
13905 {
13906 use serde::ser::SerializeStruct;
13907 let mut len = 0;
13908 if self.log_store_table.is_some() {
13909 len += 1;
13910 }
13911 if self.pause_duration_ms != 0 {
13912 len += 1;
13913 }
13914 if self.buffer_size != 0 {
13915 len += 1;
13916 }
13917 if self.aligned {
13918 len += 1;
13919 }
13920 let mut struct_ser = serializer.serialize_struct("stream_plan.SyncLogStoreNode", len)?;
13921 if let Some(v) = self.log_store_table.as_ref() {
13922 struct_ser.serialize_field("logStoreTable", v)?;
13923 }
13924 if self.pause_duration_ms != 0 {
13925 struct_ser.serialize_field("pauseDurationMs", &self.pause_duration_ms)?;
13926 }
13927 if self.buffer_size != 0 {
13928 struct_ser.serialize_field("bufferSize", &self.buffer_size)?;
13929 }
13930 if self.aligned {
13931 struct_ser.serialize_field("aligned", &self.aligned)?;
13932 }
13933 struct_ser.end()
13934 }
13935}
13936impl<'de> serde::Deserialize<'de> for SyncLogStoreNode {
13937 #[allow(deprecated)]
13938 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13939 where
13940 D: serde::Deserializer<'de>,
13941 {
13942 const FIELDS: &[&str] = &[
13943 "log_store_table",
13944 "logStoreTable",
13945 "pause_duration_ms",
13946 "pauseDurationMs",
13947 "buffer_size",
13948 "bufferSize",
13949 "aligned",
13950 ];
13951
13952 #[allow(clippy::enum_variant_names)]
13953 enum GeneratedField {
13954 LogStoreTable,
13955 PauseDurationMs,
13956 BufferSize,
13957 Aligned,
13958 }
13959 impl<'de> serde::Deserialize<'de> for GeneratedField {
13960 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13961 where
13962 D: serde::Deserializer<'de>,
13963 {
13964 struct GeneratedVisitor;
13965
13966 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13967 type Value = GeneratedField;
13968
13969 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13970 write!(formatter, "expected one of: {:?}", &FIELDS)
13971 }
13972
13973 #[allow(unused_variables)]
13974 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13975 where
13976 E: serde::de::Error,
13977 {
13978 match value {
13979 "logStoreTable" | "log_store_table" => Ok(GeneratedField::LogStoreTable),
13980 "pauseDurationMs" | "pause_duration_ms" => Ok(GeneratedField::PauseDurationMs),
13981 "bufferSize" | "buffer_size" => Ok(GeneratedField::BufferSize),
13982 "aligned" => Ok(GeneratedField::Aligned),
13983 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13984 }
13985 }
13986 }
13987 deserializer.deserialize_identifier(GeneratedVisitor)
13988 }
13989 }
13990 struct GeneratedVisitor;
13991 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13992 type Value = SyncLogStoreNode;
13993
13994 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13995 formatter.write_str("struct stream_plan.SyncLogStoreNode")
13996 }
13997
13998 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SyncLogStoreNode, V::Error>
13999 where
14000 V: serde::de::MapAccess<'de>,
14001 {
14002 let mut log_store_table__ = None;
14003 let mut pause_duration_ms__ = None;
14004 let mut buffer_size__ = None;
14005 let mut aligned__ = None;
14006 while let Some(k) = map_.next_key()? {
14007 match k {
14008 GeneratedField::LogStoreTable => {
14009 if log_store_table__.is_some() {
14010 return Err(serde::de::Error::duplicate_field("logStoreTable"));
14011 }
14012 log_store_table__ = map_.next_value()?;
14013 }
14014 GeneratedField::PauseDurationMs => {
14015 if pause_duration_ms__.is_some() {
14016 return Err(serde::de::Error::duplicate_field("pauseDurationMs"));
14017 }
14018 pause_duration_ms__ =
14019 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14020 ;
14021 }
14022 GeneratedField::BufferSize => {
14023 if buffer_size__.is_some() {
14024 return Err(serde::de::Error::duplicate_field("bufferSize"));
14025 }
14026 buffer_size__ =
14027 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14028 ;
14029 }
14030 GeneratedField::Aligned => {
14031 if aligned__.is_some() {
14032 return Err(serde::de::Error::duplicate_field("aligned"));
14033 }
14034 aligned__ = Some(map_.next_value()?);
14035 }
14036 }
14037 }
14038 Ok(SyncLogStoreNode {
14039 log_store_table: log_store_table__,
14040 pause_duration_ms: pause_duration_ms__.unwrap_or_default(),
14041 buffer_size: buffer_size__.unwrap_or_default(),
14042 aligned: aligned__.unwrap_or_default(),
14043 })
14044 }
14045 }
14046 deserializer.deserialize_struct("stream_plan.SyncLogStoreNode", FIELDS, GeneratedVisitor)
14047 }
14048}
14049impl serde::Serialize for TemporalJoinNode {
14050 #[allow(deprecated)]
14051 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14052 where
14053 S: serde::Serializer,
14054 {
14055 use serde::ser::SerializeStruct;
14056 let mut len = 0;
14057 if self.join_type != 0 {
14058 len += 1;
14059 }
14060 if !self.left_key.is_empty() {
14061 len += 1;
14062 }
14063 if !self.right_key.is_empty() {
14064 len += 1;
14065 }
14066 if !self.null_safe.is_empty() {
14067 len += 1;
14068 }
14069 if self.condition.is_some() {
14070 len += 1;
14071 }
14072 if !self.output_indices.is_empty() {
14073 len += 1;
14074 }
14075 if self.table_desc.is_some() {
14076 len += 1;
14077 }
14078 if !self.table_output_indices.is_empty() {
14079 len += 1;
14080 }
14081 if self.memo_table.is_some() {
14082 len += 1;
14083 }
14084 if self.is_nested_loop {
14085 len += 1;
14086 }
14087 let mut struct_ser = serializer.serialize_struct("stream_plan.TemporalJoinNode", len)?;
14088 if self.join_type != 0 {
14089 let v = super::plan_common::JoinType::try_from(self.join_type)
14090 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
14091 struct_ser.serialize_field("joinType", &v)?;
14092 }
14093 if !self.left_key.is_empty() {
14094 struct_ser.serialize_field("leftKey", &self.left_key)?;
14095 }
14096 if !self.right_key.is_empty() {
14097 struct_ser.serialize_field("rightKey", &self.right_key)?;
14098 }
14099 if !self.null_safe.is_empty() {
14100 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
14101 }
14102 if let Some(v) = self.condition.as_ref() {
14103 struct_ser.serialize_field("condition", v)?;
14104 }
14105 if !self.output_indices.is_empty() {
14106 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
14107 }
14108 if let Some(v) = self.table_desc.as_ref() {
14109 struct_ser.serialize_field("tableDesc", v)?;
14110 }
14111 if !self.table_output_indices.is_empty() {
14112 struct_ser.serialize_field("tableOutputIndices", &self.table_output_indices)?;
14113 }
14114 if let Some(v) = self.memo_table.as_ref() {
14115 struct_ser.serialize_field("memoTable", v)?;
14116 }
14117 if self.is_nested_loop {
14118 struct_ser.serialize_field("isNestedLoop", &self.is_nested_loop)?;
14119 }
14120 struct_ser.end()
14121 }
14122}
14123impl<'de> serde::Deserialize<'de> for TemporalJoinNode {
14124 #[allow(deprecated)]
14125 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14126 where
14127 D: serde::Deserializer<'de>,
14128 {
14129 const FIELDS: &[&str] = &[
14130 "join_type",
14131 "joinType",
14132 "left_key",
14133 "leftKey",
14134 "right_key",
14135 "rightKey",
14136 "null_safe",
14137 "nullSafe",
14138 "condition",
14139 "output_indices",
14140 "outputIndices",
14141 "table_desc",
14142 "tableDesc",
14143 "table_output_indices",
14144 "tableOutputIndices",
14145 "memo_table",
14146 "memoTable",
14147 "is_nested_loop",
14148 "isNestedLoop",
14149 ];
14150
14151 #[allow(clippy::enum_variant_names)]
14152 enum GeneratedField {
14153 JoinType,
14154 LeftKey,
14155 RightKey,
14156 NullSafe,
14157 Condition,
14158 OutputIndices,
14159 TableDesc,
14160 TableOutputIndices,
14161 MemoTable,
14162 IsNestedLoop,
14163 }
14164 impl<'de> serde::Deserialize<'de> for GeneratedField {
14165 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14166 where
14167 D: serde::Deserializer<'de>,
14168 {
14169 struct GeneratedVisitor;
14170
14171 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14172 type Value = GeneratedField;
14173
14174 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14175 write!(formatter, "expected one of: {:?}", &FIELDS)
14176 }
14177
14178 #[allow(unused_variables)]
14179 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14180 where
14181 E: serde::de::Error,
14182 {
14183 match value {
14184 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
14185 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
14186 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
14187 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
14188 "condition" => Ok(GeneratedField::Condition),
14189 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
14190 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
14191 "tableOutputIndices" | "table_output_indices" => Ok(GeneratedField::TableOutputIndices),
14192 "memoTable" | "memo_table" => Ok(GeneratedField::MemoTable),
14193 "isNestedLoop" | "is_nested_loop" => Ok(GeneratedField::IsNestedLoop),
14194 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14195 }
14196 }
14197 }
14198 deserializer.deserialize_identifier(GeneratedVisitor)
14199 }
14200 }
14201 struct GeneratedVisitor;
14202 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14203 type Value = TemporalJoinNode;
14204
14205 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14206 formatter.write_str("struct stream_plan.TemporalJoinNode")
14207 }
14208
14209 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TemporalJoinNode, V::Error>
14210 where
14211 V: serde::de::MapAccess<'de>,
14212 {
14213 let mut join_type__ = None;
14214 let mut left_key__ = None;
14215 let mut right_key__ = None;
14216 let mut null_safe__ = None;
14217 let mut condition__ = None;
14218 let mut output_indices__ = None;
14219 let mut table_desc__ = None;
14220 let mut table_output_indices__ = None;
14221 let mut memo_table__ = None;
14222 let mut is_nested_loop__ = None;
14223 while let Some(k) = map_.next_key()? {
14224 match k {
14225 GeneratedField::JoinType => {
14226 if join_type__.is_some() {
14227 return Err(serde::de::Error::duplicate_field("joinType"));
14228 }
14229 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
14230 }
14231 GeneratedField::LeftKey => {
14232 if left_key__.is_some() {
14233 return Err(serde::de::Error::duplicate_field("leftKey"));
14234 }
14235 left_key__ =
14236 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14237 .into_iter().map(|x| x.0).collect())
14238 ;
14239 }
14240 GeneratedField::RightKey => {
14241 if right_key__.is_some() {
14242 return Err(serde::de::Error::duplicate_field("rightKey"));
14243 }
14244 right_key__ =
14245 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14246 .into_iter().map(|x| x.0).collect())
14247 ;
14248 }
14249 GeneratedField::NullSafe => {
14250 if null_safe__.is_some() {
14251 return Err(serde::de::Error::duplicate_field("nullSafe"));
14252 }
14253 null_safe__ = Some(map_.next_value()?);
14254 }
14255 GeneratedField::Condition => {
14256 if condition__.is_some() {
14257 return Err(serde::de::Error::duplicate_field("condition"));
14258 }
14259 condition__ = map_.next_value()?;
14260 }
14261 GeneratedField::OutputIndices => {
14262 if output_indices__.is_some() {
14263 return Err(serde::de::Error::duplicate_field("outputIndices"));
14264 }
14265 output_indices__ =
14266 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14267 .into_iter().map(|x| x.0).collect())
14268 ;
14269 }
14270 GeneratedField::TableDesc => {
14271 if table_desc__.is_some() {
14272 return Err(serde::de::Error::duplicate_field("tableDesc"));
14273 }
14274 table_desc__ = map_.next_value()?;
14275 }
14276 GeneratedField::TableOutputIndices => {
14277 if table_output_indices__.is_some() {
14278 return Err(serde::de::Error::duplicate_field("tableOutputIndices"));
14279 }
14280 table_output_indices__ =
14281 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14282 .into_iter().map(|x| x.0).collect())
14283 ;
14284 }
14285 GeneratedField::MemoTable => {
14286 if memo_table__.is_some() {
14287 return Err(serde::de::Error::duplicate_field("memoTable"));
14288 }
14289 memo_table__ = map_.next_value()?;
14290 }
14291 GeneratedField::IsNestedLoop => {
14292 if is_nested_loop__.is_some() {
14293 return Err(serde::de::Error::duplicate_field("isNestedLoop"));
14294 }
14295 is_nested_loop__ = Some(map_.next_value()?);
14296 }
14297 }
14298 }
14299 Ok(TemporalJoinNode {
14300 join_type: join_type__.unwrap_or_default(),
14301 left_key: left_key__.unwrap_or_default(),
14302 right_key: right_key__.unwrap_or_default(),
14303 null_safe: null_safe__.unwrap_or_default(),
14304 condition: condition__,
14305 output_indices: output_indices__.unwrap_or_default(),
14306 table_desc: table_desc__,
14307 table_output_indices: table_output_indices__.unwrap_or_default(),
14308 memo_table: memo_table__,
14309 is_nested_loop: is_nested_loop__.unwrap_or_default(),
14310 })
14311 }
14312 }
14313 deserializer.deserialize_struct("stream_plan.TemporalJoinNode", FIELDS, GeneratedVisitor)
14314 }
14315}
14316impl serde::Serialize for ThrottleMutation {
14317 #[allow(deprecated)]
14318 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14319 where
14320 S: serde::Serializer,
14321 {
14322 use serde::ser::SerializeStruct;
14323 let mut len = 0;
14324 if !self.actor_throttle.is_empty() {
14325 len += 1;
14326 }
14327 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation", len)?;
14328 if !self.actor_throttle.is_empty() {
14329 struct_ser.serialize_field("actorThrottle", &self.actor_throttle)?;
14330 }
14331 struct_ser.end()
14332 }
14333}
14334impl<'de> serde::Deserialize<'de> for ThrottleMutation {
14335 #[allow(deprecated)]
14336 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14337 where
14338 D: serde::Deserializer<'de>,
14339 {
14340 const FIELDS: &[&str] = &[
14341 "actor_throttle",
14342 "actorThrottle",
14343 ];
14344
14345 #[allow(clippy::enum_variant_names)]
14346 enum GeneratedField {
14347 ActorThrottle,
14348 }
14349 impl<'de> serde::Deserialize<'de> for GeneratedField {
14350 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14351 where
14352 D: serde::Deserializer<'de>,
14353 {
14354 struct GeneratedVisitor;
14355
14356 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14357 type Value = GeneratedField;
14358
14359 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14360 write!(formatter, "expected one of: {:?}", &FIELDS)
14361 }
14362
14363 #[allow(unused_variables)]
14364 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14365 where
14366 E: serde::de::Error,
14367 {
14368 match value {
14369 "actorThrottle" | "actor_throttle" => Ok(GeneratedField::ActorThrottle),
14370 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14371 }
14372 }
14373 }
14374 deserializer.deserialize_identifier(GeneratedVisitor)
14375 }
14376 }
14377 struct GeneratedVisitor;
14378 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14379 type Value = ThrottleMutation;
14380
14381 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14382 formatter.write_str("struct stream_plan.ThrottleMutation")
14383 }
14384
14385 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ThrottleMutation, V::Error>
14386 where
14387 V: serde::de::MapAccess<'de>,
14388 {
14389 let mut actor_throttle__ = None;
14390 while let Some(k) = map_.next_key()? {
14391 match k {
14392 GeneratedField::ActorThrottle => {
14393 if actor_throttle__.is_some() {
14394 return Err(serde::de::Error::duplicate_field("actorThrottle"));
14395 }
14396 actor_throttle__ = Some(
14397 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14398 .into_iter().map(|(k,v)| (k.0, v)).collect()
14399 );
14400 }
14401 }
14402 }
14403 Ok(ThrottleMutation {
14404 actor_throttle: actor_throttle__.unwrap_or_default(),
14405 })
14406 }
14407 }
14408 deserializer.deserialize_struct("stream_plan.ThrottleMutation", FIELDS, GeneratedVisitor)
14409 }
14410}
14411impl serde::Serialize for throttle_mutation::RateLimit {
14412 #[allow(deprecated)]
14413 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14414 where
14415 S: serde::Serializer,
14416 {
14417 use serde::ser::SerializeStruct;
14418 let mut len = 0;
14419 if self.rate_limit.is_some() {
14420 len += 1;
14421 }
14422 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation.RateLimit", len)?;
14423 if let Some(v) = self.rate_limit.as_ref() {
14424 struct_ser.serialize_field("rateLimit", v)?;
14425 }
14426 struct_ser.end()
14427 }
14428}
14429impl<'de> serde::Deserialize<'de> for throttle_mutation::RateLimit {
14430 #[allow(deprecated)]
14431 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14432 where
14433 D: serde::Deserializer<'de>,
14434 {
14435 const FIELDS: &[&str] = &[
14436 "rate_limit",
14437 "rateLimit",
14438 ];
14439
14440 #[allow(clippy::enum_variant_names)]
14441 enum GeneratedField {
14442 RateLimit,
14443 }
14444 impl<'de> serde::Deserialize<'de> for GeneratedField {
14445 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14446 where
14447 D: serde::Deserializer<'de>,
14448 {
14449 struct GeneratedVisitor;
14450
14451 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14452 type Value = GeneratedField;
14453
14454 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14455 write!(formatter, "expected one of: {:?}", &FIELDS)
14456 }
14457
14458 #[allow(unused_variables)]
14459 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14460 where
14461 E: serde::de::Error,
14462 {
14463 match value {
14464 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
14465 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14466 }
14467 }
14468 }
14469 deserializer.deserialize_identifier(GeneratedVisitor)
14470 }
14471 }
14472 struct GeneratedVisitor;
14473 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14474 type Value = throttle_mutation::RateLimit;
14475
14476 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14477 formatter.write_str("struct stream_plan.ThrottleMutation.RateLimit")
14478 }
14479
14480 fn visit_map<V>(self, mut map_: V) -> std::result::Result<throttle_mutation::RateLimit, V::Error>
14481 where
14482 V: serde::de::MapAccess<'de>,
14483 {
14484 let mut rate_limit__ = None;
14485 while let Some(k) = map_.next_key()? {
14486 match k {
14487 GeneratedField::RateLimit => {
14488 if rate_limit__.is_some() {
14489 return Err(serde::de::Error::duplicate_field("rateLimit"));
14490 }
14491 rate_limit__ =
14492 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14493 ;
14494 }
14495 }
14496 }
14497 Ok(throttle_mutation::RateLimit {
14498 rate_limit: rate_limit__,
14499 })
14500 }
14501 }
14502 deserializer.deserialize_struct("stream_plan.ThrottleMutation.RateLimit", FIELDS, GeneratedVisitor)
14503 }
14504}
14505impl serde::Serialize for TopNNode {
14506 #[allow(deprecated)]
14507 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14508 where
14509 S: serde::Serializer,
14510 {
14511 use serde::ser::SerializeStruct;
14512 let mut len = 0;
14513 if self.limit != 0 {
14514 len += 1;
14515 }
14516 if self.offset != 0 {
14517 len += 1;
14518 }
14519 if self.table.is_some() {
14520 len += 1;
14521 }
14522 if !self.order_by.is_empty() {
14523 len += 1;
14524 }
14525 if self.with_ties {
14526 len += 1;
14527 }
14528 let mut struct_ser = serializer.serialize_struct("stream_plan.TopNNode", len)?;
14529 if self.limit != 0 {
14530 #[allow(clippy::needless_borrow)]
14531 #[allow(clippy::needless_borrows_for_generic_args)]
14532 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
14533 }
14534 if self.offset != 0 {
14535 #[allow(clippy::needless_borrow)]
14536 #[allow(clippy::needless_borrows_for_generic_args)]
14537 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
14538 }
14539 if let Some(v) = self.table.as_ref() {
14540 struct_ser.serialize_field("table", v)?;
14541 }
14542 if !self.order_by.is_empty() {
14543 struct_ser.serialize_field("orderBy", &self.order_by)?;
14544 }
14545 if self.with_ties {
14546 struct_ser.serialize_field("withTies", &self.with_ties)?;
14547 }
14548 struct_ser.end()
14549 }
14550}
14551impl<'de> serde::Deserialize<'de> for TopNNode {
14552 #[allow(deprecated)]
14553 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14554 where
14555 D: serde::Deserializer<'de>,
14556 {
14557 const FIELDS: &[&str] = &[
14558 "limit",
14559 "offset",
14560 "table",
14561 "order_by",
14562 "orderBy",
14563 "with_ties",
14564 "withTies",
14565 ];
14566
14567 #[allow(clippy::enum_variant_names)]
14568 enum GeneratedField {
14569 Limit,
14570 Offset,
14571 Table,
14572 OrderBy,
14573 WithTies,
14574 }
14575 impl<'de> serde::Deserialize<'de> for GeneratedField {
14576 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14577 where
14578 D: serde::Deserializer<'de>,
14579 {
14580 struct GeneratedVisitor;
14581
14582 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14583 type Value = GeneratedField;
14584
14585 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14586 write!(formatter, "expected one of: {:?}", &FIELDS)
14587 }
14588
14589 #[allow(unused_variables)]
14590 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14591 where
14592 E: serde::de::Error,
14593 {
14594 match value {
14595 "limit" => Ok(GeneratedField::Limit),
14596 "offset" => Ok(GeneratedField::Offset),
14597 "table" => Ok(GeneratedField::Table),
14598 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
14599 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
14600 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14601 }
14602 }
14603 }
14604 deserializer.deserialize_identifier(GeneratedVisitor)
14605 }
14606 }
14607 struct GeneratedVisitor;
14608 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14609 type Value = TopNNode;
14610
14611 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14612 formatter.write_str("struct stream_plan.TopNNode")
14613 }
14614
14615 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
14616 where
14617 V: serde::de::MapAccess<'de>,
14618 {
14619 let mut limit__ = None;
14620 let mut offset__ = None;
14621 let mut table__ = None;
14622 let mut order_by__ = None;
14623 let mut with_ties__ = None;
14624 while let Some(k) = map_.next_key()? {
14625 match k {
14626 GeneratedField::Limit => {
14627 if limit__.is_some() {
14628 return Err(serde::de::Error::duplicate_field("limit"));
14629 }
14630 limit__ =
14631 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14632 ;
14633 }
14634 GeneratedField::Offset => {
14635 if offset__.is_some() {
14636 return Err(serde::de::Error::duplicate_field("offset"));
14637 }
14638 offset__ =
14639 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14640 ;
14641 }
14642 GeneratedField::Table => {
14643 if table__.is_some() {
14644 return Err(serde::de::Error::duplicate_field("table"));
14645 }
14646 table__ = map_.next_value()?;
14647 }
14648 GeneratedField::OrderBy => {
14649 if order_by__.is_some() {
14650 return Err(serde::de::Error::duplicate_field("orderBy"));
14651 }
14652 order_by__ = Some(map_.next_value()?);
14653 }
14654 GeneratedField::WithTies => {
14655 if with_ties__.is_some() {
14656 return Err(serde::de::Error::duplicate_field("withTies"));
14657 }
14658 with_ties__ = Some(map_.next_value()?);
14659 }
14660 }
14661 }
14662 Ok(TopNNode {
14663 limit: limit__.unwrap_or_default(),
14664 offset: offset__.unwrap_or_default(),
14665 table: table__,
14666 order_by: order_by__.unwrap_or_default(),
14667 with_ties: with_ties__.unwrap_or_default(),
14668 })
14669 }
14670 }
14671 deserializer.deserialize_struct("stream_plan.TopNNode", FIELDS, GeneratedVisitor)
14672 }
14673}
14674impl serde::Serialize for UnionNode {
14675 #[allow(deprecated)]
14676 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14677 where
14678 S: serde::Serializer,
14679 {
14680 use serde::ser::SerializeStruct;
14681 let len = 0;
14682 let struct_ser = serializer.serialize_struct("stream_plan.UnionNode", len)?;
14683 struct_ser.end()
14684 }
14685}
14686impl<'de> serde::Deserialize<'de> for UnionNode {
14687 #[allow(deprecated)]
14688 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14689 where
14690 D: serde::Deserializer<'de>,
14691 {
14692 const FIELDS: &[&str] = &[
14693 ];
14694
14695 #[allow(clippy::enum_variant_names)]
14696 enum GeneratedField {
14697 }
14698 impl<'de> serde::Deserialize<'de> for GeneratedField {
14699 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14700 where
14701 D: serde::Deserializer<'de>,
14702 {
14703 struct GeneratedVisitor;
14704
14705 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14706 type Value = GeneratedField;
14707
14708 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14709 write!(formatter, "expected one of: {:?}", &FIELDS)
14710 }
14711
14712 #[allow(unused_variables)]
14713 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14714 where
14715 E: serde::de::Error,
14716 {
14717 Err(serde::de::Error::unknown_field(value, FIELDS))
14718 }
14719 }
14720 deserializer.deserialize_identifier(GeneratedVisitor)
14721 }
14722 }
14723 struct GeneratedVisitor;
14724 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14725 type Value = UnionNode;
14726
14727 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14728 formatter.write_str("struct stream_plan.UnionNode")
14729 }
14730
14731 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
14732 where
14733 V: serde::de::MapAccess<'de>,
14734 {
14735 while map_.next_key::<GeneratedField>()?.is_some() {
14736 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14737 }
14738 Ok(UnionNode {
14739 })
14740 }
14741 }
14742 deserializer.deserialize_struct("stream_plan.UnionNode", FIELDS, GeneratedVisitor)
14743 }
14744}
14745impl serde::Serialize for UpdateMutation {
14746 #[allow(deprecated)]
14747 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14748 where
14749 S: serde::Serializer,
14750 {
14751 use serde::ser::SerializeStruct;
14752 let mut len = 0;
14753 if !self.dispatcher_update.is_empty() {
14754 len += 1;
14755 }
14756 if !self.merge_update.is_empty() {
14757 len += 1;
14758 }
14759 if !self.actor_vnode_bitmap_update.is_empty() {
14760 len += 1;
14761 }
14762 if !self.dropped_actors.is_empty() {
14763 len += 1;
14764 }
14765 if !self.actor_splits.is_empty() {
14766 len += 1;
14767 }
14768 if !self.actor_new_dispatchers.is_empty() {
14769 len += 1;
14770 }
14771 if self.actor_cdc_table_snapshot_splits.is_some() {
14772 len += 1;
14773 }
14774 if !self.sink_add_columns.is_empty() {
14775 len += 1;
14776 }
14777 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation", len)?;
14778 if !self.dispatcher_update.is_empty() {
14779 struct_ser.serialize_field("dispatcherUpdate", &self.dispatcher_update)?;
14780 }
14781 if !self.merge_update.is_empty() {
14782 struct_ser.serialize_field("mergeUpdate", &self.merge_update)?;
14783 }
14784 if !self.actor_vnode_bitmap_update.is_empty() {
14785 struct_ser.serialize_field("actorVnodeBitmapUpdate", &self.actor_vnode_bitmap_update)?;
14786 }
14787 if !self.dropped_actors.is_empty() {
14788 struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
14789 }
14790 if !self.actor_splits.is_empty() {
14791 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
14792 }
14793 if !self.actor_new_dispatchers.is_empty() {
14794 struct_ser.serialize_field("actorNewDispatchers", &self.actor_new_dispatchers)?;
14795 }
14796 if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
14797 struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
14798 }
14799 if !self.sink_add_columns.is_empty() {
14800 struct_ser.serialize_field("sinkAddColumns", &self.sink_add_columns)?;
14801 }
14802 struct_ser.end()
14803 }
14804}
14805impl<'de> serde::Deserialize<'de> for UpdateMutation {
14806 #[allow(deprecated)]
14807 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14808 where
14809 D: serde::Deserializer<'de>,
14810 {
14811 const FIELDS: &[&str] = &[
14812 "dispatcher_update",
14813 "dispatcherUpdate",
14814 "merge_update",
14815 "mergeUpdate",
14816 "actor_vnode_bitmap_update",
14817 "actorVnodeBitmapUpdate",
14818 "dropped_actors",
14819 "droppedActors",
14820 "actor_splits",
14821 "actorSplits",
14822 "actor_new_dispatchers",
14823 "actorNewDispatchers",
14824 "actor_cdc_table_snapshot_splits",
14825 "actorCdcTableSnapshotSplits",
14826 "sink_add_columns",
14827 "sinkAddColumns",
14828 ];
14829
14830 #[allow(clippy::enum_variant_names)]
14831 enum GeneratedField {
14832 DispatcherUpdate,
14833 MergeUpdate,
14834 ActorVnodeBitmapUpdate,
14835 DroppedActors,
14836 ActorSplits,
14837 ActorNewDispatchers,
14838 ActorCdcTableSnapshotSplits,
14839 SinkAddColumns,
14840 }
14841 impl<'de> serde::Deserialize<'de> for GeneratedField {
14842 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14843 where
14844 D: serde::Deserializer<'de>,
14845 {
14846 struct GeneratedVisitor;
14847
14848 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14849 type Value = GeneratedField;
14850
14851 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14852 write!(formatter, "expected one of: {:?}", &FIELDS)
14853 }
14854
14855 #[allow(unused_variables)]
14856 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14857 where
14858 E: serde::de::Error,
14859 {
14860 match value {
14861 "dispatcherUpdate" | "dispatcher_update" => Ok(GeneratedField::DispatcherUpdate),
14862 "mergeUpdate" | "merge_update" => Ok(GeneratedField::MergeUpdate),
14863 "actorVnodeBitmapUpdate" | "actor_vnode_bitmap_update" => Ok(GeneratedField::ActorVnodeBitmapUpdate),
14864 "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
14865 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
14866 "actorNewDispatchers" | "actor_new_dispatchers" => Ok(GeneratedField::ActorNewDispatchers),
14867 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
14868 "sinkAddColumns" | "sink_add_columns" => Ok(GeneratedField::SinkAddColumns),
14869 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14870 }
14871 }
14872 }
14873 deserializer.deserialize_identifier(GeneratedVisitor)
14874 }
14875 }
14876 struct GeneratedVisitor;
14877 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14878 type Value = UpdateMutation;
14879
14880 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14881 formatter.write_str("struct stream_plan.UpdateMutation")
14882 }
14883
14884 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateMutation, V::Error>
14885 where
14886 V: serde::de::MapAccess<'de>,
14887 {
14888 let mut dispatcher_update__ = None;
14889 let mut merge_update__ = None;
14890 let mut actor_vnode_bitmap_update__ = None;
14891 let mut dropped_actors__ = None;
14892 let mut actor_splits__ = None;
14893 let mut actor_new_dispatchers__ = None;
14894 let mut actor_cdc_table_snapshot_splits__ = None;
14895 let mut sink_add_columns__ = None;
14896 while let Some(k) = map_.next_key()? {
14897 match k {
14898 GeneratedField::DispatcherUpdate => {
14899 if dispatcher_update__.is_some() {
14900 return Err(serde::de::Error::duplicate_field("dispatcherUpdate"));
14901 }
14902 dispatcher_update__ = Some(map_.next_value()?);
14903 }
14904 GeneratedField::MergeUpdate => {
14905 if merge_update__.is_some() {
14906 return Err(serde::de::Error::duplicate_field("mergeUpdate"));
14907 }
14908 merge_update__ = Some(map_.next_value()?);
14909 }
14910 GeneratedField::ActorVnodeBitmapUpdate => {
14911 if actor_vnode_bitmap_update__.is_some() {
14912 return Err(serde::de::Error::duplicate_field("actorVnodeBitmapUpdate"));
14913 }
14914 actor_vnode_bitmap_update__ = Some(
14915 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14916 .into_iter().map(|(k,v)| (k.0, v)).collect()
14917 );
14918 }
14919 GeneratedField::DroppedActors => {
14920 if dropped_actors__.is_some() {
14921 return Err(serde::de::Error::duplicate_field("droppedActors"));
14922 }
14923 dropped_actors__ =
14924 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14925 .into_iter().map(|x| x.0).collect())
14926 ;
14927 }
14928 GeneratedField::ActorSplits => {
14929 if actor_splits__.is_some() {
14930 return Err(serde::de::Error::duplicate_field("actorSplits"));
14931 }
14932 actor_splits__ = Some(
14933 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14934 .into_iter().map(|(k,v)| (k.0, v)).collect()
14935 );
14936 }
14937 GeneratedField::ActorNewDispatchers => {
14938 if actor_new_dispatchers__.is_some() {
14939 return Err(serde::de::Error::duplicate_field("actorNewDispatchers"));
14940 }
14941 actor_new_dispatchers__ = Some(
14942 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14943 .into_iter().map(|(k,v)| (k.0, v)).collect()
14944 );
14945 }
14946 GeneratedField::ActorCdcTableSnapshotSplits => {
14947 if actor_cdc_table_snapshot_splits__.is_some() {
14948 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
14949 }
14950 actor_cdc_table_snapshot_splits__ = map_.next_value()?;
14951 }
14952 GeneratedField::SinkAddColumns => {
14953 if sink_add_columns__.is_some() {
14954 return Err(serde::de::Error::duplicate_field("sinkAddColumns"));
14955 }
14956 sink_add_columns__ = Some(
14957 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14958 .into_iter().map(|(k,v)| (k.0, v)).collect()
14959 );
14960 }
14961 }
14962 }
14963 Ok(UpdateMutation {
14964 dispatcher_update: dispatcher_update__.unwrap_or_default(),
14965 merge_update: merge_update__.unwrap_or_default(),
14966 actor_vnode_bitmap_update: actor_vnode_bitmap_update__.unwrap_or_default(),
14967 dropped_actors: dropped_actors__.unwrap_or_default(),
14968 actor_splits: actor_splits__.unwrap_or_default(),
14969 actor_new_dispatchers: actor_new_dispatchers__.unwrap_or_default(),
14970 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
14971 sink_add_columns: sink_add_columns__.unwrap_or_default(),
14972 })
14973 }
14974 }
14975 deserializer.deserialize_struct("stream_plan.UpdateMutation", FIELDS, GeneratedVisitor)
14976 }
14977}
14978impl serde::Serialize for update_mutation::DispatcherUpdate {
14979 #[allow(deprecated)]
14980 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14981 where
14982 S: serde::Serializer,
14983 {
14984 use serde::ser::SerializeStruct;
14985 let mut len = 0;
14986 if self.actor_id != 0 {
14987 len += 1;
14988 }
14989 if self.dispatcher_id != 0 {
14990 len += 1;
14991 }
14992 if self.hash_mapping.is_some() {
14993 len += 1;
14994 }
14995 if !self.added_downstream_actor_id.is_empty() {
14996 len += 1;
14997 }
14998 if !self.removed_downstream_actor_id.is_empty() {
14999 len += 1;
15000 }
15001 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", len)?;
15002 if self.actor_id != 0 {
15003 struct_ser.serialize_field("actorId", &self.actor_id)?;
15004 }
15005 if self.dispatcher_id != 0 {
15006 #[allow(clippy::needless_borrow)]
15007 #[allow(clippy::needless_borrows_for_generic_args)]
15008 struct_ser.serialize_field("dispatcherId", ToString::to_string(&self.dispatcher_id).as_str())?;
15009 }
15010 if let Some(v) = self.hash_mapping.as_ref() {
15011 struct_ser.serialize_field("hashMapping", v)?;
15012 }
15013 if !self.added_downstream_actor_id.is_empty() {
15014 struct_ser.serialize_field("addedDownstreamActorId", &self.added_downstream_actor_id)?;
15015 }
15016 if !self.removed_downstream_actor_id.is_empty() {
15017 struct_ser.serialize_field("removedDownstreamActorId", &self.removed_downstream_actor_id)?;
15018 }
15019 struct_ser.end()
15020 }
15021}
15022impl<'de> serde::Deserialize<'de> for update_mutation::DispatcherUpdate {
15023 #[allow(deprecated)]
15024 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15025 where
15026 D: serde::Deserializer<'de>,
15027 {
15028 const FIELDS: &[&str] = &[
15029 "actor_id",
15030 "actorId",
15031 "dispatcher_id",
15032 "dispatcherId",
15033 "hash_mapping",
15034 "hashMapping",
15035 "added_downstream_actor_id",
15036 "addedDownstreamActorId",
15037 "removed_downstream_actor_id",
15038 "removedDownstreamActorId",
15039 ];
15040
15041 #[allow(clippy::enum_variant_names)]
15042 enum GeneratedField {
15043 ActorId,
15044 DispatcherId,
15045 HashMapping,
15046 AddedDownstreamActorId,
15047 RemovedDownstreamActorId,
15048 }
15049 impl<'de> serde::Deserialize<'de> for GeneratedField {
15050 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15051 where
15052 D: serde::Deserializer<'de>,
15053 {
15054 struct GeneratedVisitor;
15055
15056 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15057 type Value = GeneratedField;
15058
15059 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15060 write!(formatter, "expected one of: {:?}", &FIELDS)
15061 }
15062
15063 #[allow(unused_variables)]
15064 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15065 where
15066 E: serde::de::Error,
15067 {
15068 match value {
15069 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
15070 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
15071 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
15072 "addedDownstreamActorId" | "added_downstream_actor_id" => Ok(GeneratedField::AddedDownstreamActorId),
15073 "removedDownstreamActorId" | "removed_downstream_actor_id" => Ok(GeneratedField::RemovedDownstreamActorId),
15074 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15075 }
15076 }
15077 }
15078 deserializer.deserialize_identifier(GeneratedVisitor)
15079 }
15080 }
15081 struct GeneratedVisitor;
15082 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15083 type Value = update_mutation::DispatcherUpdate;
15084
15085 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15086 formatter.write_str("struct stream_plan.UpdateMutation.DispatcherUpdate")
15087 }
15088
15089 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::DispatcherUpdate, V::Error>
15090 where
15091 V: serde::de::MapAccess<'de>,
15092 {
15093 let mut actor_id__ = None;
15094 let mut dispatcher_id__ = None;
15095 let mut hash_mapping__ = None;
15096 let mut added_downstream_actor_id__ = None;
15097 let mut removed_downstream_actor_id__ = None;
15098 while let Some(k) = map_.next_key()? {
15099 match k {
15100 GeneratedField::ActorId => {
15101 if actor_id__.is_some() {
15102 return Err(serde::de::Error::duplicate_field("actorId"));
15103 }
15104 actor_id__ =
15105 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15106 ;
15107 }
15108 GeneratedField::DispatcherId => {
15109 if dispatcher_id__.is_some() {
15110 return Err(serde::de::Error::duplicate_field("dispatcherId"));
15111 }
15112 dispatcher_id__ =
15113 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15114 ;
15115 }
15116 GeneratedField::HashMapping => {
15117 if hash_mapping__.is_some() {
15118 return Err(serde::de::Error::duplicate_field("hashMapping"));
15119 }
15120 hash_mapping__ = map_.next_value()?;
15121 }
15122 GeneratedField::AddedDownstreamActorId => {
15123 if added_downstream_actor_id__.is_some() {
15124 return Err(serde::de::Error::duplicate_field("addedDownstreamActorId"));
15125 }
15126 added_downstream_actor_id__ =
15127 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15128 .into_iter().map(|x| x.0).collect())
15129 ;
15130 }
15131 GeneratedField::RemovedDownstreamActorId => {
15132 if removed_downstream_actor_id__.is_some() {
15133 return Err(serde::de::Error::duplicate_field("removedDownstreamActorId"));
15134 }
15135 removed_downstream_actor_id__ =
15136 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15137 .into_iter().map(|x| x.0).collect())
15138 ;
15139 }
15140 }
15141 }
15142 Ok(update_mutation::DispatcherUpdate {
15143 actor_id: actor_id__.unwrap_or_default(),
15144 dispatcher_id: dispatcher_id__.unwrap_or_default(),
15145 hash_mapping: hash_mapping__,
15146 added_downstream_actor_id: added_downstream_actor_id__.unwrap_or_default(),
15147 removed_downstream_actor_id: removed_downstream_actor_id__.unwrap_or_default(),
15148 })
15149 }
15150 }
15151 deserializer.deserialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", FIELDS, GeneratedVisitor)
15152 }
15153}
15154impl serde::Serialize for update_mutation::MergeUpdate {
15155 #[allow(deprecated)]
15156 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15157 where
15158 S: serde::Serializer,
15159 {
15160 use serde::ser::SerializeStruct;
15161 let mut len = 0;
15162 if self.actor_id != 0 {
15163 len += 1;
15164 }
15165 if self.upstream_fragment_id != 0 {
15166 len += 1;
15167 }
15168 if self.new_upstream_fragment_id.is_some() {
15169 len += 1;
15170 }
15171 if !self.added_upstream_actors.is_empty() {
15172 len += 1;
15173 }
15174 if !self.removed_upstream_actor_id.is_empty() {
15175 len += 1;
15176 }
15177 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.MergeUpdate", len)?;
15178 if self.actor_id != 0 {
15179 struct_ser.serialize_field("actorId", &self.actor_id)?;
15180 }
15181 if self.upstream_fragment_id != 0 {
15182 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
15183 }
15184 if let Some(v) = self.new_upstream_fragment_id.as_ref() {
15185 struct_ser.serialize_field("newUpstreamFragmentId", v)?;
15186 }
15187 if !self.added_upstream_actors.is_empty() {
15188 struct_ser.serialize_field("addedUpstreamActors", &self.added_upstream_actors)?;
15189 }
15190 if !self.removed_upstream_actor_id.is_empty() {
15191 struct_ser.serialize_field("removedUpstreamActorId", &self.removed_upstream_actor_id)?;
15192 }
15193 struct_ser.end()
15194 }
15195}
15196impl<'de> serde::Deserialize<'de> for update_mutation::MergeUpdate {
15197 #[allow(deprecated)]
15198 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15199 where
15200 D: serde::Deserializer<'de>,
15201 {
15202 const FIELDS: &[&str] = &[
15203 "actor_id",
15204 "actorId",
15205 "upstream_fragment_id",
15206 "upstreamFragmentId",
15207 "new_upstream_fragment_id",
15208 "newUpstreamFragmentId",
15209 "added_upstream_actors",
15210 "addedUpstreamActors",
15211 "removed_upstream_actor_id",
15212 "removedUpstreamActorId",
15213 ];
15214
15215 #[allow(clippy::enum_variant_names)]
15216 enum GeneratedField {
15217 ActorId,
15218 UpstreamFragmentId,
15219 NewUpstreamFragmentId,
15220 AddedUpstreamActors,
15221 RemovedUpstreamActorId,
15222 }
15223 impl<'de> serde::Deserialize<'de> for GeneratedField {
15224 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15225 where
15226 D: serde::Deserializer<'de>,
15227 {
15228 struct GeneratedVisitor;
15229
15230 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15231 type Value = GeneratedField;
15232
15233 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15234 write!(formatter, "expected one of: {:?}", &FIELDS)
15235 }
15236
15237 #[allow(unused_variables)]
15238 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15239 where
15240 E: serde::de::Error,
15241 {
15242 match value {
15243 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
15244 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
15245 "newUpstreamFragmentId" | "new_upstream_fragment_id" => Ok(GeneratedField::NewUpstreamFragmentId),
15246 "addedUpstreamActors" | "added_upstream_actors" => Ok(GeneratedField::AddedUpstreamActors),
15247 "removedUpstreamActorId" | "removed_upstream_actor_id" => Ok(GeneratedField::RemovedUpstreamActorId),
15248 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15249 }
15250 }
15251 }
15252 deserializer.deserialize_identifier(GeneratedVisitor)
15253 }
15254 }
15255 struct GeneratedVisitor;
15256 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15257 type Value = update_mutation::MergeUpdate;
15258
15259 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15260 formatter.write_str("struct stream_plan.UpdateMutation.MergeUpdate")
15261 }
15262
15263 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::MergeUpdate, V::Error>
15264 where
15265 V: serde::de::MapAccess<'de>,
15266 {
15267 let mut actor_id__ = None;
15268 let mut upstream_fragment_id__ = None;
15269 let mut new_upstream_fragment_id__ = None;
15270 let mut added_upstream_actors__ = None;
15271 let mut removed_upstream_actor_id__ = None;
15272 while let Some(k) = map_.next_key()? {
15273 match k {
15274 GeneratedField::ActorId => {
15275 if actor_id__.is_some() {
15276 return Err(serde::de::Error::duplicate_field("actorId"));
15277 }
15278 actor_id__ =
15279 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15280 ;
15281 }
15282 GeneratedField::UpstreamFragmentId => {
15283 if upstream_fragment_id__.is_some() {
15284 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
15285 }
15286 upstream_fragment_id__ =
15287 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15288 ;
15289 }
15290 GeneratedField::NewUpstreamFragmentId => {
15291 if new_upstream_fragment_id__.is_some() {
15292 return Err(serde::de::Error::duplicate_field("newUpstreamFragmentId"));
15293 }
15294 new_upstream_fragment_id__ =
15295 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15296 ;
15297 }
15298 GeneratedField::AddedUpstreamActors => {
15299 if added_upstream_actors__.is_some() {
15300 return Err(serde::de::Error::duplicate_field("addedUpstreamActors"));
15301 }
15302 added_upstream_actors__ = Some(map_.next_value()?);
15303 }
15304 GeneratedField::RemovedUpstreamActorId => {
15305 if removed_upstream_actor_id__.is_some() {
15306 return Err(serde::de::Error::duplicate_field("removedUpstreamActorId"));
15307 }
15308 removed_upstream_actor_id__ =
15309 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15310 .into_iter().map(|x| x.0).collect())
15311 ;
15312 }
15313 }
15314 }
15315 Ok(update_mutation::MergeUpdate {
15316 actor_id: actor_id__.unwrap_or_default(),
15317 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
15318 new_upstream_fragment_id: new_upstream_fragment_id__,
15319 added_upstream_actors: added_upstream_actors__.unwrap_or_default(),
15320 removed_upstream_actor_id: removed_upstream_actor_id__.unwrap_or_default(),
15321 })
15322 }
15323 }
15324 deserializer.deserialize_struct("stream_plan.UpdateMutation.MergeUpdate", FIELDS, GeneratedVisitor)
15325 }
15326}
15327impl serde::Serialize for UpstreamSinkInfo {
15328 #[allow(deprecated)]
15329 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15330 where
15331 S: serde::Serializer,
15332 {
15333 use serde::ser::SerializeStruct;
15334 let mut len = 0;
15335 if self.upstream_fragment_id != 0 {
15336 len += 1;
15337 }
15338 if !self.sink_output_schema.is_empty() {
15339 len += 1;
15340 }
15341 if !self.project_exprs.is_empty() {
15342 len += 1;
15343 }
15344 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkInfo", len)?;
15345 if self.upstream_fragment_id != 0 {
15346 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
15347 }
15348 if !self.sink_output_schema.is_empty() {
15349 struct_ser.serialize_field("sinkOutputSchema", &self.sink_output_schema)?;
15350 }
15351 if !self.project_exprs.is_empty() {
15352 struct_ser.serialize_field("projectExprs", &self.project_exprs)?;
15353 }
15354 struct_ser.end()
15355 }
15356}
15357impl<'de> serde::Deserialize<'de> for UpstreamSinkInfo {
15358 #[allow(deprecated)]
15359 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15360 where
15361 D: serde::Deserializer<'de>,
15362 {
15363 const FIELDS: &[&str] = &[
15364 "upstream_fragment_id",
15365 "upstreamFragmentId",
15366 "sink_output_schema",
15367 "sinkOutputSchema",
15368 "project_exprs",
15369 "projectExprs",
15370 ];
15371
15372 #[allow(clippy::enum_variant_names)]
15373 enum GeneratedField {
15374 UpstreamFragmentId,
15375 SinkOutputSchema,
15376 ProjectExprs,
15377 }
15378 impl<'de> serde::Deserialize<'de> for GeneratedField {
15379 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15380 where
15381 D: serde::Deserializer<'de>,
15382 {
15383 struct GeneratedVisitor;
15384
15385 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15386 type Value = GeneratedField;
15387
15388 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15389 write!(formatter, "expected one of: {:?}", &FIELDS)
15390 }
15391
15392 #[allow(unused_variables)]
15393 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15394 where
15395 E: serde::de::Error,
15396 {
15397 match value {
15398 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
15399 "sinkOutputSchema" | "sink_output_schema" => Ok(GeneratedField::SinkOutputSchema),
15400 "projectExprs" | "project_exprs" => Ok(GeneratedField::ProjectExprs),
15401 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15402 }
15403 }
15404 }
15405 deserializer.deserialize_identifier(GeneratedVisitor)
15406 }
15407 }
15408 struct GeneratedVisitor;
15409 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15410 type Value = UpstreamSinkInfo;
15411
15412 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15413 formatter.write_str("struct stream_plan.UpstreamSinkInfo")
15414 }
15415
15416 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkInfo, V::Error>
15417 where
15418 V: serde::de::MapAccess<'de>,
15419 {
15420 let mut upstream_fragment_id__ = None;
15421 let mut sink_output_schema__ = None;
15422 let mut project_exprs__ = None;
15423 while let Some(k) = map_.next_key()? {
15424 match k {
15425 GeneratedField::UpstreamFragmentId => {
15426 if upstream_fragment_id__.is_some() {
15427 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
15428 }
15429 upstream_fragment_id__ =
15430 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15431 ;
15432 }
15433 GeneratedField::SinkOutputSchema => {
15434 if sink_output_schema__.is_some() {
15435 return Err(serde::de::Error::duplicate_field("sinkOutputSchema"));
15436 }
15437 sink_output_schema__ = Some(map_.next_value()?);
15438 }
15439 GeneratedField::ProjectExprs => {
15440 if project_exprs__.is_some() {
15441 return Err(serde::de::Error::duplicate_field("projectExprs"));
15442 }
15443 project_exprs__ = Some(map_.next_value()?);
15444 }
15445 }
15446 }
15447 Ok(UpstreamSinkInfo {
15448 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
15449 sink_output_schema: sink_output_schema__.unwrap_or_default(),
15450 project_exprs: project_exprs__.unwrap_or_default(),
15451 })
15452 }
15453 }
15454 deserializer.deserialize_struct("stream_plan.UpstreamSinkInfo", FIELDS, GeneratedVisitor)
15455 }
15456}
15457impl serde::Serialize for UpstreamSinkUnionNode {
15458 #[allow(deprecated)]
15459 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15460 where
15461 S: serde::Serializer,
15462 {
15463 use serde::ser::SerializeStruct;
15464 let mut len = 0;
15465 if !self.init_upstreams.is_empty() {
15466 len += 1;
15467 }
15468 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkUnionNode", len)?;
15469 if !self.init_upstreams.is_empty() {
15470 struct_ser.serialize_field("initUpstreams", &self.init_upstreams)?;
15471 }
15472 struct_ser.end()
15473 }
15474}
15475impl<'de> serde::Deserialize<'de> for UpstreamSinkUnionNode {
15476 #[allow(deprecated)]
15477 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15478 where
15479 D: serde::Deserializer<'de>,
15480 {
15481 const FIELDS: &[&str] = &[
15482 "init_upstreams",
15483 "initUpstreams",
15484 ];
15485
15486 #[allow(clippy::enum_variant_names)]
15487 enum GeneratedField {
15488 InitUpstreams,
15489 }
15490 impl<'de> serde::Deserialize<'de> for GeneratedField {
15491 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15492 where
15493 D: serde::Deserializer<'de>,
15494 {
15495 struct GeneratedVisitor;
15496
15497 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15498 type Value = GeneratedField;
15499
15500 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15501 write!(formatter, "expected one of: {:?}", &FIELDS)
15502 }
15503
15504 #[allow(unused_variables)]
15505 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15506 where
15507 E: serde::de::Error,
15508 {
15509 match value {
15510 "initUpstreams" | "init_upstreams" => Ok(GeneratedField::InitUpstreams),
15511 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15512 }
15513 }
15514 }
15515 deserializer.deserialize_identifier(GeneratedVisitor)
15516 }
15517 }
15518 struct GeneratedVisitor;
15519 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15520 type Value = UpstreamSinkUnionNode;
15521
15522 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15523 formatter.write_str("struct stream_plan.UpstreamSinkUnionNode")
15524 }
15525
15526 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkUnionNode, V::Error>
15527 where
15528 V: serde::de::MapAccess<'de>,
15529 {
15530 let mut init_upstreams__ = None;
15531 while let Some(k) = map_.next_key()? {
15532 match k {
15533 GeneratedField::InitUpstreams => {
15534 if init_upstreams__.is_some() {
15535 return Err(serde::de::Error::duplicate_field("initUpstreams"));
15536 }
15537 init_upstreams__ = Some(map_.next_value()?);
15538 }
15539 }
15540 }
15541 Ok(UpstreamSinkUnionNode {
15542 init_upstreams: init_upstreams__.unwrap_or_default(),
15543 })
15544 }
15545 }
15546 deserializer.deserialize_struct("stream_plan.UpstreamSinkUnionNode", FIELDS, GeneratedVisitor)
15547 }
15548}
15549impl serde::Serialize for ValuesNode {
15550 #[allow(deprecated)]
15551 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15552 where
15553 S: serde::Serializer,
15554 {
15555 use serde::ser::SerializeStruct;
15556 let mut len = 0;
15557 if !self.tuples.is_empty() {
15558 len += 1;
15559 }
15560 if !self.fields.is_empty() {
15561 len += 1;
15562 }
15563 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode", len)?;
15564 if !self.tuples.is_empty() {
15565 struct_ser.serialize_field("tuples", &self.tuples)?;
15566 }
15567 if !self.fields.is_empty() {
15568 struct_ser.serialize_field("fields", &self.fields)?;
15569 }
15570 struct_ser.end()
15571 }
15572}
15573impl<'de> serde::Deserialize<'de> for ValuesNode {
15574 #[allow(deprecated)]
15575 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15576 where
15577 D: serde::Deserializer<'de>,
15578 {
15579 const FIELDS: &[&str] = &[
15580 "tuples",
15581 "fields",
15582 ];
15583
15584 #[allow(clippy::enum_variant_names)]
15585 enum GeneratedField {
15586 Tuples,
15587 Fields,
15588 }
15589 impl<'de> serde::Deserialize<'de> for GeneratedField {
15590 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15591 where
15592 D: serde::Deserializer<'de>,
15593 {
15594 struct GeneratedVisitor;
15595
15596 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15597 type Value = GeneratedField;
15598
15599 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15600 write!(formatter, "expected one of: {:?}", &FIELDS)
15601 }
15602
15603 #[allow(unused_variables)]
15604 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15605 where
15606 E: serde::de::Error,
15607 {
15608 match value {
15609 "tuples" => Ok(GeneratedField::Tuples),
15610 "fields" => Ok(GeneratedField::Fields),
15611 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15612 }
15613 }
15614 }
15615 deserializer.deserialize_identifier(GeneratedVisitor)
15616 }
15617 }
15618 struct GeneratedVisitor;
15619 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15620 type Value = ValuesNode;
15621
15622 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15623 formatter.write_str("struct stream_plan.ValuesNode")
15624 }
15625
15626 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
15627 where
15628 V: serde::de::MapAccess<'de>,
15629 {
15630 let mut tuples__ = None;
15631 let mut fields__ = None;
15632 while let Some(k) = map_.next_key()? {
15633 match k {
15634 GeneratedField::Tuples => {
15635 if tuples__.is_some() {
15636 return Err(serde::de::Error::duplicate_field("tuples"));
15637 }
15638 tuples__ = Some(map_.next_value()?);
15639 }
15640 GeneratedField::Fields => {
15641 if fields__.is_some() {
15642 return Err(serde::de::Error::duplicate_field("fields"));
15643 }
15644 fields__ = Some(map_.next_value()?);
15645 }
15646 }
15647 }
15648 Ok(ValuesNode {
15649 tuples: tuples__.unwrap_or_default(),
15650 fields: fields__.unwrap_or_default(),
15651 })
15652 }
15653 }
15654 deserializer.deserialize_struct("stream_plan.ValuesNode", FIELDS, GeneratedVisitor)
15655 }
15656}
15657impl serde::Serialize for values_node::ExprTuple {
15658 #[allow(deprecated)]
15659 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15660 where
15661 S: serde::Serializer,
15662 {
15663 use serde::ser::SerializeStruct;
15664 let mut len = 0;
15665 if !self.cells.is_empty() {
15666 len += 1;
15667 }
15668 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode.ExprTuple", len)?;
15669 if !self.cells.is_empty() {
15670 struct_ser.serialize_field("cells", &self.cells)?;
15671 }
15672 struct_ser.end()
15673 }
15674}
15675impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
15676 #[allow(deprecated)]
15677 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15678 where
15679 D: serde::Deserializer<'de>,
15680 {
15681 const FIELDS: &[&str] = &[
15682 "cells",
15683 ];
15684
15685 #[allow(clippy::enum_variant_names)]
15686 enum GeneratedField {
15687 Cells,
15688 }
15689 impl<'de> serde::Deserialize<'de> for GeneratedField {
15690 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15691 where
15692 D: serde::Deserializer<'de>,
15693 {
15694 struct GeneratedVisitor;
15695
15696 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15697 type Value = GeneratedField;
15698
15699 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15700 write!(formatter, "expected one of: {:?}", &FIELDS)
15701 }
15702
15703 #[allow(unused_variables)]
15704 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15705 where
15706 E: serde::de::Error,
15707 {
15708 match value {
15709 "cells" => Ok(GeneratedField::Cells),
15710 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15711 }
15712 }
15713 }
15714 deserializer.deserialize_identifier(GeneratedVisitor)
15715 }
15716 }
15717 struct GeneratedVisitor;
15718 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15719 type Value = values_node::ExprTuple;
15720
15721 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15722 formatter.write_str("struct stream_plan.ValuesNode.ExprTuple")
15723 }
15724
15725 fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
15726 where
15727 V: serde::de::MapAccess<'de>,
15728 {
15729 let mut cells__ = None;
15730 while let Some(k) = map_.next_key()? {
15731 match k {
15732 GeneratedField::Cells => {
15733 if cells__.is_some() {
15734 return Err(serde::de::Error::duplicate_field("cells"));
15735 }
15736 cells__ = Some(map_.next_value()?);
15737 }
15738 }
15739 }
15740 Ok(values_node::ExprTuple {
15741 cells: cells__.unwrap_or_default(),
15742 })
15743 }
15744 }
15745 deserializer.deserialize_struct("stream_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
15746 }
15747}
15748impl serde::Serialize for VectorIndexWriteNode {
15749 #[allow(deprecated)]
15750 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15751 where
15752 S: serde::Serializer,
15753 {
15754 use serde::ser::SerializeStruct;
15755 let mut len = 0;
15756 if self.table.is_some() {
15757 len += 1;
15758 }
15759 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexWriteNode", len)?;
15760 if let Some(v) = self.table.as_ref() {
15761 struct_ser.serialize_field("table", v)?;
15762 }
15763 struct_ser.end()
15764 }
15765}
15766impl<'de> serde::Deserialize<'de> for VectorIndexWriteNode {
15767 #[allow(deprecated)]
15768 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15769 where
15770 D: serde::Deserializer<'de>,
15771 {
15772 const FIELDS: &[&str] = &[
15773 "table",
15774 ];
15775
15776 #[allow(clippy::enum_variant_names)]
15777 enum GeneratedField {
15778 Table,
15779 }
15780 impl<'de> serde::Deserialize<'de> for GeneratedField {
15781 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15782 where
15783 D: serde::Deserializer<'de>,
15784 {
15785 struct GeneratedVisitor;
15786
15787 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15788 type Value = GeneratedField;
15789
15790 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15791 write!(formatter, "expected one of: {:?}", &FIELDS)
15792 }
15793
15794 #[allow(unused_variables)]
15795 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15796 where
15797 E: serde::de::Error,
15798 {
15799 match value {
15800 "table" => Ok(GeneratedField::Table),
15801 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15802 }
15803 }
15804 }
15805 deserializer.deserialize_identifier(GeneratedVisitor)
15806 }
15807 }
15808 struct GeneratedVisitor;
15809 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15810 type Value = VectorIndexWriteNode;
15811
15812 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15813 formatter.write_str("struct stream_plan.VectorIndexWriteNode")
15814 }
15815
15816 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexWriteNode, V::Error>
15817 where
15818 V: serde::de::MapAccess<'de>,
15819 {
15820 let mut table__ = None;
15821 while let Some(k) = map_.next_key()? {
15822 match k {
15823 GeneratedField::Table => {
15824 if table__.is_some() {
15825 return Err(serde::de::Error::duplicate_field("table"));
15826 }
15827 table__ = map_.next_value()?;
15828 }
15829 }
15830 }
15831 Ok(VectorIndexWriteNode {
15832 table: table__,
15833 })
15834 }
15835 }
15836 deserializer.deserialize_struct("stream_plan.VectorIndexWriteNode", FIELDS, GeneratedVisitor)
15837 }
15838}
15839impl serde::Serialize for Watermark {
15840 #[allow(deprecated)]
15841 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15842 where
15843 S: serde::Serializer,
15844 {
15845 use serde::ser::SerializeStruct;
15846 let mut len = 0;
15847 if self.column.is_some() {
15848 len += 1;
15849 }
15850 if self.val.is_some() {
15851 len += 1;
15852 }
15853 let mut struct_ser = serializer.serialize_struct("stream_plan.Watermark", len)?;
15854 if let Some(v) = self.column.as_ref() {
15855 struct_ser.serialize_field("column", v)?;
15856 }
15857 if let Some(v) = self.val.as_ref() {
15858 struct_ser.serialize_field("val", v)?;
15859 }
15860 struct_ser.end()
15861 }
15862}
15863impl<'de> serde::Deserialize<'de> for Watermark {
15864 #[allow(deprecated)]
15865 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15866 where
15867 D: serde::Deserializer<'de>,
15868 {
15869 const FIELDS: &[&str] = &[
15870 "column",
15871 "val",
15872 ];
15873
15874 #[allow(clippy::enum_variant_names)]
15875 enum GeneratedField {
15876 Column,
15877 Val,
15878 }
15879 impl<'de> serde::Deserialize<'de> for GeneratedField {
15880 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15881 where
15882 D: serde::Deserializer<'de>,
15883 {
15884 struct GeneratedVisitor;
15885
15886 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15887 type Value = GeneratedField;
15888
15889 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15890 write!(formatter, "expected one of: {:?}", &FIELDS)
15891 }
15892
15893 #[allow(unused_variables)]
15894 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15895 where
15896 E: serde::de::Error,
15897 {
15898 match value {
15899 "column" => Ok(GeneratedField::Column),
15900 "val" => Ok(GeneratedField::Val),
15901 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15902 }
15903 }
15904 }
15905 deserializer.deserialize_identifier(GeneratedVisitor)
15906 }
15907 }
15908 struct GeneratedVisitor;
15909 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15910 type Value = Watermark;
15911
15912 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15913 formatter.write_str("struct stream_plan.Watermark")
15914 }
15915
15916 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Watermark, V::Error>
15917 where
15918 V: serde::de::MapAccess<'de>,
15919 {
15920 let mut column__ = None;
15921 let mut val__ = None;
15922 while let Some(k) = map_.next_key()? {
15923 match k {
15924 GeneratedField::Column => {
15925 if column__.is_some() {
15926 return Err(serde::de::Error::duplicate_field("column"));
15927 }
15928 column__ = map_.next_value()?;
15929 }
15930 GeneratedField::Val => {
15931 if val__.is_some() {
15932 return Err(serde::de::Error::duplicate_field("val"));
15933 }
15934 val__ = map_.next_value()?;
15935 }
15936 }
15937 }
15938 Ok(Watermark {
15939 column: column__,
15940 val: val__,
15941 })
15942 }
15943 }
15944 deserializer.deserialize_struct("stream_plan.Watermark", FIELDS, GeneratedVisitor)
15945 }
15946}
15947impl serde::Serialize for WatermarkFilterNode {
15948 #[allow(deprecated)]
15949 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15950 where
15951 S: serde::Serializer,
15952 {
15953 use serde::ser::SerializeStruct;
15954 let mut len = 0;
15955 if !self.watermark_descs.is_empty() {
15956 len += 1;
15957 }
15958 if !self.tables.is_empty() {
15959 len += 1;
15960 }
15961 let mut struct_ser = serializer.serialize_struct("stream_plan.WatermarkFilterNode", len)?;
15962 if !self.watermark_descs.is_empty() {
15963 struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
15964 }
15965 if !self.tables.is_empty() {
15966 struct_ser.serialize_field("tables", &self.tables)?;
15967 }
15968 struct_ser.end()
15969 }
15970}
15971impl<'de> serde::Deserialize<'de> for WatermarkFilterNode {
15972 #[allow(deprecated)]
15973 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15974 where
15975 D: serde::Deserializer<'de>,
15976 {
15977 const FIELDS: &[&str] = &[
15978 "watermark_descs",
15979 "watermarkDescs",
15980 "tables",
15981 ];
15982
15983 #[allow(clippy::enum_variant_names)]
15984 enum GeneratedField {
15985 WatermarkDescs,
15986 Tables,
15987 }
15988 impl<'de> serde::Deserialize<'de> for GeneratedField {
15989 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15990 where
15991 D: serde::Deserializer<'de>,
15992 {
15993 struct GeneratedVisitor;
15994
15995 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15996 type Value = GeneratedField;
15997
15998 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15999 write!(formatter, "expected one of: {:?}", &FIELDS)
16000 }
16001
16002 #[allow(unused_variables)]
16003 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16004 where
16005 E: serde::de::Error,
16006 {
16007 match value {
16008 "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
16009 "tables" => Ok(GeneratedField::Tables),
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 = WatermarkFilterNode;
16020
16021 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16022 formatter.write_str("struct stream_plan.WatermarkFilterNode")
16023 }
16024
16025 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkFilterNode, V::Error>
16026 where
16027 V: serde::de::MapAccess<'de>,
16028 {
16029 let mut watermark_descs__ = None;
16030 let mut tables__ = None;
16031 while let Some(k) = map_.next_key()? {
16032 match k {
16033 GeneratedField::WatermarkDescs => {
16034 if watermark_descs__.is_some() {
16035 return Err(serde::de::Error::duplicate_field("watermarkDescs"));
16036 }
16037 watermark_descs__ = Some(map_.next_value()?);
16038 }
16039 GeneratedField::Tables => {
16040 if tables__.is_some() {
16041 return Err(serde::de::Error::duplicate_field("tables"));
16042 }
16043 tables__ = Some(map_.next_value()?);
16044 }
16045 }
16046 }
16047 Ok(WatermarkFilterNode {
16048 watermark_descs: watermark_descs__.unwrap_or_default(),
16049 tables: tables__.unwrap_or_default(),
16050 })
16051 }
16052 }
16053 deserializer.deserialize_struct("stream_plan.WatermarkFilterNode", FIELDS, GeneratedVisitor)
16054 }
16055}