1#![allow(clippy::useless_conversion)]
2#![allow(clippy::useless_borrows_in_formatting)]
3use crate::stream_plan::*;
4impl serde::Serialize for ActorMapping {
5 #[allow(deprecated)]
6 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7 where
8 S: serde::Serializer,
9 {
10 use serde::ser::SerializeStruct;
11 let mut len = 0;
12 if !self.original_indices.is_empty() {
13 len += 1;
14 }
15 if !self.data.is_empty() {
16 len += 1;
17 }
18 let mut struct_ser = serializer.serialize_struct("stream_plan.ActorMapping", len)?;
19 if !self.original_indices.is_empty() {
20 struct_ser.serialize_field("originalIndices", &self.original_indices)?;
21 }
22 if !self.data.is_empty() {
23 struct_ser.serialize_field("data", &self.data)?;
24 }
25 struct_ser.end()
26 }
27}
28impl<'de> serde::Deserialize<'de> for ActorMapping {
29 #[allow(deprecated)]
30 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
31 where
32 D: serde::Deserializer<'de>,
33 {
34 const FIELDS: &[&str] = &[
35 "original_indices",
36 "originalIndices",
37 "data",
38 ];
39
40 #[allow(clippy::enum_variant_names)]
41 enum GeneratedField {
42 OriginalIndices,
43 Data,
44 }
45 impl<'de> serde::Deserialize<'de> for GeneratedField {
46 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
47 where
48 D: serde::Deserializer<'de>,
49 {
50 struct GeneratedVisitor;
51
52 impl serde::de::Visitor<'_> for GeneratedVisitor {
53 type Value = GeneratedField;
54
55 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
56 write!(formatter, "expected one of: {:?}", &FIELDS)
57 }
58
59 #[allow(unused_variables)]
60 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
61 where
62 E: serde::de::Error,
63 {
64 match value {
65 "originalIndices" | "original_indices" => Ok(GeneratedField::OriginalIndices),
66 "data" => Ok(GeneratedField::Data),
67 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
68 }
69 }
70 }
71 deserializer.deserialize_identifier(GeneratedVisitor)
72 }
73 }
74 struct GeneratedVisitor;
75 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
76 type Value = ActorMapping;
77
78 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
79 formatter.write_str("struct stream_plan.ActorMapping")
80 }
81
82 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorMapping, V::Error>
83 where
84 V: serde::de::MapAccess<'de>,
85 {
86 let mut original_indices__ = None;
87 let mut data__ = None;
88 while let Some(k) = map_.next_key()? {
89 match k {
90 GeneratedField::OriginalIndices => {
91 if original_indices__.is_some() {
92 return Err(serde::de::Error::duplicate_field("originalIndices"));
93 }
94 original_indices__ =
95 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
96 .into_iter().map(|x| x.0).collect())
97 ;
98 }
99 GeneratedField::Data => {
100 if data__.is_some() {
101 return Err(serde::de::Error::duplicate_field("data"));
102 }
103 data__ =
104 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
105 .into_iter().map(|x| x.0).collect())
106 ;
107 }
108 }
109 }
110 Ok(ActorMapping {
111 original_indices: original_indices__.unwrap_or_default(),
112 data: data__.unwrap_or_default(),
113 })
114 }
115 }
116 deserializer.deserialize_struct("stream_plan.ActorMapping", FIELDS, GeneratedVisitor)
117 }
118}
119impl serde::Serialize for AddMutation {
120 #[allow(deprecated)]
121 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
122 where
123 S: serde::Serializer,
124 {
125 use serde::ser::SerializeStruct;
126 let mut len = 0;
127 if !self.actor_dispatchers.is_empty() {
128 len += 1;
129 }
130 if !self.added_actors.is_empty() {
131 len += 1;
132 }
133 if !self.actor_splits.is_empty() {
134 len += 1;
135 }
136 if self.pause {
137 len += 1;
138 }
139 if !self.subscriptions_to_add.is_empty() {
140 len += 1;
141 }
142 if !self.backfill_nodes_to_pause.is_empty() {
143 len += 1;
144 }
145 if self.actor_cdc_table_snapshot_splits.is_some() {
146 len += 1;
147 }
148 if !self.new_upstream_sinks.is_empty() {
149 len += 1;
150 }
151 if !self.dropped_actors.is_empty() {
152 len += 1;
153 }
154 if !self.sink_log_store_flush.is_empty() {
155 len += 1;
156 }
157 let mut struct_ser = serializer.serialize_struct("stream_plan.AddMutation", len)?;
158 if !self.actor_dispatchers.is_empty() {
159 struct_ser.serialize_field("actorDispatchers", &self.actor_dispatchers)?;
160 }
161 if !self.added_actors.is_empty() {
162 struct_ser.serialize_field("addedActors", &self.added_actors)?;
163 }
164 if !self.actor_splits.is_empty() {
165 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
166 }
167 if self.pause {
168 struct_ser.serialize_field("pause", &self.pause)?;
169 }
170 if !self.subscriptions_to_add.is_empty() {
171 struct_ser.serialize_field("subscriptionsToAdd", &self.subscriptions_to_add)?;
172 }
173 if !self.backfill_nodes_to_pause.is_empty() {
174 struct_ser.serialize_field("backfillNodesToPause", &self.backfill_nodes_to_pause)?;
175 }
176 if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
177 struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
178 }
179 if !self.new_upstream_sinks.is_empty() {
180 struct_ser.serialize_field("newUpstreamSinks", &self.new_upstream_sinks)?;
181 }
182 if !self.dropped_actors.is_empty() {
183 struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
184 }
185 if !self.sink_log_store_flush.is_empty() {
186 struct_ser.serialize_field("sinkLogStoreFlush", &self.sink_log_store_flush)?;
187 }
188 struct_ser.end()
189 }
190}
191impl<'de> serde::Deserialize<'de> for AddMutation {
192 #[allow(deprecated)]
193 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
194 where
195 D: serde::Deserializer<'de>,
196 {
197 const FIELDS: &[&str] = &[
198 "actor_dispatchers",
199 "actorDispatchers",
200 "added_actors",
201 "addedActors",
202 "actor_splits",
203 "actorSplits",
204 "pause",
205 "subscriptions_to_add",
206 "subscriptionsToAdd",
207 "backfill_nodes_to_pause",
208 "backfillNodesToPause",
209 "actor_cdc_table_snapshot_splits",
210 "actorCdcTableSnapshotSplits",
211 "new_upstream_sinks",
212 "newUpstreamSinks",
213 "dropped_actors",
214 "droppedActors",
215 "sink_log_store_flush",
216 "sinkLogStoreFlush",
217 ];
218
219 #[allow(clippy::enum_variant_names)]
220 enum GeneratedField {
221 ActorDispatchers,
222 AddedActors,
223 ActorSplits,
224 Pause,
225 SubscriptionsToAdd,
226 BackfillNodesToPause,
227 ActorCdcTableSnapshotSplits,
228 NewUpstreamSinks,
229 DroppedActors,
230 SinkLogStoreFlush,
231 }
232 impl<'de> serde::Deserialize<'de> for GeneratedField {
233 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
234 where
235 D: serde::Deserializer<'de>,
236 {
237 struct GeneratedVisitor;
238
239 impl serde::de::Visitor<'_> for GeneratedVisitor {
240 type Value = GeneratedField;
241
242 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
243 write!(formatter, "expected one of: {:?}", &FIELDS)
244 }
245
246 #[allow(unused_variables)]
247 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
248 where
249 E: serde::de::Error,
250 {
251 match value {
252 "actorDispatchers" | "actor_dispatchers" => Ok(GeneratedField::ActorDispatchers),
253 "addedActors" | "added_actors" => Ok(GeneratedField::AddedActors),
254 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
255 "pause" => Ok(GeneratedField::Pause),
256 "subscriptionsToAdd" | "subscriptions_to_add" => Ok(GeneratedField::SubscriptionsToAdd),
257 "backfillNodesToPause" | "backfill_nodes_to_pause" => Ok(GeneratedField::BackfillNodesToPause),
258 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
259 "newUpstreamSinks" | "new_upstream_sinks" => Ok(GeneratedField::NewUpstreamSinks),
260 "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
261 "sinkLogStoreFlush" | "sink_log_store_flush" => Ok(GeneratedField::SinkLogStoreFlush),
262 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
263 }
264 }
265 }
266 deserializer.deserialize_identifier(GeneratedVisitor)
267 }
268 }
269 struct GeneratedVisitor;
270 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
271 type Value = AddMutation;
272
273 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
274 formatter.write_str("struct stream_plan.AddMutation")
275 }
276
277 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddMutation, V::Error>
278 where
279 V: serde::de::MapAccess<'de>,
280 {
281 let mut actor_dispatchers__ = None;
282 let mut added_actors__ = None;
283 let mut actor_splits__ = None;
284 let mut pause__ = None;
285 let mut subscriptions_to_add__ = None;
286 let mut backfill_nodes_to_pause__ = None;
287 let mut actor_cdc_table_snapshot_splits__ = None;
288 let mut new_upstream_sinks__ = None;
289 let mut dropped_actors__ = None;
290 let mut sink_log_store_flush__ = None;
291 while let Some(k) = map_.next_key()? {
292 match k {
293 GeneratedField::ActorDispatchers => {
294 if actor_dispatchers__.is_some() {
295 return Err(serde::de::Error::duplicate_field("actorDispatchers"));
296 }
297 actor_dispatchers__ = Some(
298 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
299 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
300 );
301 }
302 GeneratedField::AddedActors => {
303 if added_actors__.is_some() {
304 return Err(serde::de::Error::duplicate_field("addedActors"));
305 }
306 added_actors__ =
307 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
308 .into_iter().map(|x| x.0).collect())
309 ;
310 }
311 GeneratedField::ActorSplits => {
312 if actor_splits__.is_some() {
313 return Err(serde::de::Error::duplicate_field("actorSplits"));
314 }
315 actor_splits__ = Some(
316 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
317 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
318 );
319 }
320 GeneratedField::Pause => {
321 if pause__.is_some() {
322 return Err(serde::de::Error::duplicate_field("pause"));
323 }
324 pause__ = Some(map_.next_value()?);
325 }
326 GeneratedField::SubscriptionsToAdd => {
327 if subscriptions_to_add__.is_some() {
328 return Err(serde::de::Error::duplicate_field("subscriptionsToAdd"));
329 }
330 subscriptions_to_add__ = Some(map_.next_value()?);
331 }
332 GeneratedField::BackfillNodesToPause => {
333 if backfill_nodes_to_pause__.is_some() {
334 return Err(serde::de::Error::duplicate_field("backfillNodesToPause"));
335 }
336 backfill_nodes_to_pause__ =
337 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
338 .into_iter().map(|x| x.0).collect())
339 ;
340 }
341 GeneratedField::ActorCdcTableSnapshotSplits => {
342 if actor_cdc_table_snapshot_splits__.is_some() {
343 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
344 }
345 actor_cdc_table_snapshot_splits__ = map_.next_value()?;
346 }
347 GeneratedField::NewUpstreamSinks => {
348 if new_upstream_sinks__.is_some() {
349 return Err(serde::de::Error::duplicate_field("newUpstreamSinks"));
350 }
351 new_upstream_sinks__ = Some(
352 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
353 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
354 );
355 }
356 GeneratedField::DroppedActors => {
357 if dropped_actors__.is_some() {
358 return Err(serde::de::Error::duplicate_field("droppedActors"));
359 }
360 dropped_actors__ =
361 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
362 .into_iter().map(|x| x.0).collect())
363 ;
364 }
365 GeneratedField::SinkLogStoreFlush => {
366 if sink_log_store_flush__.is_some() {
367 return Err(serde::de::Error::duplicate_field("sinkLogStoreFlush"));
368 }
369 sink_log_store_flush__ =
370 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
371 .into_iter().map(|x| x.0).collect())
372 ;
373 }
374 }
375 }
376 Ok(AddMutation {
377 actor_dispatchers: actor_dispatchers__.unwrap_or_default(),
378 added_actors: added_actors__.unwrap_or_default(),
379 actor_splits: actor_splits__.unwrap_or_default(),
380 pause: pause__.unwrap_or_default(),
381 subscriptions_to_add: subscriptions_to_add__.unwrap_or_default(),
382 backfill_nodes_to_pause: backfill_nodes_to_pause__.unwrap_or_default(),
383 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
384 new_upstream_sinks: new_upstream_sinks__.unwrap_or_default(),
385 dropped_actors: dropped_actors__.unwrap_or_default(),
386 sink_log_store_flush: sink_log_store_flush__.unwrap_or_default(),
387 })
388 }
389 }
390 deserializer.deserialize_struct("stream_plan.AddMutation", FIELDS, GeneratedVisitor)
391 }
392}
393impl serde::Serialize for add_mutation::NewUpstreamSink {
394 #[allow(deprecated)]
395 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
396 where
397 S: serde::Serializer,
398 {
399 use serde::ser::SerializeStruct;
400 let mut len = 0;
401 if self.info.is_some() {
402 len += 1;
403 }
404 if !self.upstream_actors.is_empty() {
405 len += 1;
406 }
407 let mut struct_ser = serializer.serialize_struct("stream_plan.AddMutation.NewUpstreamSink", len)?;
408 if let Some(v) = self.info.as_ref() {
409 struct_ser.serialize_field("info", v)?;
410 }
411 if !self.upstream_actors.is_empty() {
412 struct_ser.serialize_field("upstreamActors", &self.upstream_actors)?;
413 }
414 struct_ser.end()
415 }
416}
417impl<'de> serde::Deserialize<'de> for add_mutation::NewUpstreamSink {
418 #[allow(deprecated)]
419 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
420 where
421 D: serde::Deserializer<'de>,
422 {
423 const FIELDS: &[&str] = &[
424 "info",
425 "upstream_actors",
426 "upstreamActors",
427 ];
428
429 #[allow(clippy::enum_variant_names)]
430 enum GeneratedField {
431 Info,
432 UpstreamActors,
433 }
434 impl<'de> serde::Deserialize<'de> for GeneratedField {
435 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
436 where
437 D: serde::Deserializer<'de>,
438 {
439 struct GeneratedVisitor;
440
441 impl serde::de::Visitor<'_> for GeneratedVisitor {
442 type Value = GeneratedField;
443
444 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
445 write!(formatter, "expected one of: {:?}", &FIELDS)
446 }
447
448 #[allow(unused_variables)]
449 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
450 where
451 E: serde::de::Error,
452 {
453 match value {
454 "info" => Ok(GeneratedField::Info),
455 "upstreamActors" | "upstream_actors" => Ok(GeneratedField::UpstreamActors),
456 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
457 }
458 }
459 }
460 deserializer.deserialize_identifier(GeneratedVisitor)
461 }
462 }
463 struct GeneratedVisitor;
464 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
465 type Value = add_mutation::NewUpstreamSink;
466
467 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
468 formatter.write_str("struct stream_plan.AddMutation.NewUpstreamSink")
469 }
470
471 fn visit_map<V>(self, mut map_: V) -> std::result::Result<add_mutation::NewUpstreamSink, V::Error>
472 where
473 V: serde::de::MapAccess<'de>,
474 {
475 let mut info__ = None;
476 let mut upstream_actors__ = None;
477 while let Some(k) = map_.next_key()? {
478 match k {
479 GeneratedField::Info => {
480 if info__.is_some() {
481 return Err(serde::de::Error::duplicate_field("info"));
482 }
483 info__ = map_.next_value()?;
484 }
485 GeneratedField::UpstreamActors => {
486 if upstream_actors__.is_some() {
487 return Err(serde::de::Error::duplicate_field("upstreamActors"));
488 }
489 upstream_actors__ = Some(map_.next_value()?);
490 }
491 }
492 }
493 Ok(add_mutation::NewUpstreamSink {
494 info: info__,
495 upstream_actors: upstream_actors__.unwrap_or_default(),
496 })
497 }
498 }
499 deserializer.deserialize_struct("stream_plan.AddMutation.NewUpstreamSink", FIELDS, GeneratedVisitor)
500 }
501}
502impl serde::Serialize for AggCallState {
503 #[allow(deprecated)]
504 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
505 where
506 S: serde::Serializer,
507 {
508 use serde::ser::SerializeStruct;
509 let mut len = 0;
510 if self.inner.is_some() {
511 len += 1;
512 }
513 let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState", len)?;
514 if let Some(v) = self.inner.as_ref() {
515 match v {
516 agg_call_state::Inner::ValueState(v) => {
517 struct_ser.serialize_field("valueState", v)?;
518 }
519 agg_call_state::Inner::MaterializedInputState(v) => {
520 struct_ser.serialize_field("materializedInputState", v)?;
521 }
522 }
523 }
524 struct_ser.end()
525 }
526}
527impl<'de> serde::Deserialize<'de> for AggCallState {
528 #[allow(deprecated)]
529 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
530 where
531 D: serde::Deserializer<'de>,
532 {
533 const FIELDS: &[&str] = &[
534 "value_state",
535 "valueState",
536 "materialized_input_state",
537 "materializedInputState",
538 ];
539
540 #[allow(clippy::enum_variant_names)]
541 enum GeneratedField {
542 ValueState,
543 MaterializedInputState,
544 }
545 impl<'de> serde::Deserialize<'de> for GeneratedField {
546 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
547 where
548 D: serde::Deserializer<'de>,
549 {
550 struct GeneratedVisitor;
551
552 impl serde::de::Visitor<'_> for GeneratedVisitor {
553 type Value = GeneratedField;
554
555 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
556 write!(formatter, "expected one of: {:?}", &FIELDS)
557 }
558
559 #[allow(unused_variables)]
560 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
561 where
562 E: serde::de::Error,
563 {
564 match value {
565 "valueState" | "value_state" => Ok(GeneratedField::ValueState),
566 "materializedInputState" | "materialized_input_state" => Ok(GeneratedField::MaterializedInputState),
567 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
568 }
569 }
570 }
571 deserializer.deserialize_identifier(GeneratedVisitor)
572 }
573 }
574 struct GeneratedVisitor;
575 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
576 type Value = AggCallState;
577
578 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
579 formatter.write_str("struct stream_plan.AggCallState")
580 }
581
582 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AggCallState, V::Error>
583 where
584 V: serde::de::MapAccess<'de>,
585 {
586 let mut inner__ = None;
587 while let Some(k) = map_.next_key()? {
588 match k {
589 GeneratedField::ValueState => {
590 if inner__.is_some() {
591 return Err(serde::de::Error::duplicate_field("valueState"));
592 }
593 inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::ValueState)
594;
595 }
596 GeneratedField::MaterializedInputState => {
597 if inner__.is_some() {
598 return Err(serde::de::Error::duplicate_field("materializedInputState"));
599 }
600 inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::MaterializedInputState)
601;
602 }
603 }
604 }
605 Ok(AggCallState {
606 inner: inner__,
607 })
608 }
609 }
610 deserializer.deserialize_struct("stream_plan.AggCallState", FIELDS, GeneratedVisitor)
611 }
612}
613impl serde::Serialize for agg_call_state::MaterializedInputState {
614 #[allow(deprecated)]
615 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
616 where
617 S: serde::Serializer,
618 {
619 use serde::ser::SerializeStruct;
620 let mut len = 0;
621 if self.table.is_some() {
622 len += 1;
623 }
624 if !self.included_upstream_indices.is_empty() {
625 len += 1;
626 }
627 if !self.table_value_indices.is_empty() {
628 len += 1;
629 }
630 if !self.order_columns.is_empty() {
631 len += 1;
632 }
633 let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState.MaterializedInputState", len)?;
634 if let Some(v) = self.table.as_ref() {
635 struct_ser.serialize_field("table", v)?;
636 }
637 if !self.included_upstream_indices.is_empty() {
638 struct_ser.serialize_field("includedUpstreamIndices", &self.included_upstream_indices)?;
639 }
640 if !self.table_value_indices.is_empty() {
641 struct_ser.serialize_field("tableValueIndices", &self.table_value_indices)?;
642 }
643 if !self.order_columns.is_empty() {
644 struct_ser.serialize_field("orderColumns", &self.order_columns)?;
645 }
646 struct_ser.end()
647 }
648}
649impl<'de> serde::Deserialize<'de> for agg_call_state::MaterializedInputState {
650 #[allow(deprecated)]
651 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
652 where
653 D: serde::Deserializer<'de>,
654 {
655 const FIELDS: &[&str] = &[
656 "table",
657 "included_upstream_indices",
658 "includedUpstreamIndices",
659 "table_value_indices",
660 "tableValueIndices",
661 "order_columns",
662 "orderColumns",
663 ];
664
665 #[allow(clippy::enum_variant_names)]
666 enum GeneratedField {
667 Table,
668 IncludedUpstreamIndices,
669 TableValueIndices,
670 OrderColumns,
671 }
672 impl<'de> serde::Deserialize<'de> for GeneratedField {
673 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
674 where
675 D: serde::Deserializer<'de>,
676 {
677 struct GeneratedVisitor;
678
679 impl serde::de::Visitor<'_> for GeneratedVisitor {
680 type Value = GeneratedField;
681
682 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
683 write!(formatter, "expected one of: {:?}", &FIELDS)
684 }
685
686 #[allow(unused_variables)]
687 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
688 where
689 E: serde::de::Error,
690 {
691 match value {
692 "table" => Ok(GeneratedField::Table),
693 "includedUpstreamIndices" | "included_upstream_indices" => Ok(GeneratedField::IncludedUpstreamIndices),
694 "tableValueIndices" | "table_value_indices" => Ok(GeneratedField::TableValueIndices),
695 "orderColumns" | "order_columns" => Ok(GeneratedField::OrderColumns),
696 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
697 }
698 }
699 }
700 deserializer.deserialize_identifier(GeneratedVisitor)
701 }
702 }
703 struct GeneratedVisitor;
704 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
705 type Value = agg_call_state::MaterializedInputState;
706
707 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
708 formatter.write_str("struct stream_plan.AggCallState.MaterializedInputState")
709 }
710
711 fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::MaterializedInputState, V::Error>
712 where
713 V: serde::de::MapAccess<'de>,
714 {
715 let mut table__ = None;
716 let mut included_upstream_indices__ = None;
717 let mut table_value_indices__ = None;
718 let mut order_columns__ = None;
719 while let Some(k) = map_.next_key()? {
720 match k {
721 GeneratedField::Table => {
722 if table__.is_some() {
723 return Err(serde::de::Error::duplicate_field("table"));
724 }
725 table__ = map_.next_value()?;
726 }
727 GeneratedField::IncludedUpstreamIndices => {
728 if included_upstream_indices__.is_some() {
729 return Err(serde::de::Error::duplicate_field("includedUpstreamIndices"));
730 }
731 included_upstream_indices__ =
732 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
733 .into_iter().map(|x| x.0).collect())
734 ;
735 }
736 GeneratedField::TableValueIndices => {
737 if table_value_indices__.is_some() {
738 return Err(serde::de::Error::duplicate_field("tableValueIndices"));
739 }
740 table_value_indices__ =
741 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
742 .into_iter().map(|x| x.0).collect())
743 ;
744 }
745 GeneratedField::OrderColumns => {
746 if order_columns__.is_some() {
747 return Err(serde::de::Error::duplicate_field("orderColumns"));
748 }
749 order_columns__ = Some(map_.next_value()?);
750 }
751 }
752 }
753 Ok(agg_call_state::MaterializedInputState {
754 table: table__,
755 included_upstream_indices: included_upstream_indices__.unwrap_or_default(),
756 table_value_indices: table_value_indices__.unwrap_or_default(),
757 order_columns: order_columns__.unwrap_or_default(),
758 })
759 }
760 }
761 deserializer.deserialize_struct("stream_plan.AggCallState.MaterializedInputState", FIELDS, GeneratedVisitor)
762 }
763}
764impl serde::Serialize for agg_call_state::ValueState {
765 #[allow(deprecated)]
766 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
767 where
768 S: serde::Serializer,
769 {
770 use serde::ser::SerializeStruct;
771 let len = 0;
772 let struct_ser = serializer.serialize_struct("stream_plan.AggCallState.ValueState", len)?;
773 struct_ser.end()
774 }
775}
776impl<'de> serde::Deserialize<'de> for agg_call_state::ValueState {
777 #[allow(deprecated)]
778 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
779 where
780 D: serde::Deserializer<'de>,
781 {
782 const FIELDS: &[&str] = &[
783 ];
784
785 #[allow(clippy::enum_variant_names)]
786 enum GeneratedField {
787 }
788 impl<'de> serde::Deserialize<'de> for GeneratedField {
789 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
790 where
791 D: serde::Deserializer<'de>,
792 {
793 struct GeneratedVisitor;
794
795 impl serde::de::Visitor<'_> for GeneratedVisitor {
796 type Value = GeneratedField;
797
798 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
799 write!(formatter, "expected one of: {:?}", &FIELDS)
800 }
801
802 #[allow(unused_variables)]
803 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
804 where
805 E: serde::de::Error,
806 {
807 Err(serde::de::Error::unknown_field(value, FIELDS))
808 }
809 }
810 deserializer.deserialize_identifier(GeneratedVisitor)
811 }
812 }
813 struct GeneratedVisitor;
814 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
815 type Value = agg_call_state::ValueState;
816
817 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
818 formatter.write_str("struct stream_plan.AggCallState.ValueState")
819 }
820
821 fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::ValueState, V::Error>
822 where
823 V: serde::de::MapAccess<'de>,
824 {
825 while map_.next_key::<GeneratedField>()?.is_some() {
826 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
827 }
828 Ok(agg_call_state::ValueState {
829 })
830 }
831 }
832 deserializer.deserialize_struct("stream_plan.AggCallState.ValueState", FIELDS, GeneratedVisitor)
833 }
834}
835impl serde::Serialize for AggNodeVersion {
836 #[allow(deprecated)]
837 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
838 where
839 S: serde::Serializer,
840 {
841 let variant = match self {
842 Self::Unspecified => "AGG_NODE_VERSION_UNSPECIFIED",
843 Self::Issue12140 => "AGG_NODE_VERSION_ISSUE_12140",
844 Self::Issue13465 => "AGG_NODE_VERSION_ISSUE_13465",
845 };
846 serializer.serialize_str(variant)
847 }
848}
849impl<'de> serde::Deserialize<'de> for AggNodeVersion {
850 #[allow(deprecated)]
851 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
852 where
853 D: serde::Deserializer<'de>,
854 {
855 const FIELDS: &[&str] = &[
856 "AGG_NODE_VERSION_UNSPECIFIED",
857 "AGG_NODE_VERSION_ISSUE_12140",
858 "AGG_NODE_VERSION_ISSUE_13465",
859 ];
860
861 struct GeneratedVisitor;
862
863 impl serde::de::Visitor<'_> for GeneratedVisitor {
864 type Value = AggNodeVersion;
865
866 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
867 write!(formatter, "expected one of: {:?}", &FIELDS)
868 }
869
870 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
871 where
872 E: serde::de::Error,
873 {
874 i32::try_from(v)
875 .ok()
876 .and_then(|x| x.try_into().ok())
877 .ok_or_else(|| {
878 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
879 })
880 }
881
882 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
883 where
884 E: serde::de::Error,
885 {
886 i32::try_from(v)
887 .ok()
888 .and_then(|x| x.try_into().ok())
889 .ok_or_else(|| {
890 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
891 })
892 }
893
894 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
895 where
896 E: serde::de::Error,
897 {
898 match value {
899 "AGG_NODE_VERSION_UNSPECIFIED" => Ok(AggNodeVersion::Unspecified),
900 "AGG_NODE_VERSION_ISSUE_12140" => Ok(AggNodeVersion::Issue12140),
901 "AGG_NODE_VERSION_ISSUE_13465" => Ok(AggNodeVersion::Issue13465),
902 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
903 }
904 }
905 }
906 deserializer.deserialize_any(GeneratedVisitor)
907 }
908}
909impl serde::Serialize for ArrangeNode {
910 #[allow(deprecated)]
911 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
912 where
913 S: serde::Serializer,
914 {
915 use serde::ser::SerializeStruct;
916 let mut len = 0;
917 if self.table_info.is_some() {
918 len += 1;
919 }
920 if !self.distribution_key.is_empty() {
921 len += 1;
922 }
923 if self.table.is_some() {
924 len += 1;
925 }
926 let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangeNode", len)?;
927 if let Some(v) = self.table_info.as_ref() {
928 struct_ser.serialize_field("tableInfo", v)?;
929 }
930 if !self.distribution_key.is_empty() {
931 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
932 }
933 if let Some(v) = self.table.as_ref() {
934 struct_ser.serialize_field("table", v)?;
935 }
936 struct_ser.end()
937 }
938}
939impl<'de> serde::Deserialize<'de> for ArrangeNode {
940 #[allow(deprecated)]
941 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
942 where
943 D: serde::Deserializer<'de>,
944 {
945 const FIELDS: &[&str] = &[
946 "table_info",
947 "tableInfo",
948 "distribution_key",
949 "distributionKey",
950 "table",
951 ];
952
953 #[allow(clippy::enum_variant_names)]
954 enum GeneratedField {
955 TableInfo,
956 DistributionKey,
957 Table,
958 }
959 impl<'de> serde::Deserialize<'de> for GeneratedField {
960 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
961 where
962 D: serde::Deserializer<'de>,
963 {
964 struct GeneratedVisitor;
965
966 impl serde::de::Visitor<'_> for GeneratedVisitor {
967 type Value = GeneratedField;
968
969 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
970 write!(formatter, "expected one of: {:?}", &FIELDS)
971 }
972
973 #[allow(unused_variables)]
974 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
975 where
976 E: serde::de::Error,
977 {
978 match value {
979 "tableInfo" | "table_info" => Ok(GeneratedField::TableInfo),
980 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
981 "table" => Ok(GeneratedField::Table),
982 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
983 }
984 }
985 }
986 deserializer.deserialize_identifier(GeneratedVisitor)
987 }
988 }
989 struct GeneratedVisitor;
990 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
991 type Value = ArrangeNode;
992
993 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
994 formatter.write_str("struct stream_plan.ArrangeNode")
995 }
996
997 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangeNode, V::Error>
998 where
999 V: serde::de::MapAccess<'de>,
1000 {
1001 let mut table_info__ = None;
1002 let mut distribution_key__ = None;
1003 let mut table__ = None;
1004 while let Some(k) = map_.next_key()? {
1005 match k {
1006 GeneratedField::TableInfo => {
1007 if table_info__.is_some() {
1008 return Err(serde::de::Error::duplicate_field("tableInfo"));
1009 }
1010 table_info__ = map_.next_value()?;
1011 }
1012 GeneratedField::DistributionKey => {
1013 if distribution_key__.is_some() {
1014 return Err(serde::de::Error::duplicate_field("distributionKey"));
1015 }
1016 distribution_key__ =
1017 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1018 .into_iter().map(|x| x.0).collect())
1019 ;
1020 }
1021 GeneratedField::Table => {
1022 if table__.is_some() {
1023 return Err(serde::de::Error::duplicate_field("table"));
1024 }
1025 table__ = map_.next_value()?;
1026 }
1027 }
1028 }
1029 Ok(ArrangeNode {
1030 table_info: table_info__,
1031 distribution_key: distribution_key__.unwrap_or_default(),
1032 table: table__,
1033 })
1034 }
1035 }
1036 deserializer.deserialize_struct("stream_plan.ArrangeNode", FIELDS, GeneratedVisitor)
1037 }
1038}
1039impl serde::Serialize for ArrangementInfo {
1040 #[allow(deprecated)]
1041 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1042 where
1043 S: serde::Serializer,
1044 {
1045 use serde::ser::SerializeStruct;
1046 let mut len = 0;
1047 if !self.arrange_key_orders.is_empty() {
1048 len += 1;
1049 }
1050 if !self.column_descs.is_empty() {
1051 len += 1;
1052 }
1053 if self.table_desc.is_some() {
1054 len += 1;
1055 }
1056 if !self.output_col_idx.is_empty() {
1057 len += 1;
1058 }
1059 let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangementInfo", len)?;
1060 if !self.arrange_key_orders.is_empty() {
1061 struct_ser.serialize_field("arrangeKeyOrders", &self.arrange_key_orders)?;
1062 }
1063 if !self.column_descs.is_empty() {
1064 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
1065 }
1066 if let Some(v) = self.table_desc.as_ref() {
1067 struct_ser.serialize_field("tableDesc", v)?;
1068 }
1069 if !self.output_col_idx.is_empty() {
1070 struct_ser.serialize_field("outputColIdx", &self.output_col_idx)?;
1071 }
1072 struct_ser.end()
1073 }
1074}
1075impl<'de> serde::Deserialize<'de> for ArrangementInfo {
1076 #[allow(deprecated)]
1077 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1078 where
1079 D: serde::Deserializer<'de>,
1080 {
1081 const FIELDS: &[&str] = &[
1082 "arrange_key_orders",
1083 "arrangeKeyOrders",
1084 "column_descs",
1085 "columnDescs",
1086 "table_desc",
1087 "tableDesc",
1088 "output_col_idx",
1089 "outputColIdx",
1090 ];
1091
1092 #[allow(clippy::enum_variant_names)]
1093 enum GeneratedField {
1094 ArrangeKeyOrders,
1095 ColumnDescs,
1096 TableDesc,
1097 OutputColIdx,
1098 }
1099 impl<'de> serde::Deserialize<'de> for GeneratedField {
1100 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1101 where
1102 D: serde::Deserializer<'de>,
1103 {
1104 struct GeneratedVisitor;
1105
1106 impl serde::de::Visitor<'_> for GeneratedVisitor {
1107 type Value = GeneratedField;
1108
1109 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1110 write!(formatter, "expected one of: {:?}", &FIELDS)
1111 }
1112
1113 #[allow(unused_variables)]
1114 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1115 where
1116 E: serde::de::Error,
1117 {
1118 match value {
1119 "arrangeKeyOrders" | "arrange_key_orders" => Ok(GeneratedField::ArrangeKeyOrders),
1120 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
1121 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
1122 "outputColIdx" | "output_col_idx" => Ok(GeneratedField::OutputColIdx),
1123 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1124 }
1125 }
1126 }
1127 deserializer.deserialize_identifier(GeneratedVisitor)
1128 }
1129 }
1130 struct GeneratedVisitor;
1131 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1132 type Value = ArrangementInfo;
1133
1134 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1135 formatter.write_str("struct stream_plan.ArrangementInfo")
1136 }
1137
1138 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangementInfo, V::Error>
1139 where
1140 V: serde::de::MapAccess<'de>,
1141 {
1142 let mut arrange_key_orders__ = None;
1143 let mut column_descs__ = None;
1144 let mut table_desc__ = None;
1145 let mut output_col_idx__ = None;
1146 while let Some(k) = map_.next_key()? {
1147 match k {
1148 GeneratedField::ArrangeKeyOrders => {
1149 if arrange_key_orders__.is_some() {
1150 return Err(serde::de::Error::duplicate_field("arrangeKeyOrders"));
1151 }
1152 arrange_key_orders__ = Some(map_.next_value()?);
1153 }
1154 GeneratedField::ColumnDescs => {
1155 if column_descs__.is_some() {
1156 return Err(serde::de::Error::duplicate_field("columnDescs"));
1157 }
1158 column_descs__ = Some(map_.next_value()?);
1159 }
1160 GeneratedField::TableDesc => {
1161 if table_desc__.is_some() {
1162 return Err(serde::de::Error::duplicate_field("tableDesc"));
1163 }
1164 table_desc__ = map_.next_value()?;
1165 }
1166 GeneratedField::OutputColIdx => {
1167 if output_col_idx__.is_some() {
1168 return Err(serde::de::Error::duplicate_field("outputColIdx"));
1169 }
1170 output_col_idx__ =
1171 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1172 .into_iter().map(|x| x.0).collect())
1173 ;
1174 }
1175 }
1176 }
1177 Ok(ArrangementInfo {
1178 arrange_key_orders: arrange_key_orders__.unwrap_or_default(),
1179 column_descs: column_descs__.unwrap_or_default(),
1180 table_desc: table_desc__,
1181 output_col_idx: output_col_idx__.unwrap_or_default(),
1182 })
1183 }
1184 }
1185 deserializer.deserialize_struct("stream_plan.ArrangementInfo", FIELDS, GeneratedVisitor)
1186 }
1187}
1188impl serde::Serialize for AsOfJoinNode {
1189 #[allow(deprecated)]
1190 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1191 where
1192 S: serde::Serializer,
1193 {
1194 use serde::ser::SerializeStruct;
1195 let mut len = 0;
1196 if self.join_type != 0 {
1197 len += 1;
1198 }
1199 if !self.left_key.is_empty() {
1200 len += 1;
1201 }
1202 if !self.right_key.is_empty() {
1203 len += 1;
1204 }
1205 if self.left_table.is_some() {
1206 len += 1;
1207 }
1208 if self.right_table.is_some() {
1209 len += 1;
1210 }
1211 if !self.output_indices.is_empty() {
1212 len += 1;
1213 }
1214 if !self.left_deduped_input_pk_indices.is_empty() {
1215 len += 1;
1216 }
1217 if !self.right_deduped_input_pk_indices.is_empty() {
1218 len += 1;
1219 }
1220 if !self.null_safe.is_empty() {
1221 len += 1;
1222 }
1223 if self.asof_desc.is_some() {
1224 len += 1;
1225 }
1226 if self.join_encoding_type != 0 {
1227 len += 1;
1228 }
1229 if self.use_cache.is_some() {
1230 len += 1;
1231 }
1232 let mut struct_ser = serializer.serialize_struct("stream_plan.AsOfJoinNode", len)?;
1233 if self.join_type != 0 {
1234 let v = super::plan_common::AsOfJoinType::try_from(self.join_type)
1235 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
1236 struct_ser.serialize_field("joinType", &v)?;
1237 }
1238 if !self.left_key.is_empty() {
1239 struct_ser.serialize_field("leftKey", &self.left_key)?;
1240 }
1241 if !self.right_key.is_empty() {
1242 struct_ser.serialize_field("rightKey", &self.right_key)?;
1243 }
1244 if let Some(v) = self.left_table.as_ref() {
1245 struct_ser.serialize_field("leftTable", v)?;
1246 }
1247 if let Some(v) = self.right_table.as_ref() {
1248 struct_ser.serialize_field("rightTable", v)?;
1249 }
1250 if !self.output_indices.is_empty() {
1251 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
1252 }
1253 if !self.left_deduped_input_pk_indices.is_empty() {
1254 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
1255 }
1256 if !self.right_deduped_input_pk_indices.is_empty() {
1257 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
1258 }
1259 if !self.null_safe.is_empty() {
1260 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
1261 }
1262 if let Some(v) = self.asof_desc.as_ref() {
1263 struct_ser.serialize_field("asofDesc", v)?;
1264 }
1265 if self.join_encoding_type != 0 {
1266 let v = JoinEncodingType::try_from(self.join_encoding_type)
1267 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
1268 struct_ser.serialize_field("joinEncodingType", &v)?;
1269 }
1270 if let Some(v) = self.use_cache.as_ref() {
1271 struct_ser.serialize_field("useCache", v)?;
1272 }
1273 struct_ser.end()
1274 }
1275}
1276impl<'de> serde::Deserialize<'de> for AsOfJoinNode {
1277 #[allow(deprecated)]
1278 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1279 where
1280 D: serde::Deserializer<'de>,
1281 {
1282 const FIELDS: &[&str] = &[
1283 "join_type",
1284 "joinType",
1285 "left_key",
1286 "leftKey",
1287 "right_key",
1288 "rightKey",
1289 "left_table",
1290 "leftTable",
1291 "right_table",
1292 "rightTable",
1293 "output_indices",
1294 "outputIndices",
1295 "left_deduped_input_pk_indices",
1296 "leftDedupedInputPkIndices",
1297 "right_deduped_input_pk_indices",
1298 "rightDedupedInputPkIndices",
1299 "null_safe",
1300 "nullSafe",
1301 "asof_desc",
1302 "asofDesc",
1303 "join_encoding_type",
1304 "joinEncodingType",
1305 "use_cache",
1306 "useCache",
1307 ];
1308
1309 #[allow(clippy::enum_variant_names)]
1310 enum GeneratedField {
1311 JoinType,
1312 LeftKey,
1313 RightKey,
1314 LeftTable,
1315 RightTable,
1316 OutputIndices,
1317 LeftDedupedInputPkIndices,
1318 RightDedupedInputPkIndices,
1319 NullSafe,
1320 AsofDesc,
1321 JoinEncodingType,
1322 UseCache,
1323 }
1324 impl<'de> serde::Deserialize<'de> for GeneratedField {
1325 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1326 where
1327 D: serde::Deserializer<'de>,
1328 {
1329 struct GeneratedVisitor;
1330
1331 impl serde::de::Visitor<'_> for GeneratedVisitor {
1332 type Value = GeneratedField;
1333
1334 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1335 write!(formatter, "expected one of: {:?}", &FIELDS)
1336 }
1337
1338 #[allow(unused_variables)]
1339 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1340 where
1341 E: serde::de::Error,
1342 {
1343 match value {
1344 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
1345 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
1346 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
1347 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
1348 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
1349 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
1350 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
1351 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
1352 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
1353 "asofDesc" | "asof_desc" => Ok(GeneratedField::AsofDesc),
1354 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
1355 "useCache" | "use_cache" => Ok(GeneratedField::UseCache),
1356 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1357 }
1358 }
1359 }
1360 deserializer.deserialize_identifier(GeneratedVisitor)
1361 }
1362 }
1363 struct GeneratedVisitor;
1364 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1365 type Value = AsOfJoinNode;
1366
1367 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1368 formatter.write_str("struct stream_plan.AsOfJoinNode")
1369 }
1370
1371 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AsOfJoinNode, V::Error>
1372 where
1373 V: serde::de::MapAccess<'de>,
1374 {
1375 let mut join_type__ = None;
1376 let mut left_key__ = None;
1377 let mut right_key__ = None;
1378 let mut left_table__ = None;
1379 let mut right_table__ = None;
1380 let mut output_indices__ = None;
1381 let mut left_deduped_input_pk_indices__ = None;
1382 let mut right_deduped_input_pk_indices__ = None;
1383 let mut null_safe__ = None;
1384 let mut asof_desc__ = None;
1385 let mut join_encoding_type__ = None;
1386 let mut use_cache__ = None;
1387 while let Some(k) = map_.next_key()? {
1388 match k {
1389 GeneratedField::JoinType => {
1390 if join_type__.is_some() {
1391 return Err(serde::de::Error::duplicate_field("joinType"));
1392 }
1393 join_type__ = Some(map_.next_value::<super::plan_common::AsOfJoinType>()? as i32);
1394 }
1395 GeneratedField::LeftKey => {
1396 if left_key__.is_some() {
1397 return Err(serde::de::Error::duplicate_field("leftKey"));
1398 }
1399 left_key__ =
1400 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1401 .into_iter().map(|x| x.0).collect())
1402 ;
1403 }
1404 GeneratedField::RightKey => {
1405 if right_key__.is_some() {
1406 return Err(serde::de::Error::duplicate_field("rightKey"));
1407 }
1408 right_key__ =
1409 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1410 .into_iter().map(|x| x.0).collect())
1411 ;
1412 }
1413 GeneratedField::LeftTable => {
1414 if left_table__.is_some() {
1415 return Err(serde::de::Error::duplicate_field("leftTable"));
1416 }
1417 left_table__ = map_.next_value()?;
1418 }
1419 GeneratedField::RightTable => {
1420 if right_table__.is_some() {
1421 return Err(serde::de::Error::duplicate_field("rightTable"));
1422 }
1423 right_table__ = map_.next_value()?;
1424 }
1425 GeneratedField::OutputIndices => {
1426 if output_indices__.is_some() {
1427 return Err(serde::de::Error::duplicate_field("outputIndices"));
1428 }
1429 output_indices__ =
1430 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1431 .into_iter().map(|x| x.0).collect())
1432 ;
1433 }
1434 GeneratedField::LeftDedupedInputPkIndices => {
1435 if left_deduped_input_pk_indices__.is_some() {
1436 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
1437 }
1438 left_deduped_input_pk_indices__ =
1439 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1440 .into_iter().map(|x| x.0).collect())
1441 ;
1442 }
1443 GeneratedField::RightDedupedInputPkIndices => {
1444 if right_deduped_input_pk_indices__.is_some() {
1445 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
1446 }
1447 right_deduped_input_pk_indices__ =
1448 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1449 .into_iter().map(|x| x.0).collect())
1450 ;
1451 }
1452 GeneratedField::NullSafe => {
1453 if null_safe__.is_some() {
1454 return Err(serde::de::Error::duplicate_field("nullSafe"));
1455 }
1456 null_safe__ = Some(map_.next_value()?);
1457 }
1458 GeneratedField::AsofDesc => {
1459 if asof_desc__.is_some() {
1460 return Err(serde::de::Error::duplicate_field("asofDesc"));
1461 }
1462 asof_desc__ = map_.next_value()?;
1463 }
1464 GeneratedField::JoinEncodingType => {
1465 if join_encoding_type__.is_some() {
1466 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
1467 }
1468 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
1469 }
1470 GeneratedField::UseCache => {
1471 if use_cache__.is_some() {
1472 return Err(serde::de::Error::duplicate_field("useCache"));
1473 }
1474 use_cache__ = map_.next_value()?;
1475 }
1476 }
1477 }
1478 Ok(AsOfJoinNode {
1479 join_type: join_type__.unwrap_or_default(),
1480 left_key: left_key__.unwrap_or_default(),
1481 right_key: right_key__.unwrap_or_default(),
1482 left_table: left_table__,
1483 right_table: right_table__,
1484 output_indices: output_indices__.unwrap_or_default(),
1485 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
1486 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
1487 null_safe: null_safe__.unwrap_or_default(),
1488 asof_desc: asof_desc__,
1489 join_encoding_type: join_encoding_type__.unwrap_or_default(),
1490 use_cache: use_cache__,
1491 })
1492 }
1493 }
1494 deserializer.deserialize_struct("stream_plan.AsOfJoinNode", FIELDS, GeneratedVisitor)
1495 }
1496}
1497impl serde::Serialize for BackfillOrder {
1498 #[allow(deprecated)]
1499 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1500 where
1501 S: serde::Serializer,
1502 {
1503 use serde::ser::SerializeStruct;
1504 let mut len = 0;
1505 if !self.order.is_empty() {
1506 len += 1;
1507 }
1508 let mut struct_ser = serializer.serialize_struct("stream_plan.BackfillOrder", len)?;
1509 if !self.order.is_empty() {
1510 struct_ser.serialize_field("order", &self.order)?;
1511 }
1512 struct_ser.end()
1513 }
1514}
1515impl<'de> serde::Deserialize<'de> for BackfillOrder {
1516 #[allow(deprecated)]
1517 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1518 where
1519 D: serde::Deserializer<'de>,
1520 {
1521 const FIELDS: &[&str] = &[
1522 "order",
1523 ];
1524
1525 #[allow(clippy::enum_variant_names)]
1526 enum GeneratedField {
1527 Order,
1528 }
1529 impl<'de> serde::Deserialize<'de> for GeneratedField {
1530 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1531 where
1532 D: serde::Deserializer<'de>,
1533 {
1534 struct GeneratedVisitor;
1535
1536 impl serde::de::Visitor<'_> for GeneratedVisitor {
1537 type Value = GeneratedField;
1538
1539 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1540 write!(formatter, "expected one of: {:?}", &FIELDS)
1541 }
1542
1543 #[allow(unused_variables)]
1544 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1545 where
1546 E: serde::de::Error,
1547 {
1548 match value {
1549 "order" => Ok(GeneratedField::Order),
1550 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1551 }
1552 }
1553 }
1554 deserializer.deserialize_identifier(GeneratedVisitor)
1555 }
1556 }
1557 struct GeneratedVisitor;
1558 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1559 type Value = BackfillOrder;
1560
1561 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1562 formatter.write_str("struct stream_plan.BackfillOrder")
1563 }
1564
1565 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BackfillOrder, V::Error>
1566 where
1567 V: serde::de::MapAccess<'de>,
1568 {
1569 let mut order__ = None;
1570 while let Some(k) = map_.next_key()? {
1571 match k {
1572 GeneratedField::Order => {
1573 if order__.is_some() {
1574 return Err(serde::de::Error::duplicate_field("order"));
1575 }
1576 order__ = Some(
1577 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1578 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1579 );
1580 }
1581 }
1582 }
1583 Ok(BackfillOrder {
1584 order: order__.unwrap_or_default(),
1585 })
1586 }
1587 }
1588 deserializer.deserialize_struct("stream_plan.BackfillOrder", FIELDS, GeneratedVisitor)
1589 }
1590}
1591impl serde::Serialize for Barrier {
1592 #[allow(deprecated)]
1593 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1594 where
1595 S: serde::Serializer,
1596 {
1597 use serde::ser::SerializeStruct;
1598 let mut len = 0;
1599 if self.epoch.is_some() {
1600 len += 1;
1601 }
1602 if self.mutation.is_some() {
1603 len += 1;
1604 }
1605 if !self.tracing_context.is_empty() {
1606 len += 1;
1607 }
1608 if self.kind != 0 {
1609 len += 1;
1610 }
1611 let mut struct_ser = serializer.serialize_struct("stream_plan.Barrier", len)?;
1612 if let Some(v) = self.epoch.as_ref() {
1613 struct_ser.serialize_field("epoch", v)?;
1614 }
1615 if let Some(v) = self.mutation.as_ref() {
1616 struct_ser.serialize_field("mutation", v)?;
1617 }
1618 if !self.tracing_context.is_empty() {
1619 struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
1620 }
1621 if self.kind != 0 {
1622 let v = barrier::BarrierKind::try_from(self.kind)
1623 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
1624 struct_ser.serialize_field("kind", &v)?;
1625 }
1626 struct_ser.end()
1627 }
1628}
1629impl<'de> serde::Deserialize<'de> for Barrier {
1630 #[allow(deprecated)]
1631 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1632 where
1633 D: serde::Deserializer<'de>,
1634 {
1635 const FIELDS: &[&str] = &[
1636 "epoch",
1637 "mutation",
1638 "tracing_context",
1639 "tracingContext",
1640 "kind",
1641 ];
1642
1643 #[allow(clippy::enum_variant_names)]
1644 enum GeneratedField {
1645 Epoch,
1646 Mutation,
1647 TracingContext,
1648 Kind,
1649 }
1650 impl<'de> serde::Deserialize<'de> for GeneratedField {
1651 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1652 where
1653 D: serde::Deserializer<'de>,
1654 {
1655 struct GeneratedVisitor;
1656
1657 impl serde::de::Visitor<'_> for GeneratedVisitor {
1658 type Value = GeneratedField;
1659
1660 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1661 write!(formatter, "expected one of: {:?}", &FIELDS)
1662 }
1663
1664 #[allow(unused_variables)]
1665 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1666 where
1667 E: serde::de::Error,
1668 {
1669 match value {
1670 "epoch" => Ok(GeneratedField::Epoch),
1671 "mutation" => Ok(GeneratedField::Mutation),
1672 "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
1673 "kind" => Ok(GeneratedField::Kind),
1674 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1675 }
1676 }
1677 }
1678 deserializer.deserialize_identifier(GeneratedVisitor)
1679 }
1680 }
1681 struct GeneratedVisitor;
1682 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1683 type Value = Barrier;
1684
1685 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1686 formatter.write_str("struct stream_plan.Barrier")
1687 }
1688
1689 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Barrier, V::Error>
1690 where
1691 V: serde::de::MapAccess<'de>,
1692 {
1693 let mut epoch__ = None;
1694 let mut mutation__ = None;
1695 let mut tracing_context__ = None;
1696 let mut kind__ = None;
1697 while let Some(k) = map_.next_key()? {
1698 match k {
1699 GeneratedField::Epoch => {
1700 if epoch__.is_some() {
1701 return Err(serde::de::Error::duplicate_field("epoch"));
1702 }
1703 epoch__ = map_.next_value()?;
1704 }
1705 GeneratedField::Mutation => {
1706 if mutation__.is_some() {
1707 return Err(serde::de::Error::duplicate_field("mutation"));
1708 }
1709 mutation__ = map_.next_value()?;
1710 }
1711 GeneratedField::TracingContext => {
1712 if tracing_context__.is_some() {
1713 return Err(serde::de::Error::duplicate_field("tracingContext"));
1714 }
1715 tracing_context__ = Some(
1716 map_.next_value::<std::collections::HashMap<_, _>>()?
1717 );
1718 }
1719 GeneratedField::Kind => {
1720 if kind__.is_some() {
1721 return Err(serde::de::Error::duplicate_field("kind"));
1722 }
1723 kind__ = Some(map_.next_value::<barrier::BarrierKind>()? as i32);
1724 }
1725 }
1726 }
1727 Ok(Barrier {
1728 epoch: epoch__,
1729 mutation: mutation__,
1730 tracing_context: tracing_context__.unwrap_or_default(),
1731 kind: kind__.unwrap_or_default(),
1732 })
1733 }
1734 }
1735 deserializer.deserialize_struct("stream_plan.Barrier", FIELDS, GeneratedVisitor)
1736 }
1737}
1738impl serde::Serialize for barrier::BarrierKind {
1739 #[allow(deprecated)]
1740 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1741 where
1742 S: serde::Serializer,
1743 {
1744 let variant = match self {
1745 Self::Unspecified => "BARRIER_KIND_UNSPECIFIED",
1746 Self::Initial => "BARRIER_KIND_INITIAL",
1747 Self::Barrier => "BARRIER_KIND_BARRIER",
1748 Self::Checkpoint => "BARRIER_KIND_CHECKPOINT",
1749 };
1750 serializer.serialize_str(variant)
1751 }
1752}
1753impl<'de> serde::Deserialize<'de> for barrier::BarrierKind {
1754 #[allow(deprecated)]
1755 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1756 where
1757 D: serde::Deserializer<'de>,
1758 {
1759 const FIELDS: &[&str] = &[
1760 "BARRIER_KIND_UNSPECIFIED",
1761 "BARRIER_KIND_INITIAL",
1762 "BARRIER_KIND_BARRIER",
1763 "BARRIER_KIND_CHECKPOINT",
1764 ];
1765
1766 struct GeneratedVisitor;
1767
1768 impl serde::de::Visitor<'_> for GeneratedVisitor {
1769 type Value = barrier::BarrierKind;
1770
1771 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1772 write!(formatter, "expected one of: {:?}", &FIELDS)
1773 }
1774
1775 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1776 where
1777 E: serde::de::Error,
1778 {
1779 i32::try_from(v)
1780 .ok()
1781 .and_then(|x| x.try_into().ok())
1782 .ok_or_else(|| {
1783 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1784 })
1785 }
1786
1787 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1788 where
1789 E: serde::de::Error,
1790 {
1791 i32::try_from(v)
1792 .ok()
1793 .and_then(|x| x.try_into().ok())
1794 .ok_or_else(|| {
1795 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1796 })
1797 }
1798
1799 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1800 where
1801 E: serde::de::Error,
1802 {
1803 match value {
1804 "BARRIER_KIND_UNSPECIFIED" => Ok(barrier::BarrierKind::Unspecified),
1805 "BARRIER_KIND_INITIAL" => Ok(barrier::BarrierKind::Initial),
1806 "BARRIER_KIND_BARRIER" => Ok(barrier::BarrierKind::Barrier),
1807 "BARRIER_KIND_CHECKPOINT" => Ok(barrier::BarrierKind::Checkpoint),
1808 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1809 }
1810 }
1811 }
1812 deserializer.deserialize_any(GeneratedVisitor)
1813 }
1814}
1815impl serde::Serialize for BarrierMutation {
1816 #[allow(deprecated)]
1817 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1818 where
1819 S: serde::Serializer,
1820 {
1821 use serde::ser::SerializeStruct;
1822 let mut len = 0;
1823 if self.mutation.is_some() {
1824 len += 1;
1825 }
1826 let mut struct_ser = serializer.serialize_struct("stream_plan.BarrierMutation", len)?;
1827 if let Some(v) = self.mutation.as_ref() {
1828 match v {
1829 barrier_mutation::Mutation::Add(v) => {
1830 struct_ser.serialize_field("add", v)?;
1831 }
1832 barrier_mutation::Mutation::Stop(v) => {
1833 struct_ser.serialize_field("stop", v)?;
1834 }
1835 barrier_mutation::Mutation::Update(v) => {
1836 struct_ser.serialize_field("update", v)?;
1837 }
1838 barrier_mutation::Mutation::Splits(v) => {
1839 struct_ser.serialize_field("splits", v)?;
1840 }
1841 barrier_mutation::Mutation::Pause(v) => {
1842 struct_ser.serialize_field("pause", v)?;
1843 }
1844 barrier_mutation::Mutation::Resume(v) => {
1845 struct_ser.serialize_field("resume", v)?;
1846 }
1847 barrier_mutation::Mutation::Throttle(v) => {
1848 struct_ser.serialize_field("throttle", v)?;
1849 }
1850 barrier_mutation::Mutation::DropSubscriptions(v) => {
1851 struct_ser.serialize_field("dropSubscriptions", v)?;
1852 }
1853 barrier_mutation::Mutation::ConnectorPropsChange(v) => {
1854 struct_ser.serialize_field("connectorPropsChange", v)?;
1855 }
1856 barrier_mutation::Mutation::StartFragmentBackfill(v) => {
1857 struct_ser.serialize_field("startFragmentBackfill", v)?;
1858 }
1859 barrier_mutation::Mutation::RefreshStart(v) => {
1860 struct_ser.serialize_field("refreshStart", v)?;
1861 }
1862 barrier_mutation::Mutation::LoadFinish(v) => {
1863 struct_ser.serialize_field("loadFinish", v)?;
1864 }
1865 barrier_mutation::Mutation::ListFinish(v) => {
1866 struct_ser.serialize_field("listFinish", v)?;
1867 }
1868 barrier_mutation::Mutation::ResetSource(v) => {
1869 struct_ser.serialize_field("resetSource", v)?;
1870 }
1871 barrier_mutation::Mutation::InjectSourceOffsets(v) => {
1872 struct_ser.serialize_field("injectSourceOffsets", v)?;
1873 }
1874 }
1875 }
1876 struct_ser.end()
1877 }
1878}
1879impl<'de> serde::Deserialize<'de> for BarrierMutation {
1880 #[allow(deprecated)]
1881 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1882 where
1883 D: serde::Deserializer<'de>,
1884 {
1885 const FIELDS: &[&str] = &[
1886 "add",
1887 "stop",
1888 "update",
1889 "splits",
1890 "pause",
1891 "resume",
1892 "throttle",
1893 "drop_subscriptions",
1894 "dropSubscriptions",
1895 "connector_props_change",
1896 "connectorPropsChange",
1897 "start_fragment_backfill",
1898 "startFragmentBackfill",
1899 "refresh_start",
1900 "refreshStart",
1901 "load_finish",
1902 "loadFinish",
1903 "list_finish",
1904 "listFinish",
1905 "reset_source",
1906 "resetSource",
1907 "inject_source_offsets",
1908 "injectSourceOffsets",
1909 ];
1910
1911 #[allow(clippy::enum_variant_names)]
1912 enum GeneratedField {
1913 Add,
1914 Stop,
1915 Update,
1916 Splits,
1917 Pause,
1918 Resume,
1919 Throttle,
1920 DropSubscriptions,
1921 ConnectorPropsChange,
1922 StartFragmentBackfill,
1923 RefreshStart,
1924 LoadFinish,
1925 ListFinish,
1926 ResetSource,
1927 InjectSourceOffsets,
1928 }
1929 impl<'de> serde::Deserialize<'de> for GeneratedField {
1930 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1931 where
1932 D: serde::Deserializer<'de>,
1933 {
1934 struct GeneratedVisitor;
1935
1936 impl serde::de::Visitor<'_> for GeneratedVisitor {
1937 type Value = GeneratedField;
1938
1939 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1940 write!(formatter, "expected one of: {:?}", &FIELDS)
1941 }
1942
1943 #[allow(unused_variables)]
1944 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1945 where
1946 E: serde::de::Error,
1947 {
1948 match value {
1949 "add" => Ok(GeneratedField::Add),
1950 "stop" => Ok(GeneratedField::Stop),
1951 "update" => Ok(GeneratedField::Update),
1952 "splits" => Ok(GeneratedField::Splits),
1953 "pause" => Ok(GeneratedField::Pause),
1954 "resume" => Ok(GeneratedField::Resume),
1955 "throttle" => Ok(GeneratedField::Throttle),
1956 "dropSubscriptions" | "drop_subscriptions" => Ok(GeneratedField::DropSubscriptions),
1957 "connectorPropsChange" | "connector_props_change" => Ok(GeneratedField::ConnectorPropsChange),
1958 "startFragmentBackfill" | "start_fragment_backfill" => Ok(GeneratedField::StartFragmentBackfill),
1959 "refreshStart" | "refresh_start" => Ok(GeneratedField::RefreshStart),
1960 "loadFinish" | "load_finish" => Ok(GeneratedField::LoadFinish),
1961 "listFinish" | "list_finish" => Ok(GeneratedField::ListFinish),
1962 "resetSource" | "reset_source" => Ok(GeneratedField::ResetSource),
1963 "injectSourceOffsets" | "inject_source_offsets" => Ok(GeneratedField::InjectSourceOffsets),
1964 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1965 }
1966 }
1967 }
1968 deserializer.deserialize_identifier(GeneratedVisitor)
1969 }
1970 }
1971 struct GeneratedVisitor;
1972 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1973 type Value = BarrierMutation;
1974
1975 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1976 formatter.write_str("struct stream_plan.BarrierMutation")
1977 }
1978
1979 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierMutation, V::Error>
1980 where
1981 V: serde::de::MapAccess<'de>,
1982 {
1983 let mut mutation__ = None;
1984 while let Some(k) = map_.next_key()? {
1985 match k {
1986 GeneratedField::Add => {
1987 if mutation__.is_some() {
1988 return Err(serde::de::Error::duplicate_field("add"));
1989 }
1990 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Add)
1991;
1992 }
1993 GeneratedField::Stop => {
1994 if mutation__.is_some() {
1995 return Err(serde::de::Error::duplicate_field("stop"));
1996 }
1997 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Stop)
1998;
1999 }
2000 GeneratedField::Update => {
2001 if mutation__.is_some() {
2002 return Err(serde::de::Error::duplicate_field("update"));
2003 }
2004 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Update)
2005;
2006 }
2007 GeneratedField::Splits => {
2008 if mutation__.is_some() {
2009 return Err(serde::de::Error::duplicate_field("splits"));
2010 }
2011 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Splits)
2012;
2013 }
2014 GeneratedField::Pause => {
2015 if mutation__.is_some() {
2016 return Err(serde::de::Error::duplicate_field("pause"));
2017 }
2018 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Pause)
2019;
2020 }
2021 GeneratedField::Resume => {
2022 if mutation__.is_some() {
2023 return Err(serde::de::Error::duplicate_field("resume"));
2024 }
2025 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Resume)
2026;
2027 }
2028 GeneratedField::Throttle => {
2029 if mutation__.is_some() {
2030 return Err(serde::de::Error::duplicate_field("throttle"));
2031 }
2032 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Throttle)
2033;
2034 }
2035 GeneratedField::DropSubscriptions => {
2036 if mutation__.is_some() {
2037 return Err(serde::de::Error::duplicate_field("dropSubscriptions"));
2038 }
2039 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::DropSubscriptions)
2040;
2041 }
2042 GeneratedField::ConnectorPropsChange => {
2043 if mutation__.is_some() {
2044 return Err(serde::de::Error::duplicate_field("connectorPropsChange"));
2045 }
2046 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ConnectorPropsChange)
2047;
2048 }
2049 GeneratedField::StartFragmentBackfill => {
2050 if mutation__.is_some() {
2051 return Err(serde::de::Error::duplicate_field("startFragmentBackfill"));
2052 }
2053 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::StartFragmentBackfill)
2054;
2055 }
2056 GeneratedField::RefreshStart => {
2057 if mutation__.is_some() {
2058 return Err(serde::de::Error::duplicate_field("refreshStart"));
2059 }
2060 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::RefreshStart)
2061;
2062 }
2063 GeneratedField::LoadFinish => {
2064 if mutation__.is_some() {
2065 return Err(serde::de::Error::duplicate_field("loadFinish"));
2066 }
2067 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::LoadFinish)
2068;
2069 }
2070 GeneratedField::ListFinish => {
2071 if mutation__.is_some() {
2072 return Err(serde::de::Error::duplicate_field("listFinish"));
2073 }
2074 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ListFinish)
2075;
2076 }
2077 GeneratedField::ResetSource => {
2078 if mutation__.is_some() {
2079 return Err(serde::de::Error::duplicate_field("resetSource"));
2080 }
2081 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ResetSource)
2082;
2083 }
2084 GeneratedField::InjectSourceOffsets => {
2085 if mutation__.is_some() {
2086 return Err(serde::de::Error::duplicate_field("injectSourceOffsets"));
2087 }
2088 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::InjectSourceOffsets)
2089;
2090 }
2091 }
2092 }
2093 Ok(BarrierMutation {
2094 mutation: mutation__,
2095 })
2096 }
2097 }
2098 deserializer.deserialize_struct("stream_plan.BarrierMutation", FIELDS, GeneratedVisitor)
2099 }
2100}
2101impl serde::Serialize for BarrierRecvNode {
2102 #[allow(deprecated)]
2103 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2104 where
2105 S: serde::Serializer,
2106 {
2107 use serde::ser::SerializeStruct;
2108 let len = 0;
2109 let struct_ser = serializer.serialize_struct("stream_plan.BarrierRecvNode", len)?;
2110 struct_ser.end()
2111 }
2112}
2113impl<'de> serde::Deserialize<'de> for BarrierRecvNode {
2114 #[allow(deprecated)]
2115 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2116 where
2117 D: serde::Deserializer<'de>,
2118 {
2119 const FIELDS: &[&str] = &[
2120 ];
2121
2122 #[allow(clippy::enum_variant_names)]
2123 enum GeneratedField {
2124 }
2125 impl<'de> serde::Deserialize<'de> for GeneratedField {
2126 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2127 where
2128 D: serde::Deserializer<'de>,
2129 {
2130 struct GeneratedVisitor;
2131
2132 impl serde::de::Visitor<'_> for GeneratedVisitor {
2133 type Value = GeneratedField;
2134
2135 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2136 write!(formatter, "expected one of: {:?}", &FIELDS)
2137 }
2138
2139 #[allow(unused_variables)]
2140 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2141 where
2142 E: serde::de::Error,
2143 {
2144 Err(serde::de::Error::unknown_field(value, FIELDS))
2145 }
2146 }
2147 deserializer.deserialize_identifier(GeneratedVisitor)
2148 }
2149 }
2150 struct GeneratedVisitor;
2151 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2152 type Value = BarrierRecvNode;
2153
2154 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2155 formatter.write_str("struct stream_plan.BarrierRecvNode")
2156 }
2157
2158 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierRecvNode, V::Error>
2159 where
2160 V: serde::de::MapAccess<'de>,
2161 {
2162 while map_.next_key::<GeneratedField>()?.is_some() {
2163 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2164 }
2165 Ok(BarrierRecvNode {
2166 })
2167 }
2168 }
2169 deserializer.deserialize_struct("stream_plan.BarrierRecvNode", FIELDS, GeneratedVisitor)
2170 }
2171}
2172impl serde::Serialize for BatchPlanNode {
2173 #[allow(deprecated)]
2174 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2175 where
2176 S: serde::Serializer,
2177 {
2178 use serde::ser::SerializeStruct;
2179 let mut len = 0;
2180 if self.table_desc.is_some() {
2181 len += 1;
2182 }
2183 if !self.column_ids.is_empty() {
2184 len += 1;
2185 }
2186 let mut struct_ser = serializer.serialize_struct("stream_plan.BatchPlanNode", len)?;
2187 if let Some(v) = self.table_desc.as_ref() {
2188 struct_ser.serialize_field("tableDesc", v)?;
2189 }
2190 if !self.column_ids.is_empty() {
2191 struct_ser.serialize_field("columnIds", &self.column_ids)?;
2192 }
2193 struct_ser.end()
2194 }
2195}
2196impl<'de> serde::Deserialize<'de> for BatchPlanNode {
2197 #[allow(deprecated)]
2198 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2199 where
2200 D: serde::Deserializer<'de>,
2201 {
2202 const FIELDS: &[&str] = &[
2203 "table_desc",
2204 "tableDesc",
2205 "column_ids",
2206 "columnIds",
2207 ];
2208
2209 #[allow(clippy::enum_variant_names)]
2210 enum GeneratedField {
2211 TableDesc,
2212 ColumnIds,
2213 }
2214 impl<'de> serde::Deserialize<'de> for GeneratedField {
2215 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2216 where
2217 D: serde::Deserializer<'de>,
2218 {
2219 struct GeneratedVisitor;
2220
2221 impl serde::de::Visitor<'_> for GeneratedVisitor {
2222 type Value = GeneratedField;
2223
2224 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2225 write!(formatter, "expected one of: {:?}", &FIELDS)
2226 }
2227
2228 #[allow(unused_variables)]
2229 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2230 where
2231 E: serde::de::Error,
2232 {
2233 match value {
2234 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
2235 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
2236 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2237 }
2238 }
2239 }
2240 deserializer.deserialize_identifier(GeneratedVisitor)
2241 }
2242 }
2243 struct GeneratedVisitor;
2244 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2245 type Value = BatchPlanNode;
2246
2247 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2248 formatter.write_str("struct stream_plan.BatchPlanNode")
2249 }
2250
2251 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BatchPlanNode, V::Error>
2252 where
2253 V: serde::de::MapAccess<'de>,
2254 {
2255 let mut table_desc__ = None;
2256 let mut column_ids__ = None;
2257 while let Some(k) = map_.next_key()? {
2258 match k {
2259 GeneratedField::TableDesc => {
2260 if table_desc__.is_some() {
2261 return Err(serde::de::Error::duplicate_field("tableDesc"));
2262 }
2263 table_desc__ = map_.next_value()?;
2264 }
2265 GeneratedField::ColumnIds => {
2266 if column_ids__.is_some() {
2267 return Err(serde::de::Error::duplicate_field("columnIds"));
2268 }
2269 column_ids__ =
2270 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2271 .into_iter().map(|x| x.0).collect())
2272 ;
2273 }
2274 }
2275 }
2276 Ok(BatchPlanNode {
2277 table_desc: table_desc__,
2278 column_ids: column_ids__.unwrap_or_default(),
2279 })
2280 }
2281 }
2282 deserializer.deserialize_struct("stream_plan.BatchPlanNode", FIELDS, GeneratedVisitor)
2283 }
2284}
2285impl serde::Serialize for CdcFilterNode {
2286 #[allow(deprecated)]
2287 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2288 where
2289 S: serde::Serializer,
2290 {
2291 use serde::ser::SerializeStruct;
2292 let mut len = 0;
2293 if self.search_condition.is_some() {
2294 len += 1;
2295 }
2296 if self.upstream_source_id != 0 {
2297 len += 1;
2298 }
2299 let mut struct_ser = serializer.serialize_struct("stream_plan.CdcFilterNode", len)?;
2300 if let Some(v) = self.search_condition.as_ref() {
2301 struct_ser.serialize_field("searchCondition", v)?;
2302 }
2303 if self.upstream_source_id != 0 {
2304 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
2305 }
2306 struct_ser.end()
2307 }
2308}
2309impl<'de> serde::Deserialize<'de> for CdcFilterNode {
2310 #[allow(deprecated)]
2311 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2312 where
2313 D: serde::Deserializer<'de>,
2314 {
2315 const FIELDS: &[&str] = &[
2316 "search_condition",
2317 "searchCondition",
2318 "upstream_source_id",
2319 "upstreamSourceId",
2320 ];
2321
2322 #[allow(clippy::enum_variant_names)]
2323 enum GeneratedField {
2324 SearchCondition,
2325 UpstreamSourceId,
2326 }
2327 impl<'de> serde::Deserialize<'de> for GeneratedField {
2328 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2329 where
2330 D: serde::Deserializer<'de>,
2331 {
2332 struct GeneratedVisitor;
2333
2334 impl serde::de::Visitor<'_> for GeneratedVisitor {
2335 type Value = GeneratedField;
2336
2337 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2338 write!(formatter, "expected one of: {:?}", &FIELDS)
2339 }
2340
2341 #[allow(unused_variables)]
2342 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2343 where
2344 E: serde::de::Error,
2345 {
2346 match value {
2347 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
2348 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
2349 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2350 }
2351 }
2352 }
2353 deserializer.deserialize_identifier(GeneratedVisitor)
2354 }
2355 }
2356 struct GeneratedVisitor;
2357 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2358 type Value = CdcFilterNode;
2359
2360 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2361 formatter.write_str("struct stream_plan.CdcFilterNode")
2362 }
2363
2364 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcFilterNode, V::Error>
2365 where
2366 V: serde::de::MapAccess<'de>,
2367 {
2368 let mut search_condition__ = None;
2369 let mut upstream_source_id__ = None;
2370 while let Some(k) = map_.next_key()? {
2371 match k {
2372 GeneratedField::SearchCondition => {
2373 if search_condition__.is_some() {
2374 return Err(serde::de::Error::duplicate_field("searchCondition"));
2375 }
2376 search_condition__ = map_.next_value()?;
2377 }
2378 GeneratedField::UpstreamSourceId => {
2379 if upstream_source_id__.is_some() {
2380 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
2381 }
2382 upstream_source_id__ =
2383 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2384 ;
2385 }
2386 }
2387 }
2388 Ok(CdcFilterNode {
2389 search_condition: search_condition__,
2390 upstream_source_id: upstream_source_id__.unwrap_or_default(),
2391 })
2392 }
2393 }
2394 deserializer.deserialize_struct("stream_plan.CdcFilterNode", FIELDS, GeneratedVisitor)
2395 }
2396}
2397impl serde::Serialize for ChangeLogNode {
2398 #[allow(deprecated)]
2399 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2400 where
2401 S: serde::Serializer,
2402 {
2403 use serde::ser::SerializeStruct;
2404 let mut len = 0;
2405 if self.need_op {
2406 len += 1;
2407 }
2408 if !self.distribution_keys.is_empty() {
2409 len += 1;
2410 }
2411 let mut struct_ser = serializer.serialize_struct("stream_plan.ChangeLogNode", len)?;
2412 if self.need_op {
2413 struct_ser.serialize_field("needOp", &self.need_op)?;
2414 }
2415 if !self.distribution_keys.is_empty() {
2416 struct_ser.serialize_field("distributionKeys", &self.distribution_keys)?;
2417 }
2418 struct_ser.end()
2419 }
2420}
2421impl<'de> serde::Deserialize<'de> for ChangeLogNode {
2422 #[allow(deprecated)]
2423 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2424 where
2425 D: serde::Deserializer<'de>,
2426 {
2427 const FIELDS: &[&str] = &[
2428 "need_op",
2429 "needOp",
2430 "distribution_keys",
2431 "distributionKeys",
2432 ];
2433
2434 #[allow(clippy::enum_variant_names)]
2435 enum GeneratedField {
2436 NeedOp,
2437 DistributionKeys,
2438 }
2439 impl<'de> serde::Deserialize<'de> for GeneratedField {
2440 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2441 where
2442 D: serde::Deserializer<'de>,
2443 {
2444 struct GeneratedVisitor;
2445
2446 impl serde::de::Visitor<'_> for GeneratedVisitor {
2447 type Value = GeneratedField;
2448
2449 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2450 write!(formatter, "expected one of: {:?}", &FIELDS)
2451 }
2452
2453 #[allow(unused_variables)]
2454 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2455 where
2456 E: serde::de::Error,
2457 {
2458 match value {
2459 "needOp" | "need_op" => Ok(GeneratedField::NeedOp),
2460 "distributionKeys" | "distribution_keys" => Ok(GeneratedField::DistributionKeys),
2461 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2462 }
2463 }
2464 }
2465 deserializer.deserialize_identifier(GeneratedVisitor)
2466 }
2467 }
2468 struct GeneratedVisitor;
2469 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2470 type Value = ChangeLogNode;
2471
2472 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2473 formatter.write_str("struct stream_plan.ChangeLogNode")
2474 }
2475
2476 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ChangeLogNode, V::Error>
2477 where
2478 V: serde::de::MapAccess<'de>,
2479 {
2480 let mut need_op__ = None;
2481 let mut distribution_keys__ = None;
2482 while let Some(k) = map_.next_key()? {
2483 match k {
2484 GeneratedField::NeedOp => {
2485 if need_op__.is_some() {
2486 return Err(serde::de::Error::duplicate_field("needOp"));
2487 }
2488 need_op__ = Some(map_.next_value()?);
2489 }
2490 GeneratedField::DistributionKeys => {
2491 if distribution_keys__.is_some() {
2492 return Err(serde::de::Error::duplicate_field("distributionKeys"));
2493 }
2494 distribution_keys__ =
2495 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2496 .into_iter().map(|x| x.0).collect())
2497 ;
2498 }
2499 }
2500 }
2501 Ok(ChangeLogNode {
2502 need_op: need_op__.unwrap_or_default(),
2503 distribution_keys: distribution_keys__.unwrap_or_default(),
2504 })
2505 }
2506 }
2507 deserializer.deserialize_struct("stream_plan.ChangeLogNode", FIELDS, GeneratedVisitor)
2508 }
2509}
2510impl serde::Serialize for Columns {
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.columns.is_empty() {
2519 len += 1;
2520 }
2521 let mut struct_ser = serializer.serialize_struct("stream_plan.Columns", len)?;
2522 if !self.columns.is_empty() {
2523 struct_ser.serialize_field("columns", &self.columns)?;
2524 }
2525 struct_ser.end()
2526 }
2527}
2528impl<'de> serde::Deserialize<'de> for Columns {
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 "columns",
2536 ];
2537
2538 #[allow(clippy::enum_variant_names)]
2539 enum GeneratedField {
2540 Columns,
2541 }
2542 impl<'de> serde::Deserialize<'de> for GeneratedField {
2543 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2544 where
2545 D: serde::Deserializer<'de>,
2546 {
2547 struct GeneratedVisitor;
2548
2549 impl serde::de::Visitor<'_> for GeneratedVisitor {
2550 type Value = GeneratedField;
2551
2552 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2553 write!(formatter, "expected one of: {:?}", &FIELDS)
2554 }
2555
2556 #[allow(unused_variables)]
2557 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2558 where
2559 E: serde::de::Error,
2560 {
2561 match value {
2562 "columns" => Ok(GeneratedField::Columns),
2563 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2564 }
2565 }
2566 }
2567 deserializer.deserialize_identifier(GeneratedVisitor)
2568 }
2569 }
2570 struct GeneratedVisitor;
2571 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2572 type Value = Columns;
2573
2574 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2575 formatter.write_str("struct stream_plan.Columns")
2576 }
2577
2578 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Columns, V::Error>
2579 where
2580 V: serde::de::MapAccess<'de>,
2581 {
2582 let mut columns__ = None;
2583 while let Some(k) = map_.next_key()? {
2584 match k {
2585 GeneratedField::Columns => {
2586 if columns__.is_some() {
2587 return Err(serde::de::Error::duplicate_field("columns"));
2588 }
2589 columns__ = Some(map_.next_value()?);
2590 }
2591 }
2592 }
2593 Ok(Columns {
2594 columns: columns__.unwrap_or_default(),
2595 })
2596 }
2597 }
2598 deserializer.deserialize_struct("stream_plan.Columns", FIELDS, GeneratedVisitor)
2599 }
2600}
2601impl serde::Serialize for ConnectorPropsChangeMutation {
2602 #[allow(deprecated)]
2603 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2604 where
2605 S: serde::Serializer,
2606 {
2607 use serde::ser::SerializeStruct;
2608 let mut len = 0;
2609 if !self.connector_props_infos.is_empty() {
2610 len += 1;
2611 }
2612 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation", len)?;
2613 if !self.connector_props_infos.is_empty() {
2614 struct_ser.serialize_field("connectorPropsInfos", &self.connector_props_infos)?;
2615 }
2616 struct_ser.end()
2617 }
2618}
2619impl<'de> serde::Deserialize<'de> for ConnectorPropsChangeMutation {
2620 #[allow(deprecated)]
2621 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2622 where
2623 D: serde::Deserializer<'de>,
2624 {
2625 const FIELDS: &[&str] = &[
2626 "connector_props_infos",
2627 "connectorPropsInfos",
2628 ];
2629
2630 #[allow(clippy::enum_variant_names)]
2631 enum GeneratedField {
2632 ConnectorPropsInfos,
2633 }
2634 impl<'de> serde::Deserialize<'de> for GeneratedField {
2635 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2636 where
2637 D: serde::Deserializer<'de>,
2638 {
2639 struct GeneratedVisitor;
2640
2641 impl serde::de::Visitor<'_> for GeneratedVisitor {
2642 type Value = GeneratedField;
2643
2644 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2645 write!(formatter, "expected one of: {:?}", &FIELDS)
2646 }
2647
2648 #[allow(unused_variables)]
2649 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2650 where
2651 E: serde::de::Error,
2652 {
2653 match value {
2654 "connectorPropsInfos" | "connector_props_infos" => Ok(GeneratedField::ConnectorPropsInfos),
2655 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2656 }
2657 }
2658 }
2659 deserializer.deserialize_identifier(GeneratedVisitor)
2660 }
2661 }
2662 struct GeneratedVisitor;
2663 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2664 type Value = ConnectorPropsChangeMutation;
2665
2666 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2667 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation")
2668 }
2669
2670 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectorPropsChangeMutation, V::Error>
2671 where
2672 V: serde::de::MapAccess<'de>,
2673 {
2674 let mut connector_props_infos__ = None;
2675 while let Some(k) = map_.next_key()? {
2676 match k {
2677 GeneratedField::ConnectorPropsInfos => {
2678 if connector_props_infos__.is_some() {
2679 return Err(serde::de::Error::duplicate_field("connectorPropsInfos"));
2680 }
2681 connector_props_infos__ = Some(
2682 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
2683 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
2684 );
2685 }
2686 }
2687 }
2688 Ok(ConnectorPropsChangeMutation {
2689 connector_props_infos: connector_props_infos__.unwrap_or_default(),
2690 })
2691 }
2692 }
2693 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation", FIELDS, GeneratedVisitor)
2694 }
2695}
2696impl serde::Serialize for connector_props_change_mutation::ConnectorPropsInfo {
2697 #[allow(deprecated)]
2698 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2699 where
2700 S: serde::Serializer,
2701 {
2702 use serde::ser::SerializeStruct;
2703 let mut len = 0;
2704 if !self.connector_props_info.is_empty() {
2705 len += 1;
2706 }
2707 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", len)?;
2708 if !self.connector_props_info.is_empty() {
2709 struct_ser.serialize_field("connectorPropsInfo", &self.connector_props_info)?;
2710 }
2711 struct_ser.end()
2712 }
2713}
2714impl<'de> serde::Deserialize<'de> for connector_props_change_mutation::ConnectorPropsInfo {
2715 #[allow(deprecated)]
2716 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2717 where
2718 D: serde::Deserializer<'de>,
2719 {
2720 const FIELDS: &[&str] = &[
2721 "connector_props_info",
2722 "connectorPropsInfo",
2723 ];
2724
2725 #[allow(clippy::enum_variant_names)]
2726 enum GeneratedField {
2727 ConnectorPropsInfo,
2728 }
2729 impl<'de> serde::Deserialize<'de> for GeneratedField {
2730 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2731 where
2732 D: serde::Deserializer<'de>,
2733 {
2734 struct GeneratedVisitor;
2735
2736 impl serde::de::Visitor<'_> for GeneratedVisitor {
2737 type Value = GeneratedField;
2738
2739 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2740 write!(formatter, "expected one of: {:?}", &FIELDS)
2741 }
2742
2743 #[allow(unused_variables)]
2744 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2745 where
2746 E: serde::de::Error,
2747 {
2748 match value {
2749 "connectorPropsInfo" | "connector_props_info" => Ok(GeneratedField::ConnectorPropsInfo),
2750 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2751 }
2752 }
2753 }
2754 deserializer.deserialize_identifier(GeneratedVisitor)
2755 }
2756 }
2757 struct GeneratedVisitor;
2758 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2759 type Value = connector_props_change_mutation::ConnectorPropsInfo;
2760
2761 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2762 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo")
2763 }
2764
2765 fn visit_map<V>(self, mut map_: V) -> std::result::Result<connector_props_change_mutation::ConnectorPropsInfo, V::Error>
2766 where
2767 V: serde::de::MapAccess<'de>,
2768 {
2769 let mut connector_props_info__ = None;
2770 while let Some(k) = map_.next_key()? {
2771 match k {
2772 GeneratedField::ConnectorPropsInfo => {
2773 if connector_props_info__.is_some() {
2774 return Err(serde::de::Error::duplicate_field("connectorPropsInfo"));
2775 }
2776 connector_props_info__ = Some(
2777 map_.next_value::<std::collections::HashMap<_, _>>()?
2778 );
2779 }
2780 }
2781 }
2782 Ok(connector_props_change_mutation::ConnectorPropsInfo {
2783 connector_props_info: connector_props_info__.unwrap_or_default(),
2784 })
2785 }
2786 }
2787 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", FIELDS, GeneratedVisitor)
2788 }
2789}
2790impl serde::Serialize for DedupNode {
2791 #[allow(deprecated)]
2792 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2793 where
2794 S: serde::Serializer,
2795 {
2796 use serde::ser::SerializeStruct;
2797 let mut len = 0;
2798 if self.state_table.is_some() {
2799 len += 1;
2800 }
2801 if !self.dedup_column_indices.is_empty() {
2802 len += 1;
2803 }
2804 let mut struct_ser = serializer.serialize_struct("stream_plan.DedupNode", len)?;
2805 if let Some(v) = self.state_table.as_ref() {
2806 struct_ser.serialize_field("stateTable", v)?;
2807 }
2808 if !self.dedup_column_indices.is_empty() {
2809 struct_ser.serialize_field("dedupColumnIndices", &self.dedup_column_indices)?;
2810 }
2811 struct_ser.end()
2812 }
2813}
2814impl<'de> serde::Deserialize<'de> for DedupNode {
2815 #[allow(deprecated)]
2816 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2817 where
2818 D: serde::Deserializer<'de>,
2819 {
2820 const FIELDS: &[&str] = &[
2821 "state_table",
2822 "stateTable",
2823 "dedup_column_indices",
2824 "dedupColumnIndices",
2825 ];
2826
2827 #[allow(clippy::enum_variant_names)]
2828 enum GeneratedField {
2829 StateTable,
2830 DedupColumnIndices,
2831 }
2832 impl<'de> serde::Deserialize<'de> for GeneratedField {
2833 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2834 where
2835 D: serde::Deserializer<'de>,
2836 {
2837 struct GeneratedVisitor;
2838
2839 impl serde::de::Visitor<'_> for GeneratedVisitor {
2840 type Value = GeneratedField;
2841
2842 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2843 write!(formatter, "expected one of: {:?}", &FIELDS)
2844 }
2845
2846 #[allow(unused_variables)]
2847 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2848 where
2849 E: serde::de::Error,
2850 {
2851 match value {
2852 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
2853 "dedupColumnIndices" | "dedup_column_indices" => Ok(GeneratedField::DedupColumnIndices),
2854 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2855 }
2856 }
2857 }
2858 deserializer.deserialize_identifier(GeneratedVisitor)
2859 }
2860 }
2861 struct GeneratedVisitor;
2862 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2863 type Value = DedupNode;
2864
2865 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2866 formatter.write_str("struct stream_plan.DedupNode")
2867 }
2868
2869 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DedupNode, V::Error>
2870 where
2871 V: serde::de::MapAccess<'de>,
2872 {
2873 let mut state_table__ = None;
2874 let mut dedup_column_indices__ = None;
2875 while let Some(k) = map_.next_key()? {
2876 match k {
2877 GeneratedField::StateTable => {
2878 if state_table__.is_some() {
2879 return Err(serde::de::Error::duplicate_field("stateTable"));
2880 }
2881 state_table__ = map_.next_value()?;
2882 }
2883 GeneratedField::DedupColumnIndices => {
2884 if dedup_column_indices__.is_some() {
2885 return Err(serde::de::Error::duplicate_field("dedupColumnIndices"));
2886 }
2887 dedup_column_indices__ =
2888 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2889 .into_iter().map(|x| x.0).collect())
2890 ;
2891 }
2892 }
2893 }
2894 Ok(DedupNode {
2895 state_table: state_table__,
2896 dedup_column_indices: dedup_column_indices__.unwrap_or_default(),
2897 })
2898 }
2899 }
2900 deserializer.deserialize_struct("stream_plan.DedupNode", FIELDS, GeneratedVisitor)
2901 }
2902}
2903impl serde::Serialize for DeltaExpression {
2904 #[allow(deprecated)]
2905 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2906 where
2907 S: serde::Serializer,
2908 {
2909 use serde::ser::SerializeStruct;
2910 let mut len = 0;
2911 if self.delta_type != 0 {
2912 len += 1;
2913 }
2914 if self.delta.is_some() {
2915 len += 1;
2916 }
2917 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaExpression", len)?;
2918 if self.delta_type != 0 {
2919 let v = super::expr::expr_node::Type::try_from(self.delta_type)
2920 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.delta_type)))?;
2921 struct_ser.serialize_field("deltaType", &v)?;
2922 }
2923 if let Some(v) = self.delta.as_ref() {
2924 struct_ser.serialize_field("delta", v)?;
2925 }
2926 struct_ser.end()
2927 }
2928}
2929impl<'de> serde::Deserialize<'de> for DeltaExpression {
2930 #[allow(deprecated)]
2931 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2932 where
2933 D: serde::Deserializer<'de>,
2934 {
2935 const FIELDS: &[&str] = &[
2936 "delta_type",
2937 "deltaType",
2938 "delta",
2939 ];
2940
2941 #[allow(clippy::enum_variant_names)]
2942 enum GeneratedField {
2943 DeltaType,
2944 Delta,
2945 }
2946 impl<'de> serde::Deserialize<'de> for GeneratedField {
2947 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2948 where
2949 D: serde::Deserializer<'de>,
2950 {
2951 struct GeneratedVisitor;
2952
2953 impl serde::de::Visitor<'_> for GeneratedVisitor {
2954 type Value = GeneratedField;
2955
2956 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2957 write!(formatter, "expected one of: {:?}", &FIELDS)
2958 }
2959
2960 #[allow(unused_variables)]
2961 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2962 where
2963 E: serde::de::Error,
2964 {
2965 match value {
2966 "deltaType" | "delta_type" => Ok(GeneratedField::DeltaType),
2967 "delta" => Ok(GeneratedField::Delta),
2968 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2969 }
2970 }
2971 }
2972 deserializer.deserialize_identifier(GeneratedVisitor)
2973 }
2974 }
2975 struct GeneratedVisitor;
2976 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2977 type Value = DeltaExpression;
2978
2979 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2980 formatter.write_str("struct stream_plan.DeltaExpression")
2981 }
2982
2983 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaExpression, V::Error>
2984 where
2985 V: serde::de::MapAccess<'de>,
2986 {
2987 let mut delta_type__ = None;
2988 let mut delta__ = None;
2989 while let Some(k) = map_.next_key()? {
2990 match k {
2991 GeneratedField::DeltaType => {
2992 if delta_type__.is_some() {
2993 return Err(serde::de::Error::duplicate_field("deltaType"));
2994 }
2995 delta_type__ = Some(map_.next_value::<super::expr::expr_node::Type>()? as i32);
2996 }
2997 GeneratedField::Delta => {
2998 if delta__.is_some() {
2999 return Err(serde::de::Error::duplicate_field("delta"));
3000 }
3001 delta__ = map_.next_value()?;
3002 }
3003 }
3004 }
3005 Ok(DeltaExpression {
3006 delta_type: delta_type__.unwrap_or_default(),
3007 delta: delta__,
3008 })
3009 }
3010 }
3011 deserializer.deserialize_struct("stream_plan.DeltaExpression", FIELDS, GeneratedVisitor)
3012 }
3013}
3014impl serde::Serialize for DeltaIndexJoinNode {
3015 #[allow(deprecated)]
3016 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3017 where
3018 S: serde::Serializer,
3019 {
3020 use serde::ser::SerializeStruct;
3021 let mut len = 0;
3022 if self.join_type != 0 {
3023 len += 1;
3024 }
3025 if !self.left_key.is_empty() {
3026 len += 1;
3027 }
3028 if !self.right_key.is_empty() {
3029 len += 1;
3030 }
3031 if self.condition.is_some() {
3032 len += 1;
3033 }
3034 if self.left_table_id != 0 {
3035 len += 1;
3036 }
3037 if self.right_table_id != 0 {
3038 len += 1;
3039 }
3040 if self.left_info.is_some() {
3041 len += 1;
3042 }
3043 if self.right_info.is_some() {
3044 len += 1;
3045 }
3046 if !self.output_indices.is_empty() {
3047 len += 1;
3048 }
3049 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaIndexJoinNode", len)?;
3050 if self.join_type != 0 {
3051 let v = super::plan_common::JoinType::try_from(self.join_type)
3052 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
3053 struct_ser.serialize_field("joinType", &v)?;
3054 }
3055 if !self.left_key.is_empty() {
3056 struct_ser.serialize_field("leftKey", &self.left_key)?;
3057 }
3058 if !self.right_key.is_empty() {
3059 struct_ser.serialize_field("rightKey", &self.right_key)?;
3060 }
3061 if let Some(v) = self.condition.as_ref() {
3062 struct_ser.serialize_field("condition", v)?;
3063 }
3064 if self.left_table_id != 0 {
3065 struct_ser.serialize_field("leftTableId", &self.left_table_id)?;
3066 }
3067 if self.right_table_id != 0 {
3068 struct_ser.serialize_field("rightTableId", &self.right_table_id)?;
3069 }
3070 if let Some(v) = self.left_info.as_ref() {
3071 struct_ser.serialize_field("leftInfo", v)?;
3072 }
3073 if let Some(v) = self.right_info.as_ref() {
3074 struct_ser.serialize_field("rightInfo", v)?;
3075 }
3076 if !self.output_indices.is_empty() {
3077 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
3078 }
3079 struct_ser.end()
3080 }
3081}
3082impl<'de> serde::Deserialize<'de> for DeltaIndexJoinNode {
3083 #[allow(deprecated)]
3084 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3085 where
3086 D: serde::Deserializer<'de>,
3087 {
3088 const FIELDS: &[&str] = &[
3089 "join_type",
3090 "joinType",
3091 "left_key",
3092 "leftKey",
3093 "right_key",
3094 "rightKey",
3095 "condition",
3096 "left_table_id",
3097 "leftTableId",
3098 "right_table_id",
3099 "rightTableId",
3100 "left_info",
3101 "leftInfo",
3102 "right_info",
3103 "rightInfo",
3104 "output_indices",
3105 "outputIndices",
3106 ];
3107
3108 #[allow(clippy::enum_variant_names)]
3109 enum GeneratedField {
3110 JoinType,
3111 LeftKey,
3112 RightKey,
3113 Condition,
3114 LeftTableId,
3115 RightTableId,
3116 LeftInfo,
3117 RightInfo,
3118 OutputIndices,
3119 }
3120 impl<'de> serde::Deserialize<'de> for GeneratedField {
3121 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3122 where
3123 D: serde::Deserializer<'de>,
3124 {
3125 struct GeneratedVisitor;
3126
3127 impl serde::de::Visitor<'_> for GeneratedVisitor {
3128 type Value = GeneratedField;
3129
3130 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3131 write!(formatter, "expected one of: {:?}", &FIELDS)
3132 }
3133
3134 #[allow(unused_variables)]
3135 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3136 where
3137 E: serde::de::Error,
3138 {
3139 match value {
3140 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
3141 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
3142 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
3143 "condition" => Ok(GeneratedField::Condition),
3144 "leftTableId" | "left_table_id" => Ok(GeneratedField::LeftTableId),
3145 "rightTableId" | "right_table_id" => Ok(GeneratedField::RightTableId),
3146 "leftInfo" | "left_info" => Ok(GeneratedField::LeftInfo),
3147 "rightInfo" | "right_info" => Ok(GeneratedField::RightInfo),
3148 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
3149 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3150 }
3151 }
3152 }
3153 deserializer.deserialize_identifier(GeneratedVisitor)
3154 }
3155 }
3156 struct GeneratedVisitor;
3157 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3158 type Value = DeltaIndexJoinNode;
3159
3160 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3161 formatter.write_str("struct stream_plan.DeltaIndexJoinNode")
3162 }
3163
3164 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaIndexJoinNode, V::Error>
3165 where
3166 V: serde::de::MapAccess<'de>,
3167 {
3168 let mut join_type__ = None;
3169 let mut left_key__ = None;
3170 let mut right_key__ = None;
3171 let mut condition__ = None;
3172 let mut left_table_id__ = None;
3173 let mut right_table_id__ = None;
3174 let mut left_info__ = None;
3175 let mut right_info__ = None;
3176 let mut output_indices__ = None;
3177 while let Some(k) = map_.next_key()? {
3178 match k {
3179 GeneratedField::JoinType => {
3180 if join_type__.is_some() {
3181 return Err(serde::de::Error::duplicate_field("joinType"));
3182 }
3183 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
3184 }
3185 GeneratedField::LeftKey => {
3186 if left_key__.is_some() {
3187 return Err(serde::de::Error::duplicate_field("leftKey"));
3188 }
3189 left_key__ =
3190 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3191 .into_iter().map(|x| x.0).collect())
3192 ;
3193 }
3194 GeneratedField::RightKey => {
3195 if right_key__.is_some() {
3196 return Err(serde::de::Error::duplicate_field("rightKey"));
3197 }
3198 right_key__ =
3199 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3200 .into_iter().map(|x| x.0).collect())
3201 ;
3202 }
3203 GeneratedField::Condition => {
3204 if condition__.is_some() {
3205 return Err(serde::de::Error::duplicate_field("condition"));
3206 }
3207 condition__ = map_.next_value()?;
3208 }
3209 GeneratedField::LeftTableId => {
3210 if left_table_id__.is_some() {
3211 return Err(serde::de::Error::duplicate_field("leftTableId"));
3212 }
3213 left_table_id__ =
3214 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3215 ;
3216 }
3217 GeneratedField::RightTableId => {
3218 if right_table_id__.is_some() {
3219 return Err(serde::de::Error::duplicate_field("rightTableId"));
3220 }
3221 right_table_id__ =
3222 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3223 ;
3224 }
3225 GeneratedField::LeftInfo => {
3226 if left_info__.is_some() {
3227 return Err(serde::de::Error::duplicate_field("leftInfo"));
3228 }
3229 left_info__ = map_.next_value()?;
3230 }
3231 GeneratedField::RightInfo => {
3232 if right_info__.is_some() {
3233 return Err(serde::de::Error::duplicate_field("rightInfo"));
3234 }
3235 right_info__ = map_.next_value()?;
3236 }
3237 GeneratedField::OutputIndices => {
3238 if output_indices__.is_some() {
3239 return Err(serde::de::Error::duplicate_field("outputIndices"));
3240 }
3241 output_indices__ =
3242 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3243 .into_iter().map(|x| x.0).collect())
3244 ;
3245 }
3246 }
3247 }
3248 Ok(DeltaIndexJoinNode {
3249 join_type: join_type__.unwrap_or_default(),
3250 left_key: left_key__.unwrap_or_default(),
3251 right_key: right_key__.unwrap_or_default(),
3252 condition: condition__,
3253 left_table_id: left_table_id__.unwrap_or_default(),
3254 right_table_id: right_table_id__.unwrap_or_default(),
3255 left_info: left_info__,
3256 right_info: right_info__,
3257 output_indices: output_indices__.unwrap_or_default(),
3258 })
3259 }
3260 }
3261 deserializer.deserialize_struct("stream_plan.DeltaIndexJoinNode", FIELDS, GeneratedVisitor)
3262 }
3263}
3264impl serde::Serialize for DispatchOutputMapping {
3265 #[allow(deprecated)]
3266 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3267 where
3268 S: serde::Serializer,
3269 {
3270 use serde::ser::SerializeStruct;
3271 let mut len = 0;
3272 if !self.indices.is_empty() {
3273 len += 1;
3274 }
3275 if !self.types.is_empty() {
3276 len += 1;
3277 }
3278 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping", len)?;
3279 if !self.indices.is_empty() {
3280 struct_ser.serialize_field("indices", &self.indices)?;
3281 }
3282 if !self.types.is_empty() {
3283 struct_ser.serialize_field("types", &self.types)?;
3284 }
3285 struct_ser.end()
3286 }
3287}
3288impl<'de> serde::Deserialize<'de> for DispatchOutputMapping {
3289 #[allow(deprecated)]
3290 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3291 where
3292 D: serde::Deserializer<'de>,
3293 {
3294 const FIELDS: &[&str] = &[
3295 "indices",
3296 "types",
3297 ];
3298
3299 #[allow(clippy::enum_variant_names)]
3300 enum GeneratedField {
3301 Indices,
3302 Types,
3303 }
3304 impl<'de> serde::Deserialize<'de> for GeneratedField {
3305 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3306 where
3307 D: serde::Deserializer<'de>,
3308 {
3309 struct GeneratedVisitor;
3310
3311 impl serde::de::Visitor<'_> for GeneratedVisitor {
3312 type Value = GeneratedField;
3313
3314 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3315 write!(formatter, "expected one of: {:?}", &FIELDS)
3316 }
3317
3318 #[allow(unused_variables)]
3319 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3320 where
3321 E: serde::de::Error,
3322 {
3323 match value {
3324 "indices" => Ok(GeneratedField::Indices),
3325 "types" => Ok(GeneratedField::Types),
3326 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3327 }
3328 }
3329 }
3330 deserializer.deserialize_identifier(GeneratedVisitor)
3331 }
3332 }
3333 struct GeneratedVisitor;
3334 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3335 type Value = DispatchOutputMapping;
3336
3337 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3338 formatter.write_str("struct stream_plan.DispatchOutputMapping")
3339 }
3340
3341 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchOutputMapping, V::Error>
3342 where
3343 V: serde::de::MapAccess<'de>,
3344 {
3345 let mut indices__ = None;
3346 let mut types__ = None;
3347 while let Some(k) = map_.next_key()? {
3348 match k {
3349 GeneratedField::Indices => {
3350 if indices__.is_some() {
3351 return Err(serde::de::Error::duplicate_field("indices"));
3352 }
3353 indices__ =
3354 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3355 .into_iter().map(|x| x.0).collect())
3356 ;
3357 }
3358 GeneratedField::Types => {
3359 if types__.is_some() {
3360 return Err(serde::de::Error::duplicate_field("types"));
3361 }
3362 types__ = Some(map_.next_value()?);
3363 }
3364 }
3365 }
3366 Ok(DispatchOutputMapping {
3367 indices: indices__.unwrap_or_default(),
3368 types: types__.unwrap_or_default(),
3369 })
3370 }
3371 }
3372 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping", FIELDS, GeneratedVisitor)
3373 }
3374}
3375impl serde::Serialize for dispatch_output_mapping::TypePair {
3376 #[allow(deprecated)]
3377 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3378 where
3379 S: serde::Serializer,
3380 {
3381 use serde::ser::SerializeStruct;
3382 let mut len = 0;
3383 if self.upstream.is_some() {
3384 len += 1;
3385 }
3386 if self.downstream.is_some() {
3387 len += 1;
3388 }
3389 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping.TypePair", len)?;
3390 if let Some(v) = self.upstream.as_ref() {
3391 struct_ser.serialize_field("upstream", v)?;
3392 }
3393 if let Some(v) = self.downstream.as_ref() {
3394 struct_ser.serialize_field("downstream", v)?;
3395 }
3396 struct_ser.end()
3397 }
3398}
3399impl<'de> serde::Deserialize<'de> for dispatch_output_mapping::TypePair {
3400 #[allow(deprecated)]
3401 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3402 where
3403 D: serde::Deserializer<'de>,
3404 {
3405 const FIELDS: &[&str] = &[
3406 "upstream",
3407 "downstream",
3408 ];
3409
3410 #[allow(clippy::enum_variant_names)]
3411 enum GeneratedField {
3412 Upstream,
3413 Downstream,
3414 }
3415 impl<'de> serde::Deserialize<'de> for GeneratedField {
3416 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3417 where
3418 D: serde::Deserializer<'de>,
3419 {
3420 struct GeneratedVisitor;
3421
3422 impl serde::de::Visitor<'_> for GeneratedVisitor {
3423 type Value = GeneratedField;
3424
3425 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3426 write!(formatter, "expected one of: {:?}", &FIELDS)
3427 }
3428
3429 #[allow(unused_variables)]
3430 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3431 where
3432 E: serde::de::Error,
3433 {
3434 match value {
3435 "upstream" => Ok(GeneratedField::Upstream),
3436 "downstream" => Ok(GeneratedField::Downstream),
3437 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3438 }
3439 }
3440 }
3441 deserializer.deserialize_identifier(GeneratedVisitor)
3442 }
3443 }
3444 struct GeneratedVisitor;
3445 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3446 type Value = dispatch_output_mapping::TypePair;
3447
3448 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3449 formatter.write_str("struct stream_plan.DispatchOutputMapping.TypePair")
3450 }
3451
3452 fn visit_map<V>(self, mut map_: V) -> std::result::Result<dispatch_output_mapping::TypePair, V::Error>
3453 where
3454 V: serde::de::MapAccess<'de>,
3455 {
3456 let mut upstream__ = None;
3457 let mut downstream__ = None;
3458 while let Some(k) = map_.next_key()? {
3459 match k {
3460 GeneratedField::Upstream => {
3461 if upstream__.is_some() {
3462 return Err(serde::de::Error::duplicate_field("upstream"));
3463 }
3464 upstream__ = map_.next_value()?;
3465 }
3466 GeneratedField::Downstream => {
3467 if downstream__.is_some() {
3468 return Err(serde::de::Error::duplicate_field("downstream"));
3469 }
3470 downstream__ = map_.next_value()?;
3471 }
3472 }
3473 }
3474 Ok(dispatch_output_mapping::TypePair {
3475 upstream: upstream__,
3476 downstream: downstream__,
3477 })
3478 }
3479 }
3480 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping.TypePair", FIELDS, GeneratedVisitor)
3481 }
3482}
3483impl serde::Serialize for DispatchStrategy {
3484 #[allow(deprecated)]
3485 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3486 where
3487 S: serde::Serializer,
3488 {
3489 use serde::ser::SerializeStruct;
3490 let mut len = 0;
3491 if self.r#type != 0 {
3492 len += 1;
3493 }
3494 if !self.dist_key_indices.is_empty() {
3495 len += 1;
3496 }
3497 if self.output_mapping.is_some() {
3498 len += 1;
3499 }
3500 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchStrategy", len)?;
3501 if self.r#type != 0 {
3502 let v = DispatcherType::try_from(self.r#type)
3503 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3504 struct_ser.serialize_field("type", &v)?;
3505 }
3506 if !self.dist_key_indices.is_empty() {
3507 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3508 }
3509 if let Some(v) = self.output_mapping.as_ref() {
3510 struct_ser.serialize_field("outputMapping", v)?;
3511 }
3512 struct_ser.end()
3513 }
3514}
3515impl<'de> serde::Deserialize<'de> for DispatchStrategy {
3516 #[allow(deprecated)]
3517 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3518 where
3519 D: serde::Deserializer<'de>,
3520 {
3521 const FIELDS: &[&str] = &[
3522 "type",
3523 "dist_key_indices",
3524 "distKeyIndices",
3525 "output_mapping",
3526 "outputMapping",
3527 ];
3528
3529 #[allow(clippy::enum_variant_names)]
3530 enum GeneratedField {
3531 Type,
3532 DistKeyIndices,
3533 OutputMapping,
3534 }
3535 impl<'de> serde::Deserialize<'de> for GeneratedField {
3536 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3537 where
3538 D: serde::Deserializer<'de>,
3539 {
3540 struct GeneratedVisitor;
3541
3542 impl serde::de::Visitor<'_> for GeneratedVisitor {
3543 type Value = GeneratedField;
3544
3545 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3546 write!(formatter, "expected one of: {:?}", &FIELDS)
3547 }
3548
3549 #[allow(unused_variables)]
3550 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3551 where
3552 E: serde::de::Error,
3553 {
3554 match value {
3555 "type" => Ok(GeneratedField::Type),
3556 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3557 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3558 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3559 }
3560 }
3561 }
3562 deserializer.deserialize_identifier(GeneratedVisitor)
3563 }
3564 }
3565 struct GeneratedVisitor;
3566 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3567 type Value = DispatchStrategy;
3568
3569 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3570 formatter.write_str("struct stream_plan.DispatchStrategy")
3571 }
3572
3573 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchStrategy, V::Error>
3574 where
3575 V: serde::de::MapAccess<'de>,
3576 {
3577 let mut r#type__ = None;
3578 let mut dist_key_indices__ = None;
3579 let mut output_mapping__ = None;
3580 while let Some(k) = map_.next_key()? {
3581 match k {
3582 GeneratedField::Type => {
3583 if r#type__.is_some() {
3584 return Err(serde::de::Error::duplicate_field("type"));
3585 }
3586 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3587 }
3588 GeneratedField::DistKeyIndices => {
3589 if dist_key_indices__.is_some() {
3590 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3591 }
3592 dist_key_indices__ =
3593 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3594 .into_iter().map(|x| x.0).collect())
3595 ;
3596 }
3597 GeneratedField::OutputMapping => {
3598 if output_mapping__.is_some() {
3599 return Err(serde::de::Error::duplicate_field("outputMapping"));
3600 }
3601 output_mapping__ = map_.next_value()?;
3602 }
3603 }
3604 }
3605 Ok(DispatchStrategy {
3606 r#type: r#type__.unwrap_or_default(),
3607 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3608 output_mapping: output_mapping__,
3609 })
3610 }
3611 }
3612 deserializer.deserialize_struct("stream_plan.DispatchStrategy", FIELDS, GeneratedVisitor)
3613 }
3614}
3615impl serde::Serialize for Dispatcher {
3616 #[allow(deprecated)]
3617 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3618 where
3619 S: serde::Serializer,
3620 {
3621 use serde::ser::SerializeStruct;
3622 let mut len = 0;
3623 if self.r#type != 0 {
3624 len += 1;
3625 }
3626 if !self.dist_key_indices.is_empty() {
3627 len += 1;
3628 }
3629 if self.output_mapping.is_some() {
3630 len += 1;
3631 }
3632 if self.hash_mapping.is_some() {
3633 len += 1;
3634 }
3635 if self.dispatcher_id != 0 {
3636 len += 1;
3637 }
3638 if !self.downstream_actor_id.is_empty() {
3639 len += 1;
3640 }
3641 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatcher", len)?;
3642 if self.r#type != 0 {
3643 let v = DispatcherType::try_from(self.r#type)
3644 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3645 struct_ser.serialize_field("type", &v)?;
3646 }
3647 if !self.dist_key_indices.is_empty() {
3648 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3649 }
3650 if let Some(v) = self.output_mapping.as_ref() {
3651 struct_ser.serialize_field("outputMapping", v)?;
3652 }
3653 if let Some(v) = self.hash_mapping.as_ref() {
3654 struct_ser.serialize_field("hashMapping", v)?;
3655 }
3656 if self.dispatcher_id != 0 {
3657 struct_ser.serialize_field("dispatcherId", &self.dispatcher_id)?;
3658 }
3659 if !self.downstream_actor_id.is_empty() {
3660 struct_ser.serialize_field("downstreamActorId", &self.downstream_actor_id)?;
3661 }
3662 struct_ser.end()
3663 }
3664}
3665impl<'de> serde::Deserialize<'de> for Dispatcher {
3666 #[allow(deprecated)]
3667 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3668 where
3669 D: serde::Deserializer<'de>,
3670 {
3671 const FIELDS: &[&str] = &[
3672 "type",
3673 "dist_key_indices",
3674 "distKeyIndices",
3675 "output_mapping",
3676 "outputMapping",
3677 "hash_mapping",
3678 "hashMapping",
3679 "dispatcher_id",
3680 "dispatcherId",
3681 "downstream_actor_id",
3682 "downstreamActorId",
3683 ];
3684
3685 #[allow(clippy::enum_variant_names)]
3686 enum GeneratedField {
3687 Type,
3688 DistKeyIndices,
3689 OutputMapping,
3690 HashMapping,
3691 DispatcherId,
3692 DownstreamActorId,
3693 }
3694 impl<'de> serde::Deserialize<'de> for GeneratedField {
3695 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3696 where
3697 D: serde::Deserializer<'de>,
3698 {
3699 struct GeneratedVisitor;
3700
3701 impl serde::de::Visitor<'_> for GeneratedVisitor {
3702 type Value = GeneratedField;
3703
3704 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3705 write!(formatter, "expected one of: {:?}", &FIELDS)
3706 }
3707
3708 #[allow(unused_variables)]
3709 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3710 where
3711 E: serde::de::Error,
3712 {
3713 match value {
3714 "type" => Ok(GeneratedField::Type),
3715 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3716 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3717 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
3718 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
3719 "downstreamActorId" | "downstream_actor_id" => Ok(GeneratedField::DownstreamActorId),
3720 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3721 }
3722 }
3723 }
3724 deserializer.deserialize_identifier(GeneratedVisitor)
3725 }
3726 }
3727 struct GeneratedVisitor;
3728 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3729 type Value = Dispatcher;
3730
3731 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3732 formatter.write_str("struct stream_plan.Dispatcher")
3733 }
3734
3735 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatcher, V::Error>
3736 where
3737 V: serde::de::MapAccess<'de>,
3738 {
3739 let mut r#type__ = None;
3740 let mut dist_key_indices__ = None;
3741 let mut output_mapping__ = None;
3742 let mut hash_mapping__ = None;
3743 let mut dispatcher_id__ = None;
3744 let mut downstream_actor_id__ = None;
3745 while let Some(k) = map_.next_key()? {
3746 match k {
3747 GeneratedField::Type => {
3748 if r#type__.is_some() {
3749 return Err(serde::de::Error::duplicate_field("type"));
3750 }
3751 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3752 }
3753 GeneratedField::DistKeyIndices => {
3754 if dist_key_indices__.is_some() {
3755 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3756 }
3757 dist_key_indices__ =
3758 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3759 .into_iter().map(|x| x.0).collect())
3760 ;
3761 }
3762 GeneratedField::OutputMapping => {
3763 if output_mapping__.is_some() {
3764 return Err(serde::de::Error::duplicate_field("outputMapping"));
3765 }
3766 output_mapping__ = map_.next_value()?;
3767 }
3768 GeneratedField::HashMapping => {
3769 if hash_mapping__.is_some() {
3770 return Err(serde::de::Error::duplicate_field("hashMapping"));
3771 }
3772 hash_mapping__ = map_.next_value()?;
3773 }
3774 GeneratedField::DispatcherId => {
3775 if dispatcher_id__.is_some() {
3776 return Err(serde::de::Error::duplicate_field("dispatcherId"));
3777 }
3778 dispatcher_id__ =
3779 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3780 ;
3781 }
3782 GeneratedField::DownstreamActorId => {
3783 if downstream_actor_id__.is_some() {
3784 return Err(serde::de::Error::duplicate_field("downstreamActorId"));
3785 }
3786 downstream_actor_id__ =
3787 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3788 .into_iter().map(|x| x.0).collect())
3789 ;
3790 }
3791 }
3792 }
3793 Ok(Dispatcher {
3794 r#type: r#type__.unwrap_or_default(),
3795 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3796 output_mapping: output_mapping__,
3797 hash_mapping: hash_mapping__,
3798 dispatcher_id: dispatcher_id__.unwrap_or_default(),
3799 downstream_actor_id: downstream_actor_id__.unwrap_or_default(),
3800 })
3801 }
3802 }
3803 deserializer.deserialize_struct("stream_plan.Dispatcher", FIELDS, GeneratedVisitor)
3804 }
3805}
3806impl serde::Serialize for DispatcherType {
3807 #[allow(deprecated)]
3808 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3809 where
3810 S: serde::Serializer,
3811 {
3812 let variant = match self {
3813 Self::Unspecified => "DISPATCHER_TYPE_UNSPECIFIED",
3814 Self::Hash => "DISPATCHER_TYPE_HASH",
3815 Self::Broadcast => "DISPATCHER_TYPE_BROADCAST",
3816 Self::Simple => "DISPATCHER_TYPE_SIMPLE",
3817 Self::NoShuffle => "DISPATCHER_TYPE_NO_SHUFFLE",
3818 };
3819 serializer.serialize_str(variant)
3820 }
3821}
3822impl<'de> serde::Deserialize<'de> for DispatcherType {
3823 #[allow(deprecated)]
3824 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3825 where
3826 D: serde::Deserializer<'de>,
3827 {
3828 const FIELDS: &[&str] = &[
3829 "DISPATCHER_TYPE_UNSPECIFIED",
3830 "DISPATCHER_TYPE_HASH",
3831 "DISPATCHER_TYPE_BROADCAST",
3832 "DISPATCHER_TYPE_SIMPLE",
3833 "DISPATCHER_TYPE_NO_SHUFFLE",
3834 ];
3835
3836 struct GeneratedVisitor;
3837
3838 impl serde::de::Visitor<'_> for GeneratedVisitor {
3839 type Value = DispatcherType;
3840
3841 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3842 write!(formatter, "expected one of: {:?}", &FIELDS)
3843 }
3844
3845 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3846 where
3847 E: serde::de::Error,
3848 {
3849 i32::try_from(v)
3850 .ok()
3851 .and_then(|x| x.try_into().ok())
3852 .ok_or_else(|| {
3853 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3854 })
3855 }
3856
3857 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3858 where
3859 E: serde::de::Error,
3860 {
3861 i32::try_from(v)
3862 .ok()
3863 .and_then(|x| x.try_into().ok())
3864 .ok_or_else(|| {
3865 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3866 })
3867 }
3868
3869 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3870 where
3871 E: serde::de::Error,
3872 {
3873 match value {
3874 "DISPATCHER_TYPE_UNSPECIFIED" => Ok(DispatcherType::Unspecified),
3875 "DISPATCHER_TYPE_HASH" => Ok(DispatcherType::Hash),
3876 "DISPATCHER_TYPE_BROADCAST" => Ok(DispatcherType::Broadcast),
3877 "DISPATCHER_TYPE_SIMPLE" => Ok(DispatcherType::Simple),
3878 "DISPATCHER_TYPE_NO_SHUFFLE" => Ok(DispatcherType::NoShuffle),
3879 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3880 }
3881 }
3882 }
3883 deserializer.deserialize_any(GeneratedVisitor)
3884 }
3885}
3886impl serde::Serialize for Dispatchers {
3887 #[allow(deprecated)]
3888 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3889 where
3890 S: serde::Serializer,
3891 {
3892 use serde::ser::SerializeStruct;
3893 let mut len = 0;
3894 if !self.dispatchers.is_empty() {
3895 len += 1;
3896 }
3897 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatchers", len)?;
3898 if !self.dispatchers.is_empty() {
3899 struct_ser.serialize_field("dispatchers", &self.dispatchers)?;
3900 }
3901 struct_ser.end()
3902 }
3903}
3904impl<'de> serde::Deserialize<'de> for Dispatchers {
3905 #[allow(deprecated)]
3906 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3907 where
3908 D: serde::Deserializer<'de>,
3909 {
3910 const FIELDS: &[&str] = &[
3911 "dispatchers",
3912 ];
3913
3914 #[allow(clippy::enum_variant_names)]
3915 enum GeneratedField {
3916 Dispatchers,
3917 }
3918 impl<'de> serde::Deserialize<'de> for GeneratedField {
3919 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3920 where
3921 D: serde::Deserializer<'de>,
3922 {
3923 struct GeneratedVisitor;
3924
3925 impl serde::de::Visitor<'_> for GeneratedVisitor {
3926 type Value = GeneratedField;
3927
3928 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3929 write!(formatter, "expected one of: {:?}", &FIELDS)
3930 }
3931
3932 #[allow(unused_variables)]
3933 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3934 where
3935 E: serde::de::Error,
3936 {
3937 match value {
3938 "dispatchers" => Ok(GeneratedField::Dispatchers),
3939 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3940 }
3941 }
3942 }
3943 deserializer.deserialize_identifier(GeneratedVisitor)
3944 }
3945 }
3946 struct GeneratedVisitor;
3947 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3948 type Value = Dispatchers;
3949
3950 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3951 formatter.write_str("struct stream_plan.Dispatchers")
3952 }
3953
3954 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatchers, V::Error>
3955 where
3956 V: serde::de::MapAccess<'de>,
3957 {
3958 let mut dispatchers__ = None;
3959 while let Some(k) = map_.next_key()? {
3960 match k {
3961 GeneratedField::Dispatchers => {
3962 if dispatchers__.is_some() {
3963 return Err(serde::de::Error::duplicate_field("dispatchers"));
3964 }
3965 dispatchers__ = Some(map_.next_value()?);
3966 }
3967 }
3968 }
3969 Ok(Dispatchers {
3970 dispatchers: dispatchers__.unwrap_or_default(),
3971 })
3972 }
3973 }
3974 deserializer.deserialize_struct("stream_plan.Dispatchers", FIELDS, GeneratedVisitor)
3975 }
3976}
3977impl serde::Serialize for DmlNode {
3978 #[allow(deprecated)]
3979 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3980 where
3981 S: serde::Serializer,
3982 {
3983 use serde::ser::SerializeStruct;
3984 let mut len = 0;
3985 if self.table_id != 0 {
3986 len += 1;
3987 }
3988 if self.table_version_id != 0 {
3989 len += 1;
3990 }
3991 if !self.column_descs.is_empty() {
3992 len += 1;
3993 }
3994 if self.rate_limit.is_some() {
3995 len += 1;
3996 }
3997 let mut struct_ser = serializer.serialize_struct("stream_plan.DmlNode", len)?;
3998 if self.table_id != 0 {
3999 struct_ser.serialize_field("tableId", &self.table_id)?;
4000 }
4001 if self.table_version_id != 0 {
4002 #[allow(clippy::needless_borrow)]
4003 #[allow(clippy::needless_borrows_for_generic_args)]
4004 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
4005 }
4006 if !self.column_descs.is_empty() {
4007 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
4008 }
4009 if let Some(v) = self.rate_limit.as_ref() {
4010 struct_ser.serialize_field("rateLimit", v)?;
4011 }
4012 struct_ser.end()
4013 }
4014}
4015impl<'de> serde::Deserialize<'de> for DmlNode {
4016 #[allow(deprecated)]
4017 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4018 where
4019 D: serde::Deserializer<'de>,
4020 {
4021 const FIELDS: &[&str] = &[
4022 "table_id",
4023 "tableId",
4024 "table_version_id",
4025 "tableVersionId",
4026 "column_descs",
4027 "columnDescs",
4028 "rate_limit",
4029 "rateLimit",
4030 ];
4031
4032 #[allow(clippy::enum_variant_names)]
4033 enum GeneratedField {
4034 TableId,
4035 TableVersionId,
4036 ColumnDescs,
4037 RateLimit,
4038 }
4039 impl<'de> serde::Deserialize<'de> for GeneratedField {
4040 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4041 where
4042 D: serde::Deserializer<'de>,
4043 {
4044 struct GeneratedVisitor;
4045
4046 impl serde::de::Visitor<'_> for GeneratedVisitor {
4047 type Value = GeneratedField;
4048
4049 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4050 write!(formatter, "expected one of: {:?}", &FIELDS)
4051 }
4052
4053 #[allow(unused_variables)]
4054 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4055 where
4056 E: serde::de::Error,
4057 {
4058 match value {
4059 "tableId" | "table_id" => Ok(GeneratedField::TableId),
4060 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
4061 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
4062 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
4063 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4064 }
4065 }
4066 }
4067 deserializer.deserialize_identifier(GeneratedVisitor)
4068 }
4069 }
4070 struct GeneratedVisitor;
4071 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4072 type Value = DmlNode;
4073
4074 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4075 formatter.write_str("struct stream_plan.DmlNode")
4076 }
4077
4078 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DmlNode, V::Error>
4079 where
4080 V: serde::de::MapAccess<'de>,
4081 {
4082 let mut table_id__ = None;
4083 let mut table_version_id__ = None;
4084 let mut column_descs__ = None;
4085 let mut rate_limit__ = None;
4086 while let Some(k) = map_.next_key()? {
4087 match k {
4088 GeneratedField::TableId => {
4089 if table_id__.is_some() {
4090 return Err(serde::de::Error::duplicate_field("tableId"));
4091 }
4092 table_id__ =
4093 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4094 ;
4095 }
4096 GeneratedField::TableVersionId => {
4097 if table_version_id__.is_some() {
4098 return Err(serde::de::Error::duplicate_field("tableVersionId"));
4099 }
4100 table_version_id__ =
4101 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4102 ;
4103 }
4104 GeneratedField::ColumnDescs => {
4105 if column_descs__.is_some() {
4106 return Err(serde::de::Error::duplicate_field("columnDescs"));
4107 }
4108 column_descs__ = Some(map_.next_value()?);
4109 }
4110 GeneratedField::RateLimit => {
4111 if rate_limit__.is_some() {
4112 return Err(serde::de::Error::duplicate_field("rateLimit"));
4113 }
4114 rate_limit__ =
4115 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4116 ;
4117 }
4118 }
4119 }
4120 Ok(DmlNode {
4121 table_id: table_id__.unwrap_or_default(),
4122 table_version_id: table_version_id__.unwrap_or_default(),
4123 column_descs: column_descs__.unwrap_or_default(),
4124 rate_limit: rate_limit__,
4125 })
4126 }
4127 }
4128 deserializer.deserialize_struct("stream_plan.DmlNode", FIELDS, GeneratedVisitor)
4129 }
4130}
4131impl serde::Serialize for DropSubscriptionsMutation {
4132 #[allow(deprecated)]
4133 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4134 where
4135 S: serde::Serializer,
4136 {
4137 use serde::ser::SerializeStruct;
4138 let mut len = 0;
4139 if !self.info.is_empty() {
4140 len += 1;
4141 }
4142 let mut struct_ser = serializer.serialize_struct("stream_plan.DropSubscriptionsMutation", len)?;
4143 if !self.info.is_empty() {
4144 struct_ser.serialize_field("info", &self.info)?;
4145 }
4146 struct_ser.end()
4147 }
4148}
4149impl<'de> serde::Deserialize<'de> for DropSubscriptionsMutation {
4150 #[allow(deprecated)]
4151 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4152 where
4153 D: serde::Deserializer<'de>,
4154 {
4155 const FIELDS: &[&str] = &[
4156 "info",
4157 ];
4158
4159 #[allow(clippy::enum_variant_names)]
4160 enum GeneratedField {
4161 Info,
4162 }
4163 impl<'de> serde::Deserialize<'de> for GeneratedField {
4164 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4165 where
4166 D: serde::Deserializer<'de>,
4167 {
4168 struct GeneratedVisitor;
4169
4170 impl serde::de::Visitor<'_> for GeneratedVisitor {
4171 type Value = GeneratedField;
4172
4173 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4174 write!(formatter, "expected one of: {:?}", &FIELDS)
4175 }
4176
4177 #[allow(unused_variables)]
4178 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4179 where
4180 E: serde::de::Error,
4181 {
4182 match value {
4183 "info" => Ok(GeneratedField::Info),
4184 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4185 }
4186 }
4187 }
4188 deserializer.deserialize_identifier(GeneratedVisitor)
4189 }
4190 }
4191 struct GeneratedVisitor;
4192 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4193 type Value = DropSubscriptionsMutation;
4194
4195 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4196 formatter.write_str("struct stream_plan.DropSubscriptionsMutation")
4197 }
4198
4199 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionsMutation, V::Error>
4200 where
4201 V: serde::de::MapAccess<'de>,
4202 {
4203 let mut info__ = None;
4204 while let Some(k) = map_.next_key()? {
4205 match k {
4206 GeneratedField::Info => {
4207 if info__.is_some() {
4208 return Err(serde::de::Error::duplicate_field("info"));
4209 }
4210 info__ = Some(map_.next_value()?);
4211 }
4212 }
4213 }
4214 Ok(DropSubscriptionsMutation {
4215 info: info__.unwrap_or_default(),
4216 })
4217 }
4218 }
4219 deserializer.deserialize_struct("stream_plan.DropSubscriptionsMutation", FIELDS, GeneratedVisitor)
4220 }
4221}
4222impl serde::Serialize for DynamicFilterNode {
4223 #[allow(deprecated)]
4224 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4225 where
4226 S: serde::Serializer,
4227 {
4228 use serde::ser::SerializeStruct;
4229 let mut len = 0;
4230 if self.left_key != 0 {
4231 len += 1;
4232 }
4233 if self.condition.is_some() {
4234 len += 1;
4235 }
4236 if self.left_table.is_some() {
4237 len += 1;
4238 }
4239 if self.right_table.is_some() {
4240 len += 1;
4241 }
4242 if self.condition_always_relax {
4243 len += 1;
4244 }
4245 if self.cleaned_by_watermark {
4246 len += 1;
4247 }
4248 let mut struct_ser = serializer.serialize_struct("stream_plan.DynamicFilterNode", len)?;
4249 if self.left_key != 0 {
4250 struct_ser.serialize_field("leftKey", &self.left_key)?;
4251 }
4252 if let Some(v) = self.condition.as_ref() {
4253 struct_ser.serialize_field("condition", v)?;
4254 }
4255 if let Some(v) = self.left_table.as_ref() {
4256 struct_ser.serialize_field("leftTable", v)?;
4257 }
4258 if let Some(v) = self.right_table.as_ref() {
4259 struct_ser.serialize_field("rightTable", v)?;
4260 }
4261 if self.condition_always_relax {
4262 struct_ser.serialize_field("conditionAlwaysRelax", &self.condition_always_relax)?;
4263 }
4264 if self.cleaned_by_watermark {
4265 struct_ser.serialize_field("cleanedByWatermark", &self.cleaned_by_watermark)?;
4266 }
4267 struct_ser.end()
4268 }
4269}
4270impl<'de> serde::Deserialize<'de> for DynamicFilterNode {
4271 #[allow(deprecated)]
4272 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4273 where
4274 D: serde::Deserializer<'de>,
4275 {
4276 const FIELDS: &[&str] = &[
4277 "left_key",
4278 "leftKey",
4279 "condition",
4280 "left_table",
4281 "leftTable",
4282 "right_table",
4283 "rightTable",
4284 "condition_always_relax",
4285 "conditionAlwaysRelax",
4286 "cleaned_by_watermark",
4287 "cleanedByWatermark",
4288 ];
4289
4290 #[allow(clippy::enum_variant_names)]
4291 enum GeneratedField {
4292 LeftKey,
4293 Condition,
4294 LeftTable,
4295 RightTable,
4296 ConditionAlwaysRelax,
4297 CleanedByWatermark,
4298 }
4299 impl<'de> serde::Deserialize<'de> for GeneratedField {
4300 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4301 where
4302 D: serde::Deserializer<'de>,
4303 {
4304 struct GeneratedVisitor;
4305
4306 impl serde::de::Visitor<'_> for GeneratedVisitor {
4307 type Value = GeneratedField;
4308
4309 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4310 write!(formatter, "expected one of: {:?}", &FIELDS)
4311 }
4312
4313 #[allow(unused_variables)]
4314 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4315 where
4316 E: serde::de::Error,
4317 {
4318 match value {
4319 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
4320 "condition" => Ok(GeneratedField::Condition),
4321 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
4322 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
4323 "conditionAlwaysRelax" | "condition_always_relax" => Ok(GeneratedField::ConditionAlwaysRelax),
4324 "cleanedByWatermark" | "cleaned_by_watermark" => Ok(GeneratedField::CleanedByWatermark),
4325 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4326 }
4327 }
4328 }
4329 deserializer.deserialize_identifier(GeneratedVisitor)
4330 }
4331 }
4332 struct GeneratedVisitor;
4333 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4334 type Value = DynamicFilterNode;
4335
4336 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4337 formatter.write_str("struct stream_plan.DynamicFilterNode")
4338 }
4339
4340 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DynamicFilterNode, V::Error>
4341 where
4342 V: serde::de::MapAccess<'de>,
4343 {
4344 let mut left_key__ = None;
4345 let mut condition__ = None;
4346 let mut left_table__ = None;
4347 let mut right_table__ = None;
4348 let mut condition_always_relax__ = None;
4349 let mut cleaned_by_watermark__ = None;
4350 while let Some(k) = map_.next_key()? {
4351 match k {
4352 GeneratedField::LeftKey => {
4353 if left_key__.is_some() {
4354 return Err(serde::de::Error::duplicate_field("leftKey"));
4355 }
4356 left_key__ =
4357 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4358 ;
4359 }
4360 GeneratedField::Condition => {
4361 if condition__.is_some() {
4362 return Err(serde::de::Error::duplicate_field("condition"));
4363 }
4364 condition__ = map_.next_value()?;
4365 }
4366 GeneratedField::LeftTable => {
4367 if left_table__.is_some() {
4368 return Err(serde::de::Error::duplicate_field("leftTable"));
4369 }
4370 left_table__ = map_.next_value()?;
4371 }
4372 GeneratedField::RightTable => {
4373 if right_table__.is_some() {
4374 return Err(serde::de::Error::duplicate_field("rightTable"));
4375 }
4376 right_table__ = map_.next_value()?;
4377 }
4378 GeneratedField::ConditionAlwaysRelax => {
4379 if condition_always_relax__.is_some() {
4380 return Err(serde::de::Error::duplicate_field("conditionAlwaysRelax"));
4381 }
4382 condition_always_relax__ = Some(map_.next_value()?);
4383 }
4384 GeneratedField::CleanedByWatermark => {
4385 if cleaned_by_watermark__.is_some() {
4386 return Err(serde::de::Error::duplicate_field("cleanedByWatermark"));
4387 }
4388 cleaned_by_watermark__ = Some(map_.next_value()?);
4389 }
4390 }
4391 }
4392 Ok(DynamicFilterNode {
4393 left_key: left_key__.unwrap_or_default(),
4394 condition: condition__,
4395 left_table: left_table__,
4396 right_table: right_table__,
4397 condition_always_relax: condition_always_relax__.unwrap_or_default(),
4398 cleaned_by_watermark: cleaned_by_watermark__.unwrap_or_default(),
4399 })
4400 }
4401 }
4402 deserializer.deserialize_struct("stream_plan.DynamicFilterNode", FIELDS, GeneratedVisitor)
4403 }
4404}
4405impl serde::Serialize for EowcGapFillNode {
4406 #[allow(deprecated)]
4407 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4408 where
4409 S: serde::Serializer,
4410 {
4411 use serde::ser::SerializeStruct;
4412 let mut len = 0;
4413 if self.time_column_index != 0 {
4414 len += 1;
4415 }
4416 if self.interval.is_some() {
4417 len += 1;
4418 }
4419 if !self.fill_columns.is_empty() {
4420 len += 1;
4421 }
4422 if !self.fill_strategies.is_empty() {
4423 len += 1;
4424 }
4425 if self.prev_row_table.is_some() {
4426 len += 1;
4427 }
4428 if !self.partition_by_indices.is_empty() {
4429 len += 1;
4430 }
4431 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcGapFillNode", len)?;
4432 if self.time_column_index != 0 {
4433 struct_ser.serialize_field("timeColumnIndex", &self.time_column_index)?;
4434 }
4435 if let Some(v) = self.interval.as_ref() {
4436 struct_ser.serialize_field("interval", v)?;
4437 }
4438 if !self.fill_columns.is_empty() {
4439 struct_ser.serialize_field("fillColumns", &self.fill_columns)?;
4440 }
4441 if !self.fill_strategies.is_empty() {
4442 struct_ser.serialize_field("fillStrategies", &self.fill_strategies)?;
4443 }
4444 if let Some(v) = self.prev_row_table.as_ref() {
4445 struct_ser.serialize_field("prevRowTable", v)?;
4446 }
4447 if !self.partition_by_indices.is_empty() {
4448 struct_ser.serialize_field("partitionByIndices", &self.partition_by_indices)?;
4449 }
4450 struct_ser.end()
4451 }
4452}
4453impl<'de> serde::Deserialize<'de> for EowcGapFillNode {
4454 #[allow(deprecated)]
4455 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4456 where
4457 D: serde::Deserializer<'de>,
4458 {
4459 const FIELDS: &[&str] = &[
4460 "time_column_index",
4461 "timeColumnIndex",
4462 "interval",
4463 "fill_columns",
4464 "fillColumns",
4465 "fill_strategies",
4466 "fillStrategies",
4467 "prev_row_table",
4468 "prevRowTable",
4469 "partition_by_indices",
4470 "partitionByIndices",
4471 ];
4472
4473 #[allow(clippy::enum_variant_names)]
4474 enum GeneratedField {
4475 TimeColumnIndex,
4476 Interval,
4477 FillColumns,
4478 FillStrategies,
4479 PrevRowTable,
4480 PartitionByIndices,
4481 }
4482 impl<'de> serde::Deserialize<'de> for GeneratedField {
4483 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4484 where
4485 D: serde::Deserializer<'de>,
4486 {
4487 struct GeneratedVisitor;
4488
4489 impl serde::de::Visitor<'_> for GeneratedVisitor {
4490 type Value = GeneratedField;
4491
4492 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4493 write!(formatter, "expected one of: {:?}", &FIELDS)
4494 }
4495
4496 #[allow(unused_variables)]
4497 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4498 where
4499 E: serde::de::Error,
4500 {
4501 match value {
4502 "timeColumnIndex" | "time_column_index" => Ok(GeneratedField::TimeColumnIndex),
4503 "interval" => Ok(GeneratedField::Interval),
4504 "fillColumns" | "fill_columns" => Ok(GeneratedField::FillColumns),
4505 "fillStrategies" | "fill_strategies" => Ok(GeneratedField::FillStrategies),
4506 "prevRowTable" | "prev_row_table" => Ok(GeneratedField::PrevRowTable),
4507 "partitionByIndices" | "partition_by_indices" => Ok(GeneratedField::PartitionByIndices),
4508 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4509 }
4510 }
4511 }
4512 deserializer.deserialize_identifier(GeneratedVisitor)
4513 }
4514 }
4515 struct GeneratedVisitor;
4516 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4517 type Value = EowcGapFillNode;
4518
4519 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4520 formatter.write_str("struct stream_plan.EowcGapFillNode")
4521 }
4522
4523 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcGapFillNode, V::Error>
4524 where
4525 V: serde::de::MapAccess<'de>,
4526 {
4527 let mut time_column_index__ = None;
4528 let mut interval__ = None;
4529 let mut fill_columns__ = None;
4530 let mut fill_strategies__ = None;
4531 let mut prev_row_table__ = None;
4532 let mut partition_by_indices__ = None;
4533 while let Some(k) = map_.next_key()? {
4534 match k {
4535 GeneratedField::TimeColumnIndex => {
4536 if time_column_index__.is_some() {
4537 return Err(serde::de::Error::duplicate_field("timeColumnIndex"));
4538 }
4539 time_column_index__ =
4540 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4541 ;
4542 }
4543 GeneratedField::Interval => {
4544 if interval__.is_some() {
4545 return Err(serde::de::Error::duplicate_field("interval"));
4546 }
4547 interval__ = map_.next_value()?;
4548 }
4549 GeneratedField::FillColumns => {
4550 if fill_columns__.is_some() {
4551 return Err(serde::de::Error::duplicate_field("fillColumns"));
4552 }
4553 fill_columns__ =
4554 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4555 .into_iter().map(|x| x.0).collect())
4556 ;
4557 }
4558 GeneratedField::FillStrategies => {
4559 if fill_strategies__.is_some() {
4560 return Err(serde::de::Error::duplicate_field("fillStrategies"));
4561 }
4562 fill_strategies__ = Some(map_.next_value()?);
4563 }
4564 GeneratedField::PrevRowTable => {
4565 if prev_row_table__.is_some() {
4566 return Err(serde::de::Error::duplicate_field("prevRowTable"));
4567 }
4568 prev_row_table__ = map_.next_value()?;
4569 }
4570 GeneratedField::PartitionByIndices => {
4571 if partition_by_indices__.is_some() {
4572 return Err(serde::de::Error::duplicate_field("partitionByIndices"));
4573 }
4574 partition_by_indices__ =
4575 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4576 .into_iter().map(|x| x.0).collect())
4577 ;
4578 }
4579 }
4580 }
4581 Ok(EowcGapFillNode {
4582 time_column_index: time_column_index__.unwrap_or_default(),
4583 interval: interval__,
4584 fill_columns: fill_columns__.unwrap_or_default(),
4585 fill_strategies: fill_strategies__.unwrap_or_default(),
4586 prev_row_table: prev_row_table__,
4587 partition_by_indices: partition_by_indices__.unwrap_or_default(),
4588 })
4589 }
4590 }
4591 deserializer.deserialize_struct("stream_plan.EowcGapFillNode", FIELDS, GeneratedVisitor)
4592 }
4593}
4594impl serde::Serialize for EowcOverWindowNode {
4595 #[allow(deprecated)]
4596 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4597 where
4598 S: serde::Serializer,
4599 {
4600 use serde::ser::SerializeStruct;
4601 let mut len = 0;
4602 if !self.calls.is_empty() {
4603 len += 1;
4604 }
4605 if !self.partition_by.is_empty() {
4606 len += 1;
4607 }
4608 if !self.order_by.is_empty() {
4609 len += 1;
4610 }
4611 if self.state_table.is_some() {
4612 len += 1;
4613 }
4614 if self.intermediate_state_table.is_some() {
4615 len += 1;
4616 }
4617 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcOverWindowNode", len)?;
4618 if !self.calls.is_empty() {
4619 struct_ser.serialize_field("calls", &self.calls)?;
4620 }
4621 if !self.partition_by.is_empty() {
4622 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
4623 }
4624 if !self.order_by.is_empty() {
4625 struct_ser.serialize_field("orderBy", &self.order_by)?;
4626 }
4627 if let Some(v) = self.state_table.as_ref() {
4628 struct_ser.serialize_field("stateTable", v)?;
4629 }
4630 if let Some(v) = self.intermediate_state_table.as_ref() {
4631 struct_ser.serialize_field("intermediateStateTable", v)?;
4632 }
4633 struct_ser.end()
4634 }
4635}
4636impl<'de> serde::Deserialize<'de> for EowcOverWindowNode {
4637 #[allow(deprecated)]
4638 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4639 where
4640 D: serde::Deserializer<'de>,
4641 {
4642 const FIELDS: &[&str] = &[
4643 "calls",
4644 "partition_by",
4645 "partitionBy",
4646 "order_by",
4647 "orderBy",
4648 "state_table",
4649 "stateTable",
4650 "intermediate_state_table",
4651 "intermediateStateTable",
4652 ];
4653
4654 #[allow(clippy::enum_variant_names)]
4655 enum GeneratedField {
4656 Calls,
4657 PartitionBy,
4658 OrderBy,
4659 StateTable,
4660 IntermediateStateTable,
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 serde::de::Visitor<'_> 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 "calls" => Ok(GeneratedField::Calls),
4683 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
4684 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
4685 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
4686 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
4687 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4688 }
4689 }
4690 }
4691 deserializer.deserialize_identifier(GeneratedVisitor)
4692 }
4693 }
4694 struct GeneratedVisitor;
4695 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4696 type Value = EowcOverWindowNode;
4697
4698 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4699 formatter.write_str("struct stream_plan.EowcOverWindowNode")
4700 }
4701
4702 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcOverWindowNode, V::Error>
4703 where
4704 V: serde::de::MapAccess<'de>,
4705 {
4706 let mut calls__ = None;
4707 let mut partition_by__ = None;
4708 let mut order_by__ = None;
4709 let mut state_table__ = None;
4710 let mut intermediate_state_table__ = None;
4711 while let Some(k) = map_.next_key()? {
4712 match k {
4713 GeneratedField::Calls => {
4714 if calls__.is_some() {
4715 return Err(serde::de::Error::duplicate_field("calls"));
4716 }
4717 calls__ = Some(map_.next_value()?);
4718 }
4719 GeneratedField::PartitionBy => {
4720 if partition_by__.is_some() {
4721 return Err(serde::de::Error::duplicate_field("partitionBy"));
4722 }
4723 partition_by__ =
4724 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4725 .into_iter().map(|x| x.0).collect())
4726 ;
4727 }
4728 GeneratedField::OrderBy => {
4729 if order_by__.is_some() {
4730 return Err(serde::de::Error::duplicate_field("orderBy"));
4731 }
4732 order_by__ = Some(map_.next_value()?);
4733 }
4734 GeneratedField::StateTable => {
4735 if state_table__.is_some() {
4736 return Err(serde::de::Error::duplicate_field("stateTable"));
4737 }
4738 state_table__ = map_.next_value()?;
4739 }
4740 GeneratedField::IntermediateStateTable => {
4741 if intermediate_state_table__.is_some() {
4742 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
4743 }
4744 intermediate_state_table__ = map_.next_value()?;
4745 }
4746 }
4747 }
4748 Ok(EowcOverWindowNode {
4749 calls: calls__.unwrap_or_default(),
4750 partition_by: partition_by__.unwrap_or_default(),
4751 order_by: order_by__.unwrap_or_default(),
4752 state_table: state_table__,
4753 intermediate_state_table: intermediate_state_table__,
4754 })
4755 }
4756 }
4757 deserializer.deserialize_struct("stream_plan.EowcOverWindowNode", FIELDS, GeneratedVisitor)
4758 }
4759}
4760impl serde::Serialize for ExchangeNode {
4761 #[allow(deprecated)]
4762 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4763 where
4764 S: serde::Serializer,
4765 {
4766 use serde::ser::SerializeStruct;
4767 let mut len = 0;
4768 if self.strategy.is_some() {
4769 len += 1;
4770 }
4771 let mut struct_ser = serializer.serialize_struct("stream_plan.ExchangeNode", len)?;
4772 if let Some(v) = self.strategy.as_ref() {
4773 struct_ser.serialize_field("strategy", v)?;
4774 }
4775 struct_ser.end()
4776 }
4777}
4778impl<'de> serde::Deserialize<'de> for ExchangeNode {
4779 #[allow(deprecated)]
4780 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4781 where
4782 D: serde::Deserializer<'de>,
4783 {
4784 const FIELDS: &[&str] = &[
4785 "strategy",
4786 ];
4787
4788 #[allow(clippy::enum_variant_names)]
4789 enum GeneratedField {
4790 Strategy,
4791 }
4792 impl<'de> serde::Deserialize<'de> for GeneratedField {
4793 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4794 where
4795 D: serde::Deserializer<'de>,
4796 {
4797 struct GeneratedVisitor;
4798
4799 impl serde::de::Visitor<'_> for GeneratedVisitor {
4800 type Value = GeneratedField;
4801
4802 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4803 write!(formatter, "expected one of: {:?}", &FIELDS)
4804 }
4805
4806 #[allow(unused_variables)]
4807 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4808 where
4809 E: serde::de::Error,
4810 {
4811 match value {
4812 "strategy" => Ok(GeneratedField::Strategy),
4813 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4814 }
4815 }
4816 }
4817 deserializer.deserialize_identifier(GeneratedVisitor)
4818 }
4819 }
4820 struct GeneratedVisitor;
4821 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4822 type Value = ExchangeNode;
4823
4824 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4825 formatter.write_str("struct stream_plan.ExchangeNode")
4826 }
4827
4828 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExchangeNode, V::Error>
4829 where
4830 V: serde::de::MapAccess<'de>,
4831 {
4832 let mut strategy__ = None;
4833 while let Some(k) = map_.next_key()? {
4834 match k {
4835 GeneratedField::Strategy => {
4836 if strategy__.is_some() {
4837 return Err(serde::de::Error::duplicate_field("strategy"));
4838 }
4839 strategy__ = map_.next_value()?;
4840 }
4841 }
4842 }
4843 Ok(ExchangeNode {
4844 strategy: strategy__,
4845 })
4846 }
4847 }
4848 deserializer.deserialize_struct("stream_plan.ExchangeNode", FIELDS, GeneratedVisitor)
4849 }
4850}
4851impl serde::Serialize for ExpandNode {
4852 #[allow(deprecated)]
4853 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4854 where
4855 S: serde::Serializer,
4856 {
4857 use serde::ser::SerializeStruct;
4858 let mut len = 0;
4859 if !self.column_subsets.is_empty() {
4860 len += 1;
4861 }
4862 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode", len)?;
4863 if !self.column_subsets.is_empty() {
4864 struct_ser.serialize_field("columnSubsets", &self.column_subsets)?;
4865 }
4866 struct_ser.end()
4867 }
4868}
4869impl<'de> serde::Deserialize<'de> for ExpandNode {
4870 #[allow(deprecated)]
4871 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4872 where
4873 D: serde::Deserializer<'de>,
4874 {
4875 const FIELDS: &[&str] = &[
4876 "column_subsets",
4877 "columnSubsets",
4878 ];
4879
4880 #[allow(clippy::enum_variant_names)]
4881 enum GeneratedField {
4882 ColumnSubsets,
4883 }
4884 impl<'de> serde::Deserialize<'de> for GeneratedField {
4885 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4886 where
4887 D: serde::Deserializer<'de>,
4888 {
4889 struct GeneratedVisitor;
4890
4891 impl serde::de::Visitor<'_> for GeneratedVisitor {
4892 type Value = GeneratedField;
4893
4894 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4895 write!(formatter, "expected one of: {:?}", &FIELDS)
4896 }
4897
4898 #[allow(unused_variables)]
4899 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4900 where
4901 E: serde::de::Error,
4902 {
4903 match value {
4904 "columnSubsets" | "column_subsets" => Ok(GeneratedField::ColumnSubsets),
4905 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4906 }
4907 }
4908 }
4909 deserializer.deserialize_identifier(GeneratedVisitor)
4910 }
4911 }
4912 struct GeneratedVisitor;
4913 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4914 type Value = ExpandNode;
4915
4916 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4917 formatter.write_str("struct stream_plan.ExpandNode")
4918 }
4919
4920 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpandNode, V::Error>
4921 where
4922 V: serde::de::MapAccess<'de>,
4923 {
4924 let mut column_subsets__ = None;
4925 while let Some(k) = map_.next_key()? {
4926 match k {
4927 GeneratedField::ColumnSubsets => {
4928 if column_subsets__.is_some() {
4929 return Err(serde::de::Error::duplicate_field("columnSubsets"));
4930 }
4931 column_subsets__ = Some(map_.next_value()?);
4932 }
4933 }
4934 }
4935 Ok(ExpandNode {
4936 column_subsets: column_subsets__.unwrap_or_default(),
4937 })
4938 }
4939 }
4940 deserializer.deserialize_struct("stream_plan.ExpandNode", FIELDS, GeneratedVisitor)
4941 }
4942}
4943impl serde::Serialize for expand_node::Subset {
4944 #[allow(deprecated)]
4945 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4946 where
4947 S: serde::Serializer,
4948 {
4949 use serde::ser::SerializeStruct;
4950 let mut len = 0;
4951 if !self.column_indices.is_empty() {
4952 len += 1;
4953 }
4954 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode.Subset", len)?;
4955 if !self.column_indices.is_empty() {
4956 struct_ser.serialize_field("columnIndices", &self.column_indices)?;
4957 }
4958 struct_ser.end()
4959 }
4960}
4961impl<'de> serde::Deserialize<'de> for expand_node::Subset {
4962 #[allow(deprecated)]
4963 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4964 where
4965 D: serde::Deserializer<'de>,
4966 {
4967 const FIELDS: &[&str] = &[
4968 "column_indices",
4969 "columnIndices",
4970 ];
4971
4972 #[allow(clippy::enum_variant_names)]
4973 enum GeneratedField {
4974 ColumnIndices,
4975 }
4976 impl<'de> serde::Deserialize<'de> for GeneratedField {
4977 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4978 where
4979 D: serde::Deserializer<'de>,
4980 {
4981 struct GeneratedVisitor;
4982
4983 impl serde::de::Visitor<'_> for GeneratedVisitor {
4984 type Value = GeneratedField;
4985
4986 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4987 write!(formatter, "expected one of: {:?}", &FIELDS)
4988 }
4989
4990 #[allow(unused_variables)]
4991 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4992 where
4993 E: serde::de::Error,
4994 {
4995 match value {
4996 "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
4997 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4998 }
4999 }
5000 }
5001 deserializer.deserialize_identifier(GeneratedVisitor)
5002 }
5003 }
5004 struct GeneratedVisitor;
5005 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5006 type Value = expand_node::Subset;
5007
5008 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5009 formatter.write_str("struct stream_plan.ExpandNode.Subset")
5010 }
5011
5012 fn visit_map<V>(self, mut map_: V) -> std::result::Result<expand_node::Subset, V::Error>
5013 where
5014 V: serde::de::MapAccess<'de>,
5015 {
5016 let mut column_indices__ = None;
5017 while let Some(k) = map_.next_key()? {
5018 match k {
5019 GeneratedField::ColumnIndices => {
5020 if column_indices__.is_some() {
5021 return Err(serde::de::Error::duplicate_field("columnIndices"));
5022 }
5023 column_indices__ =
5024 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5025 .into_iter().map(|x| x.0).collect())
5026 ;
5027 }
5028 }
5029 }
5030 Ok(expand_node::Subset {
5031 column_indices: column_indices__.unwrap_or_default(),
5032 })
5033 }
5034 }
5035 deserializer.deserialize_struct("stream_plan.ExpandNode.Subset", FIELDS, GeneratedVisitor)
5036 }
5037}
5038impl serde::Serialize for FilterNode {
5039 #[allow(deprecated)]
5040 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5041 where
5042 S: serde::Serializer,
5043 {
5044 use serde::ser::SerializeStruct;
5045 let mut len = 0;
5046 if self.search_condition.is_some() {
5047 len += 1;
5048 }
5049 let mut struct_ser = serializer.serialize_struct("stream_plan.FilterNode", len)?;
5050 if let Some(v) = self.search_condition.as_ref() {
5051 struct_ser.serialize_field("searchCondition", v)?;
5052 }
5053 struct_ser.end()
5054 }
5055}
5056impl<'de> serde::Deserialize<'de> for FilterNode {
5057 #[allow(deprecated)]
5058 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5059 where
5060 D: serde::Deserializer<'de>,
5061 {
5062 const FIELDS: &[&str] = &[
5063 "search_condition",
5064 "searchCondition",
5065 ];
5066
5067 #[allow(clippy::enum_variant_names)]
5068 enum GeneratedField {
5069 SearchCondition,
5070 }
5071 impl<'de> serde::Deserialize<'de> for GeneratedField {
5072 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5073 where
5074 D: serde::Deserializer<'de>,
5075 {
5076 struct GeneratedVisitor;
5077
5078 impl serde::de::Visitor<'_> for GeneratedVisitor {
5079 type Value = GeneratedField;
5080
5081 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5082 write!(formatter, "expected one of: {:?}", &FIELDS)
5083 }
5084
5085 #[allow(unused_variables)]
5086 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5087 where
5088 E: serde::de::Error,
5089 {
5090 match value {
5091 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
5092 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5093 }
5094 }
5095 }
5096 deserializer.deserialize_identifier(GeneratedVisitor)
5097 }
5098 }
5099 struct GeneratedVisitor;
5100 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5101 type Value = FilterNode;
5102
5103 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5104 formatter.write_str("struct stream_plan.FilterNode")
5105 }
5106
5107 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FilterNode, V::Error>
5108 where
5109 V: serde::de::MapAccess<'de>,
5110 {
5111 let mut search_condition__ = None;
5112 while let Some(k) = map_.next_key()? {
5113 match k {
5114 GeneratedField::SearchCondition => {
5115 if search_condition__.is_some() {
5116 return Err(serde::de::Error::duplicate_field("searchCondition"));
5117 }
5118 search_condition__ = map_.next_value()?;
5119 }
5120 }
5121 }
5122 Ok(FilterNode {
5123 search_condition: search_condition__,
5124 })
5125 }
5126 }
5127 deserializer.deserialize_struct("stream_plan.FilterNode", FIELDS, GeneratedVisitor)
5128 }
5129}
5130impl serde::Serialize for GapFillNode {
5131 #[allow(deprecated)]
5132 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5133 where
5134 S: serde::Serializer,
5135 {
5136 use serde::ser::SerializeStruct;
5137 let mut len = 0;
5138 if self.time_column_index != 0 {
5139 len += 1;
5140 }
5141 if self.interval.is_some() {
5142 len += 1;
5143 }
5144 if !self.fill_columns.is_empty() {
5145 len += 1;
5146 }
5147 if !self.fill_strategies.is_empty() {
5148 len += 1;
5149 }
5150 if self.state_table.is_some() {
5151 len += 1;
5152 }
5153 if !self.partition_by_indices.is_empty() {
5154 len += 1;
5155 }
5156 if !self.pointer_key_indices.is_empty() {
5157 len += 1;
5158 }
5159 let mut struct_ser = serializer.serialize_struct("stream_plan.GapFillNode", len)?;
5160 if self.time_column_index != 0 {
5161 struct_ser.serialize_field("timeColumnIndex", &self.time_column_index)?;
5162 }
5163 if let Some(v) = self.interval.as_ref() {
5164 struct_ser.serialize_field("interval", v)?;
5165 }
5166 if !self.fill_columns.is_empty() {
5167 struct_ser.serialize_field("fillColumns", &self.fill_columns)?;
5168 }
5169 if !self.fill_strategies.is_empty() {
5170 struct_ser.serialize_field("fillStrategies", &self.fill_strategies)?;
5171 }
5172 if let Some(v) = self.state_table.as_ref() {
5173 struct_ser.serialize_field("stateTable", v)?;
5174 }
5175 if !self.partition_by_indices.is_empty() {
5176 struct_ser.serialize_field("partitionByIndices", &self.partition_by_indices)?;
5177 }
5178 if !self.pointer_key_indices.is_empty() {
5179 struct_ser.serialize_field("pointerKeyIndices", &self.pointer_key_indices)?;
5180 }
5181 struct_ser.end()
5182 }
5183}
5184impl<'de> serde::Deserialize<'de> for GapFillNode {
5185 #[allow(deprecated)]
5186 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5187 where
5188 D: serde::Deserializer<'de>,
5189 {
5190 const FIELDS: &[&str] = &[
5191 "time_column_index",
5192 "timeColumnIndex",
5193 "interval",
5194 "fill_columns",
5195 "fillColumns",
5196 "fill_strategies",
5197 "fillStrategies",
5198 "state_table",
5199 "stateTable",
5200 "partition_by_indices",
5201 "partitionByIndices",
5202 "pointer_key_indices",
5203 "pointerKeyIndices",
5204 ];
5205
5206 #[allow(clippy::enum_variant_names)]
5207 enum GeneratedField {
5208 TimeColumnIndex,
5209 Interval,
5210 FillColumns,
5211 FillStrategies,
5212 StateTable,
5213 PartitionByIndices,
5214 PointerKeyIndices,
5215 }
5216 impl<'de> serde::Deserialize<'de> for GeneratedField {
5217 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5218 where
5219 D: serde::Deserializer<'de>,
5220 {
5221 struct GeneratedVisitor;
5222
5223 impl serde::de::Visitor<'_> for GeneratedVisitor {
5224 type Value = GeneratedField;
5225
5226 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5227 write!(formatter, "expected one of: {:?}", &FIELDS)
5228 }
5229
5230 #[allow(unused_variables)]
5231 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5232 where
5233 E: serde::de::Error,
5234 {
5235 match value {
5236 "timeColumnIndex" | "time_column_index" => Ok(GeneratedField::TimeColumnIndex),
5237 "interval" => Ok(GeneratedField::Interval),
5238 "fillColumns" | "fill_columns" => Ok(GeneratedField::FillColumns),
5239 "fillStrategies" | "fill_strategies" => Ok(GeneratedField::FillStrategies),
5240 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
5241 "partitionByIndices" | "partition_by_indices" => Ok(GeneratedField::PartitionByIndices),
5242 "pointerKeyIndices" | "pointer_key_indices" => Ok(GeneratedField::PointerKeyIndices),
5243 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5244 }
5245 }
5246 }
5247 deserializer.deserialize_identifier(GeneratedVisitor)
5248 }
5249 }
5250 struct GeneratedVisitor;
5251 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5252 type Value = GapFillNode;
5253
5254 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5255 formatter.write_str("struct stream_plan.GapFillNode")
5256 }
5257
5258 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GapFillNode, V::Error>
5259 where
5260 V: serde::de::MapAccess<'de>,
5261 {
5262 let mut time_column_index__ = None;
5263 let mut interval__ = None;
5264 let mut fill_columns__ = None;
5265 let mut fill_strategies__ = None;
5266 let mut state_table__ = None;
5267 let mut partition_by_indices__ = None;
5268 let mut pointer_key_indices__ = None;
5269 while let Some(k) = map_.next_key()? {
5270 match k {
5271 GeneratedField::TimeColumnIndex => {
5272 if time_column_index__.is_some() {
5273 return Err(serde::de::Error::duplicate_field("timeColumnIndex"));
5274 }
5275 time_column_index__ =
5276 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5277 ;
5278 }
5279 GeneratedField::Interval => {
5280 if interval__.is_some() {
5281 return Err(serde::de::Error::duplicate_field("interval"));
5282 }
5283 interval__ = map_.next_value()?;
5284 }
5285 GeneratedField::FillColumns => {
5286 if fill_columns__.is_some() {
5287 return Err(serde::de::Error::duplicate_field("fillColumns"));
5288 }
5289 fill_columns__ =
5290 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5291 .into_iter().map(|x| x.0).collect())
5292 ;
5293 }
5294 GeneratedField::FillStrategies => {
5295 if fill_strategies__.is_some() {
5296 return Err(serde::de::Error::duplicate_field("fillStrategies"));
5297 }
5298 fill_strategies__ = Some(map_.next_value()?);
5299 }
5300 GeneratedField::StateTable => {
5301 if state_table__.is_some() {
5302 return Err(serde::de::Error::duplicate_field("stateTable"));
5303 }
5304 state_table__ = map_.next_value()?;
5305 }
5306 GeneratedField::PartitionByIndices => {
5307 if partition_by_indices__.is_some() {
5308 return Err(serde::de::Error::duplicate_field("partitionByIndices"));
5309 }
5310 partition_by_indices__ =
5311 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5312 .into_iter().map(|x| x.0).collect())
5313 ;
5314 }
5315 GeneratedField::PointerKeyIndices => {
5316 if pointer_key_indices__.is_some() {
5317 return Err(serde::de::Error::duplicate_field("pointerKeyIndices"));
5318 }
5319 pointer_key_indices__ =
5320 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5321 .into_iter().map(|x| x.0).collect())
5322 ;
5323 }
5324 }
5325 }
5326 Ok(GapFillNode {
5327 time_column_index: time_column_index__.unwrap_or_default(),
5328 interval: interval__,
5329 fill_columns: fill_columns__.unwrap_or_default(),
5330 fill_strategies: fill_strategies__.unwrap_or_default(),
5331 state_table: state_table__,
5332 partition_by_indices: partition_by_indices__.unwrap_or_default(),
5333 pointer_key_indices: pointer_key_indices__.unwrap_or_default(),
5334 })
5335 }
5336 }
5337 deserializer.deserialize_struct("stream_plan.GapFillNode", FIELDS, GeneratedVisitor)
5338 }
5339}
5340impl serde::Serialize for GlobalApproxPercentileNode {
5341 #[allow(deprecated)]
5342 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5343 where
5344 S: serde::Serializer,
5345 {
5346 use serde::ser::SerializeStruct;
5347 let mut len = 0;
5348 if self.base != 0. {
5349 len += 1;
5350 }
5351 if self.quantile != 0. {
5352 len += 1;
5353 }
5354 if self.bucket_state_table.is_some() {
5355 len += 1;
5356 }
5357 if self.count_state_table.is_some() {
5358 len += 1;
5359 }
5360 let mut struct_ser = serializer.serialize_struct("stream_plan.GlobalApproxPercentileNode", len)?;
5361 if self.base != 0. {
5362 struct_ser.serialize_field("base", &self.base)?;
5363 }
5364 if self.quantile != 0. {
5365 struct_ser.serialize_field("quantile", &self.quantile)?;
5366 }
5367 if let Some(v) = self.bucket_state_table.as_ref() {
5368 struct_ser.serialize_field("bucketStateTable", v)?;
5369 }
5370 if let Some(v) = self.count_state_table.as_ref() {
5371 struct_ser.serialize_field("countStateTable", v)?;
5372 }
5373 struct_ser.end()
5374 }
5375}
5376impl<'de> serde::Deserialize<'de> for GlobalApproxPercentileNode {
5377 #[allow(deprecated)]
5378 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5379 where
5380 D: serde::Deserializer<'de>,
5381 {
5382 const FIELDS: &[&str] = &[
5383 "base",
5384 "quantile",
5385 "bucket_state_table",
5386 "bucketStateTable",
5387 "count_state_table",
5388 "countStateTable",
5389 ];
5390
5391 #[allow(clippy::enum_variant_names)]
5392 enum GeneratedField {
5393 Base,
5394 Quantile,
5395 BucketStateTable,
5396 CountStateTable,
5397 }
5398 impl<'de> serde::Deserialize<'de> for GeneratedField {
5399 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5400 where
5401 D: serde::Deserializer<'de>,
5402 {
5403 struct GeneratedVisitor;
5404
5405 impl serde::de::Visitor<'_> for GeneratedVisitor {
5406 type Value = GeneratedField;
5407
5408 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5409 write!(formatter, "expected one of: {:?}", &FIELDS)
5410 }
5411
5412 #[allow(unused_variables)]
5413 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5414 where
5415 E: serde::de::Error,
5416 {
5417 match value {
5418 "base" => Ok(GeneratedField::Base),
5419 "quantile" => Ok(GeneratedField::Quantile),
5420 "bucketStateTable" | "bucket_state_table" => Ok(GeneratedField::BucketStateTable),
5421 "countStateTable" | "count_state_table" => Ok(GeneratedField::CountStateTable),
5422 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5423 }
5424 }
5425 }
5426 deserializer.deserialize_identifier(GeneratedVisitor)
5427 }
5428 }
5429 struct GeneratedVisitor;
5430 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5431 type Value = GlobalApproxPercentileNode;
5432
5433 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5434 formatter.write_str("struct stream_plan.GlobalApproxPercentileNode")
5435 }
5436
5437 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GlobalApproxPercentileNode, V::Error>
5438 where
5439 V: serde::de::MapAccess<'de>,
5440 {
5441 let mut base__ = None;
5442 let mut quantile__ = None;
5443 let mut bucket_state_table__ = None;
5444 let mut count_state_table__ = None;
5445 while let Some(k) = map_.next_key()? {
5446 match k {
5447 GeneratedField::Base => {
5448 if base__.is_some() {
5449 return Err(serde::de::Error::duplicate_field("base"));
5450 }
5451 base__ =
5452 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5453 ;
5454 }
5455 GeneratedField::Quantile => {
5456 if quantile__.is_some() {
5457 return Err(serde::de::Error::duplicate_field("quantile"));
5458 }
5459 quantile__ =
5460 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5461 ;
5462 }
5463 GeneratedField::BucketStateTable => {
5464 if bucket_state_table__.is_some() {
5465 return Err(serde::de::Error::duplicate_field("bucketStateTable"));
5466 }
5467 bucket_state_table__ = map_.next_value()?;
5468 }
5469 GeneratedField::CountStateTable => {
5470 if count_state_table__.is_some() {
5471 return Err(serde::de::Error::duplicate_field("countStateTable"));
5472 }
5473 count_state_table__ = map_.next_value()?;
5474 }
5475 }
5476 }
5477 Ok(GlobalApproxPercentileNode {
5478 base: base__.unwrap_or_default(),
5479 quantile: quantile__.unwrap_or_default(),
5480 bucket_state_table: bucket_state_table__,
5481 count_state_table: count_state_table__,
5482 })
5483 }
5484 }
5485 deserializer.deserialize_struct("stream_plan.GlobalApproxPercentileNode", FIELDS, GeneratedVisitor)
5486 }
5487}
5488impl serde::Serialize for GroupTopNNode {
5489 #[allow(deprecated)]
5490 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5491 where
5492 S: serde::Serializer,
5493 {
5494 use serde::ser::SerializeStruct;
5495 let mut len = 0;
5496 if self.limit != 0 {
5497 len += 1;
5498 }
5499 if self.offset != 0 {
5500 len += 1;
5501 }
5502 if !self.group_key.is_empty() {
5503 len += 1;
5504 }
5505 if self.table.is_some() {
5506 len += 1;
5507 }
5508 if !self.order_by.is_empty() {
5509 len += 1;
5510 }
5511 if self.with_ties {
5512 len += 1;
5513 }
5514 let mut struct_ser = serializer.serialize_struct("stream_plan.GroupTopNNode", len)?;
5515 if self.limit != 0 {
5516 #[allow(clippy::needless_borrow)]
5517 #[allow(clippy::needless_borrows_for_generic_args)]
5518 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
5519 }
5520 if self.offset != 0 {
5521 #[allow(clippy::needless_borrow)]
5522 #[allow(clippy::needless_borrows_for_generic_args)]
5523 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
5524 }
5525 if !self.group_key.is_empty() {
5526 struct_ser.serialize_field("groupKey", &self.group_key)?;
5527 }
5528 if let Some(v) = self.table.as_ref() {
5529 struct_ser.serialize_field("table", v)?;
5530 }
5531 if !self.order_by.is_empty() {
5532 struct_ser.serialize_field("orderBy", &self.order_by)?;
5533 }
5534 if self.with_ties {
5535 struct_ser.serialize_field("withTies", &self.with_ties)?;
5536 }
5537 struct_ser.end()
5538 }
5539}
5540impl<'de> serde::Deserialize<'de> for GroupTopNNode {
5541 #[allow(deprecated)]
5542 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5543 where
5544 D: serde::Deserializer<'de>,
5545 {
5546 const FIELDS: &[&str] = &[
5547 "limit",
5548 "offset",
5549 "group_key",
5550 "groupKey",
5551 "table",
5552 "order_by",
5553 "orderBy",
5554 "with_ties",
5555 "withTies",
5556 ];
5557
5558 #[allow(clippy::enum_variant_names)]
5559 enum GeneratedField {
5560 Limit,
5561 Offset,
5562 GroupKey,
5563 Table,
5564 OrderBy,
5565 WithTies,
5566 }
5567 impl<'de> serde::Deserialize<'de> for GeneratedField {
5568 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5569 where
5570 D: serde::Deserializer<'de>,
5571 {
5572 struct GeneratedVisitor;
5573
5574 impl serde::de::Visitor<'_> for GeneratedVisitor {
5575 type Value = GeneratedField;
5576
5577 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5578 write!(formatter, "expected one of: {:?}", &FIELDS)
5579 }
5580
5581 #[allow(unused_variables)]
5582 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5583 where
5584 E: serde::de::Error,
5585 {
5586 match value {
5587 "limit" => Ok(GeneratedField::Limit),
5588 "offset" => Ok(GeneratedField::Offset),
5589 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5590 "table" => Ok(GeneratedField::Table),
5591 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
5592 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
5593 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5594 }
5595 }
5596 }
5597 deserializer.deserialize_identifier(GeneratedVisitor)
5598 }
5599 }
5600 struct GeneratedVisitor;
5601 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5602 type Value = GroupTopNNode;
5603
5604 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5605 formatter.write_str("struct stream_plan.GroupTopNNode")
5606 }
5607
5608 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupTopNNode, V::Error>
5609 where
5610 V: serde::de::MapAccess<'de>,
5611 {
5612 let mut limit__ = None;
5613 let mut offset__ = None;
5614 let mut group_key__ = None;
5615 let mut table__ = None;
5616 let mut order_by__ = None;
5617 let mut with_ties__ = None;
5618 while let Some(k) = map_.next_key()? {
5619 match k {
5620 GeneratedField::Limit => {
5621 if limit__.is_some() {
5622 return Err(serde::de::Error::duplicate_field("limit"));
5623 }
5624 limit__ =
5625 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5626 ;
5627 }
5628 GeneratedField::Offset => {
5629 if offset__.is_some() {
5630 return Err(serde::de::Error::duplicate_field("offset"));
5631 }
5632 offset__ =
5633 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5634 ;
5635 }
5636 GeneratedField::GroupKey => {
5637 if group_key__.is_some() {
5638 return Err(serde::de::Error::duplicate_field("groupKey"));
5639 }
5640 group_key__ =
5641 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5642 .into_iter().map(|x| x.0).collect())
5643 ;
5644 }
5645 GeneratedField::Table => {
5646 if table__.is_some() {
5647 return Err(serde::de::Error::duplicate_field("table"));
5648 }
5649 table__ = map_.next_value()?;
5650 }
5651 GeneratedField::OrderBy => {
5652 if order_by__.is_some() {
5653 return Err(serde::de::Error::duplicate_field("orderBy"));
5654 }
5655 order_by__ = Some(map_.next_value()?);
5656 }
5657 GeneratedField::WithTies => {
5658 if with_ties__.is_some() {
5659 return Err(serde::de::Error::duplicate_field("withTies"));
5660 }
5661 with_ties__ = Some(map_.next_value()?);
5662 }
5663 }
5664 }
5665 Ok(GroupTopNNode {
5666 limit: limit__.unwrap_or_default(),
5667 offset: offset__.unwrap_or_default(),
5668 group_key: group_key__.unwrap_or_default(),
5669 table: table__,
5670 order_by: order_by__.unwrap_or_default(),
5671 with_ties: with_ties__.unwrap_or_default(),
5672 })
5673 }
5674 }
5675 deserializer.deserialize_struct("stream_plan.GroupTopNNode", FIELDS, GeneratedVisitor)
5676 }
5677}
5678impl serde::Serialize for HashAggNode {
5679 #[allow(deprecated)]
5680 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5681 where
5682 S: serde::Serializer,
5683 {
5684 use serde::ser::SerializeStruct;
5685 let mut len = 0;
5686 if !self.group_key.is_empty() {
5687 len += 1;
5688 }
5689 if !self.agg_calls.is_empty() {
5690 len += 1;
5691 }
5692 if !self.agg_call_states.is_empty() {
5693 len += 1;
5694 }
5695 if self.intermediate_state_table.is_some() {
5696 len += 1;
5697 }
5698 if self.is_append_only {
5699 len += 1;
5700 }
5701 if !self.distinct_dedup_tables.is_empty() {
5702 len += 1;
5703 }
5704 if self.row_count_index != 0 {
5705 len += 1;
5706 }
5707 if self.emit_on_window_close {
5708 len += 1;
5709 }
5710 if self.version != 0 {
5711 len += 1;
5712 }
5713 let mut struct_ser = serializer.serialize_struct("stream_plan.HashAggNode", len)?;
5714 if !self.group_key.is_empty() {
5715 struct_ser.serialize_field("groupKey", &self.group_key)?;
5716 }
5717 if !self.agg_calls.is_empty() {
5718 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
5719 }
5720 if !self.agg_call_states.is_empty() {
5721 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
5722 }
5723 if let Some(v) = self.intermediate_state_table.as_ref() {
5724 struct_ser.serialize_field("intermediateStateTable", v)?;
5725 }
5726 if self.is_append_only {
5727 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5728 }
5729 if !self.distinct_dedup_tables.is_empty() {
5730 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
5731 }
5732 if self.row_count_index != 0 {
5733 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
5734 }
5735 if self.emit_on_window_close {
5736 struct_ser.serialize_field("emitOnWindowClose", &self.emit_on_window_close)?;
5737 }
5738 if self.version != 0 {
5739 let v = AggNodeVersion::try_from(self.version)
5740 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
5741 struct_ser.serialize_field("version", &v)?;
5742 }
5743 struct_ser.end()
5744 }
5745}
5746impl<'de> serde::Deserialize<'de> for HashAggNode {
5747 #[allow(deprecated)]
5748 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5749 where
5750 D: serde::Deserializer<'de>,
5751 {
5752 const FIELDS: &[&str] = &[
5753 "group_key",
5754 "groupKey",
5755 "agg_calls",
5756 "aggCalls",
5757 "agg_call_states",
5758 "aggCallStates",
5759 "intermediate_state_table",
5760 "intermediateStateTable",
5761 "is_append_only",
5762 "isAppendOnly",
5763 "distinct_dedup_tables",
5764 "distinctDedupTables",
5765 "row_count_index",
5766 "rowCountIndex",
5767 "emit_on_window_close",
5768 "emitOnWindowClose",
5769 "version",
5770 ];
5771
5772 #[allow(clippy::enum_variant_names)]
5773 enum GeneratedField {
5774 GroupKey,
5775 AggCalls,
5776 AggCallStates,
5777 IntermediateStateTable,
5778 IsAppendOnly,
5779 DistinctDedupTables,
5780 RowCountIndex,
5781 EmitOnWindowClose,
5782 Version,
5783 }
5784 impl<'de> serde::Deserialize<'de> for GeneratedField {
5785 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5786 where
5787 D: serde::Deserializer<'de>,
5788 {
5789 struct GeneratedVisitor;
5790
5791 impl serde::de::Visitor<'_> for GeneratedVisitor {
5792 type Value = GeneratedField;
5793
5794 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5795 write!(formatter, "expected one of: {:?}", &FIELDS)
5796 }
5797
5798 #[allow(unused_variables)]
5799 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5800 where
5801 E: serde::de::Error,
5802 {
5803 match value {
5804 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5805 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
5806 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
5807 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
5808 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5809 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
5810 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
5811 "emitOnWindowClose" | "emit_on_window_close" => Ok(GeneratedField::EmitOnWindowClose),
5812 "version" => Ok(GeneratedField::Version),
5813 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5814 }
5815 }
5816 }
5817 deserializer.deserialize_identifier(GeneratedVisitor)
5818 }
5819 }
5820 struct GeneratedVisitor;
5821 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5822 type Value = HashAggNode;
5823
5824 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5825 formatter.write_str("struct stream_plan.HashAggNode")
5826 }
5827
5828 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashAggNode, V::Error>
5829 where
5830 V: serde::de::MapAccess<'de>,
5831 {
5832 let mut group_key__ = None;
5833 let mut agg_calls__ = None;
5834 let mut agg_call_states__ = None;
5835 let mut intermediate_state_table__ = None;
5836 let mut is_append_only__ = None;
5837 let mut distinct_dedup_tables__ = None;
5838 let mut row_count_index__ = None;
5839 let mut emit_on_window_close__ = None;
5840 let mut version__ = None;
5841 while let Some(k) = map_.next_key()? {
5842 match k {
5843 GeneratedField::GroupKey => {
5844 if group_key__.is_some() {
5845 return Err(serde::de::Error::duplicate_field("groupKey"));
5846 }
5847 group_key__ =
5848 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5849 .into_iter().map(|x| x.0).collect())
5850 ;
5851 }
5852 GeneratedField::AggCalls => {
5853 if agg_calls__.is_some() {
5854 return Err(serde::de::Error::duplicate_field("aggCalls"));
5855 }
5856 agg_calls__ = Some(map_.next_value()?);
5857 }
5858 GeneratedField::AggCallStates => {
5859 if agg_call_states__.is_some() {
5860 return Err(serde::de::Error::duplicate_field("aggCallStates"));
5861 }
5862 agg_call_states__ = Some(map_.next_value()?);
5863 }
5864 GeneratedField::IntermediateStateTable => {
5865 if intermediate_state_table__.is_some() {
5866 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
5867 }
5868 intermediate_state_table__ = map_.next_value()?;
5869 }
5870 GeneratedField::IsAppendOnly => {
5871 if is_append_only__.is_some() {
5872 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
5873 }
5874 is_append_only__ = Some(map_.next_value()?);
5875 }
5876 GeneratedField::DistinctDedupTables => {
5877 if distinct_dedup_tables__.is_some() {
5878 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
5879 }
5880 distinct_dedup_tables__ = Some(
5881 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5882 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
5883 );
5884 }
5885 GeneratedField::RowCountIndex => {
5886 if row_count_index__.is_some() {
5887 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
5888 }
5889 row_count_index__ =
5890 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5891 ;
5892 }
5893 GeneratedField::EmitOnWindowClose => {
5894 if emit_on_window_close__.is_some() {
5895 return Err(serde::de::Error::duplicate_field("emitOnWindowClose"));
5896 }
5897 emit_on_window_close__ = Some(map_.next_value()?);
5898 }
5899 GeneratedField::Version => {
5900 if version__.is_some() {
5901 return Err(serde::de::Error::duplicate_field("version"));
5902 }
5903 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
5904 }
5905 }
5906 }
5907 Ok(HashAggNode {
5908 group_key: group_key__.unwrap_or_default(),
5909 agg_calls: agg_calls__.unwrap_or_default(),
5910 agg_call_states: agg_call_states__.unwrap_or_default(),
5911 intermediate_state_table: intermediate_state_table__,
5912 is_append_only: is_append_only__.unwrap_or_default(),
5913 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
5914 row_count_index: row_count_index__.unwrap_or_default(),
5915 emit_on_window_close: emit_on_window_close__.unwrap_or_default(),
5916 version: version__.unwrap_or_default(),
5917 })
5918 }
5919 }
5920 deserializer.deserialize_struct("stream_plan.HashAggNode", FIELDS, GeneratedVisitor)
5921 }
5922}
5923impl serde::Serialize for HashJoinNode {
5924 #[allow(deprecated)]
5925 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5926 where
5927 S: serde::Serializer,
5928 {
5929 use serde::ser::SerializeStruct;
5930 let mut len = 0;
5931 if self.join_type != 0 {
5932 len += 1;
5933 }
5934 if !self.left_key.is_empty() {
5935 len += 1;
5936 }
5937 if !self.right_key.is_empty() {
5938 len += 1;
5939 }
5940 if self.condition.is_some() {
5941 len += 1;
5942 }
5943 if self.left_table.is_some() {
5944 len += 1;
5945 }
5946 if self.right_table.is_some() {
5947 len += 1;
5948 }
5949 if self.left_degree_table.is_some() {
5950 len += 1;
5951 }
5952 if self.right_degree_table.is_some() {
5953 len += 1;
5954 }
5955 if !self.output_indices.is_empty() {
5956 len += 1;
5957 }
5958 if !self.left_deduped_input_pk_indices.is_empty() {
5959 len += 1;
5960 }
5961 if !self.right_deduped_input_pk_indices.is_empty() {
5962 len += 1;
5963 }
5964 if !self.null_safe.is_empty() {
5965 len += 1;
5966 }
5967 if self.is_append_only {
5968 len += 1;
5969 }
5970 if self.join_encoding_type != 0 {
5971 len += 1;
5972 }
5973 if self.watermark_handle_desc.is_some() {
5974 len += 1;
5975 }
5976 let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinNode", len)?;
5977 if self.join_type != 0 {
5978 let v = super::plan_common::JoinType::try_from(self.join_type)
5979 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
5980 struct_ser.serialize_field("joinType", &v)?;
5981 }
5982 if !self.left_key.is_empty() {
5983 struct_ser.serialize_field("leftKey", &self.left_key)?;
5984 }
5985 if !self.right_key.is_empty() {
5986 struct_ser.serialize_field("rightKey", &self.right_key)?;
5987 }
5988 if let Some(v) = self.condition.as_ref() {
5989 struct_ser.serialize_field("condition", v)?;
5990 }
5991 if let Some(v) = self.left_table.as_ref() {
5992 struct_ser.serialize_field("leftTable", v)?;
5993 }
5994 if let Some(v) = self.right_table.as_ref() {
5995 struct_ser.serialize_field("rightTable", v)?;
5996 }
5997 if let Some(v) = self.left_degree_table.as_ref() {
5998 struct_ser.serialize_field("leftDegreeTable", v)?;
5999 }
6000 if let Some(v) = self.right_degree_table.as_ref() {
6001 struct_ser.serialize_field("rightDegreeTable", v)?;
6002 }
6003 if !self.output_indices.is_empty() {
6004 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
6005 }
6006 if !self.left_deduped_input_pk_indices.is_empty() {
6007 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
6008 }
6009 if !self.right_deduped_input_pk_indices.is_empty() {
6010 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
6011 }
6012 if !self.null_safe.is_empty() {
6013 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
6014 }
6015 if self.is_append_only {
6016 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
6017 }
6018 if self.join_encoding_type != 0 {
6019 let v = JoinEncodingType::try_from(self.join_encoding_type)
6020 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
6021 struct_ser.serialize_field("joinEncodingType", &v)?;
6022 }
6023 if let Some(v) = self.watermark_handle_desc.as_ref() {
6024 struct_ser.serialize_field("watermarkHandleDesc", v)?;
6025 }
6026 struct_ser.end()
6027 }
6028}
6029impl<'de> serde::Deserialize<'de> for HashJoinNode {
6030 #[allow(deprecated)]
6031 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6032 where
6033 D: serde::Deserializer<'de>,
6034 {
6035 const FIELDS: &[&str] = &[
6036 "join_type",
6037 "joinType",
6038 "left_key",
6039 "leftKey",
6040 "right_key",
6041 "rightKey",
6042 "condition",
6043 "left_table",
6044 "leftTable",
6045 "right_table",
6046 "rightTable",
6047 "left_degree_table",
6048 "leftDegreeTable",
6049 "right_degree_table",
6050 "rightDegreeTable",
6051 "output_indices",
6052 "outputIndices",
6053 "left_deduped_input_pk_indices",
6054 "leftDedupedInputPkIndices",
6055 "right_deduped_input_pk_indices",
6056 "rightDedupedInputPkIndices",
6057 "null_safe",
6058 "nullSafe",
6059 "is_append_only",
6060 "isAppendOnly",
6061 "join_encoding_type",
6062 "joinEncodingType",
6063 "watermark_handle_desc",
6064 "watermarkHandleDesc",
6065 ];
6066
6067 #[allow(clippy::enum_variant_names)]
6068 enum GeneratedField {
6069 JoinType,
6070 LeftKey,
6071 RightKey,
6072 Condition,
6073 LeftTable,
6074 RightTable,
6075 LeftDegreeTable,
6076 RightDegreeTable,
6077 OutputIndices,
6078 LeftDedupedInputPkIndices,
6079 RightDedupedInputPkIndices,
6080 NullSafe,
6081 IsAppendOnly,
6082 JoinEncodingType,
6083 WatermarkHandleDesc,
6084 }
6085 impl<'de> serde::Deserialize<'de> for GeneratedField {
6086 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6087 where
6088 D: serde::Deserializer<'de>,
6089 {
6090 struct GeneratedVisitor;
6091
6092 impl serde::de::Visitor<'_> for GeneratedVisitor {
6093 type Value = GeneratedField;
6094
6095 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6096 write!(formatter, "expected one of: {:?}", &FIELDS)
6097 }
6098
6099 #[allow(unused_variables)]
6100 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6101 where
6102 E: serde::de::Error,
6103 {
6104 match value {
6105 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
6106 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
6107 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
6108 "condition" => Ok(GeneratedField::Condition),
6109 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
6110 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
6111 "leftDegreeTable" | "left_degree_table" => Ok(GeneratedField::LeftDegreeTable),
6112 "rightDegreeTable" | "right_degree_table" => Ok(GeneratedField::RightDegreeTable),
6113 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
6114 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
6115 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
6116 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
6117 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
6118 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
6119 "watermarkHandleDesc" | "watermark_handle_desc" => Ok(GeneratedField::WatermarkHandleDesc),
6120 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6121 }
6122 }
6123 }
6124 deserializer.deserialize_identifier(GeneratedVisitor)
6125 }
6126 }
6127 struct GeneratedVisitor;
6128 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6129 type Value = HashJoinNode;
6130
6131 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6132 formatter.write_str("struct stream_plan.HashJoinNode")
6133 }
6134
6135 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinNode, V::Error>
6136 where
6137 V: serde::de::MapAccess<'de>,
6138 {
6139 let mut join_type__ = None;
6140 let mut left_key__ = None;
6141 let mut right_key__ = None;
6142 let mut condition__ = None;
6143 let mut left_table__ = None;
6144 let mut right_table__ = None;
6145 let mut left_degree_table__ = None;
6146 let mut right_degree_table__ = None;
6147 let mut output_indices__ = None;
6148 let mut left_deduped_input_pk_indices__ = None;
6149 let mut right_deduped_input_pk_indices__ = None;
6150 let mut null_safe__ = None;
6151 let mut is_append_only__ = None;
6152 let mut join_encoding_type__ = None;
6153 let mut watermark_handle_desc__ = None;
6154 while let Some(k) = map_.next_key()? {
6155 match k {
6156 GeneratedField::JoinType => {
6157 if join_type__.is_some() {
6158 return Err(serde::de::Error::duplicate_field("joinType"));
6159 }
6160 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
6161 }
6162 GeneratedField::LeftKey => {
6163 if left_key__.is_some() {
6164 return Err(serde::de::Error::duplicate_field("leftKey"));
6165 }
6166 left_key__ =
6167 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6168 .into_iter().map(|x| x.0).collect())
6169 ;
6170 }
6171 GeneratedField::RightKey => {
6172 if right_key__.is_some() {
6173 return Err(serde::de::Error::duplicate_field("rightKey"));
6174 }
6175 right_key__ =
6176 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6177 .into_iter().map(|x| x.0).collect())
6178 ;
6179 }
6180 GeneratedField::Condition => {
6181 if condition__.is_some() {
6182 return Err(serde::de::Error::duplicate_field("condition"));
6183 }
6184 condition__ = map_.next_value()?;
6185 }
6186 GeneratedField::LeftTable => {
6187 if left_table__.is_some() {
6188 return Err(serde::de::Error::duplicate_field("leftTable"));
6189 }
6190 left_table__ = map_.next_value()?;
6191 }
6192 GeneratedField::RightTable => {
6193 if right_table__.is_some() {
6194 return Err(serde::de::Error::duplicate_field("rightTable"));
6195 }
6196 right_table__ = map_.next_value()?;
6197 }
6198 GeneratedField::LeftDegreeTable => {
6199 if left_degree_table__.is_some() {
6200 return Err(serde::de::Error::duplicate_field("leftDegreeTable"));
6201 }
6202 left_degree_table__ = map_.next_value()?;
6203 }
6204 GeneratedField::RightDegreeTable => {
6205 if right_degree_table__.is_some() {
6206 return Err(serde::de::Error::duplicate_field("rightDegreeTable"));
6207 }
6208 right_degree_table__ = map_.next_value()?;
6209 }
6210 GeneratedField::OutputIndices => {
6211 if output_indices__.is_some() {
6212 return Err(serde::de::Error::duplicate_field("outputIndices"));
6213 }
6214 output_indices__ =
6215 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6216 .into_iter().map(|x| x.0).collect())
6217 ;
6218 }
6219 GeneratedField::LeftDedupedInputPkIndices => {
6220 if left_deduped_input_pk_indices__.is_some() {
6221 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
6222 }
6223 left_deduped_input_pk_indices__ =
6224 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6225 .into_iter().map(|x| x.0).collect())
6226 ;
6227 }
6228 GeneratedField::RightDedupedInputPkIndices => {
6229 if right_deduped_input_pk_indices__.is_some() {
6230 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
6231 }
6232 right_deduped_input_pk_indices__ =
6233 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6234 .into_iter().map(|x| x.0).collect())
6235 ;
6236 }
6237 GeneratedField::NullSafe => {
6238 if null_safe__.is_some() {
6239 return Err(serde::de::Error::duplicate_field("nullSafe"));
6240 }
6241 null_safe__ = Some(map_.next_value()?);
6242 }
6243 GeneratedField::IsAppendOnly => {
6244 if is_append_only__.is_some() {
6245 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
6246 }
6247 is_append_only__ = Some(map_.next_value()?);
6248 }
6249 GeneratedField::JoinEncodingType => {
6250 if join_encoding_type__.is_some() {
6251 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
6252 }
6253 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
6254 }
6255 GeneratedField::WatermarkHandleDesc => {
6256 if watermark_handle_desc__.is_some() {
6257 return Err(serde::de::Error::duplicate_field("watermarkHandleDesc"));
6258 }
6259 watermark_handle_desc__ = map_.next_value()?;
6260 }
6261 }
6262 }
6263 Ok(HashJoinNode {
6264 join_type: join_type__.unwrap_or_default(),
6265 left_key: left_key__.unwrap_or_default(),
6266 right_key: right_key__.unwrap_or_default(),
6267 condition: condition__,
6268 left_table: left_table__,
6269 right_table: right_table__,
6270 left_degree_table: left_degree_table__,
6271 right_degree_table: right_degree_table__,
6272 output_indices: output_indices__.unwrap_or_default(),
6273 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
6274 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
6275 null_safe: null_safe__.unwrap_or_default(),
6276 is_append_only: is_append_only__.unwrap_or_default(),
6277 join_encoding_type: join_encoding_type__.unwrap_or_default(),
6278 watermark_handle_desc: watermark_handle_desc__,
6279 })
6280 }
6281 }
6282 deserializer.deserialize_struct("stream_plan.HashJoinNode", FIELDS, GeneratedVisitor)
6283 }
6284}
6285impl serde::Serialize for HashJoinWatermarkHandleDesc {
6286 #[allow(deprecated)]
6287 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6288 where
6289 S: serde::Serializer,
6290 {
6291 use serde::ser::SerializeStruct;
6292 let mut len = 0;
6293 if !self.watermark_indices_in_jk.is_empty() {
6294 len += 1;
6295 }
6296 if !self.inequality_pairs.is_empty() {
6297 len += 1;
6298 }
6299 let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinWatermarkHandleDesc", len)?;
6300 if !self.watermark_indices_in_jk.is_empty() {
6301 struct_ser.serialize_field("watermarkIndicesInJk", &self.watermark_indices_in_jk)?;
6302 }
6303 if !self.inequality_pairs.is_empty() {
6304 struct_ser.serialize_field("inequalityPairs", &self.inequality_pairs)?;
6305 }
6306 struct_ser.end()
6307 }
6308}
6309impl<'de> serde::Deserialize<'de> for HashJoinWatermarkHandleDesc {
6310 #[allow(deprecated)]
6311 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6312 where
6313 D: serde::Deserializer<'de>,
6314 {
6315 const FIELDS: &[&str] = &[
6316 "watermark_indices_in_jk",
6317 "watermarkIndicesInJk",
6318 "inequality_pairs",
6319 "inequalityPairs",
6320 ];
6321
6322 #[allow(clippy::enum_variant_names)]
6323 enum GeneratedField {
6324 WatermarkIndicesInJk,
6325 InequalityPairs,
6326 }
6327 impl<'de> serde::Deserialize<'de> for GeneratedField {
6328 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6329 where
6330 D: serde::Deserializer<'de>,
6331 {
6332 struct GeneratedVisitor;
6333
6334 impl serde::de::Visitor<'_> for GeneratedVisitor {
6335 type Value = GeneratedField;
6336
6337 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6338 write!(formatter, "expected one of: {:?}", &FIELDS)
6339 }
6340
6341 #[allow(unused_variables)]
6342 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6343 where
6344 E: serde::de::Error,
6345 {
6346 match value {
6347 "watermarkIndicesInJk" | "watermark_indices_in_jk" => Ok(GeneratedField::WatermarkIndicesInJk),
6348 "inequalityPairs" | "inequality_pairs" => Ok(GeneratedField::InequalityPairs),
6349 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6350 }
6351 }
6352 }
6353 deserializer.deserialize_identifier(GeneratedVisitor)
6354 }
6355 }
6356 struct GeneratedVisitor;
6357 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6358 type Value = HashJoinWatermarkHandleDesc;
6359
6360 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6361 formatter.write_str("struct stream_plan.HashJoinWatermarkHandleDesc")
6362 }
6363
6364 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinWatermarkHandleDesc, V::Error>
6365 where
6366 V: serde::de::MapAccess<'de>,
6367 {
6368 let mut watermark_indices_in_jk__ = None;
6369 let mut inequality_pairs__ = None;
6370 while let Some(k) = map_.next_key()? {
6371 match k {
6372 GeneratedField::WatermarkIndicesInJk => {
6373 if watermark_indices_in_jk__.is_some() {
6374 return Err(serde::de::Error::duplicate_field("watermarkIndicesInJk"));
6375 }
6376 watermark_indices_in_jk__ = Some(map_.next_value()?);
6377 }
6378 GeneratedField::InequalityPairs => {
6379 if inequality_pairs__.is_some() {
6380 return Err(serde::de::Error::duplicate_field("inequalityPairs"));
6381 }
6382 inequality_pairs__ = Some(map_.next_value()?);
6383 }
6384 }
6385 }
6386 Ok(HashJoinWatermarkHandleDesc {
6387 watermark_indices_in_jk: watermark_indices_in_jk__.unwrap_or_default(),
6388 inequality_pairs: inequality_pairs__.unwrap_or_default(),
6389 })
6390 }
6391 }
6392 deserializer.deserialize_struct("stream_plan.HashJoinWatermarkHandleDesc", FIELDS, GeneratedVisitor)
6393 }
6394}
6395impl serde::Serialize for HopWindowNode {
6396 #[allow(deprecated)]
6397 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6398 where
6399 S: serde::Serializer,
6400 {
6401 use serde::ser::SerializeStruct;
6402 let mut len = 0;
6403 if self.time_col != 0 {
6404 len += 1;
6405 }
6406 if self.window_slide.is_some() {
6407 len += 1;
6408 }
6409 if self.window_size.is_some() {
6410 len += 1;
6411 }
6412 if !self.output_indices.is_empty() {
6413 len += 1;
6414 }
6415 if !self.window_start_exprs.is_empty() {
6416 len += 1;
6417 }
6418 if !self.window_end_exprs.is_empty() {
6419 len += 1;
6420 }
6421 let mut struct_ser = serializer.serialize_struct("stream_plan.HopWindowNode", len)?;
6422 if self.time_col != 0 {
6423 struct_ser.serialize_field("timeCol", &self.time_col)?;
6424 }
6425 if let Some(v) = self.window_slide.as_ref() {
6426 struct_ser.serialize_field("windowSlide", v)?;
6427 }
6428 if let Some(v) = self.window_size.as_ref() {
6429 struct_ser.serialize_field("windowSize", v)?;
6430 }
6431 if !self.output_indices.is_empty() {
6432 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
6433 }
6434 if !self.window_start_exprs.is_empty() {
6435 struct_ser.serialize_field("windowStartExprs", &self.window_start_exprs)?;
6436 }
6437 if !self.window_end_exprs.is_empty() {
6438 struct_ser.serialize_field("windowEndExprs", &self.window_end_exprs)?;
6439 }
6440 struct_ser.end()
6441 }
6442}
6443impl<'de> serde::Deserialize<'de> for HopWindowNode {
6444 #[allow(deprecated)]
6445 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6446 where
6447 D: serde::Deserializer<'de>,
6448 {
6449 const FIELDS: &[&str] = &[
6450 "time_col",
6451 "timeCol",
6452 "window_slide",
6453 "windowSlide",
6454 "window_size",
6455 "windowSize",
6456 "output_indices",
6457 "outputIndices",
6458 "window_start_exprs",
6459 "windowStartExprs",
6460 "window_end_exprs",
6461 "windowEndExprs",
6462 ];
6463
6464 #[allow(clippy::enum_variant_names)]
6465 enum GeneratedField {
6466 TimeCol,
6467 WindowSlide,
6468 WindowSize,
6469 OutputIndices,
6470 WindowStartExprs,
6471 WindowEndExprs,
6472 }
6473 impl<'de> serde::Deserialize<'de> for GeneratedField {
6474 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6475 where
6476 D: serde::Deserializer<'de>,
6477 {
6478 struct GeneratedVisitor;
6479
6480 impl serde::de::Visitor<'_> for GeneratedVisitor {
6481 type Value = GeneratedField;
6482
6483 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6484 write!(formatter, "expected one of: {:?}", &FIELDS)
6485 }
6486
6487 #[allow(unused_variables)]
6488 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6489 where
6490 E: serde::de::Error,
6491 {
6492 match value {
6493 "timeCol" | "time_col" => Ok(GeneratedField::TimeCol),
6494 "windowSlide" | "window_slide" => Ok(GeneratedField::WindowSlide),
6495 "windowSize" | "window_size" => Ok(GeneratedField::WindowSize),
6496 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
6497 "windowStartExprs" | "window_start_exprs" => Ok(GeneratedField::WindowStartExprs),
6498 "windowEndExprs" | "window_end_exprs" => Ok(GeneratedField::WindowEndExprs),
6499 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6500 }
6501 }
6502 }
6503 deserializer.deserialize_identifier(GeneratedVisitor)
6504 }
6505 }
6506 struct GeneratedVisitor;
6507 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6508 type Value = HopWindowNode;
6509
6510 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6511 formatter.write_str("struct stream_plan.HopWindowNode")
6512 }
6513
6514 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HopWindowNode, V::Error>
6515 where
6516 V: serde::de::MapAccess<'de>,
6517 {
6518 let mut time_col__ = None;
6519 let mut window_slide__ = None;
6520 let mut window_size__ = None;
6521 let mut output_indices__ = None;
6522 let mut window_start_exprs__ = None;
6523 let mut window_end_exprs__ = None;
6524 while let Some(k) = map_.next_key()? {
6525 match k {
6526 GeneratedField::TimeCol => {
6527 if time_col__.is_some() {
6528 return Err(serde::de::Error::duplicate_field("timeCol"));
6529 }
6530 time_col__ =
6531 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6532 ;
6533 }
6534 GeneratedField::WindowSlide => {
6535 if window_slide__.is_some() {
6536 return Err(serde::de::Error::duplicate_field("windowSlide"));
6537 }
6538 window_slide__ = map_.next_value()?;
6539 }
6540 GeneratedField::WindowSize => {
6541 if window_size__.is_some() {
6542 return Err(serde::de::Error::duplicate_field("windowSize"));
6543 }
6544 window_size__ = map_.next_value()?;
6545 }
6546 GeneratedField::OutputIndices => {
6547 if output_indices__.is_some() {
6548 return Err(serde::de::Error::duplicate_field("outputIndices"));
6549 }
6550 output_indices__ =
6551 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6552 .into_iter().map(|x| x.0).collect())
6553 ;
6554 }
6555 GeneratedField::WindowStartExprs => {
6556 if window_start_exprs__.is_some() {
6557 return Err(serde::de::Error::duplicate_field("windowStartExprs"));
6558 }
6559 window_start_exprs__ = Some(map_.next_value()?);
6560 }
6561 GeneratedField::WindowEndExprs => {
6562 if window_end_exprs__.is_some() {
6563 return Err(serde::de::Error::duplicate_field("windowEndExprs"));
6564 }
6565 window_end_exprs__ = Some(map_.next_value()?);
6566 }
6567 }
6568 }
6569 Ok(HopWindowNode {
6570 time_col: time_col__.unwrap_or_default(),
6571 window_slide: window_slide__,
6572 window_size: window_size__,
6573 output_indices: output_indices__.unwrap_or_default(),
6574 window_start_exprs: window_start_exprs__.unwrap_or_default(),
6575 window_end_exprs: window_end_exprs__.unwrap_or_default(),
6576 })
6577 }
6578 }
6579 deserializer.deserialize_struct("stream_plan.HopWindowNode", FIELDS, GeneratedVisitor)
6580 }
6581}
6582impl serde::Serialize for IcebergWithPkIndexPositionDeleteMergerNode {
6583 #[allow(deprecated)]
6584 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6585 where
6586 S: serde::Serializer,
6587 {
6588 use serde::ser::SerializeStruct;
6589 let mut len = 0;
6590 if self.sink_desc.is_some() {
6591 len += 1;
6592 }
6593 let mut struct_ser = serializer.serialize_struct("stream_plan.IcebergWithPkIndexPositionDeleteMergerNode", len)?;
6594 if let Some(v) = self.sink_desc.as_ref() {
6595 struct_ser.serialize_field("sinkDesc", v)?;
6596 }
6597 struct_ser.end()
6598 }
6599}
6600impl<'de> serde::Deserialize<'de> for IcebergWithPkIndexPositionDeleteMergerNode {
6601 #[allow(deprecated)]
6602 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6603 where
6604 D: serde::Deserializer<'de>,
6605 {
6606 const FIELDS: &[&str] = &[
6607 "sink_desc",
6608 "sinkDesc",
6609 ];
6610
6611 #[allow(clippy::enum_variant_names)]
6612 enum GeneratedField {
6613 SinkDesc,
6614 }
6615 impl<'de> serde::Deserialize<'de> for GeneratedField {
6616 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6617 where
6618 D: serde::Deserializer<'de>,
6619 {
6620 struct GeneratedVisitor;
6621
6622 impl serde::de::Visitor<'_> for GeneratedVisitor {
6623 type Value = GeneratedField;
6624
6625 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6626 write!(formatter, "expected one of: {:?}", &FIELDS)
6627 }
6628
6629 #[allow(unused_variables)]
6630 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6631 where
6632 E: serde::de::Error,
6633 {
6634 match value {
6635 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
6636 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6637 }
6638 }
6639 }
6640 deserializer.deserialize_identifier(GeneratedVisitor)
6641 }
6642 }
6643 struct GeneratedVisitor;
6644 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6645 type Value = IcebergWithPkIndexPositionDeleteMergerNode;
6646
6647 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6648 formatter.write_str("struct stream_plan.IcebergWithPkIndexPositionDeleteMergerNode")
6649 }
6650
6651 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IcebergWithPkIndexPositionDeleteMergerNode, V::Error>
6652 where
6653 V: serde::de::MapAccess<'de>,
6654 {
6655 let mut sink_desc__ = None;
6656 while let Some(k) = map_.next_key()? {
6657 match k {
6658 GeneratedField::SinkDesc => {
6659 if sink_desc__.is_some() {
6660 return Err(serde::de::Error::duplicate_field("sinkDesc"));
6661 }
6662 sink_desc__ = map_.next_value()?;
6663 }
6664 }
6665 }
6666 Ok(IcebergWithPkIndexPositionDeleteMergerNode {
6667 sink_desc: sink_desc__,
6668 })
6669 }
6670 }
6671 deserializer.deserialize_struct("stream_plan.IcebergWithPkIndexPositionDeleteMergerNode", FIELDS, GeneratedVisitor)
6672 }
6673}
6674impl serde::Serialize for IcebergWithPkIndexWriterNode {
6675 #[allow(deprecated)]
6676 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6677 where
6678 S: serde::Serializer,
6679 {
6680 use serde::ser::SerializeStruct;
6681 let mut len = 0;
6682 if self.sink_desc.is_some() {
6683 len += 1;
6684 }
6685 if self.pk_index_table.is_some() {
6686 len += 1;
6687 }
6688 let mut struct_ser = serializer.serialize_struct("stream_plan.IcebergWithPkIndexWriterNode", len)?;
6689 if let Some(v) = self.sink_desc.as_ref() {
6690 struct_ser.serialize_field("sinkDesc", v)?;
6691 }
6692 if let Some(v) = self.pk_index_table.as_ref() {
6693 struct_ser.serialize_field("pkIndexTable", v)?;
6694 }
6695 struct_ser.end()
6696 }
6697}
6698impl<'de> serde::Deserialize<'de> for IcebergWithPkIndexWriterNode {
6699 #[allow(deprecated)]
6700 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6701 where
6702 D: serde::Deserializer<'de>,
6703 {
6704 const FIELDS: &[&str] = &[
6705 "sink_desc",
6706 "sinkDesc",
6707 "pk_index_table",
6708 "pkIndexTable",
6709 ];
6710
6711 #[allow(clippy::enum_variant_names)]
6712 enum GeneratedField {
6713 SinkDesc,
6714 PkIndexTable,
6715 }
6716 impl<'de> serde::Deserialize<'de> for GeneratedField {
6717 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6718 where
6719 D: serde::Deserializer<'de>,
6720 {
6721 struct GeneratedVisitor;
6722
6723 impl serde::de::Visitor<'_> for GeneratedVisitor {
6724 type Value = GeneratedField;
6725
6726 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6727 write!(formatter, "expected one of: {:?}", &FIELDS)
6728 }
6729
6730 #[allow(unused_variables)]
6731 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6732 where
6733 E: serde::de::Error,
6734 {
6735 match value {
6736 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
6737 "pkIndexTable" | "pk_index_table" => Ok(GeneratedField::PkIndexTable),
6738 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6739 }
6740 }
6741 }
6742 deserializer.deserialize_identifier(GeneratedVisitor)
6743 }
6744 }
6745 struct GeneratedVisitor;
6746 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6747 type Value = IcebergWithPkIndexWriterNode;
6748
6749 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6750 formatter.write_str("struct stream_plan.IcebergWithPkIndexWriterNode")
6751 }
6752
6753 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IcebergWithPkIndexWriterNode, V::Error>
6754 where
6755 V: serde::de::MapAccess<'de>,
6756 {
6757 let mut sink_desc__ = None;
6758 let mut pk_index_table__ = None;
6759 while let Some(k) = map_.next_key()? {
6760 match k {
6761 GeneratedField::SinkDesc => {
6762 if sink_desc__.is_some() {
6763 return Err(serde::de::Error::duplicate_field("sinkDesc"));
6764 }
6765 sink_desc__ = map_.next_value()?;
6766 }
6767 GeneratedField::PkIndexTable => {
6768 if pk_index_table__.is_some() {
6769 return Err(serde::de::Error::duplicate_field("pkIndexTable"));
6770 }
6771 pk_index_table__ = map_.next_value()?;
6772 }
6773 }
6774 }
6775 Ok(IcebergWithPkIndexWriterNode {
6776 sink_desc: sink_desc__,
6777 pk_index_table: pk_index_table__,
6778 })
6779 }
6780 }
6781 deserializer.deserialize_struct("stream_plan.IcebergWithPkIndexWriterNode", FIELDS, GeneratedVisitor)
6782 }
6783}
6784impl serde::Serialize for InequalityPair {
6785 #[allow(deprecated)]
6786 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6787 where
6788 S: serde::Serializer,
6789 {
6790 use serde::ser::SerializeStruct;
6791 let mut len = 0;
6792 if self.key_required_larger != 0 {
6793 len += 1;
6794 }
6795 if self.key_required_smaller != 0 {
6796 len += 1;
6797 }
6798 if self.clean_state {
6799 len += 1;
6800 }
6801 if self.delta_expression.is_some() {
6802 len += 1;
6803 }
6804 let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPair", len)?;
6805 if self.key_required_larger != 0 {
6806 struct_ser.serialize_field("keyRequiredLarger", &self.key_required_larger)?;
6807 }
6808 if self.key_required_smaller != 0 {
6809 struct_ser.serialize_field("keyRequiredSmaller", &self.key_required_smaller)?;
6810 }
6811 if self.clean_state {
6812 struct_ser.serialize_field("cleanState", &self.clean_state)?;
6813 }
6814 if let Some(v) = self.delta_expression.as_ref() {
6815 struct_ser.serialize_field("deltaExpression", v)?;
6816 }
6817 struct_ser.end()
6818 }
6819}
6820impl<'de> serde::Deserialize<'de> for InequalityPair {
6821 #[allow(deprecated)]
6822 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6823 where
6824 D: serde::Deserializer<'de>,
6825 {
6826 const FIELDS: &[&str] = &[
6827 "key_required_larger",
6828 "keyRequiredLarger",
6829 "key_required_smaller",
6830 "keyRequiredSmaller",
6831 "clean_state",
6832 "cleanState",
6833 "delta_expression",
6834 "deltaExpression",
6835 ];
6836
6837 #[allow(clippy::enum_variant_names)]
6838 enum GeneratedField {
6839 KeyRequiredLarger,
6840 KeyRequiredSmaller,
6841 CleanState,
6842 DeltaExpression,
6843 }
6844 impl<'de> serde::Deserialize<'de> for GeneratedField {
6845 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6846 where
6847 D: serde::Deserializer<'de>,
6848 {
6849 struct GeneratedVisitor;
6850
6851 impl serde::de::Visitor<'_> for GeneratedVisitor {
6852 type Value = GeneratedField;
6853
6854 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6855 write!(formatter, "expected one of: {:?}", &FIELDS)
6856 }
6857
6858 #[allow(unused_variables)]
6859 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6860 where
6861 E: serde::de::Error,
6862 {
6863 match value {
6864 "keyRequiredLarger" | "key_required_larger" => Ok(GeneratedField::KeyRequiredLarger),
6865 "keyRequiredSmaller" | "key_required_smaller" => Ok(GeneratedField::KeyRequiredSmaller),
6866 "cleanState" | "clean_state" => Ok(GeneratedField::CleanState),
6867 "deltaExpression" | "delta_expression" => Ok(GeneratedField::DeltaExpression),
6868 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6869 }
6870 }
6871 }
6872 deserializer.deserialize_identifier(GeneratedVisitor)
6873 }
6874 }
6875 struct GeneratedVisitor;
6876 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6877 type Value = InequalityPair;
6878
6879 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6880 formatter.write_str("struct stream_plan.InequalityPair")
6881 }
6882
6883 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPair, V::Error>
6884 where
6885 V: serde::de::MapAccess<'de>,
6886 {
6887 let mut key_required_larger__ = None;
6888 let mut key_required_smaller__ = None;
6889 let mut clean_state__ = None;
6890 let mut delta_expression__ = None;
6891 while let Some(k) = map_.next_key()? {
6892 match k {
6893 GeneratedField::KeyRequiredLarger => {
6894 if key_required_larger__.is_some() {
6895 return Err(serde::de::Error::duplicate_field("keyRequiredLarger"));
6896 }
6897 key_required_larger__ =
6898 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6899 ;
6900 }
6901 GeneratedField::KeyRequiredSmaller => {
6902 if key_required_smaller__.is_some() {
6903 return Err(serde::de::Error::duplicate_field("keyRequiredSmaller"));
6904 }
6905 key_required_smaller__ =
6906 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6907 ;
6908 }
6909 GeneratedField::CleanState => {
6910 if clean_state__.is_some() {
6911 return Err(serde::de::Error::duplicate_field("cleanState"));
6912 }
6913 clean_state__ = Some(map_.next_value()?);
6914 }
6915 GeneratedField::DeltaExpression => {
6916 if delta_expression__.is_some() {
6917 return Err(serde::de::Error::duplicate_field("deltaExpression"));
6918 }
6919 delta_expression__ = map_.next_value()?;
6920 }
6921 }
6922 }
6923 Ok(InequalityPair {
6924 key_required_larger: key_required_larger__.unwrap_or_default(),
6925 key_required_smaller: key_required_smaller__.unwrap_or_default(),
6926 clean_state: clean_state__.unwrap_or_default(),
6927 delta_expression: delta_expression__,
6928 })
6929 }
6930 }
6931 deserializer.deserialize_struct("stream_plan.InequalityPair", FIELDS, GeneratedVisitor)
6932 }
6933}
6934impl serde::Serialize for InequalityPairV2 {
6935 #[allow(deprecated)]
6936 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6937 where
6938 S: serde::Serializer,
6939 {
6940 use serde::ser::SerializeStruct;
6941 let mut len = 0;
6942 if self.left_idx != 0 {
6943 len += 1;
6944 }
6945 if self.right_idx != 0 {
6946 len += 1;
6947 }
6948 if self.clean_left_state {
6949 len += 1;
6950 }
6951 if self.clean_right_state {
6952 len += 1;
6953 }
6954 if self.op != 0 {
6955 len += 1;
6956 }
6957 let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPairV2", len)?;
6958 if self.left_idx != 0 {
6959 struct_ser.serialize_field("leftIdx", &self.left_idx)?;
6960 }
6961 if self.right_idx != 0 {
6962 struct_ser.serialize_field("rightIdx", &self.right_idx)?;
6963 }
6964 if self.clean_left_state {
6965 struct_ser.serialize_field("cleanLeftState", &self.clean_left_state)?;
6966 }
6967 if self.clean_right_state {
6968 struct_ser.serialize_field("cleanRightState", &self.clean_right_state)?;
6969 }
6970 if self.op != 0 {
6971 let v = InequalityType::try_from(self.op)
6972 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.op)))?;
6973 struct_ser.serialize_field("op", &v)?;
6974 }
6975 struct_ser.end()
6976 }
6977}
6978impl<'de> serde::Deserialize<'de> for InequalityPairV2 {
6979 #[allow(deprecated)]
6980 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6981 where
6982 D: serde::Deserializer<'de>,
6983 {
6984 const FIELDS: &[&str] = &[
6985 "left_idx",
6986 "leftIdx",
6987 "right_idx",
6988 "rightIdx",
6989 "clean_left_state",
6990 "cleanLeftState",
6991 "clean_right_state",
6992 "cleanRightState",
6993 "op",
6994 ];
6995
6996 #[allow(clippy::enum_variant_names)]
6997 enum GeneratedField {
6998 LeftIdx,
6999 RightIdx,
7000 CleanLeftState,
7001 CleanRightState,
7002 Op,
7003 }
7004 impl<'de> serde::Deserialize<'de> for GeneratedField {
7005 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7006 where
7007 D: serde::Deserializer<'de>,
7008 {
7009 struct GeneratedVisitor;
7010
7011 impl serde::de::Visitor<'_> for GeneratedVisitor {
7012 type Value = GeneratedField;
7013
7014 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7015 write!(formatter, "expected one of: {:?}", &FIELDS)
7016 }
7017
7018 #[allow(unused_variables)]
7019 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7020 where
7021 E: serde::de::Error,
7022 {
7023 match value {
7024 "leftIdx" | "left_idx" => Ok(GeneratedField::LeftIdx),
7025 "rightIdx" | "right_idx" => Ok(GeneratedField::RightIdx),
7026 "cleanLeftState" | "clean_left_state" => Ok(GeneratedField::CleanLeftState),
7027 "cleanRightState" | "clean_right_state" => Ok(GeneratedField::CleanRightState),
7028 "op" => Ok(GeneratedField::Op),
7029 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7030 }
7031 }
7032 }
7033 deserializer.deserialize_identifier(GeneratedVisitor)
7034 }
7035 }
7036 struct GeneratedVisitor;
7037 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7038 type Value = InequalityPairV2;
7039
7040 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7041 formatter.write_str("struct stream_plan.InequalityPairV2")
7042 }
7043
7044 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPairV2, V::Error>
7045 where
7046 V: serde::de::MapAccess<'de>,
7047 {
7048 let mut left_idx__ = None;
7049 let mut right_idx__ = None;
7050 let mut clean_left_state__ = None;
7051 let mut clean_right_state__ = None;
7052 let mut op__ = None;
7053 while let Some(k) = map_.next_key()? {
7054 match k {
7055 GeneratedField::LeftIdx => {
7056 if left_idx__.is_some() {
7057 return Err(serde::de::Error::duplicate_field("leftIdx"));
7058 }
7059 left_idx__ =
7060 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7061 ;
7062 }
7063 GeneratedField::RightIdx => {
7064 if right_idx__.is_some() {
7065 return Err(serde::de::Error::duplicate_field("rightIdx"));
7066 }
7067 right_idx__ =
7068 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7069 ;
7070 }
7071 GeneratedField::CleanLeftState => {
7072 if clean_left_state__.is_some() {
7073 return Err(serde::de::Error::duplicate_field("cleanLeftState"));
7074 }
7075 clean_left_state__ = Some(map_.next_value()?);
7076 }
7077 GeneratedField::CleanRightState => {
7078 if clean_right_state__.is_some() {
7079 return Err(serde::de::Error::duplicate_field("cleanRightState"));
7080 }
7081 clean_right_state__ = Some(map_.next_value()?);
7082 }
7083 GeneratedField::Op => {
7084 if op__.is_some() {
7085 return Err(serde::de::Error::duplicate_field("op"));
7086 }
7087 op__ = Some(map_.next_value::<InequalityType>()? as i32);
7088 }
7089 }
7090 }
7091 Ok(InequalityPairV2 {
7092 left_idx: left_idx__.unwrap_or_default(),
7093 right_idx: right_idx__.unwrap_or_default(),
7094 clean_left_state: clean_left_state__.unwrap_or_default(),
7095 clean_right_state: clean_right_state__.unwrap_or_default(),
7096 op: op__.unwrap_or_default(),
7097 })
7098 }
7099 }
7100 deserializer.deserialize_struct("stream_plan.InequalityPairV2", FIELDS, GeneratedVisitor)
7101 }
7102}
7103impl serde::Serialize for InequalityType {
7104 #[allow(deprecated)]
7105 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7106 where
7107 S: serde::Serializer,
7108 {
7109 let variant = match self {
7110 Self::Unspecified => "INEQUALITY_TYPE_UNSPECIFIED",
7111 Self::LessThan => "INEQUALITY_TYPE_LESS_THAN",
7112 Self::LessThanOrEqual => "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL",
7113 Self::GreaterThan => "INEQUALITY_TYPE_GREATER_THAN",
7114 Self::GreaterThanOrEqual => "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL",
7115 };
7116 serializer.serialize_str(variant)
7117 }
7118}
7119impl<'de> serde::Deserialize<'de> for InequalityType {
7120 #[allow(deprecated)]
7121 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7122 where
7123 D: serde::Deserializer<'de>,
7124 {
7125 const FIELDS: &[&str] = &[
7126 "INEQUALITY_TYPE_UNSPECIFIED",
7127 "INEQUALITY_TYPE_LESS_THAN",
7128 "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL",
7129 "INEQUALITY_TYPE_GREATER_THAN",
7130 "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL",
7131 ];
7132
7133 struct GeneratedVisitor;
7134
7135 impl serde::de::Visitor<'_> for GeneratedVisitor {
7136 type Value = InequalityType;
7137
7138 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7139 write!(formatter, "expected one of: {:?}", &FIELDS)
7140 }
7141
7142 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
7143 where
7144 E: serde::de::Error,
7145 {
7146 i32::try_from(v)
7147 .ok()
7148 .and_then(|x| x.try_into().ok())
7149 .ok_or_else(|| {
7150 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
7151 })
7152 }
7153
7154 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
7155 where
7156 E: serde::de::Error,
7157 {
7158 i32::try_from(v)
7159 .ok()
7160 .and_then(|x| x.try_into().ok())
7161 .ok_or_else(|| {
7162 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
7163 })
7164 }
7165
7166 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
7167 where
7168 E: serde::de::Error,
7169 {
7170 match value {
7171 "INEQUALITY_TYPE_UNSPECIFIED" => Ok(InequalityType::Unspecified),
7172 "INEQUALITY_TYPE_LESS_THAN" => Ok(InequalityType::LessThan),
7173 "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL" => Ok(InequalityType::LessThanOrEqual),
7174 "INEQUALITY_TYPE_GREATER_THAN" => Ok(InequalityType::GreaterThan),
7175 "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL" => Ok(InequalityType::GreaterThanOrEqual),
7176 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
7177 }
7178 }
7179 }
7180 deserializer.deserialize_any(GeneratedVisitor)
7181 }
7182}
7183impl serde::Serialize for InjectSourceOffsetsMutation {
7184 #[allow(deprecated)]
7185 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7186 where
7187 S: serde::Serializer,
7188 {
7189 use serde::ser::SerializeStruct;
7190 let mut len = 0;
7191 if self.source_id != 0 {
7192 len += 1;
7193 }
7194 if !self.split_offsets.is_empty() {
7195 len += 1;
7196 }
7197 let mut struct_ser = serializer.serialize_struct("stream_plan.InjectSourceOffsetsMutation", len)?;
7198 if self.source_id != 0 {
7199 struct_ser.serialize_field("sourceId", &self.source_id)?;
7200 }
7201 if !self.split_offsets.is_empty() {
7202 struct_ser.serialize_field("splitOffsets", &self.split_offsets)?;
7203 }
7204 struct_ser.end()
7205 }
7206}
7207impl<'de> serde::Deserialize<'de> for InjectSourceOffsetsMutation {
7208 #[allow(deprecated)]
7209 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7210 where
7211 D: serde::Deserializer<'de>,
7212 {
7213 const FIELDS: &[&str] = &[
7214 "source_id",
7215 "sourceId",
7216 "split_offsets",
7217 "splitOffsets",
7218 ];
7219
7220 #[allow(clippy::enum_variant_names)]
7221 enum GeneratedField {
7222 SourceId,
7223 SplitOffsets,
7224 }
7225 impl<'de> serde::Deserialize<'de> for GeneratedField {
7226 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7227 where
7228 D: serde::Deserializer<'de>,
7229 {
7230 struct GeneratedVisitor;
7231
7232 impl serde::de::Visitor<'_> for GeneratedVisitor {
7233 type Value = GeneratedField;
7234
7235 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7236 write!(formatter, "expected one of: {:?}", &FIELDS)
7237 }
7238
7239 #[allow(unused_variables)]
7240 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7241 where
7242 E: serde::de::Error,
7243 {
7244 match value {
7245 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
7246 "splitOffsets" | "split_offsets" => Ok(GeneratedField::SplitOffsets),
7247 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7248 }
7249 }
7250 }
7251 deserializer.deserialize_identifier(GeneratedVisitor)
7252 }
7253 }
7254 struct GeneratedVisitor;
7255 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7256 type Value = InjectSourceOffsetsMutation;
7257
7258 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7259 formatter.write_str("struct stream_plan.InjectSourceOffsetsMutation")
7260 }
7261
7262 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InjectSourceOffsetsMutation, V::Error>
7263 where
7264 V: serde::de::MapAccess<'de>,
7265 {
7266 let mut source_id__ = None;
7267 let mut split_offsets__ = None;
7268 while let Some(k) = map_.next_key()? {
7269 match k {
7270 GeneratedField::SourceId => {
7271 if source_id__.is_some() {
7272 return Err(serde::de::Error::duplicate_field("sourceId"));
7273 }
7274 source_id__ =
7275 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7276 ;
7277 }
7278 GeneratedField::SplitOffsets => {
7279 if split_offsets__.is_some() {
7280 return Err(serde::de::Error::duplicate_field("splitOffsets"));
7281 }
7282 split_offsets__ = Some(
7283 map_.next_value::<std::collections::HashMap<_, _>>()?
7284 );
7285 }
7286 }
7287 }
7288 Ok(InjectSourceOffsetsMutation {
7289 source_id: source_id__.unwrap_or_default(),
7290 split_offsets: split_offsets__.unwrap_or_default(),
7291 })
7292 }
7293 }
7294 deserializer.deserialize_struct("stream_plan.InjectSourceOffsetsMutation", FIELDS, GeneratedVisitor)
7295 }
7296}
7297impl serde::Serialize for JoinEncodingType {
7298 #[allow(deprecated)]
7299 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7300 where
7301 S: serde::Serializer,
7302 {
7303 let variant = match self {
7304 Self::Unspecified => "UNSPECIFIED",
7305 Self::MemoryOptimized => "MEMORY_OPTIMIZED",
7306 Self::CpuOptimized => "CPU_OPTIMIZED",
7307 };
7308 serializer.serialize_str(variant)
7309 }
7310}
7311impl<'de> serde::Deserialize<'de> for JoinEncodingType {
7312 #[allow(deprecated)]
7313 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7314 where
7315 D: serde::Deserializer<'de>,
7316 {
7317 const FIELDS: &[&str] = &[
7318 "UNSPECIFIED",
7319 "MEMORY_OPTIMIZED",
7320 "CPU_OPTIMIZED",
7321 ];
7322
7323 struct GeneratedVisitor;
7324
7325 impl serde::de::Visitor<'_> for GeneratedVisitor {
7326 type Value = JoinEncodingType;
7327
7328 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7329 write!(formatter, "expected one of: {:?}", &FIELDS)
7330 }
7331
7332 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
7333 where
7334 E: serde::de::Error,
7335 {
7336 i32::try_from(v)
7337 .ok()
7338 .and_then(|x| x.try_into().ok())
7339 .ok_or_else(|| {
7340 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
7341 })
7342 }
7343
7344 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
7345 where
7346 E: serde::de::Error,
7347 {
7348 i32::try_from(v)
7349 .ok()
7350 .and_then(|x| x.try_into().ok())
7351 .ok_or_else(|| {
7352 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
7353 })
7354 }
7355
7356 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
7357 where
7358 E: serde::de::Error,
7359 {
7360 match value {
7361 "UNSPECIFIED" => Ok(JoinEncodingType::Unspecified),
7362 "MEMORY_OPTIMIZED" => Ok(JoinEncodingType::MemoryOptimized),
7363 "CPU_OPTIMIZED" => Ok(JoinEncodingType::CpuOptimized),
7364 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
7365 }
7366 }
7367 }
7368 deserializer.deserialize_any(GeneratedVisitor)
7369 }
7370}
7371impl serde::Serialize for JoinKeyWatermarkIndex {
7372 #[allow(deprecated)]
7373 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7374 where
7375 S: serde::Serializer,
7376 {
7377 use serde::ser::SerializeStruct;
7378 let mut len = 0;
7379 if self.index != 0 {
7380 len += 1;
7381 }
7382 if self.do_state_cleaning {
7383 len += 1;
7384 }
7385 let mut struct_ser = serializer.serialize_struct("stream_plan.JoinKeyWatermarkIndex", len)?;
7386 if self.index != 0 {
7387 struct_ser.serialize_field("index", &self.index)?;
7388 }
7389 if self.do_state_cleaning {
7390 struct_ser.serialize_field("doStateCleaning", &self.do_state_cleaning)?;
7391 }
7392 struct_ser.end()
7393 }
7394}
7395impl<'de> serde::Deserialize<'de> for JoinKeyWatermarkIndex {
7396 #[allow(deprecated)]
7397 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7398 where
7399 D: serde::Deserializer<'de>,
7400 {
7401 const FIELDS: &[&str] = &[
7402 "index",
7403 "do_state_cleaning",
7404 "doStateCleaning",
7405 ];
7406
7407 #[allow(clippy::enum_variant_names)]
7408 enum GeneratedField {
7409 Index,
7410 DoStateCleaning,
7411 }
7412 impl<'de> serde::Deserialize<'de> for GeneratedField {
7413 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7414 where
7415 D: serde::Deserializer<'de>,
7416 {
7417 struct GeneratedVisitor;
7418
7419 impl serde::de::Visitor<'_> for GeneratedVisitor {
7420 type Value = GeneratedField;
7421
7422 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7423 write!(formatter, "expected one of: {:?}", &FIELDS)
7424 }
7425
7426 #[allow(unused_variables)]
7427 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7428 where
7429 E: serde::de::Error,
7430 {
7431 match value {
7432 "index" => Ok(GeneratedField::Index),
7433 "doStateCleaning" | "do_state_cleaning" => Ok(GeneratedField::DoStateCleaning),
7434 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7435 }
7436 }
7437 }
7438 deserializer.deserialize_identifier(GeneratedVisitor)
7439 }
7440 }
7441 struct GeneratedVisitor;
7442 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7443 type Value = JoinKeyWatermarkIndex;
7444
7445 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7446 formatter.write_str("struct stream_plan.JoinKeyWatermarkIndex")
7447 }
7448
7449 fn visit_map<V>(self, mut map_: V) -> std::result::Result<JoinKeyWatermarkIndex, V::Error>
7450 where
7451 V: serde::de::MapAccess<'de>,
7452 {
7453 let mut index__ = None;
7454 let mut do_state_cleaning__ = None;
7455 while let Some(k) = map_.next_key()? {
7456 match k {
7457 GeneratedField::Index => {
7458 if index__.is_some() {
7459 return Err(serde::de::Error::duplicate_field("index"));
7460 }
7461 index__ =
7462 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7463 ;
7464 }
7465 GeneratedField::DoStateCleaning => {
7466 if do_state_cleaning__.is_some() {
7467 return Err(serde::de::Error::duplicate_field("doStateCleaning"));
7468 }
7469 do_state_cleaning__ = Some(map_.next_value()?);
7470 }
7471 }
7472 }
7473 Ok(JoinKeyWatermarkIndex {
7474 index: index__.unwrap_or_default(),
7475 do_state_cleaning: do_state_cleaning__.unwrap_or_default(),
7476 })
7477 }
7478 }
7479 deserializer.deserialize_struct("stream_plan.JoinKeyWatermarkIndex", FIELDS, GeneratedVisitor)
7480 }
7481}
7482impl serde::Serialize for ListFinishMutation {
7483 #[allow(deprecated)]
7484 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7485 where
7486 S: serde::Serializer,
7487 {
7488 use serde::ser::SerializeStruct;
7489 let mut len = 0;
7490 if self.associated_source_id != 0 {
7491 len += 1;
7492 }
7493 let mut struct_ser = serializer.serialize_struct("stream_plan.ListFinishMutation", len)?;
7494 if self.associated_source_id != 0 {
7495 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
7496 }
7497 struct_ser.end()
7498 }
7499}
7500impl<'de> serde::Deserialize<'de> for ListFinishMutation {
7501 #[allow(deprecated)]
7502 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7503 where
7504 D: serde::Deserializer<'de>,
7505 {
7506 const FIELDS: &[&str] = &[
7507 "associated_source_id",
7508 "associatedSourceId",
7509 ];
7510
7511 #[allow(clippy::enum_variant_names)]
7512 enum GeneratedField {
7513 AssociatedSourceId,
7514 }
7515 impl<'de> serde::Deserialize<'de> for GeneratedField {
7516 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7517 where
7518 D: serde::Deserializer<'de>,
7519 {
7520 struct GeneratedVisitor;
7521
7522 impl serde::de::Visitor<'_> for GeneratedVisitor {
7523 type Value = GeneratedField;
7524
7525 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7526 write!(formatter, "expected one of: {:?}", &FIELDS)
7527 }
7528
7529 #[allow(unused_variables)]
7530 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7531 where
7532 E: serde::de::Error,
7533 {
7534 match value {
7535 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
7536 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7537 }
7538 }
7539 }
7540 deserializer.deserialize_identifier(GeneratedVisitor)
7541 }
7542 }
7543 struct GeneratedVisitor;
7544 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7545 type Value = ListFinishMutation;
7546
7547 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7548 formatter.write_str("struct stream_plan.ListFinishMutation")
7549 }
7550
7551 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFinishMutation, V::Error>
7552 where
7553 V: serde::de::MapAccess<'de>,
7554 {
7555 let mut associated_source_id__ = None;
7556 while let Some(k) = map_.next_key()? {
7557 match k {
7558 GeneratedField::AssociatedSourceId => {
7559 if associated_source_id__.is_some() {
7560 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
7561 }
7562 associated_source_id__ =
7563 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7564 ;
7565 }
7566 }
7567 }
7568 Ok(ListFinishMutation {
7569 associated_source_id: associated_source_id__.unwrap_or_default(),
7570 })
7571 }
7572 }
7573 deserializer.deserialize_struct("stream_plan.ListFinishMutation", FIELDS, GeneratedVisitor)
7574 }
7575}
7576impl serde::Serialize for LoadFinishMutation {
7577 #[allow(deprecated)]
7578 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7579 where
7580 S: serde::Serializer,
7581 {
7582 use serde::ser::SerializeStruct;
7583 let mut len = 0;
7584 if self.associated_source_id != 0 {
7585 len += 1;
7586 }
7587 let mut struct_ser = serializer.serialize_struct("stream_plan.LoadFinishMutation", len)?;
7588 if self.associated_source_id != 0 {
7589 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
7590 }
7591 struct_ser.end()
7592 }
7593}
7594impl<'de> serde::Deserialize<'de> for LoadFinishMutation {
7595 #[allow(deprecated)]
7596 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7597 where
7598 D: serde::Deserializer<'de>,
7599 {
7600 const FIELDS: &[&str] = &[
7601 "associated_source_id",
7602 "associatedSourceId",
7603 ];
7604
7605 #[allow(clippy::enum_variant_names)]
7606 enum GeneratedField {
7607 AssociatedSourceId,
7608 }
7609 impl<'de> serde::Deserialize<'de> for GeneratedField {
7610 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7611 where
7612 D: serde::Deserializer<'de>,
7613 {
7614 struct GeneratedVisitor;
7615
7616 impl serde::de::Visitor<'_> for GeneratedVisitor {
7617 type Value = GeneratedField;
7618
7619 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7620 write!(formatter, "expected one of: {:?}", &FIELDS)
7621 }
7622
7623 #[allow(unused_variables)]
7624 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7625 where
7626 E: serde::de::Error,
7627 {
7628 match value {
7629 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
7630 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7631 }
7632 }
7633 }
7634 deserializer.deserialize_identifier(GeneratedVisitor)
7635 }
7636 }
7637 struct GeneratedVisitor;
7638 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7639 type Value = LoadFinishMutation;
7640
7641 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7642 formatter.write_str("struct stream_plan.LoadFinishMutation")
7643 }
7644
7645 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LoadFinishMutation, V::Error>
7646 where
7647 V: serde::de::MapAccess<'de>,
7648 {
7649 let mut associated_source_id__ = None;
7650 while let Some(k) = map_.next_key()? {
7651 match k {
7652 GeneratedField::AssociatedSourceId => {
7653 if associated_source_id__.is_some() {
7654 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
7655 }
7656 associated_source_id__ =
7657 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7658 ;
7659 }
7660 }
7661 }
7662 Ok(LoadFinishMutation {
7663 associated_source_id: associated_source_id__.unwrap_or_default(),
7664 })
7665 }
7666 }
7667 deserializer.deserialize_struct("stream_plan.LoadFinishMutation", FIELDS, GeneratedVisitor)
7668 }
7669}
7670impl serde::Serialize for LocalApproxPercentileNode {
7671 #[allow(deprecated)]
7672 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7673 where
7674 S: serde::Serializer,
7675 {
7676 use serde::ser::SerializeStruct;
7677 let mut len = 0;
7678 if self.base != 0. {
7679 len += 1;
7680 }
7681 if self.percentile_index != 0 {
7682 len += 1;
7683 }
7684 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalApproxPercentileNode", len)?;
7685 if self.base != 0. {
7686 struct_ser.serialize_field("base", &self.base)?;
7687 }
7688 if self.percentile_index != 0 {
7689 struct_ser.serialize_field("percentileIndex", &self.percentile_index)?;
7690 }
7691 struct_ser.end()
7692 }
7693}
7694impl<'de> serde::Deserialize<'de> for LocalApproxPercentileNode {
7695 #[allow(deprecated)]
7696 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7697 where
7698 D: serde::Deserializer<'de>,
7699 {
7700 const FIELDS: &[&str] = &[
7701 "base",
7702 "percentile_index",
7703 "percentileIndex",
7704 ];
7705
7706 #[allow(clippy::enum_variant_names)]
7707 enum GeneratedField {
7708 Base,
7709 PercentileIndex,
7710 }
7711 impl<'de> serde::Deserialize<'de> for GeneratedField {
7712 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7713 where
7714 D: serde::Deserializer<'de>,
7715 {
7716 struct GeneratedVisitor;
7717
7718 impl serde::de::Visitor<'_> for GeneratedVisitor {
7719 type Value = GeneratedField;
7720
7721 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7722 write!(formatter, "expected one of: {:?}", &FIELDS)
7723 }
7724
7725 #[allow(unused_variables)]
7726 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7727 where
7728 E: serde::de::Error,
7729 {
7730 match value {
7731 "base" => Ok(GeneratedField::Base),
7732 "percentileIndex" | "percentile_index" => Ok(GeneratedField::PercentileIndex),
7733 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7734 }
7735 }
7736 }
7737 deserializer.deserialize_identifier(GeneratedVisitor)
7738 }
7739 }
7740 struct GeneratedVisitor;
7741 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7742 type Value = LocalApproxPercentileNode;
7743
7744 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7745 formatter.write_str("struct stream_plan.LocalApproxPercentileNode")
7746 }
7747
7748 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalApproxPercentileNode, V::Error>
7749 where
7750 V: serde::de::MapAccess<'de>,
7751 {
7752 let mut base__ = None;
7753 let mut percentile_index__ = None;
7754 while let Some(k) = map_.next_key()? {
7755 match k {
7756 GeneratedField::Base => {
7757 if base__.is_some() {
7758 return Err(serde::de::Error::duplicate_field("base"));
7759 }
7760 base__ =
7761 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7762 ;
7763 }
7764 GeneratedField::PercentileIndex => {
7765 if percentile_index__.is_some() {
7766 return Err(serde::de::Error::duplicate_field("percentileIndex"));
7767 }
7768 percentile_index__ =
7769 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7770 ;
7771 }
7772 }
7773 }
7774 Ok(LocalApproxPercentileNode {
7775 base: base__.unwrap_or_default(),
7776 percentile_index: percentile_index__.unwrap_or_default(),
7777 })
7778 }
7779 }
7780 deserializer.deserialize_struct("stream_plan.LocalApproxPercentileNode", FIELDS, GeneratedVisitor)
7781 }
7782}
7783impl serde::Serialize for LocalityProviderNode {
7784 #[allow(deprecated)]
7785 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7786 where
7787 S: serde::Serializer,
7788 {
7789 use serde::ser::SerializeStruct;
7790 let mut len = 0;
7791 if !self.locality_columns.is_empty() {
7792 len += 1;
7793 }
7794 if self.state_table.is_some() {
7795 len += 1;
7796 }
7797 if self.progress_table.is_some() {
7798 len += 1;
7799 }
7800 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalityProviderNode", len)?;
7801 if !self.locality_columns.is_empty() {
7802 struct_ser.serialize_field("localityColumns", &self.locality_columns)?;
7803 }
7804 if let Some(v) = self.state_table.as_ref() {
7805 struct_ser.serialize_field("stateTable", v)?;
7806 }
7807 if let Some(v) = self.progress_table.as_ref() {
7808 struct_ser.serialize_field("progressTable", v)?;
7809 }
7810 struct_ser.end()
7811 }
7812}
7813impl<'de> serde::Deserialize<'de> for LocalityProviderNode {
7814 #[allow(deprecated)]
7815 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7816 where
7817 D: serde::Deserializer<'de>,
7818 {
7819 const FIELDS: &[&str] = &[
7820 "locality_columns",
7821 "localityColumns",
7822 "state_table",
7823 "stateTable",
7824 "progress_table",
7825 "progressTable",
7826 ];
7827
7828 #[allow(clippy::enum_variant_names)]
7829 enum GeneratedField {
7830 LocalityColumns,
7831 StateTable,
7832 ProgressTable,
7833 }
7834 impl<'de> serde::Deserialize<'de> for GeneratedField {
7835 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7836 where
7837 D: serde::Deserializer<'de>,
7838 {
7839 struct GeneratedVisitor;
7840
7841 impl serde::de::Visitor<'_> for GeneratedVisitor {
7842 type Value = GeneratedField;
7843
7844 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7845 write!(formatter, "expected one of: {:?}", &FIELDS)
7846 }
7847
7848 #[allow(unused_variables)]
7849 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7850 where
7851 E: serde::de::Error,
7852 {
7853 match value {
7854 "localityColumns" | "locality_columns" => Ok(GeneratedField::LocalityColumns),
7855 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7856 "progressTable" | "progress_table" => Ok(GeneratedField::ProgressTable),
7857 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7858 }
7859 }
7860 }
7861 deserializer.deserialize_identifier(GeneratedVisitor)
7862 }
7863 }
7864 struct GeneratedVisitor;
7865 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7866 type Value = LocalityProviderNode;
7867
7868 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7869 formatter.write_str("struct stream_plan.LocalityProviderNode")
7870 }
7871
7872 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalityProviderNode, V::Error>
7873 where
7874 V: serde::de::MapAccess<'de>,
7875 {
7876 let mut locality_columns__ = None;
7877 let mut state_table__ = None;
7878 let mut progress_table__ = None;
7879 while let Some(k) = map_.next_key()? {
7880 match k {
7881 GeneratedField::LocalityColumns => {
7882 if locality_columns__.is_some() {
7883 return Err(serde::de::Error::duplicate_field("localityColumns"));
7884 }
7885 locality_columns__ =
7886 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7887 .into_iter().map(|x| x.0).collect())
7888 ;
7889 }
7890 GeneratedField::StateTable => {
7891 if state_table__.is_some() {
7892 return Err(serde::de::Error::duplicate_field("stateTable"));
7893 }
7894 state_table__ = map_.next_value()?;
7895 }
7896 GeneratedField::ProgressTable => {
7897 if progress_table__.is_some() {
7898 return Err(serde::de::Error::duplicate_field("progressTable"));
7899 }
7900 progress_table__ = map_.next_value()?;
7901 }
7902 }
7903 }
7904 Ok(LocalityProviderNode {
7905 locality_columns: locality_columns__.unwrap_or_default(),
7906 state_table: state_table__,
7907 progress_table: progress_table__,
7908 })
7909 }
7910 }
7911 deserializer.deserialize_struct("stream_plan.LocalityProviderNode", FIELDS, GeneratedVisitor)
7912 }
7913}
7914impl serde::Serialize for LookupNode {
7915 #[allow(deprecated)]
7916 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7917 where
7918 S: serde::Serializer,
7919 {
7920 use serde::ser::SerializeStruct;
7921 let mut len = 0;
7922 if !self.arrange_key.is_empty() {
7923 len += 1;
7924 }
7925 if !self.stream_key.is_empty() {
7926 len += 1;
7927 }
7928 if self.use_current_epoch {
7929 len += 1;
7930 }
7931 if !self.column_mapping.is_empty() {
7932 len += 1;
7933 }
7934 if self.arrangement_table_info.is_some() {
7935 len += 1;
7936 }
7937 if self.arrangement_table_id.is_some() {
7938 len += 1;
7939 }
7940 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupNode", len)?;
7941 if !self.arrange_key.is_empty() {
7942 struct_ser.serialize_field("arrangeKey", &self.arrange_key)?;
7943 }
7944 if !self.stream_key.is_empty() {
7945 struct_ser.serialize_field("streamKey", &self.stream_key)?;
7946 }
7947 if self.use_current_epoch {
7948 struct_ser.serialize_field("useCurrentEpoch", &self.use_current_epoch)?;
7949 }
7950 if !self.column_mapping.is_empty() {
7951 struct_ser.serialize_field("columnMapping", &self.column_mapping)?;
7952 }
7953 if let Some(v) = self.arrangement_table_info.as_ref() {
7954 struct_ser.serialize_field("arrangementTableInfo", v)?;
7955 }
7956 if let Some(v) = self.arrangement_table_id.as_ref() {
7957 match v {
7958 lookup_node::ArrangementTableId::TableId(v) => {
7959 struct_ser.serialize_field("tableId", v)?;
7960 }
7961 lookup_node::ArrangementTableId::IndexId(v) => {
7962 struct_ser.serialize_field("indexId", v)?;
7963 }
7964 }
7965 }
7966 struct_ser.end()
7967 }
7968}
7969impl<'de> serde::Deserialize<'de> for LookupNode {
7970 #[allow(deprecated)]
7971 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7972 where
7973 D: serde::Deserializer<'de>,
7974 {
7975 const FIELDS: &[&str] = &[
7976 "arrange_key",
7977 "arrangeKey",
7978 "stream_key",
7979 "streamKey",
7980 "use_current_epoch",
7981 "useCurrentEpoch",
7982 "column_mapping",
7983 "columnMapping",
7984 "arrangement_table_info",
7985 "arrangementTableInfo",
7986 "table_id",
7987 "tableId",
7988 "index_id",
7989 "indexId",
7990 ];
7991
7992 #[allow(clippy::enum_variant_names)]
7993 enum GeneratedField {
7994 ArrangeKey,
7995 StreamKey,
7996 UseCurrentEpoch,
7997 ColumnMapping,
7998 ArrangementTableInfo,
7999 TableId,
8000 IndexId,
8001 }
8002 impl<'de> serde::Deserialize<'de> for GeneratedField {
8003 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8004 where
8005 D: serde::Deserializer<'de>,
8006 {
8007 struct GeneratedVisitor;
8008
8009 impl serde::de::Visitor<'_> for GeneratedVisitor {
8010 type Value = GeneratedField;
8011
8012 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8013 write!(formatter, "expected one of: {:?}", &FIELDS)
8014 }
8015
8016 #[allow(unused_variables)]
8017 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8018 where
8019 E: serde::de::Error,
8020 {
8021 match value {
8022 "arrangeKey" | "arrange_key" => Ok(GeneratedField::ArrangeKey),
8023 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
8024 "useCurrentEpoch" | "use_current_epoch" => Ok(GeneratedField::UseCurrentEpoch),
8025 "columnMapping" | "column_mapping" => Ok(GeneratedField::ColumnMapping),
8026 "arrangementTableInfo" | "arrangement_table_info" => Ok(GeneratedField::ArrangementTableInfo),
8027 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8028 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
8029 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8030 }
8031 }
8032 }
8033 deserializer.deserialize_identifier(GeneratedVisitor)
8034 }
8035 }
8036 struct GeneratedVisitor;
8037 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8038 type Value = LookupNode;
8039
8040 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8041 formatter.write_str("struct stream_plan.LookupNode")
8042 }
8043
8044 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupNode, V::Error>
8045 where
8046 V: serde::de::MapAccess<'de>,
8047 {
8048 let mut arrange_key__ = None;
8049 let mut stream_key__ = None;
8050 let mut use_current_epoch__ = None;
8051 let mut column_mapping__ = None;
8052 let mut arrangement_table_info__ = None;
8053 let mut arrangement_table_id__ = None;
8054 while let Some(k) = map_.next_key()? {
8055 match k {
8056 GeneratedField::ArrangeKey => {
8057 if arrange_key__.is_some() {
8058 return Err(serde::de::Error::duplicate_field("arrangeKey"));
8059 }
8060 arrange_key__ =
8061 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8062 .into_iter().map(|x| x.0).collect())
8063 ;
8064 }
8065 GeneratedField::StreamKey => {
8066 if stream_key__.is_some() {
8067 return Err(serde::de::Error::duplicate_field("streamKey"));
8068 }
8069 stream_key__ =
8070 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8071 .into_iter().map(|x| x.0).collect())
8072 ;
8073 }
8074 GeneratedField::UseCurrentEpoch => {
8075 if use_current_epoch__.is_some() {
8076 return Err(serde::de::Error::duplicate_field("useCurrentEpoch"));
8077 }
8078 use_current_epoch__ = Some(map_.next_value()?);
8079 }
8080 GeneratedField::ColumnMapping => {
8081 if column_mapping__.is_some() {
8082 return Err(serde::de::Error::duplicate_field("columnMapping"));
8083 }
8084 column_mapping__ =
8085 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8086 .into_iter().map(|x| x.0).collect())
8087 ;
8088 }
8089 GeneratedField::ArrangementTableInfo => {
8090 if arrangement_table_info__.is_some() {
8091 return Err(serde::de::Error::duplicate_field("arrangementTableInfo"));
8092 }
8093 arrangement_table_info__ = map_.next_value()?;
8094 }
8095 GeneratedField::TableId => {
8096 if arrangement_table_id__.is_some() {
8097 return Err(serde::de::Error::duplicate_field("tableId"));
8098 }
8099 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::TableId(x.0));
8100 }
8101 GeneratedField::IndexId => {
8102 if arrangement_table_id__.is_some() {
8103 return Err(serde::de::Error::duplicate_field("indexId"));
8104 }
8105 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::IndexId(x.0));
8106 }
8107 }
8108 }
8109 Ok(LookupNode {
8110 arrange_key: arrange_key__.unwrap_or_default(),
8111 stream_key: stream_key__.unwrap_or_default(),
8112 use_current_epoch: use_current_epoch__.unwrap_or_default(),
8113 column_mapping: column_mapping__.unwrap_or_default(),
8114 arrangement_table_info: arrangement_table_info__,
8115 arrangement_table_id: arrangement_table_id__,
8116 })
8117 }
8118 }
8119 deserializer.deserialize_struct("stream_plan.LookupNode", FIELDS, GeneratedVisitor)
8120 }
8121}
8122impl serde::Serialize for LookupUnionNode {
8123 #[allow(deprecated)]
8124 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8125 where
8126 S: serde::Serializer,
8127 {
8128 use serde::ser::SerializeStruct;
8129 let mut len = 0;
8130 if !self.order.is_empty() {
8131 len += 1;
8132 }
8133 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupUnionNode", len)?;
8134 if !self.order.is_empty() {
8135 struct_ser.serialize_field("order", &self.order)?;
8136 }
8137 struct_ser.end()
8138 }
8139}
8140impl<'de> serde::Deserialize<'de> for LookupUnionNode {
8141 #[allow(deprecated)]
8142 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8143 where
8144 D: serde::Deserializer<'de>,
8145 {
8146 const FIELDS: &[&str] = &[
8147 "order",
8148 ];
8149
8150 #[allow(clippy::enum_variant_names)]
8151 enum GeneratedField {
8152 Order,
8153 }
8154 impl<'de> serde::Deserialize<'de> for GeneratedField {
8155 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8156 where
8157 D: serde::Deserializer<'de>,
8158 {
8159 struct GeneratedVisitor;
8160
8161 impl serde::de::Visitor<'_> for GeneratedVisitor {
8162 type Value = GeneratedField;
8163
8164 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8165 write!(formatter, "expected one of: {:?}", &FIELDS)
8166 }
8167
8168 #[allow(unused_variables)]
8169 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8170 where
8171 E: serde::de::Error,
8172 {
8173 match value {
8174 "order" => Ok(GeneratedField::Order),
8175 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8176 }
8177 }
8178 }
8179 deserializer.deserialize_identifier(GeneratedVisitor)
8180 }
8181 }
8182 struct GeneratedVisitor;
8183 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8184 type Value = LookupUnionNode;
8185
8186 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8187 formatter.write_str("struct stream_plan.LookupUnionNode")
8188 }
8189
8190 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupUnionNode, V::Error>
8191 where
8192 V: serde::de::MapAccess<'de>,
8193 {
8194 let mut order__ = None;
8195 while let Some(k) = map_.next_key()? {
8196 match k {
8197 GeneratedField::Order => {
8198 if order__.is_some() {
8199 return Err(serde::de::Error::duplicate_field("order"));
8200 }
8201 order__ =
8202 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8203 .into_iter().map(|x| x.0).collect())
8204 ;
8205 }
8206 }
8207 }
8208 Ok(LookupUnionNode {
8209 order: order__.unwrap_or_default(),
8210 })
8211 }
8212 }
8213 deserializer.deserialize_struct("stream_plan.LookupUnionNode", FIELDS, GeneratedVisitor)
8214 }
8215}
8216impl serde::Serialize for MaterializeNode {
8217 #[allow(deprecated)]
8218 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8219 where
8220 S: serde::Serializer,
8221 {
8222 use serde::ser::SerializeStruct;
8223 let mut len = 0;
8224 if self.table_id != 0 {
8225 len += 1;
8226 }
8227 if !self.column_orders.is_empty() {
8228 len += 1;
8229 }
8230 if self.table.is_some() {
8231 len += 1;
8232 }
8233 if self.staging_table.is_some() {
8234 len += 1;
8235 }
8236 if self.refresh_progress_table.is_some() {
8237 len += 1;
8238 }
8239 if self.cleaned_by_ttl_watermark {
8240 len += 1;
8241 }
8242 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializeNode", len)?;
8243 if self.table_id != 0 {
8244 struct_ser.serialize_field("tableId", &self.table_id)?;
8245 }
8246 if !self.column_orders.is_empty() {
8247 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
8248 }
8249 if let Some(v) = self.table.as_ref() {
8250 struct_ser.serialize_field("table", v)?;
8251 }
8252 if let Some(v) = self.staging_table.as_ref() {
8253 struct_ser.serialize_field("stagingTable", v)?;
8254 }
8255 if let Some(v) = self.refresh_progress_table.as_ref() {
8256 struct_ser.serialize_field("refreshProgressTable", v)?;
8257 }
8258 if self.cleaned_by_ttl_watermark {
8259 struct_ser.serialize_field("cleanedByTtlWatermark", &self.cleaned_by_ttl_watermark)?;
8260 }
8261 struct_ser.end()
8262 }
8263}
8264impl<'de> serde::Deserialize<'de> for MaterializeNode {
8265 #[allow(deprecated)]
8266 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8267 where
8268 D: serde::Deserializer<'de>,
8269 {
8270 const FIELDS: &[&str] = &[
8271 "table_id",
8272 "tableId",
8273 "column_orders",
8274 "columnOrders",
8275 "table",
8276 "staging_table",
8277 "stagingTable",
8278 "refresh_progress_table",
8279 "refreshProgressTable",
8280 "cleaned_by_ttl_watermark",
8281 "cleanedByTtlWatermark",
8282 ];
8283
8284 #[allow(clippy::enum_variant_names)]
8285 enum GeneratedField {
8286 TableId,
8287 ColumnOrders,
8288 Table,
8289 StagingTable,
8290 RefreshProgressTable,
8291 CleanedByTtlWatermark,
8292 }
8293 impl<'de> serde::Deserialize<'de> for GeneratedField {
8294 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8295 where
8296 D: serde::Deserializer<'de>,
8297 {
8298 struct GeneratedVisitor;
8299
8300 impl serde::de::Visitor<'_> for GeneratedVisitor {
8301 type Value = GeneratedField;
8302
8303 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8304 write!(formatter, "expected one of: {:?}", &FIELDS)
8305 }
8306
8307 #[allow(unused_variables)]
8308 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8309 where
8310 E: serde::de::Error,
8311 {
8312 match value {
8313 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8314 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
8315 "table" => Ok(GeneratedField::Table),
8316 "stagingTable" | "staging_table" => Ok(GeneratedField::StagingTable),
8317 "refreshProgressTable" | "refresh_progress_table" => Ok(GeneratedField::RefreshProgressTable),
8318 "cleanedByTtlWatermark" | "cleaned_by_ttl_watermark" => Ok(GeneratedField::CleanedByTtlWatermark),
8319 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8320 }
8321 }
8322 }
8323 deserializer.deserialize_identifier(GeneratedVisitor)
8324 }
8325 }
8326 struct GeneratedVisitor;
8327 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8328 type Value = MaterializeNode;
8329
8330 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8331 formatter.write_str("struct stream_plan.MaterializeNode")
8332 }
8333
8334 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializeNode, V::Error>
8335 where
8336 V: serde::de::MapAccess<'de>,
8337 {
8338 let mut table_id__ = None;
8339 let mut column_orders__ = None;
8340 let mut table__ = None;
8341 let mut staging_table__ = None;
8342 let mut refresh_progress_table__ = None;
8343 let mut cleaned_by_ttl_watermark__ = None;
8344 while let Some(k) = map_.next_key()? {
8345 match k {
8346 GeneratedField::TableId => {
8347 if table_id__.is_some() {
8348 return Err(serde::de::Error::duplicate_field("tableId"));
8349 }
8350 table_id__ =
8351 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8352 ;
8353 }
8354 GeneratedField::ColumnOrders => {
8355 if column_orders__.is_some() {
8356 return Err(serde::de::Error::duplicate_field("columnOrders"));
8357 }
8358 column_orders__ = Some(map_.next_value()?);
8359 }
8360 GeneratedField::Table => {
8361 if table__.is_some() {
8362 return Err(serde::de::Error::duplicate_field("table"));
8363 }
8364 table__ = map_.next_value()?;
8365 }
8366 GeneratedField::StagingTable => {
8367 if staging_table__.is_some() {
8368 return Err(serde::de::Error::duplicate_field("stagingTable"));
8369 }
8370 staging_table__ = map_.next_value()?;
8371 }
8372 GeneratedField::RefreshProgressTable => {
8373 if refresh_progress_table__.is_some() {
8374 return Err(serde::de::Error::duplicate_field("refreshProgressTable"));
8375 }
8376 refresh_progress_table__ = map_.next_value()?;
8377 }
8378 GeneratedField::CleanedByTtlWatermark => {
8379 if cleaned_by_ttl_watermark__.is_some() {
8380 return Err(serde::de::Error::duplicate_field("cleanedByTtlWatermark"));
8381 }
8382 cleaned_by_ttl_watermark__ = Some(map_.next_value()?);
8383 }
8384 }
8385 }
8386 Ok(MaterializeNode {
8387 table_id: table_id__.unwrap_or_default(),
8388 column_orders: column_orders__.unwrap_or_default(),
8389 table: table__,
8390 staging_table: staging_table__,
8391 refresh_progress_table: refresh_progress_table__,
8392 cleaned_by_ttl_watermark: cleaned_by_ttl_watermark__.unwrap_or_default(),
8393 })
8394 }
8395 }
8396 deserializer.deserialize_struct("stream_plan.MaterializeNode", FIELDS, GeneratedVisitor)
8397 }
8398}
8399impl serde::Serialize for MaterializedExprsNode {
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.exprs.is_empty() {
8408 len += 1;
8409 }
8410 if self.state_table.is_some() {
8411 len += 1;
8412 }
8413 if self.state_clean_col_idx.is_some() {
8414 len += 1;
8415 }
8416 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializedExprsNode", len)?;
8417 if !self.exprs.is_empty() {
8418 struct_ser.serialize_field("exprs", &self.exprs)?;
8419 }
8420 if let Some(v) = self.state_table.as_ref() {
8421 struct_ser.serialize_field("stateTable", v)?;
8422 }
8423 if let Some(v) = self.state_clean_col_idx.as_ref() {
8424 struct_ser.serialize_field("stateCleanColIdx", v)?;
8425 }
8426 struct_ser.end()
8427 }
8428}
8429impl<'de> serde::Deserialize<'de> for MaterializedExprsNode {
8430 #[allow(deprecated)]
8431 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8432 where
8433 D: serde::Deserializer<'de>,
8434 {
8435 const FIELDS: &[&str] = &[
8436 "exprs",
8437 "state_table",
8438 "stateTable",
8439 "state_clean_col_idx",
8440 "stateCleanColIdx",
8441 ];
8442
8443 #[allow(clippy::enum_variant_names)]
8444 enum GeneratedField {
8445 Exprs,
8446 StateTable,
8447 StateCleanColIdx,
8448 }
8449 impl<'de> serde::Deserialize<'de> for GeneratedField {
8450 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8451 where
8452 D: serde::Deserializer<'de>,
8453 {
8454 struct GeneratedVisitor;
8455
8456 impl serde::de::Visitor<'_> for GeneratedVisitor {
8457 type Value = GeneratedField;
8458
8459 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8460 write!(formatter, "expected one of: {:?}", &FIELDS)
8461 }
8462
8463 #[allow(unused_variables)]
8464 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8465 where
8466 E: serde::de::Error,
8467 {
8468 match value {
8469 "exprs" => Ok(GeneratedField::Exprs),
8470 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
8471 "stateCleanColIdx" | "state_clean_col_idx" => Ok(GeneratedField::StateCleanColIdx),
8472 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8473 }
8474 }
8475 }
8476 deserializer.deserialize_identifier(GeneratedVisitor)
8477 }
8478 }
8479 struct GeneratedVisitor;
8480 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8481 type Value = MaterializedExprsNode;
8482
8483 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8484 formatter.write_str("struct stream_plan.MaterializedExprsNode")
8485 }
8486
8487 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializedExprsNode, V::Error>
8488 where
8489 V: serde::de::MapAccess<'de>,
8490 {
8491 let mut exprs__ = None;
8492 let mut state_table__ = None;
8493 let mut state_clean_col_idx__ = None;
8494 while let Some(k) = map_.next_key()? {
8495 match k {
8496 GeneratedField::Exprs => {
8497 if exprs__.is_some() {
8498 return Err(serde::de::Error::duplicate_field("exprs"));
8499 }
8500 exprs__ = Some(map_.next_value()?);
8501 }
8502 GeneratedField::StateTable => {
8503 if state_table__.is_some() {
8504 return Err(serde::de::Error::duplicate_field("stateTable"));
8505 }
8506 state_table__ = map_.next_value()?;
8507 }
8508 GeneratedField::StateCleanColIdx => {
8509 if state_clean_col_idx__.is_some() {
8510 return Err(serde::de::Error::duplicate_field("stateCleanColIdx"));
8511 }
8512 state_clean_col_idx__ =
8513 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
8514 ;
8515 }
8516 }
8517 }
8518 Ok(MaterializedExprsNode {
8519 exprs: exprs__.unwrap_or_default(),
8520 state_table: state_table__,
8521 state_clean_col_idx: state_clean_col_idx__,
8522 })
8523 }
8524 }
8525 deserializer.deserialize_struct("stream_plan.MaterializedExprsNode", FIELDS, GeneratedVisitor)
8526 }
8527}
8528impl serde::Serialize for MergeNode {
8529 #[allow(deprecated)]
8530 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8531 where
8532 S: serde::Serializer,
8533 {
8534 use serde::ser::SerializeStruct;
8535 let mut len = 0;
8536 if !self.upstream_actor_id.is_empty() {
8537 len += 1;
8538 }
8539 if self.upstream_fragment_id != 0 {
8540 len += 1;
8541 }
8542 if self.upstream_dispatcher_type != 0 {
8543 len += 1;
8544 }
8545 if !self.fields.is_empty() {
8546 len += 1;
8547 }
8548 let mut struct_ser = serializer.serialize_struct("stream_plan.MergeNode", len)?;
8549 if !self.upstream_actor_id.is_empty() {
8550 struct_ser.serialize_field("upstreamActorId", &self.upstream_actor_id)?;
8551 }
8552 if self.upstream_fragment_id != 0 {
8553 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
8554 }
8555 if self.upstream_dispatcher_type != 0 {
8556 let v = DispatcherType::try_from(self.upstream_dispatcher_type)
8557 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.upstream_dispatcher_type)))?;
8558 struct_ser.serialize_field("upstreamDispatcherType", &v)?;
8559 }
8560 if !self.fields.is_empty() {
8561 struct_ser.serialize_field("fields", &self.fields)?;
8562 }
8563 struct_ser.end()
8564 }
8565}
8566impl<'de> serde::Deserialize<'de> for MergeNode {
8567 #[allow(deprecated)]
8568 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8569 where
8570 D: serde::Deserializer<'de>,
8571 {
8572 const FIELDS: &[&str] = &[
8573 "upstream_actor_id",
8574 "upstreamActorId",
8575 "upstream_fragment_id",
8576 "upstreamFragmentId",
8577 "upstream_dispatcher_type",
8578 "upstreamDispatcherType",
8579 "fields",
8580 ];
8581
8582 #[allow(clippy::enum_variant_names)]
8583 enum GeneratedField {
8584 UpstreamActorId,
8585 UpstreamFragmentId,
8586 UpstreamDispatcherType,
8587 Fields,
8588 }
8589 impl<'de> serde::Deserialize<'de> for GeneratedField {
8590 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8591 where
8592 D: serde::Deserializer<'de>,
8593 {
8594 struct GeneratedVisitor;
8595
8596 impl serde::de::Visitor<'_> for GeneratedVisitor {
8597 type Value = GeneratedField;
8598
8599 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8600 write!(formatter, "expected one of: {:?}", &FIELDS)
8601 }
8602
8603 #[allow(unused_variables)]
8604 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8605 where
8606 E: serde::de::Error,
8607 {
8608 match value {
8609 "upstreamActorId" | "upstream_actor_id" => Ok(GeneratedField::UpstreamActorId),
8610 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
8611 "upstreamDispatcherType" | "upstream_dispatcher_type" => Ok(GeneratedField::UpstreamDispatcherType),
8612 "fields" => Ok(GeneratedField::Fields),
8613 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8614 }
8615 }
8616 }
8617 deserializer.deserialize_identifier(GeneratedVisitor)
8618 }
8619 }
8620 struct GeneratedVisitor;
8621 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8622 type Value = MergeNode;
8623
8624 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8625 formatter.write_str("struct stream_plan.MergeNode")
8626 }
8627
8628 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeNode, V::Error>
8629 where
8630 V: serde::de::MapAccess<'de>,
8631 {
8632 let mut upstream_actor_id__ = None;
8633 let mut upstream_fragment_id__ = None;
8634 let mut upstream_dispatcher_type__ = None;
8635 let mut fields__ = None;
8636 while let Some(k) = map_.next_key()? {
8637 match k {
8638 GeneratedField::UpstreamActorId => {
8639 if upstream_actor_id__.is_some() {
8640 return Err(serde::de::Error::duplicate_field("upstreamActorId"));
8641 }
8642 upstream_actor_id__ =
8643 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8644 .into_iter().map(|x| x.0).collect())
8645 ;
8646 }
8647 GeneratedField::UpstreamFragmentId => {
8648 if upstream_fragment_id__.is_some() {
8649 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
8650 }
8651 upstream_fragment_id__ =
8652 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8653 ;
8654 }
8655 GeneratedField::UpstreamDispatcherType => {
8656 if upstream_dispatcher_type__.is_some() {
8657 return Err(serde::de::Error::duplicate_field("upstreamDispatcherType"));
8658 }
8659 upstream_dispatcher_type__ = Some(map_.next_value::<DispatcherType>()? as i32);
8660 }
8661 GeneratedField::Fields => {
8662 if fields__.is_some() {
8663 return Err(serde::de::Error::duplicate_field("fields"));
8664 }
8665 fields__ = Some(map_.next_value()?);
8666 }
8667 }
8668 }
8669 Ok(MergeNode {
8670 upstream_actor_id: upstream_actor_id__.unwrap_or_default(),
8671 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
8672 upstream_dispatcher_type: upstream_dispatcher_type__.unwrap_or_default(),
8673 fields: fields__.unwrap_or_default(),
8674 })
8675 }
8676 }
8677 deserializer.deserialize_struct("stream_plan.MergeNode", FIELDS, GeneratedVisitor)
8678 }
8679}
8680impl serde::Serialize for NoOpNode {
8681 #[allow(deprecated)]
8682 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8683 where
8684 S: serde::Serializer,
8685 {
8686 use serde::ser::SerializeStruct;
8687 let len = 0;
8688 let struct_ser = serializer.serialize_struct("stream_plan.NoOpNode", len)?;
8689 struct_ser.end()
8690 }
8691}
8692impl<'de> serde::Deserialize<'de> for NoOpNode {
8693 #[allow(deprecated)]
8694 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8695 where
8696 D: serde::Deserializer<'de>,
8697 {
8698 const FIELDS: &[&str] = &[
8699 ];
8700
8701 #[allow(clippy::enum_variant_names)]
8702 enum GeneratedField {
8703 }
8704 impl<'de> serde::Deserialize<'de> for GeneratedField {
8705 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8706 where
8707 D: serde::Deserializer<'de>,
8708 {
8709 struct GeneratedVisitor;
8710
8711 impl serde::de::Visitor<'_> for GeneratedVisitor {
8712 type Value = GeneratedField;
8713
8714 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8715 write!(formatter, "expected one of: {:?}", &FIELDS)
8716 }
8717
8718 #[allow(unused_variables)]
8719 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8720 where
8721 E: serde::de::Error,
8722 {
8723 Err(serde::de::Error::unknown_field(value, FIELDS))
8724 }
8725 }
8726 deserializer.deserialize_identifier(GeneratedVisitor)
8727 }
8728 }
8729 struct GeneratedVisitor;
8730 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8731 type Value = NoOpNode;
8732
8733 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8734 formatter.write_str("struct stream_plan.NoOpNode")
8735 }
8736
8737 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NoOpNode, V::Error>
8738 where
8739 V: serde::de::MapAccess<'de>,
8740 {
8741 while map_.next_key::<GeneratedField>()?.is_some() {
8742 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8743 }
8744 Ok(NoOpNode {
8745 })
8746 }
8747 }
8748 deserializer.deserialize_struct("stream_plan.NoOpNode", FIELDS, GeneratedVisitor)
8749 }
8750}
8751impl serde::Serialize for NowModeGenerateSeries {
8752 #[allow(deprecated)]
8753 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8754 where
8755 S: serde::Serializer,
8756 {
8757 use serde::ser::SerializeStruct;
8758 let mut len = 0;
8759 if self.start_timestamp.is_some() {
8760 len += 1;
8761 }
8762 if self.interval.is_some() {
8763 len += 1;
8764 }
8765 let mut struct_ser = serializer.serialize_struct("stream_plan.NowModeGenerateSeries", len)?;
8766 if let Some(v) = self.start_timestamp.as_ref() {
8767 struct_ser.serialize_field("startTimestamp", v)?;
8768 }
8769 if let Some(v) = self.interval.as_ref() {
8770 struct_ser.serialize_field("interval", v)?;
8771 }
8772 struct_ser.end()
8773 }
8774}
8775impl<'de> serde::Deserialize<'de> for NowModeGenerateSeries {
8776 #[allow(deprecated)]
8777 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8778 where
8779 D: serde::Deserializer<'de>,
8780 {
8781 const FIELDS: &[&str] = &[
8782 "start_timestamp",
8783 "startTimestamp",
8784 "interval",
8785 ];
8786
8787 #[allow(clippy::enum_variant_names)]
8788 enum GeneratedField {
8789 StartTimestamp,
8790 Interval,
8791 }
8792 impl<'de> serde::Deserialize<'de> for GeneratedField {
8793 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8794 where
8795 D: serde::Deserializer<'de>,
8796 {
8797 struct GeneratedVisitor;
8798
8799 impl serde::de::Visitor<'_> for GeneratedVisitor {
8800 type Value = GeneratedField;
8801
8802 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8803 write!(formatter, "expected one of: {:?}", &FIELDS)
8804 }
8805
8806 #[allow(unused_variables)]
8807 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8808 where
8809 E: serde::de::Error,
8810 {
8811 match value {
8812 "startTimestamp" | "start_timestamp" => Ok(GeneratedField::StartTimestamp),
8813 "interval" => Ok(GeneratedField::Interval),
8814 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8815 }
8816 }
8817 }
8818 deserializer.deserialize_identifier(GeneratedVisitor)
8819 }
8820 }
8821 struct GeneratedVisitor;
8822 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8823 type Value = NowModeGenerateSeries;
8824
8825 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8826 formatter.write_str("struct stream_plan.NowModeGenerateSeries")
8827 }
8828
8829 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeGenerateSeries, V::Error>
8830 where
8831 V: serde::de::MapAccess<'de>,
8832 {
8833 let mut start_timestamp__ = None;
8834 let mut interval__ = None;
8835 while let Some(k) = map_.next_key()? {
8836 match k {
8837 GeneratedField::StartTimestamp => {
8838 if start_timestamp__.is_some() {
8839 return Err(serde::de::Error::duplicate_field("startTimestamp"));
8840 }
8841 start_timestamp__ = map_.next_value()?;
8842 }
8843 GeneratedField::Interval => {
8844 if interval__.is_some() {
8845 return Err(serde::de::Error::duplicate_field("interval"));
8846 }
8847 interval__ = map_.next_value()?;
8848 }
8849 }
8850 }
8851 Ok(NowModeGenerateSeries {
8852 start_timestamp: start_timestamp__,
8853 interval: interval__,
8854 })
8855 }
8856 }
8857 deserializer.deserialize_struct("stream_plan.NowModeGenerateSeries", FIELDS, GeneratedVisitor)
8858 }
8859}
8860impl serde::Serialize for NowModeUpdateCurrent {
8861 #[allow(deprecated)]
8862 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8863 where
8864 S: serde::Serializer,
8865 {
8866 use serde::ser::SerializeStruct;
8867 let len = 0;
8868 let struct_ser = serializer.serialize_struct("stream_plan.NowModeUpdateCurrent", len)?;
8869 struct_ser.end()
8870 }
8871}
8872impl<'de> serde::Deserialize<'de> for NowModeUpdateCurrent {
8873 #[allow(deprecated)]
8874 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8875 where
8876 D: serde::Deserializer<'de>,
8877 {
8878 const FIELDS: &[&str] = &[
8879 ];
8880
8881 #[allow(clippy::enum_variant_names)]
8882 enum GeneratedField {
8883 }
8884 impl<'de> serde::Deserialize<'de> for GeneratedField {
8885 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8886 where
8887 D: serde::Deserializer<'de>,
8888 {
8889 struct GeneratedVisitor;
8890
8891 impl serde::de::Visitor<'_> for GeneratedVisitor {
8892 type Value = GeneratedField;
8893
8894 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8895 write!(formatter, "expected one of: {:?}", &FIELDS)
8896 }
8897
8898 #[allow(unused_variables)]
8899 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8900 where
8901 E: serde::de::Error,
8902 {
8903 Err(serde::de::Error::unknown_field(value, FIELDS))
8904 }
8905 }
8906 deserializer.deserialize_identifier(GeneratedVisitor)
8907 }
8908 }
8909 struct GeneratedVisitor;
8910 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8911 type Value = NowModeUpdateCurrent;
8912
8913 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8914 formatter.write_str("struct stream_plan.NowModeUpdateCurrent")
8915 }
8916
8917 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeUpdateCurrent, V::Error>
8918 where
8919 V: serde::de::MapAccess<'de>,
8920 {
8921 while map_.next_key::<GeneratedField>()?.is_some() {
8922 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8923 }
8924 Ok(NowModeUpdateCurrent {
8925 })
8926 }
8927 }
8928 deserializer.deserialize_struct("stream_plan.NowModeUpdateCurrent", FIELDS, GeneratedVisitor)
8929 }
8930}
8931impl serde::Serialize for NowNode {
8932 #[allow(deprecated)]
8933 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8934 where
8935 S: serde::Serializer,
8936 {
8937 use serde::ser::SerializeStruct;
8938 let mut len = 0;
8939 if self.state_table.is_some() {
8940 len += 1;
8941 }
8942 if self.mode.is_some() {
8943 len += 1;
8944 }
8945 let mut struct_ser = serializer.serialize_struct("stream_plan.NowNode", len)?;
8946 if let Some(v) = self.state_table.as_ref() {
8947 struct_ser.serialize_field("stateTable", v)?;
8948 }
8949 if let Some(v) = self.mode.as_ref() {
8950 match v {
8951 now_node::Mode::UpdateCurrent(v) => {
8952 struct_ser.serialize_field("updateCurrent", v)?;
8953 }
8954 now_node::Mode::GenerateSeries(v) => {
8955 struct_ser.serialize_field("generateSeries", v)?;
8956 }
8957 }
8958 }
8959 struct_ser.end()
8960 }
8961}
8962impl<'de> serde::Deserialize<'de> for NowNode {
8963 #[allow(deprecated)]
8964 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8965 where
8966 D: serde::Deserializer<'de>,
8967 {
8968 const FIELDS: &[&str] = &[
8969 "state_table",
8970 "stateTable",
8971 "update_current",
8972 "updateCurrent",
8973 "generate_series",
8974 "generateSeries",
8975 ];
8976
8977 #[allow(clippy::enum_variant_names)]
8978 enum GeneratedField {
8979 StateTable,
8980 UpdateCurrent,
8981 GenerateSeries,
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 serde::de::Visitor<'_> 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 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9004 "updateCurrent" | "update_current" => Ok(GeneratedField::UpdateCurrent),
9005 "generateSeries" | "generate_series" => Ok(GeneratedField::GenerateSeries),
9006 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9007 }
9008 }
9009 }
9010 deserializer.deserialize_identifier(GeneratedVisitor)
9011 }
9012 }
9013 struct GeneratedVisitor;
9014 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9015 type Value = NowNode;
9016
9017 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9018 formatter.write_str("struct stream_plan.NowNode")
9019 }
9020
9021 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowNode, V::Error>
9022 where
9023 V: serde::de::MapAccess<'de>,
9024 {
9025 let mut state_table__ = None;
9026 let mut mode__ = None;
9027 while let Some(k) = map_.next_key()? {
9028 match k {
9029 GeneratedField::StateTable => {
9030 if state_table__.is_some() {
9031 return Err(serde::de::Error::duplicate_field("stateTable"));
9032 }
9033 state_table__ = map_.next_value()?;
9034 }
9035 GeneratedField::UpdateCurrent => {
9036 if mode__.is_some() {
9037 return Err(serde::de::Error::duplicate_field("updateCurrent"));
9038 }
9039 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::UpdateCurrent)
9040;
9041 }
9042 GeneratedField::GenerateSeries => {
9043 if mode__.is_some() {
9044 return Err(serde::de::Error::duplicate_field("generateSeries"));
9045 }
9046 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::GenerateSeries)
9047;
9048 }
9049 }
9050 }
9051 Ok(NowNode {
9052 state_table: state_table__,
9053 mode: mode__,
9054 })
9055 }
9056 }
9057 deserializer.deserialize_struct("stream_plan.NowNode", FIELDS, GeneratedVisitor)
9058 }
9059}
9060impl serde::Serialize for OverWindowCachePolicy {
9061 #[allow(deprecated)]
9062 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9063 where
9064 S: serde::Serializer,
9065 {
9066 let variant = match self {
9067 Self::Unspecified => "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
9068 Self::Full => "OVER_WINDOW_CACHE_POLICY_FULL",
9069 Self::Recent => "OVER_WINDOW_CACHE_POLICY_RECENT",
9070 Self::RecentFirstN => "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
9071 Self::RecentLastN => "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
9072 };
9073 serializer.serialize_str(variant)
9074 }
9075}
9076impl<'de> serde::Deserialize<'de> for OverWindowCachePolicy {
9077 #[allow(deprecated)]
9078 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9079 where
9080 D: serde::Deserializer<'de>,
9081 {
9082 const FIELDS: &[&str] = &[
9083 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
9084 "OVER_WINDOW_CACHE_POLICY_FULL",
9085 "OVER_WINDOW_CACHE_POLICY_RECENT",
9086 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
9087 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
9088 ];
9089
9090 struct GeneratedVisitor;
9091
9092 impl serde::de::Visitor<'_> for GeneratedVisitor {
9093 type Value = OverWindowCachePolicy;
9094
9095 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9096 write!(formatter, "expected one of: {:?}", &FIELDS)
9097 }
9098
9099 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9100 where
9101 E: serde::de::Error,
9102 {
9103 i32::try_from(v)
9104 .ok()
9105 .and_then(|x| x.try_into().ok())
9106 .ok_or_else(|| {
9107 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9108 })
9109 }
9110
9111 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9112 where
9113 E: serde::de::Error,
9114 {
9115 i32::try_from(v)
9116 .ok()
9117 .and_then(|x| x.try_into().ok())
9118 .ok_or_else(|| {
9119 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9120 })
9121 }
9122
9123 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9124 where
9125 E: serde::de::Error,
9126 {
9127 match value {
9128 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED" => Ok(OverWindowCachePolicy::Unspecified),
9129 "OVER_WINDOW_CACHE_POLICY_FULL" => Ok(OverWindowCachePolicy::Full),
9130 "OVER_WINDOW_CACHE_POLICY_RECENT" => Ok(OverWindowCachePolicy::Recent),
9131 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N" => Ok(OverWindowCachePolicy::RecentFirstN),
9132 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N" => Ok(OverWindowCachePolicy::RecentLastN),
9133 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9134 }
9135 }
9136 }
9137 deserializer.deserialize_any(GeneratedVisitor)
9138 }
9139}
9140impl serde::Serialize for OverWindowNode {
9141 #[allow(deprecated)]
9142 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9143 where
9144 S: serde::Serializer,
9145 {
9146 use serde::ser::SerializeStruct;
9147 let mut len = 0;
9148 if !self.calls.is_empty() {
9149 len += 1;
9150 }
9151 if !self.partition_by.is_empty() {
9152 len += 1;
9153 }
9154 if !self.order_by.is_empty() {
9155 len += 1;
9156 }
9157 if self.state_table.is_some() {
9158 len += 1;
9159 }
9160 if self.cache_policy != 0 {
9161 len += 1;
9162 }
9163 let mut struct_ser = serializer.serialize_struct("stream_plan.OverWindowNode", len)?;
9164 if !self.calls.is_empty() {
9165 struct_ser.serialize_field("calls", &self.calls)?;
9166 }
9167 if !self.partition_by.is_empty() {
9168 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
9169 }
9170 if !self.order_by.is_empty() {
9171 struct_ser.serialize_field("orderBy", &self.order_by)?;
9172 }
9173 if let Some(v) = self.state_table.as_ref() {
9174 struct_ser.serialize_field("stateTable", v)?;
9175 }
9176 if self.cache_policy != 0 {
9177 let v = OverWindowCachePolicy::try_from(self.cache_policy)
9178 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cache_policy)))?;
9179 struct_ser.serialize_field("cachePolicy", &v)?;
9180 }
9181 struct_ser.end()
9182 }
9183}
9184impl<'de> serde::Deserialize<'de> for OverWindowNode {
9185 #[allow(deprecated)]
9186 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9187 where
9188 D: serde::Deserializer<'de>,
9189 {
9190 const FIELDS: &[&str] = &[
9191 "calls",
9192 "partition_by",
9193 "partitionBy",
9194 "order_by",
9195 "orderBy",
9196 "state_table",
9197 "stateTable",
9198 "cache_policy",
9199 "cachePolicy",
9200 ];
9201
9202 #[allow(clippy::enum_variant_names)]
9203 enum GeneratedField {
9204 Calls,
9205 PartitionBy,
9206 OrderBy,
9207 StateTable,
9208 CachePolicy,
9209 }
9210 impl<'de> serde::Deserialize<'de> for GeneratedField {
9211 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9212 where
9213 D: serde::Deserializer<'de>,
9214 {
9215 struct GeneratedVisitor;
9216
9217 impl serde::de::Visitor<'_> for GeneratedVisitor {
9218 type Value = GeneratedField;
9219
9220 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9221 write!(formatter, "expected one of: {:?}", &FIELDS)
9222 }
9223
9224 #[allow(unused_variables)]
9225 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9226 where
9227 E: serde::de::Error,
9228 {
9229 match value {
9230 "calls" => Ok(GeneratedField::Calls),
9231 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
9232 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
9233 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9234 "cachePolicy" | "cache_policy" => Ok(GeneratedField::CachePolicy),
9235 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9236 }
9237 }
9238 }
9239 deserializer.deserialize_identifier(GeneratedVisitor)
9240 }
9241 }
9242 struct GeneratedVisitor;
9243 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9244 type Value = OverWindowNode;
9245
9246 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9247 formatter.write_str("struct stream_plan.OverWindowNode")
9248 }
9249
9250 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverWindowNode, V::Error>
9251 where
9252 V: serde::de::MapAccess<'de>,
9253 {
9254 let mut calls__ = None;
9255 let mut partition_by__ = None;
9256 let mut order_by__ = None;
9257 let mut state_table__ = None;
9258 let mut cache_policy__ = None;
9259 while let Some(k) = map_.next_key()? {
9260 match k {
9261 GeneratedField::Calls => {
9262 if calls__.is_some() {
9263 return Err(serde::de::Error::duplicate_field("calls"));
9264 }
9265 calls__ = Some(map_.next_value()?);
9266 }
9267 GeneratedField::PartitionBy => {
9268 if partition_by__.is_some() {
9269 return Err(serde::de::Error::duplicate_field("partitionBy"));
9270 }
9271 partition_by__ =
9272 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9273 .into_iter().map(|x| x.0).collect())
9274 ;
9275 }
9276 GeneratedField::OrderBy => {
9277 if order_by__.is_some() {
9278 return Err(serde::de::Error::duplicate_field("orderBy"));
9279 }
9280 order_by__ = Some(map_.next_value()?);
9281 }
9282 GeneratedField::StateTable => {
9283 if state_table__.is_some() {
9284 return Err(serde::de::Error::duplicate_field("stateTable"));
9285 }
9286 state_table__ = map_.next_value()?;
9287 }
9288 GeneratedField::CachePolicy => {
9289 if cache_policy__.is_some() {
9290 return Err(serde::de::Error::duplicate_field("cachePolicy"));
9291 }
9292 cache_policy__ = Some(map_.next_value::<OverWindowCachePolicy>()? as i32);
9293 }
9294 }
9295 }
9296 Ok(OverWindowNode {
9297 calls: calls__.unwrap_or_default(),
9298 partition_by: partition_by__.unwrap_or_default(),
9299 order_by: order_by__.unwrap_or_default(),
9300 state_table: state_table__,
9301 cache_policy: cache_policy__.unwrap_or_default(),
9302 })
9303 }
9304 }
9305 deserializer.deserialize_struct("stream_plan.OverWindowNode", FIELDS, GeneratedVisitor)
9306 }
9307}
9308impl serde::Serialize for PauseMutation {
9309 #[allow(deprecated)]
9310 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9311 where
9312 S: serde::Serializer,
9313 {
9314 use serde::ser::SerializeStruct;
9315 let len = 0;
9316 let struct_ser = serializer.serialize_struct("stream_plan.PauseMutation", len)?;
9317 struct_ser.end()
9318 }
9319}
9320impl<'de> serde::Deserialize<'de> for PauseMutation {
9321 #[allow(deprecated)]
9322 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9323 where
9324 D: serde::Deserializer<'de>,
9325 {
9326 const FIELDS: &[&str] = &[
9327 ];
9328
9329 #[allow(clippy::enum_variant_names)]
9330 enum GeneratedField {
9331 }
9332 impl<'de> serde::Deserialize<'de> for GeneratedField {
9333 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9334 where
9335 D: serde::Deserializer<'de>,
9336 {
9337 struct GeneratedVisitor;
9338
9339 impl serde::de::Visitor<'_> for GeneratedVisitor {
9340 type Value = GeneratedField;
9341
9342 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9343 write!(formatter, "expected one of: {:?}", &FIELDS)
9344 }
9345
9346 #[allow(unused_variables)]
9347 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9348 where
9349 E: serde::de::Error,
9350 {
9351 Err(serde::de::Error::unknown_field(value, FIELDS))
9352 }
9353 }
9354 deserializer.deserialize_identifier(GeneratedVisitor)
9355 }
9356 }
9357 struct GeneratedVisitor;
9358 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9359 type Value = PauseMutation;
9360
9361 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9362 formatter.write_str("struct stream_plan.PauseMutation")
9363 }
9364
9365 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseMutation, V::Error>
9366 where
9367 V: serde::de::MapAccess<'de>,
9368 {
9369 while map_.next_key::<GeneratedField>()?.is_some() {
9370 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9371 }
9372 Ok(PauseMutation {
9373 })
9374 }
9375 }
9376 deserializer.deserialize_struct("stream_plan.PauseMutation", FIELDS, GeneratedVisitor)
9377 }
9378}
9379impl serde::Serialize for ProjectNode {
9380 #[allow(deprecated)]
9381 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9382 where
9383 S: serde::Serializer,
9384 {
9385 use serde::ser::SerializeStruct;
9386 let mut len = 0;
9387 if !self.select_list.is_empty() {
9388 len += 1;
9389 }
9390 if !self.watermark_input_cols.is_empty() {
9391 len += 1;
9392 }
9393 if !self.watermark_output_cols.is_empty() {
9394 len += 1;
9395 }
9396 if !self.nondecreasing_exprs.is_empty() {
9397 len += 1;
9398 }
9399 if self.noop_update_hint {
9400 len += 1;
9401 }
9402 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectNode", len)?;
9403 if !self.select_list.is_empty() {
9404 struct_ser.serialize_field("selectList", &self.select_list)?;
9405 }
9406 if !self.watermark_input_cols.is_empty() {
9407 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
9408 }
9409 if !self.watermark_output_cols.is_empty() {
9410 struct_ser.serialize_field("watermarkOutputCols", &self.watermark_output_cols)?;
9411 }
9412 if !self.nondecreasing_exprs.is_empty() {
9413 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
9414 }
9415 if self.noop_update_hint {
9416 struct_ser.serialize_field("noopUpdateHint", &self.noop_update_hint)?;
9417 }
9418 struct_ser.end()
9419 }
9420}
9421impl<'de> serde::Deserialize<'de> for ProjectNode {
9422 #[allow(deprecated)]
9423 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9424 where
9425 D: serde::Deserializer<'de>,
9426 {
9427 const FIELDS: &[&str] = &[
9428 "select_list",
9429 "selectList",
9430 "watermark_input_cols",
9431 "watermarkInputCols",
9432 "watermark_output_cols",
9433 "watermarkOutputCols",
9434 "nondecreasing_exprs",
9435 "nondecreasingExprs",
9436 "noop_update_hint",
9437 "noopUpdateHint",
9438 ];
9439
9440 #[allow(clippy::enum_variant_names)]
9441 enum GeneratedField {
9442 SelectList,
9443 WatermarkInputCols,
9444 WatermarkOutputCols,
9445 NondecreasingExprs,
9446 NoopUpdateHint,
9447 }
9448 impl<'de> serde::Deserialize<'de> for GeneratedField {
9449 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9450 where
9451 D: serde::Deserializer<'de>,
9452 {
9453 struct GeneratedVisitor;
9454
9455 impl serde::de::Visitor<'_> for GeneratedVisitor {
9456 type Value = GeneratedField;
9457
9458 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9459 write!(formatter, "expected one of: {:?}", &FIELDS)
9460 }
9461
9462 #[allow(unused_variables)]
9463 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9464 where
9465 E: serde::de::Error,
9466 {
9467 match value {
9468 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
9469 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
9470 "watermarkOutputCols" | "watermark_output_cols" => Ok(GeneratedField::WatermarkOutputCols),
9471 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
9472 "noopUpdateHint" | "noop_update_hint" => Ok(GeneratedField::NoopUpdateHint),
9473 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9474 }
9475 }
9476 }
9477 deserializer.deserialize_identifier(GeneratedVisitor)
9478 }
9479 }
9480 struct GeneratedVisitor;
9481 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9482 type Value = ProjectNode;
9483
9484 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9485 formatter.write_str("struct stream_plan.ProjectNode")
9486 }
9487
9488 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
9489 where
9490 V: serde::de::MapAccess<'de>,
9491 {
9492 let mut select_list__ = None;
9493 let mut watermark_input_cols__ = None;
9494 let mut watermark_output_cols__ = None;
9495 let mut nondecreasing_exprs__ = None;
9496 let mut noop_update_hint__ = None;
9497 while let Some(k) = map_.next_key()? {
9498 match k {
9499 GeneratedField::SelectList => {
9500 if select_list__.is_some() {
9501 return Err(serde::de::Error::duplicate_field("selectList"));
9502 }
9503 select_list__ = Some(map_.next_value()?);
9504 }
9505 GeneratedField::WatermarkInputCols => {
9506 if watermark_input_cols__.is_some() {
9507 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
9508 }
9509 watermark_input_cols__ =
9510 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9511 .into_iter().map(|x| x.0).collect())
9512 ;
9513 }
9514 GeneratedField::WatermarkOutputCols => {
9515 if watermark_output_cols__.is_some() {
9516 return Err(serde::de::Error::duplicate_field("watermarkOutputCols"));
9517 }
9518 watermark_output_cols__ =
9519 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9520 .into_iter().map(|x| x.0).collect())
9521 ;
9522 }
9523 GeneratedField::NondecreasingExprs => {
9524 if nondecreasing_exprs__.is_some() {
9525 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
9526 }
9527 nondecreasing_exprs__ =
9528 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9529 .into_iter().map(|x| x.0).collect())
9530 ;
9531 }
9532 GeneratedField::NoopUpdateHint => {
9533 if noop_update_hint__.is_some() {
9534 return Err(serde::de::Error::duplicate_field("noopUpdateHint"));
9535 }
9536 noop_update_hint__ = Some(map_.next_value()?);
9537 }
9538 }
9539 }
9540 Ok(ProjectNode {
9541 select_list: select_list__.unwrap_or_default(),
9542 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
9543 watermark_output_cols: watermark_output_cols__.unwrap_or_default(),
9544 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
9545 noop_update_hint: noop_update_hint__.unwrap_or_default(),
9546 })
9547 }
9548 }
9549 deserializer.deserialize_struct("stream_plan.ProjectNode", FIELDS, GeneratedVisitor)
9550 }
9551}
9552impl serde::Serialize for ProjectSetNode {
9553 #[allow(deprecated)]
9554 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9555 where
9556 S: serde::Serializer,
9557 {
9558 use serde::ser::SerializeStruct;
9559 let mut len = 0;
9560 if !self.select_list.is_empty() {
9561 len += 1;
9562 }
9563 if !self.watermark_input_cols.is_empty() {
9564 len += 1;
9565 }
9566 if !self.watermark_expr_indices.is_empty() {
9567 len += 1;
9568 }
9569 if !self.nondecreasing_exprs.is_empty() {
9570 len += 1;
9571 }
9572 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectSetNode", len)?;
9573 if !self.select_list.is_empty() {
9574 struct_ser.serialize_field("selectList", &self.select_list)?;
9575 }
9576 if !self.watermark_input_cols.is_empty() {
9577 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
9578 }
9579 if !self.watermark_expr_indices.is_empty() {
9580 struct_ser.serialize_field("watermarkExprIndices", &self.watermark_expr_indices)?;
9581 }
9582 if !self.nondecreasing_exprs.is_empty() {
9583 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
9584 }
9585 struct_ser.end()
9586 }
9587}
9588impl<'de> serde::Deserialize<'de> for ProjectSetNode {
9589 #[allow(deprecated)]
9590 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9591 where
9592 D: serde::Deserializer<'de>,
9593 {
9594 const FIELDS: &[&str] = &[
9595 "select_list",
9596 "selectList",
9597 "watermark_input_cols",
9598 "watermarkInputCols",
9599 "watermark_expr_indices",
9600 "watermarkExprIndices",
9601 "nondecreasing_exprs",
9602 "nondecreasingExprs",
9603 ];
9604
9605 #[allow(clippy::enum_variant_names)]
9606 enum GeneratedField {
9607 SelectList,
9608 WatermarkInputCols,
9609 WatermarkExprIndices,
9610 NondecreasingExprs,
9611 }
9612 impl<'de> serde::Deserialize<'de> for GeneratedField {
9613 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9614 where
9615 D: serde::Deserializer<'de>,
9616 {
9617 struct GeneratedVisitor;
9618
9619 impl serde::de::Visitor<'_> for GeneratedVisitor {
9620 type Value = GeneratedField;
9621
9622 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9623 write!(formatter, "expected one of: {:?}", &FIELDS)
9624 }
9625
9626 #[allow(unused_variables)]
9627 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9628 where
9629 E: serde::de::Error,
9630 {
9631 match value {
9632 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
9633 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
9634 "watermarkExprIndices" | "watermark_expr_indices" => Ok(GeneratedField::WatermarkExprIndices),
9635 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
9636 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9637 }
9638 }
9639 }
9640 deserializer.deserialize_identifier(GeneratedVisitor)
9641 }
9642 }
9643 struct GeneratedVisitor;
9644 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9645 type Value = ProjectSetNode;
9646
9647 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9648 formatter.write_str("struct stream_plan.ProjectSetNode")
9649 }
9650
9651 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
9652 where
9653 V: serde::de::MapAccess<'de>,
9654 {
9655 let mut select_list__ = None;
9656 let mut watermark_input_cols__ = None;
9657 let mut watermark_expr_indices__ = None;
9658 let mut nondecreasing_exprs__ = None;
9659 while let Some(k) = map_.next_key()? {
9660 match k {
9661 GeneratedField::SelectList => {
9662 if select_list__.is_some() {
9663 return Err(serde::de::Error::duplicate_field("selectList"));
9664 }
9665 select_list__ = Some(map_.next_value()?);
9666 }
9667 GeneratedField::WatermarkInputCols => {
9668 if watermark_input_cols__.is_some() {
9669 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
9670 }
9671 watermark_input_cols__ =
9672 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9673 .into_iter().map(|x| x.0).collect())
9674 ;
9675 }
9676 GeneratedField::WatermarkExprIndices => {
9677 if watermark_expr_indices__.is_some() {
9678 return Err(serde::de::Error::duplicate_field("watermarkExprIndices"));
9679 }
9680 watermark_expr_indices__ =
9681 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9682 .into_iter().map(|x| x.0).collect())
9683 ;
9684 }
9685 GeneratedField::NondecreasingExprs => {
9686 if nondecreasing_exprs__.is_some() {
9687 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
9688 }
9689 nondecreasing_exprs__ =
9690 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9691 .into_iter().map(|x| x.0).collect())
9692 ;
9693 }
9694 }
9695 }
9696 Ok(ProjectSetNode {
9697 select_list: select_list__.unwrap_or_default(),
9698 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
9699 watermark_expr_indices: watermark_expr_indices__.unwrap_or_default(),
9700 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
9701 })
9702 }
9703 }
9704 deserializer.deserialize_struct("stream_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
9705 }
9706}
9707impl serde::Serialize for RefreshStartMutation {
9708 #[allow(deprecated)]
9709 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9710 where
9711 S: serde::Serializer,
9712 {
9713 use serde::ser::SerializeStruct;
9714 let mut len = 0;
9715 if self.table_id != 0 {
9716 len += 1;
9717 }
9718 if self.associated_source_id != 0 {
9719 len += 1;
9720 }
9721 let mut struct_ser = serializer.serialize_struct("stream_plan.RefreshStartMutation", len)?;
9722 if self.table_id != 0 {
9723 struct_ser.serialize_field("tableId", &self.table_id)?;
9724 }
9725 if self.associated_source_id != 0 {
9726 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
9727 }
9728 struct_ser.end()
9729 }
9730}
9731impl<'de> serde::Deserialize<'de> for RefreshStartMutation {
9732 #[allow(deprecated)]
9733 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9734 where
9735 D: serde::Deserializer<'de>,
9736 {
9737 const FIELDS: &[&str] = &[
9738 "table_id",
9739 "tableId",
9740 "associated_source_id",
9741 "associatedSourceId",
9742 ];
9743
9744 #[allow(clippy::enum_variant_names)]
9745 enum GeneratedField {
9746 TableId,
9747 AssociatedSourceId,
9748 }
9749 impl<'de> serde::Deserialize<'de> for GeneratedField {
9750 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9751 where
9752 D: serde::Deserializer<'de>,
9753 {
9754 struct GeneratedVisitor;
9755
9756 impl serde::de::Visitor<'_> for GeneratedVisitor {
9757 type Value = GeneratedField;
9758
9759 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9760 write!(formatter, "expected one of: {:?}", &FIELDS)
9761 }
9762
9763 #[allow(unused_variables)]
9764 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9765 where
9766 E: serde::de::Error,
9767 {
9768 match value {
9769 "tableId" | "table_id" => Ok(GeneratedField::TableId),
9770 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
9771 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9772 }
9773 }
9774 }
9775 deserializer.deserialize_identifier(GeneratedVisitor)
9776 }
9777 }
9778 struct GeneratedVisitor;
9779 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9780 type Value = RefreshStartMutation;
9781
9782 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9783 formatter.write_str("struct stream_plan.RefreshStartMutation")
9784 }
9785
9786 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshStartMutation, V::Error>
9787 where
9788 V: serde::de::MapAccess<'de>,
9789 {
9790 let mut table_id__ = None;
9791 let mut associated_source_id__ = None;
9792 while let Some(k) = map_.next_key()? {
9793 match k {
9794 GeneratedField::TableId => {
9795 if table_id__.is_some() {
9796 return Err(serde::de::Error::duplicate_field("tableId"));
9797 }
9798 table_id__ =
9799 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9800 ;
9801 }
9802 GeneratedField::AssociatedSourceId => {
9803 if associated_source_id__.is_some() {
9804 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
9805 }
9806 associated_source_id__ =
9807 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9808 ;
9809 }
9810 }
9811 }
9812 Ok(RefreshStartMutation {
9813 table_id: table_id__.unwrap_or_default(),
9814 associated_source_id: associated_source_id__.unwrap_or_default(),
9815 })
9816 }
9817 }
9818 deserializer.deserialize_struct("stream_plan.RefreshStartMutation", FIELDS, GeneratedVisitor)
9819 }
9820}
9821impl serde::Serialize for ResetSourceMutation {
9822 #[allow(deprecated)]
9823 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9824 where
9825 S: serde::Serializer,
9826 {
9827 use serde::ser::SerializeStruct;
9828 let mut len = 0;
9829 if self.source_id != 0 {
9830 len += 1;
9831 }
9832 let mut struct_ser = serializer.serialize_struct("stream_plan.ResetSourceMutation", len)?;
9833 if self.source_id != 0 {
9834 struct_ser.serialize_field("sourceId", &self.source_id)?;
9835 }
9836 struct_ser.end()
9837 }
9838}
9839impl<'de> serde::Deserialize<'de> for ResetSourceMutation {
9840 #[allow(deprecated)]
9841 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9842 where
9843 D: serde::Deserializer<'de>,
9844 {
9845 const FIELDS: &[&str] = &[
9846 "source_id",
9847 "sourceId",
9848 ];
9849
9850 #[allow(clippy::enum_variant_names)]
9851 enum GeneratedField {
9852 SourceId,
9853 }
9854 impl<'de> serde::Deserialize<'de> for GeneratedField {
9855 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9856 where
9857 D: serde::Deserializer<'de>,
9858 {
9859 struct GeneratedVisitor;
9860
9861 impl serde::de::Visitor<'_> for GeneratedVisitor {
9862 type Value = GeneratedField;
9863
9864 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9865 write!(formatter, "expected one of: {:?}", &FIELDS)
9866 }
9867
9868 #[allow(unused_variables)]
9869 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9870 where
9871 E: serde::de::Error,
9872 {
9873 match value {
9874 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
9875 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9876 }
9877 }
9878 }
9879 deserializer.deserialize_identifier(GeneratedVisitor)
9880 }
9881 }
9882 struct GeneratedVisitor;
9883 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9884 type Value = ResetSourceMutation;
9885
9886 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9887 formatter.write_str("struct stream_plan.ResetSourceMutation")
9888 }
9889
9890 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceMutation, V::Error>
9891 where
9892 V: serde::de::MapAccess<'de>,
9893 {
9894 let mut source_id__ = None;
9895 while let Some(k) = map_.next_key()? {
9896 match k {
9897 GeneratedField::SourceId => {
9898 if source_id__.is_some() {
9899 return Err(serde::de::Error::duplicate_field("sourceId"));
9900 }
9901 source_id__ =
9902 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9903 ;
9904 }
9905 }
9906 }
9907 Ok(ResetSourceMutation {
9908 source_id: source_id__.unwrap_or_default(),
9909 })
9910 }
9911 }
9912 deserializer.deserialize_struct("stream_plan.ResetSourceMutation", FIELDS, GeneratedVisitor)
9913 }
9914}
9915impl serde::Serialize for ResumeMutation {
9916 #[allow(deprecated)]
9917 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9918 where
9919 S: serde::Serializer,
9920 {
9921 use serde::ser::SerializeStruct;
9922 let len = 0;
9923 let struct_ser = serializer.serialize_struct("stream_plan.ResumeMutation", len)?;
9924 struct_ser.end()
9925 }
9926}
9927impl<'de> serde::Deserialize<'de> for ResumeMutation {
9928 #[allow(deprecated)]
9929 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9930 where
9931 D: serde::Deserializer<'de>,
9932 {
9933 const FIELDS: &[&str] = &[
9934 ];
9935
9936 #[allow(clippy::enum_variant_names)]
9937 enum GeneratedField {
9938 }
9939 impl<'de> serde::Deserialize<'de> for GeneratedField {
9940 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9941 where
9942 D: serde::Deserializer<'de>,
9943 {
9944 struct GeneratedVisitor;
9945
9946 impl serde::de::Visitor<'_> for GeneratedVisitor {
9947 type Value = GeneratedField;
9948
9949 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9950 write!(formatter, "expected one of: {:?}", &FIELDS)
9951 }
9952
9953 #[allow(unused_variables)]
9954 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9955 where
9956 E: serde::de::Error,
9957 {
9958 Err(serde::de::Error::unknown_field(value, FIELDS))
9959 }
9960 }
9961 deserializer.deserialize_identifier(GeneratedVisitor)
9962 }
9963 }
9964 struct GeneratedVisitor;
9965 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9966 type Value = ResumeMutation;
9967
9968 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9969 formatter.write_str("struct stream_plan.ResumeMutation")
9970 }
9971
9972 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeMutation, V::Error>
9973 where
9974 V: serde::de::MapAccess<'de>,
9975 {
9976 while map_.next_key::<GeneratedField>()?.is_some() {
9977 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9978 }
9979 Ok(ResumeMutation {
9980 })
9981 }
9982 }
9983 deserializer.deserialize_struct("stream_plan.ResumeMutation", FIELDS, GeneratedVisitor)
9984 }
9985}
9986impl serde::Serialize for RowIdGenNode {
9987 #[allow(deprecated)]
9988 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9989 where
9990 S: serde::Serializer,
9991 {
9992 use serde::ser::SerializeStruct;
9993 let mut len = 0;
9994 if self.row_id_index != 0 {
9995 len += 1;
9996 }
9997 let mut struct_ser = serializer.serialize_struct("stream_plan.RowIdGenNode", len)?;
9998 if self.row_id_index != 0 {
9999 #[allow(clippy::needless_borrow)]
10000 #[allow(clippy::needless_borrows_for_generic_args)]
10001 struct_ser.serialize_field("rowIdIndex", ToString::to_string(&self.row_id_index).as_str())?;
10002 }
10003 struct_ser.end()
10004 }
10005}
10006impl<'de> serde::Deserialize<'de> for RowIdGenNode {
10007 #[allow(deprecated)]
10008 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10009 where
10010 D: serde::Deserializer<'de>,
10011 {
10012 const FIELDS: &[&str] = &[
10013 "row_id_index",
10014 "rowIdIndex",
10015 ];
10016
10017 #[allow(clippy::enum_variant_names)]
10018 enum GeneratedField {
10019 RowIdIndex,
10020 }
10021 impl<'de> serde::Deserialize<'de> for GeneratedField {
10022 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10023 where
10024 D: serde::Deserializer<'de>,
10025 {
10026 struct GeneratedVisitor;
10027
10028 impl serde::de::Visitor<'_> for GeneratedVisitor {
10029 type Value = GeneratedField;
10030
10031 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10032 write!(formatter, "expected one of: {:?}", &FIELDS)
10033 }
10034
10035 #[allow(unused_variables)]
10036 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10037 where
10038 E: serde::de::Error,
10039 {
10040 match value {
10041 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
10042 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10043 }
10044 }
10045 }
10046 deserializer.deserialize_identifier(GeneratedVisitor)
10047 }
10048 }
10049 struct GeneratedVisitor;
10050 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10051 type Value = RowIdGenNode;
10052
10053 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10054 formatter.write_str("struct stream_plan.RowIdGenNode")
10055 }
10056
10057 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowIdGenNode, V::Error>
10058 where
10059 V: serde::de::MapAccess<'de>,
10060 {
10061 let mut row_id_index__ = None;
10062 while let Some(k) = map_.next_key()? {
10063 match k {
10064 GeneratedField::RowIdIndex => {
10065 if row_id_index__.is_some() {
10066 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
10067 }
10068 row_id_index__ =
10069 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10070 ;
10071 }
10072 }
10073 }
10074 Ok(RowIdGenNode {
10075 row_id_index: row_id_index__.unwrap_or_default(),
10076 })
10077 }
10078 }
10079 deserializer.deserialize_struct("stream_plan.RowIdGenNode", FIELDS, GeneratedVisitor)
10080 }
10081}
10082impl serde::Serialize for RowMergeNode {
10083 #[allow(deprecated)]
10084 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10085 where
10086 S: serde::Serializer,
10087 {
10088 use serde::ser::SerializeStruct;
10089 let mut len = 0;
10090 if self.lhs_mapping.is_some() {
10091 len += 1;
10092 }
10093 if self.rhs_mapping.is_some() {
10094 len += 1;
10095 }
10096 let mut struct_ser = serializer.serialize_struct("stream_plan.RowMergeNode", len)?;
10097 if let Some(v) = self.lhs_mapping.as_ref() {
10098 struct_ser.serialize_field("lhsMapping", v)?;
10099 }
10100 if let Some(v) = self.rhs_mapping.as_ref() {
10101 struct_ser.serialize_field("rhsMapping", v)?;
10102 }
10103 struct_ser.end()
10104 }
10105}
10106impl<'de> serde::Deserialize<'de> for RowMergeNode {
10107 #[allow(deprecated)]
10108 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10109 where
10110 D: serde::Deserializer<'de>,
10111 {
10112 const FIELDS: &[&str] = &[
10113 "lhs_mapping",
10114 "lhsMapping",
10115 "rhs_mapping",
10116 "rhsMapping",
10117 ];
10118
10119 #[allow(clippy::enum_variant_names)]
10120 enum GeneratedField {
10121 LhsMapping,
10122 RhsMapping,
10123 }
10124 impl<'de> serde::Deserialize<'de> for GeneratedField {
10125 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10126 where
10127 D: serde::Deserializer<'de>,
10128 {
10129 struct GeneratedVisitor;
10130
10131 impl serde::de::Visitor<'_> for GeneratedVisitor {
10132 type Value = GeneratedField;
10133
10134 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10135 write!(formatter, "expected one of: {:?}", &FIELDS)
10136 }
10137
10138 #[allow(unused_variables)]
10139 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10140 where
10141 E: serde::de::Error,
10142 {
10143 match value {
10144 "lhsMapping" | "lhs_mapping" => Ok(GeneratedField::LhsMapping),
10145 "rhsMapping" | "rhs_mapping" => Ok(GeneratedField::RhsMapping),
10146 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10147 }
10148 }
10149 }
10150 deserializer.deserialize_identifier(GeneratedVisitor)
10151 }
10152 }
10153 struct GeneratedVisitor;
10154 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10155 type Value = RowMergeNode;
10156
10157 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10158 formatter.write_str("struct stream_plan.RowMergeNode")
10159 }
10160
10161 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowMergeNode, V::Error>
10162 where
10163 V: serde::de::MapAccess<'de>,
10164 {
10165 let mut lhs_mapping__ = None;
10166 let mut rhs_mapping__ = None;
10167 while let Some(k) = map_.next_key()? {
10168 match k {
10169 GeneratedField::LhsMapping => {
10170 if lhs_mapping__.is_some() {
10171 return Err(serde::de::Error::duplicate_field("lhsMapping"));
10172 }
10173 lhs_mapping__ = map_.next_value()?;
10174 }
10175 GeneratedField::RhsMapping => {
10176 if rhs_mapping__.is_some() {
10177 return Err(serde::de::Error::duplicate_field("rhsMapping"));
10178 }
10179 rhs_mapping__ = map_.next_value()?;
10180 }
10181 }
10182 }
10183 Ok(RowMergeNode {
10184 lhs_mapping: lhs_mapping__,
10185 rhs_mapping: rhs_mapping__,
10186 })
10187 }
10188 }
10189 deserializer.deserialize_struct("stream_plan.RowMergeNode", FIELDS, GeneratedVisitor)
10190 }
10191}
10192impl serde::Serialize for SimpleAggNode {
10193 #[allow(deprecated)]
10194 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10195 where
10196 S: serde::Serializer,
10197 {
10198 use serde::ser::SerializeStruct;
10199 let mut len = 0;
10200 if !self.agg_calls.is_empty() {
10201 len += 1;
10202 }
10203 if !self.agg_call_states.is_empty() {
10204 len += 1;
10205 }
10206 if self.intermediate_state_table.is_some() {
10207 len += 1;
10208 }
10209 if self.is_append_only {
10210 len += 1;
10211 }
10212 if !self.distinct_dedup_tables.is_empty() {
10213 len += 1;
10214 }
10215 if self.row_count_index != 0 {
10216 len += 1;
10217 }
10218 if self.version != 0 {
10219 len += 1;
10220 }
10221 if self.must_output_per_barrier {
10222 len += 1;
10223 }
10224 let mut struct_ser = serializer.serialize_struct("stream_plan.SimpleAggNode", len)?;
10225 if !self.agg_calls.is_empty() {
10226 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
10227 }
10228 if !self.agg_call_states.is_empty() {
10229 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
10230 }
10231 if let Some(v) = self.intermediate_state_table.as_ref() {
10232 struct_ser.serialize_field("intermediateStateTable", v)?;
10233 }
10234 if self.is_append_only {
10235 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
10236 }
10237 if !self.distinct_dedup_tables.is_empty() {
10238 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
10239 }
10240 if self.row_count_index != 0 {
10241 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
10242 }
10243 if self.version != 0 {
10244 let v = AggNodeVersion::try_from(self.version)
10245 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
10246 struct_ser.serialize_field("version", &v)?;
10247 }
10248 if self.must_output_per_barrier {
10249 struct_ser.serialize_field("mustOutputPerBarrier", &self.must_output_per_barrier)?;
10250 }
10251 struct_ser.end()
10252 }
10253}
10254impl<'de> serde::Deserialize<'de> for SimpleAggNode {
10255 #[allow(deprecated)]
10256 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10257 where
10258 D: serde::Deserializer<'de>,
10259 {
10260 const FIELDS: &[&str] = &[
10261 "agg_calls",
10262 "aggCalls",
10263 "agg_call_states",
10264 "aggCallStates",
10265 "intermediate_state_table",
10266 "intermediateStateTable",
10267 "is_append_only",
10268 "isAppendOnly",
10269 "distinct_dedup_tables",
10270 "distinctDedupTables",
10271 "row_count_index",
10272 "rowCountIndex",
10273 "version",
10274 "must_output_per_barrier",
10275 "mustOutputPerBarrier",
10276 ];
10277
10278 #[allow(clippy::enum_variant_names)]
10279 enum GeneratedField {
10280 AggCalls,
10281 AggCallStates,
10282 IntermediateStateTable,
10283 IsAppendOnly,
10284 DistinctDedupTables,
10285 RowCountIndex,
10286 Version,
10287 MustOutputPerBarrier,
10288 }
10289 impl<'de> serde::Deserialize<'de> for GeneratedField {
10290 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10291 where
10292 D: serde::Deserializer<'de>,
10293 {
10294 struct GeneratedVisitor;
10295
10296 impl serde::de::Visitor<'_> for GeneratedVisitor {
10297 type Value = GeneratedField;
10298
10299 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10300 write!(formatter, "expected one of: {:?}", &FIELDS)
10301 }
10302
10303 #[allow(unused_variables)]
10304 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10305 where
10306 E: serde::de::Error,
10307 {
10308 match value {
10309 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
10310 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
10311 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
10312 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
10313 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
10314 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
10315 "version" => Ok(GeneratedField::Version),
10316 "mustOutputPerBarrier" | "must_output_per_barrier" => Ok(GeneratedField::MustOutputPerBarrier),
10317 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10318 }
10319 }
10320 }
10321 deserializer.deserialize_identifier(GeneratedVisitor)
10322 }
10323 }
10324 struct GeneratedVisitor;
10325 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10326 type Value = SimpleAggNode;
10327
10328 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10329 formatter.write_str("struct stream_plan.SimpleAggNode")
10330 }
10331
10332 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SimpleAggNode, V::Error>
10333 where
10334 V: serde::de::MapAccess<'de>,
10335 {
10336 let mut agg_calls__ = None;
10337 let mut agg_call_states__ = None;
10338 let mut intermediate_state_table__ = None;
10339 let mut is_append_only__ = None;
10340 let mut distinct_dedup_tables__ = None;
10341 let mut row_count_index__ = None;
10342 let mut version__ = None;
10343 let mut must_output_per_barrier__ = None;
10344 while let Some(k) = map_.next_key()? {
10345 match k {
10346 GeneratedField::AggCalls => {
10347 if agg_calls__.is_some() {
10348 return Err(serde::de::Error::duplicate_field("aggCalls"));
10349 }
10350 agg_calls__ = Some(map_.next_value()?);
10351 }
10352 GeneratedField::AggCallStates => {
10353 if agg_call_states__.is_some() {
10354 return Err(serde::de::Error::duplicate_field("aggCallStates"));
10355 }
10356 agg_call_states__ = Some(map_.next_value()?);
10357 }
10358 GeneratedField::IntermediateStateTable => {
10359 if intermediate_state_table__.is_some() {
10360 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
10361 }
10362 intermediate_state_table__ = map_.next_value()?;
10363 }
10364 GeneratedField::IsAppendOnly => {
10365 if is_append_only__.is_some() {
10366 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
10367 }
10368 is_append_only__ = Some(map_.next_value()?);
10369 }
10370 GeneratedField::DistinctDedupTables => {
10371 if distinct_dedup_tables__.is_some() {
10372 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
10373 }
10374 distinct_dedup_tables__ = Some(
10375 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10376 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
10377 );
10378 }
10379 GeneratedField::RowCountIndex => {
10380 if row_count_index__.is_some() {
10381 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
10382 }
10383 row_count_index__ =
10384 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10385 ;
10386 }
10387 GeneratedField::Version => {
10388 if version__.is_some() {
10389 return Err(serde::de::Error::duplicate_field("version"));
10390 }
10391 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
10392 }
10393 GeneratedField::MustOutputPerBarrier => {
10394 if must_output_per_barrier__.is_some() {
10395 return Err(serde::de::Error::duplicate_field("mustOutputPerBarrier"));
10396 }
10397 must_output_per_barrier__ = Some(map_.next_value()?);
10398 }
10399 }
10400 }
10401 Ok(SimpleAggNode {
10402 agg_calls: agg_calls__.unwrap_or_default(),
10403 agg_call_states: agg_call_states__.unwrap_or_default(),
10404 intermediate_state_table: intermediate_state_table__,
10405 is_append_only: is_append_only__.unwrap_or_default(),
10406 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
10407 row_count_index: row_count_index__.unwrap_or_default(),
10408 version: version__.unwrap_or_default(),
10409 must_output_per_barrier: must_output_per_barrier__.unwrap_or_default(),
10410 })
10411 }
10412 }
10413 deserializer.deserialize_struct("stream_plan.SimpleAggNode", FIELDS, GeneratedVisitor)
10414 }
10415}
10416impl serde::Serialize for SinkAddColumnsOp {
10417 #[allow(deprecated)]
10418 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10419 where
10420 S: serde::Serializer,
10421 {
10422 use serde::ser::SerializeStruct;
10423 let mut len = 0;
10424 if !self.fields.is_empty() {
10425 len += 1;
10426 }
10427 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkAddColumnsOp", len)?;
10428 if !self.fields.is_empty() {
10429 struct_ser.serialize_field("fields", &self.fields)?;
10430 }
10431 struct_ser.end()
10432 }
10433}
10434impl<'de> serde::Deserialize<'de> for SinkAddColumnsOp {
10435 #[allow(deprecated)]
10436 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10437 where
10438 D: serde::Deserializer<'de>,
10439 {
10440 const FIELDS: &[&str] = &[
10441 "fields",
10442 ];
10443
10444 #[allow(clippy::enum_variant_names)]
10445 enum GeneratedField {
10446 Fields,
10447 }
10448 impl<'de> serde::Deserialize<'de> for GeneratedField {
10449 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10450 where
10451 D: serde::Deserializer<'de>,
10452 {
10453 struct GeneratedVisitor;
10454
10455 impl serde::de::Visitor<'_> for GeneratedVisitor {
10456 type Value = GeneratedField;
10457
10458 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10459 write!(formatter, "expected one of: {:?}", &FIELDS)
10460 }
10461
10462 #[allow(unused_variables)]
10463 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10464 where
10465 E: serde::de::Error,
10466 {
10467 match value {
10468 "fields" => Ok(GeneratedField::Fields),
10469 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10470 }
10471 }
10472 }
10473 deserializer.deserialize_identifier(GeneratedVisitor)
10474 }
10475 }
10476 struct GeneratedVisitor;
10477 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10478 type Value = SinkAddColumnsOp;
10479
10480 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10481 formatter.write_str("struct stream_plan.SinkAddColumnsOp")
10482 }
10483
10484 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkAddColumnsOp, V::Error>
10485 where
10486 V: serde::de::MapAccess<'de>,
10487 {
10488 let mut fields__ = None;
10489 while let Some(k) = map_.next_key()? {
10490 match k {
10491 GeneratedField::Fields => {
10492 if fields__.is_some() {
10493 return Err(serde::de::Error::duplicate_field("fields"));
10494 }
10495 fields__ = Some(map_.next_value()?);
10496 }
10497 }
10498 }
10499 Ok(SinkAddColumnsOp {
10500 fields: fields__.unwrap_or_default(),
10501 })
10502 }
10503 }
10504 deserializer.deserialize_struct("stream_plan.SinkAddColumnsOp", FIELDS, GeneratedVisitor)
10505 }
10506}
10507impl serde::Serialize for SinkDesc {
10508 #[allow(deprecated)]
10509 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10510 where
10511 S: serde::Serializer,
10512 {
10513 use serde::ser::SerializeStruct;
10514 let mut len = 0;
10515 if self.id != 0 {
10516 len += 1;
10517 }
10518 if !self.name.is_empty() {
10519 len += 1;
10520 }
10521 if !self.definition.is_empty() {
10522 len += 1;
10523 }
10524 if !self.plan_pk.is_empty() {
10525 len += 1;
10526 }
10527 if !self.downstream_pk.is_empty() {
10528 len += 1;
10529 }
10530 if !self.distribution_key.is_empty() {
10531 len += 1;
10532 }
10533 if !self.properties.is_empty() {
10534 len += 1;
10535 }
10536 if self.sink_type != 0 {
10537 len += 1;
10538 }
10539 if !self.column_catalogs.is_empty() {
10540 len += 1;
10541 }
10542 if !self.db_name.is_empty() {
10543 len += 1;
10544 }
10545 if !self.sink_from_name.is_empty() {
10546 len += 1;
10547 }
10548 if self.format_desc.is_some() {
10549 len += 1;
10550 }
10551 if self.target_table.is_some() {
10552 len += 1;
10553 }
10554 if self.extra_partition_col_idx.is_some() {
10555 len += 1;
10556 }
10557 if !self.secret_refs.is_empty() {
10558 len += 1;
10559 }
10560 if self.raw_ignore_delete {
10561 len += 1;
10562 }
10563 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDesc", len)?;
10564 if self.id != 0 {
10565 struct_ser.serialize_field("id", &self.id)?;
10566 }
10567 if !self.name.is_empty() {
10568 struct_ser.serialize_field("name", &self.name)?;
10569 }
10570 if !self.definition.is_empty() {
10571 struct_ser.serialize_field("definition", &self.definition)?;
10572 }
10573 if !self.plan_pk.is_empty() {
10574 struct_ser.serialize_field("planPk", &self.plan_pk)?;
10575 }
10576 if !self.downstream_pk.is_empty() {
10577 struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
10578 }
10579 if !self.distribution_key.is_empty() {
10580 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
10581 }
10582 if !self.properties.is_empty() {
10583 struct_ser.serialize_field("properties", &self.properties)?;
10584 }
10585 if self.sink_type != 0 {
10586 let v = super::catalog::SinkType::try_from(self.sink_type)
10587 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
10588 struct_ser.serialize_field("sinkType", &v)?;
10589 }
10590 if !self.column_catalogs.is_empty() {
10591 struct_ser.serialize_field("columnCatalogs", &self.column_catalogs)?;
10592 }
10593 if !self.db_name.is_empty() {
10594 struct_ser.serialize_field("dbName", &self.db_name)?;
10595 }
10596 if !self.sink_from_name.is_empty() {
10597 struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
10598 }
10599 if let Some(v) = self.format_desc.as_ref() {
10600 struct_ser.serialize_field("formatDesc", v)?;
10601 }
10602 if let Some(v) = self.target_table.as_ref() {
10603 struct_ser.serialize_field("targetTable", v)?;
10604 }
10605 if let Some(v) = self.extra_partition_col_idx.as_ref() {
10606 #[allow(clippy::needless_borrow)]
10607 #[allow(clippy::needless_borrows_for_generic_args)]
10608 struct_ser.serialize_field("extraPartitionColIdx", ToString::to_string(&v).as_str())?;
10609 }
10610 if !self.secret_refs.is_empty() {
10611 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
10612 }
10613 if self.raw_ignore_delete {
10614 struct_ser.serialize_field("rawIgnoreDelete", &self.raw_ignore_delete)?;
10615 }
10616 struct_ser.end()
10617 }
10618}
10619impl<'de> serde::Deserialize<'de> for SinkDesc {
10620 #[allow(deprecated)]
10621 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10622 where
10623 D: serde::Deserializer<'de>,
10624 {
10625 const FIELDS: &[&str] = &[
10626 "id",
10627 "name",
10628 "definition",
10629 "plan_pk",
10630 "planPk",
10631 "downstream_pk",
10632 "downstreamPk",
10633 "distribution_key",
10634 "distributionKey",
10635 "properties",
10636 "sink_type",
10637 "sinkType",
10638 "column_catalogs",
10639 "columnCatalogs",
10640 "db_name",
10641 "dbName",
10642 "sink_from_name",
10643 "sinkFromName",
10644 "format_desc",
10645 "formatDesc",
10646 "target_table",
10647 "targetTable",
10648 "extra_partition_col_idx",
10649 "extraPartitionColIdx",
10650 "secret_refs",
10651 "secretRefs",
10652 "raw_ignore_delete",
10653 "rawIgnoreDelete",
10654 ];
10655
10656 #[allow(clippy::enum_variant_names)]
10657 enum GeneratedField {
10658 Id,
10659 Name,
10660 Definition,
10661 PlanPk,
10662 DownstreamPk,
10663 DistributionKey,
10664 Properties,
10665 SinkType,
10666 ColumnCatalogs,
10667 DbName,
10668 SinkFromName,
10669 FormatDesc,
10670 TargetTable,
10671 ExtraPartitionColIdx,
10672 SecretRefs,
10673 RawIgnoreDelete,
10674 }
10675 impl<'de> serde::Deserialize<'de> for GeneratedField {
10676 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10677 where
10678 D: serde::Deserializer<'de>,
10679 {
10680 struct GeneratedVisitor;
10681
10682 impl serde::de::Visitor<'_> for GeneratedVisitor {
10683 type Value = GeneratedField;
10684
10685 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10686 write!(formatter, "expected one of: {:?}", &FIELDS)
10687 }
10688
10689 #[allow(unused_variables)]
10690 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10691 where
10692 E: serde::de::Error,
10693 {
10694 match value {
10695 "id" => Ok(GeneratedField::Id),
10696 "name" => Ok(GeneratedField::Name),
10697 "definition" => Ok(GeneratedField::Definition),
10698 "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
10699 "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
10700 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
10701 "properties" => Ok(GeneratedField::Properties),
10702 "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
10703 "columnCatalogs" | "column_catalogs" => Ok(GeneratedField::ColumnCatalogs),
10704 "dbName" | "db_name" => Ok(GeneratedField::DbName),
10705 "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
10706 "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
10707 "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
10708 "extraPartitionColIdx" | "extra_partition_col_idx" => Ok(GeneratedField::ExtraPartitionColIdx),
10709 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
10710 "rawIgnoreDelete" | "raw_ignore_delete" => Ok(GeneratedField::RawIgnoreDelete),
10711 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10712 }
10713 }
10714 }
10715 deserializer.deserialize_identifier(GeneratedVisitor)
10716 }
10717 }
10718 struct GeneratedVisitor;
10719 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10720 type Value = SinkDesc;
10721
10722 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10723 formatter.write_str("struct stream_plan.SinkDesc")
10724 }
10725
10726 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDesc, V::Error>
10727 where
10728 V: serde::de::MapAccess<'de>,
10729 {
10730 let mut id__ = None;
10731 let mut name__ = None;
10732 let mut definition__ = None;
10733 let mut plan_pk__ = None;
10734 let mut downstream_pk__ = None;
10735 let mut distribution_key__ = None;
10736 let mut properties__ = None;
10737 let mut sink_type__ = None;
10738 let mut column_catalogs__ = None;
10739 let mut db_name__ = None;
10740 let mut sink_from_name__ = None;
10741 let mut format_desc__ = None;
10742 let mut target_table__ = None;
10743 let mut extra_partition_col_idx__ = None;
10744 let mut secret_refs__ = None;
10745 let mut raw_ignore_delete__ = None;
10746 while let Some(k) = map_.next_key()? {
10747 match k {
10748 GeneratedField::Id => {
10749 if id__.is_some() {
10750 return Err(serde::de::Error::duplicate_field("id"));
10751 }
10752 id__ =
10753 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10754 ;
10755 }
10756 GeneratedField::Name => {
10757 if name__.is_some() {
10758 return Err(serde::de::Error::duplicate_field("name"));
10759 }
10760 name__ = Some(map_.next_value()?);
10761 }
10762 GeneratedField::Definition => {
10763 if definition__.is_some() {
10764 return Err(serde::de::Error::duplicate_field("definition"));
10765 }
10766 definition__ = Some(map_.next_value()?);
10767 }
10768 GeneratedField::PlanPk => {
10769 if plan_pk__.is_some() {
10770 return Err(serde::de::Error::duplicate_field("planPk"));
10771 }
10772 plan_pk__ = Some(map_.next_value()?);
10773 }
10774 GeneratedField::DownstreamPk => {
10775 if downstream_pk__.is_some() {
10776 return Err(serde::de::Error::duplicate_field("downstreamPk"));
10777 }
10778 downstream_pk__ =
10779 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10780 .into_iter().map(|x| x.0).collect())
10781 ;
10782 }
10783 GeneratedField::DistributionKey => {
10784 if distribution_key__.is_some() {
10785 return Err(serde::de::Error::duplicate_field("distributionKey"));
10786 }
10787 distribution_key__ =
10788 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10789 .into_iter().map(|x| x.0).collect())
10790 ;
10791 }
10792 GeneratedField::Properties => {
10793 if properties__.is_some() {
10794 return Err(serde::de::Error::duplicate_field("properties"));
10795 }
10796 properties__ = Some(
10797 map_.next_value::<std::collections::BTreeMap<_, _>>()?
10798 );
10799 }
10800 GeneratedField::SinkType => {
10801 if sink_type__.is_some() {
10802 return Err(serde::de::Error::duplicate_field("sinkType"));
10803 }
10804 sink_type__ = Some(map_.next_value::<super::catalog::SinkType>()? as i32);
10805 }
10806 GeneratedField::ColumnCatalogs => {
10807 if column_catalogs__.is_some() {
10808 return Err(serde::de::Error::duplicate_field("columnCatalogs"));
10809 }
10810 column_catalogs__ = Some(map_.next_value()?);
10811 }
10812 GeneratedField::DbName => {
10813 if db_name__.is_some() {
10814 return Err(serde::de::Error::duplicate_field("dbName"));
10815 }
10816 db_name__ = Some(map_.next_value()?);
10817 }
10818 GeneratedField::SinkFromName => {
10819 if sink_from_name__.is_some() {
10820 return Err(serde::de::Error::duplicate_field("sinkFromName"));
10821 }
10822 sink_from_name__ = Some(map_.next_value()?);
10823 }
10824 GeneratedField::FormatDesc => {
10825 if format_desc__.is_some() {
10826 return Err(serde::de::Error::duplicate_field("formatDesc"));
10827 }
10828 format_desc__ = map_.next_value()?;
10829 }
10830 GeneratedField::TargetTable => {
10831 if target_table__.is_some() {
10832 return Err(serde::de::Error::duplicate_field("targetTable"));
10833 }
10834 target_table__ =
10835 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10836 ;
10837 }
10838 GeneratedField::ExtraPartitionColIdx => {
10839 if extra_partition_col_idx__.is_some() {
10840 return Err(serde::de::Error::duplicate_field("extraPartitionColIdx"));
10841 }
10842 extra_partition_col_idx__ =
10843 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10844 ;
10845 }
10846 GeneratedField::SecretRefs => {
10847 if secret_refs__.is_some() {
10848 return Err(serde::de::Error::duplicate_field("secretRefs"));
10849 }
10850 secret_refs__ = Some(
10851 map_.next_value::<std::collections::BTreeMap<_, _>>()?
10852 );
10853 }
10854 GeneratedField::RawIgnoreDelete => {
10855 if raw_ignore_delete__.is_some() {
10856 return Err(serde::de::Error::duplicate_field("rawIgnoreDelete"));
10857 }
10858 raw_ignore_delete__ = Some(map_.next_value()?);
10859 }
10860 }
10861 }
10862 Ok(SinkDesc {
10863 id: id__.unwrap_or_default(),
10864 name: name__.unwrap_or_default(),
10865 definition: definition__.unwrap_or_default(),
10866 plan_pk: plan_pk__.unwrap_or_default(),
10867 downstream_pk: downstream_pk__.unwrap_or_default(),
10868 distribution_key: distribution_key__.unwrap_or_default(),
10869 properties: properties__.unwrap_or_default(),
10870 sink_type: sink_type__.unwrap_or_default(),
10871 column_catalogs: column_catalogs__.unwrap_or_default(),
10872 db_name: db_name__.unwrap_or_default(),
10873 sink_from_name: sink_from_name__.unwrap_or_default(),
10874 format_desc: format_desc__,
10875 target_table: target_table__,
10876 extra_partition_col_idx: extra_partition_col_idx__,
10877 secret_refs: secret_refs__.unwrap_or_default(),
10878 raw_ignore_delete: raw_ignore_delete__.unwrap_or_default(),
10879 })
10880 }
10881 }
10882 deserializer.deserialize_struct("stream_plan.SinkDesc", FIELDS, GeneratedVisitor)
10883 }
10884}
10885impl serde::Serialize for SinkDropColumnsOp {
10886 #[allow(deprecated)]
10887 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10888 where
10889 S: serde::Serializer,
10890 {
10891 use serde::ser::SerializeStruct;
10892 let mut len = 0;
10893 if !self.column_names.is_empty() {
10894 len += 1;
10895 }
10896 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDropColumnsOp", len)?;
10897 if !self.column_names.is_empty() {
10898 struct_ser.serialize_field("columnNames", &self.column_names)?;
10899 }
10900 struct_ser.end()
10901 }
10902}
10903impl<'de> serde::Deserialize<'de> for SinkDropColumnsOp {
10904 #[allow(deprecated)]
10905 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10906 where
10907 D: serde::Deserializer<'de>,
10908 {
10909 const FIELDS: &[&str] = &[
10910 "column_names",
10911 "columnNames",
10912 ];
10913
10914 #[allow(clippy::enum_variant_names)]
10915 enum GeneratedField {
10916 ColumnNames,
10917 }
10918 impl<'de> serde::Deserialize<'de> for GeneratedField {
10919 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10920 where
10921 D: serde::Deserializer<'de>,
10922 {
10923 struct GeneratedVisitor;
10924
10925 impl serde::de::Visitor<'_> for GeneratedVisitor {
10926 type Value = GeneratedField;
10927
10928 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10929 write!(formatter, "expected one of: {:?}", &FIELDS)
10930 }
10931
10932 #[allow(unused_variables)]
10933 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10934 where
10935 E: serde::de::Error,
10936 {
10937 match value {
10938 "columnNames" | "column_names" => Ok(GeneratedField::ColumnNames),
10939 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10940 }
10941 }
10942 }
10943 deserializer.deserialize_identifier(GeneratedVisitor)
10944 }
10945 }
10946 struct GeneratedVisitor;
10947 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10948 type Value = SinkDropColumnsOp;
10949
10950 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10951 formatter.write_str("struct stream_plan.SinkDropColumnsOp")
10952 }
10953
10954 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDropColumnsOp, V::Error>
10955 where
10956 V: serde::de::MapAccess<'de>,
10957 {
10958 let mut column_names__ = None;
10959 while let Some(k) = map_.next_key()? {
10960 match k {
10961 GeneratedField::ColumnNames => {
10962 if column_names__.is_some() {
10963 return Err(serde::de::Error::duplicate_field("columnNames"));
10964 }
10965 column_names__ = Some(map_.next_value()?);
10966 }
10967 }
10968 }
10969 Ok(SinkDropColumnsOp {
10970 column_names: column_names__.unwrap_or_default(),
10971 })
10972 }
10973 }
10974 deserializer.deserialize_struct("stream_plan.SinkDropColumnsOp", FIELDS, GeneratedVisitor)
10975 }
10976}
10977impl serde::Serialize for SinkLogStoreType {
10978 #[allow(deprecated)]
10979 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10980 where
10981 S: serde::Serializer,
10982 {
10983 let variant = match self {
10984 Self::Unspecified => "SINK_LOG_STORE_TYPE_UNSPECIFIED",
10985 Self::KvLogStore => "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
10986 Self::InMemoryLogStore => "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
10987 };
10988 serializer.serialize_str(variant)
10989 }
10990}
10991impl<'de> serde::Deserialize<'de> for SinkLogStoreType {
10992 #[allow(deprecated)]
10993 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10994 where
10995 D: serde::Deserializer<'de>,
10996 {
10997 const FIELDS: &[&str] = &[
10998 "SINK_LOG_STORE_TYPE_UNSPECIFIED",
10999 "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
11000 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
11001 ];
11002
11003 struct GeneratedVisitor;
11004
11005 impl serde::de::Visitor<'_> for GeneratedVisitor {
11006 type Value = SinkLogStoreType;
11007
11008 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11009 write!(formatter, "expected one of: {:?}", &FIELDS)
11010 }
11011
11012 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
11013 where
11014 E: serde::de::Error,
11015 {
11016 i32::try_from(v)
11017 .ok()
11018 .and_then(|x| x.try_into().ok())
11019 .ok_or_else(|| {
11020 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
11021 })
11022 }
11023
11024 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
11025 where
11026 E: serde::de::Error,
11027 {
11028 i32::try_from(v)
11029 .ok()
11030 .and_then(|x| x.try_into().ok())
11031 .ok_or_else(|| {
11032 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
11033 })
11034 }
11035
11036 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
11037 where
11038 E: serde::de::Error,
11039 {
11040 match value {
11041 "SINK_LOG_STORE_TYPE_UNSPECIFIED" => Ok(SinkLogStoreType::Unspecified),
11042 "SINK_LOG_STORE_TYPE_KV_LOG_STORE" => Ok(SinkLogStoreType::KvLogStore),
11043 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE" => Ok(SinkLogStoreType::InMemoryLogStore),
11044 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
11045 }
11046 }
11047 }
11048 deserializer.deserialize_any(GeneratedVisitor)
11049 }
11050}
11051impl serde::Serialize for SinkNode {
11052 #[allow(deprecated)]
11053 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11054 where
11055 S: serde::Serializer,
11056 {
11057 use serde::ser::SerializeStruct;
11058 let mut len = 0;
11059 if self.sink_desc.is_some() {
11060 len += 1;
11061 }
11062 if self.table.is_some() {
11063 len += 1;
11064 }
11065 if self.log_store_type != 0 {
11066 len += 1;
11067 }
11068 if self.rate_limit.is_some() {
11069 len += 1;
11070 }
11071 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkNode", len)?;
11072 if let Some(v) = self.sink_desc.as_ref() {
11073 struct_ser.serialize_field("sinkDesc", v)?;
11074 }
11075 if let Some(v) = self.table.as_ref() {
11076 struct_ser.serialize_field("table", v)?;
11077 }
11078 if self.log_store_type != 0 {
11079 let v = SinkLogStoreType::try_from(self.log_store_type)
11080 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.log_store_type)))?;
11081 struct_ser.serialize_field("logStoreType", &v)?;
11082 }
11083 if let Some(v) = self.rate_limit.as_ref() {
11084 struct_ser.serialize_field("rateLimit", v)?;
11085 }
11086 struct_ser.end()
11087 }
11088}
11089impl<'de> serde::Deserialize<'de> for SinkNode {
11090 #[allow(deprecated)]
11091 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11092 where
11093 D: serde::Deserializer<'de>,
11094 {
11095 const FIELDS: &[&str] = &[
11096 "sink_desc",
11097 "sinkDesc",
11098 "table",
11099 "log_store_type",
11100 "logStoreType",
11101 "rate_limit",
11102 "rateLimit",
11103 ];
11104
11105 #[allow(clippy::enum_variant_names)]
11106 enum GeneratedField {
11107 SinkDesc,
11108 Table,
11109 LogStoreType,
11110 RateLimit,
11111 }
11112 impl<'de> serde::Deserialize<'de> for GeneratedField {
11113 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11114 where
11115 D: serde::Deserializer<'de>,
11116 {
11117 struct GeneratedVisitor;
11118
11119 impl serde::de::Visitor<'_> for GeneratedVisitor {
11120 type Value = GeneratedField;
11121
11122 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11123 write!(formatter, "expected one of: {:?}", &FIELDS)
11124 }
11125
11126 #[allow(unused_variables)]
11127 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11128 where
11129 E: serde::de::Error,
11130 {
11131 match value {
11132 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
11133 "table" => Ok(GeneratedField::Table),
11134 "logStoreType" | "log_store_type" => Ok(GeneratedField::LogStoreType),
11135 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11136 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11137 }
11138 }
11139 }
11140 deserializer.deserialize_identifier(GeneratedVisitor)
11141 }
11142 }
11143 struct GeneratedVisitor;
11144 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11145 type Value = SinkNode;
11146
11147 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11148 formatter.write_str("struct stream_plan.SinkNode")
11149 }
11150
11151 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkNode, V::Error>
11152 where
11153 V: serde::de::MapAccess<'de>,
11154 {
11155 let mut sink_desc__ = None;
11156 let mut table__ = None;
11157 let mut log_store_type__ = None;
11158 let mut rate_limit__ = None;
11159 while let Some(k) = map_.next_key()? {
11160 match k {
11161 GeneratedField::SinkDesc => {
11162 if sink_desc__.is_some() {
11163 return Err(serde::de::Error::duplicate_field("sinkDesc"));
11164 }
11165 sink_desc__ = map_.next_value()?;
11166 }
11167 GeneratedField::Table => {
11168 if table__.is_some() {
11169 return Err(serde::de::Error::duplicate_field("table"));
11170 }
11171 table__ = map_.next_value()?;
11172 }
11173 GeneratedField::LogStoreType => {
11174 if log_store_type__.is_some() {
11175 return Err(serde::de::Error::duplicate_field("logStoreType"));
11176 }
11177 log_store_type__ = Some(map_.next_value::<SinkLogStoreType>()? as i32);
11178 }
11179 GeneratedField::RateLimit => {
11180 if rate_limit__.is_some() {
11181 return Err(serde::de::Error::duplicate_field("rateLimit"));
11182 }
11183 rate_limit__ =
11184 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11185 ;
11186 }
11187 }
11188 }
11189 Ok(SinkNode {
11190 sink_desc: sink_desc__,
11191 table: table__,
11192 log_store_type: log_store_type__.unwrap_or_default(),
11193 rate_limit: rate_limit__,
11194 })
11195 }
11196 }
11197 deserializer.deserialize_struct("stream_plan.SinkNode", FIELDS, GeneratedVisitor)
11198 }
11199}
11200impl serde::Serialize for SinkSchemaChange {
11201 #[allow(deprecated)]
11202 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11203 where
11204 S: serde::Serializer,
11205 {
11206 use serde::ser::SerializeStruct;
11207 let mut len = 0;
11208 if !self.original_schema.is_empty() {
11209 len += 1;
11210 }
11211 if self.op.is_some() {
11212 len += 1;
11213 }
11214 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkSchemaChange", len)?;
11215 if !self.original_schema.is_empty() {
11216 struct_ser.serialize_field("originalSchema", &self.original_schema)?;
11217 }
11218 if let Some(v) = self.op.as_ref() {
11219 match v {
11220 sink_schema_change::Op::AddColumns(v) => {
11221 struct_ser.serialize_field("addColumns", v)?;
11222 }
11223 sink_schema_change::Op::DropColumns(v) => {
11224 struct_ser.serialize_field("dropColumns", v)?;
11225 }
11226 }
11227 }
11228 struct_ser.end()
11229 }
11230}
11231impl<'de> serde::Deserialize<'de> for SinkSchemaChange {
11232 #[allow(deprecated)]
11233 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11234 where
11235 D: serde::Deserializer<'de>,
11236 {
11237 const FIELDS: &[&str] = &[
11238 "original_schema",
11239 "originalSchema",
11240 "add_columns",
11241 "addColumns",
11242 "drop_columns",
11243 "dropColumns",
11244 ];
11245
11246 #[allow(clippy::enum_variant_names)]
11247 enum GeneratedField {
11248 OriginalSchema,
11249 AddColumns,
11250 DropColumns,
11251 }
11252 impl<'de> serde::Deserialize<'de> for GeneratedField {
11253 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11254 where
11255 D: serde::Deserializer<'de>,
11256 {
11257 struct GeneratedVisitor;
11258
11259 impl serde::de::Visitor<'_> for GeneratedVisitor {
11260 type Value = GeneratedField;
11261
11262 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11263 write!(formatter, "expected one of: {:?}", &FIELDS)
11264 }
11265
11266 #[allow(unused_variables)]
11267 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11268 where
11269 E: serde::de::Error,
11270 {
11271 match value {
11272 "originalSchema" | "original_schema" => Ok(GeneratedField::OriginalSchema),
11273 "addColumns" | "add_columns" => Ok(GeneratedField::AddColumns),
11274 "dropColumns" | "drop_columns" => Ok(GeneratedField::DropColumns),
11275 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11276 }
11277 }
11278 }
11279 deserializer.deserialize_identifier(GeneratedVisitor)
11280 }
11281 }
11282 struct GeneratedVisitor;
11283 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11284 type Value = SinkSchemaChange;
11285
11286 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11287 formatter.write_str("struct stream_plan.SinkSchemaChange")
11288 }
11289
11290 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkSchemaChange, V::Error>
11291 where
11292 V: serde::de::MapAccess<'de>,
11293 {
11294 let mut original_schema__ = None;
11295 let mut op__ = None;
11296 while let Some(k) = map_.next_key()? {
11297 match k {
11298 GeneratedField::OriginalSchema => {
11299 if original_schema__.is_some() {
11300 return Err(serde::de::Error::duplicate_field("originalSchema"));
11301 }
11302 original_schema__ = Some(map_.next_value()?);
11303 }
11304 GeneratedField::AddColumns => {
11305 if op__.is_some() {
11306 return Err(serde::de::Error::duplicate_field("addColumns"));
11307 }
11308 op__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_schema_change::Op::AddColumns)
11309;
11310 }
11311 GeneratedField::DropColumns => {
11312 if op__.is_some() {
11313 return Err(serde::de::Error::duplicate_field("dropColumns"));
11314 }
11315 op__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_schema_change::Op::DropColumns)
11316;
11317 }
11318 }
11319 }
11320 Ok(SinkSchemaChange {
11321 original_schema: original_schema__.unwrap_or_default(),
11322 op: op__,
11323 })
11324 }
11325 }
11326 deserializer.deserialize_struct("stream_plan.SinkSchemaChange", FIELDS, GeneratedVisitor)
11327 }
11328}
11329impl serde::Serialize for SortNode {
11330 #[allow(deprecated)]
11331 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11332 where
11333 S: serde::Serializer,
11334 {
11335 use serde::ser::SerializeStruct;
11336 let mut len = 0;
11337 if self.state_table.is_some() {
11338 len += 1;
11339 }
11340 if self.sort_column_index != 0 {
11341 len += 1;
11342 }
11343 let mut struct_ser = serializer.serialize_struct("stream_plan.SortNode", len)?;
11344 if let Some(v) = self.state_table.as_ref() {
11345 struct_ser.serialize_field("stateTable", v)?;
11346 }
11347 if self.sort_column_index != 0 {
11348 struct_ser.serialize_field("sortColumnIndex", &self.sort_column_index)?;
11349 }
11350 struct_ser.end()
11351 }
11352}
11353impl<'de> serde::Deserialize<'de> for SortNode {
11354 #[allow(deprecated)]
11355 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11356 where
11357 D: serde::Deserializer<'de>,
11358 {
11359 const FIELDS: &[&str] = &[
11360 "state_table",
11361 "stateTable",
11362 "sort_column_index",
11363 "sortColumnIndex",
11364 ];
11365
11366 #[allow(clippy::enum_variant_names)]
11367 enum GeneratedField {
11368 StateTable,
11369 SortColumnIndex,
11370 }
11371 impl<'de> serde::Deserialize<'de> for GeneratedField {
11372 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11373 where
11374 D: serde::Deserializer<'de>,
11375 {
11376 struct GeneratedVisitor;
11377
11378 impl serde::de::Visitor<'_> for GeneratedVisitor {
11379 type Value = GeneratedField;
11380
11381 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11382 write!(formatter, "expected one of: {:?}", &FIELDS)
11383 }
11384
11385 #[allow(unused_variables)]
11386 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11387 where
11388 E: serde::de::Error,
11389 {
11390 match value {
11391 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11392 "sortColumnIndex" | "sort_column_index" => Ok(GeneratedField::SortColumnIndex),
11393 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11394 }
11395 }
11396 }
11397 deserializer.deserialize_identifier(GeneratedVisitor)
11398 }
11399 }
11400 struct GeneratedVisitor;
11401 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11402 type Value = SortNode;
11403
11404 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11405 formatter.write_str("struct stream_plan.SortNode")
11406 }
11407
11408 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
11409 where
11410 V: serde::de::MapAccess<'de>,
11411 {
11412 let mut state_table__ = None;
11413 let mut sort_column_index__ = None;
11414 while let Some(k) = map_.next_key()? {
11415 match k {
11416 GeneratedField::StateTable => {
11417 if state_table__.is_some() {
11418 return Err(serde::de::Error::duplicate_field("stateTable"));
11419 }
11420 state_table__ = map_.next_value()?;
11421 }
11422 GeneratedField::SortColumnIndex => {
11423 if sort_column_index__.is_some() {
11424 return Err(serde::de::Error::duplicate_field("sortColumnIndex"));
11425 }
11426 sort_column_index__ =
11427 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11428 ;
11429 }
11430 }
11431 }
11432 Ok(SortNode {
11433 state_table: state_table__,
11434 sort_column_index: sort_column_index__.unwrap_or_default(),
11435 })
11436 }
11437 }
11438 deserializer.deserialize_struct("stream_plan.SortNode", FIELDS, GeneratedVisitor)
11439 }
11440}
11441impl serde::Serialize for SourceBackfillNode {
11442 #[allow(deprecated)]
11443 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11444 where
11445 S: serde::Serializer,
11446 {
11447 use serde::ser::SerializeStruct;
11448 let mut len = 0;
11449 if self.upstream_source_id != 0 {
11450 len += 1;
11451 }
11452 if self.row_id_index.is_some() {
11453 len += 1;
11454 }
11455 if !self.columns.is_empty() {
11456 len += 1;
11457 }
11458 if self.info.is_some() {
11459 len += 1;
11460 }
11461 if !self.source_name.is_empty() {
11462 len += 1;
11463 }
11464 if !self.with_properties.is_empty() {
11465 len += 1;
11466 }
11467 if self.rate_limit.is_some() {
11468 len += 1;
11469 }
11470 if self.state_table.is_some() {
11471 len += 1;
11472 }
11473 if !self.secret_refs.is_empty() {
11474 len += 1;
11475 }
11476 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceBackfillNode", len)?;
11477 if self.upstream_source_id != 0 {
11478 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
11479 }
11480 if let Some(v) = self.row_id_index.as_ref() {
11481 struct_ser.serialize_field("rowIdIndex", v)?;
11482 }
11483 if !self.columns.is_empty() {
11484 struct_ser.serialize_field("columns", &self.columns)?;
11485 }
11486 if let Some(v) = self.info.as_ref() {
11487 struct_ser.serialize_field("info", v)?;
11488 }
11489 if !self.source_name.is_empty() {
11490 struct_ser.serialize_field("sourceName", &self.source_name)?;
11491 }
11492 if !self.with_properties.is_empty() {
11493 struct_ser.serialize_field("withProperties", &self.with_properties)?;
11494 }
11495 if let Some(v) = self.rate_limit.as_ref() {
11496 struct_ser.serialize_field("rateLimit", v)?;
11497 }
11498 if let Some(v) = self.state_table.as_ref() {
11499 struct_ser.serialize_field("stateTable", v)?;
11500 }
11501 if !self.secret_refs.is_empty() {
11502 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
11503 }
11504 struct_ser.end()
11505 }
11506}
11507impl<'de> serde::Deserialize<'de> for SourceBackfillNode {
11508 #[allow(deprecated)]
11509 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11510 where
11511 D: serde::Deserializer<'de>,
11512 {
11513 const FIELDS: &[&str] = &[
11514 "upstream_source_id",
11515 "upstreamSourceId",
11516 "row_id_index",
11517 "rowIdIndex",
11518 "columns",
11519 "info",
11520 "source_name",
11521 "sourceName",
11522 "with_properties",
11523 "withProperties",
11524 "rate_limit",
11525 "rateLimit",
11526 "state_table",
11527 "stateTable",
11528 "secret_refs",
11529 "secretRefs",
11530 ];
11531
11532 #[allow(clippy::enum_variant_names)]
11533 enum GeneratedField {
11534 UpstreamSourceId,
11535 RowIdIndex,
11536 Columns,
11537 Info,
11538 SourceName,
11539 WithProperties,
11540 RateLimit,
11541 StateTable,
11542 SecretRefs,
11543 }
11544 impl<'de> serde::Deserialize<'de> for GeneratedField {
11545 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11546 where
11547 D: serde::Deserializer<'de>,
11548 {
11549 struct GeneratedVisitor;
11550
11551 impl serde::de::Visitor<'_> for GeneratedVisitor {
11552 type Value = GeneratedField;
11553
11554 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11555 write!(formatter, "expected one of: {:?}", &FIELDS)
11556 }
11557
11558 #[allow(unused_variables)]
11559 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11560 where
11561 E: serde::de::Error,
11562 {
11563 match value {
11564 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
11565 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
11566 "columns" => Ok(GeneratedField::Columns),
11567 "info" => Ok(GeneratedField::Info),
11568 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
11569 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
11570 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11571 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11572 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
11573 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11574 }
11575 }
11576 }
11577 deserializer.deserialize_identifier(GeneratedVisitor)
11578 }
11579 }
11580 struct GeneratedVisitor;
11581 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11582 type Value = SourceBackfillNode;
11583
11584 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11585 formatter.write_str("struct stream_plan.SourceBackfillNode")
11586 }
11587
11588 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceBackfillNode, V::Error>
11589 where
11590 V: serde::de::MapAccess<'de>,
11591 {
11592 let mut upstream_source_id__ = None;
11593 let mut row_id_index__ = None;
11594 let mut columns__ = None;
11595 let mut info__ = None;
11596 let mut source_name__ = None;
11597 let mut with_properties__ = None;
11598 let mut rate_limit__ = None;
11599 let mut state_table__ = None;
11600 let mut secret_refs__ = None;
11601 while let Some(k) = map_.next_key()? {
11602 match k {
11603 GeneratedField::UpstreamSourceId => {
11604 if upstream_source_id__.is_some() {
11605 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
11606 }
11607 upstream_source_id__ =
11608 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11609 ;
11610 }
11611 GeneratedField::RowIdIndex => {
11612 if row_id_index__.is_some() {
11613 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
11614 }
11615 row_id_index__ =
11616 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11617 ;
11618 }
11619 GeneratedField::Columns => {
11620 if columns__.is_some() {
11621 return Err(serde::de::Error::duplicate_field("columns"));
11622 }
11623 columns__ = Some(map_.next_value()?);
11624 }
11625 GeneratedField::Info => {
11626 if info__.is_some() {
11627 return Err(serde::de::Error::duplicate_field("info"));
11628 }
11629 info__ = map_.next_value()?;
11630 }
11631 GeneratedField::SourceName => {
11632 if source_name__.is_some() {
11633 return Err(serde::de::Error::duplicate_field("sourceName"));
11634 }
11635 source_name__ = Some(map_.next_value()?);
11636 }
11637 GeneratedField::WithProperties => {
11638 if with_properties__.is_some() {
11639 return Err(serde::de::Error::duplicate_field("withProperties"));
11640 }
11641 with_properties__ = Some(
11642 map_.next_value::<std::collections::BTreeMap<_, _>>()?
11643 );
11644 }
11645 GeneratedField::RateLimit => {
11646 if rate_limit__.is_some() {
11647 return Err(serde::de::Error::duplicate_field("rateLimit"));
11648 }
11649 rate_limit__ =
11650 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11651 ;
11652 }
11653 GeneratedField::StateTable => {
11654 if state_table__.is_some() {
11655 return Err(serde::de::Error::duplicate_field("stateTable"));
11656 }
11657 state_table__ = map_.next_value()?;
11658 }
11659 GeneratedField::SecretRefs => {
11660 if secret_refs__.is_some() {
11661 return Err(serde::de::Error::duplicate_field("secretRefs"));
11662 }
11663 secret_refs__ = Some(
11664 map_.next_value::<std::collections::BTreeMap<_, _>>()?
11665 );
11666 }
11667 }
11668 }
11669 Ok(SourceBackfillNode {
11670 upstream_source_id: upstream_source_id__.unwrap_or_default(),
11671 row_id_index: row_id_index__,
11672 columns: columns__.unwrap_or_default(),
11673 info: info__,
11674 source_name: source_name__.unwrap_or_default(),
11675 with_properties: with_properties__.unwrap_or_default(),
11676 rate_limit: rate_limit__,
11677 state_table: state_table__,
11678 secret_refs: secret_refs__.unwrap_or_default(),
11679 })
11680 }
11681 }
11682 deserializer.deserialize_struct("stream_plan.SourceBackfillNode", FIELDS, GeneratedVisitor)
11683 }
11684}
11685impl serde::Serialize for SourceChangeSplitMutation {
11686 #[allow(deprecated)]
11687 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11688 where
11689 S: serde::Serializer,
11690 {
11691 use serde::ser::SerializeStruct;
11692 let mut len = 0;
11693 if !self.actor_splits.is_empty() {
11694 len += 1;
11695 }
11696 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceChangeSplitMutation", len)?;
11697 if !self.actor_splits.is_empty() {
11698 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
11699 }
11700 struct_ser.end()
11701 }
11702}
11703impl<'de> serde::Deserialize<'de> for SourceChangeSplitMutation {
11704 #[allow(deprecated)]
11705 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11706 where
11707 D: serde::Deserializer<'de>,
11708 {
11709 const FIELDS: &[&str] = &[
11710 "actor_splits",
11711 "actorSplits",
11712 ];
11713
11714 #[allow(clippy::enum_variant_names)]
11715 enum GeneratedField {
11716 ActorSplits,
11717 }
11718 impl<'de> serde::Deserialize<'de> for GeneratedField {
11719 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11720 where
11721 D: serde::Deserializer<'de>,
11722 {
11723 struct GeneratedVisitor;
11724
11725 impl serde::de::Visitor<'_> for GeneratedVisitor {
11726 type Value = GeneratedField;
11727
11728 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11729 write!(formatter, "expected one of: {:?}", &FIELDS)
11730 }
11731
11732 #[allow(unused_variables)]
11733 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11734 where
11735 E: serde::de::Error,
11736 {
11737 match value {
11738 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
11739 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11740 }
11741 }
11742 }
11743 deserializer.deserialize_identifier(GeneratedVisitor)
11744 }
11745 }
11746 struct GeneratedVisitor;
11747 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11748 type Value = SourceChangeSplitMutation;
11749
11750 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11751 formatter.write_str("struct stream_plan.SourceChangeSplitMutation")
11752 }
11753
11754 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceChangeSplitMutation, V::Error>
11755 where
11756 V: serde::de::MapAccess<'de>,
11757 {
11758 let mut actor_splits__ = None;
11759 while let Some(k) = map_.next_key()? {
11760 match k {
11761 GeneratedField::ActorSplits => {
11762 if actor_splits__.is_some() {
11763 return Err(serde::de::Error::duplicate_field("actorSplits"));
11764 }
11765 actor_splits__ = Some(
11766 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11767 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
11768 );
11769 }
11770 }
11771 }
11772 Ok(SourceChangeSplitMutation {
11773 actor_splits: actor_splits__.unwrap_or_default(),
11774 })
11775 }
11776 }
11777 deserializer.deserialize_struct("stream_plan.SourceChangeSplitMutation", FIELDS, GeneratedVisitor)
11778 }
11779}
11780impl serde::Serialize for SourceNode {
11781 #[allow(deprecated)]
11782 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11783 where
11784 S: serde::Serializer,
11785 {
11786 use serde::ser::SerializeStruct;
11787 let mut len = 0;
11788 if self.source_inner.is_some() {
11789 len += 1;
11790 }
11791 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceNode", len)?;
11792 if let Some(v) = self.source_inner.as_ref() {
11793 struct_ser.serialize_field("sourceInner", v)?;
11794 }
11795 struct_ser.end()
11796 }
11797}
11798impl<'de> serde::Deserialize<'de> for SourceNode {
11799 #[allow(deprecated)]
11800 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11801 where
11802 D: serde::Deserializer<'de>,
11803 {
11804 const FIELDS: &[&str] = &[
11805 "source_inner",
11806 "sourceInner",
11807 ];
11808
11809 #[allow(clippy::enum_variant_names)]
11810 enum GeneratedField {
11811 SourceInner,
11812 }
11813 impl<'de> serde::Deserialize<'de> for GeneratedField {
11814 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11815 where
11816 D: serde::Deserializer<'de>,
11817 {
11818 struct GeneratedVisitor;
11819
11820 impl serde::de::Visitor<'_> for GeneratedVisitor {
11821 type Value = GeneratedField;
11822
11823 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11824 write!(formatter, "expected one of: {:?}", &FIELDS)
11825 }
11826
11827 #[allow(unused_variables)]
11828 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11829 where
11830 E: serde::de::Error,
11831 {
11832 match value {
11833 "sourceInner" | "source_inner" => Ok(GeneratedField::SourceInner),
11834 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11835 }
11836 }
11837 }
11838 deserializer.deserialize_identifier(GeneratedVisitor)
11839 }
11840 }
11841 struct GeneratedVisitor;
11842 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11843 type Value = SourceNode;
11844
11845 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11846 formatter.write_str("struct stream_plan.SourceNode")
11847 }
11848
11849 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
11850 where
11851 V: serde::de::MapAccess<'de>,
11852 {
11853 let mut source_inner__ = None;
11854 while let Some(k) = map_.next_key()? {
11855 match k {
11856 GeneratedField::SourceInner => {
11857 if source_inner__.is_some() {
11858 return Err(serde::de::Error::duplicate_field("sourceInner"));
11859 }
11860 source_inner__ = map_.next_value()?;
11861 }
11862 }
11863 }
11864 Ok(SourceNode {
11865 source_inner: source_inner__,
11866 })
11867 }
11868 }
11869 deserializer.deserialize_struct("stream_plan.SourceNode", FIELDS, GeneratedVisitor)
11870 }
11871}
11872impl serde::Serialize for StartFragmentBackfillMutation {
11873 #[allow(deprecated)]
11874 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11875 where
11876 S: serde::Serializer,
11877 {
11878 use serde::ser::SerializeStruct;
11879 let mut len = 0;
11880 if !self.fragment_ids.is_empty() {
11881 len += 1;
11882 }
11883 let mut struct_ser = serializer.serialize_struct("stream_plan.StartFragmentBackfillMutation", len)?;
11884 if !self.fragment_ids.is_empty() {
11885 struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
11886 }
11887 struct_ser.end()
11888 }
11889}
11890impl<'de> serde::Deserialize<'de> for StartFragmentBackfillMutation {
11891 #[allow(deprecated)]
11892 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11893 where
11894 D: serde::Deserializer<'de>,
11895 {
11896 const FIELDS: &[&str] = &[
11897 "fragment_ids",
11898 "fragmentIds",
11899 ];
11900
11901 #[allow(clippy::enum_variant_names)]
11902 enum GeneratedField {
11903 FragmentIds,
11904 }
11905 impl<'de> serde::Deserialize<'de> for GeneratedField {
11906 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11907 where
11908 D: serde::Deserializer<'de>,
11909 {
11910 struct GeneratedVisitor;
11911
11912 impl serde::de::Visitor<'_> for GeneratedVisitor {
11913 type Value = GeneratedField;
11914
11915 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11916 write!(formatter, "expected one of: {:?}", &FIELDS)
11917 }
11918
11919 #[allow(unused_variables)]
11920 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11921 where
11922 E: serde::de::Error,
11923 {
11924 match value {
11925 "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
11926 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11927 }
11928 }
11929 }
11930 deserializer.deserialize_identifier(GeneratedVisitor)
11931 }
11932 }
11933 struct GeneratedVisitor;
11934 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11935 type Value = StartFragmentBackfillMutation;
11936
11937 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11938 formatter.write_str("struct stream_plan.StartFragmentBackfillMutation")
11939 }
11940
11941 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StartFragmentBackfillMutation, V::Error>
11942 where
11943 V: serde::de::MapAccess<'de>,
11944 {
11945 let mut fragment_ids__ = None;
11946 while let Some(k) = map_.next_key()? {
11947 match k {
11948 GeneratedField::FragmentIds => {
11949 if fragment_ids__.is_some() {
11950 return Err(serde::de::Error::duplicate_field("fragmentIds"));
11951 }
11952 fragment_ids__ =
11953 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11954 .into_iter().map(|x| x.0).collect())
11955 ;
11956 }
11957 }
11958 }
11959 Ok(StartFragmentBackfillMutation {
11960 fragment_ids: fragment_ids__.unwrap_or_default(),
11961 })
11962 }
11963 }
11964 deserializer.deserialize_struct("stream_plan.StartFragmentBackfillMutation", FIELDS, GeneratedVisitor)
11965 }
11966}
11967impl serde::Serialize for StopMutation {
11968 #[allow(deprecated)]
11969 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11970 where
11971 S: serde::Serializer,
11972 {
11973 use serde::ser::SerializeStruct;
11974 let mut len = 0;
11975 if !self.actors.is_empty() {
11976 len += 1;
11977 }
11978 if !self.dropped_sink_fragments.is_empty() {
11979 len += 1;
11980 }
11981 let mut struct_ser = serializer.serialize_struct("stream_plan.StopMutation", len)?;
11982 if !self.actors.is_empty() {
11983 struct_ser.serialize_field("actors", &self.actors)?;
11984 }
11985 if !self.dropped_sink_fragments.is_empty() {
11986 struct_ser.serialize_field("droppedSinkFragments", &self.dropped_sink_fragments)?;
11987 }
11988 struct_ser.end()
11989 }
11990}
11991impl<'de> serde::Deserialize<'de> for StopMutation {
11992 #[allow(deprecated)]
11993 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11994 where
11995 D: serde::Deserializer<'de>,
11996 {
11997 const FIELDS: &[&str] = &[
11998 "actors",
11999 "dropped_sink_fragments",
12000 "droppedSinkFragments",
12001 ];
12002
12003 #[allow(clippy::enum_variant_names)]
12004 enum GeneratedField {
12005 Actors,
12006 DroppedSinkFragments,
12007 }
12008 impl<'de> serde::Deserialize<'de> for GeneratedField {
12009 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12010 where
12011 D: serde::Deserializer<'de>,
12012 {
12013 struct GeneratedVisitor;
12014
12015 impl serde::de::Visitor<'_> for GeneratedVisitor {
12016 type Value = GeneratedField;
12017
12018 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12019 write!(formatter, "expected one of: {:?}", &FIELDS)
12020 }
12021
12022 #[allow(unused_variables)]
12023 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12024 where
12025 E: serde::de::Error,
12026 {
12027 match value {
12028 "actors" => Ok(GeneratedField::Actors),
12029 "droppedSinkFragments" | "dropped_sink_fragments" => Ok(GeneratedField::DroppedSinkFragments),
12030 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12031 }
12032 }
12033 }
12034 deserializer.deserialize_identifier(GeneratedVisitor)
12035 }
12036 }
12037 struct GeneratedVisitor;
12038 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12039 type Value = StopMutation;
12040
12041 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12042 formatter.write_str("struct stream_plan.StopMutation")
12043 }
12044
12045 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopMutation, V::Error>
12046 where
12047 V: serde::de::MapAccess<'de>,
12048 {
12049 let mut actors__ = None;
12050 let mut dropped_sink_fragments__ = None;
12051 while let Some(k) = map_.next_key()? {
12052 match k {
12053 GeneratedField::Actors => {
12054 if actors__.is_some() {
12055 return Err(serde::de::Error::duplicate_field("actors"));
12056 }
12057 actors__ =
12058 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12059 .into_iter().map(|x| x.0).collect())
12060 ;
12061 }
12062 GeneratedField::DroppedSinkFragments => {
12063 if dropped_sink_fragments__.is_some() {
12064 return Err(serde::de::Error::duplicate_field("droppedSinkFragments"));
12065 }
12066 dropped_sink_fragments__ =
12067 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12068 .into_iter().map(|x| x.0).collect())
12069 ;
12070 }
12071 }
12072 }
12073 Ok(StopMutation {
12074 actors: actors__.unwrap_or_default(),
12075 dropped_sink_fragments: dropped_sink_fragments__.unwrap_or_default(),
12076 })
12077 }
12078 }
12079 deserializer.deserialize_struct("stream_plan.StopMutation", FIELDS, GeneratedVisitor)
12080 }
12081}
12082impl serde::Serialize for StreamActor {
12083 #[allow(deprecated)]
12084 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12085 where
12086 S: serde::Serializer,
12087 {
12088 use serde::ser::SerializeStruct;
12089 let mut len = 0;
12090 if self.actor_id != 0 {
12091 len += 1;
12092 }
12093 if self.fragment_id != 0 {
12094 len += 1;
12095 }
12096 if !self.dispatcher.is_empty() {
12097 len += 1;
12098 }
12099 if self.vnode_bitmap.is_some() {
12100 len += 1;
12101 }
12102 if !self.mview_definition.is_empty() {
12103 len += 1;
12104 }
12105 if self.expr_context.is_some() {
12106 len += 1;
12107 }
12108 if !self.config_override.is_empty() {
12109 len += 1;
12110 }
12111 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamActor", len)?;
12112 if self.actor_id != 0 {
12113 struct_ser.serialize_field("actorId", &self.actor_id)?;
12114 }
12115 if self.fragment_id != 0 {
12116 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
12117 }
12118 if !self.dispatcher.is_empty() {
12119 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
12120 }
12121 if let Some(v) = self.vnode_bitmap.as_ref() {
12122 struct_ser.serialize_field("vnodeBitmap", v)?;
12123 }
12124 if !self.mview_definition.is_empty() {
12125 struct_ser.serialize_field("mviewDefinition", &self.mview_definition)?;
12126 }
12127 if let Some(v) = self.expr_context.as_ref() {
12128 struct_ser.serialize_field("exprContext", v)?;
12129 }
12130 if !self.config_override.is_empty() {
12131 struct_ser.serialize_field("configOverride", &self.config_override)?;
12132 }
12133 struct_ser.end()
12134 }
12135}
12136impl<'de> serde::Deserialize<'de> for StreamActor {
12137 #[allow(deprecated)]
12138 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12139 where
12140 D: serde::Deserializer<'de>,
12141 {
12142 const FIELDS: &[&str] = &[
12143 "actor_id",
12144 "actorId",
12145 "fragment_id",
12146 "fragmentId",
12147 "dispatcher",
12148 "vnode_bitmap",
12149 "vnodeBitmap",
12150 "mview_definition",
12151 "mviewDefinition",
12152 "expr_context",
12153 "exprContext",
12154 "config_override",
12155 "configOverride",
12156 ];
12157
12158 #[allow(clippy::enum_variant_names)]
12159 enum GeneratedField {
12160 ActorId,
12161 FragmentId,
12162 Dispatcher,
12163 VnodeBitmap,
12164 MviewDefinition,
12165 ExprContext,
12166 ConfigOverride,
12167 }
12168 impl<'de> serde::Deserialize<'de> for GeneratedField {
12169 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12170 where
12171 D: serde::Deserializer<'de>,
12172 {
12173 struct GeneratedVisitor;
12174
12175 impl serde::de::Visitor<'_> for GeneratedVisitor {
12176 type Value = GeneratedField;
12177
12178 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12179 write!(formatter, "expected one of: {:?}", &FIELDS)
12180 }
12181
12182 #[allow(unused_variables)]
12183 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12184 where
12185 E: serde::de::Error,
12186 {
12187 match value {
12188 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
12189 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
12190 "dispatcher" => Ok(GeneratedField::Dispatcher),
12191 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
12192 "mviewDefinition" | "mview_definition" => Ok(GeneratedField::MviewDefinition),
12193 "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
12194 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
12195 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12196 }
12197 }
12198 }
12199 deserializer.deserialize_identifier(GeneratedVisitor)
12200 }
12201 }
12202 struct GeneratedVisitor;
12203 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12204 type Value = StreamActor;
12205
12206 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12207 formatter.write_str("struct stream_plan.StreamActor")
12208 }
12209
12210 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamActor, V::Error>
12211 where
12212 V: serde::de::MapAccess<'de>,
12213 {
12214 let mut actor_id__ = None;
12215 let mut fragment_id__ = None;
12216 let mut dispatcher__ = None;
12217 let mut vnode_bitmap__ = None;
12218 let mut mview_definition__ = None;
12219 let mut expr_context__ = None;
12220 let mut config_override__ = None;
12221 while let Some(k) = map_.next_key()? {
12222 match k {
12223 GeneratedField::ActorId => {
12224 if actor_id__.is_some() {
12225 return Err(serde::de::Error::duplicate_field("actorId"));
12226 }
12227 actor_id__ =
12228 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12229 ;
12230 }
12231 GeneratedField::FragmentId => {
12232 if fragment_id__.is_some() {
12233 return Err(serde::de::Error::duplicate_field("fragmentId"));
12234 }
12235 fragment_id__ =
12236 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12237 ;
12238 }
12239 GeneratedField::Dispatcher => {
12240 if dispatcher__.is_some() {
12241 return Err(serde::de::Error::duplicate_field("dispatcher"));
12242 }
12243 dispatcher__ = Some(map_.next_value()?);
12244 }
12245 GeneratedField::VnodeBitmap => {
12246 if vnode_bitmap__.is_some() {
12247 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
12248 }
12249 vnode_bitmap__ = map_.next_value()?;
12250 }
12251 GeneratedField::MviewDefinition => {
12252 if mview_definition__.is_some() {
12253 return Err(serde::de::Error::duplicate_field("mviewDefinition"));
12254 }
12255 mview_definition__ = Some(map_.next_value()?);
12256 }
12257 GeneratedField::ExprContext => {
12258 if expr_context__.is_some() {
12259 return Err(serde::de::Error::duplicate_field("exprContext"));
12260 }
12261 expr_context__ = map_.next_value()?;
12262 }
12263 GeneratedField::ConfigOverride => {
12264 if config_override__.is_some() {
12265 return Err(serde::de::Error::duplicate_field("configOverride"));
12266 }
12267 config_override__ = Some(map_.next_value()?);
12268 }
12269 }
12270 }
12271 Ok(StreamActor {
12272 actor_id: actor_id__.unwrap_or_default(),
12273 fragment_id: fragment_id__.unwrap_or_default(),
12274 dispatcher: dispatcher__.unwrap_or_default(),
12275 vnode_bitmap: vnode_bitmap__,
12276 mview_definition: mview_definition__.unwrap_or_default(),
12277 expr_context: expr_context__,
12278 config_override: config_override__.unwrap_or_default(),
12279 })
12280 }
12281 }
12282 deserializer.deserialize_struct("stream_plan.StreamActor", FIELDS, GeneratedVisitor)
12283 }
12284}
12285impl serde::Serialize for StreamCdcScanNode {
12286 #[allow(deprecated)]
12287 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12288 where
12289 S: serde::Serializer,
12290 {
12291 use serde::ser::SerializeStruct;
12292 let mut len = 0;
12293 if self.table_id != 0 {
12294 len += 1;
12295 }
12296 if !self.upstream_column_ids.is_empty() {
12297 len += 1;
12298 }
12299 if !self.output_indices.is_empty() {
12300 len += 1;
12301 }
12302 if self.state_table.is_some() {
12303 len += 1;
12304 }
12305 if self.cdc_table_desc.is_some() {
12306 len += 1;
12307 }
12308 if self.rate_limit.is_some() {
12309 len += 1;
12310 }
12311 if self.disable_backfill {
12312 len += 1;
12313 }
12314 if self.options.is_some() {
12315 len += 1;
12316 }
12317 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanNode", len)?;
12318 if self.table_id != 0 {
12319 struct_ser.serialize_field("tableId", &self.table_id)?;
12320 }
12321 if !self.upstream_column_ids.is_empty() {
12322 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
12323 }
12324 if !self.output_indices.is_empty() {
12325 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
12326 }
12327 if let Some(v) = self.state_table.as_ref() {
12328 struct_ser.serialize_field("stateTable", v)?;
12329 }
12330 if let Some(v) = self.cdc_table_desc.as_ref() {
12331 struct_ser.serialize_field("cdcTableDesc", v)?;
12332 }
12333 if let Some(v) = self.rate_limit.as_ref() {
12334 struct_ser.serialize_field("rateLimit", v)?;
12335 }
12336 if self.disable_backfill {
12337 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
12338 }
12339 if let Some(v) = self.options.as_ref() {
12340 struct_ser.serialize_field("options", v)?;
12341 }
12342 struct_ser.end()
12343 }
12344}
12345impl<'de> serde::Deserialize<'de> for StreamCdcScanNode {
12346 #[allow(deprecated)]
12347 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12348 where
12349 D: serde::Deserializer<'de>,
12350 {
12351 const FIELDS: &[&str] = &[
12352 "table_id",
12353 "tableId",
12354 "upstream_column_ids",
12355 "upstreamColumnIds",
12356 "output_indices",
12357 "outputIndices",
12358 "state_table",
12359 "stateTable",
12360 "cdc_table_desc",
12361 "cdcTableDesc",
12362 "rate_limit",
12363 "rateLimit",
12364 "disable_backfill",
12365 "disableBackfill",
12366 "options",
12367 ];
12368
12369 #[allow(clippy::enum_variant_names)]
12370 enum GeneratedField {
12371 TableId,
12372 UpstreamColumnIds,
12373 OutputIndices,
12374 StateTable,
12375 CdcTableDesc,
12376 RateLimit,
12377 DisableBackfill,
12378 Options,
12379 }
12380 impl<'de> serde::Deserialize<'de> for GeneratedField {
12381 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12382 where
12383 D: serde::Deserializer<'de>,
12384 {
12385 struct GeneratedVisitor;
12386
12387 impl serde::de::Visitor<'_> for GeneratedVisitor {
12388 type Value = GeneratedField;
12389
12390 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12391 write!(formatter, "expected one of: {:?}", &FIELDS)
12392 }
12393
12394 #[allow(unused_variables)]
12395 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12396 where
12397 E: serde::de::Error,
12398 {
12399 match value {
12400 "tableId" | "table_id" => Ok(GeneratedField::TableId),
12401 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
12402 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
12403 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
12404 "cdcTableDesc" | "cdc_table_desc" => Ok(GeneratedField::CdcTableDesc),
12405 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
12406 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
12407 "options" => Ok(GeneratedField::Options),
12408 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12409 }
12410 }
12411 }
12412 deserializer.deserialize_identifier(GeneratedVisitor)
12413 }
12414 }
12415 struct GeneratedVisitor;
12416 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12417 type Value = StreamCdcScanNode;
12418
12419 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12420 formatter.write_str("struct stream_plan.StreamCdcScanNode")
12421 }
12422
12423 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanNode, V::Error>
12424 where
12425 V: serde::de::MapAccess<'de>,
12426 {
12427 let mut table_id__ = None;
12428 let mut upstream_column_ids__ = None;
12429 let mut output_indices__ = None;
12430 let mut state_table__ = None;
12431 let mut cdc_table_desc__ = None;
12432 let mut rate_limit__ = None;
12433 let mut disable_backfill__ = None;
12434 let mut options__ = None;
12435 while let Some(k) = map_.next_key()? {
12436 match k {
12437 GeneratedField::TableId => {
12438 if table_id__.is_some() {
12439 return Err(serde::de::Error::duplicate_field("tableId"));
12440 }
12441 table_id__ =
12442 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12443 ;
12444 }
12445 GeneratedField::UpstreamColumnIds => {
12446 if upstream_column_ids__.is_some() {
12447 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
12448 }
12449 upstream_column_ids__ =
12450 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12451 .into_iter().map(|x| x.0).collect())
12452 ;
12453 }
12454 GeneratedField::OutputIndices => {
12455 if output_indices__.is_some() {
12456 return Err(serde::de::Error::duplicate_field("outputIndices"));
12457 }
12458 output_indices__ =
12459 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12460 .into_iter().map(|x| x.0).collect())
12461 ;
12462 }
12463 GeneratedField::StateTable => {
12464 if state_table__.is_some() {
12465 return Err(serde::de::Error::duplicate_field("stateTable"));
12466 }
12467 state_table__ = map_.next_value()?;
12468 }
12469 GeneratedField::CdcTableDesc => {
12470 if cdc_table_desc__.is_some() {
12471 return Err(serde::de::Error::duplicate_field("cdcTableDesc"));
12472 }
12473 cdc_table_desc__ = map_.next_value()?;
12474 }
12475 GeneratedField::RateLimit => {
12476 if rate_limit__.is_some() {
12477 return Err(serde::de::Error::duplicate_field("rateLimit"));
12478 }
12479 rate_limit__ =
12480 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12481 ;
12482 }
12483 GeneratedField::DisableBackfill => {
12484 if disable_backfill__.is_some() {
12485 return Err(serde::de::Error::duplicate_field("disableBackfill"));
12486 }
12487 disable_backfill__ = Some(map_.next_value()?);
12488 }
12489 GeneratedField::Options => {
12490 if options__.is_some() {
12491 return Err(serde::de::Error::duplicate_field("options"));
12492 }
12493 options__ = map_.next_value()?;
12494 }
12495 }
12496 }
12497 Ok(StreamCdcScanNode {
12498 table_id: table_id__.unwrap_or_default(),
12499 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
12500 output_indices: output_indices__.unwrap_or_default(),
12501 state_table: state_table__,
12502 cdc_table_desc: cdc_table_desc__,
12503 rate_limit: rate_limit__,
12504 disable_backfill: disable_backfill__.unwrap_or_default(),
12505 options: options__,
12506 })
12507 }
12508 }
12509 deserializer.deserialize_struct("stream_plan.StreamCdcScanNode", FIELDS, GeneratedVisitor)
12510 }
12511}
12512impl serde::Serialize for StreamCdcScanOptions {
12513 #[allow(deprecated)]
12514 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12515 where
12516 S: serde::Serializer,
12517 {
12518 use serde::ser::SerializeStruct;
12519 let mut len = 0;
12520 if self.disable_backfill {
12521 len += 1;
12522 }
12523 if self.snapshot_barrier_interval != 0 {
12524 len += 1;
12525 }
12526 if self.snapshot_batch_size != 0 {
12527 len += 1;
12528 }
12529 if self.backfill_parallelism != 0 {
12530 len += 1;
12531 }
12532 if self.backfill_num_rows_per_split != 0 {
12533 len += 1;
12534 }
12535 if self.backfill_as_even_splits {
12536 len += 1;
12537 }
12538 if self.backfill_split_pk_column_index != 0 {
12539 len += 1;
12540 }
12541 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanOptions", len)?;
12542 if self.disable_backfill {
12543 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
12544 }
12545 if self.snapshot_barrier_interval != 0 {
12546 struct_ser.serialize_field("snapshotBarrierInterval", &self.snapshot_barrier_interval)?;
12547 }
12548 if self.snapshot_batch_size != 0 {
12549 struct_ser.serialize_field("snapshotBatchSize", &self.snapshot_batch_size)?;
12550 }
12551 if self.backfill_parallelism != 0 {
12552 struct_ser.serialize_field("backfillParallelism", &self.backfill_parallelism)?;
12553 }
12554 if self.backfill_num_rows_per_split != 0 {
12555 #[allow(clippy::needless_borrow)]
12556 #[allow(clippy::needless_borrows_for_generic_args)]
12557 struct_ser.serialize_field("backfillNumRowsPerSplit", ToString::to_string(&self.backfill_num_rows_per_split).as_str())?;
12558 }
12559 if self.backfill_as_even_splits {
12560 struct_ser.serialize_field("backfillAsEvenSplits", &self.backfill_as_even_splits)?;
12561 }
12562 if self.backfill_split_pk_column_index != 0 {
12563 struct_ser.serialize_field("backfillSplitPkColumnIndex", &self.backfill_split_pk_column_index)?;
12564 }
12565 struct_ser.end()
12566 }
12567}
12568impl<'de> serde::Deserialize<'de> for StreamCdcScanOptions {
12569 #[allow(deprecated)]
12570 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12571 where
12572 D: serde::Deserializer<'de>,
12573 {
12574 const FIELDS: &[&str] = &[
12575 "disable_backfill",
12576 "disableBackfill",
12577 "snapshot_barrier_interval",
12578 "snapshotBarrierInterval",
12579 "snapshot_batch_size",
12580 "snapshotBatchSize",
12581 "backfill_parallelism",
12582 "backfillParallelism",
12583 "backfill_num_rows_per_split",
12584 "backfillNumRowsPerSplit",
12585 "backfill_as_even_splits",
12586 "backfillAsEvenSplits",
12587 "backfill_split_pk_column_index",
12588 "backfillSplitPkColumnIndex",
12589 ];
12590
12591 #[allow(clippy::enum_variant_names)]
12592 enum GeneratedField {
12593 DisableBackfill,
12594 SnapshotBarrierInterval,
12595 SnapshotBatchSize,
12596 BackfillParallelism,
12597 BackfillNumRowsPerSplit,
12598 BackfillAsEvenSplits,
12599 BackfillSplitPkColumnIndex,
12600 }
12601 impl<'de> serde::Deserialize<'de> for GeneratedField {
12602 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12603 where
12604 D: serde::Deserializer<'de>,
12605 {
12606 struct GeneratedVisitor;
12607
12608 impl serde::de::Visitor<'_> for GeneratedVisitor {
12609 type Value = GeneratedField;
12610
12611 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12612 write!(formatter, "expected one of: {:?}", &FIELDS)
12613 }
12614
12615 #[allow(unused_variables)]
12616 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12617 where
12618 E: serde::de::Error,
12619 {
12620 match value {
12621 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
12622 "snapshotBarrierInterval" | "snapshot_barrier_interval" => Ok(GeneratedField::SnapshotBarrierInterval),
12623 "snapshotBatchSize" | "snapshot_batch_size" => Ok(GeneratedField::SnapshotBatchSize),
12624 "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
12625 "backfillNumRowsPerSplit" | "backfill_num_rows_per_split" => Ok(GeneratedField::BackfillNumRowsPerSplit),
12626 "backfillAsEvenSplits" | "backfill_as_even_splits" => Ok(GeneratedField::BackfillAsEvenSplits),
12627 "backfillSplitPkColumnIndex" | "backfill_split_pk_column_index" => Ok(GeneratedField::BackfillSplitPkColumnIndex),
12628 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12629 }
12630 }
12631 }
12632 deserializer.deserialize_identifier(GeneratedVisitor)
12633 }
12634 }
12635 struct GeneratedVisitor;
12636 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12637 type Value = StreamCdcScanOptions;
12638
12639 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12640 formatter.write_str("struct stream_plan.StreamCdcScanOptions")
12641 }
12642
12643 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanOptions, V::Error>
12644 where
12645 V: serde::de::MapAccess<'de>,
12646 {
12647 let mut disable_backfill__ = None;
12648 let mut snapshot_barrier_interval__ = None;
12649 let mut snapshot_batch_size__ = None;
12650 let mut backfill_parallelism__ = None;
12651 let mut backfill_num_rows_per_split__ = None;
12652 let mut backfill_as_even_splits__ = None;
12653 let mut backfill_split_pk_column_index__ = None;
12654 while let Some(k) = map_.next_key()? {
12655 match k {
12656 GeneratedField::DisableBackfill => {
12657 if disable_backfill__.is_some() {
12658 return Err(serde::de::Error::duplicate_field("disableBackfill"));
12659 }
12660 disable_backfill__ = Some(map_.next_value()?);
12661 }
12662 GeneratedField::SnapshotBarrierInterval => {
12663 if snapshot_barrier_interval__.is_some() {
12664 return Err(serde::de::Error::duplicate_field("snapshotBarrierInterval"));
12665 }
12666 snapshot_barrier_interval__ =
12667 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12668 ;
12669 }
12670 GeneratedField::SnapshotBatchSize => {
12671 if snapshot_batch_size__.is_some() {
12672 return Err(serde::de::Error::duplicate_field("snapshotBatchSize"));
12673 }
12674 snapshot_batch_size__ =
12675 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12676 ;
12677 }
12678 GeneratedField::BackfillParallelism => {
12679 if backfill_parallelism__.is_some() {
12680 return Err(serde::de::Error::duplicate_field("backfillParallelism"));
12681 }
12682 backfill_parallelism__ =
12683 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12684 ;
12685 }
12686 GeneratedField::BackfillNumRowsPerSplit => {
12687 if backfill_num_rows_per_split__.is_some() {
12688 return Err(serde::de::Error::duplicate_field("backfillNumRowsPerSplit"));
12689 }
12690 backfill_num_rows_per_split__ =
12691 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12692 ;
12693 }
12694 GeneratedField::BackfillAsEvenSplits => {
12695 if backfill_as_even_splits__.is_some() {
12696 return Err(serde::de::Error::duplicate_field("backfillAsEvenSplits"));
12697 }
12698 backfill_as_even_splits__ = Some(map_.next_value()?);
12699 }
12700 GeneratedField::BackfillSplitPkColumnIndex => {
12701 if backfill_split_pk_column_index__.is_some() {
12702 return Err(serde::de::Error::duplicate_field("backfillSplitPkColumnIndex"));
12703 }
12704 backfill_split_pk_column_index__ =
12705 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12706 ;
12707 }
12708 }
12709 }
12710 Ok(StreamCdcScanOptions {
12711 disable_backfill: disable_backfill__.unwrap_or_default(),
12712 snapshot_barrier_interval: snapshot_barrier_interval__.unwrap_or_default(),
12713 snapshot_batch_size: snapshot_batch_size__.unwrap_or_default(),
12714 backfill_parallelism: backfill_parallelism__.unwrap_or_default(),
12715 backfill_num_rows_per_split: backfill_num_rows_per_split__.unwrap_or_default(),
12716 backfill_as_even_splits: backfill_as_even_splits__.unwrap_or_default(),
12717 backfill_split_pk_column_index: backfill_split_pk_column_index__.unwrap_or_default(),
12718 })
12719 }
12720 }
12721 deserializer.deserialize_struct("stream_plan.StreamCdcScanOptions", FIELDS, GeneratedVisitor)
12722 }
12723}
12724impl serde::Serialize for StreamContext {
12725 #[allow(deprecated)]
12726 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12727 where
12728 S: serde::Serializer,
12729 {
12730 use serde::ser::SerializeStruct;
12731 let mut len = 0;
12732 if !self.timezone.is_empty() {
12733 len += 1;
12734 }
12735 if !self.config_override.is_empty() {
12736 len += 1;
12737 }
12738 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamContext", len)?;
12739 if !self.timezone.is_empty() {
12740 struct_ser.serialize_field("timezone", &self.timezone)?;
12741 }
12742 if !self.config_override.is_empty() {
12743 struct_ser.serialize_field("configOverride", &self.config_override)?;
12744 }
12745 struct_ser.end()
12746 }
12747}
12748impl<'de> serde::Deserialize<'de> for StreamContext {
12749 #[allow(deprecated)]
12750 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12751 where
12752 D: serde::Deserializer<'de>,
12753 {
12754 const FIELDS: &[&str] = &[
12755 "timezone",
12756 "config_override",
12757 "configOverride",
12758 ];
12759
12760 #[allow(clippy::enum_variant_names)]
12761 enum GeneratedField {
12762 Timezone,
12763 ConfigOverride,
12764 }
12765 impl<'de> serde::Deserialize<'de> for GeneratedField {
12766 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12767 where
12768 D: serde::Deserializer<'de>,
12769 {
12770 struct GeneratedVisitor;
12771
12772 impl serde::de::Visitor<'_> for GeneratedVisitor {
12773 type Value = GeneratedField;
12774
12775 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12776 write!(formatter, "expected one of: {:?}", &FIELDS)
12777 }
12778
12779 #[allow(unused_variables)]
12780 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12781 where
12782 E: serde::de::Error,
12783 {
12784 match value {
12785 "timezone" => Ok(GeneratedField::Timezone),
12786 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
12787 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12788 }
12789 }
12790 }
12791 deserializer.deserialize_identifier(GeneratedVisitor)
12792 }
12793 }
12794 struct GeneratedVisitor;
12795 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12796 type Value = StreamContext;
12797
12798 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12799 formatter.write_str("struct stream_plan.StreamContext")
12800 }
12801
12802 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamContext, V::Error>
12803 where
12804 V: serde::de::MapAccess<'de>,
12805 {
12806 let mut timezone__ = None;
12807 let mut config_override__ = None;
12808 while let Some(k) = map_.next_key()? {
12809 match k {
12810 GeneratedField::Timezone => {
12811 if timezone__.is_some() {
12812 return Err(serde::de::Error::duplicate_field("timezone"));
12813 }
12814 timezone__ = Some(map_.next_value()?);
12815 }
12816 GeneratedField::ConfigOverride => {
12817 if config_override__.is_some() {
12818 return Err(serde::de::Error::duplicate_field("configOverride"));
12819 }
12820 config_override__ = Some(map_.next_value()?);
12821 }
12822 }
12823 }
12824 Ok(StreamContext {
12825 timezone: timezone__.unwrap_or_default(),
12826 config_override: config_override__.unwrap_or_default(),
12827 })
12828 }
12829 }
12830 deserializer.deserialize_struct("stream_plan.StreamContext", FIELDS, GeneratedVisitor)
12831 }
12832}
12833impl serde::Serialize for StreamFragmentGraph {
12834 #[allow(deprecated)]
12835 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12836 where
12837 S: serde::Serializer,
12838 {
12839 use serde::ser::SerializeStruct;
12840 let mut len = 0;
12841 if !self.fragments.is_empty() {
12842 len += 1;
12843 }
12844 if !self.edges.is_empty() {
12845 len += 1;
12846 }
12847 if !self.dependent_table_ids.is_empty() {
12848 len += 1;
12849 }
12850 if self.table_ids_cnt != 0 {
12851 len += 1;
12852 }
12853 if self.ctx.is_some() {
12854 len += 1;
12855 }
12856 if self.parallelism.is_some() {
12857 len += 1;
12858 }
12859 if self.backfill_parallelism.is_some() {
12860 len += 1;
12861 }
12862 if !self.adaptive_parallelism_strategy.is_empty() {
12863 len += 1;
12864 }
12865 if !self.backfill_adaptive_parallelism_strategy.is_empty() {
12866 len += 1;
12867 }
12868 if self.max_parallelism != 0 {
12869 len += 1;
12870 }
12871 if self.backfill_order.is_some() {
12872 len += 1;
12873 }
12874 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph", len)?;
12875 if !self.fragments.is_empty() {
12876 struct_ser.serialize_field("fragments", &self.fragments)?;
12877 }
12878 if !self.edges.is_empty() {
12879 struct_ser.serialize_field("edges", &self.edges)?;
12880 }
12881 if !self.dependent_table_ids.is_empty() {
12882 struct_ser.serialize_field("dependentTableIds", &self.dependent_table_ids)?;
12883 }
12884 if self.table_ids_cnt != 0 {
12885 struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
12886 }
12887 if let Some(v) = self.ctx.as_ref() {
12888 struct_ser.serialize_field("ctx", v)?;
12889 }
12890 if let Some(v) = self.parallelism.as_ref() {
12891 struct_ser.serialize_field("parallelism", v)?;
12892 }
12893 if let Some(v) = self.backfill_parallelism.as_ref() {
12894 struct_ser.serialize_field("backfillParallelism", v)?;
12895 }
12896 if !self.adaptive_parallelism_strategy.is_empty() {
12897 struct_ser.serialize_field("adaptiveParallelismStrategy", &self.adaptive_parallelism_strategy)?;
12898 }
12899 if !self.backfill_adaptive_parallelism_strategy.is_empty() {
12900 struct_ser.serialize_field("backfillAdaptiveParallelismStrategy", &self.backfill_adaptive_parallelism_strategy)?;
12901 }
12902 if self.max_parallelism != 0 {
12903 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
12904 }
12905 if let Some(v) = self.backfill_order.as_ref() {
12906 struct_ser.serialize_field("backfillOrder", v)?;
12907 }
12908 struct_ser.end()
12909 }
12910}
12911impl<'de> serde::Deserialize<'de> for StreamFragmentGraph {
12912 #[allow(deprecated)]
12913 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12914 where
12915 D: serde::Deserializer<'de>,
12916 {
12917 const FIELDS: &[&str] = &[
12918 "fragments",
12919 "edges",
12920 "dependent_table_ids",
12921 "dependentTableIds",
12922 "table_ids_cnt",
12923 "tableIdsCnt",
12924 "ctx",
12925 "parallelism",
12926 "backfill_parallelism",
12927 "backfillParallelism",
12928 "adaptive_parallelism_strategy",
12929 "adaptiveParallelismStrategy",
12930 "backfill_adaptive_parallelism_strategy",
12931 "backfillAdaptiveParallelismStrategy",
12932 "max_parallelism",
12933 "maxParallelism",
12934 "backfill_order",
12935 "backfillOrder",
12936 ];
12937
12938 #[allow(clippy::enum_variant_names)]
12939 enum GeneratedField {
12940 Fragments,
12941 Edges,
12942 DependentTableIds,
12943 TableIdsCnt,
12944 Ctx,
12945 Parallelism,
12946 BackfillParallelism,
12947 AdaptiveParallelismStrategy,
12948 BackfillAdaptiveParallelismStrategy,
12949 MaxParallelism,
12950 BackfillOrder,
12951 }
12952 impl<'de> serde::Deserialize<'de> for GeneratedField {
12953 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12954 where
12955 D: serde::Deserializer<'de>,
12956 {
12957 struct GeneratedVisitor;
12958
12959 impl serde::de::Visitor<'_> for GeneratedVisitor {
12960 type Value = GeneratedField;
12961
12962 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12963 write!(formatter, "expected one of: {:?}", &FIELDS)
12964 }
12965
12966 #[allow(unused_variables)]
12967 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12968 where
12969 E: serde::de::Error,
12970 {
12971 match value {
12972 "fragments" => Ok(GeneratedField::Fragments),
12973 "edges" => Ok(GeneratedField::Edges),
12974 "dependentTableIds" | "dependent_table_ids" => Ok(GeneratedField::DependentTableIds),
12975 "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
12976 "ctx" => Ok(GeneratedField::Ctx),
12977 "parallelism" => Ok(GeneratedField::Parallelism),
12978 "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
12979 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
12980 "backfillAdaptiveParallelismStrategy" | "backfill_adaptive_parallelism_strategy" => Ok(GeneratedField::BackfillAdaptiveParallelismStrategy),
12981 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
12982 "backfillOrder" | "backfill_order" => Ok(GeneratedField::BackfillOrder),
12983 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12984 }
12985 }
12986 }
12987 deserializer.deserialize_identifier(GeneratedVisitor)
12988 }
12989 }
12990 struct GeneratedVisitor;
12991 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12992 type Value = StreamFragmentGraph;
12993
12994 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12995 formatter.write_str("struct stream_plan.StreamFragmentGraph")
12996 }
12997
12998 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFragmentGraph, V::Error>
12999 where
13000 V: serde::de::MapAccess<'de>,
13001 {
13002 let mut fragments__ = None;
13003 let mut edges__ = None;
13004 let mut dependent_table_ids__ = None;
13005 let mut table_ids_cnt__ = None;
13006 let mut ctx__ = None;
13007 let mut parallelism__ = None;
13008 let mut backfill_parallelism__ = None;
13009 let mut adaptive_parallelism_strategy__ = None;
13010 let mut backfill_adaptive_parallelism_strategy__ = None;
13011 let mut max_parallelism__ = None;
13012 let mut backfill_order__ = None;
13013 while let Some(k) = map_.next_key()? {
13014 match k {
13015 GeneratedField::Fragments => {
13016 if fragments__.is_some() {
13017 return Err(serde::de::Error::duplicate_field("fragments"));
13018 }
13019 fragments__ = Some(
13020 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
13021 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
13022 );
13023 }
13024 GeneratedField::Edges => {
13025 if edges__.is_some() {
13026 return Err(serde::de::Error::duplicate_field("edges"));
13027 }
13028 edges__ = Some(map_.next_value()?);
13029 }
13030 GeneratedField::DependentTableIds => {
13031 if dependent_table_ids__.is_some() {
13032 return Err(serde::de::Error::duplicate_field("dependentTableIds"));
13033 }
13034 dependent_table_ids__ =
13035 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13036 .into_iter().map(|x| x.0).collect())
13037 ;
13038 }
13039 GeneratedField::TableIdsCnt => {
13040 if table_ids_cnt__.is_some() {
13041 return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
13042 }
13043 table_ids_cnt__ =
13044 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13045 ;
13046 }
13047 GeneratedField::Ctx => {
13048 if ctx__.is_some() {
13049 return Err(serde::de::Error::duplicate_field("ctx"));
13050 }
13051 ctx__ = map_.next_value()?;
13052 }
13053 GeneratedField::Parallelism => {
13054 if parallelism__.is_some() {
13055 return Err(serde::de::Error::duplicate_field("parallelism"));
13056 }
13057 parallelism__ = map_.next_value()?;
13058 }
13059 GeneratedField::BackfillParallelism => {
13060 if backfill_parallelism__.is_some() {
13061 return Err(serde::de::Error::duplicate_field("backfillParallelism"));
13062 }
13063 backfill_parallelism__ = map_.next_value()?;
13064 }
13065 GeneratedField::AdaptiveParallelismStrategy => {
13066 if adaptive_parallelism_strategy__.is_some() {
13067 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
13068 }
13069 adaptive_parallelism_strategy__ = Some(map_.next_value()?);
13070 }
13071 GeneratedField::BackfillAdaptiveParallelismStrategy => {
13072 if backfill_adaptive_parallelism_strategy__.is_some() {
13073 return Err(serde::de::Error::duplicate_field("backfillAdaptiveParallelismStrategy"));
13074 }
13075 backfill_adaptive_parallelism_strategy__ = Some(map_.next_value()?);
13076 }
13077 GeneratedField::MaxParallelism => {
13078 if max_parallelism__.is_some() {
13079 return Err(serde::de::Error::duplicate_field("maxParallelism"));
13080 }
13081 max_parallelism__ =
13082 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13083 ;
13084 }
13085 GeneratedField::BackfillOrder => {
13086 if backfill_order__.is_some() {
13087 return Err(serde::de::Error::duplicate_field("backfillOrder"));
13088 }
13089 backfill_order__ = map_.next_value()?;
13090 }
13091 }
13092 }
13093 Ok(StreamFragmentGraph {
13094 fragments: fragments__.unwrap_or_default(),
13095 edges: edges__.unwrap_or_default(),
13096 dependent_table_ids: dependent_table_ids__.unwrap_or_default(),
13097 table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
13098 ctx: ctx__,
13099 parallelism: parallelism__,
13100 backfill_parallelism: backfill_parallelism__,
13101 adaptive_parallelism_strategy: adaptive_parallelism_strategy__.unwrap_or_default(),
13102 backfill_adaptive_parallelism_strategy: backfill_adaptive_parallelism_strategy__.unwrap_or_default(),
13103 max_parallelism: max_parallelism__.unwrap_or_default(),
13104 backfill_order: backfill_order__,
13105 })
13106 }
13107 }
13108 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph", FIELDS, GeneratedVisitor)
13109 }
13110}
13111impl serde::Serialize for stream_fragment_graph::Parallelism {
13112 #[allow(deprecated)]
13113 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13114 where
13115 S: serde::Serializer,
13116 {
13117 use serde::ser::SerializeStruct;
13118 let mut len = 0;
13119 if self.parallelism != 0 {
13120 len += 1;
13121 }
13122 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.Parallelism", len)?;
13123 if self.parallelism != 0 {
13124 #[allow(clippy::needless_borrow)]
13125 #[allow(clippy::needless_borrows_for_generic_args)]
13126 struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
13127 }
13128 struct_ser.end()
13129 }
13130}
13131impl<'de> serde::Deserialize<'de> for stream_fragment_graph::Parallelism {
13132 #[allow(deprecated)]
13133 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13134 where
13135 D: serde::Deserializer<'de>,
13136 {
13137 const FIELDS: &[&str] = &[
13138 "parallelism",
13139 ];
13140
13141 #[allow(clippy::enum_variant_names)]
13142 enum GeneratedField {
13143 Parallelism,
13144 }
13145 impl<'de> serde::Deserialize<'de> for GeneratedField {
13146 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13147 where
13148 D: serde::Deserializer<'de>,
13149 {
13150 struct GeneratedVisitor;
13151
13152 impl serde::de::Visitor<'_> for GeneratedVisitor {
13153 type Value = GeneratedField;
13154
13155 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13156 write!(formatter, "expected one of: {:?}", &FIELDS)
13157 }
13158
13159 #[allow(unused_variables)]
13160 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13161 where
13162 E: serde::de::Error,
13163 {
13164 match value {
13165 "parallelism" => Ok(GeneratedField::Parallelism),
13166 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13167 }
13168 }
13169 }
13170 deserializer.deserialize_identifier(GeneratedVisitor)
13171 }
13172 }
13173 struct GeneratedVisitor;
13174 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13175 type Value = stream_fragment_graph::Parallelism;
13176
13177 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13178 formatter.write_str("struct stream_plan.StreamFragmentGraph.Parallelism")
13179 }
13180
13181 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::Parallelism, V::Error>
13182 where
13183 V: serde::de::MapAccess<'de>,
13184 {
13185 let mut parallelism__ = None;
13186 while let Some(k) = map_.next_key()? {
13187 match k {
13188 GeneratedField::Parallelism => {
13189 if parallelism__.is_some() {
13190 return Err(serde::de::Error::duplicate_field("parallelism"));
13191 }
13192 parallelism__ =
13193 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13194 ;
13195 }
13196 }
13197 }
13198 Ok(stream_fragment_graph::Parallelism {
13199 parallelism: parallelism__.unwrap_or_default(),
13200 })
13201 }
13202 }
13203 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.Parallelism", FIELDS, GeneratedVisitor)
13204 }
13205}
13206impl serde::Serialize for stream_fragment_graph::StreamFragment {
13207 #[allow(deprecated)]
13208 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13209 where
13210 S: serde::Serializer,
13211 {
13212 use serde::ser::SerializeStruct;
13213 let mut len = 0;
13214 if self.fragment_id != 0 {
13215 len += 1;
13216 }
13217 if self.node.is_some() {
13218 len += 1;
13219 }
13220 if self.fragment_type_mask != 0 {
13221 len += 1;
13222 }
13223 if self.requires_singleton {
13224 len += 1;
13225 }
13226 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", len)?;
13227 if self.fragment_id != 0 {
13228 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
13229 }
13230 if let Some(v) = self.node.as_ref() {
13231 struct_ser.serialize_field("node", v)?;
13232 }
13233 if self.fragment_type_mask != 0 {
13234 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
13235 }
13236 if self.requires_singleton {
13237 struct_ser.serialize_field("requiresSingleton", &self.requires_singleton)?;
13238 }
13239 struct_ser.end()
13240 }
13241}
13242impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragment {
13243 #[allow(deprecated)]
13244 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13245 where
13246 D: serde::Deserializer<'de>,
13247 {
13248 const FIELDS: &[&str] = &[
13249 "fragment_id",
13250 "fragmentId",
13251 "node",
13252 "fragment_type_mask",
13253 "fragmentTypeMask",
13254 "requires_singleton",
13255 "requiresSingleton",
13256 ];
13257
13258 #[allow(clippy::enum_variant_names)]
13259 enum GeneratedField {
13260 FragmentId,
13261 Node,
13262 FragmentTypeMask,
13263 RequiresSingleton,
13264 }
13265 impl<'de> serde::Deserialize<'de> for GeneratedField {
13266 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13267 where
13268 D: serde::Deserializer<'de>,
13269 {
13270 struct GeneratedVisitor;
13271
13272 impl serde::de::Visitor<'_> for GeneratedVisitor {
13273 type Value = GeneratedField;
13274
13275 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13276 write!(formatter, "expected one of: {:?}", &FIELDS)
13277 }
13278
13279 #[allow(unused_variables)]
13280 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13281 where
13282 E: serde::de::Error,
13283 {
13284 match value {
13285 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
13286 "node" => Ok(GeneratedField::Node),
13287 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
13288 "requiresSingleton" | "requires_singleton" => Ok(GeneratedField::RequiresSingleton),
13289 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13290 }
13291 }
13292 }
13293 deserializer.deserialize_identifier(GeneratedVisitor)
13294 }
13295 }
13296 struct GeneratedVisitor;
13297 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13298 type Value = stream_fragment_graph::StreamFragment;
13299
13300 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13301 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragment")
13302 }
13303
13304 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragment, V::Error>
13305 where
13306 V: serde::de::MapAccess<'de>,
13307 {
13308 let mut fragment_id__ = None;
13309 let mut node__ = None;
13310 let mut fragment_type_mask__ = None;
13311 let mut requires_singleton__ = None;
13312 while let Some(k) = map_.next_key()? {
13313 match k {
13314 GeneratedField::FragmentId => {
13315 if fragment_id__.is_some() {
13316 return Err(serde::de::Error::duplicate_field("fragmentId"));
13317 }
13318 fragment_id__ =
13319 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13320 ;
13321 }
13322 GeneratedField::Node => {
13323 if node__.is_some() {
13324 return Err(serde::de::Error::duplicate_field("node"));
13325 }
13326 node__ = map_.next_value()?;
13327 }
13328 GeneratedField::FragmentTypeMask => {
13329 if fragment_type_mask__.is_some() {
13330 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
13331 }
13332 fragment_type_mask__ =
13333 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13334 ;
13335 }
13336 GeneratedField::RequiresSingleton => {
13337 if requires_singleton__.is_some() {
13338 return Err(serde::de::Error::duplicate_field("requiresSingleton"));
13339 }
13340 requires_singleton__ = Some(map_.next_value()?);
13341 }
13342 }
13343 }
13344 Ok(stream_fragment_graph::StreamFragment {
13345 fragment_id: fragment_id__.unwrap_or_default(),
13346 node: node__,
13347 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
13348 requires_singleton: requires_singleton__.unwrap_or_default(),
13349 })
13350 }
13351 }
13352 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", FIELDS, GeneratedVisitor)
13353 }
13354}
13355impl serde::Serialize for stream_fragment_graph::StreamFragmentEdge {
13356 #[allow(deprecated)]
13357 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13358 where
13359 S: serde::Serializer,
13360 {
13361 use serde::ser::SerializeStruct;
13362 let mut len = 0;
13363 if self.dispatch_strategy.is_some() {
13364 len += 1;
13365 }
13366 if self.link_id != 0 {
13367 len += 1;
13368 }
13369 if self.upstream_id != 0 {
13370 len += 1;
13371 }
13372 if self.downstream_id != 0 {
13373 len += 1;
13374 }
13375 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", len)?;
13376 if let Some(v) = self.dispatch_strategy.as_ref() {
13377 struct_ser.serialize_field("dispatchStrategy", v)?;
13378 }
13379 if self.link_id != 0 {
13380 #[allow(clippy::needless_borrow)]
13381 #[allow(clippy::needless_borrows_for_generic_args)]
13382 struct_ser.serialize_field("linkId", ToString::to_string(&self.link_id).as_str())?;
13383 }
13384 if self.upstream_id != 0 {
13385 struct_ser.serialize_field("upstreamId", &self.upstream_id)?;
13386 }
13387 if self.downstream_id != 0 {
13388 struct_ser.serialize_field("downstreamId", &self.downstream_id)?;
13389 }
13390 struct_ser.end()
13391 }
13392}
13393impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragmentEdge {
13394 #[allow(deprecated)]
13395 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13396 where
13397 D: serde::Deserializer<'de>,
13398 {
13399 const FIELDS: &[&str] = &[
13400 "dispatch_strategy",
13401 "dispatchStrategy",
13402 "link_id",
13403 "linkId",
13404 "upstream_id",
13405 "upstreamId",
13406 "downstream_id",
13407 "downstreamId",
13408 ];
13409
13410 #[allow(clippy::enum_variant_names)]
13411 enum GeneratedField {
13412 DispatchStrategy,
13413 LinkId,
13414 UpstreamId,
13415 DownstreamId,
13416 }
13417 impl<'de> serde::Deserialize<'de> for GeneratedField {
13418 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13419 where
13420 D: serde::Deserializer<'de>,
13421 {
13422 struct GeneratedVisitor;
13423
13424 impl serde::de::Visitor<'_> for GeneratedVisitor {
13425 type Value = GeneratedField;
13426
13427 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13428 write!(formatter, "expected one of: {:?}", &FIELDS)
13429 }
13430
13431 #[allow(unused_variables)]
13432 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13433 where
13434 E: serde::de::Error,
13435 {
13436 match value {
13437 "dispatchStrategy" | "dispatch_strategy" => Ok(GeneratedField::DispatchStrategy),
13438 "linkId" | "link_id" => Ok(GeneratedField::LinkId),
13439 "upstreamId" | "upstream_id" => Ok(GeneratedField::UpstreamId),
13440 "downstreamId" | "downstream_id" => Ok(GeneratedField::DownstreamId),
13441 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13442 }
13443 }
13444 }
13445 deserializer.deserialize_identifier(GeneratedVisitor)
13446 }
13447 }
13448 struct GeneratedVisitor;
13449 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13450 type Value = stream_fragment_graph::StreamFragmentEdge;
13451
13452 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13453 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragmentEdge")
13454 }
13455
13456 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragmentEdge, V::Error>
13457 where
13458 V: serde::de::MapAccess<'de>,
13459 {
13460 let mut dispatch_strategy__ = None;
13461 let mut link_id__ = None;
13462 let mut upstream_id__ = None;
13463 let mut downstream_id__ = None;
13464 while let Some(k) = map_.next_key()? {
13465 match k {
13466 GeneratedField::DispatchStrategy => {
13467 if dispatch_strategy__.is_some() {
13468 return Err(serde::de::Error::duplicate_field("dispatchStrategy"));
13469 }
13470 dispatch_strategy__ = map_.next_value()?;
13471 }
13472 GeneratedField::LinkId => {
13473 if link_id__.is_some() {
13474 return Err(serde::de::Error::duplicate_field("linkId"));
13475 }
13476 link_id__ =
13477 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13478 ;
13479 }
13480 GeneratedField::UpstreamId => {
13481 if upstream_id__.is_some() {
13482 return Err(serde::de::Error::duplicate_field("upstreamId"));
13483 }
13484 upstream_id__ =
13485 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13486 ;
13487 }
13488 GeneratedField::DownstreamId => {
13489 if downstream_id__.is_some() {
13490 return Err(serde::de::Error::duplicate_field("downstreamId"));
13491 }
13492 downstream_id__ =
13493 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13494 ;
13495 }
13496 }
13497 }
13498 Ok(stream_fragment_graph::StreamFragmentEdge {
13499 dispatch_strategy: dispatch_strategy__,
13500 link_id: link_id__.unwrap_or_default(),
13501 upstream_id: upstream_id__.unwrap_or_default(),
13502 downstream_id: downstream_id__.unwrap_or_default(),
13503 })
13504 }
13505 }
13506 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", FIELDS, GeneratedVisitor)
13507 }
13508}
13509impl serde::Serialize for StreamFsFetch {
13510 #[allow(deprecated)]
13511 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13512 where
13513 S: serde::Serializer,
13514 {
13515 use serde::ser::SerializeStruct;
13516 let mut len = 0;
13517 if self.source_id != 0 {
13518 len += 1;
13519 }
13520 if self.state_table.is_some() {
13521 len += 1;
13522 }
13523 if self.row_id_index.is_some() {
13524 len += 1;
13525 }
13526 if !self.columns.is_empty() {
13527 len += 1;
13528 }
13529 if !self.with_properties.is_empty() {
13530 len += 1;
13531 }
13532 if self.info.is_some() {
13533 len += 1;
13534 }
13535 if !self.source_name.is_empty() {
13536 len += 1;
13537 }
13538 if self.rate_limit.is_some() {
13539 len += 1;
13540 }
13541 if !self.secret_refs.is_empty() {
13542 len += 1;
13543 }
13544 if self.refresh_mode.is_some() {
13545 len += 1;
13546 }
13547 if self.associated_table_id.is_some() {
13548 len += 1;
13549 }
13550 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetch", len)?;
13551 if self.source_id != 0 {
13552 struct_ser.serialize_field("sourceId", &self.source_id)?;
13553 }
13554 if let Some(v) = self.state_table.as_ref() {
13555 struct_ser.serialize_field("stateTable", v)?;
13556 }
13557 if let Some(v) = self.row_id_index.as_ref() {
13558 struct_ser.serialize_field("rowIdIndex", v)?;
13559 }
13560 if !self.columns.is_empty() {
13561 struct_ser.serialize_field("columns", &self.columns)?;
13562 }
13563 if !self.with_properties.is_empty() {
13564 struct_ser.serialize_field("withProperties", &self.with_properties)?;
13565 }
13566 if let Some(v) = self.info.as_ref() {
13567 struct_ser.serialize_field("info", v)?;
13568 }
13569 if !self.source_name.is_empty() {
13570 struct_ser.serialize_field("sourceName", &self.source_name)?;
13571 }
13572 if let Some(v) = self.rate_limit.as_ref() {
13573 struct_ser.serialize_field("rateLimit", v)?;
13574 }
13575 if !self.secret_refs.is_empty() {
13576 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
13577 }
13578 if let Some(v) = self.refresh_mode.as_ref() {
13579 struct_ser.serialize_field("refreshMode", v)?;
13580 }
13581 if let Some(v) = self.associated_table_id.as_ref() {
13582 struct_ser.serialize_field("associatedTableId", v)?;
13583 }
13584 struct_ser.end()
13585 }
13586}
13587impl<'de> serde::Deserialize<'de> for StreamFsFetch {
13588 #[allow(deprecated)]
13589 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13590 where
13591 D: serde::Deserializer<'de>,
13592 {
13593 const FIELDS: &[&str] = &[
13594 "source_id",
13595 "sourceId",
13596 "state_table",
13597 "stateTable",
13598 "row_id_index",
13599 "rowIdIndex",
13600 "columns",
13601 "with_properties",
13602 "withProperties",
13603 "info",
13604 "source_name",
13605 "sourceName",
13606 "rate_limit",
13607 "rateLimit",
13608 "secret_refs",
13609 "secretRefs",
13610 "refresh_mode",
13611 "refreshMode",
13612 "associated_table_id",
13613 "associatedTableId",
13614 ];
13615
13616 #[allow(clippy::enum_variant_names)]
13617 enum GeneratedField {
13618 SourceId,
13619 StateTable,
13620 RowIdIndex,
13621 Columns,
13622 WithProperties,
13623 Info,
13624 SourceName,
13625 RateLimit,
13626 SecretRefs,
13627 RefreshMode,
13628 AssociatedTableId,
13629 }
13630 impl<'de> serde::Deserialize<'de> for GeneratedField {
13631 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13632 where
13633 D: serde::Deserializer<'de>,
13634 {
13635 struct GeneratedVisitor;
13636
13637 impl serde::de::Visitor<'_> for GeneratedVisitor {
13638 type Value = GeneratedField;
13639
13640 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13641 write!(formatter, "expected one of: {:?}", &FIELDS)
13642 }
13643
13644 #[allow(unused_variables)]
13645 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13646 where
13647 E: serde::de::Error,
13648 {
13649 match value {
13650 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
13651 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
13652 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
13653 "columns" => Ok(GeneratedField::Columns),
13654 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
13655 "info" => Ok(GeneratedField::Info),
13656 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
13657 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
13658 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
13659 "refreshMode" | "refresh_mode" => Ok(GeneratedField::RefreshMode),
13660 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
13661 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13662 }
13663 }
13664 }
13665 deserializer.deserialize_identifier(GeneratedVisitor)
13666 }
13667 }
13668 struct GeneratedVisitor;
13669 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13670 type Value = StreamFsFetch;
13671
13672 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13673 formatter.write_str("struct stream_plan.StreamFsFetch")
13674 }
13675
13676 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetch, V::Error>
13677 where
13678 V: serde::de::MapAccess<'de>,
13679 {
13680 let mut source_id__ = None;
13681 let mut state_table__ = None;
13682 let mut row_id_index__ = None;
13683 let mut columns__ = None;
13684 let mut with_properties__ = None;
13685 let mut info__ = None;
13686 let mut source_name__ = None;
13687 let mut rate_limit__ = None;
13688 let mut secret_refs__ = None;
13689 let mut refresh_mode__ = None;
13690 let mut associated_table_id__ = None;
13691 while let Some(k) = map_.next_key()? {
13692 match k {
13693 GeneratedField::SourceId => {
13694 if source_id__.is_some() {
13695 return Err(serde::de::Error::duplicate_field("sourceId"));
13696 }
13697 source_id__ =
13698 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13699 ;
13700 }
13701 GeneratedField::StateTable => {
13702 if state_table__.is_some() {
13703 return Err(serde::de::Error::duplicate_field("stateTable"));
13704 }
13705 state_table__ = map_.next_value()?;
13706 }
13707 GeneratedField::RowIdIndex => {
13708 if row_id_index__.is_some() {
13709 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
13710 }
13711 row_id_index__ =
13712 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13713 ;
13714 }
13715 GeneratedField::Columns => {
13716 if columns__.is_some() {
13717 return Err(serde::de::Error::duplicate_field("columns"));
13718 }
13719 columns__ = Some(map_.next_value()?);
13720 }
13721 GeneratedField::WithProperties => {
13722 if with_properties__.is_some() {
13723 return Err(serde::de::Error::duplicate_field("withProperties"));
13724 }
13725 with_properties__ = Some(
13726 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13727 );
13728 }
13729 GeneratedField::Info => {
13730 if info__.is_some() {
13731 return Err(serde::de::Error::duplicate_field("info"));
13732 }
13733 info__ = map_.next_value()?;
13734 }
13735 GeneratedField::SourceName => {
13736 if source_name__.is_some() {
13737 return Err(serde::de::Error::duplicate_field("sourceName"));
13738 }
13739 source_name__ = Some(map_.next_value()?);
13740 }
13741 GeneratedField::RateLimit => {
13742 if rate_limit__.is_some() {
13743 return Err(serde::de::Error::duplicate_field("rateLimit"));
13744 }
13745 rate_limit__ =
13746 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13747 ;
13748 }
13749 GeneratedField::SecretRefs => {
13750 if secret_refs__.is_some() {
13751 return Err(serde::de::Error::duplicate_field("secretRefs"));
13752 }
13753 secret_refs__ = Some(
13754 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13755 );
13756 }
13757 GeneratedField::RefreshMode => {
13758 if refresh_mode__.is_some() {
13759 return Err(serde::de::Error::duplicate_field("refreshMode"));
13760 }
13761 refresh_mode__ = map_.next_value()?;
13762 }
13763 GeneratedField::AssociatedTableId => {
13764 if associated_table_id__.is_some() {
13765 return Err(serde::de::Error::duplicate_field("associatedTableId"));
13766 }
13767 associated_table_id__ =
13768 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13769 ;
13770 }
13771 }
13772 }
13773 Ok(StreamFsFetch {
13774 source_id: source_id__.unwrap_or_default(),
13775 state_table: state_table__,
13776 row_id_index: row_id_index__,
13777 columns: columns__.unwrap_or_default(),
13778 with_properties: with_properties__.unwrap_or_default(),
13779 info: info__,
13780 source_name: source_name__.unwrap_or_default(),
13781 rate_limit: rate_limit__,
13782 secret_refs: secret_refs__.unwrap_or_default(),
13783 refresh_mode: refresh_mode__,
13784 associated_table_id: associated_table_id__,
13785 })
13786 }
13787 }
13788 deserializer.deserialize_struct("stream_plan.StreamFsFetch", FIELDS, GeneratedVisitor)
13789 }
13790}
13791impl serde::Serialize for StreamFsFetchNode {
13792 #[allow(deprecated)]
13793 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13794 where
13795 S: serde::Serializer,
13796 {
13797 use serde::ser::SerializeStruct;
13798 let mut len = 0;
13799 if self.node_inner.is_some() {
13800 len += 1;
13801 }
13802 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetchNode", len)?;
13803 if let Some(v) = self.node_inner.as_ref() {
13804 struct_ser.serialize_field("nodeInner", v)?;
13805 }
13806 struct_ser.end()
13807 }
13808}
13809impl<'de> serde::Deserialize<'de> for StreamFsFetchNode {
13810 #[allow(deprecated)]
13811 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13812 where
13813 D: serde::Deserializer<'de>,
13814 {
13815 const FIELDS: &[&str] = &[
13816 "node_inner",
13817 "nodeInner",
13818 ];
13819
13820 #[allow(clippy::enum_variant_names)]
13821 enum GeneratedField {
13822 NodeInner,
13823 }
13824 impl<'de> serde::Deserialize<'de> for GeneratedField {
13825 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13826 where
13827 D: serde::Deserializer<'de>,
13828 {
13829 struct GeneratedVisitor;
13830
13831 impl serde::de::Visitor<'_> for GeneratedVisitor {
13832 type Value = GeneratedField;
13833
13834 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13835 write!(formatter, "expected one of: {:?}", &FIELDS)
13836 }
13837
13838 #[allow(unused_variables)]
13839 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13840 where
13841 E: serde::de::Error,
13842 {
13843 match value {
13844 "nodeInner" | "node_inner" => Ok(GeneratedField::NodeInner),
13845 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13846 }
13847 }
13848 }
13849 deserializer.deserialize_identifier(GeneratedVisitor)
13850 }
13851 }
13852 struct GeneratedVisitor;
13853 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13854 type Value = StreamFsFetchNode;
13855
13856 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13857 formatter.write_str("struct stream_plan.StreamFsFetchNode")
13858 }
13859
13860 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetchNode, V::Error>
13861 where
13862 V: serde::de::MapAccess<'de>,
13863 {
13864 let mut node_inner__ = None;
13865 while let Some(k) = map_.next_key()? {
13866 match k {
13867 GeneratedField::NodeInner => {
13868 if node_inner__.is_some() {
13869 return Err(serde::de::Error::duplicate_field("nodeInner"));
13870 }
13871 node_inner__ = map_.next_value()?;
13872 }
13873 }
13874 }
13875 Ok(StreamFsFetchNode {
13876 node_inner: node_inner__,
13877 })
13878 }
13879 }
13880 deserializer.deserialize_struct("stream_plan.StreamFsFetchNode", FIELDS, GeneratedVisitor)
13881 }
13882}
13883impl serde::Serialize for StreamMessage {
13884 #[allow(deprecated)]
13885 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13886 where
13887 S: serde::Serializer,
13888 {
13889 use serde::ser::SerializeStruct;
13890 let mut len = 0;
13891 if self.stream_message.is_some() {
13892 len += 1;
13893 }
13894 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessage", len)?;
13895 if let Some(v) = self.stream_message.as_ref() {
13896 match v {
13897 stream_message::StreamMessage::StreamChunk(v) => {
13898 struct_ser.serialize_field("streamChunk", v)?;
13899 }
13900 stream_message::StreamMessage::Barrier(v) => {
13901 struct_ser.serialize_field("barrier", v)?;
13902 }
13903 stream_message::StreamMessage::Watermark(v) => {
13904 struct_ser.serialize_field("watermark", v)?;
13905 }
13906 }
13907 }
13908 struct_ser.end()
13909 }
13910}
13911impl<'de> serde::Deserialize<'de> for StreamMessage {
13912 #[allow(deprecated)]
13913 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13914 where
13915 D: serde::Deserializer<'de>,
13916 {
13917 const FIELDS: &[&str] = &[
13918 "stream_chunk",
13919 "streamChunk",
13920 "barrier",
13921 "watermark",
13922 ];
13923
13924 #[allow(clippy::enum_variant_names)]
13925 enum GeneratedField {
13926 StreamChunk,
13927 Barrier,
13928 Watermark,
13929 }
13930 impl<'de> serde::Deserialize<'de> for GeneratedField {
13931 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13932 where
13933 D: serde::Deserializer<'de>,
13934 {
13935 struct GeneratedVisitor;
13936
13937 impl serde::de::Visitor<'_> for GeneratedVisitor {
13938 type Value = GeneratedField;
13939
13940 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13941 write!(formatter, "expected one of: {:?}", &FIELDS)
13942 }
13943
13944 #[allow(unused_variables)]
13945 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13946 where
13947 E: serde::de::Error,
13948 {
13949 match value {
13950 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
13951 "barrier" => Ok(GeneratedField::Barrier),
13952 "watermark" => Ok(GeneratedField::Watermark),
13953 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13954 }
13955 }
13956 }
13957 deserializer.deserialize_identifier(GeneratedVisitor)
13958 }
13959 }
13960 struct GeneratedVisitor;
13961 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13962 type Value = StreamMessage;
13963
13964 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13965 formatter.write_str("struct stream_plan.StreamMessage")
13966 }
13967
13968 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessage, V::Error>
13969 where
13970 V: serde::de::MapAccess<'de>,
13971 {
13972 let mut stream_message__ = None;
13973 while let Some(k) = map_.next_key()? {
13974 match k {
13975 GeneratedField::StreamChunk => {
13976 if stream_message__.is_some() {
13977 return Err(serde::de::Error::duplicate_field("streamChunk"));
13978 }
13979 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::StreamChunk)
13980;
13981 }
13982 GeneratedField::Barrier => {
13983 if stream_message__.is_some() {
13984 return Err(serde::de::Error::duplicate_field("barrier"));
13985 }
13986 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Barrier)
13987;
13988 }
13989 GeneratedField::Watermark => {
13990 if stream_message__.is_some() {
13991 return Err(serde::de::Error::duplicate_field("watermark"));
13992 }
13993 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Watermark)
13994;
13995 }
13996 }
13997 }
13998 Ok(StreamMessage {
13999 stream_message: stream_message__,
14000 })
14001 }
14002 }
14003 deserializer.deserialize_struct("stream_plan.StreamMessage", FIELDS, GeneratedVisitor)
14004 }
14005}
14006impl serde::Serialize for StreamMessageBatch {
14007 #[allow(deprecated)]
14008 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14009 where
14010 S: serde::Serializer,
14011 {
14012 use serde::ser::SerializeStruct;
14013 let mut len = 0;
14014 if self.stream_message_batch.is_some() {
14015 len += 1;
14016 }
14017 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch", len)?;
14018 if let Some(v) = self.stream_message_batch.as_ref() {
14019 match v {
14020 stream_message_batch::StreamMessageBatch::StreamChunk(v) => {
14021 struct_ser.serialize_field("streamChunk", v)?;
14022 }
14023 stream_message_batch::StreamMessageBatch::BarrierBatch(v) => {
14024 struct_ser.serialize_field("barrierBatch", v)?;
14025 }
14026 stream_message_batch::StreamMessageBatch::Watermark(v) => {
14027 struct_ser.serialize_field("watermark", v)?;
14028 }
14029 }
14030 }
14031 struct_ser.end()
14032 }
14033}
14034impl<'de> serde::Deserialize<'de> for StreamMessageBatch {
14035 #[allow(deprecated)]
14036 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14037 where
14038 D: serde::Deserializer<'de>,
14039 {
14040 const FIELDS: &[&str] = &[
14041 "stream_chunk",
14042 "streamChunk",
14043 "barrier_batch",
14044 "barrierBatch",
14045 "watermark",
14046 ];
14047
14048 #[allow(clippy::enum_variant_names)]
14049 enum GeneratedField {
14050 StreamChunk,
14051 BarrierBatch,
14052 Watermark,
14053 }
14054 impl<'de> serde::Deserialize<'de> for GeneratedField {
14055 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14056 where
14057 D: serde::Deserializer<'de>,
14058 {
14059 struct GeneratedVisitor;
14060
14061 impl serde::de::Visitor<'_> for GeneratedVisitor {
14062 type Value = GeneratedField;
14063
14064 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14065 write!(formatter, "expected one of: {:?}", &FIELDS)
14066 }
14067
14068 #[allow(unused_variables)]
14069 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14070 where
14071 E: serde::de::Error,
14072 {
14073 match value {
14074 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
14075 "barrierBatch" | "barrier_batch" => Ok(GeneratedField::BarrierBatch),
14076 "watermark" => Ok(GeneratedField::Watermark),
14077 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14078 }
14079 }
14080 }
14081 deserializer.deserialize_identifier(GeneratedVisitor)
14082 }
14083 }
14084 struct GeneratedVisitor;
14085 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14086 type Value = StreamMessageBatch;
14087
14088 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14089 formatter.write_str("struct stream_plan.StreamMessageBatch")
14090 }
14091
14092 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessageBatch, V::Error>
14093 where
14094 V: serde::de::MapAccess<'de>,
14095 {
14096 let mut stream_message_batch__ = None;
14097 while let Some(k) = map_.next_key()? {
14098 match k {
14099 GeneratedField::StreamChunk => {
14100 if stream_message_batch__.is_some() {
14101 return Err(serde::de::Error::duplicate_field("streamChunk"));
14102 }
14103 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::StreamChunk)
14104;
14105 }
14106 GeneratedField::BarrierBatch => {
14107 if stream_message_batch__.is_some() {
14108 return Err(serde::de::Error::duplicate_field("barrierBatch"));
14109 }
14110 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::BarrierBatch)
14111;
14112 }
14113 GeneratedField::Watermark => {
14114 if stream_message_batch__.is_some() {
14115 return Err(serde::de::Error::duplicate_field("watermark"));
14116 }
14117 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::Watermark)
14118;
14119 }
14120 }
14121 }
14122 Ok(StreamMessageBatch {
14123 stream_message_batch: stream_message_batch__,
14124 })
14125 }
14126 }
14127 deserializer.deserialize_struct("stream_plan.StreamMessageBatch", FIELDS, GeneratedVisitor)
14128 }
14129}
14130impl serde::Serialize for stream_message_batch::BarrierBatch {
14131 #[allow(deprecated)]
14132 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14133 where
14134 S: serde::Serializer,
14135 {
14136 use serde::ser::SerializeStruct;
14137 let mut len = 0;
14138 if !self.barriers.is_empty() {
14139 len += 1;
14140 }
14141 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", len)?;
14142 if !self.barriers.is_empty() {
14143 struct_ser.serialize_field("barriers", &self.barriers)?;
14144 }
14145 struct_ser.end()
14146 }
14147}
14148impl<'de> serde::Deserialize<'de> for stream_message_batch::BarrierBatch {
14149 #[allow(deprecated)]
14150 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14151 where
14152 D: serde::Deserializer<'de>,
14153 {
14154 const FIELDS: &[&str] = &[
14155 "barriers",
14156 ];
14157
14158 #[allow(clippy::enum_variant_names)]
14159 enum GeneratedField {
14160 Barriers,
14161 }
14162 impl<'de> serde::Deserialize<'de> for GeneratedField {
14163 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14164 where
14165 D: serde::Deserializer<'de>,
14166 {
14167 struct GeneratedVisitor;
14168
14169 impl serde::de::Visitor<'_> for GeneratedVisitor {
14170 type Value = GeneratedField;
14171
14172 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14173 write!(formatter, "expected one of: {:?}", &FIELDS)
14174 }
14175
14176 #[allow(unused_variables)]
14177 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14178 where
14179 E: serde::de::Error,
14180 {
14181 match value {
14182 "barriers" => Ok(GeneratedField::Barriers),
14183 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14184 }
14185 }
14186 }
14187 deserializer.deserialize_identifier(GeneratedVisitor)
14188 }
14189 }
14190 struct GeneratedVisitor;
14191 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14192 type Value = stream_message_batch::BarrierBatch;
14193
14194 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14195 formatter.write_str("struct stream_plan.StreamMessageBatch.BarrierBatch")
14196 }
14197
14198 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_message_batch::BarrierBatch, V::Error>
14199 where
14200 V: serde::de::MapAccess<'de>,
14201 {
14202 let mut barriers__ = None;
14203 while let Some(k) = map_.next_key()? {
14204 match k {
14205 GeneratedField::Barriers => {
14206 if barriers__.is_some() {
14207 return Err(serde::de::Error::duplicate_field("barriers"));
14208 }
14209 barriers__ = Some(map_.next_value()?);
14210 }
14211 }
14212 }
14213 Ok(stream_message_batch::BarrierBatch {
14214 barriers: barriers__.unwrap_or_default(),
14215 })
14216 }
14217 }
14218 deserializer.deserialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", FIELDS, GeneratedVisitor)
14219 }
14220}
14221impl serde::Serialize for StreamNode {
14222 #[allow(deprecated)]
14223 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14224 where
14225 S: serde::Serializer,
14226 {
14227 use serde::ser::SerializeStruct;
14228 let mut len = 0;
14229 if self.operator_id != 0 {
14230 len += 1;
14231 }
14232 if !self.input.is_empty() {
14233 len += 1;
14234 }
14235 if !self.stream_key.is_empty() {
14236 len += 1;
14237 }
14238 if self.stream_kind != 0 {
14239 len += 1;
14240 }
14241 if !self.identity.is_empty() {
14242 len += 1;
14243 }
14244 if !self.fields.is_empty() {
14245 len += 1;
14246 }
14247 if self.node_body.is_some() {
14248 len += 1;
14249 }
14250 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamNode", len)?;
14251 if self.operator_id != 0 {
14252 #[allow(clippy::needless_borrow)]
14253 #[allow(clippy::needless_borrows_for_generic_args)]
14254 struct_ser.serialize_field("operatorId", ToString::to_string(&self.operator_id).as_str())?;
14255 }
14256 if !self.input.is_empty() {
14257 struct_ser.serialize_field("input", &self.input)?;
14258 }
14259 if !self.stream_key.is_empty() {
14260 struct_ser.serialize_field("streamKey", &self.stream_key)?;
14261 }
14262 if self.stream_kind != 0 {
14263 let v = stream_node::StreamKind::try_from(self.stream_kind)
14264 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_kind)))?;
14265 struct_ser.serialize_field("streamKind", &v)?;
14266 }
14267 if !self.identity.is_empty() {
14268 struct_ser.serialize_field("identity", &self.identity)?;
14269 }
14270 if !self.fields.is_empty() {
14271 struct_ser.serialize_field("fields", &self.fields)?;
14272 }
14273 if let Some(v) = self.node_body.as_ref() {
14274 match v {
14275 stream_node::NodeBody::Source(v) => {
14276 struct_ser.serialize_field("source", v)?;
14277 }
14278 stream_node::NodeBody::Project(v) => {
14279 struct_ser.serialize_field("project", v)?;
14280 }
14281 stream_node::NodeBody::Filter(v) => {
14282 struct_ser.serialize_field("filter", v)?;
14283 }
14284 stream_node::NodeBody::Materialize(v) => {
14285 struct_ser.serialize_field("materialize", v)?;
14286 }
14287 stream_node::NodeBody::StatelessSimpleAgg(v) => {
14288 struct_ser.serialize_field("statelessSimpleAgg", v)?;
14289 }
14290 stream_node::NodeBody::SimpleAgg(v) => {
14291 struct_ser.serialize_field("simpleAgg", v)?;
14292 }
14293 stream_node::NodeBody::HashAgg(v) => {
14294 struct_ser.serialize_field("hashAgg", v)?;
14295 }
14296 stream_node::NodeBody::AppendOnlyTopN(v) => {
14297 struct_ser.serialize_field("appendOnlyTopN", v)?;
14298 }
14299 stream_node::NodeBody::HashJoin(v) => {
14300 struct_ser.serialize_field("hashJoin", v)?;
14301 }
14302 stream_node::NodeBody::TopN(v) => {
14303 struct_ser.serialize_field("topN", v)?;
14304 }
14305 stream_node::NodeBody::HopWindow(v) => {
14306 struct_ser.serialize_field("hopWindow", v)?;
14307 }
14308 stream_node::NodeBody::Merge(v) => {
14309 struct_ser.serialize_field("merge", v)?;
14310 }
14311 stream_node::NodeBody::Exchange(v) => {
14312 struct_ser.serialize_field("exchange", v)?;
14313 }
14314 stream_node::NodeBody::StreamScan(v) => {
14315 struct_ser.serialize_field("streamScan", v)?;
14316 }
14317 stream_node::NodeBody::BatchPlan(v) => {
14318 struct_ser.serialize_field("batchPlan", v)?;
14319 }
14320 stream_node::NodeBody::Lookup(v) => {
14321 struct_ser.serialize_field("lookup", v)?;
14322 }
14323 stream_node::NodeBody::Arrange(v) => {
14324 struct_ser.serialize_field("arrange", v)?;
14325 }
14326 stream_node::NodeBody::LookupUnion(v) => {
14327 struct_ser.serialize_field("lookupUnion", v)?;
14328 }
14329 stream_node::NodeBody::Union(v) => {
14330 struct_ser.serialize_field("union", v)?;
14331 }
14332 stream_node::NodeBody::DeltaIndexJoin(v) => {
14333 struct_ser.serialize_field("deltaIndexJoin", v)?;
14334 }
14335 stream_node::NodeBody::Sink(v) => {
14336 struct_ser.serialize_field("sink", v)?;
14337 }
14338 stream_node::NodeBody::Expand(v) => {
14339 struct_ser.serialize_field("expand", v)?;
14340 }
14341 stream_node::NodeBody::DynamicFilter(v) => {
14342 struct_ser.serialize_field("dynamicFilter", v)?;
14343 }
14344 stream_node::NodeBody::ProjectSet(v) => {
14345 struct_ser.serialize_field("projectSet", v)?;
14346 }
14347 stream_node::NodeBody::GroupTopN(v) => {
14348 struct_ser.serialize_field("groupTopN", v)?;
14349 }
14350 stream_node::NodeBody::Sort(v) => {
14351 struct_ser.serialize_field("sort", v)?;
14352 }
14353 stream_node::NodeBody::WatermarkFilter(v) => {
14354 struct_ser.serialize_field("watermarkFilter", v)?;
14355 }
14356 stream_node::NodeBody::Dml(v) => {
14357 struct_ser.serialize_field("dml", v)?;
14358 }
14359 stream_node::NodeBody::RowIdGen(v) => {
14360 struct_ser.serialize_field("rowIdGen", v)?;
14361 }
14362 stream_node::NodeBody::Now(v) => {
14363 struct_ser.serialize_field("now", v)?;
14364 }
14365 stream_node::NodeBody::AppendOnlyGroupTopN(v) => {
14366 struct_ser.serialize_field("appendOnlyGroupTopN", v)?;
14367 }
14368 stream_node::NodeBody::TemporalJoin(v) => {
14369 struct_ser.serialize_field("temporalJoin", v)?;
14370 }
14371 stream_node::NodeBody::BarrierRecv(v) => {
14372 struct_ser.serialize_field("barrierRecv", v)?;
14373 }
14374 stream_node::NodeBody::Values(v) => {
14375 struct_ser.serialize_field("values", v)?;
14376 }
14377 stream_node::NodeBody::AppendOnlyDedup(v) => {
14378 struct_ser.serialize_field("appendOnlyDedup", v)?;
14379 }
14380 stream_node::NodeBody::NoOp(v) => {
14381 struct_ser.serialize_field("noOp", v)?;
14382 }
14383 stream_node::NodeBody::EowcOverWindow(v) => {
14384 struct_ser.serialize_field("eowcOverWindow", v)?;
14385 }
14386 stream_node::NodeBody::OverWindow(v) => {
14387 struct_ser.serialize_field("overWindow", v)?;
14388 }
14389 stream_node::NodeBody::StreamFsFetch(v) => {
14390 struct_ser.serialize_field("streamFsFetch", v)?;
14391 }
14392 stream_node::NodeBody::StreamCdcScan(v) => {
14393 struct_ser.serialize_field("streamCdcScan", v)?;
14394 }
14395 stream_node::NodeBody::CdcFilter(v) => {
14396 struct_ser.serialize_field("cdcFilter", v)?;
14397 }
14398 stream_node::NodeBody::SourceBackfill(v) => {
14399 struct_ser.serialize_field("sourceBackfill", v)?;
14400 }
14401 stream_node::NodeBody::Changelog(v) => {
14402 struct_ser.serialize_field("changelog", v)?;
14403 }
14404 stream_node::NodeBody::LocalApproxPercentile(v) => {
14405 struct_ser.serialize_field("localApproxPercentile", v)?;
14406 }
14407 stream_node::NodeBody::GlobalApproxPercentile(v) => {
14408 struct_ser.serialize_field("globalApproxPercentile", v)?;
14409 }
14410 stream_node::NodeBody::RowMerge(v) => {
14411 struct_ser.serialize_field("rowMerge", v)?;
14412 }
14413 stream_node::NodeBody::AsOfJoin(v) => {
14414 struct_ser.serialize_field("asOfJoin", v)?;
14415 }
14416 stream_node::NodeBody::SyncLogStore(v) => {
14417 struct_ser.serialize_field("syncLogStore", v)?;
14418 }
14419 stream_node::NodeBody::MaterializedExprs(v) => {
14420 struct_ser.serialize_field("materializedExprs", v)?;
14421 }
14422 stream_node::NodeBody::VectorIndexWrite(v) => {
14423 struct_ser.serialize_field("vectorIndexWrite", v)?;
14424 }
14425 stream_node::NodeBody::UpstreamSinkUnion(v) => {
14426 struct_ser.serialize_field("upstreamSinkUnion", v)?;
14427 }
14428 stream_node::NodeBody::LocalityProvider(v) => {
14429 struct_ser.serialize_field("localityProvider", v)?;
14430 }
14431 stream_node::NodeBody::EowcGapFill(v) => {
14432 struct_ser.serialize_field("eowcGapFill", v)?;
14433 }
14434 stream_node::NodeBody::GapFill(v) => {
14435 struct_ser.serialize_field("gapFill", v)?;
14436 }
14437 stream_node::NodeBody::VectorIndexLookupJoin(v) => {
14438 struct_ser.serialize_field("vectorIndexLookupJoin", v)?;
14439 }
14440 stream_node::NodeBody::IcebergWithPkIndexWriter(v) => {
14441 struct_ser.serialize_field("icebergWithPkIndexWriter", v)?;
14442 }
14443 stream_node::NodeBody::IcebergWithPkIndexPositionDeleteMerger(v) => {
14444 struct_ser.serialize_field("icebergWithPkIndexPositionDeleteMerger", v)?;
14445 }
14446 }
14447 }
14448 struct_ser.end()
14449 }
14450}
14451impl<'de> serde::Deserialize<'de> for StreamNode {
14452 #[allow(deprecated)]
14453 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14454 where
14455 D: serde::Deserializer<'de>,
14456 {
14457 const FIELDS: &[&str] = &[
14458 "operator_id",
14459 "operatorId",
14460 "input",
14461 "stream_key",
14462 "streamKey",
14463 "stream_kind",
14464 "streamKind",
14465 "identity",
14466 "fields",
14467 "source",
14468 "project",
14469 "filter",
14470 "materialize",
14471 "stateless_simple_agg",
14472 "statelessSimpleAgg",
14473 "simple_agg",
14474 "simpleAgg",
14475 "hash_agg",
14476 "hashAgg",
14477 "append_only_top_n",
14478 "appendOnlyTopN",
14479 "hash_join",
14480 "hashJoin",
14481 "top_n",
14482 "topN",
14483 "hop_window",
14484 "hopWindow",
14485 "merge",
14486 "exchange",
14487 "stream_scan",
14488 "streamScan",
14489 "batch_plan",
14490 "batchPlan",
14491 "lookup",
14492 "arrange",
14493 "lookup_union",
14494 "lookupUnion",
14495 "union",
14496 "delta_index_join",
14497 "deltaIndexJoin",
14498 "sink",
14499 "expand",
14500 "dynamic_filter",
14501 "dynamicFilter",
14502 "project_set",
14503 "projectSet",
14504 "group_top_n",
14505 "groupTopN",
14506 "sort",
14507 "watermark_filter",
14508 "watermarkFilter",
14509 "dml",
14510 "row_id_gen",
14511 "rowIdGen",
14512 "now",
14513 "append_only_group_top_n",
14514 "appendOnlyGroupTopN",
14515 "temporal_join",
14516 "temporalJoin",
14517 "barrier_recv",
14518 "barrierRecv",
14519 "values",
14520 "append_only_dedup",
14521 "appendOnlyDedup",
14522 "no_op",
14523 "noOp",
14524 "eowc_over_window",
14525 "eowcOverWindow",
14526 "over_window",
14527 "overWindow",
14528 "stream_fs_fetch",
14529 "streamFsFetch",
14530 "stream_cdc_scan",
14531 "streamCdcScan",
14532 "cdc_filter",
14533 "cdcFilter",
14534 "source_backfill",
14535 "sourceBackfill",
14536 "changelog",
14537 "local_approx_percentile",
14538 "localApproxPercentile",
14539 "global_approx_percentile",
14540 "globalApproxPercentile",
14541 "row_merge",
14542 "rowMerge",
14543 "as_of_join",
14544 "asOfJoin",
14545 "sync_log_store",
14546 "syncLogStore",
14547 "materialized_exprs",
14548 "materializedExprs",
14549 "vector_index_write",
14550 "vectorIndexWrite",
14551 "upstream_sink_union",
14552 "upstreamSinkUnion",
14553 "locality_provider",
14554 "localityProvider",
14555 "eowc_gap_fill",
14556 "eowcGapFill",
14557 "gap_fill",
14558 "gapFill",
14559 "vector_index_lookup_join",
14560 "vectorIndexLookupJoin",
14561 "iceberg_with_pk_index_writer",
14562 "icebergWithPkIndexWriter",
14563 "iceberg_with_pk_index_position_delete_merger",
14564 "icebergWithPkIndexPositionDeleteMerger",
14565 ];
14566
14567 #[allow(clippy::enum_variant_names)]
14568 enum GeneratedField {
14569 OperatorId,
14570 Input,
14571 StreamKey,
14572 StreamKind,
14573 Identity,
14574 Fields,
14575 Source,
14576 Project,
14577 Filter,
14578 Materialize,
14579 StatelessSimpleAgg,
14580 SimpleAgg,
14581 HashAgg,
14582 AppendOnlyTopN,
14583 HashJoin,
14584 TopN,
14585 HopWindow,
14586 Merge,
14587 Exchange,
14588 StreamScan,
14589 BatchPlan,
14590 Lookup,
14591 Arrange,
14592 LookupUnion,
14593 Union,
14594 DeltaIndexJoin,
14595 Sink,
14596 Expand,
14597 DynamicFilter,
14598 ProjectSet,
14599 GroupTopN,
14600 Sort,
14601 WatermarkFilter,
14602 Dml,
14603 RowIdGen,
14604 Now,
14605 AppendOnlyGroupTopN,
14606 TemporalJoin,
14607 BarrierRecv,
14608 Values,
14609 AppendOnlyDedup,
14610 NoOp,
14611 EowcOverWindow,
14612 OverWindow,
14613 StreamFsFetch,
14614 StreamCdcScan,
14615 CdcFilter,
14616 SourceBackfill,
14617 Changelog,
14618 LocalApproxPercentile,
14619 GlobalApproxPercentile,
14620 RowMerge,
14621 AsOfJoin,
14622 SyncLogStore,
14623 MaterializedExprs,
14624 VectorIndexWrite,
14625 UpstreamSinkUnion,
14626 LocalityProvider,
14627 EowcGapFill,
14628 GapFill,
14629 VectorIndexLookupJoin,
14630 IcebergWithPkIndexWriter,
14631 IcebergWithPkIndexPositionDeleteMerger,
14632 }
14633 impl<'de> serde::Deserialize<'de> for GeneratedField {
14634 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14635 where
14636 D: serde::Deserializer<'de>,
14637 {
14638 struct GeneratedVisitor;
14639
14640 impl serde::de::Visitor<'_> for GeneratedVisitor {
14641 type Value = GeneratedField;
14642
14643 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14644 write!(formatter, "expected one of: {:?}", &FIELDS)
14645 }
14646
14647 #[allow(unused_variables)]
14648 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14649 where
14650 E: serde::de::Error,
14651 {
14652 match value {
14653 "operatorId" | "operator_id" => Ok(GeneratedField::OperatorId),
14654 "input" => Ok(GeneratedField::Input),
14655 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
14656 "streamKind" | "stream_kind" => Ok(GeneratedField::StreamKind),
14657 "identity" => Ok(GeneratedField::Identity),
14658 "fields" => Ok(GeneratedField::Fields),
14659 "source" => Ok(GeneratedField::Source),
14660 "project" => Ok(GeneratedField::Project),
14661 "filter" => Ok(GeneratedField::Filter),
14662 "materialize" => Ok(GeneratedField::Materialize),
14663 "statelessSimpleAgg" | "stateless_simple_agg" => Ok(GeneratedField::StatelessSimpleAgg),
14664 "simpleAgg" | "simple_agg" => Ok(GeneratedField::SimpleAgg),
14665 "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
14666 "appendOnlyTopN" | "append_only_top_n" => Ok(GeneratedField::AppendOnlyTopN),
14667 "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
14668 "topN" | "top_n" => Ok(GeneratedField::TopN),
14669 "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
14670 "merge" => Ok(GeneratedField::Merge),
14671 "exchange" => Ok(GeneratedField::Exchange),
14672 "streamScan" | "stream_scan" => Ok(GeneratedField::StreamScan),
14673 "batchPlan" | "batch_plan" => Ok(GeneratedField::BatchPlan),
14674 "lookup" => Ok(GeneratedField::Lookup),
14675 "arrange" => Ok(GeneratedField::Arrange),
14676 "lookupUnion" | "lookup_union" => Ok(GeneratedField::LookupUnion),
14677 "union" => Ok(GeneratedField::Union),
14678 "deltaIndexJoin" | "delta_index_join" => Ok(GeneratedField::DeltaIndexJoin),
14679 "sink" => Ok(GeneratedField::Sink),
14680 "expand" => Ok(GeneratedField::Expand),
14681 "dynamicFilter" | "dynamic_filter" => Ok(GeneratedField::DynamicFilter),
14682 "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
14683 "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
14684 "sort" => Ok(GeneratedField::Sort),
14685 "watermarkFilter" | "watermark_filter" => Ok(GeneratedField::WatermarkFilter),
14686 "dml" => Ok(GeneratedField::Dml),
14687 "rowIdGen" | "row_id_gen" => Ok(GeneratedField::RowIdGen),
14688 "now" => Ok(GeneratedField::Now),
14689 "appendOnlyGroupTopN" | "append_only_group_top_n" => Ok(GeneratedField::AppendOnlyGroupTopN),
14690 "temporalJoin" | "temporal_join" => Ok(GeneratedField::TemporalJoin),
14691 "barrierRecv" | "barrier_recv" => Ok(GeneratedField::BarrierRecv),
14692 "values" => Ok(GeneratedField::Values),
14693 "appendOnlyDedup" | "append_only_dedup" => Ok(GeneratedField::AppendOnlyDedup),
14694 "noOp" | "no_op" => Ok(GeneratedField::NoOp),
14695 "eowcOverWindow" | "eowc_over_window" => Ok(GeneratedField::EowcOverWindow),
14696 "overWindow" | "over_window" => Ok(GeneratedField::OverWindow),
14697 "streamFsFetch" | "stream_fs_fetch" => Ok(GeneratedField::StreamFsFetch),
14698 "streamCdcScan" | "stream_cdc_scan" => Ok(GeneratedField::StreamCdcScan),
14699 "cdcFilter" | "cdc_filter" => Ok(GeneratedField::CdcFilter),
14700 "sourceBackfill" | "source_backfill" => Ok(GeneratedField::SourceBackfill),
14701 "changelog" => Ok(GeneratedField::Changelog),
14702 "localApproxPercentile" | "local_approx_percentile" => Ok(GeneratedField::LocalApproxPercentile),
14703 "globalApproxPercentile" | "global_approx_percentile" => Ok(GeneratedField::GlobalApproxPercentile),
14704 "rowMerge" | "row_merge" => Ok(GeneratedField::RowMerge),
14705 "asOfJoin" | "as_of_join" => Ok(GeneratedField::AsOfJoin),
14706 "syncLogStore" | "sync_log_store" => Ok(GeneratedField::SyncLogStore),
14707 "materializedExprs" | "materialized_exprs" => Ok(GeneratedField::MaterializedExprs),
14708 "vectorIndexWrite" | "vector_index_write" => Ok(GeneratedField::VectorIndexWrite),
14709 "upstreamSinkUnion" | "upstream_sink_union" => Ok(GeneratedField::UpstreamSinkUnion),
14710 "localityProvider" | "locality_provider" => Ok(GeneratedField::LocalityProvider),
14711 "eowcGapFill" | "eowc_gap_fill" => Ok(GeneratedField::EowcGapFill),
14712 "gapFill" | "gap_fill" => Ok(GeneratedField::GapFill),
14713 "vectorIndexLookupJoin" | "vector_index_lookup_join" => Ok(GeneratedField::VectorIndexLookupJoin),
14714 "icebergWithPkIndexWriter" | "iceberg_with_pk_index_writer" => Ok(GeneratedField::IcebergWithPkIndexWriter),
14715 "icebergWithPkIndexPositionDeleteMerger" | "iceberg_with_pk_index_position_delete_merger" => Ok(GeneratedField::IcebergWithPkIndexPositionDeleteMerger),
14716 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14717 }
14718 }
14719 }
14720 deserializer.deserialize_identifier(GeneratedVisitor)
14721 }
14722 }
14723 struct GeneratedVisitor;
14724 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14725 type Value = StreamNode;
14726
14727 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14728 formatter.write_str("struct stream_plan.StreamNode")
14729 }
14730
14731 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamNode, V::Error>
14732 where
14733 V: serde::de::MapAccess<'de>,
14734 {
14735 let mut operator_id__ = None;
14736 let mut input__ = None;
14737 let mut stream_key__ = None;
14738 let mut stream_kind__ = None;
14739 let mut identity__ = None;
14740 let mut fields__ = None;
14741 let mut node_body__ = None;
14742 while let Some(k) = map_.next_key()? {
14743 match k {
14744 GeneratedField::OperatorId => {
14745 if operator_id__.is_some() {
14746 return Err(serde::de::Error::duplicate_field("operatorId"));
14747 }
14748 operator_id__ =
14749 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14750 ;
14751 }
14752 GeneratedField::Input => {
14753 if input__.is_some() {
14754 return Err(serde::de::Error::duplicate_field("input"));
14755 }
14756 input__ = Some(map_.next_value()?);
14757 }
14758 GeneratedField::StreamKey => {
14759 if stream_key__.is_some() {
14760 return Err(serde::de::Error::duplicate_field("streamKey"));
14761 }
14762 stream_key__ =
14763 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14764 .into_iter().map(|x| x.0).collect())
14765 ;
14766 }
14767 GeneratedField::StreamKind => {
14768 if stream_kind__.is_some() {
14769 return Err(serde::de::Error::duplicate_field("streamKind"));
14770 }
14771 stream_kind__ = Some(map_.next_value::<stream_node::StreamKind>()? as i32);
14772 }
14773 GeneratedField::Identity => {
14774 if identity__.is_some() {
14775 return Err(serde::de::Error::duplicate_field("identity"));
14776 }
14777 identity__ = Some(map_.next_value()?);
14778 }
14779 GeneratedField::Fields => {
14780 if fields__.is_some() {
14781 return Err(serde::de::Error::duplicate_field("fields"));
14782 }
14783 fields__ = Some(map_.next_value()?);
14784 }
14785 GeneratedField::Source => {
14786 if node_body__.is_some() {
14787 return Err(serde::de::Error::duplicate_field("source"));
14788 }
14789 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Source)
14790;
14791 }
14792 GeneratedField::Project => {
14793 if node_body__.is_some() {
14794 return Err(serde::de::Error::duplicate_field("project"));
14795 }
14796 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Project)
14797;
14798 }
14799 GeneratedField::Filter => {
14800 if node_body__.is_some() {
14801 return Err(serde::de::Error::duplicate_field("filter"));
14802 }
14803 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Filter)
14804;
14805 }
14806 GeneratedField::Materialize => {
14807 if node_body__.is_some() {
14808 return Err(serde::de::Error::duplicate_field("materialize"));
14809 }
14810 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Materialize)
14811;
14812 }
14813 GeneratedField::StatelessSimpleAgg => {
14814 if node_body__.is_some() {
14815 return Err(serde::de::Error::duplicate_field("statelessSimpleAgg"));
14816 }
14817 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StatelessSimpleAgg)
14818;
14819 }
14820 GeneratedField::SimpleAgg => {
14821 if node_body__.is_some() {
14822 return Err(serde::de::Error::duplicate_field("simpleAgg"));
14823 }
14824 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SimpleAgg)
14825;
14826 }
14827 GeneratedField::HashAgg => {
14828 if node_body__.is_some() {
14829 return Err(serde::de::Error::duplicate_field("hashAgg"));
14830 }
14831 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashAgg)
14832;
14833 }
14834 GeneratedField::AppendOnlyTopN => {
14835 if node_body__.is_some() {
14836 return Err(serde::de::Error::duplicate_field("appendOnlyTopN"));
14837 }
14838 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyTopN)
14839;
14840 }
14841 GeneratedField::HashJoin => {
14842 if node_body__.is_some() {
14843 return Err(serde::de::Error::duplicate_field("hashJoin"));
14844 }
14845 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashJoin)
14846;
14847 }
14848 GeneratedField::TopN => {
14849 if node_body__.is_some() {
14850 return Err(serde::de::Error::duplicate_field("topN"));
14851 }
14852 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TopN)
14853;
14854 }
14855 GeneratedField::HopWindow => {
14856 if node_body__.is_some() {
14857 return Err(serde::de::Error::duplicate_field("hopWindow"));
14858 }
14859 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HopWindow)
14860;
14861 }
14862 GeneratedField::Merge => {
14863 if node_body__.is_some() {
14864 return Err(serde::de::Error::duplicate_field("merge"));
14865 }
14866 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Merge)
14867;
14868 }
14869 GeneratedField::Exchange => {
14870 if node_body__.is_some() {
14871 return Err(serde::de::Error::duplicate_field("exchange"));
14872 }
14873 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Exchange)
14874;
14875 }
14876 GeneratedField::StreamScan => {
14877 if node_body__.is_some() {
14878 return Err(serde::de::Error::duplicate_field("streamScan"));
14879 }
14880 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamScan)
14881;
14882 }
14883 GeneratedField::BatchPlan => {
14884 if node_body__.is_some() {
14885 return Err(serde::de::Error::duplicate_field("batchPlan"));
14886 }
14887 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BatchPlan)
14888;
14889 }
14890 GeneratedField::Lookup => {
14891 if node_body__.is_some() {
14892 return Err(serde::de::Error::duplicate_field("lookup"));
14893 }
14894 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Lookup)
14895;
14896 }
14897 GeneratedField::Arrange => {
14898 if node_body__.is_some() {
14899 return Err(serde::de::Error::duplicate_field("arrange"));
14900 }
14901 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Arrange)
14902;
14903 }
14904 GeneratedField::LookupUnion => {
14905 if node_body__.is_some() {
14906 return Err(serde::de::Error::duplicate_field("lookupUnion"));
14907 }
14908 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LookupUnion)
14909;
14910 }
14911 GeneratedField::Union => {
14912 if node_body__.is_some() {
14913 return Err(serde::de::Error::duplicate_field("union"));
14914 }
14915 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Union)
14916;
14917 }
14918 GeneratedField::DeltaIndexJoin => {
14919 if node_body__.is_some() {
14920 return Err(serde::de::Error::duplicate_field("deltaIndexJoin"));
14921 }
14922 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DeltaIndexJoin)
14923;
14924 }
14925 GeneratedField::Sink => {
14926 if node_body__.is_some() {
14927 return Err(serde::de::Error::duplicate_field("sink"));
14928 }
14929 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sink)
14930;
14931 }
14932 GeneratedField::Expand => {
14933 if node_body__.is_some() {
14934 return Err(serde::de::Error::duplicate_field("expand"));
14935 }
14936 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Expand)
14937;
14938 }
14939 GeneratedField::DynamicFilter => {
14940 if node_body__.is_some() {
14941 return Err(serde::de::Error::duplicate_field("dynamicFilter"));
14942 }
14943 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DynamicFilter)
14944;
14945 }
14946 GeneratedField::ProjectSet => {
14947 if node_body__.is_some() {
14948 return Err(serde::de::Error::duplicate_field("projectSet"));
14949 }
14950 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::ProjectSet)
14951;
14952 }
14953 GeneratedField::GroupTopN => {
14954 if node_body__.is_some() {
14955 return Err(serde::de::Error::duplicate_field("groupTopN"));
14956 }
14957 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GroupTopN)
14958;
14959 }
14960 GeneratedField::Sort => {
14961 if node_body__.is_some() {
14962 return Err(serde::de::Error::duplicate_field("sort"));
14963 }
14964 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sort)
14965;
14966 }
14967 GeneratedField::WatermarkFilter => {
14968 if node_body__.is_some() {
14969 return Err(serde::de::Error::duplicate_field("watermarkFilter"));
14970 }
14971 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::WatermarkFilter)
14972;
14973 }
14974 GeneratedField::Dml => {
14975 if node_body__.is_some() {
14976 return Err(serde::de::Error::duplicate_field("dml"));
14977 }
14978 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Dml)
14979;
14980 }
14981 GeneratedField::RowIdGen => {
14982 if node_body__.is_some() {
14983 return Err(serde::de::Error::duplicate_field("rowIdGen"));
14984 }
14985 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowIdGen)
14986;
14987 }
14988 GeneratedField::Now => {
14989 if node_body__.is_some() {
14990 return Err(serde::de::Error::duplicate_field("now"));
14991 }
14992 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Now)
14993;
14994 }
14995 GeneratedField::AppendOnlyGroupTopN => {
14996 if node_body__.is_some() {
14997 return Err(serde::de::Error::duplicate_field("appendOnlyGroupTopN"));
14998 }
14999 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyGroupTopN)
15000;
15001 }
15002 GeneratedField::TemporalJoin => {
15003 if node_body__.is_some() {
15004 return Err(serde::de::Error::duplicate_field("temporalJoin"));
15005 }
15006 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TemporalJoin)
15007;
15008 }
15009 GeneratedField::BarrierRecv => {
15010 if node_body__.is_some() {
15011 return Err(serde::de::Error::duplicate_field("barrierRecv"));
15012 }
15013 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BarrierRecv)
15014;
15015 }
15016 GeneratedField::Values => {
15017 if node_body__.is_some() {
15018 return Err(serde::de::Error::duplicate_field("values"));
15019 }
15020 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Values)
15021;
15022 }
15023 GeneratedField::AppendOnlyDedup => {
15024 if node_body__.is_some() {
15025 return Err(serde::de::Error::duplicate_field("appendOnlyDedup"));
15026 }
15027 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyDedup)
15028;
15029 }
15030 GeneratedField::NoOp => {
15031 if node_body__.is_some() {
15032 return Err(serde::de::Error::duplicate_field("noOp"));
15033 }
15034 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::NoOp)
15035;
15036 }
15037 GeneratedField::EowcOverWindow => {
15038 if node_body__.is_some() {
15039 return Err(serde::de::Error::duplicate_field("eowcOverWindow"));
15040 }
15041 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcOverWindow)
15042;
15043 }
15044 GeneratedField::OverWindow => {
15045 if node_body__.is_some() {
15046 return Err(serde::de::Error::duplicate_field("overWindow"));
15047 }
15048 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::OverWindow)
15049;
15050 }
15051 GeneratedField::StreamFsFetch => {
15052 if node_body__.is_some() {
15053 return Err(serde::de::Error::duplicate_field("streamFsFetch"));
15054 }
15055 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamFsFetch)
15056;
15057 }
15058 GeneratedField::StreamCdcScan => {
15059 if node_body__.is_some() {
15060 return Err(serde::de::Error::duplicate_field("streamCdcScan"));
15061 }
15062 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamCdcScan)
15063;
15064 }
15065 GeneratedField::CdcFilter => {
15066 if node_body__.is_some() {
15067 return Err(serde::de::Error::duplicate_field("cdcFilter"));
15068 }
15069 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CdcFilter)
15070;
15071 }
15072 GeneratedField::SourceBackfill => {
15073 if node_body__.is_some() {
15074 return Err(serde::de::Error::duplicate_field("sourceBackfill"));
15075 }
15076 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SourceBackfill)
15077;
15078 }
15079 GeneratedField::Changelog => {
15080 if node_body__.is_some() {
15081 return Err(serde::de::Error::duplicate_field("changelog"));
15082 }
15083 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Changelog)
15084;
15085 }
15086 GeneratedField::LocalApproxPercentile => {
15087 if node_body__.is_some() {
15088 return Err(serde::de::Error::duplicate_field("localApproxPercentile"));
15089 }
15090 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalApproxPercentile)
15091;
15092 }
15093 GeneratedField::GlobalApproxPercentile => {
15094 if node_body__.is_some() {
15095 return Err(serde::de::Error::duplicate_field("globalApproxPercentile"));
15096 }
15097 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GlobalApproxPercentile)
15098;
15099 }
15100 GeneratedField::RowMerge => {
15101 if node_body__.is_some() {
15102 return Err(serde::de::Error::duplicate_field("rowMerge"));
15103 }
15104 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowMerge)
15105;
15106 }
15107 GeneratedField::AsOfJoin => {
15108 if node_body__.is_some() {
15109 return Err(serde::de::Error::duplicate_field("asOfJoin"));
15110 }
15111 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AsOfJoin)
15112;
15113 }
15114 GeneratedField::SyncLogStore => {
15115 if node_body__.is_some() {
15116 return Err(serde::de::Error::duplicate_field("syncLogStore"));
15117 }
15118 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SyncLogStore)
15119;
15120 }
15121 GeneratedField::MaterializedExprs => {
15122 if node_body__.is_some() {
15123 return Err(serde::de::Error::duplicate_field("materializedExprs"));
15124 }
15125 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MaterializedExprs)
15126;
15127 }
15128 GeneratedField::VectorIndexWrite => {
15129 if node_body__.is_some() {
15130 return Err(serde::de::Error::duplicate_field("vectorIndexWrite"));
15131 }
15132 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexWrite)
15133;
15134 }
15135 GeneratedField::UpstreamSinkUnion => {
15136 if node_body__.is_some() {
15137 return Err(serde::de::Error::duplicate_field("upstreamSinkUnion"));
15138 }
15139 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::UpstreamSinkUnion)
15140;
15141 }
15142 GeneratedField::LocalityProvider => {
15143 if node_body__.is_some() {
15144 return Err(serde::de::Error::duplicate_field("localityProvider"));
15145 }
15146 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalityProvider)
15147;
15148 }
15149 GeneratedField::EowcGapFill => {
15150 if node_body__.is_some() {
15151 return Err(serde::de::Error::duplicate_field("eowcGapFill"));
15152 }
15153 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcGapFill)
15154;
15155 }
15156 GeneratedField::GapFill => {
15157 if node_body__.is_some() {
15158 return Err(serde::de::Error::duplicate_field("gapFill"));
15159 }
15160 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GapFill)
15161;
15162 }
15163 GeneratedField::VectorIndexLookupJoin => {
15164 if node_body__.is_some() {
15165 return Err(serde::de::Error::duplicate_field("vectorIndexLookupJoin"));
15166 }
15167 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexLookupJoin)
15168;
15169 }
15170 GeneratedField::IcebergWithPkIndexWriter => {
15171 if node_body__.is_some() {
15172 return Err(serde::de::Error::duplicate_field("icebergWithPkIndexWriter"));
15173 }
15174 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::IcebergWithPkIndexWriter)
15175;
15176 }
15177 GeneratedField::IcebergWithPkIndexPositionDeleteMerger => {
15178 if node_body__.is_some() {
15179 return Err(serde::de::Error::duplicate_field("icebergWithPkIndexPositionDeleteMerger"));
15180 }
15181 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::IcebergWithPkIndexPositionDeleteMerger)
15182;
15183 }
15184 }
15185 }
15186 Ok(StreamNode {
15187 operator_id: operator_id__.unwrap_or_default(),
15188 input: input__.unwrap_or_default(),
15189 stream_key: stream_key__.unwrap_or_default(),
15190 stream_kind: stream_kind__.unwrap_or_default(),
15191 identity: identity__.unwrap_or_default(),
15192 fields: fields__.unwrap_or_default(),
15193 node_body: node_body__,
15194 })
15195 }
15196 }
15197 deserializer.deserialize_struct("stream_plan.StreamNode", FIELDS, GeneratedVisitor)
15198 }
15199}
15200impl serde::Serialize for stream_node::StreamKind {
15201 #[allow(deprecated)]
15202 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15203 where
15204 S: serde::Serializer,
15205 {
15206 let variant = match self {
15207 Self::Retract => "STREAM_KIND_RETRACT",
15208 Self::AppendOnly => "STREAM_KIND_APPEND_ONLY",
15209 Self::Upsert => "STREAM_KIND_UPSERT",
15210 };
15211 serializer.serialize_str(variant)
15212 }
15213}
15214impl<'de> serde::Deserialize<'de> for stream_node::StreamKind {
15215 #[allow(deprecated)]
15216 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15217 where
15218 D: serde::Deserializer<'de>,
15219 {
15220 const FIELDS: &[&str] = &[
15221 "STREAM_KIND_RETRACT",
15222 "STREAM_KIND_APPEND_ONLY",
15223 "STREAM_KIND_UPSERT",
15224 ];
15225
15226 struct GeneratedVisitor;
15227
15228 impl serde::de::Visitor<'_> for GeneratedVisitor {
15229 type Value = stream_node::StreamKind;
15230
15231 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15232 write!(formatter, "expected one of: {:?}", &FIELDS)
15233 }
15234
15235 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15236 where
15237 E: serde::de::Error,
15238 {
15239 i32::try_from(v)
15240 .ok()
15241 .and_then(|x| x.try_into().ok())
15242 .ok_or_else(|| {
15243 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15244 })
15245 }
15246
15247 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15248 where
15249 E: serde::de::Error,
15250 {
15251 i32::try_from(v)
15252 .ok()
15253 .and_then(|x| x.try_into().ok())
15254 .ok_or_else(|| {
15255 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15256 })
15257 }
15258
15259 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15260 where
15261 E: serde::de::Error,
15262 {
15263 match value {
15264 "STREAM_KIND_RETRACT" => Ok(stream_node::StreamKind::Retract),
15265 "STREAM_KIND_APPEND_ONLY" => Ok(stream_node::StreamKind::AppendOnly),
15266 "STREAM_KIND_UPSERT" => Ok(stream_node::StreamKind::Upsert),
15267 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15268 }
15269 }
15270 }
15271 deserializer.deserialize_any(GeneratedVisitor)
15272 }
15273}
15274impl serde::Serialize for StreamScanNode {
15275 #[allow(deprecated)]
15276 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15277 where
15278 S: serde::Serializer,
15279 {
15280 use serde::ser::SerializeStruct;
15281 let mut len = 0;
15282 if self.table_id != 0 {
15283 len += 1;
15284 }
15285 if !self.upstream_column_ids.is_empty() {
15286 len += 1;
15287 }
15288 if !self.output_indices.is_empty() {
15289 len += 1;
15290 }
15291 if self.stream_scan_type != 0 {
15292 len += 1;
15293 }
15294 if self.state_table.is_some() {
15295 len += 1;
15296 }
15297 if self.table_desc.is_some() {
15298 len += 1;
15299 }
15300 if self.rate_limit.is_some() {
15301 len += 1;
15302 }
15303 if self.snapshot_read_barrier_interval != 0 {
15304 len += 1;
15305 }
15306 if self.arrangement_table.is_some() {
15307 len += 1;
15308 }
15309 if self.snapshot_backfill_epoch.is_some() {
15310 len += 1;
15311 }
15312 if self.pk_scan_range.is_some() {
15313 len += 1;
15314 }
15315 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamScanNode", len)?;
15316 if self.table_id != 0 {
15317 struct_ser.serialize_field("tableId", &self.table_id)?;
15318 }
15319 if !self.upstream_column_ids.is_empty() {
15320 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
15321 }
15322 if !self.output_indices.is_empty() {
15323 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
15324 }
15325 if self.stream_scan_type != 0 {
15326 let v = StreamScanType::try_from(self.stream_scan_type)
15327 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_scan_type)))?;
15328 struct_ser.serialize_field("streamScanType", &v)?;
15329 }
15330 if let Some(v) = self.state_table.as_ref() {
15331 struct_ser.serialize_field("stateTable", v)?;
15332 }
15333 if let Some(v) = self.table_desc.as_ref() {
15334 struct_ser.serialize_field("tableDesc", v)?;
15335 }
15336 if let Some(v) = self.rate_limit.as_ref() {
15337 struct_ser.serialize_field("rateLimit", v)?;
15338 }
15339 if self.snapshot_read_barrier_interval != 0 {
15340 struct_ser.serialize_field("snapshotReadBarrierInterval", &self.snapshot_read_barrier_interval)?;
15341 }
15342 if let Some(v) = self.arrangement_table.as_ref() {
15343 struct_ser.serialize_field("arrangementTable", v)?;
15344 }
15345 if let Some(v) = self.snapshot_backfill_epoch.as_ref() {
15346 #[allow(clippy::needless_borrow)]
15347 #[allow(clippy::needless_borrows_for_generic_args)]
15348 struct_ser.serialize_field("snapshotBackfillEpoch", ToString::to_string(&v).as_str())?;
15349 }
15350 if let Some(v) = self.pk_scan_range.as_ref() {
15351 struct_ser.serialize_field("pkScanRange", v)?;
15352 }
15353 struct_ser.end()
15354 }
15355}
15356impl<'de> serde::Deserialize<'de> for StreamScanNode {
15357 #[allow(deprecated)]
15358 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15359 where
15360 D: serde::Deserializer<'de>,
15361 {
15362 const FIELDS: &[&str] = &[
15363 "table_id",
15364 "tableId",
15365 "upstream_column_ids",
15366 "upstreamColumnIds",
15367 "output_indices",
15368 "outputIndices",
15369 "stream_scan_type",
15370 "streamScanType",
15371 "state_table",
15372 "stateTable",
15373 "table_desc",
15374 "tableDesc",
15375 "rate_limit",
15376 "rateLimit",
15377 "snapshot_read_barrier_interval",
15378 "snapshotReadBarrierInterval",
15379 "arrangement_table",
15380 "arrangementTable",
15381 "snapshot_backfill_epoch",
15382 "snapshotBackfillEpoch",
15383 "pk_scan_range",
15384 "pkScanRange",
15385 ];
15386
15387 #[allow(clippy::enum_variant_names)]
15388 enum GeneratedField {
15389 TableId,
15390 UpstreamColumnIds,
15391 OutputIndices,
15392 StreamScanType,
15393 StateTable,
15394 TableDesc,
15395 RateLimit,
15396 SnapshotReadBarrierInterval,
15397 ArrangementTable,
15398 SnapshotBackfillEpoch,
15399 PkScanRange,
15400 }
15401 impl<'de> serde::Deserialize<'de> for GeneratedField {
15402 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15403 where
15404 D: serde::Deserializer<'de>,
15405 {
15406 struct GeneratedVisitor;
15407
15408 impl serde::de::Visitor<'_> for GeneratedVisitor {
15409 type Value = GeneratedField;
15410
15411 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15412 write!(formatter, "expected one of: {:?}", &FIELDS)
15413 }
15414
15415 #[allow(unused_variables)]
15416 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15417 where
15418 E: serde::de::Error,
15419 {
15420 match value {
15421 "tableId" | "table_id" => Ok(GeneratedField::TableId),
15422 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
15423 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
15424 "streamScanType" | "stream_scan_type" => Ok(GeneratedField::StreamScanType),
15425 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
15426 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
15427 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
15428 "snapshotReadBarrierInterval" | "snapshot_read_barrier_interval" => Ok(GeneratedField::SnapshotReadBarrierInterval),
15429 "arrangementTable" | "arrangement_table" => Ok(GeneratedField::ArrangementTable),
15430 "snapshotBackfillEpoch" | "snapshot_backfill_epoch" => Ok(GeneratedField::SnapshotBackfillEpoch),
15431 "pkScanRange" | "pk_scan_range" => Ok(GeneratedField::PkScanRange),
15432 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15433 }
15434 }
15435 }
15436 deserializer.deserialize_identifier(GeneratedVisitor)
15437 }
15438 }
15439 struct GeneratedVisitor;
15440 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15441 type Value = StreamScanNode;
15442
15443 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15444 formatter.write_str("struct stream_plan.StreamScanNode")
15445 }
15446
15447 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamScanNode, V::Error>
15448 where
15449 V: serde::de::MapAccess<'de>,
15450 {
15451 let mut table_id__ = None;
15452 let mut upstream_column_ids__ = None;
15453 let mut output_indices__ = None;
15454 let mut stream_scan_type__ = None;
15455 let mut state_table__ = None;
15456 let mut table_desc__ = None;
15457 let mut rate_limit__ = None;
15458 let mut snapshot_read_barrier_interval__ = None;
15459 let mut arrangement_table__ = None;
15460 let mut snapshot_backfill_epoch__ = None;
15461 let mut pk_scan_range__ = None;
15462 while let Some(k) = map_.next_key()? {
15463 match k {
15464 GeneratedField::TableId => {
15465 if table_id__.is_some() {
15466 return Err(serde::de::Error::duplicate_field("tableId"));
15467 }
15468 table_id__ =
15469 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15470 ;
15471 }
15472 GeneratedField::UpstreamColumnIds => {
15473 if upstream_column_ids__.is_some() {
15474 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
15475 }
15476 upstream_column_ids__ =
15477 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15478 .into_iter().map(|x| x.0).collect())
15479 ;
15480 }
15481 GeneratedField::OutputIndices => {
15482 if output_indices__.is_some() {
15483 return Err(serde::de::Error::duplicate_field("outputIndices"));
15484 }
15485 output_indices__ =
15486 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15487 .into_iter().map(|x| x.0).collect())
15488 ;
15489 }
15490 GeneratedField::StreamScanType => {
15491 if stream_scan_type__.is_some() {
15492 return Err(serde::de::Error::duplicate_field("streamScanType"));
15493 }
15494 stream_scan_type__ = Some(map_.next_value::<StreamScanType>()? as i32);
15495 }
15496 GeneratedField::StateTable => {
15497 if state_table__.is_some() {
15498 return Err(serde::de::Error::duplicate_field("stateTable"));
15499 }
15500 state_table__ = map_.next_value()?;
15501 }
15502 GeneratedField::TableDesc => {
15503 if table_desc__.is_some() {
15504 return Err(serde::de::Error::duplicate_field("tableDesc"));
15505 }
15506 table_desc__ = map_.next_value()?;
15507 }
15508 GeneratedField::RateLimit => {
15509 if rate_limit__.is_some() {
15510 return Err(serde::de::Error::duplicate_field("rateLimit"));
15511 }
15512 rate_limit__ =
15513 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15514 ;
15515 }
15516 GeneratedField::SnapshotReadBarrierInterval => {
15517 if snapshot_read_barrier_interval__.is_some() {
15518 return Err(serde::de::Error::duplicate_field("snapshotReadBarrierInterval"));
15519 }
15520 snapshot_read_barrier_interval__ =
15521 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15522 ;
15523 }
15524 GeneratedField::ArrangementTable => {
15525 if arrangement_table__.is_some() {
15526 return Err(serde::de::Error::duplicate_field("arrangementTable"));
15527 }
15528 arrangement_table__ = map_.next_value()?;
15529 }
15530 GeneratedField::SnapshotBackfillEpoch => {
15531 if snapshot_backfill_epoch__.is_some() {
15532 return Err(serde::de::Error::duplicate_field("snapshotBackfillEpoch"));
15533 }
15534 snapshot_backfill_epoch__ =
15535 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15536 ;
15537 }
15538 GeneratedField::PkScanRange => {
15539 if pk_scan_range__.is_some() {
15540 return Err(serde::de::Error::duplicate_field("pkScanRange"));
15541 }
15542 pk_scan_range__ = map_.next_value()?;
15543 }
15544 }
15545 }
15546 Ok(StreamScanNode {
15547 table_id: table_id__.unwrap_or_default(),
15548 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
15549 output_indices: output_indices__.unwrap_or_default(),
15550 stream_scan_type: stream_scan_type__.unwrap_or_default(),
15551 state_table: state_table__,
15552 table_desc: table_desc__,
15553 rate_limit: rate_limit__,
15554 snapshot_read_barrier_interval: snapshot_read_barrier_interval__.unwrap_or_default(),
15555 arrangement_table: arrangement_table__,
15556 snapshot_backfill_epoch: snapshot_backfill_epoch__,
15557 pk_scan_range: pk_scan_range__,
15558 })
15559 }
15560 }
15561 deserializer.deserialize_struct("stream_plan.StreamScanNode", FIELDS, GeneratedVisitor)
15562 }
15563}
15564impl serde::Serialize for StreamScanType {
15565 #[allow(deprecated)]
15566 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15567 where
15568 S: serde::Serializer,
15569 {
15570 let variant = match self {
15571 Self::Unspecified => "STREAM_SCAN_TYPE_UNSPECIFIED",
15572 Self::Chain => "STREAM_SCAN_TYPE_CHAIN",
15573 Self::Rearrange => "STREAM_SCAN_TYPE_REARRANGE",
15574 Self::Backfill => "STREAM_SCAN_TYPE_BACKFILL",
15575 Self::UpstreamOnly => "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
15576 Self::ArrangementBackfill => "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
15577 Self::SnapshotBackfill => "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
15578 Self::CrossDbSnapshotBackfill => "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
15579 };
15580 serializer.serialize_str(variant)
15581 }
15582}
15583impl<'de> serde::Deserialize<'de> for StreamScanType {
15584 #[allow(deprecated)]
15585 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15586 where
15587 D: serde::Deserializer<'de>,
15588 {
15589 const FIELDS: &[&str] = &[
15590 "STREAM_SCAN_TYPE_UNSPECIFIED",
15591 "STREAM_SCAN_TYPE_CHAIN",
15592 "STREAM_SCAN_TYPE_REARRANGE",
15593 "STREAM_SCAN_TYPE_BACKFILL",
15594 "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
15595 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
15596 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
15597 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
15598 ];
15599
15600 struct GeneratedVisitor;
15601
15602 impl serde::de::Visitor<'_> for GeneratedVisitor {
15603 type Value = StreamScanType;
15604
15605 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15606 write!(formatter, "expected one of: {:?}", &FIELDS)
15607 }
15608
15609 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15610 where
15611 E: serde::de::Error,
15612 {
15613 i32::try_from(v)
15614 .ok()
15615 .and_then(|x| x.try_into().ok())
15616 .ok_or_else(|| {
15617 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15618 })
15619 }
15620
15621 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15622 where
15623 E: serde::de::Error,
15624 {
15625 i32::try_from(v)
15626 .ok()
15627 .and_then(|x| x.try_into().ok())
15628 .ok_or_else(|| {
15629 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15630 })
15631 }
15632
15633 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15634 where
15635 E: serde::de::Error,
15636 {
15637 match value {
15638 "STREAM_SCAN_TYPE_UNSPECIFIED" => Ok(StreamScanType::Unspecified),
15639 "STREAM_SCAN_TYPE_CHAIN" => Ok(StreamScanType::Chain),
15640 "STREAM_SCAN_TYPE_REARRANGE" => Ok(StreamScanType::Rearrange),
15641 "STREAM_SCAN_TYPE_BACKFILL" => Ok(StreamScanType::Backfill),
15642 "STREAM_SCAN_TYPE_UPSTREAM_ONLY" => Ok(StreamScanType::UpstreamOnly),
15643 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL" => Ok(StreamScanType::ArrangementBackfill),
15644 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL" => Ok(StreamScanType::SnapshotBackfill),
15645 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL" => Ok(StreamScanType::CrossDbSnapshotBackfill),
15646 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15647 }
15648 }
15649 }
15650 deserializer.deserialize_any(GeneratedVisitor)
15651 }
15652}
15653impl serde::Serialize for StreamSource {
15654 #[allow(deprecated)]
15655 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15656 where
15657 S: serde::Serializer,
15658 {
15659 use serde::ser::SerializeStruct;
15660 let mut len = 0;
15661 if self.source_id != 0 {
15662 len += 1;
15663 }
15664 if self.state_table.is_some() {
15665 len += 1;
15666 }
15667 if self.row_id_index.is_some() {
15668 len += 1;
15669 }
15670 if !self.columns.is_empty() {
15671 len += 1;
15672 }
15673 if !self.with_properties.is_empty() {
15674 len += 1;
15675 }
15676 if self.info.is_some() {
15677 len += 1;
15678 }
15679 if !self.source_name.is_empty() {
15680 len += 1;
15681 }
15682 if self.rate_limit.is_some() {
15683 len += 1;
15684 }
15685 if !self.secret_refs.is_empty() {
15686 len += 1;
15687 }
15688 if self.downstream_columns.is_some() {
15689 len += 1;
15690 }
15691 if self.refresh_mode.is_some() {
15692 len += 1;
15693 }
15694 if self.associated_table_id.is_some() {
15695 len += 1;
15696 }
15697 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamSource", len)?;
15698 if self.source_id != 0 {
15699 struct_ser.serialize_field("sourceId", &self.source_id)?;
15700 }
15701 if let Some(v) = self.state_table.as_ref() {
15702 struct_ser.serialize_field("stateTable", v)?;
15703 }
15704 if let Some(v) = self.row_id_index.as_ref() {
15705 struct_ser.serialize_field("rowIdIndex", v)?;
15706 }
15707 if !self.columns.is_empty() {
15708 struct_ser.serialize_field("columns", &self.columns)?;
15709 }
15710 if !self.with_properties.is_empty() {
15711 struct_ser.serialize_field("withProperties", &self.with_properties)?;
15712 }
15713 if let Some(v) = self.info.as_ref() {
15714 struct_ser.serialize_field("info", v)?;
15715 }
15716 if !self.source_name.is_empty() {
15717 struct_ser.serialize_field("sourceName", &self.source_name)?;
15718 }
15719 if let Some(v) = self.rate_limit.as_ref() {
15720 struct_ser.serialize_field("rateLimit", v)?;
15721 }
15722 if !self.secret_refs.is_empty() {
15723 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
15724 }
15725 if let Some(v) = self.downstream_columns.as_ref() {
15726 struct_ser.serialize_field("downstreamColumns", v)?;
15727 }
15728 if let Some(v) = self.refresh_mode.as_ref() {
15729 struct_ser.serialize_field("refreshMode", v)?;
15730 }
15731 if let Some(v) = self.associated_table_id.as_ref() {
15732 struct_ser.serialize_field("associatedTableId", v)?;
15733 }
15734 struct_ser.end()
15735 }
15736}
15737impl<'de> serde::Deserialize<'de> for StreamSource {
15738 #[allow(deprecated)]
15739 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15740 where
15741 D: serde::Deserializer<'de>,
15742 {
15743 const FIELDS: &[&str] = &[
15744 "source_id",
15745 "sourceId",
15746 "state_table",
15747 "stateTable",
15748 "row_id_index",
15749 "rowIdIndex",
15750 "columns",
15751 "with_properties",
15752 "withProperties",
15753 "info",
15754 "source_name",
15755 "sourceName",
15756 "rate_limit",
15757 "rateLimit",
15758 "secret_refs",
15759 "secretRefs",
15760 "downstream_columns",
15761 "downstreamColumns",
15762 "refresh_mode",
15763 "refreshMode",
15764 "associated_table_id",
15765 "associatedTableId",
15766 ];
15767
15768 #[allow(clippy::enum_variant_names)]
15769 enum GeneratedField {
15770 SourceId,
15771 StateTable,
15772 RowIdIndex,
15773 Columns,
15774 WithProperties,
15775 Info,
15776 SourceName,
15777 RateLimit,
15778 SecretRefs,
15779 DownstreamColumns,
15780 RefreshMode,
15781 AssociatedTableId,
15782 }
15783 impl<'de> serde::Deserialize<'de> for GeneratedField {
15784 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15785 where
15786 D: serde::Deserializer<'de>,
15787 {
15788 struct GeneratedVisitor;
15789
15790 impl serde::de::Visitor<'_> for GeneratedVisitor {
15791 type Value = GeneratedField;
15792
15793 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15794 write!(formatter, "expected one of: {:?}", &FIELDS)
15795 }
15796
15797 #[allow(unused_variables)]
15798 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15799 where
15800 E: serde::de::Error,
15801 {
15802 match value {
15803 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
15804 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
15805 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
15806 "columns" => Ok(GeneratedField::Columns),
15807 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
15808 "info" => Ok(GeneratedField::Info),
15809 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
15810 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
15811 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
15812 "downstreamColumns" | "downstream_columns" => Ok(GeneratedField::DownstreamColumns),
15813 "refreshMode" | "refresh_mode" => Ok(GeneratedField::RefreshMode),
15814 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
15815 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15816 }
15817 }
15818 }
15819 deserializer.deserialize_identifier(GeneratedVisitor)
15820 }
15821 }
15822 struct GeneratedVisitor;
15823 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15824 type Value = StreamSource;
15825
15826 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15827 formatter.write_str("struct stream_plan.StreamSource")
15828 }
15829
15830 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSource, V::Error>
15831 where
15832 V: serde::de::MapAccess<'de>,
15833 {
15834 let mut source_id__ = None;
15835 let mut state_table__ = None;
15836 let mut row_id_index__ = None;
15837 let mut columns__ = None;
15838 let mut with_properties__ = None;
15839 let mut info__ = None;
15840 let mut source_name__ = None;
15841 let mut rate_limit__ = None;
15842 let mut secret_refs__ = None;
15843 let mut downstream_columns__ = None;
15844 let mut refresh_mode__ = None;
15845 let mut associated_table_id__ = None;
15846 while let Some(k) = map_.next_key()? {
15847 match k {
15848 GeneratedField::SourceId => {
15849 if source_id__.is_some() {
15850 return Err(serde::de::Error::duplicate_field("sourceId"));
15851 }
15852 source_id__ =
15853 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15854 ;
15855 }
15856 GeneratedField::StateTable => {
15857 if state_table__.is_some() {
15858 return Err(serde::de::Error::duplicate_field("stateTable"));
15859 }
15860 state_table__ = map_.next_value()?;
15861 }
15862 GeneratedField::RowIdIndex => {
15863 if row_id_index__.is_some() {
15864 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
15865 }
15866 row_id_index__ =
15867 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15868 ;
15869 }
15870 GeneratedField::Columns => {
15871 if columns__.is_some() {
15872 return Err(serde::de::Error::duplicate_field("columns"));
15873 }
15874 columns__ = Some(map_.next_value()?);
15875 }
15876 GeneratedField::WithProperties => {
15877 if with_properties__.is_some() {
15878 return Err(serde::de::Error::duplicate_field("withProperties"));
15879 }
15880 with_properties__ = Some(
15881 map_.next_value::<std::collections::BTreeMap<_, _>>()?
15882 );
15883 }
15884 GeneratedField::Info => {
15885 if info__.is_some() {
15886 return Err(serde::de::Error::duplicate_field("info"));
15887 }
15888 info__ = map_.next_value()?;
15889 }
15890 GeneratedField::SourceName => {
15891 if source_name__.is_some() {
15892 return Err(serde::de::Error::duplicate_field("sourceName"));
15893 }
15894 source_name__ = Some(map_.next_value()?);
15895 }
15896 GeneratedField::RateLimit => {
15897 if rate_limit__.is_some() {
15898 return Err(serde::de::Error::duplicate_field("rateLimit"));
15899 }
15900 rate_limit__ =
15901 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15902 ;
15903 }
15904 GeneratedField::SecretRefs => {
15905 if secret_refs__.is_some() {
15906 return Err(serde::de::Error::duplicate_field("secretRefs"));
15907 }
15908 secret_refs__ = Some(
15909 map_.next_value::<std::collections::BTreeMap<_, _>>()?
15910 );
15911 }
15912 GeneratedField::DownstreamColumns => {
15913 if downstream_columns__.is_some() {
15914 return Err(serde::de::Error::duplicate_field("downstreamColumns"));
15915 }
15916 downstream_columns__ = map_.next_value()?;
15917 }
15918 GeneratedField::RefreshMode => {
15919 if refresh_mode__.is_some() {
15920 return Err(serde::de::Error::duplicate_field("refreshMode"));
15921 }
15922 refresh_mode__ = map_.next_value()?;
15923 }
15924 GeneratedField::AssociatedTableId => {
15925 if associated_table_id__.is_some() {
15926 return Err(serde::de::Error::duplicate_field("associatedTableId"));
15927 }
15928 associated_table_id__ =
15929 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15930 ;
15931 }
15932 }
15933 }
15934 Ok(StreamSource {
15935 source_id: source_id__.unwrap_or_default(),
15936 state_table: state_table__,
15937 row_id_index: row_id_index__,
15938 columns: columns__.unwrap_or_default(),
15939 with_properties: with_properties__.unwrap_or_default(),
15940 info: info__,
15941 source_name: source_name__.unwrap_or_default(),
15942 rate_limit: rate_limit__,
15943 secret_refs: secret_refs__.unwrap_or_default(),
15944 downstream_columns: downstream_columns__,
15945 refresh_mode: refresh_mode__,
15946 associated_table_id: associated_table_id__,
15947 })
15948 }
15949 }
15950 deserializer.deserialize_struct("stream_plan.StreamSource", FIELDS, GeneratedVisitor)
15951 }
15952}
15953impl serde::Serialize for SubscriptionUpstreamInfo {
15954 #[allow(deprecated)]
15955 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15956 where
15957 S: serde::Serializer,
15958 {
15959 use serde::ser::SerializeStruct;
15960 let mut len = 0;
15961 if self.subscriber_id != 0 {
15962 len += 1;
15963 }
15964 if self.upstream_mv_table_id != 0 {
15965 len += 1;
15966 }
15967 let mut struct_ser = serializer.serialize_struct("stream_plan.SubscriptionUpstreamInfo", len)?;
15968 if self.subscriber_id != 0 {
15969 struct_ser.serialize_field("subscriberId", &self.subscriber_id)?;
15970 }
15971 if self.upstream_mv_table_id != 0 {
15972 struct_ser.serialize_field("upstreamMvTableId", &self.upstream_mv_table_id)?;
15973 }
15974 struct_ser.end()
15975 }
15976}
15977impl<'de> serde::Deserialize<'de> for SubscriptionUpstreamInfo {
15978 #[allow(deprecated)]
15979 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15980 where
15981 D: serde::Deserializer<'de>,
15982 {
15983 const FIELDS: &[&str] = &[
15984 "subscriber_id",
15985 "subscriberId",
15986 "upstream_mv_table_id",
15987 "upstreamMvTableId",
15988 ];
15989
15990 #[allow(clippy::enum_variant_names)]
15991 enum GeneratedField {
15992 SubscriberId,
15993 UpstreamMvTableId,
15994 }
15995 impl<'de> serde::Deserialize<'de> for GeneratedField {
15996 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15997 where
15998 D: serde::Deserializer<'de>,
15999 {
16000 struct GeneratedVisitor;
16001
16002 impl serde::de::Visitor<'_> for GeneratedVisitor {
16003 type Value = GeneratedField;
16004
16005 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16006 write!(formatter, "expected one of: {:?}", &FIELDS)
16007 }
16008
16009 #[allow(unused_variables)]
16010 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16011 where
16012 E: serde::de::Error,
16013 {
16014 match value {
16015 "subscriberId" | "subscriber_id" => Ok(GeneratedField::SubscriberId),
16016 "upstreamMvTableId" | "upstream_mv_table_id" => Ok(GeneratedField::UpstreamMvTableId),
16017 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16018 }
16019 }
16020 }
16021 deserializer.deserialize_identifier(GeneratedVisitor)
16022 }
16023 }
16024 struct GeneratedVisitor;
16025 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16026 type Value = SubscriptionUpstreamInfo;
16027
16028 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16029 formatter.write_str("struct stream_plan.SubscriptionUpstreamInfo")
16030 }
16031
16032 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscriptionUpstreamInfo, V::Error>
16033 where
16034 V: serde::de::MapAccess<'de>,
16035 {
16036 let mut subscriber_id__ = None;
16037 let mut upstream_mv_table_id__ = None;
16038 while let Some(k) = map_.next_key()? {
16039 match k {
16040 GeneratedField::SubscriberId => {
16041 if subscriber_id__.is_some() {
16042 return Err(serde::de::Error::duplicate_field("subscriberId"));
16043 }
16044 subscriber_id__ =
16045 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16046 ;
16047 }
16048 GeneratedField::UpstreamMvTableId => {
16049 if upstream_mv_table_id__.is_some() {
16050 return Err(serde::de::Error::duplicate_field("upstreamMvTableId"));
16051 }
16052 upstream_mv_table_id__ =
16053 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16054 ;
16055 }
16056 }
16057 }
16058 Ok(SubscriptionUpstreamInfo {
16059 subscriber_id: subscriber_id__.unwrap_or_default(),
16060 upstream_mv_table_id: upstream_mv_table_id__.unwrap_or_default(),
16061 })
16062 }
16063 }
16064 deserializer.deserialize_struct("stream_plan.SubscriptionUpstreamInfo", FIELDS, GeneratedVisitor)
16065 }
16066}
16067impl serde::Serialize for SyncLogStoreNode {
16068 #[allow(deprecated)]
16069 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16070 where
16071 S: serde::Serializer,
16072 {
16073 use serde::ser::SerializeStruct;
16074 let mut len = 0;
16075 if self.log_store_table.is_some() {
16076 len += 1;
16077 }
16078 if self.pause_duration_ms.is_some() {
16079 len += 1;
16080 }
16081 if self.buffer_size.is_some() {
16082 len += 1;
16083 }
16084 if self.aligned {
16085 len += 1;
16086 }
16087 let mut struct_ser = serializer.serialize_struct("stream_plan.SyncLogStoreNode", len)?;
16088 if let Some(v) = self.log_store_table.as_ref() {
16089 struct_ser.serialize_field("logStoreTable", v)?;
16090 }
16091 if let Some(v) = self.pause_duration_ms.as_ref() {
16092 struct_ser.serialize_field("pauseDurationMs", v)?;
16093 }
16094 if let Some(v) = self.buffer_size.as_ref() {
16095 struct_ser.serialize_field("bufferSize", v)?;
16096 }
16097 if self.aligned {
16098 struct_ser.serialize_field("aligned", &self.aligned)?;
16099 }
16100 struct_ser.end()
16101 }
16102}
16103impl<'de> serde::Deserialize<'de> for SyncLogStoreNode {
16104 #[allow(deprecated)]
16105 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16106 where
16107 D: serde::Deserializer<'de>,
16108 {
16109 const FIELDS: &[&str] = &[
16110 "log_store_table",
16111 "logStoreTable",
16112 "pause_duration_ms",
16113 "pauseDurationMs",
16114 "buffer_size",
16115 "bufferSize",
16116 "aligned",
16117 ];
16118
16119 #[allow(clippy::enum_variant_names)]
16120 enum GeneratedField {
16121 LogStoreTable,
16122 PauseDurationMs,
16123 BufferSize,
16124 Aligned,
16125 }
16126 impl<'de> serde::Deserialize<'de> for GeneratedField {
16127 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16128 where
16129 D: serde::Deserializer<'de>,
16130 {
16131 struct GeneratedVisitor;
16132
16133 impl serde::de::Visitor<'_> for GeneratedVisitor {
16134 type Value = GeneratedField;
16135
16136 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16137 write!(formatter, "expected one of: {:?}", &FIELDS)
16138 }
16139
16140 #[allow(unused_variables)]
16141 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16142 where
16143 E: serde::de::Error,
16144 {
16145 match value {
16146 "logStoreTable" | "log_store_table" => Ok(GeneratedField::LogStoreTable),
16147 "pauseDurationMs" | "pause_duration_ms" => Ok(GeneratedField::PauseDurationMs),
16148 "bufferSize" | "buffer_size" => Ok(GeneratedField::BufferSize),
16149 "aligned" => Ok(GeneratedField::Aligned),
16150 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16151 }
16152 }
16153 }
16154 deserializer.deserialize_identifier(GeneratedVisitor)
16155 }
16156 }
16157 struct GeneratedVisitor;
16158 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16159 type Value = SyncLogStoreNode;
16160
16161 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16162 formatter.write_str("struct stream_plan.SyncLogStoreNode")
16163 }
16164
16165 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SyncLogStoreNode, V::Error>
16166 where
16167 V: serde::de::MapAccess<'de>,
16168 {
16169 let mut log_store_table__ = None;
16170 let mut pause_duration_ms__ = None;
16171 let mut buffer_size__ = None;
16172 let mut aligned__ = None;
16173 while let Some(k) = map_.next_key()? {
16174 match k {
16175 GeneratedField::LogStoreTable => {
16176 if log_store_table__.is_some() {
16177 return Err(serde::de::Error::duplicate_field("logStoreTable"));
16178 }
16179 log_store_table__ = map_.next_value()?;
16180 }
16181 GeneratedField::PauseDurationMs => {
16182 if pause_duration_ms__.is_some() {
16183 return Err(serde::de::Error::duplicate_field("pauseDurationMs"));
16184 }
16185 pause_duration_ms__ =
16186 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16187 ;
16188 }
16189 GeneratedField::BufferSize => {
16190 if buffer_size__.is_some() {
16191 return Err(serde::de::Error::duplicate_field("bufferSize"));
16192 }
16193 buffer_size__ =
16194 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16195 ;
16196 }
16197 GeneratedField::Aligned => {
16198 if aligned__.is_some() {
16199 return Err(serde::de::Error::duplicate_field("aligned"));
16200 }
16201 aligned__ = Some(map_.next_value()?);
16202 }
16203 }
16204 }
16205 Ok(SyncLogStoreNode {
16206 log_store_table: log_store_table__,
16207 pause_duration_ms: pause_duration_ms__,
16208 buffer_size: buffer_size__,
16209 aligned: aligned__.unwrap_or_default(),
16210 })
16211 }
16212 }
16213 deserializer.deserialize_struct("stream_plan.SyncLogStoreNode", FIELDS, GeneratedVisitor)
16214 }
16215}
16216impl serde::Serialize for TemporalJoinNode {
16217 #[allow(deprecated)]
16218 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16219 where
16220 S: serde::Serializer,
16221 {
16222 use serde::ser::SerializeStruct;
16223 let mut len = 0;
16224 if self.join_type != 0 {
16225 len += 1;
16226 }
16227 if !self.left_key.is_empty() {
16228 len += 1;
16229 }
16230 if !self.right_key.is_empty() {
16231 len += 1;
16232 }
16233 if !self.null_safe.is_empty() {
16234 len += 1;
16235 }
16236 if self.condition.is_some() {
16237 len += 1;
16238 }
16239 if !self.output_indices.is_empty() {
16240 len += 1;
16241 }
16242 if self.table_desc.is_some() {
16243 len += 1;
16244 }
16245 if !self.table_output_indices.is_empty() {
16246 len += 1;
16247 }
16248 if self.memo_table.is_some() {
16249 len += 1;
16250 }
16251 if self.is_nested_loop {
16252 len += 1;
16253 }
16254 let mut struct_ser = serializer.serialize_struct("stream_plan.TemporalJoinNode", len)?;
16255 if self.join_type != 0 {
16256 let v = super::plan_common::JoinType::try_from(self.join_type)
16257 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
16258 struct_ser.serialize_field("joinType", &v)?;
16259 }
16260 if !self.left_key.is_empty() {
16261 struct_ser.serialize_field("leftKey", &self.left_key)?;
16262 }
16263 if !self.right_key.is_empty() {
16264 struct_ser.serialize_field("rightKey", &self.right_key)?;
16265 }
16266 if !self.null_safe.is_empty() {
16267 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
16268 }
16269 if let Some(v) = self.condition.as_ref() {
16270 struct_ser.serialize_field("condition", v)?;
16271 }
16272 if !self.output_indices.is_empty() {
16273 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
16274 }
16275 if let Some(v) = self.table_desc.as_ref() {
16276 struct_ser.serialize_field("tableDesc", v)?;
16277 }
16278 if !self.table_output_indices.is_empty() {
16279 struct_ser.serialize_field("tableOutputIndices", &self.table_output_indices)?;
16280 }
16281 if let Some(v) = self.memo_table.as_ref() {
16282 struct_ser.serialize_field("memoTable", v)?;
16283 }
16284 if self.is_nested_loop {
16285 struct_ser.serialize_field("isNestedLoop", &self.is_nested_loop)?;
16286 }
16287 struct_ser.end()
16288 }
16289}
16290impl<'de> serde::Deserialize<'de> for TemporalJoinNode {
16291 #[allow(deprecated)]
16292 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16293 where
16294 D: serde::Deserializer<'de>,
16295 {
16296 const FIELDS: &[&str] = &[
16297 "join_type",
16298 "joinType",
16299 "left_key",
16300 "leftKey",
16301 "right_key",
16302 "rightKey",
16303 "null_safe",
16304 "nullSafe",
16305 "condition",
16306 "output_indices",
16307 "outputIndices",
16308 "table_desc",
16309 "tableDesc",
16310 "table_output_indices",
16311 "tableOutputIndices",
16312 "memo_table",
16313 "memoTable",
16314 "is_nested_loop",
16315 "isNestedLoop",
16316 ];
16317
16318 #[allow(clippy::enum_variant_names)]
16319 enum GeneratedField {
16320 JoinType,
16321 LeftKey,
16322 RightKey,
16323 NullSafe,
16324 Condition,
16325 OutputIndices,
16326 TableDesc,
16327 TableOutputIndices,
16328 MemoTable,
16329 IsNestedLoop,
16330 }
16331 impl<'de> serde::Deserialize<'de> for GeneratedField {
16332 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16333 where
16334 D: serde::Deserializer<'de>,
16335 {
16336 struct GeneratedVisitor;
16337
16338 impl serde::de::Visitor<'_> for GeneratedVisitor {
16339 type Value = GeneratedField;
16340
16341 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16342 write!(formatter, "expected one of: {:?}", &FIELDS)
16343 }
16344
16345 #[allow(unused_variables)]
16346 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16347 where
16348 E: serde::de::Error,
16349 {
16350 match value {
16351 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
16352 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
16353 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
16354 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
16355 "condition" => Ok(GeneratedField::Condition),
16356 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
16357 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
16358 "tableOutputIndices" | "table_output_indices" => Ok(GeneratedField::TableOutputIndices),
16359 "memoTable" | "memo_table" => Ok(GeneratedField::MemoTable),
16360 "isNestedLoop" | "is_nested_loop" => Ok(GeneratedField::IsNestedLoop),
16361 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16362 }
16363 }
16364 }
16365 deserializer.deserialize_identifier(GeneratedVisitor)
16366 }
16367 }
16368 struct GeneratedVisitor;
16369 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16370 type Value = TemporalJoinNode;
16371
16372 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16373 formatter.write_str("struct stream_plan.TemporalJoinNode")
16374 }
16375
16376 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TemporalJoinNode, V::Error>
16377 where
16378 V: serde::de::MapAccess<'de>,
16379 {
16380 let mut join_type__ = None;
16381 let mut left_key__ = None;
16382 let mut right_key__ = None;
16383 let mut null_safe__ = None;
16384 let mut condition__ = None;
16385 let mut output_indices__ = None;
16386 let mut table_desc__ = None;
16387 let mut table_output_indices__ = None;
16388 let mut memo_table__ = None;
16389 let mut is_nested_loop__ = None;
16390 while let Some(k) = map_.next_key()? {
16391 match k {
16392 GeneratedField::JoinType => {
16393 if join_type__.is_some() {
16394 return Err(serde::de::Error::duplicate_field("joinType"));
16395 }
16396 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
16397 }
16398 GeneratedField::LeftKey => {
16399 if left_key__.is_some() {
16400 return Err(serde::de::Error::duplicate_field("leftKey"));
16401 }
16402 left_key__ =
16403 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16404 .into_iter().map(|x| x.0).collect())
16405 ;
16406 }
16407 GeneratedField::RightKey => {
16408 if right_key__.is_some() {
16409 return Err(serde::de::Error::duplicate_field("rightKey"));
16410 }
16411 right_key__ =
16412 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16413 .into_iter().map(|x| x.0).collect())
16414 ;
16415 }
16416 GeneratedField::NullSafe => {
16417 if null_safe__.is_some() {
16418 return Err(serde::de::Error::duplicate_field("nullSafe"));
16419 }
16420 null_safe__ = Some(map_.next_value()?);
16421 }
16422 GeneratedField::Condition => {
16423 if condition__.is_some() {
16424 return Err(serde::de::Error::duplicate_field("condition"));
16425 }
16426 condition__ = map_.next_value()?;
16427 }
16428 GeneratedField::OutputIndices => {
16429 if output_indices__.is_some() {
16430 return Err(serde::de::Error::duplicate_field("outputIndices"));
16431 }
16432 output_indices__ =
16433 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16434 .into_iter().map(|x| x.0).collect())
16435 ;
16436 }
16437 GeneratedField::TableDesc => {
16438 if table_desc__.is_some() {
16439 return Err(serde::de::Error::duplicate_field("tableDesc"));
16440 }
16441 table_desc__ = map_.next_value()?;
16442 }
16443 GeneratedField::TableOutputIndices => {
16444 if table_output_indices__.is_some() {
16445 return Err(serde::de::Error::duplicate_field("tableOutputIndices"));
16446 }
16447 table_output_indices__ =
16448 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16449 .into_iter().map(|x| x.0).collect())
16450 ;
16451 }
16452 GeneratedField::MemoTable => {
16453 if memo_table__.is_some() {
16454 return Err(serde::de::Error::duplicate_field("memoTable"));
16455 }
16456 memo_table__ = map_.next_value()?;
16457 }
16458 GeneratedField::IsNestedLoop => {
16459 if is_nested_loop__.is_some() {
16460 return Err(serde::de::Error::duplicate_field("isNestedLoop"));
16461 }
16462 is_nested_loop__ = Some(map_.next_value()?);
16463 }
16464 }
16465 }
16466 Ok(TemporalJoinNode {
16467 join_type: join_type__.unwrap_or_default(),
16468 left_key: left_key__.unwrap_or_default(),
16469 right_key: right_key__.unwrap_or_default(),
16470 null_safe: null_safe__.unwrap_or_default(),
16471 condition: condition__,
16472 output_indices: output_indices__.unwrap_or_default(),
16473 table_desc: table_desc__,
16474 table_output_indices: table_output_indices__.unwrap_or_default(),
16475 memo_table: memo_table__,
16476 is_nested_loop: is_nested_loop__.unwrap_or_default(),
16477 })
16478 }
16479 }
16480 deserializer.deserialize_struct("stream_plan.TemporalJoinNode", FIELDS, GeneratedVisitor)
16481 }
16482}
16483impl serde::Serialize for ThrottleMutation {
16484 #[allow(deprecated)]
16485 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16486 where
16487 S: serde::Serializer,
16488 {
16489 use serde::ser::SerializeStruct;
16490 let mut len = 0;
16491 if !self.fragment_throttle.is_empty() {
16492 len += 1;
16493 }
16494 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation", len)?;
16495 if !self.fragment_throttle.is_empty() {
16496 struct_ser.serialize_field("fragmentThrottle", &self.fragment_throttle)?;
16497 }
16498 struct_ser.end()
16499 }
16500}
16501impl<'de> serde::Deserialize<'de> for ThrottleMutation {
16502 #[allow(deprecated)]
16503 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16504 where
16505 D: serde::Deserializer<'de>,
16506 {
16507 const FIELDS: &[&str] = &[
16508 "fragment_throttle",
16509 "fragmentThrottle",
16510 ];
16511
16512 #[allow(clippy::enum_variant_names)]
16513 enum GeneratedField {
16514 FragmentThrottle,
16515 }
16516 impl<'de> serde::Deserialize<'de> for GeneratedField {
16517 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16518 where
16519 D: serde::Deserializer<'de>,
16520 {
16521 struct GeneratedVisitor;
16522
16523 impl serde::de::Visitor<'_> for GeneratedVisitor {
16524 type Value = GeneratedField;
16525
16526 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16527 write!(formatter, "expected one of: {:?}", &FIELDS)
16528 }
16529
16530 #[allow(unused_variables)]
16531 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16532 where
16533 E: serde::de::Error,
16534 {
16535 match value {
16536 "fragmentThrottle" | "fragment_throttle" => Ok(GeneratedField::FragmentThrottle),
16537 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16538 }
16539 }
16540 }
16541 deserializer.deserialize_identifier(GeneratedVisitor)
16542 }
16543 }
16544 struct GeneratedVisitor;
16545 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16546 type Value = ThrottleMutation;
16547
16548 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16549 formatter.write_str("struct stream_plan.ThrottleMutation")
16550 }
16551
16552 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ThrottleMutation, V::Error>
16553 where
16554 V: serde::de::MapAccess<'de>,
16555 {
16556 let mut fragment_throttle__ = None;
16557 while let Some(k) = map_.next_key()? {
16558 match k {
16559 GeneratedField::FragmentThrottle => {
16560 if fragment_throttle__.is_some() {
16561 return Err(serde::de::Error::duplicate_field("fragmentThrottle"));
16562 }
16563 fragment_throttle__ = Some(
16564 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
16565 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
16566 );
16567 }
16568 }
16569 }
16570 Ok(ThrottleMutation {
16571 fragment_throttle: fragment_throttle__.unwrap_or_default(),
16572 })
16573 }
16574 }
16575 deserializer.deserialize_struct("stream_plan.ThrottleMutation", FIELDS, GeneratedVisitor)
16576 }
16577}
16578impl serde::Serialize for throttle_mutation::ThrottleConfig {
16579 #[allow(deprecated)]
16580 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16581 where
16582 S: serde::Serializer,
16583 {
16584 use serde::ser::SerializeStruct;
16585 let mut len = 0;
16586 if self.rate_limit.is_some() {
16587 len += 1;
16588 }
16589 if self.throttle_type != 0 {
16590 len += 1;
16591 }
16592 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation.ThrottleConfig", len)?;
16593 if let Some(v) = self.rate_limit.as_ref() {
16594 struct_ser.serialize_field("rateLimit", v)?;
16595 }
16596 if self.throttle_type != 0 {
16597 let v = super::common::ThrottleType::try_from(self.throttle_type)
16598 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.throttle_type)))?;
16599 struct_ser.serialize_field("throttleType", &v)?;
16600 }
16601 struct_ser.end()
16602 }
16603}
16604impl<'de> serde::Deserialize<'de> for throttle_mutation::ThrottleConfig {
16605 #[allow(deprecated)]
16606 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16607 where
16608 D: serde::Deserializer<'de>,
16609 {
16610 const FIELDS: &[&str] = &[
16611 "rate_limit",
16612 "rateLimit",
16613 "throttle_type",
16614 "throttleType",
16615 ];
16616
16617 #[allow(clippy::enum_variant_names)]
16618 enum GeneratedField {
16619 RateLimit,
16620 ThrottleType,
16621 }
16622 impl<'de> serde::Deserialize<'de> for GeneratedField {
16623 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16624 where
16625 D: serde::Deserializer<'de>,
16626 {
16627 struct GeneratedVisitor;
16628
16629 impl serde::de::Visitor<'_> for GeneratedVisitor {
16630 type Value = GeneratedField;
16631
16632 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16633 write!(formatter, "expected one of: {:?}", &FIELDS)
16634 }
16635
16636 #[allow(unused_variables)]
16637 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16638 where
16639 E: serde::de::Error,
16640 {
16641 match value {
16642 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
16643 "throttleType" | "throttle_type" => Ok(GeneratedField::ThrottleType),
16644 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16645 }
16646 }
16647 }
16648 deserializer.deserialize_identifier(GeneratedVisitor)
16649 }
16650 }
16651 struct GeneratedVisitor;
16652 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16653 type Value = throttle_mutation::ThrottleConfig;
16654
16655 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16656 formatter.write_str("struct stream_plan.ThrottleMutation.ThrottleConfig")
16657 }
16658
16659 fn visit_map<V>(self, mut map_: V) -> std::result::Result<throttle_mutation::ThrottleConfig, V::Error>
16660 where
16661 V: serde::de::MapAccess<'de>,
16662 {
16663 let mut rate_limit__ = None;
16664 let mut throttle_type__ = None;
16665 while let Some(k) = map_.next_key()? {
16666 match k {
16667 GeneratedField::RateLimit => {
16668 if rate_limit__.is_some() {
16669 return Err(serde::de::Error::duplicate_field("rateLimit"));
16670 }
16671 rate_limit__ =
16672 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16673 ;
16674 }
16675 GeneratedField::ThrottleType => {
16676 if throttle_type__.is_some() {
16677 return Err(serde::de::Error::duplicate_field("throttleType"));
16678 }
16679 throttle_type__ = Some(map_.next_value::<super::common::ThrottleType>()? as i32);
16680 }
16681 }
16682 }
16683 Ok(throttle_mutation::ThrottleConfig {
16684 rate_limit: rate_limit__,
16685 throttle_type: throttle_type__.unwrap_or_default(),
16686 })
16687 }
16688 }
16689 deserializer.deserialize_struct("stream_plan.ThrottleMutation.ThrottleConfig", FIELDS, GeneratedVisitor)
16690 }
16691}
16692impl serde::Serialize for TopNNode {
16693 #[allow(deprecated)]
16694 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16695 where
16696 S: serde::Serializer,
16697 {
16698 use serde::ser::SerializeStruct;
16699 let mut len = 0;
16700 if self.limit != 0 {
16701 len += 1;
16702 }
16703 if self.offset != 0 {
16704 len += 1;
16705 }
16706 if self.table.is_some() {
16707 len += 1;
16708 }
16709 if !self.order_by.is_empty() {
16710 len += 1;
16711 }
16712 if self.with_ties {
16713 len += 1;
16714 }
16715 let mut struct_ser = serializer.serialize_struct("stream_plan.TopNNode", len)?;
16716 if self.limit != 0 {
16717 #[allow(clippy::needless_borrow)]
16718 #[allow(clippy::needless_borrows_for_generic_args)]
16719 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
16720 }
16721 if self.offset != 0 {
16722 #[allow(clippy::needless_borrow)]
16723 #[allow(clippy::needless_borrows_for_generic_args)]
16724 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
16725 }
16726 if let Some(v) = self.table.as_ref() {
16727 struct_ser.serialize_field("table", v)?;
16728 }
16729 if !self.order_by.is_empty() {
16730 struct_ser.serialize_field("orderBy", &self.order_by)?;
16731 }
16732 if self.with_ties {
16733 struct_ser.serialize_field("withTies", &self.with_ties)?;
16734 }
16735 struct_ser.end()
16736 }
16737}
16738impl<'de> serde::Deserialize<'de> for TopNNode {
16739 #[allow(deprecated)]
16740 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16741 where
16742 D: serde::Deserializer<'de>,
16743 {
16744 const FIELDS: &[&str] = &[
16745 "limit",
16746 "offset",
16747 "table",
16748 "order_by",
16749 "orderBy",
16750 "with_ties",
16751 "withTies",
16752 ];
16753
16754 #[allow(clippy::enum_variant_names)]
16755 enum GeneratedField {
16756 Limit,
16757 Offset,
16758 Table,
16759 OrderBy,
16760 WithTies,
16761 }
16762 impl<'de> serde::Deserialize<'de> for GeneratedField {
16763 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16764 where
16765 D: serde::Deserializer<'de>,
16766 {
16767 struct GeneratedVisitor;
16768
16769 impl serde::de::Visitor<'_> for GeneratedVisitor {
16770 type Value = GeneratedField;
16771
16772 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16773 write!(formatter, "expected one of: {:?}", &FIELDS)
16774 }
16775
16776 #[allow(unused_variables)]
16777 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16778 where
16779 E: serde::de::Error,
16780 {
16781 match value {
16782 "limit" => Ok(GeneratedField::Limit),
16783 "offset" => Ok(GeneratedField::Offset),
16784 "table" => Ok(GeneratedField::Table),
16785 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
16786 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
16787 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16788 }
16789 }
16790 }
16791 deserializer.deserialize_identifier(GeneratedVisitor)
16792 }
16793 }
16794 struct GeneratedVisitor;
16795 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16796 type Value = TopNNode;
16797
16798 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16799 formatter.write_str("struct stream_plan.TopNNode")
16800 }
16801
16802 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
16803 where
16804 V: serde::de::MapAccess<'de>,
16805 {
16806 let mut limit__ = None;
16807 let mut offset__ = None;
16808 let mut table__ = None;
16809 let mut order_by__ = None;
16810 let mut with_ties__ = None;
16811 while let Some(k) = map_.next_key()? {
16812 match k {
16813 GeneratedField::Limit => {
16814 if limit__.is_some() {
16815 return Err(serde::de::Error::duplicate_field("limit"));
16816 }
16817 limit__ =
16818 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16819 ;
16820 }
16821 GeneratedField::Offset => {
16822 if offset__.is_some() {
16823 return Err(serde::de::Error::duplicate_field("offset"));
16824 }
16825 offset__ =
16826 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16827 ;
16828 }
16829 GeneratedField::Table => {
16830 if table__.is_some() {
16831 return Err(serde::de::Error::duplicate_field("table"));
16832 }
16833 table__ = map_.next_value()?;
16834 }
16835 GeneratedField::OrderBy => {
16836 if order_by__.is_some() {
16837 return Err(serde::de::Error::duplicate_field("orderBy"));
16838 }
16839 order_by__ = Some(map_.next_value()?);
16840 }
16841 GeneratedField::WithTies => {
16842 if with_ties__.is_some() {
16843 return Err(serde::de::Error::duplicate_field("withTies"));
16844 }
16845 with_ties__ = Some(map_.next_value()?);
16846 }
16847 }
16848 }
16849 Ok(TopNNode {
16850 limit: limit__.unwrap_or_default(),
16851 offset: offset__.unwrap_or_default(),
16852 table: table__,
16853 order_by: order_by__.unwrap_or_default(),
16854 with_ties: with_ties__.unwrap_or_default(),
16855 })
16856 }
16857 }
16858 deserializer.deserialize_struct("stream_plan.TopNNode", FIELDS, GeneratedVisitor)
16859 }
16860}
16861impl serde::Serialize for UnionNode {
16862 #[allow(deprecated)]
16863 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16864 where
16865 S: serde::Serializer,
16866 {
16867 use serde::ser::SerializeStruct;
16868 let len = 0;
16869 let struct_ser = serializer.serialize_struct("stream_plan.UnionNode", len)?;
16870 struct_ser.end()
16871 }
16872}
16873impl<'de> serde::Deserialize<'de> for UnionNode {
16874 #[allow(deprecated)]
16875 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16876 where
16877 D: serde::Deserializer<'de>,
16878 {
16879 const FIELDS: &[&str] = &[
16880 ];
16881
16882 #[allow(clippy::enum_variant_names)]
16883 enum GeneratedField {
16884 }
16885 impl<'de> serde::Deserialize<'de> for GeneratedField {
16886 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16887 where
16888 D: serde::Deserializer<'de>,
16889 {
16890 struct GeneratedVisitor;
16891
16892 impl serde::de::Visitor<'_> for GeneratedVisitor {
16893 type Value = GeneratedField;
16894
16895 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16896 write!(formatter, "expected one of: {:?}", &FIELDS)
16897 }
16898
16899 #[allow(unused_variables)]
16900 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16901 where
16902 E: serde::de::Error,
16903 {
16904 Err(serde::de::Error::unknown_field(value, FIELDS))
16905 }
16906 }
16907 deserializer.deserialize_identifier(GeneratedVisitor)
16908 }
16909 }
16910 struct GeneratedVisitor;
16911 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16912 type Value = UnionNode;
16913
16914 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16915 formatter.write_str("struct stream_plan.UnionNode")
16916 }
16917
16918 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
16919 where
16920 V: serde::de::MapAccess<'de>,
16921 {
16922 while map_.next_key::<GeneratedField>()?.is_some() {
16923 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16924 }
16925 Ok(UnionNode {
16926 })
16927 }
16928 }
16929 deserializer.deserialize_struct("stream_plan.UnionNode", FIELDS, GeneratedVisitor)
16930 }
16931}
16932impl serde::Serialize for UpdateMutation {
16933 #[allow(deprecated)]
16934 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16935 where
16936 S: serde::Serializer,
16937 {
16938 use serde::ser::SerializeStruct;
16939 let mut len = 0;
16940 if !self.dispatcher_update.is_empty() {
16941 len += 1;
16942 }
16943 if !self.merge_update.is_empty() {
16944 len += 1;
16945 }
16946 if !self.actor_vnode_bitmap_update.is_empty() {
16947 len += 1;
16948 }
16949 if !self.dropped_actors.is_empty() {
16950 len += 1;
16951 }
16952 if !self.actor_splits.is_empty() {
16953 len += 1;
16954 }
16955 if !self.actor_new_dispatchers.is_empty() {
16956 len += 1;
16957 }
16958 if self.actor_cdc_table_snapshot_splits.is_some() {
16959 len += 1;
16960 }
16961 if !self.sink_schema_change.is_empty() {
16962 len += 1;
16963 }
16964 if !self.subscriptions_to_drop.is_empty() {
16965 len += 1;
16966 }
16967 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation", len)?;
16968 if !self.dispatcher_update.is_empty() {
16969 struct_ser.serialize_field("dispatcherUpdate", &self.dispatcher_update)?;
16970 }
16971 if !self.merge_update.is_empty() {
16972 struct_ser.serialize_field("mergeUpdate", &self.merge_update)?;
16973 }
16974 if !self.actor_vnode_bitmap_update.is_empty() {
16975 struct_ser.serialize_field("actorVnodeBitmapUpdate", &self.actor_vnode_bitmap_update)?;
16976 }
16977 if !self.dropped_actors.is_empty() {
16978 struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
16979 }
16980 if !self.actor_splits.is_empty() {
16981 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
16982 }
16983 if !self.actor_new_dispatchers.is_empty() {
16984 struct_ser.serialize_field("actorNewDispatchers", &self.actor_new_dispatchers)?;
16985 }
16986 if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
16987 struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
16988 }
16989 if !self.sink_schema_change.is_empty() {
16990 struct_ser.serialize_field("sinkSchemaChange", &self.sink_schema_change)?;
16991 }
16992 if !self.subscriptions_to_drop.is_empty() {
16993 struct_ser.serialize_field("subscriptionsToDrop", &self.subscriptions_to_drop)?;
16994 }
16995 struct_ser.end()
16996 }
16997}
16998impl<'de> serde::Deserialize<'de> for UpdateMutation {
16999 #[allow(deprecated)]
17000 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17001 where
17002 D: serde::Deserializer<'de>,
17003 {
17004 const FIELDS: &[&str] = &[
17005 "dispatcher_update",
17006 "dispatcherUpdate",
17007 "merge_update",
17008 "mergeUpdate",
17009 "actor_vnode_bitmap_update",
17010 "actorVnodeBitmapUpdate",
17011 "dropped_actors",
17012 "droppedActors",
17013 "actor_splits",
17014 "actorSplits",
17015 "actor_new_dispatchers",
17016 "actorNewDispatchers",
17017 "actor_cdc_table_snapshot_splits",
17018 "actorCdcTableSnapshotSplits",
17019 "sink_schema_change",
17020 "sinkSchemaChange",
17021 "subscriptions_to_drop",
17022 "subscriptionsToDrop",
17023 ];
17024
17025 #[allow(clippy::enum_variant_names)]
17026 enum GeneratedField {
17027 DispatcherUpdate,
17028 MergeUpdate,
17029 ActorVnodeBitmapUpdate,
17030 DroppedActors,
17031 ActorSplits,
17032 ActorNewDispatchers,
17033 ActorCdcTableSnapshotSplits,
17034 SinkSchemaChange,
17035 SubscriptionsToDrop,
17036 }
17037 impl<'de> serde::Deserialize<'de> for GeneratedField {
17038 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17039 where
17040 D: serde::Deserializer<'de>,
17041 {
17042 struct GeneratedVisitor;
17043
17044 impl serde::de::Visitor<'_> for GeneratedVisitor {
17045 type Value = GeneratedField;
17046
17047 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17048 write!(formatter, "expected one of: {:?}", &FIELDS)
17049 }
17050
17051 #[allow(unused_variables)]
17052 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17053 where
17054 E: serde::de::Error,
17055 {
17056 match value {
17057 "dispatcherUpdate" | "dispatcher_update" => Ok(GeneratedField::DispatcherUpdate),
17058 "mergeUpdate" | "merge_update" => Ok(GeneratedField::MergeUpdate),
17059 "actorVnodeBitmapUpdate" | "actor_vnode_bitmap_update" => Ok(GeneratedField::ActorVnodeBitmapUpdate),
17060 "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
17061 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
17062 "actorNewDispatchers" | "actor_new_dispatchers" => Ok(GeneratedField::ActorNewDispatchers),
17063 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
17064 "sinkSchemaChange" | "sink_schema_change" => Ok(GeneratedField::SinkSchemaChange),
17065 "subscriptionsToDrop" | "subscriptions_to_drop" => Ok(GeneratedField::SubscriptionsToDrop),
17066 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17067 }
17068 }
17069 }
17070 deserializer.deserialize_identifier(GeneratedVisitor)
17071 }
17072 }
17073 struct GeneratedVisitor;
17074 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17075 type Value = UpdateMutation;
17076
17077 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17078 formatter.write_str("struct stream_plan.UpdateMutation")
17079 }
17080
17081 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateMutation, V::Error>
17082 where
17083 V: serde::de::MapAccess<'de>,
17084 {
17085 let mut dispatcher_update__ = None;
17086 let mut merge_update__ = None;
17087 let mut actor_vnode_bitmap_update__ = None;
17088 let mut dropped_actors__ = None;
17089 let mut actor_splits__ = None;
17090 let mut actor_new_dispatchers__ = None;
17091 let mut actor_cdc_table_snapshot_splits__ = None;
17092 let mut sink_schema_change__ = None;
17093 let mut subscriptions_to_drop__ = None;
17094 while let Some(k) = map_.next_key()? {
17095 match k {
17096 GeneratedField::DispatcherUpdate => {
17097 if dispatcher_update__.is_some() {
17098 return Err(serde::de::Error::duplicate_field("dispatcherUpdate"));
17099 }
17100 dispatcher_update__ = Some(map_.next_value()?);
17101 }
17102 GeneratedField::MergeUpdate => {
17103 if merge_update__.is_some() {
17104 return Err(serde::de::Error::duplicate_field("mergeUpdate"));
17105 }
17106 merge_update__ = Some(map_.next_value()?);
17107 }
17108 GeneratedField::ActorVnodeBitmapUpdate => {
17109 if actor_vnode_bitmap_update__.is_some() {
17110 return Err(serde::de::Error::duplicate_field("actorVnodeBitmapUpdate"));
17111 }
17112 actor_vnode_bitmap_update__ = Some(
17113 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
17114 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
17115 );
17116 }
17117 GeneratedField::DroppedActors => {
17118 if dropped_actors__.is_some() {
17119 return Err(serde::de::Error::duplicate_field("droppedActors"));
17120 }
17121 dropped_actors__ =
17122 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17123 .into_iter().map(|x| x.0).collect())
17124 ;
17125 }
17126 GeneratedField::ActorSplits => {
17127 if actor_splits__.is_some() {
17128 return Err(serde::de::Error::duplicate_field("actorSplits"));
17129 }
17130 actor_splits__ = Some(
17131 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
17132 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
17133 );
17134 }
17135 GeneratedField::ActorNewDispatchers => {
17136 if actor_new_dispatchers__.is_some() {
17137 return Err(serde::de::Error::duplicate_field("actorNewDispatchers"));
17138 }
17139 actor_new_dispatchers__ = Some(
17140 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
17141 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
17142 );
17143 }
17144 GeneratedField::ActorCdcTableSnapshotSplits => {
17145 if actor_cdc_table_snapshot_splits__.is_some() {
17146 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
17147 }
17148 actor_cdc_table_snapshot_splits__ = map_.next_value()?;
17149 }
17150 GeneratedField::SinkSchemaChange => {
17151 if sink_schema_change__.is_some() {
17152 return Err(serde::de::Error::duplicate_field("sinkSchemaChange"));
17153 }
17154 sink_schema_change__ = Some(
17155 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
17156 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
17157 );
17158 }
17159 GeneratedField::SubscriptionsToDrop => {
17160 if subscriptions_to_drop__.is_some() {
17161 return Err(serde::de::Error::duplicate_field("subscriptionsToDrop"));
17162 }
17163 subscriptions_to_drop__ = Some(map_.next_value()?);
17164 }
17165 }
17166 }
17167 Ok(UpdateMutation {
17168 dispatcher_update: dispatcher_update__.unwrap_or_default(),
17169 merge_update: merge_update__.unwrap_or_default(),
17170 actor_vnode_bitmap_update: actor_vnode_bitmap_update__.unwrap_or_default(),
17171 dropped_actors: dropped_actors__.unwrap_or_default(),
17172 actor_splits: actor_splits__.unwrap_or_default(),
17173 actor_new_dispatchers: actor_new_dispatchers__.unwrap_or_default(),
17174 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
17175 sink_schema_change: sink_schema_change__.unwrap_or_default(),
17176 subscriptions_to_drop: subscriptions_to_drop__.unwrap_or_default(),
17177 })
17178 }
17179 }
17180 deserializer.deserialize_struct("stream_plan.UpdateMutation", FIELDS, GeneratedVisitor)
17181 }
17182}
17183impl serde::Serialize for update_mutation::DispatcherUpdate {
17184 #[allow(deprecated)]
17185 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17186 where
17187 S: serde::Serializer,
17188 {
17189 use serde::ser::SerializeStruct;
17190 let mut len = 0;
17191 if self.actor_id != 0 {
17192 len += 1;
17193 }
17194 if self.dispatcher_id != 0 {
17195 len += 1;
17196 }
17197 if self.hash_mapping.is_some() {
17198 len += 1;
17199 }
17200 if !self.added_downstream_actor_id.is_empty() {
17201 len += 1;
17202 }
17203 if !self.removed_downstream_actor_id.is_empty() {
17204 len += 1;
17205 }
17206 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", len)?;
17207 if self.actor_id != 0 {
17208 struct_ser.serialize_field("actorId", &self.actor_id)?;
17209 }
17210 if self.dispatcher_id != 0 {
17211 struct_ser.serialize_field("dispatcherId", &self.dispatcher_id)?;
17212 }
17213 if let Some(v) = self.hash_mapping.as_ref() {
17214 struct_ser.serialize_field("hashMapping", v)?;
17215 }
17216 if !self.added_downstream_actor_id.is_empty() {
17217 struct_ser.serialize_field("addedDownstreamActorId", &self.added_downstream_actor_id)?;
17218 }
17219 if !self.removed_downstream_actor_id.is_empty() {
17220 struct_ser.serialize_field("removedDownstreamActorId", &self.removed_downstream_actor_id)?;
17221 }
17222 struct_ser.end()
17223 }
17224}
17225impl<'de> serde::Deserialize<'de> for update_mutation::DispatcherUpdate {
17226 #[allow(deprecated)]
17227 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17228 where
17229 D: serde::Deserializer<'de>,
17230 {
17231 const FIELDS: &[&str] = &[
17232 "actor_id",
17233 "actorId",
17234 "dispatcher_id",
17235 "dispatcherId",
17236 "hash_mapping",
17237 "hashMapping",
17238 "added_downstream_actor_id",
17239 "addedDownstreamActorId",
17240 "removed_downstream_actor_id",
17241 "removedDownstreamActorId",
17242 ];
17243
17244 #[allow(clippy::enum_variant_names)]
17245 enum GeneratedField {
17246 ActorId,
17247 DispatcherId,
17248 HashMapping,
17249 AddedDownstreamActorId,
17250 RemovedDownstreamActorId,
17251 }
17252 impl<'de> serde::Deserialize<'de> for GeneratedField {
17253 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17254 where
17255 D: serde::Deserializer<'de>,
17256 {
17257 struct GeneratedVisitor;
17258
17259 impl serde::de::Visitor<'_> for GeneratedVisitor {
17260 type Value = GeneratedField;
17261
17262 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17263 write!(formatter, "expected one of: {:?}", &FIELDS)
17264 }
17265
17266 #[allow(unused_variables)]
17267 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17268 where
17269 E: serde::de::Error,
17270 {
17271 match value {
17272 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
17273 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
17274 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
17275 "addedDownstreamActorId" | "added_downstream_actor_id" => Ok(GeneratedField::AddedDownstreamActorId),
17276 "removedDownstreamActorId" | "removed_downstream_actor_id" => Ok(GeneratedField::RemovedDownstreamActorId),
17277 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17278 }
17279 }
17280 }
17281 deserializer.deserialize_identifier(GeneratedVisitor)
17282 }
17283 }
17284 struct GeneratedVisitor;
17285 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17286 type Value = update_mutation::DispatcherUpdate;
17287
17288 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17289 formatter.write_str("struct stream_plan.UpdateMutation.DispatcherUpdate")
17290 }
17291
17292 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::DispatcherUpdate, V::Error>
17293 where
17294 V: serde::de::MapAccess<'de>,
17295 {
17296 let mut actor_id__ = None;
17297 let mut dispatcher_id__ = None;
17298 let mut hash_mapping__ = None;
17299 let mut added_downstream_actor_id__ = None;
17300 let mut removed_downstream_actor_id__ = None;
17301 while let Some(k) = map_.next_key()? {
17302 match k {
17303 GeneratedField::ActorId => {
17304 if actor_id__.is_some() {
17305 return Err(serde::de::Error::duplicate_field("actorId"));
17306 }
17307 actor_id__ =
17308 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17309 ;
17310 }
17311 GeneratedField::DispatcherId => {
17312 if dispatcher_id__.is_some() {
17313 return Err(serde::de::Error::duplicate_field("dispatcherId"));
17314 }
17315 dispatcher_id__ =
17316 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17317 ;
17318 }
17319 GeneratedField::HashMapping => {
17320 if hash_mapping__.is_some() {
17321 return Err(serde::de::Error::duplicate_field("hashMapping"));
17322 }
17323 hash_mapping__ = map_.next_value()?;
17324 }
17325 GeneratedField::AddedDownstreamActorId => {
17326 if added_downstream_actor_id__.is_some() {
17327 return Err(serde::de::Error::duplicate_field("addedDownstreamActorId"));
17328 }
17329 added_downstream_actor_id__ =
17330 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17331 .into_iter().map(|x| x.0).collect())
17332 ;
17333 }
17334 GeneratedField::RemovedDownstreamActorId => {
17335 if removed_downstream_actor_id__.is_some() {
17336 return Err(serde::de::Error::duplicate_field("removedDownstreamActorId"));
17337 }
17338 removed_downstream_actor_id__ =
17339 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17340 .into_iter().map(|x| x.0).collect())
17341 ;
17342 }
17343 }
17344 }
17345 Ok(update_mutation::DispatcherUpdate {
17346 actor_id: actor_id__.unwrap_or_default(),
17347 dispatcher_id: dispatcher_id__.unwrap_or_default(),
17348 hash_mapping: hash_mapping__,
17349 added_downstream_actor_id: added_downstream_actor_id__.unwrap_or_default(),
17350 removed_downstream_actor_id: removed_downstream_actor_id__.unwrap_or_default(),
17351 })
17352 }
17353 }
17354 deserializer.deserialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", FIELDS, GeneratedVisitor)
17355 }
17356}
17357impl serde::Serialize for update_mutation::MergeUpdate {
17358 #[allow(deprecated)]
17359 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17360 where
17361 S: serde::Serializer,
17362 {
17363 use serde::ser::SerializeStruct;
17364 let mut len = 0;
17365 if self.actor_id != 0 {
17366 len += 1;
17367 }
17368 if self.upstream_fragment_id != 0 {
17369 len += 1;
17370 }
17371 if self.new_upstream_fragment_id.is_some() {
17372 len += 1;
17373 }
17374 if !self.added_upstream_actors.is_empty() {
17375 len += 1;
17376 }
17377 if !self.removed_upstream_actor_id.is_empty() {
17378 len += 1;
17379 }
17380 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.MergeUpdate", len)?;
17381 if self.actor_id != 0 {
17382 struct_ser.serialize_field("actorId", &self.actor_id)?;
17383 }
17384 if self.upstream_fragment_id != 0 {
17385 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
17386 }
17387 if let Some(v) = self.new_upstream_fragment_id.as_ref() {
17388 struct_ser.serialize_field("newUpstreamFragmentId", v)?;
17389 }
17390 if !self.added_upstream_actors.is_empty() {
17391 struct_ser.serialize_field("addedUpstreamActors", &self.added_upstream_actors)?;
17392 }
17393 if !self.removed_upstream_actor_id.is_empty() {
17394 struct_ser.serialize_field("removedUpstreamActorId", &self.removed_upstream_actor_id)?;
17395 }
17396 struct_ser.end()
17397 }
17398}
17399impl<'de> serde::Deserialize<'de> for update_mutation::MergeUpdate {
17400 #[allow(deprecated)]
17401 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17402 where
17403 D: serde::Deserializer<'de>,
17404 {
17405 const FIELDS: &[&str] = &[
17406 "actor_id",
17407 "actorId",
17408 "upstream_fragment_id",
17409 "upstreamFragmentId",
17410 "new_upstream_fragment_id",
17411 "newUpstreamFragmentId",
17412 "added_upstream_actors",
17413 "addedUpstreamActors",
17414 "removed_upstream_actor_id",
17415 "removedUpstreamActorId",
17416 ];
17417
17418 #[allow(clippy::enum_variant_names)]
17419 enum GeneratedField {
17420 ActorId,
17421 UpstreamFragmentId,
17422 NewUpstreamFragmentId,
17423 AddedUpstreamActors,
17424 RemovedUpstreamActorId,
17425 }
17426 impl<'de> serde::Deserialize<'de> for GeneratedField {
17427 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17428 where
17429 D: serde::Deserializer<'de>,
17430 {
17431 struct GeneratedVisitor;
17432
17433 impl serde::de::Visitor<'_> for GeneratedVisitor {
17434 type Value = GeneratedField;
17435
17436 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17437 write!(formatter, "expected one of: {:?}", &FIELDS)
17438 }
17439
17440 #[allow(unused_variables)]
17441 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17442 where
17443 E: serde::de::Error,
17444 {
17445 match value {
17446 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
17447 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
17448 "newUpstreamFragmentId" | "new_upstream_fragment_id" => Ok(GeneratedField::NewUpstreamFragmentId),
17449 "addedUpstreamActors" | "added_upstream_actors" => Ok(GeneratedField::AddedUpstreamActors),
17450 "removedUpstreamActorId" | "removed_upstream_actor_id" => Ok(GeneratedField::RemovedUpstreamActorId),
17451 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17452 }
17453 }
17454 }
17455 deserializer.deserialize_identifier(GeneratedVisitor)
17456 }
17457 }
17458 struct GeneratedVisitor;
17459 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17460 type Value = update_mutation::MergeUpdate;
17461
17462 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17463 formatter.write_str("struct stream_plan.UpdateMutation.MergeUpdate")
17464 }
17465
17466 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::MergeUpdate, V::Error>
17467 where
17468 V: serde::de::MapAccess<'de>,
17469 {
17470 let mut actor_id__ = None;
17471 let mut upstream_fragment_id__ = None;
17472 let mut new_upstream_fragment_id__ = None;
17473 let mut added_upstream_actors__ = None;
17474 let mut removed_upstream_actor_id__ = None;
17475 while let Some(k) = map_.next_key()? {
17476 match k {
17477 GeneratedField::ActorId => {
17478 if actor_id__.is_some() {
17479 return Err(serde::de::Error::duplicate_field("actorId"));
17480 }
17481 actor_id__ =
17482 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17483 ;
17484 }
17485 GeneratedField::UpstreamFragmentId => {
17486 if upstream_fragment_id__.is_some() {
17487 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
17488 }
17489 upstream_fragment_id__ =
17490 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17491 ;
17492 }
17493 GeneratedField::NewUpstreamFragmentId => {
17494 if new_upstream_fragment_id__.is_some() {
17495 return Err(serde::de::Error::duplicate_field("newUpstreamFragmentId"));
17496 }
17497 new_upstream_fragment_id__ =
17498 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17499 ;
17500 }
17501 GeneratedField::AddedUpstreamActors => {
17502 if added_upstream_actors__.is_some() {
17503 return Err(serde::de::Error::duplicate_field("addedUpstreamActors"));
17504 }
17505 added_upstream_actors__ = Some(map_.next_value()?);
17506 }
17507 GeneratedField::RemovedUpstreamActorId => {
17508 if removed_upstream_actor_id__.is_some() {
17509 return Err(serde::de::Error::duplicate_field("removedUpstreamActorId"));
17510 }
17511 removed_upstream_actor_id__ =
17512 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17513 .into_iter().map(|x| x.0).collect())
17514 ;
17515 }
17516 }
17517 }
17518 Ok(update_mutation::MergeUpdate {
17519 actor_id: actor_id__.unwrap_or_default(),
17520 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
17521 new_upstream_fragment_id: new_upstream_fragment_id__,
17522 added_upstream_actors: added_upstream_actors__.unwrap_or_default(),
17523 removed_upstream_actor_id: removed_upstream_actor_id__.unwrap_or_default(),
17524 })
17525 }
17526 }
17527 deserializer.deserialize_struct("stream_plan.UpdateMutation.MergeUpdate", FIELDS, GeneratedVisitor)
17528 }
17529}
17530impl serde::Serialize for UpstreamSinkInfo {
17531 #[allow(deprecated)]
17532 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17533 where
17534 S: serde::Serializer,
17535 {
17536 use serde::ser::SerializeStruct;
17537 let mut len = 0;
17538 if self.upstream_fragment_id != 0 {
17539 len += 1;
17540 }
17541 if !self.sink_output_schema.is_empty() {
17542 len += 1;
17543 }
17544 if !self.project_exprs.is_empty() {
17545 len += 1;
17546 }
17547 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkInfo", len)?;
17548 if self.upstream_fragment_id != 0 {
17549 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
17550 }
17551 if !self.sink_output_schema.is_empty() {
17552 struct_ser.serialize_field("sinkOutputSchema", &self.sink_output_schema)?;
17553 }
17554 if !self.project_exprs.is_empty() {
17555 struct_ser.serialize_field("projectExprs", &self.project_exprs)?;
17556 }
17557 struct_ser.end()
17558 }
17559}
17560impl<'de> serde::Deserialize<'de> for UpstreamSinkInfo {
17561 #[allow(deprecated)]
17562 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17563 where
17564 D: serde::Deserializer<'de>,
17565 {
17566 const FIELDS: &[&str] = &[
17567 "upstream_fragment_id",
17568 "upstreamFragmentId",
17569 "sink_output_schema",
17570 "sinkOutputSchema",
17571 "project_exprs",
17572 "projectExprs",
17573 ];
17574
17575 #[allow(clippy::enum_variant_names)]
17576 enum GeneratedField {
17577 UpstreamFragmentId,
17578 SinkOutputSchema,
17579 ProjectExprs,
17580 }
17581 impl<'de> serde::Deserialize<'de> for GeneratedField {
17582 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17583 where
17584 D: serde::Deserializer<'de>,
17585 {
17586 struct GeneratedVisitor;
17587
17588 impl serde::de::Visitor<'_> for GeneratedVisitor {
17589 type Value = GeneratedField;
17590
17591 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17592 write!(formatter, "expected one of: {:?}", &FIELDS)
17593 }
17594
17595 #[allow(unused_variables)]
17596 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17597 where
17598 E: serde::de::Error,
17599 {
17600 match value {
17601 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
17602 "sinkOutputSchema" | "sink_output_schema" => Ok(GeneratedField::SinkOutputSchema),
17603 "projectExprs" | "project_exprs" => Ok(GeneratedField::ProjectExprs),
17604 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17605 }
17606 }
17607 }
17608 deserializer.deserialize_identifier(GeneratedVisitor)
17609 }
17610 }
17611 struct GeneratedVisitor;
17612 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17613 type Value = UpstreamSinkInfo;
17614
17615 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17616 formatter.write_str("struct stream_plan.UpstreamSinkInfo")
17617 }
17618
17619 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkInfo, V::Error>
17620 where
17621 V: serde::de::MapAccess<'de>,
17622 {
17623 let mut upstream_fragment_id__ = None;
17624 let mut sink_output_schema__ = None;
17625 let mut project_exprs__ = None;
17626 while let Some(k) = map_.next_key()? {
17627 match k {
17628 GeneratedField::UpstreamFragmentId => {
17629 if upstream_fragment_id__.is_some() {
17630 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
17631 }
17632 upstream_fragment_id__ =
17633 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17634 ;
17635 }
17636 GeneratedField::SinkOutputSchema => {
17637 if sink_output_schema__.is_some() {
17638 return Err(serde::de::Error::duplicate_field("sinkOutputSchema"));
17639 }
17640 sink_output_schema__ = Some(map_.next_value()?);
17641 }
17642 GeneratedField::ProjectExprs => {
17643 if project_exprs__.is_some() {
17644 return Err(serde::de::Error::duplicate_field("projectExprs"));
17645 }
17646 project_exprs__ = Some(map_.next_value()?);
17647 }
17648 }
17649 }
17650 Ok(UpstreamSinkInfo {
17651 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
17652 sink_output_schema: sink_output_schema__.unwrap_or_default(),
17653 project_exprs: project_exprs__.unwrap_or_default(),
17654 })
17655 }
17656 }
17657 deserializer.deserialize_struct("stream_plan.UpstreamSinkInfo", FIELDS, GeneratedVisitor)
17658 }
17659}
17660impl serde::Serialize for UpstreamSinkUnionNode {
17661 #[allow(deprecated)]
17662 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17663 where
17664 S: serde::Serializer,
17665 {
17666 use serde::ser::SerializeStruct;
17667 let mut len = 0;
17668 if !self.init_upstreams.is_empty() {
17669 len += 1;
17670 }
17671 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkUnionNode", len)?;
17672 if !self.init_upstreams.is_empty() {
17673 struct_ser.serialize_field("initUpstreams", &self.init_upstreams)?;
17674 }
17675 struct_ser.end()
17676 }
17677}
17678impl<'de> serde::Deserialize<'de> for UpstreamSinkUnionNode {
17679 #[allow(deprecated)]
17680 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17681 where
17682 D: serde::Deserializer<'de>,
17683 {
17684 const FIELDS: &[&str] = &[
17685 "init_upstreams",
17686 "initUpstreams",
17687 ];
17688
17689 #[allow(clippy::enum_variant_names)]
17690 enum GeneratedField {
17691 InitUpstreams,
17692 }
17693 impl<'de> serde::Deserialize<'de> for GeneratedField {
17694 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17695 where
17696 D: serde::Deserializer<'de>,
17697 {
17698 struct GeneratedVisitor;
17699
17700 impl serde::de::Visitor<'_> for GeneratedVisitor {
17701 type Value = GeneratedField;
17702
17703 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17704 write!(formatter, "expected one of: {:?}", &FIELDS)
17705 }
17706
17707 #[allow(unused_variables)]
17708 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17709 where
17710 E: serde::de::Error,
17711 {
17712 match value {
17713 "initUpstreams" | "init_upstreams" => Ok(GeneratedField::InitUpstreams),
17714 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17715 }
17716 }
17717 }
17718 deserializer.deserialize_identifier(GeneratedVisitor)
17719 }
17720 }
17721 struct GeneratedVisitor;
17722 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17723 type Value = UpstreamSinkUnionNode;
17724
17725 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17726 formatter.write_str("struct stream_plan.UpstreamSinkUnionNode")
17727 }
17728
17729 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkUnionNode, V::Error>
17730 where
17731 V: serde::de::MapAccess<'de>,
17732 {
17733 let mut init_upstreams__ = None;
17734 while let Some(k) = map_.next_key()? {
17735 match k {
17736 GeneratedField::InitUpstreams => {
17737 if init_upstreams__.is_some() {
17738 return Err(serde::de::Error::duplicate_field("initUpstreams"));
17739 }
17740 init_upstreams__ = Some(map_.next_value()?);
17741 }
17742 }
17743 }
17744 Ok(UpstreamSinkUnionNode {
17745 init_upstreams: init_upstreams__.unwrap_or_default(),
17746 })
17747 }
17748 }
17749 deserializer.deserialize_struct("stream_plan.UpstreamSinkUnionNode", FIELDS, GeneratedVisitor)
17750 }
17751}
17752impl serde::Serialize for ValuesNode {
17753 #[allow(deprecated)]
17754 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17755 where
17756 S: serde::Serializer,
17757 {
17758 use serde::ser::SerializeStruct;
17759 let mut len = 0;
17760 if !self.tuples.is_empty() {
17761 len += 1;
17762 }
17763 if !self.fields.is_empty() {
17764 len += 1;
17765 }
17766 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode", len)?;
17767 if !self.tuples.is_empty() {
17768 struct_ser.serialize_field("tuples", &self.tuples)?;
17769 }
17770 if !self.fields.is_empty() {
17771 struct_ser.serialize_field("fields", &self.fields)?;
17772 }
17773 struct_ser.end()
17774 }
17775}
17776impl<'de> serde::Deserialize<'de> for ValuesNode {
17777 #[allow(deprecated)]
17778 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17779 where
17780 D: serde::Deserializer<'de>,
17781 {
17782 const FIELDS: &[&str] = &[
17783 "tuples",
17784 "fields",
17785 ];
17786
17787 #[allow(clippy::enum_variant_names)]
17788 enum GeneratedField {
17789 Tuples,
17790 Fields,
17791 }
17792 impl<'de> serde::Deserialize<'de> for GeneratedField {
17793 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17794 where
17795 D: serde::Deserializer<'de>,
17796 {
17797 struct GeneratedVisitor;
17798
17799 impl serde::de::Visitor<'_> for GeneratedVisitor {
17800 type Value = GeneratedField;
17801
17802 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17803 write!(formatter, "expected one of: {:?}", &FIELDS)
17804 }
17805
17806 #[allow(unused_variables)]
17807 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17808 where
17809 E: serde::de::Error,
17810 {
17811 match value {
17812 "tuples" => Ok(GeneratedField::Tuples),
17813 "fields" => Ok(GeneratedField::Fields),
17814 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17815 }
17816 }
17817 }
17818 deserializer.deserialize_identifier(GeneratedVisitor)
17819 }
17820 }
17821 struct GeneratedVisitor;
17822 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17823 type Value = ValuesNode;
17824
17825 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17826 formatter.write_str("struct stream_plan.ValuesNode")
17827 }
17828
17829 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
17830 where
17831 V: serde::de::MapAccess<'de>,
17832 {
17833 let mut tuples__ = None;
17834 let mut fields__ = None;
17835 while let Some(k) = map_.next_key()? {
17836 match k {
17837 GeneratedField::Tuples => {
17838 if tuples__.is_some() {
17839 return Err(serde::de::Error::duplicate_field("tuples"));
17840 }
17841 tuples__ = Some(map_.next_value()?);
17842 }
17843 GeneratedField::Fields => {
17844 if fields__.is_some() {
17845 return Err(serde::de::Error::duplicate_field("fields"));
17846 }
17847 fields__ = Some(map_.next_value()?);
17848 }
17849 }
17850 }
17851 Ok(ValuesNode {
17852 tuples: tuples__.unwrap_or_default(),
17853 fields: fields__.unwrap_or_default(),
17854 })
17855 }
17856 }
17857 deserializer.deserialize_struct("stream_plan.ValuesNode", FIELDS, GeneratedVisitor)
17858 }
17859}
17860impl serde::Serialize for values_node::ExprTuple {
17861 #[allow(deprecated)]
17862 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17863 where
17864 S: serde::Serializer,
17865 {
17866 use serde::ser::SerializeStruct;
17867 let mut len = 0;
17868 if !self.cells.is_empty() {
17869 len += 1;
17870 }
17871 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode.ExprTuple", len)?;
17872 if !self.cells.is_empty() {
17873 struct_ser.serialize_field("cells", &self.cells)?;
17874 }
17875 struct_ser.end()
17876 }
17877}
17878impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
17879 #[allow(deprecated)]
17880 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17881 where
17882 D: serde::Deserializer<'de>,
17883 {
17884 const FIELDS: &[&str] = &[
17885 "cells",
17886 ];
17887
17888 #[allow(clippy::enum_variant_names)]
17889 enum GeneratedField {
17890 Cells,
17891 }
17892 impl<'de> serde::Deserialize<'de> for GeneratedField {
17893 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17894 where
17895 D: serde::Deserializer<'de>,
17896 {
17897 struct GeneratedVisitor;
17898
17899 impl serde::de::Visitor<'_> for GeneratedVisitor {
17900 type Value = GeneratedField;
17901
17902 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17903 write!(formatter, "expected one of: {:?}", &FIELDS)
17904 }
17905
17906 #[allow(unused_variables)]
17907 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17908 where
17909 E: serde::de::Error,
17910 {
17911 match value {
17912 "cells" => Ok(GeneratedField::Cells),
17913 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17914 }
17915 }
17916 }
17917 deserializer.deserialize_identifier(GeneratedVisitor)
17918 }
17919 }
17920 struct GeneratedVisitor;
17921 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17922 type Value = values_node::ExprTuple;
17923
17924 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17925 formatter.write_str("struct stream_plan.ValuesNode.ExprTuple")
17926 }
17927
17928 fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
17929 where
17930 V: serde::de::MapAccess<'de>,
17931 {
17932 let mut cells__ = None;
17933 while let Some(k) = map_.next_key()? {
17934 match k {
17935 GeneratedField::Cells => {
17936 if cells__.is_some() {
17937 return Err(serde::de::Error::duplicate_field("cells"));
17938 }
17939 cells__ = Some(map_.next_value()?);
17940 }
17941 }
17942 }
17943 Ok(values_node::ExprTuple {
17944 cells: cells__.unwrap_or_default(),
17945 })
17946 }
17947 }
17948 deserializer.deserialize_struct("stream_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
17949 }
17950}
17951impl serde::Serialize for VectorIndexLookupJoinNode {
17952 #[allow(deprecated)]
17953 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17954 where
17955 S: serde::Serializer,
17956 {
17957 use serde::ser::SerializeStruct;
17958 let mut len = 0;
17959 if self.reader_desc.is_some() {
17960 len += 1;
17961 }
17962 if self.vector_column_idx != 0 {
17963 len += 1;
17964 }
17965 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexLookupJoinNode", len)?;
17966 if let Some(v) = self.reader_desc.as_ref() {
17967 struct_ser.serialize_field("readerDesc", v)?;
17968 }
17969 if self.vector_column_idx != 0 {
17970 struct_ser.serialize_field("vectorColumnIdx", &self.vector_column_idx)?;
17971 }
17972 struct_ser.end()
17973 }
17974}
17975impl<'de> serde::Deserialize<'de> for VectorIndexLookupJoinNode {
17976 #[allow(deprecated)]
17977 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17978 where
17979 D: serde::Deserializer<'de>,
17980 {
17981 const FIELDS: &[&str] = &[
17982 "reader_desc",
17983 "readerDesc",
17984 "vector_column_idx",
17985 "vectorColumnIdx",
17986 ];
17987
17988 #[allow(clippy::enum_variant_names)]
17989 enum GeneratedField {
17990 ReaderDesc,
17991 VectorColumnIdx,
17992 }
17993 impl<'de> serde::Deserialize<'de> for GeneratedField {
17994 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17995 where
17996 D: serde::Deserializer<'de>,
17997 {
17998 struct GeneratedVisitor;
17999
18000 impl serde::de::Visitor<'_> for GeneratedVisitor {
18001 type Value = GeneratedField;
18002
18003 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18004 write!(formatter, "expected one of: {:?}", &FIELDS)
18005 }
18006
18007 #[allow(unused_variables)]
18008 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18009 where
18010 E: serde::de::Error,
18011 {
18012 match value {
18013 "readerDesc" | "reader_desc" => Ok(GeneratedField::ReaderDesc),
18014 "vectorColumnIdx" | "vector_column_idx" => Ok(GeneratedField::VectorColumnIdx),
18015 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18016 }
18017 }
18018 }
18019 deserializer.deserialize_identifier(GeneratedVisitor)
18020 }
18021 }
18022 struct GeneratedVisitor;
18023 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18024 type Value = VectorIndexLookupJoinNode;
18025
18026 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18027 formatter.write_str("struct stream_plan.VectorIndexLookupJoinNode")
18028 }
18029
18030 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexLookupJoinNode, V::Error>
18031 where
18032 V: serde::de::MapAccess<'de>,
18033 {
18034 let mut reader_desc__ = None;
18035 let mut vector_column_idx__ = None;
18036 while let Some(k) = map_.next_key()? {
18037 match k {
18038 GeneratedField::ReaderDesc => {
18039 if reader_desc__.is_some() {
18040 return Err(serde::de::Error::duplicate_field("readerDesc"));
18041 }
18042 reader_desc__ = map_.next_value()?;
18043 }
18044 GeneratedField::VectorColumnIdx => {
18045 if vector_column_idx__.is_some() {
18046 return Err(serde::de::Error::duplicate_field("vectorColumnIdx"));
18047 }
18048 vector_column_idx__ =
18049 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18050 ;
18051 }
18052 }
18053 }
18054 Ok(VectorIndexLookupJoinNode {
18055 reader_desc: reader_desc__,
18056 vector_column_idx: vector_column_idx__.unwrap_or_default(),
18057 })
18058 }
18059 }
18060 deserializer.deserialize_struct("stream_plan.VectorIndexLookupJoinNode", FIELDS, GeneratedVisitor)
18061 }
18062}
18063impl serde::Serialize for VectorIndexWriteNode {
18064 #[allow(deprecated)]
18065 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18066 where
18067 S: serde::Serializer,
18068 {
18069 use serde::ser::SerializeStruct;
18070 let mut len = 0;
18071 if self.table.is_some() {
18072 len += 1;
18073 }
18074 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexWriteNode", len)?;
18075 if let Some(v) = self.table.as_ref() {
18076 struct_ser.serialize_field("table", v)?;
18077 }
18078 struct_ser.end()
18079 }
18080}
18081impl<'de> serde::Deserialize<'de> for VectorIndexWriteNode {
18082 #[allow(deprecated)]
18083 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18084 where
18085 D: serde::Deserializer<'de>,
18086 {
18087 const FIELDS: &[&str] = &[
18088 "table",
18089 ];
18090
18091 #[allow(clippy::enum_variant_names)]
18092 enum GeneratedField {
18093 Table,
18094 }
18095 impl<'de> serde::Deserialize<'de> for GeneratedField {
18096 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18097 where
18098 D: serde::Deserializer<'de>,
18099 {
18100 struct GeneratedVisitor;
18101
18102 impl serde::de::Visitor<'_> for GeneratedVisitor {
18103 type Value = GeneratedField;
18104
18105 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18106 write!(formatter, "expected one of: {:?}", &FIELDS)
18107 }
18108
18109 #[allow(unused_variables)]
18110 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18111 where
18112 E: serde::de::Error,
18113 {
18114 match value {
18115 "table" => Ok(GeneratedField::Table),
18116 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18117 }
18118 }
18119 }
18120 deserializer.deserialize_identifier(GeneratedVisitor)
18121 }
18122 }
18123 struct GeneratedVisitor;
18124 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18125 type Value = VectorIndexWriteNode;
18126
18127 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18128 formatter.write_str("struct stream_plan.VectorIndexWriteNode")
18129 }
18130
18131 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexWriteNode, V::Error>
18132 where
18133 V: serde::de::MapAccess<'de>,
18134 {
18135 let mut table__ = None;
18136 while let Some(k) = map_.next_key()? {
18137 match k {
18138 GeneratedField::Table => {
18139 if table__.is_some() {
18140 return Err(serde::de::Error::duplicate_field("table"));
18141 }
18142 table__ = map_.next_value()?;
18143 }
18144 }
18145 }
18146 Ok(VectorIndexWriteNode {
18147 table: table__,
18148 })
18149 }
18150 }
18151 deserializer.deserialize_struct("stream_plan.VectorIndexWriteNode", FIELDS, GeneratedVisitor)
18152 }
18153}
18154impl serde::Serialize for Watermark {
18155 #[allow(deprecated)]
18156 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18157 where
18158 S: serde::Serializer,
18159 {
18160 use serde::ser::SerializeStruct;
18161 let mut len = 0;
18162 if self.column.is_some() {
18163 len += 1;
18164 }
18165 if self.val.is_some() {
18166 len += 1;
18167 }
18168 let mut struct_ser = serializer.serialize_struct("stream_plan.Watermark", len)?;
18169 if let Some(v) = self.column.as_ref() {
18170 struct_ser.serialize_field("column", v)?;
18171 }
18172 if let Some(v) = self.val.as_ref() {
18173 struct_ser.serialize_field("val", v)?;
18174 }
18175 struct_ser.end()
18176 }
18177}
18178impl<'de> serde::Deserialize<'de> for Watermark {
18179 #[allow(deprecated)]
18180 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18181 where
18182 D: serde::Deserializer<'de>,
18183 {
18184 const FIELDS: &[&str] = &[
18185 "column",
18186 "val",
18187 ];
18188
18189 #[allow(clippy::enum_variant_names)]
18190 enum GeneratedField {
18191 Column,
18192 Val,
18193 }
18194 impl<'de> serde::Deserialize<'de> for GeneratedField {
18195 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18196 where
18197 D: serde::Deserializer<'de>,
18198 {
18199 struct GeneratedVisitor;
18200
18201 impl serde::de::Visitor<'_> for GeneratedVisitor {
18202 type Value = GeneratedField;
18203
18204 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18205 write!(formatter, "expected one of: {:?}", &FIELDS)
18206 }
18207
18208 #[allow(unused_variables)]
18209 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18210 where
18211 E: serde::de::Error,
18212 {
18213 match value {
18214 "column" => Ok(GeneratedField::Column),
18215 "val" => Ok(GeneratedField::Val),
18216 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18217 }
18218 }
18219 }
18220 deserializer.deserialize_identifier(GeneratedVisitor)
18221 }
18222 }
18223 struct GeneratedVisitor;
18224 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18225 type Value = Watermark;
18226
18227 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18228 formatter.write_str("struct stream_plan.Watermark")
18229 }
18230
18231 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Watermark, V::Error>
18232 where
18233 V: serde::de::MapAccess<'de>,
18234 {
18235 let mut column__ = None;
18236 let mut val__ = None;
18237 while let Some(k) = map_.next_key()? {
18238 match k {
18239 GeneratedField::Column => {
18240 if column__.is_some() {
18241 return Err(serde::de::Error::duplicate_field("column"));
18242 }
18243 column__ = map_.next_value()?;
18244 }
18245 GeneratedField::Val => {
18246 if val__.is_some() {
18247 return Err(serde::de::Error::duplicate_field("val"));
18248 }
18249 val__ = map_.next_value()?;
18250 }
18251 }
18252 }
18253 Ok(Watermark {
18254 column: column__,
18255 val: val__,
18256 })
18257 }
18258 }
18259 deserializer.deserialize_struct("stream_plan.Watermark", FIELDS, GeneratedVisitor)
18260 }
18261}
18262impl serde::Serialize for WatermarkFilterNode {
18263 #[allow(deprecated)]
18264 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18265 where
18266 S: serde::Serializer,
18267 {
18268 use serde::ser::SerializeStruct;
18269 let mut len = 0;
18270 if !self.watermark_descs.is_empty() {
18271 len += 1;
18272 }
18273 if !self.tables.is_empty() {
18274 len += 1;
18275 }
18276 let mut struct_ser = serializer.serialize_struct("stream_plan.WatermarkFilterNode", len)?;
18277 if !self.watermark_descs.is_empty() {
18278 struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
18279 }
18280 if !self.tables.is_empty() {
18281 struct_ser.serialize_field("tables", &self.tables)?;
18282 }
18283 struct_ser.end()
18284 }
18285}
18286impl<'de> serde::Deserialize<'de> for WatermarkFilterNode {
18287 #[allow(deprecated)]
18288 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18289 where
18290 D: serde::Deserializer<'de>,
18291 {
18292 const FIELDS: &[&str] = &[
18293 "watermark_descs",
18294 "watermarkDescs",
18295 "tables",
18296 ];
18297
18298 #[allow(clippy::enum_variant_names)]
18299 enum GeneratedField {
18300 WatermarkDescs,
18301 Tables,
18302 }
18303 impl<'de> serde::Deserialize<'de> for GeneratedField {
18304 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18305 where
18306 D: serde::Deserializer<'de>,
18307 {
18308 struct GeneratedVisitor;
18309
18310 impl serde::de::Visitor<'_> for GeneratedVisitor {
18311 type Value = GeneratedField;
18312
18313 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18314 write!(formatter, "expected one of: {:?}", &FIELDS)
18315 }
18316
18317 #[allow(unused_variables)]
18318 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18319 where
18320 E: serde::de::Error,
18321 {
18322 match value {
18323 "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
18324 "tables" => Ok(GeneratedField::Tables),
18325 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18326 }
18327 }
18328 }
18329 deserializer.deserialize_identifier(GeneratedVisitor)
18330 }
18331 }
18332 struct GeneratedVisitor;
18333 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18334 type Value = WatermarkFilterNode;
18335
18336 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18337 formatter.write_str("struct stream_plan.WatermarkFilterNode")
18338 }
18339
18340 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkFilterNode, V::Error>
18341 where
18342 V: serde::de::MapAccess<'de>,
18343 {
18344 let mut watermark_descs__ = None;
18345 let mut tables__ = None;
18346 while let Some(k) = map_.next_key()? {
18347 match k {
18348 GeneratedField::WatermarkDescs => {
18349 if watermark_descs__.is_some() {
18350 return Err(serde::de::Error::duplicate_field("watermarkDescs"));
18351 }
18352 watermark_descs__ = Some(map_.next_value()?);
18353 }
18354 GeneratedField::Tables => {
18355 if tables__.is_some() {
18356 return Err(serde::de::Error::duplicate_field("tables"));
18357 }
18358 tables__ = Some(map_.next_value()?);
18359 }
18360 }
18361 }
18362 Ok(WatermarkFilterNode {
18363 watermark_descs: watermark_descs__.unwrap_or_default(),
18364 tables: tables__.unwrap_or_default(),
18365 })
18366 }
18367 }
18368 deserializer.deserialize_struct("stream_plan.WatermarkFilterNode", FIELDS, GeneratedVisitor)
18369 }
18370}