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 if self.iceberg_pk_index_compaction.is_some() {
1612 len += 1;
1613 }
1614 let mut struct_ser = serializer.serialize_struct("stream_plan.Barrier", len)?;
1615 if let Some(v) = self.epoch.as_ref() {
1616 struct_ser.serialize_field("epoch", v)?;
1617 }
1618 if let Some(v) = self.mutation.as_ref() {
1619 struct_ser.serialize_field("mutation", v)?;
1620 }
1621 if !self.tracing_context.is_empty() {
1622 struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
1623 }
1624 if self.kind != 0 {
1625 let v = barrier::BarrierKind::try_from(self.kind)
1626 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
1627 struct_ser.serialize_field("kind", &v)?;
1628 }
1629 if let Some(v) = self.iceberg_pk_index_compaction.as_ref() {
1630 struct_ser.serialize_field("icebergPkIndexCompaction", v)?;
1631 }
1632 struct_ser.end()
1633 }
1634}
1635impl<'de> serde::Deserialize<'de> for Barrier {
1636 #[allow(deprecated)]
1637 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1638 where
1639 D: serde::Deserializer<'de>,
1640 {
1641 const FIELDS: &[&str] = &[
1642 "epoch",
1643 "mutation",
1644 "tracing_context",
1645 "tracingContext",
1646 "kind",
1647 "iceberg_pk_index_compaction",
1648 "icebergPkIndexCompaction",
1649 ];
1650
1651 #[allow(clippy::enum_variant_names)]
1652 enum GeneratedField {
1653 Epoch,
1654 Mutation,
1655 TracingContext,
1656 Kind,
1657 IcebergPkIndexCompaction,
1658 }
1659 impl<'de> serde::Deserialize<'de> for GeneratedField {
1660 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1661 where
1662 D: serde::Deserializer<'de>,
1663 {
1664 struct GeneratedVisitor;
1665
1666 impl serde::de::Visitor<'_> for GeneratedVisitor {
1667 type Value = GeneratedField;
1668
1669 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1670 write!(formatter, "expected one of: {:?}", &FIELDS)
1671 }
1672
1673 #[allow(unused_variables)]
1674 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1675 where
1676 E: serde::de::Error,
1677 {
1678 match value {
1679 "epoch" => Ok(GeneratedField::Epoch),
1680 "mutation" => Ok(GeneratedField::Mutation),
1681 "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
1682 "kind" => Ok(GeneratedField::Kind),
1683 "icebergPkIndexCompaction" | "iceberg_pk_index_compaction" => Ok(GeneratedField::IcebergPkIndexCompaction),
1684 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1685 }
1686 }
1687 }
1688 deserializer.deserialize_identifier(GeneratedVisitor)
1689 }
1690 }
1691 struct GeneratedVisitor;
1692 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1693 type Value = Barrier;
1694
1695 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1696 formatter.write_str("struct stream_plan.Barrier")
1697 }
1698
1699 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Barrier, V::Error>
1700 where
1701 V: serde::de::MapAccess<'de>,
1702 {
1703 let mut epoch__ = None;
1704 let mut mutation__ = None;
1705 let mut tracing_context__ = None;
1706 let mut kind__ = None;
1707 let mut iceberg_pk_index_compaction__ = None;
1708 while let Some(k) = map_.next_key()? {
1709 match k {
1710 GeneratedField::Epoch => {
1711 if epoch__.is_some() {
1712 return Err(serde::de::Error::duplicate_field("epoch"));
1713 }
1714 epoch__ = map_.next_value()?;
1715 }
1716 GeneratedField::Mutation => {
1717 if mutation__.is_some() {
1718 return Err(serde::de::Error::duplicate_field("mutation"));
1719 }
1720 mutation__ = map_.next_value()?;
1721 }
1722 GeneratedField::TracingContext => {
1723 if tracing_context__.is_some() {
1724 return Err(serde::de::Error::duplicate_field("tracingContext"));
1725 }
1726 tracing_context__ = Some(
1727 map_.next_value::<std::collections::HashMap<_, _>>()?
1728 );
1729 }
1730 GeneratedField::Kind => {
1731 if kind__.is_some() {
1732 return Err(serde::de::Error::duplicate_field("kind"));
1733 }
1734 kind__ = Some(map_.next_value::<barrier::BarrierKind>()? as i32);
1735 }
1736 GeneratedField::IcebergPkIndexCompaction => {
1737 if iceberg_pk_index_compaction__.is_some() {
1738 return Err(serde::de::Error::duplicate_field("icebergPkIndexCompaction"));
1739 }
1740 iceberg_pk_index_compaction__ = map_.next_value()?;
1741 }
1742 }
1743 }
1744 Ok(Barrier {
1745 epoch: epoch__,
1746 mutation: mutation__,
1747 tracing_context: tracing_context__.unwrap_or_default(),
1748 kind: kind__.unwrap_or_default(),
1749 iceberg_pk_index_compaction: iceberg_pk_index_compaction__,
1750 })
1751 }
1752 }
1753 deserializer.deserialize_struct("stream_plan.Barrier", FIELDS, GeneratedVisitor)
1754 }
1755}
1756impl serde::Serialize for barrier::BarrierKind {
1757 #[allow(deprecated)]
1758 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1759 where
1760 S: serde::Serializer,
1761 {
1762 let variant = match self {
1763 Self::Unspecified => "BARRIER_KIND_UNSPECIFIED",
1764 Self::Initial => "BARRIER_KIND_INITIAL",
1765 Self::Barrier => "BARRIER_KIND_BARRIER",
1766 Self::Checkpoint => "BARRIER_KIND_CHECKPOINT",
1767 };
1768 serializer.serialize_str(variant)
1769 }
1770}
1771impl<'de> serde::Deserialize<'de> for barrier::BarrierKind {
1772 #[allow(deprecated)]
1773 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1774 where
1775 D: serde::Deserializer<'de>,
1776 {
1777 const FIELDS: &[&str] = &[
1778 "BARRIER_KIND_UNSPECIFIED",
1779 "BARRIER_KIND_INITIAL",
1780 "BARRIER_KIND_BARRIER",
1781 "BARRIER_KIND_CHECKPOINT",
1782 ];
1783
1784 struct GeneratedVisitor;
1785
1786 impl serde::de::Visitor<'_> for GeneratedVisitor {
1787 type Value = barrier::BarrierKind;
1788
1789 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1790 write!(formatter, "expected one of: {:?}", &FIELDS)
1791 }
1792
1793 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1794 where
1795 E: serde::de::Error,
1796 {
1797 i32::try_from(v)
1798 .ok()
1799 .and_then(|x| x.try_into().ok())
1800 .ok_or_else(|| {
1801 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1802 })
1803 }
1804
1805 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1806 where
1807 E: serde::de::Error,
1808 {
1809 i32::try_from(v)
1810 .ok()
1811 .and_then(|x| x.try_into().ok())
1812 .ok_or_else(|| {
1813 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1814 })
1815 }
1816
1817 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1818 where
1819 E: serde::de::Error,
1820 {
1821 match value {
1822 "BARRIER_KIND_UNSPECIFIED" => Ok(barrier::BarrierKind::Unspecified),
1823 "BARRIER_KIND_INITIAL" => Ok(barrier::BarrierKind::Initial),
1824 "BARRIER_KIND_BARRIER" => Ok(barrier::BarrierKind::Barrier),
1825 "BARRIER_KIND_CHECKPOINT" => Ok(barrier::BarrierKind::Checkpoint),
1826 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1827 }
1828 }
1829 }
1830 deserializer.deserialize_any(GeneratedVisitor)
1831 }
1832}
1833impl serde::Serialize for BarrierMutation {
1834 #[allow(deprecated)]
1835 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1836 where
1837 S: serde::Serializer,
1838 {
1839 use serde::ser::SerializeStruct;
1840 let mut len = 0;
1841 if self.mutation.is_some() {
1842 len += 1;
1843 }
1844 let mut struct_ser = serializer.serialize_struct("stream_plan.BarrierMutation", len)?;
1845 if let Some(v) = self.mutation.as_ref() {
1846 match v {
1847 barrier_mutation::Mutation::Add(v) => {
1848 struct_ser.serialize_field("add", v)?;
1849 }
1850 barrier_mutation::Mutation::Stop(v) => {
1851 struct_ser.serialize_field("stop", v)?;
1852 }
1853 barrier_mutation::Mutation::Update(v) => {
1854 struct_ser.serialize_field("update", v)?;
1855 }
1856 barrier_mutation::Mutation::Splits(v) => {
1857 struct_ser.serialize_field("splits", v)?;
1858 }
1859 barrier_mutation::Mutation::Pause(v) => {
1860 struct_ser.serialize_field("pause", v)?;
1861 }
1862 barrier_mutation::Mutation::Resume(v) => {
1863 struct_ser.serialize_field("resume", v)?;
1864 }
1865 barrier_mutation::Mutation::Throttle(v) => {
1866 struct_ser.serialize_field("throttle", v)?;
1867 }
1868 barrier_mutation::Mutation::DropSubscriptions(v) => {
1869 struct_ser.serialize_field("dropSubscriptions", v)?;
1870 }
1871 barrier_mutation::Mutation::ConnectorPropsChange(v) => {
1872 struct_ser.serialize_field("connectorPropsChange", v)?;
1873 }
1874 barrier_mutation::Mutation::StartFragmentBackfill(v) => {
1875 struct_ser.serialize_field("startFragmentBackfill", v)?;
1876 }
1877 barrier_mutation::Mutation::RefreshStart(v) => {
1878 struct_ser.serialize_field("refreshStart", v)?;
1879 }
1880 barrier_mutation::Mutation::LoadFinish(v) => {
1881 struct_ser.serialize_field("loadFinish", v)?;
1882 }
1883 barrier_mutation::Mutation::ListFinish(v) => {
1884 struct_ser.serialize_field("listFinish", v)?;
1885 }
1886 barrier_mutation::Mutation::ResetSource(v) => {
1887 struct_ser.serialize_field("resetSource", v)?;
1888 }
1889 barrier_mutation::Mutation::InjectSourceOffsets(v) => {
1890 struct_ser.serialize_field("injectSourceOffsets", v)?;
1891 }
1892 }
1893 }
1894 struct_ser.end()
1895 }
1896}
1897impl<'de> serde::Deserialize<'de> for BarrierMutation {
1898 #[allow(deprecated)]
1899 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1900 where
1901 D: serde::Deserializer<'de>,
1902 {
1903 const FIELDS: &[&str] = &[
1904 "add",
1905 "stop",
1906 "update",
1907 "splits",
1908 "pause",
1909 "resume",
1910 "throttle",
1911 "drop_subscriptions",
1912 "dropSubscriptions",
1913 "connector_props_change",
1914 "connectorPropsChange",
1915 "start_fragment_backfill",
1916 "startFragmentBackfill",
1917 "refresh_start",
1918 "refreshStart",
1919 "load_finish",
1920 "loadFinish",
1921 "list_finish",
1922 "listFinish",
1923 "reset_source",
1924 "resetSource",
1925 "inject_source_offsets",
1926 "injectSourceOffsets",
1927 ];
1928
1929 #[allow(clippy::enum_variant_names)]
1930 enum GeneratedField {
1931 Add,
1932 Stop,
1933 Update,
1934 Splits,
1935 Pause,
1936 Resume,
1937 Throttle,
1938 DropSubscriptions,
1939 ConnectorPropsChange,
1940 StartFragmentBackfill,
1941 RefreshStart,
1942 LoadFinish,
1943 ListFinish,
1944 ResetSource,
1945 InjectSourceOffsets,
1946 }
1947 impl<'de> serde::Deserialize<'de> for GeneratedField {
1948 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1949 where
1950 D: serde::Deserializer<'de>,
1951 {
1952 struct GeneratedVisitor;
1953
1954 impl serde::de::Visitor<'_> for GeneratedVisitor {
1955 type Value = GeneratedField;
1956
1957 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1958 write!(formatter, "expected one of: {:?}", &FIELDS)
1959 }
1960
1961 #[allow(unused_variables)]
1962 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1963 where
1964 E: serde::de::Error,
1965 {
1966 match value {
1967 "add" => Ok(GeneratedField::Add),
1968 "stop" => Ok(GeneratedField::Stop),
1969 "update" => Ok(GeneratedField::Update),
1970 "splits" => Ok(GeneratedField::Splits),
1971 "pause" => Ok(GeneratedField::Pause),
1972 "resume" => Ok(GeneratedField::Resume),
1973 "throttle" => Ok(GeneratedField::Throttle),
1974 "dropSubscriptions" | "drop_subscriptions" => Ok(GeneratedField::DropSubscriptions),
1975 "connectorPropsChange" | "connector_props_change" => Ok(GeneratedField::ConnectorPropsChange),
1976 "startFragmentBackfill" | "start_fragment_backfill" => Ok(GeneratedField::StartFragmentBackfill),
1977 "refreshStart" | "refresh_start" => Ok(GeneratedField::RefreshStart),
1978 "loadFinish" | "load_finish" => Ok(GeneratedField::LoadFinish),
1979 "listFinish" | "list_finish" => Ok(GeneratedField::ListFinish),
1980 "resetSource" | "reset_source" => Ok(GeneratedField::ResetSource),
1981 "injectSourceOffsets" | "inject_source_offsets" => Ok(GeneratedField::InjectSourceOffsets),
1982 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1983 }
1984 }
1985 }
1986 deserializer.deserialize_identifier(GeneratedVisitor)
1987 }
1988 }
1989 struct GeneratedVisitor;
1990 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1991 type Value = BarrierMutation;
1992
1993 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1994 formatter.write_str("struct stream_plan.BarrierMutation")
1995 }
1996
1997 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierMutation, V::Error>
1998 where
1999 V: serde::de::MapAccess<'de>,
2000 {
2001 let mut mutation__ = None;
2002 while let Some(k) = map_.next_key()? {
2003 match k {
2004 GeneratedField::Add => {
2005 if mutation__.is_some() {
2006 return Err(serde::de::Error::duplicate_field("add"));
2007 }
2008 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Add)
2009;
2010 }
2011 GeneratedField::Stop => {
2012 if mutation__.is_some() {
2013 return Err(serde::de::Error::duplicate_field("stop"));
2014 }
2015 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Stop)
2016;
2017 }
2018 GeneratedField::Update => {
2019 if mutation__.is_some() {
2020 return Err(serde::de::Error::duplicate_field("update"));
2021 }
2022 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Update)
2023;
2024 }
2025 GeneratedField::Splits => {
2026 if mutation__.is_some() {
2027 return Err(serde::de::Error::duplicate_field("splits"));
2028 }
2029 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Splits)
2030;
2031 }
2032 GeneratedField::Pause => {
2033 if mutation__.is_some() {
2034 return Err(serde::de::Error::duplicate_field("pause"));
2035 }
2036 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Pause)
2037;
2038 }
2039 GeneratedField::Resume => {
2040 if mutation__.is_some() {
2041 return Err(serde::de::Error::duplicate_field("resume"));
2042 }
2043 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Resume)
2044;
2045 }
2046 GeneratedField::Throttle => {
2047 if mutation__.is_some() {
2048 return Err(serde::de::Error::duplicate_field("throttle"));
2049 }
2050 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Throttle)
2051;
2052 }
2053 GeneratedField::DropSubscriptions => {
2054 if mutation__.is_some() {
2055 return Err(serde::de::Error::duplicate_field("dropSubscriptions"));
2056 }
2057 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::DropSubscriptions)
2058;
2059 }
2060 GeneratedField::ConnectorPropsChange => {
2061 if mutation__.is_some() {
2062 return Err(serde::de::Error::duplicate_field("connectorPropsChange"));
2063 }
2064 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ConnectorPropsChange)
2065;
2066 }
2067 GeneratedField::StartFragmentBackfill => {
2068 if mutation__.is_some() {
2069 return Err(serde::de::Error::duplicate_field("startFragmentBackfill"));
2070 }
2071 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::StartFragmentBackfill)
2072;
2073 }
2074 GeneratedField::RefreshStart => {
2075 if mutation__.is_some() {
2076 return Err(serde::de::Error::duplicate_field("refreshStart"));
2077 }
2078 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::RefreshStart)
2079;
2080 }
2081 GeneratedField::LoadFinish => {
2082 if mutation__.is_some() {
2083 return Err(serde::de::Error::duplicate_field("loadFinish"));
2084 }
2085 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::LoadFinish)
2086;
2087 }
2088 GeneratedField::ListFinish => {
2089 if mutation__.is_some() {
2090 return Err(serde::de::Error::duplicate_field("listFinish"));
2091 }
2092 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ListFinish)
2093;
2094 }
2095 GeneratedField::ResetSource => {
2096 if mutation__.is_some() {
2097 return Err(serde::de::Error::duplicate_field("resetSource"));
2098 }
2099 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ResetSource)
2100;
2101 }
2102 GeneratedField::InjectSourceOffsets => {
2103 if mutation__.is_some() {
2104 return Err(serde::de::Error::duplicate_field("injectSourceOffsets"));
2105 }
2106 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::InjectSourceOffsets)
2107;
2108 }
2109 }
2110 }
2111 Ok(BarrierMutation {
2112 mutation: mutation__,
2113 })
2114 }
2115 }
2116 deserializer.deserialize_struct("stream_plan.BarrierMutation", FIELDS, GeneratedVisitor)
2117 }
2118}
2119impl serde::Serialize for BarrierRecvNode {
2120 #[allow(deprecated)]
2121 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2122 where
2123 S: serde::Serializer,
2124 {
2125 use serde::ser::SerializeStruct;
2126 let len = 0;
2127 let struct_ser = serializer.serialize_struct("stream_plan.BarrierRecvNode", len)?;
2128 struct_ser.end()
2129 }
2130}
2131impl<'de> serde::Deserialize<'de> for BarrierRecvNode {
2132 #[allow(deprecated)]
2133 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2134 where
2135 D: serde::Deserializer<'de>,
2136 {
2137 const FIELDS: &[&str] = &[
2138 ];
2139
2140 #[allow(clippy::enum_variant_names)]
2141 enum GeneratedField {
2142 }
2143 impl<'de> serde::Deserialize<'de> for GeneratedField {
2144 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2145 where
2146 D: serde::Deserializer<'de>,
2147 {
2148 struct GeneratedVisitor;
2149
2150 impl serde::de::Visitor<'_> for GeneratedVisitor {
2151 type Value = GeneratedField;
2152
2153 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2154 write!(formatter, "expected one of: {:?}", &FIELDS)
2155 }
2156
2157 #[allow(unused_variables)]
2158 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2159 where
2160 E: serde::de::Error,
2161 {
2162 Err(serde::de::Error::unknown_field(value, FIELDS))
2163 }
2164 }
2165 deserializer.deserialize_identifier(GeneratedVisitor)
2166 }
2167 }
2168 struct GeneratedVisitor;
2169 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2170 type Value = BarrierRecvNode;
2171
2172 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2173 formatter.write_str("struct stream_plan.BarrierRecvNode")
2174 }
2175
2176 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierRecvNode, V::Error>
2177 where
2178 V: serde::de::MapAccess<'de>,
2179 {
2180 while map_.next_key::<GeneratedField>()?.is_some() {
2181 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2182 }
2183 Ok(BarrierRecvNode {
2184 })
2185 }
2186 }
2187 deserializer.deserialize_struct("stream_plan.BarrierRecvNode", FIELDS, GeneratedVisitor)
2188 }
2189}
2190impl serde::Serialize for BatchPlanNode {
2191 #[allow(deprecated)]
2192 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2193 where
2194 S: serde::Serializer,
2195 {
2196 use serde::ser::SerializeStruct;
2197 let mut len = 0;
2198 if self.table_desc.is_some() {
2199 len += 1;
2200 }
2201 if !self.column_ids.is_empty() {
2202 len += 1;
2203 }
2204 let mut struct_ser = serializer.serialize_struct("stream_plan.BatchPlanNode", len)?;
2205 if let Some(v) = self.table_desc.as_ref() {
2206 struct_ser.serialize_field("tableDesc", v)?;
2207 }
2208 if !self.column_ids.is_empty() {
2209 struct_ser.serialize_field("columnIds", &self.column_ids)?;
2210 }
2211 struct_ser.end()
2212 }
2213}
2214impl<'de> serde::Deserialize<'de> for BatchPlanNode {
2215 #[allow(deprecated)]
2216 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2217 where
2218 D: serde::Deserializer<'de>,
2219 {
2220 const FIELDS: &[&str] = &[
2221 "table_desc",
2222 "tableDesc",
2223 "column_ids",
2224 "columnIds",
2225 ];
2226
2227 #[allow(clippy::enum_variant_names)]
2228 enum GeneratedField {
2229 TableDesc,
2230 ColumnIds,
2231 }
2232 impl<'de> serde::Deserialize<'de> for GeneratedField {
2233 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2234 where
2235 D: serde::Deserializer<'de>,
2236 {
2237 struct GeneratedVisitor;
2238
2239 impl serde::de::Visitor<'_> for GeneratedVisitor {
2240 type Value = GeneratedField;
2241
2242 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2243 write!(formatter, "expected one of: {:?}", &FIELDS)
2244 }
2245
2246 #[allow(unused_variables)]
2247 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2248 where
2249 E: serde::de::Error,
2250 {
2251 match value {
2252 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
2253 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
2254 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2255 }
2256 }
2257 }
2258 deserializer.deserialize_identifier(GeneratedVisitor)
2259 }
2260 }
2261 struct GeneratedVisitor;
2262 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2263 type Value = BatchPlanNode;
2264
2265 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2266 formatter.write_str("struct stream_plan.BatchPlanNode")
2267 }
2268
2269 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BatchPlanNode, V::Error>
2270 where
2271 V: serde::de::MapAccess<'de>,
2272 {
2273 let mut table_desc__ = None;
2274 let mut column_ids__ = None;
2275 while let Some(k) = map_.next_key()? {
2276 match k {
2277 GeneratedField::TableDesc => {
2278 if table_desc__.is_some() {
2279 return Err(serde::de::Error::duplicate_field("tableDesc"));
2280 }
2281 table_desc__ = map_.next_value()?;
2282 }
2283 GeneratedField::ColumnIds => {
2284 if column_ids__.is_some() {
2285 return Err(serde::de::Error::duplicate_field("columnIds"));
2286 }
2287 column_ids__ =
2288 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2289 .into_iter().map(|x| x.0).collect())
2290 ;
2291 }
2292 }
2293 }
2294 Ok(BatchPlanNode {
2295 table_desc: table_desc__,
2296 column_ids: column_ids__.unwrap_or_default(),
2297 })
2298 }
2299 }
2300 deserializer.deserialize_struct("stream_plan.BatchPlanNode", FIELDS, GeneratedVisitor)
2301 }
2302}
2303impl serde::Serialize for CdcFilterNode {
2304 #[allow(deprecated)]
2305 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2306 where
2307 S: serde::Serializer,
2308 {
2309 use serde::ser::SerializeStruct;
2310 let mut len = 0;
2311 if self.search_condition.is_some() {
2312 len += 1;
2313 }
2314 if self.upstream_source_id != 0 {
2315 len += 1;
2316 }
2317 let mut struct_ser = serializer.serialize_struct("stream_plan.CdcFilterNode", len)?;
2318 if let Some(v) = self.search_condition.as_ref() {
2319 struct_ser.serialize_field("searchCondition", v)?;
2320 }
2321 if self.upstream_source_id != 0 {
2322 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
2323 }
2324 struct_ser.end()
2325 }
2326}
2327impl<'de> serde::Deserialize<'de> for CdcFilterNode {
2328 #[allow(deprecated)]
2329 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2330 where
2331 D: serde::Deserializer<'de>,
2332 {
2333 const FIELDS: &[&str] = &[
2334 "search_condition",
2335 "searchCondition",
2336 "upstream_source_id",
2337 "upstreamSourceId",
2338 ];
2339
2340 #[allow(clippy::enum_variant_names)]
2341 enum GeneratedField {
2342 SearchCondition,
2343 UpstreamSourceId,
2344 }
2345 impl<'de> serde::Deserialize<'de> for GeneratedField {
2346 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2347 where
2348 D: serde::Deserializer<'de>,
2349 {
2350 struct GeneratedVisitor;
2351
2352 impl serde::de::Visitor<'_> for GeneratedVisitor {
2353 type Value = GeneratedField;
2354
2355 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2356 write!(formatter, "expected one of: {:?}", &FIELDS)
2357 }
2358
2359 #[allow(unused_variables)]
2360 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2361 where
2362 E: serde::de::Error,
2363 {
2364 match value {
2365 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
2366 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
2367 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2368 }
2369 }
2370 }
2371 deserializer.deserialize_identifier(GeneratedVisitor)
2372 }
2373 }
2374 struct GeneratedVisitor;
2375 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2376 type Value = CdcFilterNode;
2377
2378 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2379 formatter.write_str("struct stream_plan.CdcFilterNode")
2380 }
2381
2382 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcFilterNode, V::Error>
2383 where
2384 V: serde::de::MapAccess<'de>,
2385 {
2386 let mut search_condition__ = None;
2387 let mut upstream_source_id__ = None;
2388 while let Some(k) = map_.next_key()? {
2389 match k {
2390 GeneratedField::SearchCondition => {
2391 if search_condition__.is_some() {
2392 return Err(serde::de::Error::duplicate_field("searchCondition"));
2393 }
2394 search_condition__ = map_.next_value()?;
2395 }
2396 GeneratedField::UpstreamSourceId => {
2397 if upstream_source_id__.is_some() {
2398 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
2399 }
2400 upstream_source_id__ =
2401 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2402 ;
2403 }
2404 }
2405 }
2406 Ok(CdcFilterNode {
2407 search_condition: search_condition__,
2408 upstream_source_id: upstream_source_id__.unwrap_or_default(),
2409 })
2410 }
2411 }
2412 deserializer.deserialize_struct("stream_plan.CdcFilterNode", FIELDS, GeneratedVisitor)
2413 }
2414}
2415impl serde::Serialize for ChangeLogNode {
2416 #[allow(deprecated)]
2417 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2418 where
2419 S: serde::Serializer,
2420 {
2421 use serde::ser::SerializeStruct;
2422 let mut len = 0;
2423 if self.need_op {
2424 len += 1;
2425 }
2426 if !self.distribution_keys.is_empty() {
2427 len += 1;
2428 }
2429 let mut struct_ser = serializer.serialize_struct("stream_plan.ChangeLogNode", len)?;
2430 if self.need_op {
2431 struct_ser.serialize_field("needOp", &self.need_op)?;
2432 }
2433 if !self.distribution_keys.is_empty() {
2434 struct_ser.serialize_field("distributionKeys", &self.distribution_keys)?;
2435 }
2436 struct_ser.end()
2437 }
2438}
2439impl<'de> serde::Deserialize<'de> for ChangeLogNode {
2440 #[allow(deprecated)]
2441 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2442 where
2443 D: serde::Deserializer<'de>,
2444 {
2445 const FIELDS: &[&str] = &[
2446 "need_op",
2447 "needOp",
2448 "distribution_keys",
2449 "distributionKeys",
2450 ];
2451
2452 #[allow(clippy::enum_variant_names)]
2453 enum GeneratedField {
2454 NeedOp,
2455 DistributionKeys,
2456 }
2457 impl<'de> serde::Deserialize<'de> for GeneratedField {
2458 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2459 where
2460 D: serde::Deserializer<'de>,
2461 {
2462 struct GeneratedVisitor;
2463
2464 impl serde::de::Visitor<'_> for GeneratedVisitor {
2465 type Value = GeneratedField;
2466
2467 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2468 write!(formatter, "expected one of: {:?}", &FIELDS)
2469 }
2470
2471 #[allow(unused_variables)]
2472 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2473 where
2474 E: serde::de::Error,
2475 {
2476 match value {
2477 "needOp" | "need_op" => Ok(GeneratedField::NeedOp),
2478 "distributionKeys" | "distribution_keys" => Ok(GeneratedField::DistributionKeys),
2479 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2480 }
2481 }
2482 }
2483 deserializer.deserialize_identifier(GeneratedVisitor)
2484 }
2485 }
2486 struct GeneratedVisitor;
2487 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2488 type Value = ChangeLogNode;
2489
2490 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2491 formatter.write_str("struct stream_plan.ChangeLogNode")
2492 }
2493
2494 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ChangeLogNode, V::Error>
2495 where
2496 V: serde::de::MapAccess<'de>,
2497 {
2498 let mut need_op__ = None;
2499 let mut distribution_keys__ = None;
2500 while let Some(k) = map_.next_key()? {
2501 match k {
2502 GeneratedField::NeedOp => {
2503 if need_op__.is_some() {
2504 return Err(serde::de::Error::duplicate_field("needOp"));
2505 }
2506 need_op__ = Some(map_.next_value()?);
2507 }
2508 GeneratedField::DistributionKeys => {
2509 if distribution_keys__.is_some() {
2510 return Err(serde::de::Error::duplicate_field("distributionKeys"));
2511 }
2512 distribution_keys__ =
2513 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2514 .into_iter().map(|x| x.0).collect())
2515 ;
2516 }
2517 }
2518 }
2519 Ok(ChangeLogNode {
2520 need_op: need_op__.unwrap_or_default(),
2521 distribution_keys: distribution_keys__.unwrap_or_default(),
2522 })
2523 }
2524 }
2525 deserializer.deserialize_struct("stream_plan.ChangeLogNode", FIELDS, GeneratedVisitor)
2526 }
2527}
2528impl serde::Serialize for Columns {
2529 #[allow(deprecated)]
2530 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2531 where
2532 S: serde::Serializer,
2533 {
2534 use serde::ser::SerializeStruct;
2535 let mut len = 0;
2536 if !self.columns.is_empty() {
2537 len += 1;
2538 }
2539 let mut struct_ser = serializer.serialize_struct("stream_plan.Columns", len)?;
2540 if !self.columns.is_empty() {
2541 struct_ser.serialize_field("columns", &self.columns)?;
2542 }
2543 struct_ser.end()
2544 }
2545}
2546impl<'de> serde::Deserialize<'de> for Columns {
2547 #[allow(deprecated)]
2548 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2549 where
2550 D: serde::Deserializer<'de>,
2551 {
2552 const FIELDS: &[&str] = &[
2553 "columns",
2554 ];
2555
2556 #[allow(clippy::enum_variant_names)]
2557 enum GeneratedField {
2558 Columns,
2559 }
2560 impl<'de> serde::Deserialize<'de> for GeneratedField {
2561 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2562 where
2563 D: serde::Deserializer<'de>,
2564 {
2565 struct GeneratedVisitor;
2566
2567 impl serde::de::Visitor<'_> for GeneratedVisitor {
2568 type Value = GeneratedField;
2569
2570 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2571 write!(formatter, "expected one of: {:?}", &FIELDS)
2572 }
2573
2574 #[allow(unused_variables)]
2575 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2576 where
2577 E: serde::de::Error,
2578 {
2579 match value {
2580 "columns" => Ok(GeneratedField::Columns),
2581 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2582 }
2583 }
2584 }
2585 deserializer.deserialize_identifier(GeneratedVisitor)
2586 }
2587 }
2588 struct GeneratedVisitor;
2589 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2590 type Value = Columns;
2591
2592 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2593 formatter.write_str("struct stream_plan.Columns")
2594 }
2595
2596 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Columns, V::Error>
2597 where
2598 V: serde::de::MapAccess<'de>,
2599 {
2600 let mut columns__ = None;
2601 while let Some(k) = map_.next_key()? {
2602 match k {
2603 GeneratedField::Columns => {
2604 if columns__.is_some() {
2605 return Err(serde::de::Error::duplicate_field("columns"));
2606 }
2607 columns__ = Some(map_.next_value()?);
2608 }
2609 }
2610 }
2611 Ok(Columns {
2612 columns: columns__.unwrap_or_default(),
2613 })
2614 }
2615 }
2616 deserializer.deserialize_struct("stream_plan.Columns", FIELDS, GeneratedVisitor)
2617 }
2618}
2619impl serde::Serialize for CompactionResolverNode {
2620 #[allow(deprecated)]
2621 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2622 where
2623 S: serde::Serializer,
2624 {
2625 use serde::ser::SerializeStruct;
2626 let mut len = 0;
2627 if self.sink_desc.is_some() {
2628 len += 1;
2629 }
2630 if self.pk_index_table.is_some() {
2631 len += 1;
2632 }
2633 if !self.output_data_file_paths.is_empty() {
2634 len += 1;
2635 }
2636 if !self.input_data_file_paths.is_empty() {
2637 len += 1;
2638 }
2639 if self.read_snapshot_id != 0 {
2640 len += 1;
2641 }
2642 if self.compaction_task_id != 0 {
2643 len += 1;
2644 }
2645 let mut struct_ser = serializer.serialize_struct("stream_plan.CompactionResolverNode", len)?;
2646 if let Some(v) = self.sink_desc.as_ref() {
2647 struct_ser.serialize_field("sinkDesc", v)?;
2648 }
2649 if let Some(v) = self.pk_index_table.as_ref() {
2650 struct_ser.serialize_field("pkIndexTable", v)?;
2651 }
2652 if !self.output_data_file_paths.is_empty() {
2653 struct_ser.serialize_field("outputDataFilePaths", &self.output_data_file_paths)?;
2654 }
2655 if !self.input_data_file_paths.is_empty() {
2656 struct_ser.serialize_field("inputDataFilePaths", &self.input_data_file_paths)?;
2657 }
2658 if self.read_snapshot_id != 0 {
2659 #[allow(clippy::needless_borrow)]
2660 #[allow(clippy::needless_borrows_for_generic_args)]
2661 struct_ser.serialize_field("readSnapshotId", ToString::to_string(&self.read_snapshot_id).as_str())?;
2662 }
2663 if self.compaction_task_id != 0 {
2664 #[allow(clippy::needless_borrow)]
2665 #[allow(clippy::needless_borrows_for_generic_args)]
2666 struct_ser.serialize_field("compactionTaskId", ToString::to_string(&self.compaction_task_id).as_str())?;
2667 }
2668 struct_ser.end()
2669 }
2670}
2671impl<'de> serde::Deserialize<'de> for CompactionResolverNode {
2672 #[allow(deprecated)]
2673 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2674 where
2675 D: serde::Deserializer<'de>,
2676 {
2677 const FIELDS: &[&str] = &[
2678 "sink_desc",
2679 "sinkDesc",
2680 "pk_index_table",
2681 "pkIndexTable",
2682 "output_data_file_paths",
2683 "outputDataFilePaths",
2684 "input_data_file_paths",
2685 "inputDataFilePaths",
2686 "read_snapshot_id",
2687 "readSnapshotId",
2688 "compaction_task_id",
2689 "compactionTaskId",
2690 ];
2691
2692 #[allow(clippy::enum_variant_names)]
2693 enum GeneratedField {
2694 SinkDesc,
2695 PkIndexTable,
2696 OutputDataFilePaths,
2697 InputDataFilePaths,
2698 ReadSnapshotId,
2699 CompactionTaskId,
2700 }
2701 impl<'de> serde::Deserialize<'de> for GeneratedField {
2702 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2703 where
2704 D: serde::Deserializer<'de>,
2705 {
2706 struct GeneratedVisitor;
2707
2708 impl serde::de::Visitor<'_> for GeneratedVisitor {
2709 type Value = GeneratedField;
2710
2711 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2712 write!(formatter, "expected one of: {:?}", &FIELDS)
2713 }
2714
2715 #[allow(unused_variables)]
2716 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2717 where
2718 E: serde::de::Error,
2719 {
2720 match value {
2721 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
2722 "pkIndexTable" | "pk_index_table" => Ok(GeneratedField::PkIndexTable),
2723 "outputDataFilePaths" | "output_data_file_paths" => Ok(GeneratedField::OutputDataFilePaths),
2724 "inputDataFilePaths" | "input_data_file_paths" => Ok(GeneratedField::InputDataFilePaths),
2725 "readSnapshotId" | "read_snapshot_id" => Ok(GeneratedField::ReadSnapshotId),
2726 "compactionTaskId" | "compaction_task_id" => Ok(GeneratedField::CompactionTaskId),
2727 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2728 }
2729 }
2730 }
2731 deserializer.deserialize_identifier(GeneratedVisitor)
2732 }
2733 }
2734 struct GeneratedVisitor;
2735 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2736 type Value = CompactionResolverNode;
2737
2738 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2739 formatter.write_str("struct stream_plan.CompactionResolverNode")
2740 }
2741
2742 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionResolverNode, V::Error>
2743 where
2744 V: serde::de::MapAccess<'de>,
2745 {
2746 let mut sink_desc__ = None;
2747 let mut pk_index_table__ = None;
2748 let mut output_data_file_paths__ = None;
2749 let mut input_data_file_paths__ = None;
2750 let mut read_snapshot_id__ = None;
2751 let mut compaction_task_id__ = None;
2752 while let Some(k) = map_.next_key()? {
2753 match k {
2754 GeneratedField::SinkDesc => {
2755 if sink_desc__.is_some() {
2756 return Err(serde::de::Error::duplicate_field("sinkDesc"));
2757 }
2758 sink_desc__ = map_.next_value()?;
2759 }
2760 GeneratedField::PkIndexTable => {
2761 if pk_index_table__.is_some() {
2762 return Err(serde::de::Error::duplicate_field("pkIndexTable"));
2763 }
2764 pk_index_table__ = map_.next_value()?;
2765 }
2766 GeneratedField::OutputDataFilePaths => {
2767 if output_data_file_paths__.is_some() {
2768 return Err(serde::de::Error::duplicate_field("outputDataFilePaths"));
2769 }
2770 output_data_file_paths__ = Some(map_.next_value()?);
2771 }
2772 GeneratedField::InputDataFilePaths => {
2773 if input_data_file_paths__.is_some() {
2774 return Err(serde::de::Error::duplicate_field("inputDataFilePaths"));
2775 }
2776 input_data_file_paths__ = Some(map_.next_value()?);
2777 }
2778 GeneratedField::ReadSnapshotId => {
2779 if read_snapshot_id__.is_some() {
2780 return Err(serde::de::Error::duplicate_field("readSnapshotId"));
2781 }
2782 read_snapshot_id__ =
2783 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2784 ;
2785 }
2786 GeneratedField::CompactionTaskId => {
2787 if compaction_task_id__.is_some() {
2788 return Err(serde::de::Error::duplicate_field("compactionTaskId"));
2789 }
2790 compaction_task_id__ =
2791 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2792 ;
2793 }
2794 }
2795 }
2796 Ok(CompactionResolverNode {
2797 sink_desc: sink_desc__,
2798 pk_index_table: pk_index_table__,
2799 output_data_file_paths: output_data_file_paths__.unwrap_or_default(),
2800 input_data_file_paths: input_data_file_paths__.unwrap_or_default(),
2801 read_snapshot_id: read_snapshot_id__.unwrap_or_default(),
2802 compaction_task_id: compaction_task_id__.unwrap_or_default(),
2803 })
2804 }
2805 }
2806 deserializer.deserialize_struct("stream_plan.CompactionResolverNode", FIELDS, GeneratedVisitor)
2807 }
2808}
2809impl serde::Serialize for ConnectorPropsChangeMutation {
2810 #[allow(deprecated)]
2811 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2812 where
2813 S: serde::Serializer,
2814 {
2815 use serde::ser::SerializeStruct;
2816 let mut len = 0;
2817 if !self.connector_props_infos.is_empty() {
2818 len += 1;
2819 }
2820 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation", len)?;
2821 if !self.connector_props_infos.is_empty() {
2822 struct_ser.serialize_field("connectorPropsInfos", &self.connector_props_infos)?;
2823 }
2824 struct_ser.end()
2825 }
2826}
2827impl<'de> serde::Deserialize<'de> for ConnectorPropsChangeMutation {
2828 #[allow(deprecated)]
2829 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2830 where
2831 D: serde::Deserializer<'de>,
2832 {
2833 const FIELDS: &[&str] = &[
2834 "connector_props_infos",
2835 "connectorPropsInfos",
2836 ];
2837
2838 #[allow(clippy::enum_variant_names)]
2839 enum GeneratedField {
2840 ConnectorPropsInfos,
2841 }
2842 impl<'de> serde::Deserialize<'de> for GeneratedField {
2843 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2844 where
2845 D: serde::Deserializer<'de>,
2846 {
2847 struct GeneratedVisitor;
2848
2849 impl serde::de::Visitor<'_> for GeneratedVisitor {
2850 type Value = GeneratedField;
2851
2852 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2853 write!(formatter, "expected one of: {:?}", &FIELDS)
2854 }
2855
2856 #[allow(unused_variables)]
2857 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2858 where
2859 E: serde::de::Error,
2860 {
2861 match value {
2862 "connectorPropsInfos" | "connector_props_infos" => Ok(GeneratedField::ConnectorPropsInfos),
2863 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2864 }
2865 }
2866 }
2867 deserializer.deserialize_identifier(GeneratedVisitor)
2868 }
2869 }
2870 struct GeneratedVisitor;
2871 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2872 type Value = ConnectorPropsChangeMutation;
2873
2874 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2875 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation")
2876 }
2877
2878 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectorPropsChangeMutation, V::Error>
2879 where
2880 V: serde::de::MapAccess<'de>,
2881 {
2882 let mut connector_props_infos__ = None;
2883 while let Some(k) = map_.next_key()? {
2884 match k {
2885 GeneratedField::ConnectorPropsInfos => {
2886 if connector_props_infos__.is_some() {
2887 return Err(serde::de::Error::duplicate_field("connectorPropsInfos"));
2888 }
2889 connector_props_infos__ = Some(
2890 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
2891 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
2892 );
2893 }
2894 }
2895 }
2896 Ok(ConnectorPropsChangeMutation {
2897 connector_props_infos: connector_props_infos__.unwrap_or_default(),
2898 })
2899 }
2900 }
2901 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation", FIELDS, GeneratedVisitor)
2902 }
2903}
2904impl serde::Serialize for connector_props_change_mutation::ConnectorPropsInfo {
2905 #[allow(deprecated)]
2906 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2907 where
2908 S: serde::Serializer,
2909 {
2910 use serde::ser::SerializeStruct;
2911 let mut len = 0;
2912 if !self.connector_props_info.is_empty() {
2913 len += 1;
2914 }
2915 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", len)?;
2916 if !self.connector_props_info.is_empty() {
2917 struct_ser.serialize_field("connectorPropsInfo", &self.connector_props_info)?;
2918 }
2919 struct_ser.end()
2920 }
2921}
2922impl<'de> serde::Deserialize<'de> for connector_props_change_mutation::ConnectorPropsInfo {
2923 #[allow(deprecated)]
2924 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2925 where
2926 D: serde::Deserializer<'de>,
2927 {
2928 const FIELDS: &[&str] = &[
2929 "connector_props_info",
2930 "connectorPropsInfo",
2931 ];
2932
2933 #[allow(clippy::enum_variant_names)]
2934 enum GeneratedField {
2935 ConnectorPropsInfo,
2936 }
2937 impl<'de> serde::Deserialize<'de> for GeneratedField {
2938 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2939 where
2940 D: serde::Deserializer<'de>,
2941 {
2942 struct GeneratedVisitor;
2943
2944 impl serde::de::Visitor<'_> for GeneratedVisitor {
2945 type Value = GeneratedField;
2946
2947 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2948 write!(formatter, "expected one of: {:?}", &FIELDS)
2949 }
2950
2951 #[allow(unused_variables)]
2952 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2953 where
2954 E: serde::de::Error,
2955 {
2956 match value {
2957 "connectorPropsInfo" | "connector_props_info" => Ok(GeneratedField::ConnectorPropsInfo),
2958 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2959 }
2960 }
2961 }
2962 deserializer.deserialize_identifier(GeneratedVisitor)
2963 }
2964 }
2965 struct GeneratedVisitor;
2966 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2967 type Value = connector_props_change_mutation::ConnectorPropsInfo;
2968
2969 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2970 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo")
2971 }
2972
2973 fn visit_map<V>(self, mut map_: V) -> std::result::Result<connector_props_change_mutation::ConnectorPropsInfo, V::Error>
2974 where
2975 V: serde::de::MapAccess<'de>,
2976 {
2977 let mut connector_props_info__ = None;
2978 while let Some(k) = map_.next_key()? {
2979 match k {
2980 GeneratedField::ConnectorPropsInfo => {
2981 if connector_props_info__.is_some() {
2982 return Err(serde::de::Error::duplicate_field("connectorPropsInfo"));
2983 }
2984 connector_props_info__ = Some(
2985 map_.next_value::<std::collections::HashMap<_, _>>()?
2986 );
2987 }
2988 }
2989 }
2990 Ok(connector_props_change_mutation::ConnectorPropsInfo {
2991 connector_props_info: connector_props_info__.unwrap_or_default(),
2992 })
2993 }
2994 }
2995 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", FIELDS, GeneratedVisitor)
2996 }
2997}
2998impl serde::Serialize for DedupNode {
2999 #[allow(deprecated)]
3000 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3001 where
3002 S: serde::Serializer,
3003 {
3004 use serde::ser::SerializeStruct;
3005 let mut len = 0;
3006 if self.state_table.is_some() {
3007 len += 1;
3008 }
3009 if !self.dedup_column_indices.is_empty() {
3010 len += 1;
3011 }
3012 let mut struct_ser = serializer.serialize_struct("stream_plan.DedupNode", len)?;
3013 if let Some(v) = self.state_table.as_ref() {
3014 struct_ser.serialize_field("stateTable", v)?;
3015 }
3016 if !self.dedup_column_indices.is_empty() {
3017 struct_ser.serialize_field("dedupColumnIndices", &self.dedup_column_indices)?;
3018 }
3019 struct_ser.end()
3020 }
3021}
3022impl<'de> serde::Deserialize<'de> for DedupNode {
3023 #[allow(deprecated)]
3024 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3025 where
3026 D: serde::Deserializer<'de>,
3027 {
3028 const FIELDS: &[&str] = &[
3029 "state_table",
3030 "stateTable",
3031 "dedup_column_indices",
3032 "dedupColumnIndices",
3033 ];
3034
3035 #[allow(clippy::enum_variant_names)]
3036 enum GeneratedField {
3037 StateTable,
3038 DedupColumnIndices,
3039 }
3040 impl<'de> serde::Deserialize<'de> for GeneratedField {
3041 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3042 where
3043 D: serde::Deserializer<'de>,
3044 {
3045 struct GeneratedVisitor;
3046
3047 impl serde::de::Visitor<'_> for GeneratedVisitor {
3048 type Value = GeneratedField;
3049
3050 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3051 write!(formatter, "expected one of: {:?}", &FIELDS)
3052 }
3053
3054 #[allow(unused_variables)]
3055 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3056 where
3057 E: serde::de::Error,
3058 {
3059 match value {
3060 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
3061 "dedupColumnIndices" | "dedup_column_indices" => Ok(GeneratedField::DedupColumnIndices),
3062 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3063 }
3064 }
3065 }
3066 deserializer.deserialize_identifier(GeneratedVisitor)
3067 }
3068 }
3069 struct GeneratedVisitor;
3070 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3071 type Value = DedupNode;
3072
3073 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3074 formatter.write_str("struct stream_plan.DedupNode")
3075 }
3076
3077 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DedupNode, V::Error>
3078 where
3079 V: serde::de::MapAccess<'de>,
3080 {
3081 let mut state_table__ = None;
3082 let mut dedup_column_indices__ = None;
3083 while let Some(k) = map_.next_key()? {
3084 match k {
3085 GeneratedField::StateTable => {
3086 if state_table__.is_some() {
3087 return Err(serde::de::Error::duplicate_field("stateTable"));
3088 }
3089 state_table__ = map_.next_value()?;
3090 }
3091 GeneratedField::DedupColumnIndices => {
3092 if dedup_column_indices__.is_some() {
3093 return Err(serde::de::Error::duplicate_field("dedupColumnIndices"));
3094 }
3095 dedup_column_indices__ =
3096 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3097 .into_iter().map(|x| x.0).collect())
3098 ;
3099 }
3100 }
3101 }
3102 Ok(DedupNode {
3103 state_table: state_table__,
3104 dedup_column_indices: dedup_column_indices__.unwrap_or_default(),
3105 })
3106 }
3107 }
3108 deserializer.deserialize_struct("stream_plan.DedupNode", FIELDS, GeneratedVisitor)
3109 }
3110}
3111impl serde::Serialize for DeltaExpression {
3112 #[allow(deprecated)]
3113 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3114 where
3115 S: serde::Serializer,
3116 {
3117 use serde::ser::SerializeStruct;
3118 let mut len = 0;
3119 if self.delta_type != 0 {
3120 len += 1;
3121 }
3122 if self.delta.is_some() {
3123 len += 1;
3124 }
3125 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaExpression", len)?;
3126 if self.delta_type != 0 {
3127 let v = super::expr::expr_node::Type::try_from(self.delta_type)
3128 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.delta_type)))?;
3129 struct_ser.serialize_field("deltaType", &v)?;
3130 }
3131 if let Some(v) = self.delta.as_ref() {
3132 struct_ser.serialize_field("delta", v)?;
3133 }
3134 struct_ser.end()
3135 }
3136}
3137impl<'de> serde::Deserialize<'de> for DeltaExpression {
3138 #[allow(deprecated)]
3139 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3140 where
3141 D: serde::Deserializer<'de>,
3142 {
3143 const FIELDS: &[&str] = &[
3144 "delta_type",
3145 "deltaType",
3146 "delta",
3147 ];
3148
3149 #[allow(clippy::enum_variant_names)]
3150 enum GeneratedField {
3151 DeltaType,
3152 Delta,
3153 }
3154 impl<'de> serde::Deserialize<'de> for GeneratedField {
3155 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3156 where
3157 D: serde::Deserializer<'de>,
3158 {
3159 struct GeneratedVisitor;
3160
3161 impl serde::de::Visitor<'_> for GeneratedVisitor {
3162 type Value = GeneratedField;
3163
3164 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3165 write!(formatter, "expected one of: {:?}", &FIELDS)
3166 }
3167
3168 #[allow(unused_variables)]
3169 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3170 where
3171 E: serde::de::Error,
3172 {
3173 match value {
3174 "deltaType" | "delta_type" => Ok(GeneratedField::DeltaType),
3175 "delta" => Ok(GeneratedField::Delta),
3176 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3177 }
3178 }
3179 }
3180 deserializer.deserialize_identifier(GeneratedVisitor)
3181 }
3182 }
3183 struct GeneratedVisitor;
3184 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3185 type Value = DeltaExpression;
3186
3187 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3188 formatter.write_str("struct stream_plan.DeltaExpression")
3189 }
3190
3191 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaExpression, V::Error>
3192 where
3193 V: serde::de::MapAccess<'de>,
3194 {
3195 let mut delta_type__ = None;
3196 let mut delta__ = None;
3197 while let Some(k) = map_.next_key()? {
3198 match k {
3199 GeneratedField::DeltaType => {
3200 if delta_type__.is_some() {
3201 return Err(serde::de::Error::duplicate_field("deltaType"));
3202 }
3203 delta_type__ = Some(map_.next_value::<super::expr::expr_node::Type>()? as i32);
3204 }
3205 GeneratedField::Delta => {
3206 if delta__.is_some() {
3207 return Err(serde::de::Error::duplicate_field("delta"));
3208 }
3209 delta__ = map_.next_value()?;
3210 }
3211 }
3212 }
3213 Ok(DeltaExpression {
3214 delta_type: delta_type__.unwrap_or_default(),
3215 delta: delta__,
3216 })
3217 }
3218 }
3219 deserializer.deserialize_struct("stream_plan.DeltaExpression", FIELDS, GeneratedVisitor)
3220 }
3221}
3222impl serde::Serialize for DeltaIndexJoinNode {
3223 #[allow(deprecated)]
3224 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3225 where
3226 S: serde::Serializer,
3227 {
3228 use serde::ser::SerializeStruct;
3229 let mut len = 0;
3230 if self.join_type != 0 {
3231 len += 1;
3232 }
3233 if !self.left_key.is_empty() {
3234 len += 1;
3235 }
3236 if !self.right_key.is_empty() {
3237 len += 1;
3238 }
3239 if self.condition.is_some() {
3240 len += 1;
3241 }
3242 if self.left_table_id != 0 {
3243 len += 1;
3244 }
3245 if self.right_table_id != 0 {
3246 len += 1;
3247 }
3248 if self.left_info.is_some() {
3249 len += 1;
3250 }
3251 if self.right_info.is_some() {
3252 len += 1;
3253 }
3254 if !self.output_indices.is_empty() {
3255 len += 1;
3256 }
3257 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaIndexJoinNode", len)?;
3258 if self.join_type != 0 {
3259 let v = super::plan_common::JoinType::try_from(self.join_type)
3260 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
3261 struct_ser.serialize_field("joinType", &v)?;
3262 }
3263 if !self.left_key.is_empty() {
3264 struct_ser.serialize_field("leftKey", &self.left_key)?;
3265 }
3266 if !self.right_key.is_empty() {
3267 struct_ser.serialize_field("rightKey", &self.right_key)?;
3268 }
3269 if let Some(v) = self.condition.as_ref() {
3270 struct_ser.serialize_field("condition", v)?;
3271 }
3272 if self.left_table_id != 0 {
3273 struct_ser.serialize_field("leftTableId", &self.left_table_id)?;
3274 }
3275 if self.right_table_id != 0 {
3276 struct_ser.serialize_field("rightTableId", &self.right_table_id)?;
3277 }
3278 if let Some(v) = self.left_info.as_ref() {
3279 struct_ser.serialize_field("leftInfo", v)?;
3280 }
3281 if let Some(v) = self.right_info.as_ref() {
3282 struct_ser.serialize_field("rightInfo", v)?;
3283 }
3284 if !self.output_indices.is_empty() {
3285 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
3286 }
3287 struct_ser.end()
3288 }
3289}
3290impl<'de> serde::Deserialize<'de> for DeltaIndexJoinNode {
3291 #[allow(deprecated)]
3292 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3293 where
3294 D: serde::Deserializer<'de>,
3295 {
3296 const FIELDS: &[&str] = &[
3297 "join_type",
3298 "joinType",
3299 "left_key",
3300 "leftKey",
3301 "right_key",
3302 "rightKey",
3303 "condition",
3304 "left_table_id",
3305 "leftTableId",
3306 "right_table_id",
3307 "rightTableId",
3308 "left_info",
3309 "leftInfo",
3310 "right_info",
3311 "rightInfo",
3312 "output_indices",
3313 "outputIndices",
3314 ];
3315
3316 #[allow(clippy::enum_variant_names)]
3317 enum GeneratedField {
3318 JoinType,
3319 LeftKey,
3320 RightKey,
3321 Condition,
3322 LeftTableId,
3323 RightTableId,
3324 LeftInfo,
3325 RightInfo,
3326 OutputIndices,
3327 }
3328 impl<'de> serde::Deserialize<'de> for GeneratedField {
3329 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3330 where
3331 D: serde::Deserializer<'de>,
3332 {
3333 struct GeneratedVisitor;
3334
3335 impl serde::de::Visitor<'_> for GeneratedVisitor {
3336 type Value = GeneratedField;
3337
3338 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3339 write!(formatter, "expected one of: {:?}", &FIELDS)
3340 }
3341
3342 #[allow(unused_variables)]
3343 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3344 where
3345 E: serde::de::Error,
3346 {
3347 match value {
3348 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
3349 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
3350 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
3351 "condition" => Ok(GeneratedField::Condition),
3352 "leftTableId" | "left_table_id" => Ok(GeneratedField::LeftTableId),
3353 "rightTableId" | "right_table_id" => Ok(GeneratedField::RightTableId),
3354 "leftInfo" | "left_info" => Ok(GeneratedField::LeftInfo),
3355 "rightInfo" | "right_info" => Ok(GeneratedField::RightInfo),
3356 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
3357 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3358 }
3359 }
3360 }
3361 deserializer.deserialize_identifier(GeneratedVisitor)
3362 }
3363 }
3364 struct GeneratedVisitor;
3365 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3366 type Value = DeltaIndexJoinNode;
3367
3368 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3369 formatter.write_str("struct stream_plan.DeltaIndexJoinNode")
3370 }
3371
3372 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaIndexJoinNode, V::Error>
3373 where
3374 V: serde::de::MapAccess<'de>,
3375 {
3376 let mut join_type__ = None;
3377 let mut left_key__ = None;
3378 let mut right_key__ = None;
3379 let mut condition__ = None;
3380 let mut left_table_id__ = None;
3381 let mut right_table_id__ = None;
3382 let mut left_info__ = None;
3383 let mut right_info__ = None;
3384 let mut output_indices__ = None;
3385 while let Some(k) = map_.next_key()? {
3386 match k {
3387 GeneratedField::JoinType => {
3388 if join_type__.is_some() {
3389 return Err(serde::de::Error::duplicate_field("joinType"));
3390 }
3391 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
3392 }
3393 GeneratedField::LeftKey => {
3394 if left_key__.is_some() {
3395 return Err(serde::de::Error::duplicate_field("leftKey"));
3396 }
3397 left_key__ =
3398 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3399 .into_iter().map(|x| x.0).collect())
3400 ;
3401 }
3402 GeneratedField::RightKey => {
3403 if right_key__.is_some() {
3404 return Err(serde::de::Error::duplicate_field("rightKey"));
3405 }
3406 right_key__ =
3407 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3408 .into_iter().map(|x| x.0).collect())
3409 ;
3410 }
3411 GeneratedField::Condition => {
3412 if condition__.is_some() {
3413 return Err(serde::de::Error::duplicate_field("condition"));
3414 }
3415 condition__ = map_.next_value()?;
3416 }
3417 GeneratedField::LeftTableId => {
3418 if left_table_id__.is_some() {
3419 return Err(serde::de::Error::duplicate_field("leftTableId"));
3420 }
3421 left_table_id__ =
3422 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3423 ;
3424 }
3425 GeneratedField::RightTableId => {
3426 if right_table_id__.is_some() {
3427 return Err(serde::de::Error::duplicate_field("rightTableId"));
3428 }
3429 right_table_id__ =
3430 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3431 ;
3432 }
3433 GeneratedField::LeftInfo => {
3434 if left_info__.is_some() {
3435 return Err(serde::de::Error::duplicate_field("leftInfo"));
3436 }
3437 left_info__ = map_.next_value()?;
3438 }
3439 GeneratedField::RightInfo => {
3440 if right_info__.is_some() {
3441 return Err(serde::de::Error::duplicate_field("rightInfo"));
3442 }
3443 right_info__ = map_.next_value()?;
3444 }
3445 GeneratedField::OutputIndices => {
3446 if output_indices__.is_some() {
3447 return Err(serde::de::Error::duplicate_field("outputIndices"));
3448 }
3449 output_indices__ =
3450 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3451 .into_iter().map(|x| x.0).collect())
3452 ;
3453 }
3454 }
3455 }
3456 Ok(DeltaIndexJoinNode {
3457 join_type: join_type__.unwrap_or_default(),
3458 left_key: left_key__.unwrap_or_default(),
3459 right_key: right_key__.unwrap_or_default(),
3460 condition: condition__,
3461 left_table_id: left_table_id__.unwrap_or_default(),
3462 right_table_id: right_table_id__.unwrap_or_default(),
3463 left_info: left_info__,
3464 right_info: right_info__,
3465 output_indices: output_indices__.unwrap_or_default(),
3466 })
3467 }
3468 }
3469 deserializer.deserialize_struct("stream_plan.DeltaIndexJoinNode", FIELDS, GeneratedVisitor)
3470 }
3471}
3472impl serde::Serialize for DispatchOutputMapping {
3473 #[allow(deprecated)]
3474 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3475 where
3476 S: serde::Serializer,
3477 {
3478 use serde::ser::SerializeStruct;
3479 let mut len = 0;
3480 if !self.indices.is_empty() {
3481 len += 1;
3482 }
3483 if !self.types.is_empty() {
3484 len += 1;
3485 }
3486 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping", len)?;
3487 if !self.indices.is_empty() {
3488 struct_ser.serialize_field("indices", &self.indices)?;
3489 }
3490 if !self.types.is_empty() {
3491 struct_ser.serialize_field("types", &self.types)?;
3492 }
3493 struct_ser.end()
3494 }
3495}
3496impl<'de> serde::Deserialize<'de> for DispatchOutputMapping {
3497 #[allow(deprecated)]
3498 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3499 where
3500 D: serde::Deserializer<'de>,
3501 {
3502 const FIELDS: &[&str] = &[
3503 "indices",
3504 "types",
3505 ];
3506
3507 #[allow(clippy::enum_variant_names)]
3508 enum GeneratedField {
3509 Indices,
3510 Types,
3511 }
3512 impl<'de> serde::Deserialize<'de> for GeneratedField {
3513 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3514 where
3515 D: serde::Deserializer<'de>,
3516 {
3517 struct GeneratedVisitor;
3518
3519 impl serde::de::Visitor<'_> for GeneratedVisitor {
3520 type Value = GeneratedField;
3521
3522 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3523 write!(formatter, "expected one of: {:?}", &FIELDS)
3524 }
3525
3526 #[allow(unused_variables)]
3527 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3528 where
3529 E: serde::de::Error,
3530 {
3531 match value {
3532 "indices" => Ok(GeneratedField::Indices),
3533 "types" => Ok(GeneratedField::Types),
3534 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3535 }
3536 }
3537 }
3538 deserializer.deserialize_identifier(GeneratedVisitor)
3539 }
3540 }
3541 struct GeneratedVisitor;
3542 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3543 type Value = DispatchOutputMapping;
3544
3545 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3546 formatter.write_str("struct stream_plan.DispatchOutputMapping")
3547 }
3548
3549 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchOutputMapping, V::Error>
3550 where
3551 V: serde::de::MapAccess<'de>,
3552 {
3553 let mut indices__ = None;
3554 let mut types__ = None;
3555 while let Some(k) = map_.next_key()? {
3556 match k {
3557 GeneratedField::Indices => {
3558 if indices__.is_some() {
3559 return Err(serde::de::Error::duplicate_field("indices"));
3560 }
3561 indices__ =
3562 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3563 .into_iter().map(|x| x.0).collect())
3564 ;
3565 }
3566 GeneratedField::Types => {
3567 if types__.is_some() {
3568 return Err(serde::de::Error::duplicate_field("types"));
3569 }
3570 types__ = Some(map_.next_value()?);
3571 }
3572 }
3573 }
3574 Ok(DispatchOutputMapping {
3575 indices: indices__.unwrap_or_default(),
3576 types: types__.unwrap_or_default(),
3577 })
3578 }
3579 }
3580 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping", FIELDS, GeneratedVisitor)
3581 }
3582}
3583impl serde::Serialize for dispatch_output_mapping::TypePair {
3584 #[allow(deprecated)]
3585 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3586 where
3587 S: serde::Serializer,
3588 {
3589 use serde::ser::SerializeStruct;
3590 let mut len = 0;
3591 if self.upstream.is_some() {
3592 len += 1;
3593 }
3594 if self.downstream.is_some() {
3595 len += 1;
3596 }
3597 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping.TypePair", len)?;
3598 if let Some(v) = self.upstream.as_ref() {
3599 struct_ser.serialize_field("upstream", v)?;
3600 }
3601 if let Some(v) = self.downstream.as_ref() {
3602 struct_ser.serialize_field("downstream", v)?;
3603 }
3604 struct_ser.end()
3605 }
3606}
3607impl<'de> serde::Deserialize<'de> for dispatch_output_mapping::TypePair {
3608 #[allow(deprecated)]
3609 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3610 where
3611 D: serde::Deserializer<'de>,
3612 {
3613 const FIELDS: &[&str] = &[
3614 "upstream",
3615 "downstream",
3616 ];
3617
3618 #[allow(clippy::enum_variant_names)]
3619 enum GeneratedField {
3620 Upstream,
3621 Downstream,
3622 }
3623 impl<'de> serde::Deserialize<'de> for GeneratedField {
3624 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3625 where
3626 D: serde::Deserializer<'de>,
3627 {
3628 struct GeneratedVisitor;
3629
3630 impl serde::de::Visitor<'_> for GeneratedVisitor {
3631 type Value = GeneratedField;
3632
3633 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3634 write!(formatter, "expected one of: {:?}", &FIELDS)
3635 }
3636
3637 #[allow(unused_variables)]
3638 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3639 where
3640 E: serde::de::Error,
3641 {
3642 match value {
3643 "upstream" => Ok(GeneratedField::Upstream),
3644 "downstream" => Ok(GeneratedField::Downstream),
3645 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3646 }
3647 }
3648 }
3649 deserializer.deserialize_identifier(GeneratedVisitor)
3650 }
3651 }
3652 struct GeneratedVisitor;
3653 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3654 type Value = dispatch_output_mapping::TypePair;
3655
3656 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3657 formatter.write_str("struct stream_plan.DispatchOutputMapping.TypePair")
3658 }
3659
3660 fn visit_map<V>(self, mut map_: V) -> std::result::Result<dispatch_output_mapping::TypePair, V::Error>
3661 where
3662 V: serde::de::MapAccess<'de>,
3663 {
3664 let mut upstream__ = None;
3665 let mut downstream__ = None;
3666 while let Some(k) = map_.next_key()? {
3667 match k {
3668 GeneratedField::Upstream => {
3669 if upstream__.is_some() {
3670 return Err(serde::de::Error::duplicate_field("upstream"));
3671 }
3672 upstream__ = map_.next_value()?;
3673 }
3674 GeneratedField::Downstream => {
3675 if downstream__.is_some() {
3676 return Err(serde::de::Error::duplicate_field("downstream"));
3677 }
3678 downstream__ = map_.next_value()?;
3679 }
3680 }
3681 }
3682 Ok(dispatch_output_mapping::TypePair {
3683 upstream: upstream__,
3684 downstream: downstream__,
3685 })
3686 }
3687 }
3688 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping.TypePair", FIELDS, GeneratedVisitor)
3689 }
3690}
3691impl serde::Serialize for DispatchStrategy {
3692 #[allow(deprecated)]
3693 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3694 where
3695 S: serde::Serializer,
3696 {
3697 use serde::ser::SerializeStruct;
3698 let mut len = 0;
3699 if self.r#type != 0 {
3700 len += 1;
3701 }
3702 if !self.dist_key_indices.is_empty() {
3703 len += 1;
3704 }
3705 if self.output_mapping.is_some() {
3706 len += 1;
3707 }
3708 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchStrategy", len)?;
3709 if self.r#type != 0 {
3710 let v = DispatcherType::try_from(self.r#type)
3711 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3712 struct_ser.serialize_field("type", &v)?;
3713 }
3714 if !self.dist_key_indices.is_empty() {
3715 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3716 }
3717 if let Some(v) = self.output_mapping.as_ref() {
3718 struct_ser.serialize_field("outputMapping", v)?;
3719 }
3720 struct_ser.end()
3721 }
3722}
3723impl<'de> serde::Deserialize<'de> for DispatchStrategy {
3724 #[allow(deprecated)]
3725 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3726 where
3727 D: serde::Deserializer<'de>,
3728 {
3729 const FIELDS: &[&str] = &[
3730 "type",
3731 "dist_key_indices",
3732 "distKeyIndices",
3733 "output_mapping",
3734 "outputMapping",
3735 ];
3736
3737 #[allow(clippy::enum_variant_names)]
3738 enum GeneratedField {
3739 Type,
3740 DistKeyIndices,
3741 OutputMapping,
3742 }
3743 impl<'de> serde::Deserialize<'de> for GeneratedField {
3744 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3745 where
3746 D: serde::Deserializer<'de>,
3747 {
3748 struct GeneratedVisitor;
3749
3750 impl serde::de::Visitor<'_> for GeneratedVisitor {
3751 type Value = GeneratedField;
3752
3753 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3754 write!(formatter, "expected one of: {:?}", &FIELDS)
3755 }
3756
3757 #[allow(unused_variables)]
3758 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3759 where
3760 E: serde::de::Error,
3761 {
3762 match value {
3763 "type" => Ok(GeneratedField::Type),
3764 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3765 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3766 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3767 }
3768 }
3769 }
3770 deserializer.deserialize_identifier(GeneratedVisitor)
3771 }
3772 }
3773 struct GeneratedVisitor;
3774 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3775 type Value = DispatchStrategy;
3776
3777 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3778 formatter.write_str("struct stream_plan.DispatchStrategy")
3779 }
3780
3781 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchStrategy, V::Error>
3782 where
3783 V: serde::de::MapAccess<'de>,
3784 {
3785 let mut r#type__ = None;
3786 let mut dist_key_indices__ = None;
3787 let mut output_mapping__ = None;
3788 while let Some(k) = map_.next_key()? {
3789 match k {
3790 GeneratedField::Type => {
3791 if r#type__.is_some() {
3792 return Err(serde::de::Error::duplicate_field("type"));
3793 }
3794 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3795 }
3796 GeneratedField::DistKeyIndices => {
3797 if dist_key_indices__.is_some() {
3798 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3799 }
3800 dist_key_indices__ =
3801 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3802 .into_iter().map(|x| x.0).collect())
3803 ;
3804 }
3805 GeneratedField::OutputMapping => {
3806 if output_mapping__.is_some() {
3807 return Err(serde::de::Error::duplicate_field("outputMapping"));
3808 }
3809 output_mapping__ = map_.next_value()?;
3810 }
3811 }
3812 }
3813 Ok(DispatchStrategy {
3814 r#type: r#type__.unwrap_or_default(),
3815 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3816 output_mapping: output_mapping__,
3817 })
3818 }
3819 }
3820 deserializer.deserialize_struct("stream_plan.DispatchStrategy", FIELDS, GeneratedVisitor)
3821 }
3822}
3823impl serde::Serialize for Dispatcher {
3824 #[allow(deprecated)]
3825 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3826 where
3827 S: serde::Serializer,
3828 {
3829 use serde::ser::SerializeStruct;
3830 let mut len = 0;
3831 if self.r#type != 0 {
3832 len += 1;
3833 }
3834 if !self.dist_key_indices.is_empty() {
3835 len += 1;
3836 }
3837 if self.output_mapping.is_some() {
3838 len += 1;
3839 }
3840 if self.hash_mapping.is_some() {
3841 len += 1;
3842 }
3843 if self.dispatcher_id != 0 {
3844 len += 1;
3845 }
3846 if !self.downstream_actor_id.is_empty() {
3847 len += 1;
3848 }
3849 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatcher", len)?;
3850 if self.r#type != 0 {
3851 let v = DispatcherType::try_from(self.r#type)
3852 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3853 struct_ser.serialize_field("type", &v)?;
3854 }
3855 if !self.dist_key_indices.is_empty() {
3856 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3857 }
3858 if let Some(v) = self.output_mapping.as_ref() {
3859 struct_ser.serialize_field("outputMapping", v)?;
3860 }
3861 if let Some(v) = self.hash_mapping.as_ref() {
3862 struct_ser.serialize_field("hashMapping", v)?;
3863 }
3864 if self.dispatcher_id != 0 {
3865 struct_ser.serialize_field("dispatcherId", &self.dispatcher_id)?;
3866 }
3867 if !self.downstream_actor_id.is_empty() {
3868 struct_ser.serialize_field("downstreamActorId", &self.downstream_actor_id)?;
3869 }
3870 struct_ser.end()
3871 }
3872}
3873impl<'de> serde::Deserialize<'de> for Dispatcher {
3874 #[allow(deprecated)]
3875 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3876 where
3877 D: serde::Deserializer<'de>,
3878 {
3879 const FIELDS: &[&str] = &[
3880 "type",
3881 "dist_key_indices",
3882 "distKeyIndices",
3883 "output_mapping",
3884 "outputMapping",
3885 "hash_mapping",
3886 "hashMapping",
3887 "dispatcher_id",
3888 "dispatcherId",
3889 "downstream_actor_id",
3890 "downstreamActorId",
3891 ];
3892
3893 #[allow(clippy::enum_variant_names)]
3894 enum GeneratedField {
3895 Type,
3896 DistKeyIndices,
3897 OutputMapping,
3898 HashMapping,
3899 DispatcherId,
3900 DownstreamActorId,
3901 }
3902 impl<'de> serde::Deserialize<'de> for GeneratedField {
3903 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3904 where
3905 D: serde::Deserializer<'de>,
3906 {
3907 struct GeneratedVisitor;
3908
3909 impl serde::de::Visitor<'_> for GeneratedVisitor {
3910 type Value = GeneratedField;
3911
3912 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3913 write!(formatter, "expected one of: {:?}", &FIELDS)
3914 }
3915
3916 #[allow(unused_variables)]
3917 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3918 where
3919 E: serde::de::Error,
3920 {
3921 match value {
3922 "type" => Ok(GeneratedField::Type),
3923 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3924 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3925 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
3926 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
3927 "downstreamActorId" | "downstream_actor_id" => Ok(GeneratedField::DownstreamActorId),
3928 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3929 }
3930 }
3931 }
3932 deserializer.deserialize_identifier(GeneratedVisitor)
3933 }
3934 }
3935 struct GeneratedVisitor;
3936 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3937 type Value = Dispatcher;
3938
3939 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3940 formatter.write_str("struct stream_plan.Dispatcher")
3941 }
3942
3943 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatcher, V::Error>
3944 where
3945 V: serde::de::MapAccess<'de>,
3946 {
3947 let mut r#type__ = None;
3948 let mut dist_key_indices__ = None;
3949 let mut output_mapping__ = None;
3950 let mut hash_mapping__ = None;
3951 let mut dispatcher_id__ = None;
3952 let mut downstream_actor_id__ = None;
3953 while let Some(k) = map_.next_key()? {
3954 match k {
3955 GeneratedField::Type => {
3956 if r#type__.is_some() {
3957 return Err(serde::de::Error::duplicate_field("type"));
3958 }
3959 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3960 }
3961 GeneratedField::DistKeyIndices => {
3962 if dist_key_indices__.is_some() {
3963 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3964 }
3965 dist_key_indices__ =
3966 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3967 .into_iter().map(|x| x.0).collect())
3968 ;
3969 }
3970 GeneratedField::OutputMapping => {
3971 if output_mapping__.is_some() {
3972 return Err(serde::de::Error::duplicate_field("outputMapping"));
3973 }
3974 output_mapping__ = map_.next_value()?;
3975 }
3976 GeneratedField::HashMapping => {
3977 if hash_mapping__.is_some() {
3978 return Err(serde::de::Error::duplicate_field("hashMapping"));
3979 }
3980 hash_mapping__ = map_.next_value()?;
3981 }
3982 GeneratedField::DispatcherId => {
3983 if dispatcher_id__.is_some() {
3984 return Err(serde::de::Error::duplicate_field("dispatcherId"));
3985 }
3986 dispatcher_id__ =
3987 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3988 ;
3989 }
3990 GeneratedField::DownstreamActorId => {
3991 if downstream_actor_id__.is_some() {
3992 return Err(serde::de::Error::duplicate_field("downstreamActorId"));
3993 }
3994 downstream_actor_id__ =
3995 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3996 .into_iter().map(|x| x.0).collect())
3997 ;
3998 }
3999 }
4000 }
4001 Ok(Dispatcher {
4002 r#type: r#type__.unwrap_or_default(),
4003 dist_key_indices: dist_key_indices__.unwrap_or_default(),
4004 output_mapping: output_mapping__,
4005 hash_mapping: hash_mapping__,
4006 dispatcher_id: dispatcher_id__.unwrap_or_default(),
4007 downstream_actor_id: downstream_actor_id__.unwrap_or_default(),
4008 })
4009 }
4010 }
4011 deserializer.deserialize_struct("stream_plan.Dispatcher", FIELDS, GeneratedVisitor)
4012 }
4013}
4014impl serde::Serialize for DispatcherType {
4015 #[allow(deprecated)]
4016 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4017 where
4018 S: serde::Serializer,
4019 {
4020 let variant = match self {
4021 Self::Unspecified => "DISPATCHER_TYPE_UNSPECIFIED",
4022 Self::Hash => "DISPATCHER_TYPE_HASH",
4023 Self::Broadcast => "DISPATCHER_TYPE_BROADCAST",
4024 Self::Simple => "DISPATCHER_TYPE_SIMPLE",
4025 Self::NoShuffle => "DISPATCHER_TYPE_NO_SHUFFLE",
4026 };
4027 serializer.serialize_str(variant)
4028 }
4029}
4030impl<'de> serde::Deserialize<'de> for DispatcherType {
4031 #[allow(deprecated)]
4032 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4033 where
4034 D: serde::Deserializer<'de>,
4035 {
4036 const FIELDS: &[&str] = &[
4037 "DISPATCHER_TYPE_UNSPECIFIED",
4038 "DISPATCHER_TYPE_HASH",
4039 "DISPATCHER_TYPE_BROADCAST",
4040 "DISPATCHER_TYPE_SIMPLE",
4041 "DISPATCHER_TYPE_NO_SHUFFLE",
4042 ];
4043
4044 struct GeneratedVisitor;
4045
4046 impl serde::de::Visitor<'_> for GeneratedVisitor {
4047 type Value = DispatcherType;
4048
4049 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4050 write!(formatter, "expected one of: {:?}", &FIELDS)
4051 }
4052
4053 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
4054 where
4055 E: serde::de::Error,
4056 {
4057 i32::try_from(v)
4058 .ok()
4059 .and_then(|x| x.try_into().ok())
4060 .ok_or_else(|| {
4061 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
4062 })
4063 }
4064
4065 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
4066 where
4067 E: serde::de::Error,
4068 {
4069 i32::try_from(v)
4070 .ok()
4071 .and_then(|x| x.try_into().ok())
4072 .ok_or_else(|| {
4073 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
4074 })
4075 }
4076
4077 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
4078 where
4079 E: serde::de::Error,
4080 {
4081 match value {
4082 "DISPATCHER_TYPE_UNSPECIFIED" => Ok(DispatcherType::Unspecified),
4083 "DISPATCHER_TYPE_HASH" => Ok(DispatcherType::Hash),
4084 "DISPATCHER_TYPE_BROADCAST" => Ok(DispatcherType::Broadcast),
4085 "DISPATCHER_TYPE_SIMPLE" => Ok(DispatcherType::Simple),
4086 "DISPATCHER_TYPE_NO_SHUFFLE" => Ok(DispatcherType::NoShuffle),
4087 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
4088 }
4089 }
4090 }
4091 deserializer.deserialize_any(GeneratedVisitor)
4092 }
4093}
4094impl serde::Serialize for Dispatchers {
4095 #[allow(deprecated)]
4096 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4097 where
4098 S: serde::Serializer,
4099 {
4100 use serde::ser::SerializeStruct;
4101 let mut len = 0;
4102 if !self.dispatchers.is_empty() {
4103 len += 1;
4104 }
4105 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatchers", len)?;
4106 if !self.dispatchers.is_empty() {
4107 struct_ser.serialize_field("dispatchers", &self.dispatchers)?;
4108 }
4109 struct_ser.end()
4110 }
4111}
4112impl<'de> serde::Deserialize<'de> for Dispatchers {
4113 #[allow(deprecated)]
4114 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4115 where
4116 D: serde::Deserializer<'de>,
4117 {
4118 const FIELDS: &[&str] = &[
4119 "dispatchers",
4120 ];
4121
4122 #[allow(clippy::enum_variant_names)]
4123 enum GeneratedField {
4124 Dispatchers,
4125 }
4126 impl<'de> serde::Deserialize<'de> for GeneratedField {
4127 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4128 where
4129 D: serde::Deserializer<'de>,
4130 {
4131 struct GeneratedVisitor;
4132
4133 impl serde::de::Visitor<'_> for GeneratedVisitor {
4134 type Value = GeneratedField;
4135
4136 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4137 write!(formatter, "expected one of: {:?}", &FIELDS)
4138 }
4139
4140 #[allow(unused_variables)]
4141 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4142 where
4143 E: serde::de::Error,
4144 {
4145 match value {
4146 "dispatchers" => Ok(GeneratedField::Dispatchers),
4147 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4148 }
4149 }
4150 }
4151 deserializer.deserialize_identifier(GeneratedVisitor)
4152 }
4153 }
4154 struct GeneratedVisitor;
4155 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4156 type Value = Dispatchers;
4157
4158 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4159 formatter.write_str("struct stream_plan.Dispatchers")
4160 }
4161
4162 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatchers, V::Error>
4163 where
4164 V: serde::de::MapAccess<'de>,
4165 {
4166 let mut dispatchers__ = None;
4167 while let Some(k) = map_.next_key()? {
4168 match k {
4169 GeneratedField::Dispatchers => {
4170 if dispatchers__.is_some() {
4171 return Err(serde::de::Error::duplicate_field("dispatchers"));
4172 }
4173 dispatchers__ = Some(map_.next_value()?);
4174 }
4175 }
4176 }
4177 Ok(Dispatchers {
4178 dispatchers: dispatchers__.unwrap_or_default(),
4179 })
4180 }
4181 }
4182 deserializer.deserialize_struct("stream_plan.Dispatchers", FIELDS, GeneratedVisitor)
4183 }
4184}
4185impl serde::Serialize for DmlNode {
4186 #[allow(deprecated)]
4187 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4188 where
4189 S: serde::Serializer,
4190 {
4191 use serde::ser::SerializeStruct;
4192 let mut len = 0;
4193 if self.table_id != 0 {
4194 len += 1;
4195 }
4196 if self.table_version_id != 0 {
4197 len += 1;
4198 }
4199 if !self.column_descs.is_empty() {
4200 len += 1;
4201 }
4202 if self.rate_limit.is_some() {
4203 len += 1;
4204 }
4205 let mut struct_ser = serializer.serialize_struct("stream_plan.DmlNode", len)?;
4206 if self.table_id != 0 {
4207 struct_ser.serialize_field("tableId", &self.table_id)?;
4208 }
4209 if self.table_version_id != 0 {
4210 #[allow(clippy::needless_borrow)]
4211 #[allow(clippy::needless_borrows_for_generic_args)]
4212 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
4213 }
4214 if !self.column_descs.is_empty() {
4215 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
4216 }
4217 if let Some(v) = self.rate_limit.as_ref() {
4218 struct_ser.serialize_field("rateLimit", v)?;
4219 }
4220 struct_ser.end()
4221 }
4222}
4223impl<'de> serde::Deserialize<'de> for DmlNode {
4224 #[allow(deprecated)]
4225 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4226 where
4227 D: serde::Deserializer<'de>,
4228 {
4229 const FIELDS: &[&str] = &[
4230 "table_id",
4231 "tableId",
4232 "table_version_id",
4233 "tableVersionId",
4234 "column_descs",
4235 "columnDescs",
4236 "rate_limit",
4237 "rateLimit",
4238 ];
4239
4240 #[allow(clippy::enum_variant_names)]
4241 enum GeneratedField {
4242 TableId,
4243 TableVersionId,
4244 ColumnDescs,
4245 RateLimit,
4246 }
4247 impl<'de> serde::Deserialize<'de> for GeneratedField {
4248 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4249 where
4250 D: serde::Deserializer<'de>,
4251 {
4252 struct GeneratedVisitor;
4253
4254 impl serde::de::Visitor<'_> for GeneratedVisitor {
4255 type Value = GeneratedField;
4256
4257 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4258 write!(formatter, "expected one of: {:?}", &FIELDS)
4259 }
4260
4261 #[allow(unused_variables)]
4262 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4263 where
4264 E: serde::de::Error,
4265 {
4266 match value {
4267 "tableId" | "table_id" => Ok(GeneratedField::TableId),
4268 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
4269 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
4270 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
4271 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4272 }
4273 }
4274 }
4275 deserializer.deserialize_identifier(GeneratedVisitor)
4276 }
4277 }
4278 struct GeneratedVisitor;
4279 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4280 type Value = DmlNode;
4281
4282 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4283 formatter.write_str("struct stream_plan.DmlNode")
4284 }
4285
4286 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DmlNode, V::Error>
4287 where
4288 V: serde::de::MapAccess<'de>,
4289 {
4290 let mut table_id__ = None;
4291 let mut table_version_id__ = None;
4292 let mut column_descs__ = None;
4293 let mut rate_limit__ = None;
4294 while let Some(k) = map_.next_key()? {
4295 match k {
4296 GeneratedField::TableId => {
4297 if table_id__.is_some() {
4298 return Err(serde::de::Error::duplicate_field("tableId"));
4299 }
4300 table_id__ =
4301 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4302 ;
4303 }
4304 GeneratedField::TableVersionId => {
4305 if table_version_id__.is_some() {
4306 return Err(serde::de::Error::duplicate_field("tableVersionId"));
4307 }
4308 table_version_id__ =
4309 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4310 ;
4311 }
4312 GeneratedField::ColumnDescs => {
4313 if column_descs__.is_some() {
4314 return Err(serde::de::Error::duplicate_field("columnDescs"));
4315 }
4316 column_descs__ = Some(map_.next_value()?);
4317 }
4318 GeneratedField::RateLimit => {
4319 if rate_limit__.is_some() {
4320 return Err(serde::de::Error::duplicate_field("rateLimit"));
4321 }
4322 rate_limit__ =
4323 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4324 ;
4325 }
4326 }
4327 }
4328 Ok(DmlNode {
4329 table_id: table_id__.unwrap_or_default(),
4330 table_version_id: table_version_id__.unwrap_or_default(),
4331 column_descs: column_descs__.unwrap_or_default(),
4332 rate_limit: rate_limit__,
4333 })
4334 }
4335 }
4336 deserializer.deserialize_struct("stream_plan.DmlNode", FIELDS, GeneratedVisitor)
4337 }
4338}
4339impl serde::Serialize for DropSubscriptionsMutation {
4340 #[allow(deprecated)]
4341 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4342 where
4343 S: serde::Serializer,
4344 {
4345 use serde::ser::SerializeStruct;
4346 let mut len = 0;
4347 if !self.info.is_empty() {
4348 len += 1;
4349 }
4350 let mut struct_ser = serializer.serialize_struct("stream_plan.DropSubscriptionsMutation", len)?;
4351 if !self.info.is_empty() {
4352 struct_ser.serialize_field("info", &self.info)?;
4353 }
4354 struct_ser.end()
4355 }
4356}
4357impl<'de> serde::Deserialize<'de> for DropSubscriptionsMutation {
4358 #[allow(deprecated)]
4359 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4360 where
4361 D: serde::Deserializer<'de>,
4362 {
4363 const FIELDS: &[&str] = &[
4364 "info",
4365 ];
4366
4367 #[allow(clippy::enum_variant_names)]
4368 enum GeneratedField {
4369 Info,
4370 }
4371 impl<'de> serde::Deserialize<'de> for GeneratedField {
4372 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4373 where
4374 D: serde::Deserializer<'de>,
4375 {
4376 struct GeneratedVisitor;
4377
4378 impl serde::de::Visitor<'_> for GeneratedVisitor {
4379 type Value = GeneratedField;
4380
4381 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4382 write!(formatter, "expected one of: {:?}", &FIELDS)
4383 }
4384
4385 #[allow(unused_variables)]
4386 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4387 where
4388 E: serde::de::Error,
4389 {
4390 match value {
4391 "info" => Ok(GeneratedField::Info),
4392 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4393 }
4394 }
4395 }
4396 deserializer.deserialize_identifier(GeneratedVisitor)
4397 }
4398 }
4399 struct GeneratedVisitor;
4400 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4401 type Value = DropSubscriptionsMutation;
4402
4403 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4404 formatter.write_str("struct stream_plan.DropSubscriptionsMutation")
4405 }
4406
4407 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionsMutation, V::Error>
4408 where
4409 V: serde::de::MapAccess<'de>,
4410 {
4411 let mut info__ = None;
4412 while let Some(k) = map_.next_key()? {
4413 match k {
4414 GeneratedField::Info => {
4415 if info__.is_some() {
4416 return Err(serde::de::Error::duplicate_field("info"));
4417 }
4418 info__ = Some(map_.next_value()?);
4419 }
4420 }
4421 }
4422 Ok(DropSubscriptionsMutation {
4423 info: info__.unwrap_or_default(),
4424 })
4425 }
4426 }
4427 deserializer.deserialize_struct("stream_plan.DropSubscriptionsMutation", FIELDS, GeneratedVisitor)
4428 }
4429}
4430impl serde::Serialize for DynamicFilterNode {
4431 #[allow(deprecated)]
4432 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4433 where
4434 S: serde::Serializer,
4435 {
4436 use serde::ser::SerializeStruct;
4437 let mut len = 0;
4438 if self.left_key != 0 {
4439 len += 1;
4440 }
4441 if self.condition.is_some() {
4442 len += 1;
4443 }
4444 if self.left_table.is_some() {
4445 len += 1;
4446 }
4447 if self.right_table.is_some() {
4448 len += 1;
4449 }
4450 if self.condition_always_relax {
4451 len += 1;
4452 }
4453 if self.cleaned_by_watermark {
4454 len += 1;
4455 }
4456 let mut struct_ser = serializer.serialize_struct("stream_plan.DynamicFilterNode", len)?;
4457 if self.left_key != 0 {
4458 struct_ser.serialize_field("leftKey", &self.left_key)?;
4459 }
4460 if let Some(v) = self.condition.as_ref() {
4461 struct_ser.serialize_field("condition", v)?;
4462 }
4463 if let Some(v) = self.left_table.as_ref() {
4464 struct_ser.serialize_field("leftTable", v)?;
4465 }
4466 if let Some(v) = self.right_table.as_ref() {
4467 struct_ser.serialize_field("rightTable", v)?;
4468 }
4469 if self.condition_always_relax {
4470 struct_ser.serialize_field("conditionAlwaysRelax", &self.condition_always_relax)?;
4471 }
4472 if self.cleaned_by_watermark {
4473 struct_ser.serialize_field("cleanedByWatermark", &self.cleaned_by_watermark)?;
4474 }
4475 struct_ser.end()
4476 }
4477}
4478impl<'de> serde::Deserialize<'de> for DynamicFilterNode {
4479 #[allow(deprecated)]
4480 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4481 where
4482 D: serde::Deserializer<'de>,
4483 {
4484 const FIELDS: &[&str] = &[
4485 "left_key",
4486 "leftKey",
4487 "condition",
4488 "left_table",
4489 "leftTable",
4490 "right_table",
4491 "rightTable",
4492 "condition_always_relax",
4493 "conditionAlwaysRelax",
4494 "cleaned_by_watermark",
4495 "cleanedByWatermark",
4496 ];
4497
4498 #[allow(clippy::enum_variant_names)]
4499 enum GeneratedField {
4500 LeftKey,
4501 Condition,
4502 LeftTable,
4503 RightTable,
4504 ConditionAlwaysRelax,
4505 CleanedByWatermark,
4506 }
4507 impl<'de> serde::Deserialize<'de> for GeneratedField {
4508 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4509 where
4510 D: serde::Deserializer<'de>,
4511 {
4512 struct GeneratedVisitor;
4513
4514 impl serde::de::Visitor<'_> for GeneratedVisitor {
4515 type Value = GeneratedField;
4516
4517 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4518 write!(formatter, "expected one of: {:?}", &FIELDS)
4519 }
4520
4521 #[allow(unused_variables)]
4522 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4523 where
4524 E: serde::de::Error,
4525 {
4526 match value {
4527 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
4528 "condition" => Ok(GeneratedField::Condition),
4529 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
4530 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
4531 "conditionAlwaysRelax" | "condition_always_relax" => Ok(GeneratedField::ConditionAlwaysRelax),
4532 "cleanedByWatermark" | "cleaned_by_watermark" => Ok(GeneratedField::CleanedByWatermark),
4533 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4534 }
4535 }
4536 }
4537 deserializer.deserialize_identifier(GeneratedVisitor)
4538 }
4539 }
4540 struct GeneratedVisitor;
4541 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4542 type Value = DynamicFilterNode;
4543
4544 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4545 formatter.write_str("struct stream_plan.DynamicFilterNode")
4546 }
4547
4548 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DynamicFilterNode, V::Error>
4549 where
4550 V: serde::de::MapAccess<'de>,
4551 {
4552 let mut left_key__ = None;
4553 let mut condition__ = None;
4554 let mut left_table__ = None;
4555 let mut right_table__ = None;
4556 let mut condition_always_relax__ = None;
4557 let mut cleaned_by_watermark__ = None;
4558 while let Some(k) = map_.next_key()? {
4559 match k {
4560 GeneratedField::LeftKey => {
4561 if left_key__.is_some() {
4562 return Err(serde::de::Error::duplicate_field("leftKey"));
4563 }
4564 left_key__ =
4565 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4566 ;
4567 }
4568 GeneratedField::Condition => {
4569 if condition__.is_some() {
4570 return Err(serde::de::Error::duplicate_field("condition"));
4571 }
4572 condition__ = map_.next_value()?;
4573 }
4574 GeneratedField::LeftTable => {
4575 if left_table__.is_some() {
4576 return Err(serde::de::Error::duplicate_field("leftTable"));
4577 }
4578 left_table__ = map_.next_value()?;
4579 }
4580 GeneratedField::RightTable => {
4581 if right_table__.is_some() {
4582 return Err(serde::de::Error::duplicate_field("rightTable"));
4583 }
4584 right_table__ = map_.next_value()?;
4585 }
4586 GeneratedField::ConditionAlwaysRelax => {
4587 if condition_always_relax__.is_some() {
4588 return Err(serde::de::Error::duplicate_field("conditionAlwaysRelax"));
4589 }
4590 condition_always_relax__ = Some(map_.next_value()?);
4591 }
4592 GeneratedField::CleanedByWatermark => {
4593 if cleaned_by_watermark__.is_some() {
4594 return Err(serde::de::Error::duplicate_field("cleanedByWatermark"));
4595 }
4596 cleaned_by_watermark__ = Some(map_.next_value()?);
4597 }
4598 }
4599 }
4600 Ok(DynamicFilterNode {
4601 left_key: left_key__.unwrap_or_default(),
4602 condition: condition__,
4603 left_table: left_table__,
4604 right_table: right_table__,
4605 condition_always_relax: condition_always_relax__.unwrap_or_default(),
4606 cleaned_by_watermark: cleaned_by_watermark__.unwrap_or_default(),
4607 })
4608 }
4609 }
4610 deserializer.deserialize_struct("stream_plan.DynamicFilterNode", FIELDS, GeneratedVisitor)
4611 }
4612}
4613impl serde::Serialize for EowcGapFillNode {
4614 #[allow(deprecated)]
4615 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4616 where
4617 S: serde::Serializer,
4618 {
4619 use serde::ser::SerializeStruct;
4620 let mut len = 0;
4621 if self.time_column_index != 0 {
4622 len += 1;
4623 }
4624 if self.interval.is_some() {
4625 len += 1;
4626 }
4627 if !self.fill_columns.is_empty() {
4628 len += 1;
4629 }
4630 if !self.fill_strategies.is_empty() {
4631 len += 1;
4632 }
4633 if self.prev_row_table.is_some() {
4634 len += 1;
4635 }
4636 if !self.partition_by_indices.is_empty() {
4637 len += 1;
4638 }
4639 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcGapFillNode", len)?;
4640 if self.time_column_index != 0 {
4641 struct_ser.serialize_field("timeColumnIndex", &self.time_column_index)?;
4642 }
4643 if let Some(v) = self.interval.as_ref() {
4644 struct_ser.serialize_field("interval", v)?;
4645 }
4646 if !self.fill_columns.is_empty() {
4647 struct_ser.serialize_field("fillColumns", &self.fill_columns)?;
4648 }
4649 if !self.fill_strategies.is_empty() {
4650 struct_ser.serialize_field("fillStrategies", &self.fill_strategies)?;
4651 }
4652 if let Some(v) = self.prev_row_table.as_ref() {
4653 struct_ser.serialize_field("prevRowTable", v)?;
4654 }
4655 if !self.partition_by_indices.is_empty() {
4656 struct_ser.serialize_field("partitionByIndices", &self.partition_by_indices)?;
4657 }
4658 struct_ser.end()
4659 }
4660}
4661impl<'de> serde::Deserialize<'de> for EowcGapFillNode {
4662 #[allow(deprecated)]
4663 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4664 where
4665 D: serde::Deserializer<'de>,
4666 {
4667 const FIELDS: &[&str] = &[
4668 "time_column_index",
4669 "timeColumnIndex",
4670 "interval",
4671 "fill_columns",
4672 "fillColumns",
4673 "fill_strategies",
4674 "fillStrategies",
4675 "prev_row_table",
4676 "prevRowTable",
4677 "partition_by_indices",
4678 "partitionByIndices",
4679 ];
4680
4681 #[allow(clippy::enum_variant_names)]
4682 enum GeneratedField {
4683 TimeColumnIndex,
4684 Interval,
4685 FillColumns,
4686 FillStrategies,
4687 PrevRowTable,
4688 PartitionByIndices,
4689 }
4690 impl<'de> serde::Deserialize<'de> for GeneratedField {
4691 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4692 where
4693 D: serde::Deserializer<'de>,
4694 {
4695 struct GeneratedVisitor;
4696
4697 impl serde::de::Visitor<'_> for GeneratedVisitor {
4698 type Value = GeneratedField;
4699
4700 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4701 write!(formatter, "expected one of: {:?}", &FIELDS)
4702 }
4703
4704 #[allow(unused_variables)]
4705 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4706 where
4707 E: serde::de::Error,
4708 {
4709 match value {
4710 "timeColumnIndex" | "time_column_index" => Ok(GeneratedField::TimeColumnIndex),
4711 "interval" => Ok(GeneratedField::Interval),
4712 "fillColumns" | "fill_columns" => Ok(GeneratedField::FillColumns),
4713 "fillStrategies" | "fill_strategies" => Ok(GeneratedField::FillStrategies),
4714 "prevRowTable" | "prev_row_table" => Ok(GeneratedField::PrevRowTable),
4715 "partitionByIndices" | "partition_by_indices" => Ok(GeneratedField::PartitionByIndices),
4716 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4717 }
4718 }
4719 }
4720 deserializer.deserialize_identifier(GeneratedVisitor)
4721 }
4722 }
4723 struct GeneratedVisitor;
4724 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4725 type Value = EowcGapFillNode;
4726
4727 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4728 formatter.write_str("struct stream_plan.EowcGapFillNode")
4729 }
4730
4731 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcGapFillNode, V::Error>
4732 where
4733 V: serde::de::MapAccess<'de>,
4734 {
4735 let mut time_column_index__ = None;
4736 let mut interval__ = None;
4737 let mut fill_columns__ = None;
4738 let mut fill_strategies__ = None;
4739 let mut prev_row_table__ = None;
4740 let mut partition_by_indices__ = None;
4741 while let Some(k) = map_.next_key()? {
4742 match k {
4743 GeneratedField::TimeColumnIndex => {
4744 if time_column_index__.is_some() {
4745 return Err(serde::de::Error::duplicate_field("timeColumnIndex"));
4746 }
4747 time_column_index__ =
4748 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4749 ;
4750 }
4751 GeneratedField::Interval => {
4752 if interval__.is_some() {
4753 return Err(serde::de::Error::duplicate_field("interval"));
4754 }
4755 interval__ = map_.next_value()?;
4756 }
4757 GeneratedField::FillColumns => {
4758 if fill_columns__.is_some() {
4759 return Err(serde::de::Error::duplicate_field("fillColumns"));
4760 }
4761 fill_columns__ =
4762 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4763 .into_iter().map(|x| x.0).collect())
4764 ;
4765 }
4766 GeneratedField::FillStrategies => {
4767 if fill_strategies__.is_some() {
4768 return Err(serde::de::Error::duplicate_field("fillStrategies"));
4769 }
4770 fill_strategies__ = Some(map_.next_value()?);
4771 }
4772 GeneratedField::PrevRowTable => {
4773 if prev_row_table__.is_some() {
4774 return Err(serde::de::Error::duplicate_field("prevRowTable"));
4775 }
4776 prev_row_table__ = map_.next_value()?;
4777 }
4778 GeneratedField::PartitionByIndices => {
4779 if partition_by_indices__.is_some() {
4780 return Err(serde::de::Error::duplicate_field("partitionByIndices"));
4781 }
4782 partition_by_indices__ =
4783 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4784 .into_iter().map(|x| x.0).collect())
4785 ;
4786 }
4787 }
4788 }
4789 Ok(EowcGapFillNode {
4790 time_column_index: time_column_index__.unwrap_or_default(),
4791 interval: interval__,
4792 fill_columns: fill_columns__.unwrap_or_default(),
4793 fill_strategies: fill_strategies__.unwrap_or_default(),
4794 prev_row_table: prev_row_table__,
4795 partition_by_indices: partition_by_indices__.unwrap_or_default(),
4796 })
4797 }
4798 }
4799 deserializer.deserialize_struct("stream_plan.EowcGapFillNode", FIELDS, GeneratedVisitor)
4800 }
4801}
4802impl serde::Serialize for EowcOverWindowNode {
4803 #[allow(deprecated)]
4804 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4805 where
4806 S: serde::Serializer,
4807 {
4808 use serde::ser::SerializeStruct;
4809 let mut len = 0;
4810 if !self.calls.is_empty() {
4811 len += 1;
4812 }
4813 if !self.partition_by.is_empty() {
4814 len += 1;
4815 }
4816 if !self.order_by.is_empty() {
4817 len += 1;
4818 }
4819 if self.state_table.is_some() {
4820 len += 1;
4821 }
4822 if self.intermediate_state_table.is_some() {
4823 len += 1;
4824 }
4825 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcOverWindowNode", len)?;
4826 if !self.calls.is_empty() {
4827 struct_ser.serialize_field("calls", &self.calls)?;
4828 }
4829 if !self.partition_by.is_empty() {
4830 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
4831 }
4832 if !self.order_by.is_empty() {
4833 struct_ser.serialize_field("orderBy", &self.order_by)?;
4834 }
4835 if let Some(v) = self.state_table.as_ref() {
4836 struct_ser.serialize_field("stateTable", v)?;
4837 }
4838 if let Some(v) = self.intermediate_state_table.as_ref() {
4839 struct_ser.serialize_field("intermediateStateTable", v)?;
4840 }
4841 struct_ser.end()
4842 }
4843}
4844impl<'de> serde::Deserialize<'de> for EowcOverWindowNode {
4845 #[allow(deprecated)]
4846 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4847 where
4848 D: serde::Deserializer<'de>,
4849 {
4850 const FIELDS: &[&str] = &[
4851 "calls",
4852 "partition_by",
4853 "partitionBy",
4854 "order_by",
4855 "orderBy",
4856 "state_table",
4857 "stateTable",
4858 "intermediate_state_table",
4859 "intermediateStateTable",
4860 ];
4861
4862 #[allow(clippy::enum_variant_names)]
4863 enum GeneratedField {
4864 Calls,
4865 PartitionBy,
4866 OrderBy,
4867 StateTable,
4868 IntermediateStateTable,
4869 }
4870 impl<'de> serde::Deserialize<'de> for GeneratedField {
4871 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4872 where
4873 D: serde::Deserializer<'de>,
4874 {
4875 struct GeneratedVisitor;
4876
4877 impl serde::de::Visitor<'_> for GeneratedVisitor {
4878 type Value = GeneratedField;
4879
4880 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4881 write!(formatter, "expected one of: {:?}", &FIELDS)
4882 }
4883
4884 #[allow(unused_variables)]
4885 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4886 where
4887 E: serde::de::Error,
4888 {
4889 match value {
4890 "calls" => Ok(GeneratedField::Calls),
4891 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
4892 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
4893 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
4894 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
4895 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4896 }
4897 }
4898 }
4899 deserializer.deserialize_identifier(GeneratedVisitor)
4900 }
4901 }
4902 struct GeneratedVisitor;
4903 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4904 type Value = EowcOverWindowNode;
4905
4906 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4907 formatter.write_str("struct stream_plan.EowcOverWindowNode")
4908 }
4909
4910 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcOverWindowNode, V::Error>
4911 where
4912 V: serde::de::MapAccess<'de>,
4913 {
4914 let mut calls__ = None;
4915 let mut partition_by__ = None;
4916 let mut order_by__ = None;
4917 let mut state_table__ = None;
4918 let mut intermediate_state_table__ = None;
4919 while let Some(k) = map_.next_key()? {
4920 match k {
4921 GeneratedField::Calls => {
4922 if calls__.is_some() {
4923 return Err(serde::de::Error::duplicate_field("calls"));
4924 }
4925 calls__ = Some(map_.next_value()?);
4926 }
4927 GeneratedField::PartitionBy => {
4928 if partition_by__.is_some() {
4929 return Err(serde::de::Error::duplicate_field("partitionBy"));
4930 }
4931 partition_by__ =
4932 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4933 .into_iter().map(|x| x.0).collect())
4934 ;
4935 }
4936 GeneratedField::OrderBy => {
4937 if order_by__.is_some() {
4938 return Err(serde::de::Error::duplicate_field("orderBy"));
4939 }
4940 order_by__ = Some(map_.next_value()?);
4941 }
4942 GeneratedField::StateTable => {
4943 if state_table__.is_some() {
4944 return Err(serde::de::Error::duplicate_field("stateTable"));
4945 }
4946 state_table__ = map_.next_value()?;
4947 }
4948 GeneratedField::IntermediateStateTable => {
4949 if intermediate_state_table__.is_some() {
4950 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
4951 }
4952 intermediate_state_table__ = map_.next_value()?;
4953 }
4954 }
4955 }
4956 Ok(EowcOverWindowNode {
4957 calls: calls__.unwrap_or_default(),
4958 partition_by: partition_by__.unwrap_or_default(),
4959 order_by: order_by__.unwrap_or_default(),
4960 state_table: state_table__,
4961 intermediate_state_table: intermediate_state_table__,
4962 })
4963 }
4964 }
4965 deserializer.deserialize_struct("stream_plan.EowcOverWindowNode", FIELDS, GeneratedVisitor)
4966 }
4967}
4968impl serde::Serialize for ExchangeNode {
4969 #[allow(deprecated)]
4970 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4971 where
4972 S: serde::Serializer,
4973 {
4974 use serde::ser::SerializeStruct;
4975 let mut len = 0;
4976 if self.strategy.is_some() {
4977 len += 1;
4978 }
4979 let mut struct_ser = serializer.serialize_struct("stream_plan.ExchangeNode", len)?;
4980 if let Some(v) = self.strategy.as_ref() {
4981 struct_ser.serialize_field("strategy", v)?;
4982 }
4983 struct_ser.end()
4984 }
4985}
4986impl<'de> serde::Deserialize<'de> for ExchangeNode {
4987 #[allow(deprecated)]
4988 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4989 where
4990 D: serde::Deserializer<'de>,
4991 {
4992 const FIELDS: &[&str] = &[
4993 "strategy",
4994 ];
4995
4996 #[allow(clippy::enum_variant_names)]
4997 enum GeneratedField {
4998 Strategy,
4999 }
5000 impl<'de> serde::Deserialize<'de> for GeneratedField {
5001 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5002 where
5003 D: serde::Deserializer<'de>,
5004 {
5005 struct GeneratedVisitor;
5006
5007 impl serde::de::Visitor<'_> for GeneratedVisitor {
5008 type Value = GeneratedField;
5009
5010 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5011 write!(formatter, "expected one of: {:?}", &FIELDS)
5012 }
5013
5014 #[allow(unused_variables)]
5015 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5016 where
5017 E: serde::de::Error,
5018 {
5019 match value {
5020 "strategy" => Ok(GeneratedField::Strategy),
5021 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5022 }
5023 }
5024 }
5025 deserializer.deserialize_identifier(GeneratedVisitor)
5026 }
5027 }
5028 struct GeneratedVisitor;
5029 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5030 type Value = ExchangeNode;
5031
5032 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5033 formatter.write_str("struct stream_plan.ExchangeNode")
5034 }
5035
5036 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExchangeNode, V::Error>
5037 where
5038 V: serde::de::MapAccess<'de>,
5039 {
5040 let mut strategy__ = None;
5041 while let Some(k) = map_.next_key()? {
5042 match k {
5043 GeneratedField::Strategy => {
5044 if strategy__.is_some() {
5045 return Err(serde::de::Error::duplicate_field("strategy"));
5046 }
5047 strategy__ = map_.next_value()?;
5048 }
5049 }
5050 }
5051 Ok(ExchangeNode {
5052 strategy: strategy__,
5053 })
5054 }
5055 }
5056 deserializer.deserialize_struct("stream_plan.ExchangeNode", FIELDS, GeneratedVisitor)
5057 }
5058}
5059impl serde::Serialize for ExpandNode {
5060 #[allow(deprecated)]
5061 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5062 where
5063 S: serde::Serializer,
5064 {
5065 use serde::ser::SerializeStruct;
5066 let mut len = 0;
5067 if !self.column_subsets.is_empty() {
5068 len += 1;
5069 }
5070 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode", len)?;
5071 if !self.column_subsets.is_empty() {
5072 struct_ser.serialize_field("columnSubsets", &self.column_subsets)?;
5073 }
5074 struct_ser.end()
5075 }
5076}
5077impl<'de> serde::Deserialize<'de> for ExpandNode {
5078 #[allow(deprecated)]
5079 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5080 where
5081 D: serde::Deserializer<'de>,
5082 {
5083 const FIELDS: &[&str] = &[
5084 "column_subsets",
5085 "columnSubsets",
5086 ];
5087
5088 #[allow(clippy::enum_variant_names)]
5089 enum GeneratedField {
5090 ColumnSubsets,
5091 }
5092 impl<'de> serde::Deserialize<'de> for GeneratedField {
5093 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5094 where
5095 D: serde::Deserializer<'de>,
5096 {
5097 struct GeneratedVisitor;
5098
5099 impl serde::de::Visitor<'_> for GeneratedVisitor {
5100 type Value = GeneratedField;
5101
5102 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5103 write!(formatter, "expected one of: {:?}", &FIELDS)
5104 }
5105
5106 #[allow(unused_variables)]
5107 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5108 where
5109 E: serde::de::Error,
5110 {
5111 match value {
5112 "columnSubsets" | "column_subsets" => Ok(GeneratedField::ColumnSubsets),
5113 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5114 }
5115 }
5116 }
5117 deserializer.deserialize_identifier(GeneratedVisitor)
5118 }
5119 }
5120 struct GeneratedVisitor;
5121 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5122 type Value = ExpandNode;
5123
5124 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5125 formatter.write_str("struct stream_plan.ExpandNode")
5126 }
5127
5128 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpandNode, V::Error>
5129 where
5130 V: serde::de::MapAccess<'de>,
5131 {
5132 let mut column_subsets__ = None;
5133 while let Some(k) = map_.next_key()? {
5134 match k {
5135 GeneratedField::ColumnSubsets => {
5136 if column_subsets__.is_some() {
5137 return Err(serde::de::Error::duplicate_field("columnSubsets"));
5138 }
5139 column_subsets__ = Some(map_.next_value()?);
5140 }
5141 }
5142 }
5143 Ok(ExpandNode {
5144 column_subsets: column_subsets__.unwrap_or_default(),
5145 })
5146 }
5147 }
5148 deserializer.deserialize_struct("stream_plan.ExpandNode", FIELDS, GeneratedVisitor)
5149 }
5150}
5151impl serde::Serialize for expand_node::Subset {
5152 #[allow(deprecated)]
5153 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5154 where
5155 S: serde::Serializer,
5156 {
5157 use serde::ser::SerializeStruct;
5158 let mut len = 0;
5159 if !self.column_indices.is_empty() {
5160 len += 1;
5161 }
5162 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode.Subset", len)?;
5163 if !self.column_indices.is_empty() {
5164 struct_ser.serialize_field("columnIndices", &self.column_indices)?;
5165 }
5166 struct_ser.end()
5167 }
5168}
5169impl<'de> serde::Deserialize<'de> for expand_node::Subset {
5170 #[allow(deprecated)]
5171 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5172 where
5173 D: serde::Deserializer<'de>,
5174 {
5175 const FIELDS: &[&str] = &[
5176 "column_indices",
5177 "columnIndices",
5178 ];
5179
5180 #[allow(clippy::enum_variant_names)]
5181 enum GeneratedField {
5182 ColumnIndices,
5183 }
5184 impl<'de> serde::Deserialize<'de> for GeneratedField {
5185 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5186 where
5187 D: serde::Deserializer<'de>,
5188 {
5189 struct GeneratedVisitor;
5190
5191 impl serde::de::Visitor<'_> for GeneratedVisitor {
5192 type Value = GeneratedField;
5193
5194 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5195 write!(formatter, "expected one of: {:?}", &FIELDS)
5196 }
5197
5198 #[allow(unused_variables)]
5199 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5200 where
5201 E: serde::de::Error,
5202 {
5203 match value {
5204 "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
5205 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5206 }
5207 }
5208 }
5209 deserializer.deserialize_identifier(GeneratedVisitor)
5210 }
5211 }
5212 struct GeneratedVisitor;
5213 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5214 type Value = expand_node::Subset;
5215
5216 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5217 formatter.write_str("struct stream_plan.ExpandNode.Subset")
5218 }
5219
5220 fn visit_map<V>(self, mut map_: V) -> std::result::Result<expand_node::Subset, V::Error>
5221 where
5222 V: serde::de::MapAccess<'de>,
5223 {
5224 let mut column_indices__ = None;
5225 while let Some(k) = map_.next_key()? {
5226 match k {
5227 GeneratedField::ColumnIndices => {
5228 if column_indices__.is_some() {
5229 return Err(serde::de::Error::duplicate_field("columnIndices"));
5230 }
5231 column_indices__ =
5232 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5233 .into_iter().map(|x| x.0).collect())
5234 ;
5235 }
5236 }
5237 }
5238 Ok(expand_node::Subset {
5239 column_indices: column_indices__.unwrap_or_default(),
5240 })
5241 }
5242 }
5243 deserializer.deserialize_struct("stream_plan.ExpandNode.Subset", FIELDS, GeneratedVisitor)
5244 }
5245}
5246impl serde::Serialize for FilterNode {
5247 #[allow(deprecated)]
5248 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5249 where
5250 S: serde::Serializer,
5251 {
5252 use serde::ser::SerializeStruct;
5253 let mut len = 0;
5254 if self.search_condition.is_some() {
5255 len += 1;
5256 }
5257 let mut struct_ser = serializer.serialize_struct("stream_plan.FilterNode", len)?;
5258 if let Some(v) = self.search_condition.as_ref() {
5259 struct_ser.serialize_field("searchCondition", v)?;
5260 }
5261 struct_ser.end()
5262 }
5263}
5264impl<'de> serde::Deserialize<'de> for FilterNode {
5265 #[allow(deprecated)]
5266 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5267 where
5268 D: serde::Deserializer<'de>,
5269 {
5270 const FIELDS: &[&str] = &[
5271 "search_condition",
5272 "searchCondition",
5273 ];
5274
5275 #[allow(clippy::enum_variant_names)]
5276 enum GeneratedField {
5277 SearchCondition,
5278 }
5279 impl<'de> serde::Deserialize<'de> for GeneratedField {
5280 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5281 where
5282 D: serde::Deserializer<'de>,
5283 {
5284 struct GeneratedVisitor;
5285
5286 impl serde::de::Visitor<'_> for GeneratedVisitor {
5287 type Value = GeneratedField;
5288
5289 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5290 write!(formatter, "expected one of: {:?}", &FIELDS)
5291 }
5292
5293 #[allow(unused_variables)]
5294 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5295 where
5296 E: serde::de::Error,
5297 {
5298 match value {
5299 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
5300 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5301 }
5302 }
5303 }
5304 deserializer.deserialize_identifier(GeneratedVisitor)
5305 }
5306 }
5307 struct GeneratedVisitor;
5308 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5309 type Value = FilterNode;
5310
5311 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5312 formatter.write_str("struct stream_plan.FilterNode")
5313 }
5314
5315 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FilterNode, V::Error>
5316 where
5317 V: serde::de::MapAccess<'de>,
5318 {
5319 let mut search_condition__ = None;
5320 while let Some(k) = map_.next_key()? {
5321 match k {
5322 GeneratedField::SearchCondition => {
5323 if search_condition__.is_some() {
5324 return Err(serde::de::Error::duplicate_field("searchCondition"));
5325 }
5326 search_condition__ = map_.next_value()?;
5327 }
5328 }
5329 }
5330 Ok(FilterNode {
5331 search_condition: search_condition__,
5332 })
5333 }
5334 }
5335 deserializer.deserialize_struct("stream_plan.FilterNode", FIELDS, GeneratedVisitor)
5336 }
5337}
5338impl serde::Serialize for GapFillNode {
5339 #[allow(deprecated)]
5340 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5341 where
5342 S: serde::Serializer,
5343 {
5344 use serde::ser::SerializeStruct;
5345 let mut len = 0;
5346 if self.time_column_index != 0 {
5347 len += 1;
5348 }
5349 if self.interval.is_some() {
5350 len += 1;
5351 }
5352 if !self.fill_columns.is_empty() {
5353 len += 1;
5354 }
5355 if !self.fill_strategies.is_empty() {
5356 len += 1;
5357 }
5358 if self.state_table.is_some() {
5359 len += 1;
5360 }
5361 if !self.partition_by_indices.is_empty() {
5362 len += 1;
5363 }
5364 if !self.pointer_key_indices.is_empty() {
5365 len += 1;
5366 }
5367 let mut struct_ser = serializer.serialize_struct("stream_plan.GapFillNode", len)?;
5368 if self.time_column_index != 0 {
5369 struct_ser.serialize_field("timeColumnIndex", &self.time_column_index)?;
5370 }
5371 if let Some(v) = self.interval.as_ref() {
5372 struct_ser.serialize_field("interval", v)?;
5373 }
5374 if !self.fill_columns.is_empty() {
5375 struct_ser.serialize_field("fillColumns", &self.fill_columns)?;
5376 }
5377 if !self.fill_strategies.is_empty() {
5378 struct_ser.serialize_field("fillStrategies", &self.fill_strategies)?;
5379 }
5380 if let Some(v) = self.state_table.as_ref() {
5381 struct_ser.serialize_field("stateTable", v)?;
5382 }
5383 if !self.partition_by_indices.is_empty() {
5384 struct_ser.serialize_field("partitionByIndices", &self.partition_by_indices)?;
5385 }
5386 if !self.pointer_key_indices.is_empty() {
5387 struct_ser.serialize_field("pointerKeyIndices", &self.pointer_key_indices)?;
5388 }
5389 struct_ser.end()
5390 }
5391}
5392impl<'de> serde::Deserialize<'de> for GapFillNode {
5393 #[allow(deprecated)]
5394 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5395 where
5396 D: serde::Deserializer<'de>,
5397 {
5398 const FIELDS: &[&str] = &[
5399 "time_column_index",
5400 "timeColumnIndex",
5401 "interval",
5402 "fill_columns",
5403 "fillColumns",
5404 "fill_strategies",
5405 "fillStrategies",
5406 "state_table",
5407 "stateTable",
5408 "partition_by_indices",
5409 "partitionByIndices",
5410 "pointer_key_indices",
5411 "pointerKeyIndices",
5412 ];
5413
5414 #[allow(clippy::enum_variant_names)]
5415 enum GeneratedField {
5416 TimeColumnIndex,
5417 Interval,
5418 FillColumns,
5419 FillStrategies,
5420 StateTable,
5421 PartitionByIndices,
5422 PointerKeyIndices,
5423 }
5424 impl<'de> serde::Deserialize<'de> for GeneratedField {
5425 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5426 where
5427 D: serde::Deserializer<'de>,
5428 {
5429 struct GeneratedVisitor;
5430
5431 impl serde::de::Visitor<'_> for GeneratedVisitor {
5432 type Value = GeneratedField;
5433
5434 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5435 write!(formatter, "expected one of: {:?}", &FIELDS)
5436 }
5437
5438 #[allow(unused_variables)]
5439 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5440 where
5441 E: serde::de::Error,
5442 {
5443 match value {
5444 "timeColumnIndex" | "time_column_index" => Ok(GeneratedField::TimeColumnIndex),
5445 "interval" => Ok(GeneratedField::Interval),
5446 "fillColumns" | "fill_columns" => Ok(GeneratedField::FillColumns),
5447 "fillStrategies" | "fill_strategies" => Ok(GeneratedField::FillStrategies),
5448 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
5449 "partitionByIndices" | "partition_by_indices" => Ok(GeneratedField::PartitionByIndices),
5450 "pointerKeyIndices" | "pointer_key_indices" => Ok(GeneratedField::PointerKeyIndices),
5451 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5452 }
5453 }
5454 }
5455 deserializer.deserialize_identifier(GeneratedVisitor)
5456 }
5457 }
5458 struct GeneratedVisitor;
5459 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5460 type Value = GapFillNode;
5461
5462 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5463 formatter.write_str("struct stream_plan.GapFillNode")
5464 }
5465
5466 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GapFillNode, V::Error>
5467 where
5468 V: serde::de::MapAccess<'de>,
5469 {
5470 let mut time_column_index__ = None;
5471 let mut interval__ = None;
5472 let mut fill_columns__ = None;
5473 let mut fill_strategies__ = None;
5474 let mut state_table__ = None;
5475 let mut partition_by_indices__ = None;
5476 let mut pointer_key_indices__ = None;
5477 while let Some(k) = map_.next_key()? {
5478 match k {
5479 GeneratedField::TimeColumnIndex => {
5480 if time_column_index__.is_some() {
5481 return Err(serde::de::Error::duplicate_field("timeColumnIndex"));
5482 }
5483 time_column_index__ =
5484 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5485 ;
5486 }
5487 GeneratedField::Interval => {
5488 if interval__.is_some() {
5489 return Err(serde::de::Error::duplicate_field("interval"));
5490 }
5491 interval__ = map_.next_value()?;
5492 }
5493 GeneratedField::FillColumns => {
5494 if fill_columns__.is_some() {
5495 return Err(serde::de::Error::duplicate_field("fillColumns"));
5496 }
5497 fill_columns__ =
5498 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5499 .into_iter().map(|x| x.0).collect())
5500 ;
5501 }
5502 GeneratedField::FillStrategies => {
5503 if fill_strategies__.is_some() {
5504 return Err(serde::de::Error::duplicate_field("fillStrategies"));
5505 }
5506 fill_strategies__ = Some(map_.next_value()?);
5507 }
5508 GeneratedField::StateTable => {
5509 if state_table__.is_some() {
5510 return Err(serde::de::Error::duplicate_field("stateTable"));
5511 }
5512 state_table__ = map_.next_value()?;
5513 }
5514 GeneratedField::PartitionByIndices => {
5515 if partition_by_indices__.is_some() {
5516 return Err(serde::de::Error::duplicate_field("partitionByIndices"));
5517 }
5518 partition_by_indices__ =
5519 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5520 .into_iter().map(|x| x.0).collect())
5521 ;
5522 }
5523 GeneratedField::PointerKeyIndices => {
5524 if pointer_key_indices__.is_some() {
5525 return Err(serde::de::Error::duplicate_field("pointerKeyIndices"));
5526 }
5527 pointer_key_indices__ =
5528 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5529 .into_iter().map(|x| x.0).collect())
5530 ;
5531 }
5532 }
5533 }
5534 Ok(GapFillNode {
5535 time_column_index: time_column_index__.unwrap_or_default(),
5536 interval: interval__,
5537 fill_columns: fill_columns__.unwrap_or_default(),
5538 fill_strategies: fill_strategies__.unwrap_or_default(),
5539 state_table: state_table__,
5540 partition_by_indices: partition_by_indices__.unwrap_or_default(),
5541 pointer_key_indices: pointer_key_indices__.unwrap_or_default(),
5542 })
5543 }
5544 }
5545 deserializer.deserialize_struct("stream_plan.GapFillNode", FIELDS, GeneratedVisitor)
5546 }
5547}
5548impl serde::Serialize for GlobalApproxPercentileNode {
5549 #[allow(deprecated)]
5550 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5551 where
5552 S: serde::Serializer,
5553 {
5554 use serde::ser::SerializeStruct;
5555 let mut len = 0;
5556 if self.base != 0. {
5557 len += 1;
5558 }
5559 if self.quantile != 0. {
5560 len += 1;
5561 }
5562 if self.bucket_state_table.is_some() {
5563 len += 1;
5564 }
5565 if self.count_state_table.is_some() {
5566 len += 1;
5567 }
5568 let mut struct_ser = serializer.serialize_struct("stream_plan.GlobalApproxPercentileNode", len)?;
5569 if self.base != 0. {
5570 struct_ser.serialize_field("base", &self.base)?;
5571 }
5572 if self.quantile != 0. {
5573 struct_ser.serialize_field("quantile", &self.quantile)?;
5574 }
5575 if let Some(v) = self.bucket_state_table.as_ref() {
5576 struct_ser.serialize_field("bucketStateTable", v)?;
5577 }
5578 if let Some(v) = self.count_state_table.as_ref() {
5579 struct_ser.serialize_field("countStateTable", v)?;
5580 }
5581 struct_ser.end()
5582 }
5583}
5584impl<'de> serde::Deserialize<'de> for GlobalApproxPercentileNode {
5585 #[allow(deprecated)]
5586 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5587 where
5588 D: serde::Deserializer<'de>,
5589 {
5590 const FIELDS: &[&str] = &[
5591 "base",
5592 "quantile",
5593 "bucket_state_table",
5594 "bucketStateTable",
5595 "count_state_table",
5596 "countStateTable",
5597 ];
5598
5599 #[allow(clippy::enum_variant_names)]
5600 enum GeneratedField {
5601 Base,
5602 Quantile,
5603 BucketStateTable,
5604 CountStateTable,
5605 }
5606 impl<'de> serde::Deserialize<'de> for GeneratedField {
5607 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5608 where
5609 D: serde::Deserializer<'de>,
5610 {
5611 struct GeneratedVisitor;
5612
5613 impl serde::de::Visitor<'_> for GeneratedVisitor {
5614 type Value = GeneratedField;
5615
5616 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5617 write!(formatter, "expected one of: {:?}", &FIELDS)
5618 }
5619
5620 #[allow(unused_variables)]
5621 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5622 where
5623 E: serde::de::Error,
5624 {
5625 match value {
5626 "base" => Ok(GeneratedField::Base),
5627 "quantile" => Ok(GeneratedField::Quantile),
5628 "bucketStateTable" | "bucket_state_table" => Ok(GeneratedField::BucketStateTable),
5629 "countStateTable" | "count_state_table" => Ok(GeneratedField::CountStateTable),
5630 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5631 }
5632 }
5633 }
5634 deserializer.deserialize_identifier(GeneratedVisitor)
5635 }
5636 }
5637 struct GeneratedVisitor;
5638 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5639 type Value = GlobalApproxPercentileNode;
5640
5641 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5642 formatter.write_str("struct stream_plan.GlobalApproxPercentileNode")
5643 }
5644
5645 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GlobalApproxPercentileNode, V::Error>
5646 where
5647 V: serde::de::MapAccess<'de>,
5648 {
5649 let mut base__ = None;
5650 let mut quantile__ = None;
5651 let mut bucket_state_table__ = None;
5652 let mut count_state_table__ = None;
5653 while let Some(k) = map_.next_key()? {
5654 match k {
5655 GeneratedField::Base => {
5656 if base__.is_some() {
5657 return Err(serde::de::Error::duplicate_field("base"));
5658 }
5659 base__ =
5660 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5661 ;
5662 }
5663 GeneratedField::Quantile => {
5664 if quantile__.is_some() {
5665 return Err(serde::de::Error::duplicate_field("quantile"));
5666 }
5667 quantile__ =
5668 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5669 ;
5670 }
5671 GeneratedField::BucketStateTable => {
5672 if bucket_state_table__.is_some() {
5673 return Err(serde::de::Error::duplicate_field("bucketStateTable"));
5674 }
5675 bucket_state_table__ = map_.next_value()?;
5676 }
5677 GeneratedField::CountStateTable => {
5678 if count_state_table__.is_some() {
5679 return Err(serde::de::Error::duplicate_field("countStateTable"));
5680 }
5681 count_state_table__ = map_.next_value()?;
5682 }
5683 }
5684 }
5685 Ok(GlobalApproxPercentileNode {
5686 base: base__.unwrap_or_default(),
5687 quantile: quantile__.unwrap_or_default(),
5688 bucket_state_table: bucket_state_table__,
5689 count_state_table: count_state_table__,
5690 })
5691 }
5692 }
5693 deserializer.deserialize_struct("stream_plan.GlobalApproxPercentileNode", FIELDS, GeneratedVisitor)
5694 }
5695}
5696impl serde::Serialize for GroupTopNNode {
5697 #[allow(deprecated)]
5698 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5699 where
5700 S: serde::Serializer,
5701 {
5702 use serde::ser::SerializeStruct;
5703 let mut len = 0;
5704 if self.limit != 0 {
5705 len += 1;
5706 }
5707 if self.offset != 0 {
5708 len += 1;
5709 }
5710 if !self.group_key.is_empty() {
5711 len += 1;
5712 }
5713 if self.table.is_some() {
5714 len += 1;
5715 }
5716 if !self.order_by.is_empty() {
5717 len += 1;
5718 }
5719 if self.with_ties {
5720 len += 1;
5721 }
5722 let mut struct_ser = serializer.serialize_struct("stream_plan.GroupTopNNode", len)?;
5723 if self.limit != 0 {
5724 #[allow(clippy::needless_borrow)]
5725 #[allow(clippy::needless_borrows_for_generic_args)]
5726 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
5727 }
5728 if self.offset != 0 {
5729 #[allow(clippy::needless_borrow)]
5730 #[allow(clippy::needless_borrows_for_generic_args)]
5731 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
5732 }
5733 if !self.group_key.is_empty() {
5734 struct_ser.serialize_field("groupKey", &self.group_key)?;
5735 }
5736 if let Some(v) = self.table.as_ref() {
5737 struct_ser.serialize_field("table", v)?;
5738 }
5739 if !self.order_by.is_empty() {
5740 struct_ser.serialize_field("orderBy", &self.order_by)?;
5741 }
5742 if self.with_ties {
5743 struct_ser.serialize_field("withTies", &self.with_ties)?;
5744 }
5745 struct_ser.end()
5746 }
5747}
5748impl<'de> serde::Deserialize<'de> for GroupTopNNode {
5749 #[allow(deprecated)]
5750 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5751 where
5752 D: serde::Deserializer<'de>,
5753 {
5754 const FIELDS: &[&str] = &[
5755 "limit",
5756 "offset",
5757 "group_key",
5758 "groupKey",
5759 "table",
5760 "order_by",
5761 "orderBy",
5762 "with_ties",
5763 "withTies",
5764 ];
5765
5766 #[allow(clippy::enum_variant_names)]
5767 enum GeneratedField {
5768 Limit,
5769 Offset,
5770 GroupKey,
5771 Table,
5772 OrderBy,
5773 WithTies,
5774 }
5775 impl<'de> serde::Deserialize<'de> for GeneratedField {
5776 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5777 where
5778 D: serde::Deserializer<'de>,
5779 {
5780 struct GeneratedVisitor;
5781
5782 impl serde::de::Visitor<'_> for GeneratedVisitor {
5783 type Value = GeneratedField;
5784
5785 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5786 write!(formatter, "expected one of: {:?}", &FIELDS)
5787 }
5788
5789 #[allow(unused_variables)]
5790 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5791 where
5792 E: serde::de::Error,
5793 {
5794 match value {
5795 "limit" => Ok(GeneratedField::Limit),
5796 "offset" => Ok(GeneratedField::Offset),
5797 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5798 "table" => Ok(GeneratedField::Table),
5799 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
5800 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
5801 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5802 }
5803 }
5804 }
5805 deserializer.deserialize_identifier(GeneratedVisitor)
5806 }
5807 }
5808 struct GeneratedVisitor;
5809 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5810 type Value = GroupTopNNode;
5811
5812 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5813 formatter.write_str("struct stream_plan.GroupTopNNode")
5814 }
5815
5816 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupTopNNode, V::Error>
5817 where
5818 V: serde::de::MapAccess<'de>,
5819 {
5820 let mut limit__ = None;
5821 let mut offset__ = None;
5822 let mut group_key__ = None;
5823 let mut table__ = None;
5824 let mut order_by__ = None;
5825 let mut with_ties__ = None;
5826 while let Some(k) = map_.next_key()? {
5827 match k {
5828 GeneratedField::Limit => {
5829 if limit__.is_some() {
5830 return Err(serde::de::Error::duplicate_field("limit"));
5831 }
5832 limit__ =
5833 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5834 ;
5835 }
5836 GeneratedField::Offset => {
5837 if offset__.is_some() {
5838 return Err(serde::de::Error::duplicate_field("offset"));
5839 }
5840 offset__ =
5841 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5842 ;
5843 }
5844 GeneratedField::GroupKey => {
5845 if group_key__.is_some() {
5846 return Err(serde::de::Error::duplicate_field("groupKey"));
5847 }
5848 group_key__ =
5849 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5850 .into_iter().map(|x| x.0).collect())
5851 ;
5852 }
5853 GeneratedField::Table => {
5854 if table__.is_some() {
5855 return Err(serde::de::Error::duplicate_field("table"));
5856 }
5857 table__ = map_.next_value()?;
5858 }
5859 GeneratedField::OrderBy => {
5860 if order_by__.is_some() {
5861 return Err(serde::de::Error::duplicate_field("orderBy"));
5862 }
5863 order_by__ = Some(map_.next_value()?);
5864 }
5865 GeneratedField::WithTies => {
5866 if with_ties__.is_some() {
5867 return Err(serde::de::Error::duplicate_field("withTies"));
5868 }
5869 with_ties__ = Some(map_.next_value()?);
5870 }
5871 }
5872 }
5873 Ok(GroupTopNNode {
5874 limit: limit__.unwrap_or_default(),
5875 offset: offset__.unwrap_or_default(),
5876 group_key: group_key__.unwrap_or_default(),
5877 table: table__,
5878 order_by: order_by__.unwrap_or_default(),
5879 with_ties: with_ties__.unwrap_or_default(),
5880 })
5881 }
5882 }
5883 deserializer.deserialize_struct("stream_plan.GroupTopNNode", FIELDS, GeneratedVisitor)
5884 }
5885}
5886impl serde::Serialize for HashAggNode {
5887 #[allow(deprecated)]
5888 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5889 where
5890 S: serde::Serializer,
5891 {
5892 use serde::ser::SerializeStruct;
5893 let mut len = 0;
5894 if !self.group_key.is_empty() {
5895 len += 1;
5896 }
5897 if !self.agg_calls.is_empty() {
5898 len += 1;
5899 }
5900 if !self.agg_call_states.is_empty() {
5901 len += 1;
5902 }
5903 if self.intermediate_state_table.is_some() {
5904 len += 1;
5905 }
5906 if self.is_append_only {
5907 len += 1;
5908 }
5909 if !self.distinct_dedup_tables.is_empty() {
5910 len += 1;
5911 }
5912 if self.row_count_index != 0 {
5913 len += 1;
5914 }
5915 if self.emit_on_window_close {
5916 len += 1;
5917 }
5918 if self.version != 0 {
5919 len += 1;
5920 }
5921 let mut struct_ser = serializer.serialize_struct("stream_plan.HashAggNode", len)?;
5922 if !self.group_key.is_empty() {
5923 struct_ser.serialize_field("groupKey", &self.group_key)?;
5924 }
5925 if !self.agg_calls.is_empty() {
5926 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
5927 }
5928 if !self.agg_call_states.is_empty() {
5929 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
5930 }
5931 if let Some(v) = self.intermediate_state_table.as_ref() {
5932 struct_ser.serialize_field("intermediateStateTable", v)?;
5933 }
5934 if self.is_append_only {
5935 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5936 }
5937 if !self.distinct_dedup_tables.is_empty() {
5938 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
5939 }
5940 if self.row_count_index != 0 {
5941 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
5942 }
5943 if self.emit_on_window_close {
5944 struct_ser.serialize_field("emitOnWindowClose", &self.emit_on_window_close)?;
5945 }
5946 if self.version != 0 {
5947 let v = AggNodeVersion::try_from(self.version)
5948 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
5949 struct_ser.serialize_field("version", &v)?;
5950 }
5951 struct_ser.end()
5952 }
5953}
5954impl<'de> serde::Deserialize<'de> for HashAggNode {
5955 #[allow(deprecated)]
5956 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5957 where
5958 D: serde::Deserializer<'de>,
5959 {
5960 const FIELDS: &[&str] = &[
5961 "group_key",
5962 "groupKey",
5963 "agg_calls",
5964 "aggCalls",
5965 "agg_call_states",
5966 "aggCallStates",
5967 "intermediate_state_table",
5968 "intermediateStateTable",
5969 "is_append_only",
5970 "isAppendOnly",
5971 "distinct_dedup_tables",
5972 "distinctDedupTables",
5973 "row_count_index",
5974 "rowCountIndex",
5975 "emit_on_window_close",
5976 "emitOnWindowClose",
5977 "version",
5978 ];
5979
5980 #[allow(clippy::enum_variant_names)]
5981 enum GeneratedField {
5982 GroupKey,
5983 AggCalls,
5984 AggCallStates,
5985 IntermediateStateTable,
5986 IsAppendOnly,
5987 DistinctDedupTables,
5988 RowCountIndex,
5989 EmitOnWindowClose,
5990 Version,
5991 }
5992 impl<'de> serde::Deserialize<'de> for GeneratedField {
5993 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5994 where
5995 D: serde::Deserializer<'de>,
5996 {
5997 struct GeneratedVisitor;
5998
5999 impl serde::de::Visitor<'_> for GeneratedVisitor {
6000 type Value = GeneratedField;
6001
6002 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6003 write!(formatter, "expected one of: {:?}", &FIELDS)
6004 }
6005
6006 #[allow(unused_variables)]
6007 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6008 where
6009 E: serde::de::Error,
6010 {
6011 match value {
6012 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
6013 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
6014 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
6015 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
6016 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
6017 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
6018 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
6019 "emitOnWindowClose" | "emit_on_window_close" => Ok(GeneratedField::EmitOnWindowClose),
6020 "version" => Ok(GeneratedField::Version),
6021 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6022 }
6023 }
6024 }
6025 deserializer.deserialize_identifier(GeneratedVisitor)
6026 }
6027 }
6028 struct GeneratedVisitor;
6029 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6030 type Value = HashAggNode;
6031
6032 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6033 formatter.write_str("struct stream_plan.HashAggNode")
6034 }
6035
6036 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashAggNode, V::Error>
6037 where
6038 V: serde::de::MapAccess<'de>,
6039 {
6040 let mut group_key__ = None;
6041 let mut agg_calls__ = None;
6042 let mut agg_call_states__ = None;
6043 let mut intermediate_state_table__ = None;
6044 let mut is_append_only__ = None;
6045 let mut distinct_dedup_tables__ = None;
6046 let mut row_count_index__ = None;
6047 let mut emit_on_window_close__ = None;
6048 let mut version__ = None;
6049 while let Some(k) = map_.next_key()? {
6050 match k {
6051 GeneratedField::GroupKey => {
6052 if group_key__.is_some() {
6053 return Err(serde::de::Error::duplicate_field("groupKey"));
6054 }
6055 group_key__ =
6056 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6057 .into_iter().map(|x| x.0).collect())
6058 ;
6059 }
6060 GeneratedField::AggCalls => {
6061 if agg_calls__.is_some() {
6062 return Err(serde::de::Error::duplicate_field("aggCalls"));
6063 }
6064 agg_calls__ = Some(map_.next_value()?);
6065 }
6066 GeneratedField::AggCallStates => {
6067 if agg_call_states__.is_some() {
6068 return Err(serde::de::Error::duplicate_field("aggCallStates"));
6069 }
6070 agg_call_states__ = Some(map_.next_value()?);
6071 }
6072 GeneratedField::IntermediateStateTable => {
6073 if intermediate_state_table__.is_some() {
6074 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
6075 }
6076 intermediate_state_table__ = map_.next_value()?;
6077 }
6078 GeneratedField::IsAppendOnly => {
6079 if is_append_only__.is_some() {
6080 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
6081 }
6082 is_append_only__ = Some(map_.next_value()?);
6083 }
6084 GeneratedField::DistinctDedupTables => {
6085 if distinct_dedup_tables__.is_some() {
6086 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
6087 }
6088 distinct_dedup_tables__ = Some(
6089 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6090 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
6091 );
6092 }
6093 GeneratedField::RowCountIndex => {
6094 if row_count_index__.is_some() {
6095 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
6096 }
6097 row_count_index__ =
6098 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6099 ;
6100 }
6101 GeneratedField::EmitOnWindowClose => {
6102 if emit_on_window_close__.is_some() {
6103 return Err(serde::de::Error::duplicate_field("emitOnWindowClose"));
6104 }
6105 emit_on_window_close__ = Some(map_.next_value()?);
6106 }
6107 GeneratedField::Version => {
6108 if version__.is_some() {
6109 return Err(serde::de::Error::duplicate_field("version"));
6110 }
6111 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
6112 }
6113 }
6114 }
6115 Ok(HashAggNode {
6116 group_key: group_key__.unwrap_or_default(),
6117 agg_calls: agg_calls__.unwrap_or_default(),
6118 agg_call_states: agg_call_states__.unwrap_or_default(),
6119 intermediate_state_table: intermediate_state_table__,
6120 is_append_only: is_append_only__.unwrap_or_default(),
6121 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
6122 row_count_index: row_count_index__.unwrap_or_default(),
6123 emit_on_window_close: emit_on_window_close__.unwrap_or_default(),
6124 version: version__.unwrap_or_default(),
6125 })
6126 }
6127 }
6128 deserializer.deserialize_struct("stream_plan.HashAggNode", FIELDS, GeneratedVisitor)
6129 }
6130}
6131impl serde::Serialize for HashJoinNode {
6132 #[allow(deprecated)]
6133 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6134 where
6135 S: serde::Serializer,
6136 {
6137 use serde::ser::SerializeStruct;
6138 let mut len = 0;
6139 if self.join_type != 0 {
6140 len += 1;
6141 }
6142 if !self.left_key.is_empty() {
6143 len += 1;
6144 }
6145 if !self.right_key.is_empty() {
6146 len += 1;
6147 }
6148 if self.condition.is_some() {
6149 len += 1;
6150 }
6151 if self.left_table.is_some() {
6152 len += 1;
6153 }
6154 if self.right_table.is_some() {
6155 len += 1;
6156 }
6157 if self.left_degree_table.is_some() {
6158 len += 1;
6159 }
6160 if self.right_degree_table.is_some() {
6161 len += 1;
6162 }
6163 if !self.output_indices.is_empty() {
6164 len += 1;
6165 }
6166 if !self.left_deduped_input_pk_indices.is_empty() {
6167 len += 1;
6168 }
6169 if !self.right_deduped_input_pk_indices.is_empty() {
6170 len += 1;
6171 }
6172 if !self.null_safe.is_empty() {
6173 len += 1;
6174 }
6175 if self.is_append_only {
6176 len += 1;
6177 }
6178 if self.join_encoding_type != 0 {
6179 len += 1;
6180 }
6181 if self.watermark_handle_desc.is_some() {
6182 len += 1;
6183 }
6184 let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinNode", len)?;
6185 if self.join_type != 0 {
6186 let v = super::plan_common::JoinType::try_from(self.join_type)
6187 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
6188 struct_ser.serialize_field("joinType", &v)?;
6189 }
6190 if !self.left_key.is_empty() {
6191 struct_ser.serialize_field("leftKey", &self.left_key)?;
6192 }
6193 if !self.right_key.is_empty() {
6194 struct_ser.serialize_field("rightKey", &self.right_key)?;
6195 }
6196 if let Some(v) = self.condition.as_ref() {
6197 struct_ser.serialize_field("condition", v)?;
6198 }
6199 if let Some(v) = self.left_table.as_ref() {
6200 struct_ser.serialize_field("leftTable", v)?;
6201 }
6202 if let Some(v) = self.right_table.as_ref() {
6203 struct_ser.serialize_field("rightTable", v)?;
6204 }
6205 if let Some(v) = self.left_degree_table.as_ref() {
6206 struct_ser.serialize_field("leftDegreeTable", v)?;
6207 }
6208 if let Some(v) = self.right_degree_table.as_ref() {
6209 struct_ser.serialize_field("rightDegreeTable", v)?;
6210 }
6211 if !self.output_indices.is_empty() {
6212 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
6213 }
6214 if !self.left_deduped_input_pk_indices.is_empty() {
6215 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
6216 }
6217 if !self.right_deduped_input_pk_indices.is_empty() {
6218 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
6219 }
6220 if !self.null_safe.is_empty() {
6221 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
6222 }
6223 if self.is_append_only {
6224 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
6225 }
6226 if self.join_encoding_type != 0 {
6227 let v = JoinEncodingType::try_from(self.join_encoding_type)
6228 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
6229 struct_ser.serialize_field("joinEncodingType", &v)?;
6230 }
6231 if let Some(v) = self.watermark_handle_desc.as_ref() {
6232 struct_ser.serialize_field("watermarkHandleDesc", v)?;
6233 }
6234 struct_ser.end()
6235 }
6236}
6237impl<'de> serde::Deserialize<'de> for HashJoinNode {
6238 #[allow(deprecated)]
6239 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6240 where
6241 D: serde::Deserializer<'de>,
6242 {
6243 const FIELDS: &[&str] = &[
6244 "join_type",
6245 "joinType",
6246 "left_key",
6247 "leftKey",
6248 "right_key",
6249 "rightKey",
6250 "condition",
6251 "left_table",
6252 "leftTable",
6253 "right_table",
6254 "rightTable",
6255 "left_degree_table",
6256 "leftDegreeTable",
6257 "right_degree_table",
6258 "rightDegreeTable",
6259 "output_indices",
6260 "outputIndices",
6261 "left_deduped_input_pk_indices",
6262 "leftDedupedInputPkIndices",
6263 "right_deduped_input_pk_indices",
6264 "rightDedupedInputPkIndices",
6265 "null_safe",
6266 "nullSafe",
6267 "is_append_only",
6268 "isAppendOnly",
6269 "join_encoding_type",
6270 "joinEncodingType",
6271 "watermark_handle_desc",
6272 "watermarkHandleDesc",
6273 ];
6274
6275 #[allow(clippy::enum_variant_names)]
6276 enum GeneratedField {
6277 JoinType,
6278 LeftKey,
6279 RightKey,
6280 Condition,
6281 LeftTable,
6282 RightTable,
6283 LeftDegreeTable,
6284 RightDegreeTable,
6285 OutputIndices,
6286 LeftDedupedInputPkIndices,
6287 RightDedupedInputPkIndices,
6288 NullSafe,
6289 IsAppendOnly,
6290 JoinEncodingType,
6291 WatermarkHandleDesc,
6292 }
6293 impl<'de> serde::Deserialize<'de> for GeneratedField {
6294 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6295 where
6296 D: serde::Deserializer<'de>,
6297 {
6298 struct GeneratedVisitor;
6299
6300 impl serde::de::Visitor<'_> for GeneratedVisitor {
6301 type Value = GeneratedField;
6302
6303 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6304 write!(formatter, "expected one of: {:?}", &FIELDS)
6305 }
6306
6307 #[allow(unused_variables)]
6308 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6309 where
6310 E: serde::de::Error,
6311 {
6312 match value {
6313 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
6314 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
6315 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
6316 "condition" => Ok(GeneratedField::Condition),
6317 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
6318 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
6319 "leftDegreeTable" | "left_degree_table" => Ok(GeneratedField::LeftDegreeTable),
6320 "rightDegreeTable" | "right_degree_table" => Ok(GeneratedField::RightDegreeTable),
6321 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
6322 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
6323 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
6324 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
6325 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
6326 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
6327 "watermarkHandleDesc" | "watermark_handle_desc" => Ok(GeneratedField::WatermarkHandleDesc),
6328 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6329 }
6330 }
6331 }
6332 deserializer.deserialize_identifier(GeneratedVisitor)
6333 }
6334 }
6335 struct GeneratedVisitor;
6336 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6337 type Value = HashJoinNode;
6338
6339 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6340 formatter.write_str("struct stream_plan.HashJoinNode")
6341 }
6342
6343 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinNode, V::Error>
6344 where
6345 V: serde::de::MapAccess<'de>,
6346 {
6347 let mut join_type__ = None;
6348 let mut left_key__ = None;
6349 let mut right_key__ = None;
6350 let mut condition__ = None;
6351 let mut left_table__ = None;
6352 let mut right_table__ = None;
6353 let mut left_degree_table__ = None;
6354 let mut right_degree_table__ = None;
6355 let mut output_indices__ = None;
6356 let mut left_deduped_input_pk_indices__ = None;
6357 let mut right_deduped_input_pk_indices__ = None;
6358 let mut null_safe__ = None;
6359 let mut is_append_only__ = None;
6360 let mut join_encoding_type__ = None;
6361 let mut watermark_handle_desc__ = None;
6362 while let Some(k) = map_.next_key()? {
6363 match k {
6364 GeneratedField::JoinType => {
6365 if join_type__.is_some() {
6366 return Err(serde::de::Error::duplicate_field("joinType"));
6367 }
6368 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
6369 }
6370 GeneratedField::LeftKey => {
6371 if left_key__.is_some() {
6372 return Err(serde::de::Error::duplicate_field("leftKey"));
6373 }
6374 left_key__ =
6375 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6376 .into_iter().map(|x| x.0).collect())
6377 ;
6378 }
6379 GeneratedField::RightKey => {
6380 if right_key__.is_some() {
6381 return Err(serde::de::Error::duplicate_field("rightKey"));
6382 }
6383 right_key__ =
6384 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6385 .into_iter().map(|x| x.0).collect())
6386 ;
6387 }
6388 GeneratedField::Condition => {
6389 if condition__.is_some() {
6390 return Err(serde::de::Error::duplicate_field("condition"));
6391 }
6392 condition__ = map_.next_value()?;
6393 }
6394 GeneratedField::LeftTable => {
6395 if left_table__.is_some() {
6396 return Err(serde::de::Error::duplicate_field("leftTable"));
6397 }
6398 left_table__ = map_.next_value()?;
6399 }
6400 GeneratedField::RightTable => {
6401 if right_table__.is_some() {
6402 return Err(serde::de::Error::duplicate_field("rightTable"));
6403 }
6404 right_table__ = map_.next_value()?;
6405 }
6406 GeneratedField::LeftDegreeTable => {
6407 if left_degree_table__.is_some() {
6408 return Err(serde::de::Error::duplicate_field("leftDegreeTable"));
6409 }
6410 left_degree_table__ = map_.next_value()?;
6411 }
6412 GeneratedField::RightDegreeTable => {
6413 if right_degree_table__.is_some() {
6414 return Err(serde::de::Error::duplicate_field("rightDegreeTable"));
6415 }
6416 right_degree_table__ = map_.next_value()?;
6417 }
6418 GeneratedField::OutputIndices => {
6419 if output_indices__.is_some() {
6420 return Err(serde::de::Error::duplicate_field("outputIndices"));
6421 }
6422 output_indices__ =
6423 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6424 .into_iter().map(|x| x.0).collect())
6425 ;
6426 }
6427 GeneratedField::LeftDedupedInputPkIndices => {
6428 if left_deduped_input_pk_indices__.is_some() {
6429 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
6430 }
6431 left_deduped_input_pk_indices__ =
6432 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6433 .into_iter().map(|x| x.0).collect())
6434 ;
6435 }
6436 GeneratedField::RightDedupedInputPkIndices => {
6437 if right_deduped_input_pk_indices__.is_some() {
6438 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
6439 }
6440 right_deduped_input_pk_indices__ =
6441 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6442 .into_iter().map(|x| x.0).collect())
6443 ;
6444 }
6445 GeneratedField::NullSafe => {
6446 if null_safe__.is_some() {
6447 return Err(serde::de::Error::duplicate_field("nullSafe"));
6448 }
6449 null_safe__ = Some(map_.next_value()?);
6450 }
6451 GeneratedField::IsAppendOnly => {
6452 if is_append_only__.is_some() {
6453 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
6454 }
6455 is_append_only__ = Some(map_.next_value()?);
6456 }
6457 GeneratedField::JoinEncodingType => {
6458 if join_encoding_type__.is_some() {
6459 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
6460 }
6461 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
6462 }
6463 GeneratedField::WatermarkHandleDesc => {
6464 if watermark_handle_desc__.is_some() {
6465 return Err(serde::de::Error::duplicate_field("watermarkHandleDesc"));
6466 }
6467 watermark_handle_desc__ = map_.next_value()?;
6468 }
6469 }
6470 }
6471 Ok(HashJoinNode {
6472 join_type: join_type__.unwrap_or_default(),
6473 left_key: left_key__.unwrap_or_default(),
6474 right_key: right_key__.unwrap_or_default(),
6475 condition: condition__,
6476 left_table: left_table__,
6477 right_table: right_table__,
6478 left_degree_table: left_degree_table__,
6479 right_degree_table: right_degree_table__,
6480 output_indices: output_indices__.unwrap_or_default(),
6481 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
6482 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
6483 null_safe: null_safe__.unwrap_or_default(),
6484 is_append_only: is_append_only__.unwrap_or_default(),
6485 join_encoding_type: join_encoding_type__.unwrap_or_default(),
6486 watermark_handle_desc: watermark_handle_desc__,
6487 })
6488 }
6489 }
6490 deserializer.deserialize_struct("stream_plan.HashJoinNode", FIELDS, GeneratedVisitor)
6491 }
6492}
6493impl serde::Serialize for HashJoinWatermarkHandleDesc {
6494 #[allow(deprecated)]
6495 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6496 where
6497 S: serde::Serializer,
6498 {
6499 use serde::ser::SerializeStruct;
6500 let mut len = 0;
6501 if !self.watermark_indices_in_jk.is_empty() {
6502 len += 1;
6503 }
6504 if !self.inequality_pairs.is_empty() {
6505 len += 1;
6506 }
6507 let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinWatermarkHandleDesc", len)?;
6508 if !self.watermark_indices_in_jk.is_empty() {
6509 struct_ser.serialize_field("watermarkIndicesInJk", &self.watermark_indices_in_jk)?;
6510 }
6511 if !self.inequality_pairs.is_empty() {
6512 struct_ser.serialize_field("inequalityPairs", &self.inequality_pairs)?;
6513 }
6514 struct_ser.end()
6515 }
6516}
6517impl<'de> serde::Deserialize<'de> for HashJoinWatermarkHandleDesc {
6518 #[allow(deprecated)]
6519 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6520 where
6521 D: serde::Deserializer<'de>,
6522 {
6523 const FIELDS: &[&str] = &[
6524 "watermark_indices_in_jk",
6525 "watermarkIndicesInJk",
6526 "inequality_pairs",
6527 "inequalityPairs",
6528 ];
6529
6530 #[allow(clippy::enum_variant_names)]
6531 enum GeneratedField {
6532 WatermarkIndicesInJk,
6533 InequalityPairs,
6534 }
6535 impl<'de> serde::Deserialize<'de> for GeneratedField {
6536 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6537 where
6538 D: serde::Deserializer<'de>,
6539 {
6540 struct GeneratedVisitor;
6541
6542 impl serde::de::Visitor<'_> for GeneratedVisitor {
6543 type Value = GeneratedField;
6544
6545 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6546 write!(formatter, "expected one of: {:?}", &FIELDS)
6547 }
6548
6549 #[allow(unused_variables)]
6550 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6551 where
6552 E: serde::de::Error,
6553 {
6554 match value {
6555 "watermarkIndicesInJk" | "watermark_indices_in_jk" => Ok(GeneratedField::WatermarkIndicesInJk),
6556 "inequalityPairs" | "inequality_pairs" => Ok(GeneratedField::InequalityPairs),
6557 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6558 }
6559 }
6560 }
6561 deserializer.deserialize_identifier(GeneratedVisitor)
6562 }
6563 }
6564 struct GeneratedVisitor;
6565 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6566 type Value = HashJoinWatermarkHandleDesc;
6567
6568 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6569 formatter.write_str("struct stream_plan.HashJoinWatermarkHandleDesc")
6570 }
6571
6572 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinWatermarkHandleDesc, V::Error>
6573 where
6574 V: serde::de::MapAccess<'de>,
6575 {
6576 let mut watermark_indices_in_jk__ = None;
6577 let mut inequality_pairs__ = None;
6578 while let Some(k) = map_.next_key()? {
6579 match k {
6580 GeneratedField::WatermarkIndicesInJk => {
6581 if watermark_indices_in_jk__.is_some() {
6582 return Err(serde::de::Error::duplicate_field("watermarkIndicesInJk"));
6583 }
6584 watermark_indices_in_jk__ = Some(map_.next_value()?);
6585 }
6586 GeneratedField::InequalityPairs => {
6587 if inequality_pairs__.is_some() {
6588 return Err(serde::de::Error::duplicate_field("inequalityPairs"));
6589 }
6590 inequality_pairs__ = Some(map_.next_value()?);
6591 }
6592 }
6593 }
6594 Ok(HashJoinWatermarkHandleDesc {
6595 watermark_indices_in_jk: watermark_indices_in_jk__.unwrap_or_default(),
6596 inequality_pairs: inequality_pairs__.unwrap_or_default(),
6597 })
6598 }
6599 }
6600 deserializer.deserialize_struct("stream_plan.HashJoinWatermarkHandleDesc", FIELDS, GeneratedVisitor)
6601 }
6602}
6603impl serde::Serialize for HopWindowNode {
6604 #[allow(deprecated)]
6605 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6606 where
6607 S: serde::Serializer,
6608 {
6609 use serde::ser::SerializeStruct;
6610 let mut len = 0;
6611 if self.time_col != 0 {
6612 len += 1;
6613 }
6614 if self.window_slide.is_some() {
6615 len += 1;
6616 }
6617 if self.window_size.is_some() {
6618 len += 1;
6619 }
6620 if !self.output_indices.is_empty() {
6621 len += 1;
6622 }
6623 if !self.window_start_exprs.is_empty() {
6624 len += 1;
6625 }
6626 if !self.window_end_exprs.is_empty() {
6627 len += 1;
6628 }
6629 let mut struct_ser = serializer.serialize_struct("stream_plan.HopWindowNode", len)?;
6630 if self.time_col != 0 {
6631 struct_ser.serialize_field("timeCol", &self.time_col)?;
6632 }
6633 if let Some(v) = self.window_slide.as_ref() {
6634 struct_ser.serialize_field("windowSlide", v)?;
6635 }
6636 if let Some(v) = self.window_size.as_ref() {
6637 struct_ser.serialize_field("windowSize", v)?;
6638 }
6639 if !self.output_indices.is_empty() {
6640 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
6641 }
6642 if !self.window_start_exprs.is_empty() {
6643 struct_ser.serialize_field("windowStartExprs", &self.window_start_exprs)?;
6644 }
6645 if !self.window_end_exprs.is_empty() {
6646 struct_ser.serialize_field("windowEndExprs", &self.window_end_exprs)?;
6647 }
6648 struct_ser.end()
6649 }
6650}
6651impl<'de> serde::Deserialize<'de> for HopWindowNode {
6652 #[allow(deprecated)]
6653 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6654 where
6655 D: serde::Deserializer<'de>,
6656 {
6657 const FIELDS: &[&str] = &[
6658 "time_col",
6659 "timeCol",
6660 "window_slide",
6661 "windowSlide",
6662 "window_size",
6663 "windowSize",
6664 "output_indices",
6665 "outputIndices",
6666 "window_start_exprs",
6667 "windowStartExprs",
6668 "window_end_exprs",
6669 "windowEndExprs",
6670 ];
6671
6672 #[allow(clippy::enum_variant_names)]
6673 enum GeneratedField {
6674 TimeCol,
6675 WindowSlide,
6676 WindowSize,
6677 OutputIndices,
6678 WindowStartExprs,
6679 WindowEndExprs,
6680 }
6681 impl<'de> serde::Deserialize<'de> for GeneratedField {
6682 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6683 where
6684 D: serde::Deserializer<'de>,
6685 {
6686 struct GeneratedVisitor;
6687
6688 impl serde::de::Visitor<'_> for GeneratedVisitor {
6689 type Value = GeneratedField;
6690
6691 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6692 write!(formatter, "expected one of: {:?}", &FIELDS)
6693 }
6694
6695 #[allow(unused_variables)]
6696 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6697 where
6698 E: serde::de::Error,
6699 {
6700 match value {
6701 "timeCol" | "time_col" => Ok(GeneratedField::TimeCol),
6702 "windowSlide" | "window_slide" => Ok(GeneratedField::WindowSlide),
6703 "windowSize" | "window_size" => Ok(GeneratedField::WindowSize),
6704 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
6705 "windowStartExprs" | "window_start_exprs" => Ok(GeneratedField::WindowStartExprs),
6706 "windowEndExprs" | "window_end_exprs" => Ok(GeneratedField::WindowEndExprs),
6707 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6708 }
6709 }
6710 }
6711 deserializer.deserialize_identifier(GeneratedVisitor)
6712 }
6713 }
6714 struct GeneratedVisitor;
6715 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6716 type Value = HopWindowNode;
6717
6718 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6719 formatter.write_str("struct stream_plan.HopWindowNode")
6720 }
6721
6722 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HopWindowNode, V::Error>
6723 where
6724 V: serde::de::MapAccess<'de>,
6725 {
6726 let mut time_col__ = None;
6727 let mut window_slide__ = None;
6728 let mut window_size__ = None;
6729 let mut output_indices__ = None;
6730 let mut window_start_exprs__ = None;
6731 let mut window_end_exprs__ = None;
6732 while let Some(k) = map_.next_key()? {
6733 match k {
6734 GeneratedField::TimeCol => {
6735 if time_col__.is_some() {
6736 return Err(serde::de::Error::duplicate_field("timeCol"));
6737 }
6738 time_col__ =
6739 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6740 ;
6741 }
6742 GeneratedField::WindowSlide => {
6743 if window_slide__.is_some() {
6744 return Err(serde::de::Error::duplicate_field("windowSlide"));
6745 }
6746 window_slide__ = map_.next_value()?;
6747 }
6748 GeneratedField::WindowSize => {
6749 if window_size__.is_some() {
6750 return Err(serde::de::Error::duplicate_field("windowSize"));
6751 }
6752 window_size__ = map_.next_value()?;
6753 }
6754 GeneratedField::OutputIndices => {
6755 if output_indices__.is_some() {
6756 return Err(serde::de::Error::duplicate_field("outputIndices"));
6757 }
6758 output_indices__ =
6759 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6760 .into_iter().map(|x| x.0).collect())
6761 ;
6762 }
6763 GeneratedField::WindowStartExprs => {
6764 if window_start_exprs__.is_some() {
6765 return Err(serde::de::Error::duplicate_field("windowStartExprs"));
6766 }
6767 window_start_exprs__ = Some(map_.next_value()?);
6768 }
6769 GeneratedField::WindowEndExprs => {
6770 if window_end_exprs__.is_some() {
6771 return Err(serde::de::Error::duplicate_field("windowEndExprs"));
6772 }
6773 window_end_exprs__ = Some(map_.next_value()?);
6774 }
6775 }
6776 }
6777 Ok(HopWindowNode {
6778 time_col: time_col__.unwrap_or_default(),
6779 window_slide: window_slide__,
6780 window_size: window_size__,
6781 output_indices: output_indices__.unwrap_or_default(),
6782 window_start_exprs: window_start_exprs__.unwrap_or_default(),
6783 window_end_exprs: window_end_exprs__.unwrap_or_default(),
6784 })
6785 }
6786 }
6787 deserializer.deserialize_struct("stream_plan.HopWindowNode", FIELDS, GeneratedVisitor)
6788 }
6789}
6790impl serde::Serialize for IcebergPkIndexCompactionContext {
6791 #[allow(deprecated)]
6792 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6793 where
6794 S: serde::Serializer,
6795 {
6796 use serde::ser::SerializeStruct;
6797 let mut len = 0;
6798 if self.sink_id != 0 {
6799 len += 1;
6800 }
6801 if self.task_id != 0 {
6802 len += 1;
6803 }
6804 if self.phase != 0 {
6805 len += 1;
6806 }
6807 let mut struct_ser = serializer.serialize_struct("stream_plan.IcebergPkIndexCompactionContext", len)?;
6808 if self.sink_id != 0 {
6809 struct_ser.serialize_field("sinkId", &self.sink_id)?;
6810 }
6811 if self.task_id != 0 {
6812 #[allow(clippy::needless_borrow)]
6813 #[allow(clippy::needless_borrows_for_generic_args)]
6814 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
6815 }
6816 if self.phase != 0 {
6817 let v = iceberg_pk_index_compaction_context::Phase::try_from(self.phase)
6818 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.phase)))?;
6819 struct_ser.serialize_field("phase", &v)?;
6820 }
6821 struct_ser.end()
6822 }
6823}
6824impl<'de> serde::Deserialize<'de> for IcebergPkIndexCompactionContext {
6825 #[allow(deprecated)]
6826 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6827 where
6828 D: serde::Deserializer<'de>,
6829 {
6830 const FIELDS: &[&str] = &[
6831 "sink_id",
6832 "sinkId",
6833 "task_id",
6834 "taskId",
6835 "phase",
6836 ];
6837
6838 #[allow(clippy::enum_variant_names)]
6839 enum GeneratedField {
6840 SinkId,
6841 TaskId,
6842 Phase,
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 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
6865 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
6866 "phase" => Ok(GeneratedField::Phase),
6867 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6868 }
6869 }
6870 }
6871 deserializer.deserialize_identifier(GeneratedVisitor)
6872 }
6873 }
6874 struct GeneratedVisitor;
6875 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6876 type Value = IcebergPkIndexCompactionContext;
6877
6878 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6879 formatter.write_str("struct stream_plan.IcebergPkIndexCompactionContext")
6880 }
6881
6882 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IcebergPkIndexCompactionContext, V::Error>
6883 where
6884 V: serde::de::MapAccess<'de>,
6885 {
6886 let mut sink_id__ = None;
6887 let mut task_id__ = None;
6888 let mut phase__ = None;
6889 while let Some(k) = map_.next_key()? {
6890 match k {
6891 GeneratedField::SinkId => {
6892 if sink_id__.is_some() {
6893 return Err(serde::de::Error::duplicate_field("sinkId"));
6894 }
6895 sink_id__ =
6896 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6897 ;
6898 }
6899 GeneratedField::TaskId => {
6900 if task_id__.is_some() {
6901 return Err(serde::de::Error::duplicate_field("taskId"));
6902 }
6903 task_id__ =
6904 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6905 ;
6906 }
6907 GeneratedField::Phase => {
6908 if phase__.is_some() {
6909 return Err(serde::de::Error::duplicate_field("phase"));
6910 }
6911 phase__ = Some(map_.next_value::<iceberg_pk_index_compaction_context::Phase>()? as i32);
6912 }
6913 }
6914 }
6915 Ok(IcebergPkIndexCompactionContext {
6916 sink_id: sink_id__.unwrap_or_default(),
6917 task_id: task_id__.unwrap_or_default(),
6918 phase: phase__.unwrap_or_default(),
6919 })
6920 }
6921 }
6922 deserializer.deserialize_struct("stream_plan.IcebergPkIndexCompactionContext", FIELDS, GeneratedVisitor)
6923 }
6924}
6925impl serde::Serialize for iceberg_pk_index_compaction_context::Phase {
6926 #[allow(deprecated)]
6927 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6928 where
6929 S: serde::Serializer,
6930 {
6931 let variant = match self {
6932 Self::Unspecified => "PHASE_UNSPECIFIED",
6933 Self::Begin => "PHASE_BEGIN",
6934 Self::End => "PHASE_END",
6935 };
6936 serializer.serialize_str(variant)
6937 }
6938}
6939impl<'de> serde::Deserialize<'de> for iceberg_pk_index_compaction_context::Phase {
6940 #[allow(deprecated)]
6941 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6942 where
6943 D: serde::Deserializer<'de>,
6944 {
6945 const FIELDS: &[&str] = &[
6946 "PHASE_UNSPECIFIED",
6947 "PHASE_BEGIN",
6948 "PHASE_END",
6949 ];
6950
6951 struct GeneratedVisitor;
6952
6953 impl serde::de::Visitor<'_> for GeneratedVisitor {
6954 type Value = iceberg_pk_index_compaction_context::Phase;
6955
6956 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6957 write!(formatter, "expected one of: {:?}", &FIELDS)
6958 }
6959
6960 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6961 where
6962 E: serde::de::Error,
6963 {
6964 i32::try_from(v)
6965 .ok()
6966 .and_then(|x| x.try_into().ok())
6967 .ok_or_else(|| {
6968 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6969 })
6970 }
6971
6972 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6973 where
6974 E: serde::de::Error,
6975 {
6976 i32::try_from(v)
6977 .ok()
6978 .and_then(|x| x.try_into().ok())
6979 .ok_or_else(|| {
6980 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6981 })
6982 }
6983
6984 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6985 where
6986 E: serde::de::Error,
6987 {
6988 match value {
6989 "PHASE_UNSPECIFIED" => Ok(iceberg_pk_index_compaction_context::Phase::Unspecified),
6990 "PHASE_BEGIN" => Ok(iceberg_pk_index_compaction_context::Phase::Begin),
6991 "PHASE_END" => Ok(iceberg_pk_index_compaction_context::Phase::End),
6992 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6993 }
6994 }
6995 }
6996 deserializer.deserialize_any(GeneratedVisitor)
6997 }
6998}
6999impl serde::Serialize for IcebergWithPkIndexPositionDeleteMergerNode {
7000 #[allow(deprecated)]
7001 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7002 where
7003 S: serde::Serializer,
7004 {
7005 use serde::ser::SerializeStruct;
7006 let mut len = 0;
7007 if self.sink_desc.is_some() {
7008 len += 1;
7009 }
7010 let mut struct_ser = serializer.serialize_struct("stream_plan.IcebergWithPkIndexPositionDeleteMergerNode", len)?;
7011 if let Some(v) = self.sink_desc.as_ref() {
7012 struct_ser.serialize_field("sinkDesc", v)?;
7013 }
7014 struct_ser.end()
7015 }
7016}
7017impl<'de> serde::Deserialize<'de> for IcebergWithPkIndexPositionDeleteMergerNode {
7018 #[allow(deprecated)]
7019 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7020 where
7021 D: serde::Deserializer<'de>,
7022 {
7023 const FIELDS: &[&str] = &[
7024 "sink_desc",
7025 "sinkDesc",
7026 ];
7027
7028 #[allow(clippy::enum_variant_names)]
7029 enum GeneratedField {
7030 SinkDesc,
7031 }
7032 impl<'de> serde::Deserialize<'de> for GeneratedField {
7033 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7034 where
7035 D: serde::Deserializer<'de>,
7036 {
7037 struct GeneratedVisitor;
7038
7039 impl serde::de::Visitor<'_> for GeneratedVisitor {
7040 type Value = GeneratedField;
7041
7042 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7043 write!(formatter, "expected one of: {:?}", &FIELDS)
7044 }
7045
7046 #[allow(unused_variables)]
7047 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7048 where
7049 E: serde::de::Error,
7050 {
7051 match value {
7052 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
7053 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7054 }
7055 }
7056 }
7057 deserializer.deserialize_identifier(GeneratedVisitor)
7058 }
7059 }
7060 struct GeneratedVisitor;
7061 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7062 type Value = IcebergWithPkIndexPositionDeleteMergerNode;
7063
7064 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7065 formatter.write_str("struct stream_plan.IcebergWithPkIndexPositionDeleteMergerNode")
7066 }
7067
7068 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IcebergWithPkIndexPositionDeleteMergerNode, V::Error>
7069 where
7070 V: serde::de::MapAccess<'de>,
7071 {
7072 let mut sink_desc__ = None;
7073 while let Some(k) = map_.next_key()? {
7074 match k {
7075 GeneratedField::SinkDesc => {
7076 if sink_desc__.is_some() {
7077 return Err(serde::de::Error::duplicate_field("sinkDesc"));
7078 }
7079 sink_desc__ = map_.next_value()?;
7080 }
7081 }
7082 }
7083 Ok(IcebergWithPkIndexPositionDeleteMergerNode {
7084 sink_desc: sink_desc__,
7085 })
7086 }
7087 }
7088 deserializer.deserialize_struct("stream_plan.IcebergWithPkIndexPositionDeleteMergerNode", FIELDS, GeneratedVisitor)
7089 }
7090}
7091impl serde::Serialize for IcebergWithPkIndexWriterNode {
7092 #[allow(deprecated)]
7093 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7094 where
7095 S: serde::Serializer,
7096 {
7097 use serde::ser::SerializeStruct;
7098 let mut len = 0;
7099 if self.sink_desc.is_some() {
7100 len += 1;
7101 }
7102 if self.pk_index_table.is_some() {
7103 len += 1;
7104 }
7105 let mut struct_ser = serializer.serialize_struct("stream_plan.IcebergWithPkIndexWriterNode", len)?;
7106 if let Some(v) = self.sink_desc.as_ref() {
7107 struct_ser.serialize_field("sinkDesc", v)?;
7108 }
7109 if let Some(v) = self.pk_index_table.as_ref() {
7110 struct_ser.serialize_field("pkIndexTable", v)?;
7111 }
7112 struct_ser.end()
7113 }
7114}
7115impl<'de> serde::Deserialize<'de> for IcebergWithPkIndexWriterNode {
7116 #[allow(deprecated)]
7117 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7118 where
7119 D: serde::Deserializer<'de>,
7120 {
7121 const FIELDS: &[&str] = &[
7122 "sink_desc",
7123 "sinkDesc",
7124 "pk_index_table",
7125 "pkIndexTable",
7126 ];
7127
7128 #[allow(clippy::enum_variant_names)]
7129 enum GeneratedField {
7130 SinkDesc,
7131 PkIndexTable,
7132 }
7133 impl<'de> serde::Deserialize<'de> for GeneratedField {
7134 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7135 where
7136 D: serde::Deserializer<'de>,
7137 {
7138 struct GeneratedVisitor;
7139
7140 impl serde::de::Visitor<'_> for GeneratedVisitor {
7141 type Value = GeneratedField;
7142
7143 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7144 write!(formatter, "expected one of: {:?}", &FIELDS)
7145 }
7146
7147 #[allow(unused_variables)]
7148 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7149 where
7150 E: serde::de::Error,
7151 {
7152 match value {
7153 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
7154 "pkIndexTable" | "pk_index_table" => Ok(GeneratedField::PkIndexTable),
7155 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7156 }
7157 }
7158 }
7159 deserializer.deserialize_identifier(GeneratedVisitor)
7160 }
7161 }
7162 struct GeneratedVisitor;
7163 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7164 type Value = IcebergWithPkIndexWriterNode;
7165
7166 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7167 formatter.write_str("struct stream_plan.IcebergWithPkIndexWriterNode")
7168 }
7169
7170 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IcebergWithPkIndexWriterNode, V::Error>
7171 where
7172 V: serde::de::MapAccess<'de>,
7173 {
7174 let mut sink_desc__ = None;
7175 let mut pk_index_table__ = None;
7176 while let Some(k) = map_.next_key()? {
7177 match k {
7178 GeneratedField::SinkDesc => {
7179 if sink_desc__.is_some() {
7180 return Err(serde::de::Error::duplicate_field("sinkDesc"));
7181 }
7182 sink_desc__ = map_.next_value()?;
7183 }
7184 GeneratedField::PkIndexTable => {
7185 if pk_index_table__.is_some() {
7186 return Err(serde::de::Error::duplicate_field("pkIndexTable"));
7187 }
7188 pk_index_table__ = map_.next_value()?;
7189 }
7190 }
7191 }
7192 Ok(IcebergWithPkIndexWriterNode {
7193 sink_desc: sink_desc__,
7194 pk_index_table: pk_index_table__,
7195 })
7196 }
7197 }
7198 deserializer.deserialize_struct("stream_plan.IcebergWithPkIndexWriterNode", FIELDS, GeneratedVisitor)
7199 }
7200}
7201impl serde::Serialize for InequalityPair {
7202 #[allow(deprecated)]
7203 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7204 where
7205 S: serde::Serializer,
7206 {
7207 use serde::ser::SerializeStruct;
7208 let mut len = 0;
7209 if self.key_required_larger != 0 {
7210 len += 1;
7211 }
7212 if self.key_required_smaller != 0 {
7213 len += 1;
7214 }
7215 if self.clean_state {
7216 len += 1;
7217 }
7218 if self.delta_expression.is_some() {
7219 len += 1;
7220 }
7221 let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPair", len)?;
7222 if self.key_required_larger != 0 {
7223 struct_ser.serialize_field("keyRequiredLarger", &self.key_required_larger)?;
7224 }
7225 if self.key_required_smaller != 0 {
7226 struct_ser.serialize_field("keyRequiredSmaller", &self.key_required_smaller)?;
7227 }
7228 if self.clean_state {
7229 struct_ser.serialize_field("cleanState", &self.clean_state)?;
7230 }
7231 if let Some(v) = self.delta_expression.as_ref() {
7232 struct_ser.serialize_field("deltaExpression", v)?;
7233 }
7234 struct_ser.end()
7235 }
7236}
7237impl<'de> serde::Deserialize<'de> for InequalityPair {
7238 #[allow(deprecated)]
7239 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7240 where
7241 D: serde::Deserializer<'de>,
7242 {
7243 const FIELDS: &[&str] = &[
7244 "key_required_larger",
7245 "keyRequiredLarger",
7246 "key_required_smaller",
7247 "keyRequiredSmaller",
7248 "clean_state",
7249 "cleanState",
7250 "delta_expression",
7251 "deltaExpression",
7252 ];
7253
7254 #[allow(clippy::enum_variant_names)]
7255 enum GeneratedField {
7256 KeyRequiredLarger,
7257 KeyRequiredSmaller,
7258 CleanState,
7259 DeltaExpression,
7260 }
7261 impl<'de> serde::Deserialize<'de> for GeneratedField {
7262 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7263 where
7264 D: serde::Deserializer<'de>,
7265 {
7266 struct GeneratedVisitor;
7267
7268 impl serde::de::Visitor<'_> for GeneratedVisitor {
7269 type Value = GeneratedField;
7270
7271 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7272 write!(formatter, "expected one of: {:?}", &FIELDS)
7273 }
7274
7275 #[allow(unused_variables)]
7276 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7277 where
7278 E: serde::de::Error,
7279 {
7280 match value {
7281 "keyRequiredLarger" | "key_required_larger" => Ok(GeneratedField::KeyRequiredLarger),
7282 "keyRequiredSmaller" | "key_required_smaller" => Ok(GeneratedField::KeyRequiredSmaller),
7283 "cleanState" | "clean_state" => Ok(GeneratedField::CleanState),
7284 "deltaExpression" | "delta_expression" => Ok(GeneratedField::DeltaExpression),
7285 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7286 }
7287 }
7288 }
7289 deserializer.deserialize_identifier(GeneratedVisitor)
7290 }
7291 }
7292 struct GeneratedVisitor;
7293 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7294 type Value = InequalityPair;
7295
7296 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7297 formatter.write_str("struct stream_plan.InequalityPair")
7298 }
7299
7300 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPair, V::Error>
7301 where
7302 V: serde::de::MapAccess<'de>,
7303 {
7304 let mut key_required_larger__ = None;
7305 let mut key_required_smaller__ = None;
7306 let mut clean_state__ = None;
7307 let mut delta_expression__ = None;
7308 while let Some(k) = map_.next_key()? {
7309 match k {
7310 GeneratedField::KeyRequiredLarger => {
7311 if key_required_larger__.is_some() {
7312 return Err(serde::de::Error::duplicate_field("keyRequiredLarger"));
7313 }
7314 key_required_larger__ =
7315 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7316 ;
7317 }
7318 GeneratedField::KeyRequiredSmaller => {
7319 if key_required_smaller__.is_some() {
7320 return Err(serde::de::Error::duplicate_field("keyRequiredSmaller"));
7321 }
7322 key_required_smaller__ =
7323 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7324 ;
7325 }
7326 GeneratedField::CleanState => {
7327 if clean_state__.is_some() {
7328 return Err(serde::de::Error::duplicate_field("cleanState"));
7329 }
7330 clean_state__ = Some(map_.next_value()?);
7331 }
7332 GeneratedField::DeltaExpression => {
7333 if delta_expression__.is_some() {
7334 return Err(serde::de::Error::duplicate_field("deltaExpression"));
7335 }
7336 delta_expression__ = map_.next_value()?;
7337 }
7338 }
7339 }
7340 Ok(InequalityPair {
7341 key_required_larger: key_required_larger__.unwrap_or_default(),
7342 key_required_smaller: key_required_smaller__.unwrap_or_default(),
7343 clean_state: clean_state__.unwrap_or_default(),
7344 delta_expression: delta_expression__,
7345 })
7346 }
7347 }
7348 deserializer.deserialize_struct("stream_plan.InequalityPair", FIELDS, GeneratedVisitor)
7349 }
7350}
7351impl serde::Serialize for InequalityPairV2 {
7352 #[allow(deprecated)]
7353 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7354 where
7355 S: serde::Serializer,
7356 {
7357 use serde::ser::SerializeStruct;
7358 let mut len = 0;
7359 if self.left_idx != 0 {
7360 len += 1;
7361 }
7362 if self.right_idx != 0 {
7363 len += 1;
7364 }
7365 if self.clean_left_state {
7366 len += 1;
7367 }
7368 if self.clean_right_state {
7369 len += 1;
7370 }
7371 if self.op != 0 {
7372 len += 1;
7373 }
7374 let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPairV2", len)?;
7375 if self.left_idx != 0 {
7376 struct_ser.serialize_field("leftIdx", &self.left_idx)?;
7377 }
7378 if self.right_idx != 0 {
7379 struct_ser.serialize_field("rightIdx", &self.right_idx)?;
7380 }
7381 if self.clean_left_state {
7382 struct_ser.serialize_field("cleanLeftState", &self.clean_left_state)?;
7383 }
7384 if self.clean_right_state {
7385 struct_ser.serialize_field("cleanRightState", &self.clean_right_state)?;
7386 }
7387 if self.op != 0 {
7388 let v = InequalityType::try_from(self.op)
7389 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.op)))?;
7390 struct_ser.serialize_field("op", &v)?;
7391 }
7392 struct_ser.end()
7393 }
7394}
7395impl<'de> serde::Deserialize<'de> for InequalityPairV2 {
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 "left_idx",
7403 "leftIdx",
7404 "right_idx",
7405 "rightIdx",
7406 "clean_left_state",
7407 "cleanLeftState",
7408 "clean_right_state",
7409 "cleanRightState",
7410 "op",
7411 ];
7412
7413 #[allow(clippy::enum_variant_names)]
7414 enum GeneratedField {
7415 LeftIdx,
7416 RightIdx,
7417 CleanLeftState,
7418 CleanRightState,
7419 Op,
7420 }
7421 impl<'de> serde::Deserialize<'de> for GeneratedField {
7422 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7423 where
7424 D: serde::Deserializer<'de>,
7425 {
7426 struct GeneratedVisitor;
7427
7428 impl serde::de::Visitor<'_> for GeneratedVisitor {
7429 type Value = GeneratedField;
7430
7431 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7432 write!(formatter, "expected one of: {:?}", &FIELDS)
7433 }
7434
7435 #[allow(unused_variables)]
7436 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7437 where
7438 E: serde::de::Error,
7439 {
7440 match value {
7441 "leftIdx" | "left_idx" => Ok(GeneratedField::LeftIdx),
7442 "rightIdx" | "right_idx" => Ok(GeneratedField::RightIdx),
7443 "cleanLeftState" | "clean_left_state" => Ok(GeneratedField::CleanLeftState),
7444 "cleanRightState" | "clean_right_state" => Ok(GeneratedField::CleanRightState),
7445 "op" => Ok(GeneratedField::Op),
7446 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7447 }
7448 }
7449 }
7450 deserializer.deserialize_identifier(GeneratedVisitor)
7451 }
7452 }
7453 struct GeneratedVisitor;
7454 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7455 type Value = InequalityPairV2;
7456
7457 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7458 formatter.write_str("struct stream_plan.InequalityPairV2")
7459 }
7460
7461 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPairV2, V::Error>
7462 where
7463 V: serde::de::MapAccess<'de>,
7464 {
7465 let mut left_idx__ = None;
7466 let mut right_idx__ = None;
7467 let mut clean_left_state__ = None;
7468 let mut clean_right_state__ = None;
7469 let mut op__ = None;
7470 while let Some(k) = map_.next_key()? {
7471 match k {
7472 GeneratedField::LeftIdx => {
7473 if left_idx__.is_some() {
7474 return Err(serde::de::Error::duplicate_field("leftIdx"));
7475 }
7476 left_idx__ =
7477 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7478 ;
7479 }
7480 GeneratedField::RightIdx => {
7481 if right_idx__.is_some() {
7482 return Err(serde::de::Error::duplicate_field("rightIdx"));
7483 }
7484 right_idx__ =
7485 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7486 ;
7487 }
7488 GeneratedField::CleanLeftState => {
7489 if clean_left_state__.is_some() {
7490 return Err(serde::de::Error::duplicate_field("cleanLeftState"));
7491 }
7492 clean_left_state__ = Some(map_.next_value()?);
7493 }
7494 GeneratedField::CleanRightState => {
7495 if clean_right_state__.is_some() {
7496 return Err(serde::de::Error::duplicate_field("cleanRightState"));
7497 }
7498 clean_right_state__ = Some(map_.next_value()?);
7499 }
7500 GeneratedField::Op => {
7501 if op__.is_some() {
7502 return Err(serde::de::Error::duplicate_field("op"));
7503 }
7504 op__ = Some(map_.next_value::<InequalityType>()? as i32);
7505 }
7506 }
7507 }
7508 Ok(InequalityPairV2 {
7509 left_idx: left_idx__.unwrap_or_default(),
7510 right_idx: right_idx__.unwrap_or_default(),
7511 clean_left_state: clean_left_state__.unwrap_or_default(),
7512 clean_right_state: clean_right_state__.unwrap_or_default(),
7513 op: op__.unwrap_or_default(),
7514 })
7515 }
7516 }
7517 deserializer.deserialize_struct("stream_plan.InequalityPairV2", FIELDS, GeneratedVisitor)
7518 }
7519}
7520impl serde::Serialize for InequalityType {
7521 #[allow(deprecated)]
7522 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7523 where
7524 S: serde::Serializer,
7525 {
7526 let variant = match self {
7527 Self::Unspecified => "INEQUALITY_TYPE_UNSPECIFIED",
7528 Self::LessThan => "INEQUALITY_TYPE_LESS_THAN",
7529 Self::LessThanOrEqual => "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL",
7530 Self::GreaterThan => "INEQUALITY_TYPE_GREATER_THAN",
7531 Self::GreaterThanOrEqual => "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL",
7532 };
7533 serializer.serialize_str(variant)
7534 }
7535}
7536impl<'de> serde::Deserialize<'de> for InequalityType {
7537 #[allow(deprecated)]
7538 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7539 where
7540 D: serde::Deserializer<'de>,
7541 {
7542 const FIELDS: &[&str] = &[
7543 "INEQUALITY_TYPE_UNSPECIFIED",
7544 "INEQUALITY_TYPE_LESS_THAN",
7545 "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL",
7546 "INEQUALITY_TYPE_GREATER_THAN",
7547 "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL",
7548 ];
7549
7550 struct GeneratedVisitor;
7551
7552 impl serde::de::Visitor<'_> for GeneratedVisitor {
7553 type Value = InequalityType;
7554
7555 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7556 write!(formatter, "expected one of: {:?}", &FIELDS)
7557 }
7558
7559 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
7560 where
7561 E: serde::de::Error,
7562 {
7563 i32::try_from(v)
7564 .ok()
7565 .and_then(|x| x.try_into().ok())
7566 .ok_or_else(|| {
7567 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
7568 })
7569 }
7570
7571 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
7572 where
7573 E: serde::de::Error,
7574 {
7575 i32::try_from(v)
7576 .ok()
7577 .and_then(|x| x.try_into().ok())
7578 .ok_or_else(|| {
7579 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
7580 })
7581 }
7582
7583 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
7584 where
7585 E: serde::de::Error,
7586 {
7587 match value {
7588 "INEQUALITY_TYPE_UNSPECIFIED" => Ok(InequalityType::Unspecified),
7589 "INEQUALITY_TYPE_LESS_THAN" => Ok(InequalityType::LessThan),
7590 "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL" => Ok(InequalityType::LessThanOrEqual),
7591 "INEQUALITY_TYPE_GREATER_THAN" => Ok(InequalityType::GreaterThan),
7592 "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL" => Ok(InequalityType::GreaterThanOrEqual),
7593 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
7594 }
7595 }
7596 }
7597 deserializer.deserialize_any(GeneratedVisitor)
7598 }
7599}
7600impl serde::Serialize for InjectSourceOffsetsMutation {
7601 #[allow(deprecated)]
7602 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7603 where
7604 S: serde::Serializer,
7605 {
7606 use serde::ser::SerializeStruct;
7607 let mut len = 0;
7608 if self.source_id != 0 {
7609 len += 1;
7610 }
7611 if !self.split_offsets.is_empty() {
7612 len += 1;
7613 }
7614 let mut struct_ser = serializer.serialize_struct("stream_plan.InjectSourceOffsetsMutation", len)?;
7615 if self.source_id != 0 {
7616 struct_ser.serialize_field("sourceId", &self.source_id)?;
7617 }
7618 if !self.split_offsets.is_empty() {
7619 struct_ser.serialize_field("splitOffsets", &self.split_offsets)?;
7620 }
7621 struct_ser.end()
7622 }
7623}
7624impl<'de> serde::Deserialize<'de> for InjectSourceOffsetsMutation {
7625 #[allow(deprecated)]
7626 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7627 where
7628 D: serde::Deserializer<'de>,
7629 {
7630 const FIELDS: &[&str] = &[
7631 "source_id",
7632 "sourceId",
7633 "split_offsets",
7634 "splitOffsets",
7635 ];
7636
7637 #[allow(clippy::enum_variant_names)]
7638 enum GeneratedField {
7639 SourceId,
7640 SplitOffsets,
7641 }
7642 impl<'de> serde::Deserialize<'de> for GeneratedField {
7643 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7644 where
7645 D: serde::Deserializer<'de>,
7646 {
7647 struct GeneratedVisitor;
7648
7649 impl serde::de::Visitor<'_> for GeneratedVisitor {
7650 type Value = GeneratedField;
7651
7652 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7653 write!(formatter, "expected one of: {:?}", &FIELDS)
7654 }
7655
7656 #[allow(unused_variables)]
7657 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7658 where
7659 E: serde::de::Error,
7660 {
7661 match value {
7662 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
7663 "splitOffsets" | "split_offsets" => Ok(GeneratedField::SplitOffsets),
7664 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7665 }
7666 }
7667 }
7668 deserializer.deserialize_identifier(GeneratedVisitor)
7669 }
7670 }
7671 struct GeneratedVisitor;
7672 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7673 type Value = InjectSourceOffsetsMutation;
7674
7675 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7676 formatter.write_str("struct stream_plan.InjectSourceOffsetsMutation")
7677 }
7678
7679 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InjectSourceOffsetsMutation, V::Error>
7680 where
7681 V: serde::de::MapAccess<'de>,
7682 {
7683 let mut source_id__ = None;
7684 let mut split_offsets__ = None;
7685 while let Some(k) = map_.next_key()? {
7686 match k {
7687 GeneratedField::SourceId => {
7688 if source_id__.is_some() {
7689 return Err(serde::de::Error::duplicate_field("sourceId"));
7690 }
7691 source_id__ =
7692 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7693 ;
7694 }
7695 GeneratedField::SplitOffsets => {
7696 if split_offsets__.is_some() {
7697 return Err(serde::de::Error::duplicate_field("splitOffsets"));
7698 }
7699 split_offsets__ = Some(
7700 map_.next_value::<std::collections::HashMap<_, _>>()?
7701 );
7702 }
7703 }
7704 }
7705 Ok(InjectSourceOffsetsMutation {
7706 source_id: source_id__.unwrap_or_default(),
7707 split_offsets: split_offsets__.unwrap_or_default(),
7708 })
7709 }
7710 }
7711 deserializer.deserialize_struct("stream_plan.InjectSourceOffsetsMutation", FIELDS, GeneratedVisitor)
7712 }
7713}
7714impl serde::Serialize for JoinEncodingType {
7715 #[allow(deprecated)]
7716 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7717 where
7718 S: serde::Serializer,
7719 {
7720 let variant = match self {
7721 Self::Unspecified => "UNSPECIFIED",
7722 Self::MemoryOptimized => "MEMORY_OPTIMIZED",
7723 Self::CpuOptimized => "CPU_OPTIMIZED",
7724 };
7725 serializer.serialize_str(variant)
7726 }
7727}
7728impl<'de> serde::Deserialize<'de> for JoinEncodingType {
7729 #[allow(deprecated)]
7730 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7731 where
7732 D: serde::Deserializer<'de>,
7733 {
7734 const FIELDS: &[&str] = &[
7735 "UNSPECIFIED",
7736 "MEMORY_OPTIMIZED",
7737 "CPU_OPTIMIZED",
7738 ];
7739
7740 struct GeneratedVisitor;
7741
7742 impl serde::de::Visitor<'_> for GeneratedVisitor {
7743 type Value = JoinEncodingType;
7744
7745 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7746 write!(formatter, "expected one of: {:?}", &FIELDS)
7747 }
7748
7749 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
7750 where
7751 E: serde::de::Error,
7752 {
7753 i32::try_from(v)
7754 .ok()
7755 .and_then(|x| x.try_into().ok())
7756 .ok_or_else(|| {
7757 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
7758 })
7759 }
7760
7761 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
7762 where
7763 E: serde::de::Error,
7764 {
7765 i32::try_from(v)
7766 .ok()
7767 .and_then(|x| x.try_into().ok())
7768 .ok_or_else(|| {
7769 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
7770 })
7771 }
7772
7773 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
7774 where
7775 E: serde::de::Error,
7776 {
7777 match value {
7778 "UNSPECIFIED" => Ok(JoinEncodingType::Unspecified),
7779 "MEMORY_OPTIMIZED" => Ok(JoinEncodingType::MemoryOptimized),
7780 "CPU_OPTIMIZED" => Ok(JoinEncodingType::CpuOptimized),
7781 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
7782 }
7783 }
7784 }
7785 deserializer.deserialize_any(GeneratedVisitor)
7786 }
7787}
7788impl serde::Serialize for JoinKeyWatermarkIndex {
7789 #[allow(deprecated)]
7790 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7791 where
7792 S: serde::Serializer,
7793 {
7794 use serde::ser::SerializeStruct;
7795 let mut len = 0;
7796 if self.index != 0 {
7797 len += 1;
7798 }
7799 if self.do_state_cleaning {
7800 len += 1;
7801 }
7802 let mut struct_ser = serializer.serialize_struct("stream_plan.JoinKeyWatermarkIndex", len)?;
7803 if self.index != 0 {
7804 struct_ser.serialize_field("index", &self.index)?;
7805 }
7806 if self.do_state_cleaning {
7807 struct_ser.serialize_field("doStateCleaning", &self.do_state_cleaning)?;
7808 }
7809 struct_ser.end()
7810 }
7811}
7812impl<'de> serde::Deserialize<'de> for JoinKeyWatermarkIndex {
7813 #[allow(deprecated)]
7814 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7815 where
7816 D: serde::Deserializer<'de>,
7817 {
7818 const FIELDS: &[&str] = &[
7819 "index",
7820 "do_state_cleaning",
7821 "doStateCleaning",
7822 ];
7823
7824 #[allow(clippy::enum_variant_names)]
7825 enum GeneratedField {
7826 Index,
7827 DoStateCleaning,
7828 }
7829 impl<'de> serde::Deserialize<'de> for GeneratedField {
7830 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7831 where
7832 D: serde::Deserializer<'de>,
7833 {
7834 struct GeneratedVisitor;
7835
7836 impl serde::de::Visitor<'_> for GeneratedVisitor {
7837 type Value = GeneratedField;
7838
7839 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7840 write!(formatter, "expected one of: {:?}", &FIELDS)
7841 }
7842
7843 #[allow(unused_variables)]
7844 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7845 where
7846 E: serde::de::Error,
7847 {
7848 match value {
7849 "index" => Ok(GeneratedField::Index),
7850 "doStateCleaning" | "do_state_cleaning" => Ok(GeneratedField::DoStateCleaning),
7851 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7852 }
7853 }
7854 }
7855 deserializer.deserialize_identifier(GeneratedVisitor)
7856 }
7857 }
7858 struct GeneratedVisitor;
7859 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7860 type Value = JoinKeyWatermarkIndex;
7861
7862 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7863 formatter.write_str("struct stream_plan.JoinKeyWatermarkIndex")
7864 }
7865
7866 fn visit_map<V>(self, mut map_: V) -> std::result::Result<JoinKeyWatermarkIndex, V::Error>
7867 where
7868 V: serde::de::MapAccess<'de>,
7869 {
7870 let mut index__ = None;
7871 let mut do_state_cleaning__ = None;
7872 while let Some(k) = map_.next_key()? {
7873 match k {
7874 GeneratedField::Index => {
7875 if index__.is_some() {
7876 return Err(serde::de::Error::duplicate_field("index"));
7877 }
7878 index__ =
7879 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7880 ;
7881 }
7882 GeneratedField::DoStateCleaning => {
7883 if do_state_cleaning__.is_some() {
7884 return Err(serde::de::Error::duplicate_field("doStateCleaning"));
7885 }
7886 do_state_cleaning__ = Some(map_.next_value()?);
7887 }
7888 }
7889 }
7890 Ok(JoinKeyWatermarkIndex {
7891 index: index__.unwrap_or_default(),
7892 do_state_cleaning: do_state_cleaning__.unwrap_or_default(),
7893 })
7894 }
7895 }
7896 deserializer.deserialize_struct("stream_plan.JoinKeyWatermarkIndex", FIELDS, GeneratedVisitor)
7897 }
7898}
7899impl serde::Serialize for ListFinishMutation {
7900 #[allow(deprecated)]
7901 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7902 where
7903 S: serde::Serializer,
7904 {
7905 use serde::ser::SerializeStruct;
7906 let mut len = 0;
7907 if self.associated_source_id != 0 {
7908 len += 1;
7909 }
7910 let mut struct_ser = serializer.serialize_struct("stream_plan.ListFinishMutation", len)?;
7911 if self.associated_source_id != 0 {
7912 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
7913 }
7914 struct_ser.end()
7915 }
7916}
7917impl<'de> serde::Deserialize<'de> for ListFinishMutation {
7918 #[allow(deprecated)]
7919 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7920 where
7921 D: serde::Deserializer<'de>,
7922 {
7923 const FIELDS: &[&str] = &[
7924 "associated_source_id",
7925 "associatedSourceId",
7926 ];
7927
7928 #[allow(clippy::enum_variant_names)]
7929 enum GeneratedField {
7930 AssociatedSourceId,
7931 }
7932 impl<'de> serde::Deserialize<'de> for GeneratedField {
7933 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7934 where
7935 D: serde::Deserializer<'de>,
7936 {
7937 struct GeneratedVisitor;
7938
7939 impl serde::de::Visitor<'_> for GeneratedVisitor {
7940 type Value = GeneratedField;
7941
7942 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7943 write!(formatter, "expected one of: {:?}", &FIELDS)
7944 }
7945
7946 #[allow(unused_variables)]
7947 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7948 where
7949 E: serde::de::Error,
7950 {
7951 match value {
7952 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
7953 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7954 }
7955 }
7956 }
7957 deserializer.deserialize_identifier(GeneratedVisitor)
7958 }
7959 }
7960 struct GeneratedVisitor;
7961 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7962 type Value = ListFinishMutation;
7963
7964 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7965 formatter.write_str("struct stream_plan.ListFinishMutation")
7966 }
7967
7968 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFinishMutation, V::Error>
7969 where
7970 V: serde::de::MapAccess<'de>,
7971 {
7972 let mut associated_source_id__ = None;
7973 while let Some(k) = map_.next_key()? {
7974 match k {
7975 GeneratedField::AssociatedSourceId => {
7976 if associated_source_id__.is_some() {
7977 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
7978 }
7979 associated_source_id__ =
7980 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7981 ;
7982 }
7983 }
7984 }
7985 Ok(ListFinishMutation {
7986 associated_source_id: associated_source_id__.unwrap_or_default(),
7987 })
7988 }
7989 }
7990 deserializer.deserialize_struct("stream_plan.ListFinishMutation", FIELDS, GeneratedVisitor)
7991 }
7992}
7993impl serde::Serialize for LoadFinishMutation {
7994 #[allow(deprecated)]
7995 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7996 where
7997 S: serde::Serializer,
7998 {
7999 use serde::ser::SerializeStruct;
8000 let mut len = 0;
8001 if self.associated_source_id != 0 {
8002 len += 1;
8003 }
8004 let mut struct_ser = serializer.serialize_struct("stream_plan.LoadFinishMutation", len)?;
8005 if self.associated_source_id != 0 {
8006 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
8007 }
8008 struct_ser.end()
8009 }
8010}
8011impl<'de> serde::Deserialize<'de> for LoadFinishMutation {
8012 #[allow(deprecated)]
8013 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8014 where
8015 D: serde::Deserializer<'de>,
8016 {
8017 const FIELDS: &[&str] = &[
8018 "associated_source_id",
8019 "associatedSourceId",
8020 ];
8021
8022 #[allow(clippy::enum_variant_names)]
8023 enum GeneratedField {
8024 AssociatedSourceId,
8025 }
8026 impl<'de> serde::Deserialize<'de> for GeneratedField {
8027 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8028 where
8029 D: serde::Deserializer<'de>,
8030 {
8031 struct GeneratedVisitor;
8032
8033 impl serde::de::Visitor<'_> for GeneratedVisitor {
8034 type Value = GeneratedField;
8035
8036 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8037 write!(formatter, "expected one of: {:?}", &FIELDS)
8038 }
8039
8040 #[allow(unused_variables)]
8041 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8042 where
8043 E: serde::de::Error,
8044 {
8045 match value {
8046 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
8047 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8048 }
8049 }
8050 }
8051 deserializer.deserialize_identifier(GeneratedVisitor)
8052 }
8053 }
8054 struct GeneratedVisitor;
8055 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8056 type Value = LoadFinishMutation;
8057
8058 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8059 formatter.write_str("struct stream_plan.LoadFinishMutation")
8060 }
8061
8062 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LoadFinishMutation, V::Error>
8063 where
8064 V: serde::de::MapAccess<'de>,
8065 {
8066 let mut associated_source_id__ = None;
8067 while let Some(k) = map_.next_key()? {
8068 match k {
8069 GeneratedField::AssociatedSourceId => {
8070 if associated_source_id__.is_some() {
8071 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
8072 }
8073 associated_source_id__ =
8074 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8075 ;
8076 }
8077 }
8078 }
8079 Ok(LoadFinishMutation {
8080 associated_source_id: associated_source_id__.unwrap_or_default(),
8081 })
8082 }
8083 }
8084 deserializer.deserialize_struct("stream_plan.LoadFinishMutation", FIELDS, GeneratedVisitor)
8085 }
8086}
8087impl serde::Serialize for LocalApproxPercentileNode {
8088 #[allow(deprecated)]
8089 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8090 where
8091 S: serde::Serializer,
8092 {
8093 use serde::ser::SerializeStruct;
8094 let mut len = 0;
8095 if self.base != 0. {
8096 len += 1;
8097 }
8098 if self.percentile_index != 0 {
8099 len += 1;
8100 }
8101 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalApproxPercentileNode", len)?;
8102 if self.base != 0. {
8103 struct_ser.serialize_field("base", &self.base)?;
8104 }
8105 if self.percentile_index != 0 {
8106 struct_ser.serialize_field("percentileIndex", &self.percentile_index)?;
8107 }
8108 struct_ser.end()
8109 }
8110}
8111impl<'de> serde::Deserialize<'de> for LocalApproxPercentileNode {
8112 #[allow(deprecated)]
8113 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8114 where
8115 D: serde::Deserializer<'de>,
8116 {
8117 const FIELDS: &[&str] = &[
8118 "base",
8119 "percentile_index",
8120 "percentileIndex",
8121 ];
8122
8123 #[allow(clippy::enum_variant_names)]
8124 enum GeneratedField {
8125 Base,
8126 PercentileIndex,
8127 }
8128 impl<'de> serde::Deserialize<'de> for GeneratedField {
8129 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8130 where
8131 D: serde::Deserializer<'de>,
8132 {
8133 struct GeneratedVisitor;
8134
8135 impl serde::de::Visitor<'_> for GeneratedVisitor {
8136 type Value = GeneratedField;
8137
8138 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8139 write!(formatter, "expected one of: {:?}", &FIELDS)
8140 }
8141
8142 #[allow(unused_variables)]
8143 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8144 where
8145 E: serde::de::Error,
8146 {
8147 match value {
8148 "base" => Ok(GeneratedField::Base),
8149 "percentileIndex" | "percentile_index" => Ok(GeneratedField::PercentileIndex),
8150 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8151 }
8152 }
8153 }
8154 deserializer.deserialize_identifier(GeneratedVisitor)
8155 }
8156 }
8157 struct GeneratedVisitor;
8158 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8159 type Value = LocalApproxPercentileNode;
8160
8161 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8162 formatter.write_str("struct stream_plan.LocalApproxPercentileNode")
8163 }
8164
8165 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalApproxPercentileNode, V::Error>
8166 where
8167 V: serde::de::MapAccess<'de>,
8168 {
8169 let mut base__ = None;
8170 let mut percentile_index__ = None;
8171 while let Some(k) = map_.next_key()? {
8172 match k {
8173 GeneratedField::Base => {
8174 if base__.is_some() {
8175 return Err(serde::de::Error::duplicate_field("base"));
8176 }
8177 base__ =
8178 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8179 ;
8180 }
8181 GeneratedField::PercentileIndex => {
8182 if percentile_index__.is_some() {
8183 return Err(serde::de::Error::duplicate_field("percentileIndex"));
8184 }
8185 percentile_index__ =
8186 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8187 ;
8188 }
8189 }
8190 }
8191 Ok(LocalApproxPercentileNode {
8192 base: base__.unwrap_or_default(),
8193 percentile_index: percentile_index__.unwrap_or_default(),
8194 })
8195 }
8196 }
8197 deserializer.deserialize_struct("stream_plan.LocalApproxPercentileNode", FIELDS, GeneratedVisitor)
8198 }
8199}
8200impl serde::Serialize for LocalityProviderNode {
8201 #[allow(deprecated)]
8202 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8203 where
8204 S: serde::Serializer,
8205 {
8206 use serde::ser::SerializeStruct;
8207 let mut len = 0;
8208 if !self.locality_columns.is_empty() {
8209 len += 1;
8210 }
8211 if self.state_table.is_some() {
8212 len += 1;
8213 }
8214 if self.progress_table.is_some() {
8215 len += 1;
8216 }
8217 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalityProviderNode", len)?;
8218 if !self.locality_columns.is_empty() {
8219 struct_ser.serialize_field("localityColumns", &self.locality_columns)?;
8220 }
8221 if let Some(v) = self.state_table.as_ref() {
8222 struct_ser.serialize_field("stateTable", v)?;
8223 }
8224 if let Some(v) = self.progress_table.as_ref() {
8225 struct_ser.serialize_field("progressTable", v)?;
8226 }
8227 struct_ser.end()
8228 }
8229}
8230impl<'de> serde::Deserialize<'de> for LocalityProviderNode {
8231 #[allow(deprecated)]
8232 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8233 where
8234 D: serde::Deserializer<'de>,
8235 {
8236 const FIELDS: &[&str] = &[
8237 "locality_columns",
8238 "localityColumns",
8239 "state_table",
8240 "stateTable",
8241 "progress_table",
8242 "progressTable",
8243 ];
8244
8245 #[allow(clippy::enum_variant_names)]
8246 enum GeneratedField {
8247 LocalityColumns,
8248 StateTable,
8249 ProgressTable,
8250 }
8251 impl<'de> serde::Deserialize<'de> for GeneratedField {
8252 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8253 where
8254 D: serde::Deserializer<'de>,
8255 {
8256 struct GeneratedVisitor;
8257
8258 impl serde::de::Visitor<'_> for GeneratedVisitor {
8259 type Value = GeneratedField;
8260
8261 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8262 write!(formatter, "expected one of: {:?}", &FIELDS)
8263 }
8264
8265 #[allow(unused_variables)]
8266 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8267 where
8268 E: serde::de::Error,
8269 {
8270 match value {
8271 "localityColumns" | "locality_columns" => Ok(GeneratedField::LocalityColumns),
8272 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
8273 "progressTable" | "progress_table" => Ok(GeneratedField::ProgressTable),
8274 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8275 }
8276 }
8277 }
8278 deserializer.deserialize_identifier(GeneratedVisitor)
8279 }
8280 }
8281 struct GeneratedVisitor;
8282 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8283 type Value = LocalityProviderNode;
8284
8285 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8286 formatter.write_str("struct stream_plan.LocalityProviderNode")
8287 }
8288
8289 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalityProviderNode, V::Error>
8290 where
8291 V: serde::de::MapAccess<'de>,
8292 {
8293 let mut locality_columns__ = None;
8294 let mut state_table__ = None;
8295 let mut progress_table__ = None;
8296 while let Some(k) = map_.next_key()? {
8297 match k {
8298 GeneratedField::LocalityColumns => {
8299 if locality_columns__.is_some() {
8300 return Err(serde::de::Error::duplicate_field("localityColumns"));
8301 }
8302 locality_columns__ =
8303 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8304 .into_iter().map(|x| x.0).collect())
8305 ;
8306 }
8307 GeneratedField::StateTable => {
8308 if state_table__.is_some() {
8309 return Err(serde::de::Error::duplicate_field("stateTable"));
8310 }
8311 state_table__ = map_.next_value()?;
8312 }
8313 GeneratedField::ProgressTable => {
8314 if progress_table__.is_some() {
8315 return Err(serde::de::Error::duplicate_field("progressTable"));
8316 }
8317 progress_table__ = map_.next_value()?;
8318 }
8319 }
8320 }
8321 Ok(LocalityProviderNode {
8322 locality_columns: locality_columns__.unwrap_or_default(),
8323 state_table: state_table__,
8324 progress_table: progress_table__,
8325 })
8326 }
8327 }
8328 deserializer.deserialize_struct("stream_plan.LocalityProviderNode", FIELDS, GeneratedVisitor)
8329 }
8330}
8331impl serde::Serialize for LookupNode {
8332 #[allow(deprecated)]
8333 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8334 where
8335 S: serde::Serializer,
8336 {
8337 use serde::ser::SerializeStruct;
8338 let mut len = 0;
8339 if !self.arrange_key.is_empty() {
8340 len += 1;
8341 }
8342 if !self.stream_key.is_empty() {
8343 len += 1;
8344 }
8345 if self.use_current_epoch {
8346 len += 1;
8347 }
8348 if !self.column_mapping.is_empty() {
8349 len += 1;
8350 }
8351 if self.arrangement_table_info.is_some() {
8352 len += 1;
8353 }
8354 if self.arrangement_table_id.is_some() {
8355 len += 1;
8356 }
8357 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupNode", len)?;
8358 if !self.arrange_key.is_empty() {
8359 struct_ser.serialize_field("arrangeKey", &self.arrange_key)?;
8360 }
8361 if !self.stream_key.is_empty() {
8362 struct_ser.serialize_field("streamKey", &self.stream_key)?;
8363 }
8364 if self.use_current_epoch {
8365 struct_ser.serialize_field("useCurrentEpoch", &self.use_current_epoch)?;
8366 }
8367 if !self.column_mapping.is_empty() {
8368 struct_ser.serialize_field("columnMapping", &self.column_mapping)?;
8369 }
8370 if let Some(v) = self.arrangement_table_info.as_ref() {
8371 struct_ser.serialize_field("arrangementTableInfo", v)?;
8372 }
8373 if let Some(v) = self.arrangement_table_id.as_ref() {
8374 match v {
8375 lookup_node::ArrangementTableId::TableId(v) => {
8376 struct_ser.serialize_field("tableId", v)?;
8377 }
8378 lookup_node::ArrangementTableId::IndexId(v) => {
8379 struct_ser.serialize_field("indexId", v)?;
8380 }
8381 }
8382 }
8383 struct_ser.end()
8384 }
8385}
8386impl<'de> serde::Deserialize<'de> for LookupNode {
8387 #[allow(deprecated)]
8388 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8389 where
8390 D: serde::Deserializer<'de>,
8391 {
8392 const FIELDS: &[&str] = &[
8393 "arrange_key",
8394 "arrangeKey",
8395 "stream_key",
8396 "streamKey",
8397 "use_current_epoch",
8398 "useCurrentEpoch",
8399 "column_mapping",
8400 "columnMapping",
8401 "arrangement_table_info",
8402 "arrangementTableInfo",
8403 "table_id",
8404 "tableId",
8405 "index_id",
8406 "indexId",
8407 ];
8408
8409 #[allow(clippy::enum_variant_names)]
8410 enum GeneratedField {
8411 ArrangeKey,
8412 StreamKey,
8413 UseCurrentEpoch,
8414 ColumnMapping,
8415 ArrangementTableInfo,
8416 TableId,
8417 IndexId,
8418 }
8419 impl<'de> serde::Deserialize<'de> for GeneratedField {
8420 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8421 where
8422 D: serde::Deserializer<'de>,
8423 {
8424 struct GeneratedVisitor;
8425
8426 impl serde::de::Visitor<'_> for GeneratedVisitor {
8427 type Value = GeneratedField;
8428
8429 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8430 write!(formatter, "expected one of: {:?}", &FIELDS)
8431 }
8432
8433 #[allow(unused_variables)]
8434 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8435 where
8436 E: serde::de::Error,
8437 {
8438 match value {
8439 "arrangeKey" | "arrange_key" => Ok(GeneratedField::ArrangeKey),
8440 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
8441 "useCurrentEpoch" | "use_current_epoch" => Ok(GeneratedField::UseCurrentEpoch),
8442 "columnMapping" | "column_mapping" => Ok(GeneratedField::ColumnMapping),
8443 "arrangementTableInfo" | "arrangement_table_info" => Ok(GeneratedField::ArrangementTableInfo),
8444 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8445 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
8446 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8447 }
8448 }
8449 }
8450 deserializer.deserialize_identifier(GeneratedVisitor)
8451 }
8452 }
8453 struct GeneratedVisitor;
8454 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8455 type Value = LookupNode;
8456
8457 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8458 formatter.write_str("struct stream_plan.LookupNode")
8459 }
8460
8461 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupNode, V::Error>
8462 where
8463 V: serde::de::MapAccess<'de>,
8464 {
8465 let mut arrange_key__ = None;
8466 let mut stream_key__ = None;
8467 let mut use_current_epoch__ = None;
8468 let mut column_mapping__ = None;
8469 let mut arrangement_table_info__ = None;
8470 let mut arrangement_table_id__ = None;
8471 while let Some(k) = map_.next_key()? {
8472 match k {
8473 GeneratedField::ArrangeKey => {
8474 if arrange_key__.is_some() {
8475 return Err(serde::de::Error::duplicate_field("arrangeKey"));
8476 }
8477 arrange_key__ =
8478 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8479 .into_iter().map(|x| x.0).collect())
8480 ;
8481 }
8482 GeneratedField::StreamKey => {
8483 if stream_key__.is_some() {
8484 return Err(serde::de::Error::duplicate_field("streamKey"));
8485 }
8486 stream_key__ =
8487 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8488 .into_iter().map(|x| x.0).collect())
8489 ;
8490 }
8491 GeneratedField::UseCurrentEpoch => {
8492 if use_current_epoch__.is_some() {
8493 return Err(serde::de::Error::duplicate_field("useCurrentEpoch"));
8494 }
8495 use_current_epoch__ = Some(map_.next_value()?);
8496 }
8497 GeneratedField::ColumnMapping => {
8498 if column_mapping__.is_some() {
8499 return Err(serde::de::Error::duplicate_field("columnMapping"));
8500 }
8501 column_mapping__ =
8502 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8503 .into_iter().map(|x| x.0).collect())
8504 ;
8505 }
8506 GeneratedField::ArrangementTableInfo => {
8507 if arrangement_table_info__.is_some() {
8508 return Err(serde::de::Error::duplicate_field("arrangementTableInfo"));
8509 }
8510 arrangement_table_info__ = map_.next_value()?;
8511 }
8512 GeneratedField::TableId => {
8513 if arrangement_table_id__.is_some() {
8514 return Err(serde::de::Error::duplicate_field("tableId"));
8515 }
8516 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::TableId(x.0));
8517 }
8518 GeneratedField::IndexId => {
8519 if arrangement_table_id__.is_some() {
8520 return Err(serde::de::Error::duplicate_field("indexId"));
8521 }
8522 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::IndexId(x.0));
8523 }
8524 }
8525 }
8526 Ok(LookupNode {
8527 arrange_key: arrange_key__.unwrap_or_default(),
8528 stream_key: stream_key__.unwrap_or_default(),
8529 use_current_epoch: use_current_epoch__.unwrap_or_default(),
8530 column_mapping: column_mapping__.unwrap_or_default(),
8531 arrangement_table_info: arrangement_table_info__,
8532 arrangement_table_id: arrangement_table_id__,
8533 })
8534 }
8535 }
8536 deserializer.deserialize_struct("stream_plan.LookupNode", FIELDS, GeneratedVisitor)
8537 }
8538}
8539impl serde::Serialize for LookupUnionNode {
8540 #[allow(deprecated)]
8541 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8542 where
8543 S: serde::Serializer,
8544 {
8545 use serde::ser::SerializeStruct;
8546 let mut len = 0;
8547 if !self.order.is_empty() {
8548 len += 1;
8549 }
8550 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupUnionNode", len)?;
8551 if !self.order.is_empty() {
8552 struct_ser.serialize_field("order", &self.order)?;
8553 }
8554 struct_ser.end()
8555 }
8556}
8557impl<'de> serde::Deserialize<'de> for LookupUnionNode {
8558 #[allow(deprecated)]
8559 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8560 where
8561 D: serde::Deserializer<'de>,
8562 {
8563 const FIELDS: &[&str] = &[
8564 "order",
8565 ];
8566
8567 #[allow(clippy::enum_variant_names)]
8568 enum GeneratedField {
8569 Order,
8570 }
8571 impl<'de> serde::Deserialize<'de> for GeneratedField {
8572 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8573 where
8574 D: serde::Deserializer<'de>,
8575 {
8576 struct GeneratedVisitor;
8577
8578 impl serde::de::Visitor<'_> for GeneratedVisitor {
8579 type Value = GeneratedField;
8580
8581 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8582 write!(formatter, "expected one of: {:?}", &FIELDS)
8583 }
8584
8585 #[allow(unused_variables)]
8586 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8587 where
8588 E: serde::de::Error,
8589 {
8590 match value {
8591 "order" => Ok(GeneratedField::Order),
8592 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8593 }
8594 }
8595 }
8596 deserializer.deserialize_identifier(GeneratedVisitor)
8597 }
8598 }
8599 struct GeneratedVisitor;
8600 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8601 type Value = LookupUnionNode;
8602
8603 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8604 formatter.write_str("struct stream_plan.LookupUnionNode")
8605 }
8606
8607 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupUnionNode, V::Error>
8608 where
8609 V: serde::de::MapAccess<'de>,
8610 {
8611 let mut order__ = None;
8612 while let Some(k) = map_.next_key()? {
8613 match k {
8614 GeneratedField::Order => {
8615 if order__.is_some() {
8616 return Err(serde::de::Error::duplicate_field("order"));
8617 }
8618 order__ =
8619 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8620 .into_iter().map(|x| x.0).collect())
8621 ;
8622 }
8623 }
8624 }
8625 Ok(LookupUnionNode {
8626 order: order__.unwrap_or_default(),
8627 })
8628 }
8629 }
8630 deserializer.deserialize_struct("stream_plan.LookupUnionNode", FIELDS, GeneratedVisitor)
8631 }
8632}
8633impl serde::Serialize for MaterializeNode {
8634 #[allow(deprecated)]
8635 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8636 where
8637 S: serde::Serializer,
8638 {
8639 use serde::ser::SerializeStruct;
8640 let mut len = 0;
8641 if self.table_id != 0 {
8642 len += 1;
8643 }
8644 if !self.column_orders.is_empty() {
8645 len += 1;
8646 }
8647 if self.table.is_some() {
8648 len += 1;
8649 }
8650 if self.staging_table.is_some() {
8651 len += 1;
8652 }
8653 if self.refresh_progress_table.is_some() {
8654 len += 1;
8655 }
8656 if self.cleaned_by_ttl_watermark {
8657 len += 1;
8658 }
8659 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializeNode", len)?;
8660 if self.table_id != 0 {
8661 struct_ser.serialize_field("tableId", &self.table_id)?;
8662 }
8663 if !self.column_orders.is_empty() {
8664 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
8665 }
8666 if let Some(v) = self.table.as_ref() {
8667 struct_ser.serialize_field("table", v)?;
8668 }
8669 if let Some(v) = self.staging_table.as_ref() {
8670 struct_ser.serialize_field("stagingTable", v)?;
8671 }
8672 if let Some(v) = self.refresh_progress_table.as_ref() {
8673 struct_ser.serialize_field("refreshProgressTable", v)?;
8674 }
8675 if self.cleaned_by_ttl_watermark {
8676 struct_ser.serialize_field("cleanedByTtlWatermark", &self.cleaned_by_ttl_watermark)?;
8677 }
8678 struct_ser.end()
8679 }
8680}
8681impl<'de> serde::Deserialize<'de> for MaterializeNode {
8682 #[allow(deprecated)]
8683 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8684 where
8685 D: serde::Deserializer<'de>,
8686 {
8687 const FIELDS: &[&str] = &[
8688 "table_id",
8689 "tableId",
8690 "column_orders",
8691 "columnOrders",
8692 "table",
8693 "staging_table",
8694 "stagingTable",
8695 "refresh_progress_table",
8696 "refreshProgressTable",
8697 "cleaned_by_ttl_watermark",
8698 "cleanedByTtlWatermark",
8699 ];
8700
8701 #[allow(clippy::enum_variant_names)]
8702 enum GeneratedField {
8703 TableId,
8704 ColumnOrders,
8705 Table,
8706 StagingTable,
8707 RefreshProgressTable,
8708 CleanedByTtlWatermark,
8709 }
8710 impl<'de> serde::Deserialize<'de> for GeneratedField {
8711 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8712 where
8713 D: serde::Deserializer<'de>,
8714 {
8715 struct GeneratedVisitor;
8716
8717 impl serde::de::Visitor<'_> for GeneratedVisitor {
8718 type Value = GeneratedField;
8719
8720 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8721 write!(formatter, "expected one of: {:?}", &FIELDS)
8722 }
8723
8724 #[allow(unused_variables)]
8725 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8726 where
8727 E: serde::de::Error,
8728 {
8729 match value {
8730 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8731 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
8732 "table" => Ok(GeneratedField::Table),
8733 "stagingTable" | "staging_table" => Ok(GeneratedField::StagingTable),
8734 "refreshProgressTable" | "refresh_progress_table" => Ok(GeneratedField::RefreshProgressTable),
8735 "cleanedByTtlWatermark" | "cleaned_by_ttl_watermark" => Ok(GeneratedField::CleanedByTtlWatermark),
8736 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8737 }
8738 }
8739 }
8740 deserializer.deserialize_identifier(GeneratedVisitor)
8741 }
8742 }
8743 struct GeneratedVisitor;
8744 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8745 type Value = MaterializeNode;
8746
8747 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8748 formatter.write_str("struct stream_plan.MaterializeNode")
8749 }
8750
8751 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializeNode, V::Error>
8752 where
8753 V: serde::de::MapAccess<'de>,
8754 {
8755 let mut table_id__ = None;
8756 let mut column_orders__ = None;
8757 let mut table__ = None;
8758 let mut staging_table__ = None;
8759 let mut refresh_progress_table__ = None;
8760 let mut cleaned_by_ttl_watermark__ = None;
8761 while let Some(k) = map_.next_key()? {
8762 match k {
8763 GeneratedField::TableId => {
8764 if table_id__.is_some() {
8765 return Err(serde::de::Error::duplicate_field("tableId"));
8766 }
8767 table_id__ =
8768 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8769 ;
8770 }
8771 GeneratedField::ColumnOrders => {
8772 if column_orders__.is_some() {
8773 return Err(serde::de::Error::duplicate_field("columnOrders"));
8774 }
8775 column_orders__ = Some(map_.next_value()?);
8776 }
8777 GeneratedField::Table => {
8778 if table__.is_some() {
8779 return Err(serde::de::Error::duplicate_field("table"));
8780 }
8781 table__ = map_.next_value()?;
8782 }
8783 GeneratedField::StagingTable => {
8784 if staging_table__.is_some() {
8785 return Err(serde::de::Error::duplicate_field("stagingTable"));
8786 }
8787 staging_table__ = map_.next_value()?;
8788 }
8789 GeneratedField::RefreshProgressTable => {
8790 if refresh_progress_table__.is_some() {
8791 return Err(serde::de::Error::duplicate_field("refreshProgressTable"));
8792 }
8793 refresh_progress_table__ = map_.next_value()?;
8794 }
8795 GeneratedField::CleanedByTtlWatermark => {
8796 if cleaned_by_ttl_watermark__.is_some() {
8797 return Err(serde::de::Error::duplicate_field("cleanedByTtlWatermark"));
8798 }
8799 cleaned_by_ttl_watermark__ = Some(map_.next_value()?);
8800 }
8801 }
8802 }
8803 Ok(MaterializeNode {
8804 table_id: table_id__.unwrap_or_default(),
8805 column_orders: column_orders__.unwrap_or_default(),
8806 table: table__,
8807 staging_table: staging_table__,
8808 refresh_progress_table: refresh_progress_table__,
8809 cleaned_by_ttl_watermark: cleaned_by_ttl_watermark__.unwrap_or_default(),
8810 })
8811 }
8812 }
8813 deserializer.deserialize_struct("stream_plan.MaterializeNode", FIELDS, GeneratedVisitor)
8814 }
8815}
8816impl serde::Serialize for MaterializedExprsNode {
8817 #[allow(deprecated)]
8818 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8819 where
8820 S: serde::Serializer,
8821 {
8822 use serde::ser::SerializeStruct;
8823 let mut len = 0;
8824 if !self.exprs.is_empty() {
8825 len += 1;
8826 }
8827 if self.state_table.is_some() {
8828 len += 1;
8829 }
8830 if self.state_clean_col_idx.is_some() {
8831 len += 1;
8832 }
8833 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializedExprsNode", len)?;
8834 if !self.exprs.is_empty() {
8835 struct_ser.serialize_field("exprs", &self.exprs)?;
8836 }
8837 if let Some(v) = self.state_table.as_ref() {
8838 struct_ser.serialize_field("stateTable", v)?;
8839 }
8840 if let Some(v) = self.state_clean_col_idx.as_ref() {
8841 struct_ser.serialize_field("stateCleanColIdx", v)?;
8842 }
8843 struct_ser.end()
8844 }
8845}
8846impl<'de> serde::Deserialize<'de> for MaterializedExprsNode {
8847 #[allow(deprecated)]
8848 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8849 where
8850 D: serde::Deserializer<'de>,
8851 {
8852 const FIELDS: &[&str] = &[
8853 "exprs",
8854 "state_table",
8855 "stateTable",
8856 "state_clean_col_idx",
8857 "stateCleanColIdx",
8858 ];
8859
8860 #[allow(clippy::enum_variant_names)]
8861 enum GeneratedField {
8862 Exprs,
8863 StateTable,
8864 StateCleanColIdx,
8865 }
8866 impl<'de> serde::Deserialize<'de> for GeneratedField {
8867 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8868 where
8869 D: serde::Deserializer<'de>,
8870 {
8871 struct GeneratedVisitor;
8872
8873 impl serde::de::Visitor<'_> for GeneratedVisitor {
8874 type Value = GeneratedField;
8875
8876 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8877 write!(formatter, "expected one of: {:?}", &FIELDS)
8878 }
8879
8880 #[allow(unused_variables)]
8881 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8882 where
8883 E: serde::de::Error,
8884 {
8885 match value {
8886 "exprs" => Ok(GeneratedField::Exprs),
8887 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
8888 "stateCleanColIdx" | "state_clean_col_idx" => Ok(GeneratedField::StateCleanColIdx),
8889 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8890 }
8891 }
8892 }
8893 deserializer.deserialize_identifier(GeneratedVisitor)
8894 }
8895 }
8896 struct GeneratedVisitor;
8897 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8898 type Value = MaterializedExprsNode;
8899
8900 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8901 formatter.write_str("struct stream_plan.MaterializedExprsNode")
8902 }
8903
8904 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializedExprsNode, V::Error>
8905 where
8906 V: serde::de::MapAccess<'de>,
8907 {
8908 let mut exprs__ = None;
8909 let mut state_table__ = None;
8910 let mut state_clean_col_idx__ = None;
8911 while let Some(k) = map_.next_key()? {
8912 match k {
8913 GeneratedField::Exprs => {
8914 if exprs__.is_some() {
8915 return Err(serde::de::Error::duplicate_field("exprs"));
8916 }
8917 exprs__ = Some(map_.next_value()?);
8918 }
8919 GeneratedField::StateTable => {
8920 if state_table__.is_some() {
8921 return Err(serde::de::Error::duplicate_field("stateTable"));
8922 }
8923 state_table__ = map_.next_value()?;
8924 }
8925 GeneratedField::StateCleanColIdx => {
8926 if state_clean_col_idx__.is_some() {
8927 return Err(serde::de::Error::duplicate_field("stateCleanColIdx"));
8928 }
8929 state_clean_col_idx__ =
8930 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
8931 ;
8932 }
8933 }
8934 }
8935 Ok(MaterializedExprsNode {
8936 exprs: exprs__.unwrap_or_default(),
8937 state_table: state_table__,
8938 state_clean_col_idx: state_clean_col_idx__,
8939 })
8940 }
8941 }
8942 deserializer.deserialize_struct("stream_plan.MaterializedExprsNode", FIELDS, GeneratedVisitor)
8943 }
8944}
8945impl serde::Serialize for MergeNode {
8946 #[allow(deprecated)]
8947 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8948 where
8949 S: serde::Serializer,
8950 {
8951 use serde::ser::SerializeStruct;
8952 let mut len = 0;
8953 if !self.upstream_actor_id.is_empty() {
8954 len += 1;
8955 }
8956 if self.upstream_fragment_id != 0 {
8957 len += 1;
8958 }
8959 if self.upstream_dispatcher_type != 0 {
8960 len += 1;
8961 }
8962 if !self.fields.is_empty() {
8963 len += 1;
8964 }
8965 if self.allow_no_initial_upstream {
8966 len += 1;
8967 }
8968 let mut struct_ser = serializer.serialize_struct("stream_plan.MergeNode", len)?;
8969 if !self.upstream_actor_id.is_empty() {
8970 struct_ser.serialize_field("upstreamActorId", &self.upstream_actor_id)?;
8971 }
8972 if self.upstream_fragment_id != 0 {
8973 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
8974 }
8975 if self.upstream_dispatcher_type != 0 {
8976 let v = DispatcherType::try_from(self.upstream_dispatcher_type)
8977 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.upstream_dispatcher_type)))?;
8978 struct_ser.serialize_field("upstreamDispatcherType", &v)?;
8979 }
8980 if !self.fields.is_empty() {
8981 struct_ser.serialize_field("fields", &self.fields)?;
8982 }
8983 if self.allow_no_initial_upstream {
8984 struct_ser.serialize_field("allowNoInitialUpstream", &self.allow_no_initial_upstream)?;
8985 }
8986 struct_ser.end()
8987 }
8988}
8989impl<'de> serde::Deserialize<'de> for MergeNode {
8990 #[allow(deprecated)]
8991 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8992 where
8993 D: serde::Deserializer<'de>,
8994 {
8995 const FIELDS: &[&str] = &[
8996 "upstream_actor_id",
8997 "upstreamActorId",
8998 "upstream_fragment_id",
8999 "upstreamFragmentId",
9000 "upstream_dispatcher_type",
9001 "upstreamDispatcherType",
9002 "fields",
9003 "allow_no_initial_upstream",
9004 "allowNoInitialUpstream",
9005 ];
9006
9007 #[allow(clippy::enum_variant_names)]
9008 enum GeneratedField {
9009 UpstreamActorId,
9010 UpstreamFragmentId,
9011 UpstreamDispatcherType,
9012 Fields,
9013 AllowNoInitialUpstream,
9014 }
9015 impl<'de> serde::Deserialize<'de> for GeneratedField {
9016 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9017 where
9018 D: serde::Deserializer<'de>,
9019 {
9020 struct GeneratedVisitor;
9021
9022 impl serde::de::Visitor<'_> for GeneratedVisitor {
9023 type Value = GeneratedField;
9024
9025 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9026 write!(formatter, "expected one of: {:?}", &FIELDS)
9027 }
9028
9029 #[allow(unused_variables)]
9030 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9031 where
9032 E: serde::de::Error,
9033 {
9034 match value {
9035 "upstreamActorId" | "upstream_actor_id" => Ok(GeneratedField::UpstreamActorId),
9036 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
9037 "upstreamDispatcherType" | "upstream_dispatcher_type" => Ok(GeneratedField::UpstreamDispatcherType),
9038 "fields" => Ok(GeneratedField::Fields),
9039 "allowNoInitialUpstream" | "allow_no_initial_upstream" => Ok(GeneratedField::AllowNoInitialUpstream),
9040 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9041 }
9042 }
9043 }
9044 deserializer.deserialize_identifier(GeneratedVisitor)
9045 }
9046 }
9047 struct GeneratedVisitor;
9048 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9049 type Value = MergeNode;
9050
9051 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9052 formatter.write_str("struct stream_plan.MergeNode")
9053 }
9054
9055 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeNode, V::Error>
9056 where
9057 V: serde::de::MapAccess<'de>,
9058 {
9059 let mut upstream_actor_id__ = None;
9060 let mut upstream_fragment_id__ = None;
9061 let mut upstream_dispatcher_type__ = None;
9062 let mut fields__ = None;
9063 let mut allow_no_initial_upstream__ = None;
9064 while let Some(k) = map_.next_key()? {
9065 match k {
9066 GeneratedField::UpstreamActorId => {
9067 if upstream_actor_id__.is_some() {
9068 return Err(serde::de::Error::duplicate_field("upstreamActorId"));
9069 }
9070 upstream_actor_id__ =
9071 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9072 .into_iter().map(|x| x.0).collect())
9073 ;
9074 }
9075 GeneratedField::UpstreamFragmentId => {
9076 if upstream_fragment_id__.is_some() {
9077 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
9078 }
9079 upstream_fragment_id__ =
9080 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9081 ;
9082 }
9083 GeneratedField::UpstreamDispatcherType => {
9084 if upstream_dispatcher_type__.is_some() {
9085 return Err(serde::de::Error::duplicate_field("upstreamDispatcherType"));
9086 }
9087 upstream_dispatcher_type__ = Some(map_.next_value::<DispatcherType>()? as i32);
9088 }
9089 GeneratedField::Fields => {
9090 if fields__.is_some() {
9091 return Err(serde::de::Error::duplicate_field("fields"));
9092 }
9093 fields__ = Some(map_.next_value()?);
9094 }
9095 GeneratedField::AllowNoInitialUpstream => {
9096 if allow_no_initial_upstream__.is_some() {
9097 return Err(serde::de::Error::duplicate_field("allowNoInitialUpstream"));
9098 }
9099 allow_no_initial_upstream__ = Some(map_.next_value()?);
9100 }
9101 }
9102 }
9103 Ok(MergeNode {
9104 upstream_actor_id: upstream_actor_id__.unwrap_or_default(),
9105 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
9106 upstream_dispatcher_type: upstream_dispatcher_type__.unwrap_or_default(),
9107 fields: fields__.unwrap_or_default(),
9108 allow_no_initial_upstream: allow_no_initial_upstream__.unwrap_or_default(),
9109 })
9110 }
9111 }
9112 deserializer.deserialize_struct("stream_plan.MergeNode", FIELDS, GeneratedVisitor)
9113 }
9114}
9115impl serde::Serialize for NoOpNode {
9116 #[allow(deprecated)]
9117 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9118 where
9119 S: serde::Serializer,
9120 {
9121 use serde::ser::SerializeStruct;
9122 let len = 0;
9123 let struct_ser = serializer.serialize_struct("stream_plan.NoOpNode", len)?;
9124 struct_ser.end()
9125 }
9126}
9127impl<'de> serde::Deserialize<'de> for NoOpNode {
9128 #[allow(deprecated)]
9129 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9130 where
9131 D: serde::Deserializer<'de>,
9132 {
9133 const FIELDS: &[&str] = &[
9134 ];
9135
9136 #[allow(clippy::enum_variant_names)]
9137 enum GeneratedField {
9138 }
9139 impl<'de> serde::Deserialize<'de> for GeneratedField {
9140 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9141 where
9142 D: serde::Deserializer<'de>,
9143 {
9144 struct GeneratedVisitor;
9145
9146 impl serde::de::Visitor<'_> for GeneratedVisitor {
9147 type Value = GeneratedField;
9148
9149 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9150 write!(formatter, "expected one of: {:?}", &FIELDS)
9151 }
9152
9153 #[allow(unused_variables)]
9154 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9155 where
9156 E: serde::de::Error,
9157 {
9158 Err(serde::de::Error::unknown_field(value, FIELDS))
9159 }
9160 }
9161 deserializer.deserialize_identifier(GeneratedVisitor)
9162 }
9163 }
9164 struct GeneratedVisitor;
9165 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9166 type Value = NoOpNode;
9167
9168 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9169 formatter.write_str("struct stream_plan.NoOpNode")
9170 }
9171
9172 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NoOpNode, V::Error>
9173 where
9174 V: serde::de::MapAccess<'de>,
9175 {
9176 while map_.next_key::<GeneratedField>()?.is_some() {
9177 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9178 }
9179 Ok(NoOpNode {
9180 })
9181 }
9182 }
9183 deserializer.deserialize_struct("stream_plan.NoOpNode", FIELDS, GeneratedVisitor)
9184 }
9185}
9186impl serde::Serialize for NowModeGenerateSeries {
9187 #[allow(deprecated)]
9188 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9189 where
9190 S: serde::Serializer,
9191 {
9192 use serde::ser::SerializeStruct;
9193 let mut len = 0;
9194 if self.start_timestamp.is_some() {
9195 len += 1;
9196 }
9197 if self.interval.is_some() {
9198 len += 1;
9199 }
9200 let mut struct_ser = serializer.serialize_struct("stream_plan.NowModeGenerateSeries", len)?;
9201 if let Some(v) = self.start_timestamp.as_ref() {
9202 struct_ser.serialize_field("startTimestamp", v)?;
9203 }
9204 if let Some(v) = self.interval.as_ref() {
9205 struct_ser.serialize_field("interval", v)?;
9206 }
9207 struct_ser.end()
9208 }
9209}
9210impl<'de> serde::Deserialize<'de> for NowModeGenerateSeries {
9211 #[allow(deprecated)]
9212 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9213 where
9214 D: serde::Deserializer<'de>,
9215 {
9216 const FIELDS: &[&str] = &[
9217 "start_timestamp",
9218 "startTimestamp",
9219 "interval",
9220 ];
9221
9222 #[allow(clippy::enum_variant_names)]
9223 enum GeneratedField {
9224 StartTimestamp,
9225 Interval,
9226 }
9227 impl<'de> serde::Deserialize<'de> for GeneratedField {
9228 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9229 where
9230 D: serde::Deserializer<'de>,
9231 {
9232 struct GeneratedVisitor;
9233
9234 impl serde::de::Visitor<'_> for GeneratedVisitor {
9235 type Value = GeneratedField;
9236
9237 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9238 write!(formatter, "expected one of: {:?}", &FIELDS)
9239 }
9240
9241 #[allow(unused_variables)]
9242 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9243 where
9244 E: serde::de::Error,
9245 {
9246 match value {
9247 "startTimestamp" | "start_timestamp" => Ok(GeneratedField::StartTimestamp),
9248 "interval" => Ok(GeneratedField::Interval),
9249 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9250 }
9251 }
9252 }
9253 deserializer.deserialize_identifier(GeneratedVisitor)
9254 }
9255 }
9256 struct GeneratedVisitor;
9257 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9258 type Value = NowModeGenerateSeries;
9259
9260 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9261 formatter.write_str("struct stream_plan.NowModeGenerateSeries")
9262 }
9263
9264 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeGenerateSeries, V::Error>
9265 where
9266 V: serde::de::MapAccess<'de>,
9267 {
9268 let mut start_timestamp__ = None;
9269 let mut interval__ = None;
9270 while let Some(k) = map_.next_key()? {
9271 match k {
9272 GeneratedField::StartTimestamp => {
9273 if start_timestamp__.is_some() {
9274 return Err(serde::de::Error::duplicate_field("startTimestamp"));
9275 }
9276 start_timestamp__ = map_.next_value()?;
9277 }
9278 GeneratedField::Interval => {
9279 if interval__.is_some() {
9280 return Err(serde::de::Error::duplicate_field("interval"));
9281 }
9282 interval__ = map_.next_value()?;
9283 }
9284 }
9285 }
9286 Ok(NowModeGenerateSeries {
9287 start_timestamp: start_timestamp__,
9288 interval: interval__,
9289 })
9290 }
9291 }
9292 deserializer.deserialize_struct("stream_plan.NowModeGenerateSeries", FIELDS, GeneratedVisitor)
9293 }
9294}
9295impl serde::Serialize for NowModeUpdateCurrent {
9296 #[allow(deprecated)]
9297 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9298 where
9299 S: serde::Serializer,
9300 {
9301 use serde::ser::SerializeStruct;
9302 let len = 0;
9303 let struct_ser = serializer.serialize_struct("stream_plan.NowModeUpdateCurrent", len)?;
9304 struct_ser.end()
9305 }
9306}
9307impl<'de> serde::Deserialize<'de> for NowModeUpdateCurrent {
9308 #[allow(deprecated)]
9309 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9310 where
9311 D: serde::Deserializer<'de>,
9312 {
9313 const FIELDS: &[&str] = &[
9314 ];
9315
9316 #[allow(clippy::enum_variant_names)]
9317 enum GeneratedField {
9318 }
9319 impl<'de> serde::Deserialize<'de> for GeneratedField {
9320 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9321 where
9322 D: serde::Deserializer<'de>,
9323 {
9324 struct GeneratedVisitor;
9325
9326 impl serde::de::Visitor<'_> for GeneratedVisitor {
9327 type Value = GeneratedField;
9328
9329 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9330 write!(formatter, "expected one of: {:?}", &FIELDS)
9331 }
9332
9333 #[allow(unused_variables)]
9334 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9335 where
9336 E: serde::de::Error,
9337 {
9338 Err(serde::de::Error::unknown_field(value, FIELDS))
9339 }
9340 }
9341 deserializer.deserialize_identifier(GeneratedVisitor)
9342 }
9343 }
9344 struct GeneratedVisitor;
9345 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9346 type Value = NowModeUpdateCurrent;
9347
9348 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9349 formatter.write_str("struct stream_plan.NowModeUpdateCurrent")
9350 }
9351
9352 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeUpdateCurrent, V::Error>
9353 where
9354 V: serde::de::MapAccess<'de>,
9355 {
9356 while map_.next_key::<GeneratedField>()?.is_some() {
9357 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9358 }
9359 Ok(NowModeUpdateCurrent {
9360 })
9361 }
9362 }
9363 deserializer.deserialize_struct("stream_plan.NowModeUpdateCurrent", FIELDS, GeneratedVisitor)
9364 }
9365}
9366impl serde::Serialize for NowNode {
9367 #[allow(deprecated)]
9368 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9369 where
9370 S: serde::Serializer,
9371 {
9372 use serde::ser::SerializeStruct;
9373 let mut len = 0;
9374 if self.state_table.is_some() {
9375 len += 1;
9376 }
9377 if self.mode.is_some() {
9378 len += 1;
9379 }
9380 let mut struct_ser = serializer.serialize_struct("stream_plan.NowNode", len)?;
9381 if let Some(v) = self.state_table.as_ref() {
9382 struct_ser.serialize_field("stateTable", v)?;
9383 }
9384 if let Some(v) = self.mode.as_ref() {
9385 match v {
9386 now_node::Mode::UpdateCurrent(v) => {
9387 struct_ser.serialize_field("updateCurrent", v)?;
9388 }
9389 now_node::Mode::GenerateSeries(v) => {
9390 struct_ser.serialize_field("generateSeries", v)?;
9391 }
9392 }
9393 }
9394 struct_ser.end()
9395 }
9396}
9397impl<'de> serde::Deserialize<'de> for NowNode {
9398 #[allow(deprecated)]
9399 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9400 where
9401 D: serde::Deserializer<'de>,
9402 {
9403 const FIELDS: &[&str] = &[
9404 "state_table",
9405 "stateTable",
9406 "update_current",
9407 "updateCurrent",
9408 "generate_series",
9409 "generateSeries",
9410 ];
9411
9412 #[allow(clippy::enum_variant_names)]
9413 enum GeneratedField {
9414 StateTable,
9415 UpdateCurrent,
9416 GenerateSeries,
9417 }
9418 impl<'de> serde::Deserialize<'de> for GeneratedField {
9419 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9420 where
9421 D: serde::Deserializer<'de>,
9422 {
9423 struct GeneratedVisitor;
9424
9425 impl serde::de::Visitor<'_> for GeneratedVisitor {
9426 type Value = GeneratedField;
9427
9428 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9429 write!(formatter, "expected one of: {:?}", &FIELDS)
9430 }
9431
9432 #[allow(unused_variables)]
9433 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9434 where
9435 E: serde::de::Error,
9436 {
9437 match value {
9438 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9439 "updateCurrent" | "update_current" => Ok(GeneratedField::UpdateCurrent),
9440 "generateSeries" | "generate_series" => Ok(GeneratedField::GenerateSeries),
9441 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9442 }
9443 }
9444 }
9445 deserializer.deserialize_identifier(GeneratedVisitor)
9446 }
9447 }
9448 struct GeneratedVisitor;
9449 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9450 type Value = NowNode;
9451
9452 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9453 formatter.write_str("struct stream_plan.NowNode")
9454 }
9455
9456 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowNode, V::Error>
9457 where
9458 V: serde::de::MapAccess<'de>,
9459 {
9460 let mut state_table__ = None;
9461 let mut mode__ = None;
9462 while let Some(k) = map_.next_key()? {
9463 match k {
9464 GeneratedField::StateTable => {
9465 if state_table__.is_some() {
9466 return Err(serde::de::Error::duplicate_field("stateTable"));
9467 }
9468 state_table__ = map_.next_value()?;
9469 }
9470 GeneratedField::UpdateCurrent => {
9471 if mode__.is_some() {
9472 return Err(serde::de::Error::duplicate_field("updateCurrent"));
9473 }
9474 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::UpdateCurrent)
9475;
9476 }
9477 GeneratedField::GenerateSeries => {
9478 if mode__.is_some() {
9479 return Err(serde::de::Error::duplicate_field("generateSeries"));
9480 }
9481 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::GenerateSeries)
9482;
9483 }
9484 }
9485 }
9486 Ok(NowNode {
9487 state_table: state_table__,
9488 mode: mode__,
9489 })
9490 }
9491 }
9492 deserializer.deserialize_struct("stream_plan.NowNode", FIELDS, GeneratedVisitor)
9493 }
9494}
9495impl serde::Serialize for OverWindowCachePolicy {
9496 #[allow(deprecated)]
9497 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9498 where
9499 S: serde::Serializer,
9500 {
9501 let variant = match self {
9502 Self::Unspecified => "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
9503 Self::Full => "OVER_WINDOW_CACHE_POLICY_FULL",
9504 Self::Recent => "OVER_WINDOW_CACHE_POLICY_RECENT",
9505 Self::RecentFirstN => "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
9506 Self::RecentLastN => "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
9507 };
9508 serializer.serialize_str(variant)
9509 }
9510}
9511impl<'de> serde::Deserialize<'de> for OverWindowCachePolicy {
9512 #[allow(deprecated)]
9513 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9514 where
9515 D: serde::Deserializer<'de>,
9516 {
9517 const FIELDS: &[&str] = &[
9518 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
9519 "OVER_WINDOW_CACHE_POLICY_FULL",
9520 "OVER_WINDOW_CACHE_POLICY_RECENT",
9521 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
9522 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
9523 ];
9524
9525 struct GeneratedVisitor;
9526
9527 impl serde::de::Visitor<'_> for GeneratedVisitor {
9528 type Value = OverWindowCachePolicy;
9529
9530 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9531 write!(formatter, "expected one of: {:?}", &FIELDS)
9532 }
9533
9534 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9535 where
9536 E: serde::de::Error,
9537 {
9538 i32::try_from(v)
9539 .ok()
9540 .and_then(|x| x.try_into().ok())
9541 .ok_or_else(|| {
9542 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9543 })
9544 }
9545
9546 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9547 where
9548 E: serde::de::Error,
9549 {
9550 i32::try_from(v)
9551 .ok()
9552 .and_then(|x| x.try_into().ok())
9553 .ok_or_else(|| {
9554 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9555 })
9556 }
9557
9558 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9559 where
9560 E: serde::de::Error,
9561 {
9562 match value {
9563 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED" => Ok(OverWindowCachePolicy::Unspecified),
9564 "OVER_WINDOW_CACHE_POLICY_FULL" => Ok(OverWindowCachePolicy::Full),
9565 "OVER_WINDOW_CACHE_POLICY_RECENT" => Ok(OverWindowCachePolicy::Recent),
9566 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N" => Ok(OverWindowCachePolicy::RecentFirstN),
9567 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N" => Ok(OverWindowCachePolicy::RecentLastN),
9568 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9569 }
9570 }
9571 }
9572 deserializer.deserialize_any(GeneratedVisitor)
9573 }
9574}
9575impl serde::Serialize for OverWindowNode {
9576 #[allow(deprecated)]
9577 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9578 where
9579 S: serde::Serializer,
9580 {
9581 use serde::ser::SerializeStruct;
9582 let mut len = 0;
9583 if !self.calls.is_empty() {
9584 len += 1;
9585 }
9586 if !self.partition_by.is_empty() {
9587 len += 1;
9588 }
9589 if !self.order_by.is_empty() {
9590 len += 1;
9591 }
9592 if self.state_table.is_some() {
9593 len += 1;
9594 }
9595 if self.cache_policy != 0 {
9596 len += 1;
9597 }
9598 let mut struct_ser = serializer.serialize_struct("stream_plan.OverWindowNode", len)?;
9599 if !self.calls.is_empty() {
9600 struct_ser.serialize_field("calls", &self.calls)?;
9601 }
9602 if !self.partition_by.is_empty() {
9603 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
9604 }
9605 if !self.order_by.is_empty() {
9606 struct_ser.serialize_field("orderBy", &self.order_by)?;
9607 }
9608 if let Some(v) = self.state_table.as_ref() {
9609 struct_ser.serialize_field("stateTable", v)?;
9610 }
9611 if self.cache_policy != 0 {
9612 let v = OverWindowCachePolicy::try_from(self.cache_policy)
9613 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cache_policy)))?;
9614 struct_ser.serialize_field("cachePolicy", &v)?;
9615 }
9616 struct_ser.end()
9617 }
9618}
9619impl<'de> serde::Deserialize<'de> for OverWindowNode {
9620 #[allow(deprecated)]
9621 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9622 where
9623 D: serde::Deserializer<'de>,
9624 {
9625 const FIELDS: &[&str] = &[
9626 "calls",
9627 "partition_by",
9628 "partitionBy",
9629 "order_by",
9630 "orderBy",
9631 "state_table",
9632 "stateTable",
9633 "cache_policy",
9634 "cachePolicy",
9635 ];
9636
9637 #[allow(clippy::enum_variant_names)]
9638 enum GeneratedField {
9639 Calls,
9640 PartitionBy,
9641 OrderBy,
9642 StateTable,
9643 CachePolicy,
9644 }
9645 impl<'de> serde::Deserialize<'de> for GeneratedField {
9646 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9647 where
9648 D: serde::Deserializer<'de>,
9649 {
9650 struct GeneratedVisitor;
9651
9652 impl serde::de::Visitor<'_> for GeneratedVisitor {
9653 type Value = GeneratedField;
9654
9655 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9656 write!(formatter, "expected one of: {:?}", &FIELDS)
9657 }
9658
9659 #[allow(unused_variables)]
9660 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9661 where
9662 E: serde::de::Error,
9663 {
9664 match value {
9665 "calls" => Ok(GeneratedField::Calls),
9666 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
9667 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
9668 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9669 "cachePolicy" | "cache_policy" => Ok(GeneratedField::CachePolicy),
9670 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9671 }
9672 }
9673 }
9674 deserializer.deserialize_identifier(GeneratedVisitor)
9675 }
9676 }
9677 struct GeneratedVisitor;
9678 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9679 type Value = OverWindowNode;
9680
9681 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9682 formatter.write_str("struct stream_plan.OverWindowNode")
9683 }
9684
9685 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverWindowNode, V::Error>
9686 where
9687 V: serde::de::MapAccess<'de>,
9688 {
9689 let mut calls__ = None;
9690 let mut partition_by__ = None;
9691 let mut order_by__ = None;
9692 let mut state_table__ = None;
9693 let mut cache_policy__ = None;
9694 while let Some(k) = map_.next_key()? {
9695 match k {
9696 GeneratedField::Calls => {
9697 if calls__.is_some() {
9698 return Err(serde::de::Error::duplicate_field("calls"));
9699 }
9700 calls__ = Some(map_.next_value()?);
9701 }
9702 GeneratedField::PartitionBy => {
9703 if partition_by__.is_some() {
9704 return Err(serde::de::Error::duplicate_field("partitionBy"));
9705 }
9706 partition_by__ =
9707 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9708 .into_iter().map(|x| x.0).collect())
9709 ;
9710 }
9711 GeneratedField::OrderBy => {
9712 if order_by__.is_some() {
9713 return Err(serde::de::Error::duplicate_field("orderBy"));
9714 }
9715 order_by__ = Some(map_.next_value()?);
9716 }
9717 GeneratedField::StateTable => {
9718 if state_table__.is_some() {
9719 return Err(serde::de::Error::duplicate_field("stateTable"));
9720 }
9721 state_table__ = map_.next_value()?;
9722 }
9723 GeneratedField::CachePolicy => {
9724 if cache_policy__.is_some() {
9725 return Err(serde::de::Error::duplicate_field("cachePolicy"));
9726 }
9727 cache_policy__ = Some(map_.next_value::<OverWindowCachePolicy>()? as i32);
9728 }
9729 }
9730 }
9731 Ok(OverWindowNode {
9732 calls: calls__.unwrap_or_default(),
9733 partition_by: partition_by__.unwrap_or_default(),
9734 order_by: order_by__.unwrap_or_default(),
9735 state_table: state_table__,
9736 cache_policy: cache_policy__.unwrap_or_default(),
9737 })
9738 }
9739 }
9740 deserializer.deserialize_struct("stream_plan.OverWindowNode", FIELDS, GeneratedVisitor)
9741 }
9742}
9743impl serde::Serialize for PauseMutation {
9744 #[allow(deprecated)]
9745 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9746 where
9747 S: serde::Serializer,
9748 {
9749 use serde::ser::SerializeStruct;
9750 let len = 0;
9751 let struct_ser = serializer.serialize_struct("stream_plan.PauseMutation", len)?;
9752 struct_ser.end()
9753 }
9754}
9755impl<'de> serde::Deserialize<'de> for PauseMutation {
9756 #[allow(deprecated)]
9757 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9758 where
9759 D: serde::Deserializer<'de>,
9760 {
9761 const FIELDS: &[&str] = &[
9762 ];
9763
9764 #[allow(clippy::enum_variant_names)]
9765 enum GeneratedField {
9766 }
9767 impl<'de> serde::Deserialize<'de> for GeneratedField {
9768 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9769 where
9770 D: serde::Deserializer<'de>,
9771 {
9772 struct GeneratedVisitor;
9773
9774 impl serde::de::Visitor<'_> for GeneratedVisitor {
9775 type Value = GeneratedField;
9776
9777 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9778 write!(formatter, "expected one of: {:?}", &FIELDS)
9779 }
9780
9781 #[allow(unused_variables)]
9782 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9783 where
9784 E: serde::de::Error,
9785 {
9786 Err(serde::de::Error::unknown_field(value, FIELDS))
9787 }
9788 }
9789 deserializer.deserialize_identifier(GeneratedVisitor)
9790 }
9791 }
9792 struct GeneratedVisitor;
9793 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9794 type Value = PauseMutation;
9795
9796 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9797 formatter.write_str("struct stream_plan.PauseMutation")
9798 }
9799
9800 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseMutation, V::Error>
9801 where
9802 V: serde::de::MapAccess<'de>,
9803 {
9804 while map_.next_key::<GeneratedField>()?.is_some() {
9805 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9806 }
9807 Ok(PauseMutation {
9808 })
9809 }
9810 }
9811 deserializer.deserialize_struct("stream_plan.PauseMutation", FIELDS, GeneratedVisitor)
9812 }
9813}
9814impl serde::Serialize for ProjectNode {
9815 #[allow(deprecated)]
9816 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9817 where
9818 S: serde::Serializer,
9819 {
9820 use serde::ser::SerializeStruct;
9821 let mut len = 0;
9822 if !self.select_list.is_empty() {
9823 len += 1;
9824 }
9825 if !self.watermark_input_cols.is_empty() {
9826 len += 1;
9827 }
9828 if !self.watermark_output_cols.is_empty() {
9829 len += 1;
9830 }
9831 if !self.nondecreasing_exprs.is_empty() {
9832 len += 1;
9833 }
9834 if self.noop_update_hint {
9835 len += 1;
9836 }
9837 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectNode", len)?;
9838 if !self.select_list.is_empty() {
9839 struct_ser.serialize_field("selectList", &self.select_list)?;
9840 }
9841 if !self.watermark_input_cols.is_empty() {
9842 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
9843 }
9844 if !self.watermark_output_cols.is_empty() {
9845 struct_ser.serialize_field("watermarkOutputCols", &self.watermark_output_cols)?;
9846 }
9847 if !self.nondecreasing_exprs.is_empty() {
9848 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
9849 }
9850 if self.noop_update_hint {
9851 struct_ser.serialize_field("noopUpdateHint", &self.noop_update_hint)?;
9852 }
9853 struct_ser.end()
9854 }
9855}
9856impl<'de> serde::Deserialize<'de> for ProjectNode {
9857 #[allow(deprecated)]
9858 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9859 where
9860 D: serde::Deserializer<'de>,
9861 {
9862 const FIELDS: &[&str] = &[
9863 "select_list",
9864 "selectList",
9865 "watermark_input_cols",
9866 "watermarkInputCols",
9867 "watermark_output_cols",
9868 "watermarkOutputCols",
9869 "nondecreasing_exprs",
9870 "nondecreasingExprs",
9871 "noop_update_hint",
9872 "noopUpdateHint",
9873 ];
9874
9875 #[allow(clippy::enum_variant_names)]
9876 enum GeneratedField {
9877 SelectList,
9878 WatermarkInputCols,
9879 WatermarkOutputCols,
9880 NondecreasingExprs,
9881 NoopUpdateHint,
9882 }
9883 impl<'de> serde::Deserialize<'de> for GeneratedField {
9884 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9885 where
9886 D: serde::Deserializer<'de>,
9887 {
9888 struct GeneratedVisitor;
9889
9890 impl serde::de::Visitor<'_> for GeneratedVisitor {
9891 type Value = GeneratedField;
9892
9893 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9894 write!(formatter, "expected one of: {:?}", &FIELDS)
9895 }
9896
9897 #[allow(unused_variables)]
9898 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9899 where
9900 E: serde::de::Error,
9901 {
9902 match value {
9903 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
9904 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
9905 "watermarkOutputCols" | "watermark_output_cols" => Ok(GeneratedField::WatermarkOutputCols),
9906 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
9907 "noopUpdateHint" | "noop_update_hint" => Ok(GeneratedField::NoopUpdateHint),
9908 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9909 }
9910 }
9911 }
9912 deserializer.deserialize_identifier(GeneratedVisitor)
9913 }
9914 }
9915 struct GeneratedVisitor;
9916 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9917 type Value = ProjectNode;
9918
9919 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9920 formatter.write_str("struct stream_plan.ProjectNode")
9921 }
9922
9923 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
9924 where
9925 V: serde::de::MapAccess<'de>,
9926 {
9927 let mut select_list__ = None;
9928 let mut watermark_input_cols__ = None;
9929 let mut watermark_output_cols__ = None;
9930 let mut nondecreasing_exprs__ = None;
9931 let mut noop_update_hint__ = None;
9932 while let Some(k) = map_.next_key()? {
9933 match k {
9934 GeneratedField::SelectList => {
9935 if select_list__.is_some() {
9936 return Err(serde::de::Error::duplicate_field("selectList"));
9937 }
9938 select_list__ = Some(map_.next_value()?);
9939 }
9940 GeneratedField::WatermarkInputCols => {
9941 if watermark_input_cols__.is_some() {
9942 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
9943 }
9944 watermark_input_cols__ =
9945 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9946 .into_iter().map(|x| x.0).collect())
9947 ;
9948 }
9949 GeneratedField::WatermarkOutputCols => {
9950 if watermark_output_cols__.is_some() {
9951 return Err(serde::de::Error::duplicate_field("watermarkOutputCols"));
9952 }
9953 watermark_output_cols__ =
9954 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9955 .into_iter().map(|x| x.0).collect())
9956 ;
9957 }
9958 GeneratedField::NondecreasingExprs => {
9959 if nondecreasing_exprs__.is_some() {
9960 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
9961 }
9962 nondecreasing_exprs__ =
9963 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9964 .into_iter().map(|x| x.0).collect())
9965 ;
9966 }
9967 GeneratedField::NoopUpdateHint => {
9968 if noop_update_hint__.is_some() {
9969 return Err(serde::de::Error::duplicate_field("noopUpdateHint"));
9970 }
9971 noop_update_hint__ = Some(map_.next_value()?);
9972 }
9973 }
9974 }
9975 Ok(ProjectNode {
9976 select_list: select_list__.unwrap_or_default(),
9977 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
9978 watermark_output_cols: watermark_output_cols__.unwrap_or_default(),
9979 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
9980 noop_update_hint: noop_update_hint__.unwrap_or_default(),
9981 })
9982 }
9983 }
9984 deserializer.deserialize_struct("stream_plan.ProjectNode", FIELDS, GeneratedVisitor)
9985 }
9986}
9987impl serde::Serialize for ProjectSetNode {
9988 #[allow(deprecated)]
9989 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9990 where
9991 S: serde::Serializer,
9992 {
9993 use serde::ser::SerializeStruct;
9994 let mut len = 0;
9995 if !self.select_list.is_empty() {
9996 len += 1;
9997 }
9998 if !self.watermark_input_cols.is_empty() {
9999 len += 1;
10000 }
10001 if !self.watermark_expr_indices.is_empty() {
10002 len += 1;
10003 }
10004 if !self.nondecreasing_exprs.is_empty() {
10005 len += 1;
10006 }
10007 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectSetNode", len)?;
10008 if !self.select_list.is_empty() {
10009 struct_ser.serialize_field("selectList", &self.select_list)?;
10010 }
10011 if !self.watermark_input_cols.is_empty() {
10012 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
10013 }
10014 if !self.watermark_expr_indices.is_empty() {
10015 struct_ser.serialize_field("watermarkExprIndices", &self.watermark_expr_indices)?;
10016 }
10017 if !self.nondecreasing_exprs.is_empty() {
10018 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
10019 }
10020 struct_ser.end()
10021 }
10022}
10023impl<'de> serde::Deserialize<'de> for ProjectSetNode {
10024 #[allow(deprecated)]
10025 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10026 where
10027 D: serde::Deserializer<'de>,
10028 {
10029 const FIELDS: &[&str] = &[
10030 "select_list",
10031 "selectList",
10032 "watermark_input_cols",
10033 "watermarkInputCols",
10034 "watermark_expr_indices",
10035 "watermarkExprIndices",
10036 "nondecreasing_exprs",
10037 "nondecreasingExprs",
10038 ];
10039
10040 #[allow(clippy::enum_variant_names)]
10041 enum GeneratedField {
10042 SelectList,
10043 WatermarkInputCols,
10044 WatermarkExprIndices,
10045 NondecreasingExprs,
10046 }
10047 impl<'de> serde::Deserialize<'de> for GeneratedField {
10048 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10049 where
10050 D: serde::Deserializer<'de>,
10051 {
10052 struct GeneratedVisitor;
10053
10054 impl serde::de::Visitor<'_> for GeneratedVisitor {
10055 type Value = GeneratedField;
10056
10057 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10058 write!(formatter, "expected one of: {:?}", &FIELDS)
10059 }
10060
10061 #[allow(unused_variables)]
10062 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10063 where
10064 E: serde::de::Error,
10065 {
10066 match value {
10067 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
10068 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
10069 "watermarkExprIndices" | "watermark_expr_indices" => Ok(GeneratedField::WatermarkExprIndices),
10070 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
10071 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10072 }
10073 }
10074 }
10075 deserializer.deserialize_identifier(GeneratedVisitor)
10076 }
10077 }
10078 struct GeneratedVisitor;
10079 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10080 type Value = ProjectSetNode;
10081
10082 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10083 formatter.write_str("struct stream_plan.ProjectSetNode")
10084 }
10085
10086 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
10087 where
10088 V: serde::de::MapAccess<'de>,
10089 {
10090 let mut select_list__ = None;
10091 let mut watermark_input_cols__ = None;
10092 let mut watermark_expr_indices__ = None;
10093 let mut nondecreasing_exprs__ = None;
10094 while let Some(k) = map_.next_key()? {
10095 match k {
10096 GeneratedField::SelectList => {
10097 if select_list__.is_some() {
10098 return Err(serde::de::Error::duplicate_field("selectList"));
10099 }
10100 select_list__ = Some(map_.next_value()?);
10101 }
10102 GeneratedField::WatermarkInputCols => {
10103 if watermark_input_cols__.is_some() {
10104 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
10105 }
10106 watermark_input_cols__ =
10107 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10108 .into_iter().map(|x| x.0).collect())
10109 ;
10110 }
10111 GeneratedField::WatermarkExprIndices => {
10112 if watermark_expr_indices__.is_some() {
10113 return Err(serde::de::Error::duplicate_field("watermarkExprIndices"));
10114 }
10115 watermark_expr_indices__ =
10116 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10117 .into_iter().map(|x| x.0).collect())
10118 ;
10119 }
10120 GeneratedField::NondecreasingExprs => {
10121 if nondecreasing_exprs__.is_some() {
10122 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
10123 }
10124 nondecreasing_exprs__ =
10125 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10126 .into_iter().map(|x| x.0).collect())
10127 ;
10128 }
10129 }
10130 }
10131 Ok(ProjectSetNode {
10132 select_list: select_list__.unwrap_or_default(),
10133 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
10134 watermark_expr_indices: watermark_expr_indices__.unwrap_or_default(),
10135 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
10136 })
10137 }
10138 }
10139 deserializer.deserialize_struct("stream_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
10140 }
10141}
10142impl serde::Serialize for RefreshStartMutation {
10143 #[allow(deprecated)]
10144 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10145 where
10146 S: serde::Serializer,
10147 {
10148 use serde::ser::SerializeStruct;
10149 let mut len = 0;
10150 if self.table_id != 0 {
10151 len += 1;
10152 }
10153 if self.associated_source_id != 0 {
10154 len += 1;
10155 }
10156 let mut struct_ser = serializer.serialize_struct("stream_plan.RefreshStartMutation", len)?;
10157 if self.table_id != 0 {
10158 struct_ser.serialize_field("tableId", &self.table_id)?;
10159 }
10160 if self.associated_source_id != 0 {
10161 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
10162 }
10163 struct_ser.end()
10164 }
10165}
10166impl<'de> serde::Deserialize<'de> for RefreshStartMutation {
10167 #[allow(deprecated)]
10168 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10169 where
10170 D: serde::Deserializer<'de>,
10171 {
10172 const FIELDS: &[&str] = &[
10173 "table_id",
10174 "tableId",
10175 "associated_source_id",
10176 "associatedSourceId",
10177 ];
10178
10179 #[allow(clippy::enum_variant_names)]
10180 enum GeneratedField {
10181 TableId,
10182 AssociatedSourceId,
10183 }
10184 impl<'de> serde::Deserialize<'de> for GeneratedField {
10185 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10186 where
10187 D: serde::Deserializer<'de>,
10188 {
10189 struct GeneratedVisitor;
10190
10191 impl serde::de::Visitor<'_> for GeneratedVisitor {
10192 type Value = GeneratedField;
10193
10194 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10195 write!(formatter, "expected one of: {:?}", &FIELDS)
10196 }
10197
10198 #[allow(unused_variables)]
10199 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10200 where
10201 E: serde::de::Error,
10202 {
10203 match value {
10204 "tableId" | "table_id" => Ok(GeneratedField::TableId),
10205 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
10206 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10207 }
10208 }
10209 }
10210 deserializer.deserialize_identifier(GeneratedVisitor)
10211 }
10212 }
10213 struct GeneratedVisitor;
10214 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10215 type Value = RefreshStartMutation;
10216
10217 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10218 formatter.write_str("struct stream_plan.RefreshStartMutation")
10219 }
10220
10221 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshStartMutation, V::Error>
10222 where
10223 V: serde::de::MapAccess<'de>,
10224 {
10225 let mut table_id__ = None;
10226 let mut associated_source_id__ = None;
10227 while let Some(k) = map_.next_key()? {
10228 match k {
10229 GeneratedField::TableId => {
10230 if table_id__.is_some() {
10231 return Err(serde::de::Error::duplicate_field("tableId"));
10232 }
10233 table_id__ =
10234 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10235 ;
10236 }
10237 GeneratedField::AssociatedSourceId => {
10238 if associated_source_id__.is_some() {
10239 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
10240 }
10241 associated_source_id__ =
10242 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10243 ;
10244 }
10245 }
10246 }
10247 Ok(RefreshStartMutation {
10248 table_id: table_id__.unwrap_or_default(),
10249 associated_source_id: associated_source_id__.unwrap_or_default(),
10250 })
10251 }
10252 }
10253 deserializer.deserialize_struct("stream_plan.RefreshStartMutation", FIELDS, GeneratedVisitor)
10254 }
10255}
10256impl serde::Serialize for ResetSourceMutation {
10257 #[allow(deprecated)]
10258 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10259 where
10260 S: serde::Serializer,
10261 {
10262 use serde::ser::SerializeStruct;
10263 let mut len = 0;
10264 if self.source_id != 0 {
10265 len += 1;
10266 }
10267 let mut struct_ser = serializer.serialize_struct("stream_plan.ResetSourceMutation", len)?;
10268 if self.source_id != 0 {
10269 struct_ser.serialize_field("sourceId", &self.source_id)?;
10270 }
10271 struct_ser.end()
10272 }
10273}
10274impl<'de> serde::Deserialize<'de> for ResetSourceMutation {
10275 #[allow(deprecated)]
10276 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10277 where
10278 D: serde::Deserializer<'de>,
10279 {
10280 const FIELDS: &[&str] = &[
10281 "source_id",
10282 "sourceId",
10283 ];
10284
10285 #[allow(clippy::enum_variant_names)]
10286 enum GeneratedField {
10287 SourceId,
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 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
10310 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10311 }
10312 }
10313 }
10314 deserializer.deserialize_identifier(GeneratedVisitor)
10315 }
10316 }
10317 struct GeneratedVisitor;
10318 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10319 type Value = ResetSourceMutation;
10320
10321 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10322 formatter.write_str("struct stream_plan.ResetSourceMutation")
10323 }
10324
10325 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceMutation, V::Error>
10326 where
10327 V: serde::de::MapAccess<'de>,
10328 {
10329 let mut source_id__ = None;
10330 while let Some(k) = map_.next_key()? {
10331 match k {
10332 GeneratedField::SourceId => {
10333 if source_id__.is_some() {
10334 return Err(serde::de::Error::duplicate_field("sourceId"));
10335 }
10336 source_id__ =
10337 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10338 ;
10339 }
10340 }
10341 }
10342 Ok(ResetSourceMutation {
10343 source_id: source_id__.unwrap_or_default(),
10344 })
10345 }
10346 }
10347 deserializer.deserialize_struct("stream_plan.ResetSourceMutation", FIELDS, GeneratedVisitor)
10348 }
10349}
10350impl serde::Serialize for ResumeMutation {
10351 #[allow(deprecated)]
10352 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10353 where
10354 S: serde::Serializer,
10355 {
10356 use serde::ser::SerializeStruct;
10357 let len = 0;
10358 let struct_ser = serializer.serialize_struct("stream_plan.ResumeMutation", len)?;
10359 struct_ser.end()
10360 }
10361}
10362impl<'de> serde::Deserialize<'de> for ResumeMutation {
10363 #[allow(deprecated)]
10364 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10365 where
10366 D: serde::Deserializer<'de>,
10367 {
10368 const FIELDS: &[&str] = &[
10369 ];
10370
10371 #[allow(clippy::enum_variant_names)]
10372 enum GeneratedField {
10373 }
10374 impl<'de> serde::Deserialize<'de> for GeneratedField {
10375 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10376 where
10377 D: serde::Deserializer<'de>,
10378 {
10379 struct GeneratedVisitor;
10380
10381 impl serde::de::Visitor<'_> for GeneratedVisitor {
10382 type Value = GeneratedField;
10383
10384 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10385 write!(formatter, "expected one of: {:?}", &FIELDS)
10386 }
10387
10388 #[allow(unused_variables)]
10389 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10390 where
10391 E: serde::de::Error,
10392 {
10393 Err(serde::de::Error::unknown_field(value, FIELDS))
10394 }
10395 }
10396 deserializer.deserialize_identifier(GeneratedVisitor)
10397 }
10398 }
10399 struct GeneratedVisitor;
10400 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10401 type Value = ResumeMutation;
10402
10403 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10404 formatter.write_str("struct stream_plan.ResumeMutation")
10405 }
10406
10407 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeMutation, V::Error>
10408 where
10409 V: serde::de::MapAccess<'de>,
10410 {
10411 while map_.next_key::<GeneratedField>()?.is_some() {
10412 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10413 }
10414 Ok(ResumeMutation {
10415 })
10416 }
10417 }
10418 deserializer.deserialize_struct("stream_plan.ResumeMutation", FIELDS, GeneratedVisitor)
10419 }
10420}
10421impl serde::Serialize for RowIdGenNode {
10422 #[allow(deprecated)]
10423 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10424 where
10425 S: serde::Serializer,
10426 {
10427 use serde::ser::SerializeStruct;
10428 let mut len = 0;
10429 if self.row_id_index != 0 {
10430 len += 1;
10431 }
10432 let mut struct_ser = serializer.serialize_struct("stream_plan.RowIdGenNode", len)?;
10433 if self.row_id_index != 0 {
10434 #[allow(clippy::needless_borrow)]
10435 #[allow(clippy::needless_borrows_for_generic_args)]
10436 struct_ser.serialize_field("rowIdIndex", ToString::to_string(&self.row_id_index).as_str())?;
10437 }
10438 struct_ser.end()
10439 }
10440}
10441impl<'de> serde::Deserialize<'de> for RowIdGenNode {
10442 #[allow(deprecated)]
10443 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10444 where
10445 D: serde::Deserializer<'de>,
10446 {
10447 const FIELDS: &[&str] = &[
10448 "row_id_index",
10449 "rowIdIndex",
10450 ];
10451
10452 #[allow(clippy::enum_variant_names)]
10453 enum GeneratedField {
10454 RowIdIndex,
10455 }
10456 impl<'de> serde::Deserialize<'de> for GeneratedField {
10457 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10458 where
10459 D: serde::Deserializer<'de>,
10460 {
10461 struct GeneratedVisitor;
10462
10463 impl serde::de::Visitor<'_> for GeneratedVisitor {
10464 type Value = GeneratedField;
10465
10466 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10467 write!(formatter, "expected one of: {:?}", &FIELDS)
10468 }
10469
10470 #[allow(unused_variables)]
10471 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10472 where
10473 E: serde::de::Error,
10474 {
10475 match value {
10476 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
10477 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10478 }
10479 }
10480 }
10481 deserializer.deserialize_identifier(GeneratedVisitor)
10482 }
10483 }
10484 struct GeneratedVisitor;
10485 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10486 type Value = RowIdGenNode;
10487
10488 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10489 formatter.write_str("struct stream_plan.RowIdGenNode")
10490 }
10491
10492 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowIdGenNode, V::Error>
10493 where
10494 V: serde::de::MapAccess<'de>,
10495 {
10496 let mut row_id_index__ = None;
10497 while let Some(k) = map_.next_key()? {
10498 match k {
10499 GeneratedField::RowIdIndex => {
10500 if row_id_index__.is_some() {
10501 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
10502 }
10503 row_id_index__ =
10504 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10505 ;
10506 }
10507 }
10508 }
10509 Ok(RowIdGenNode {
10510 row_id_index: row_id_index__.unwrap_or_default(),
10511 })
10512 }
10513 }
10514 deserializer.deserialize_struct("stream_plan.RowIdGenNode", FIELDS, GeneratedVisitor)
10515 }
10516}
10517impl serde::Serialize for RowMergeNode {
10518 #[allow(deprecated)]
10519 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10520 where
10521 S: serde::Serializer,
10522 {
10523 use serde::ser::SerializeStruct;
10524 let mut len = 0;
10525 if self.lhs_mapping.is_some() {
10526 len += 1;
10527 }
10528 if self.rhs_mapping.is_some() {
10529 len += 1;
10530 }
10531 let mut struct_ser = serializer.serialize_struct("stream_plan.RowMergeNode", len)?;
10532 if let Some(v) = self.lhs_mapping.as_ref() {
10533 struct_ser.serialize_field("lhsMapping", v)?;
10534 }
10535 if let Some(v) = self.rhs_mapping.as_ref() {
10536 struct_ser.serialize_field("rhsMapping", v)?;
10537 }
10538 struct_ser.end()
10539 }
10540}
10541impl<'de> serde::Deserialize<'de> for RowMergeNode {
10542 #[allow(deprecated)]
10543 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10544 where
10545 D: serde::Deserializer<'de>,
10546 {
10547 const FIELDS: &[&str] = &[
10548 "lhs_mapping",
10549 "lhsMapping",
10550 "rhs_mapping",
10551 "rhsMapping",
10552 ];
10553
10554 #[allow(clippy::enum_variant_names)]
10555 enum GeneratedField {
10556 LhsMapping,
10557 RhsMapping,
10558 }
10559 impl<'de> serde::Deserialize<'de> for GeneratedField {
10560 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10561 where
10562 D: serde::Deserializer<'de>,
10563 {
10564 struct GeneratedVisitor;
10565
10566 impl serde::de::Visitor<'_> for GeneratedVisitor {
10567 type Value = GeneratedField;
10568
10569 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10570 write!(formatter, "expected one of: {:?}", &FIELDS)
10571 }
10572
10573 #[allow(unused_variables)]
10574 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10575 where
10576 E: serde::de::Error,
10577 {
10578 match value {
10579 "lhsMapping" | "lhs_mapping" => Ok(GeneratedField::LhsMapping),
10580 "rhsMapping" | "rhs_mapping" => Ok(GeneratedField::RhsMapping),
10581 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10582 }
10583 }
10584 }
10585 deserializer.deserialize_identifier(GeneratedVisitor)
10586 }
10587 }
10588 struct GeneratedVisitor;
10589 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10590 type Value = RowMergeNode;
10591
10592 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10593 formatter.write_str("struct stream_plan.RowMergeNode")
10594 }
10595
10596 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowMergeNode, V::Error>
10597 where
10598 V: serde::de::MapAccess<'de>,
10599 {
10600 let mut lhs_mapping__ = None;
10601 let mut rhs_mapping__ = None;
10602 while let Some(k) = map_.next_key()? {
10603 match k {
10604 GeneratedField::LhsMapping => {
10605 if lhs_mapping__.is_some() {
10606 return Err(serde::de::Error::duplicate_field("lhsMapping"));
10607 }
10608 lhs_mapping__ = map_.next_value()?;
10609 }
10610 GeneratedField::RhsMapping => {
10611 if rhs_mapping__.is_some() {
10612 return Err(serde::de::Error::duplicate_field("rhsMapping"));
10613 }
10614 rhs_mapping__ = map_.next_value()?;
10615 }
10616 }
10617 }
10618 Ok(RowMergeNode {
10619 lhs_mapping: lhs_mapping__,
10620 rhs_mapping: rhs_mapping__,
10621 })
10622 }
10623 }
10624 deserializer.deserialize_struct("stream_plan.RowMergeNode", FIELDS, GeneratedVisitor)
10625 }
10626}
10627impl serde::Serialize for SimpleAggNode {
10628 #[allow(deprecated)]
10629 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10630 where
10631 S: serde::Serializer,
10632 {
10633 use serde::ser::SerializeStruct;
10634 let mut len = 0;
10635 if !self.agg_calls.is_empty() {
10636 len += 1;
10637 }
10638 if !self.agg_call_states.is_empty() {
10639 len += 1;
10640 }
10641 if self.intermediate_state_table.is_some() {
10642 len += 1;
10643 }
10644 if self.is_append_only {
10645 len += 1;
10646 }
10647 if !self.distinct_dedup_tables.is_empty() {
10648 len += 1;
10649 }
10650 if self.row_count_index != 0 {
10651 len += 1;
10652 }
10653 if self.version != 0 {
10654 len += 1;
10655 }
10656 if self.must_output_per_barrier {
10657 len += 1;
10658 }
10659 let mut struct_ser = serializer.serialize_struct("stream_plan.SimpleAggNode", len)?;
10660 if !self.agg_calls.is_empty() {
10661 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
10662 }
10663 if !self.agg_call_states.is_empty() {
10664 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
10665 }
10666 if let Some(v) = self.intermediate_state_table.as_ref() {
10667 struct_ser.serialize_field("intermediateStateTable", v)?;
10668 }
10669 if self.is_append_only {
10670 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
10671 }
10672 if !self.distinct_dedup_tables.is_empty() {
10673 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
10674 }
10675 if self.row_count_index != 0 {
10676 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
10677 }
10678 if self.version != 0 {
10679 let v = AggNodeVersion::try_from(self.version)
10680 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
10681 struct_ser.serialize_field("version", &v)?;
10682 }
10683 if self.must_output_per_barrier {
10684 struct_ser.serialize_field("mustOutputPerBarrier", &self.must_output_per_barrier)?;
10685 }
10686 struct_ser.end()
10687 }
10688}
10689impl<'de> serde::Deserialize<'de> for SimpleAggNode {
10690 #[allow(deprecated)]
10691 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10692 where
10693 D: serde::Deserializer<'de>,
10694 {
10695 const FIELDS: &[&str] = &[
10696 "agg_calls",
10697 "aggCalls",
10698 "agg_call_states",
10699 "aggCallStates",
10700 "intermediate_state_table",
10701 "intermediateStateTable",
10702 "is_append_only",
10703 "isAppendOnly",
10704 "distinct_dedup_tables",
10705 "distinctDedupTables",
10706 "row_count_index",
10707 "rowCountIndex",
10708 "version",
10709 "must_output_per_barrier",
10710 "mustOutputPerBarrier",
10711 ];
10712
10713 #[allow(clippy::enum_variant_names)]
10714 enum GeneratedField {
10715 AggCalls,
10716 AggCallStates,
10717 IntermediateStateTable,
10718 IsAppendOnly,
10719 DistinctDedupTables,
10720 RowCountIndex,
10721 Version,
10722 MustOutputPerBarrier,
10723 }
10724 impl<'de> serde::Deserialize<'de> for GeneratedField {
10725 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10726 where
10727 D: serde::Deserializer<'de>,
10728 {
10729 struct GeneratedVisitor;
10730
10731 impl serde::de::Visitor<'_> for GeneratedVisitor {
10732 type Value = GeneratedField;
10733
10734 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10735 write!(formatter, "expected one of: {:?}", &FIELDS)
10736 }
10737
10738 #[allow(unused_variables)]
10739 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10740 where
10741 E: serde::de::Error,
10742 {
10743 match value {
10744 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
10745 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
10746 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
10747 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
10748 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
10749 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
10750 "version" => Ok(GeneratedField::Version),
10751 "mustOutputPerBarrier" | "must_output_per_barrier" => Ok(GeneratedField::MustOutputPerBarrier),
10752 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10753 }
10754 }
10755 }
10756 deserializer.deserialize_identifier(GeneratedVisitor)
10757 }
10758 }
10759 struct GeneratedVisitor;
10760 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10761 type Value = SimpleAggNode;
10762
10763 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10764 formatter.write_str("struct stream_plan.SimpleAggNode")
10765 }
10766
10767 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SimpleAggNode, V::Error>
10768 where
10769 V: serde::de::MapAccess<'de>,
10770 {
10771 let mut agg_calls__ = None;
10772 let mut agg_call_states__ = None;
10773 let mut intermediate_state_table__ = None;
10774 let mut is_append_only__ = None;
10775 let mut distinct_dedup_tables__ = None;
10776 let mut row_count_index__ = None;
10777 let mut version__ = None;
10778 let mut must_output_per_barrier__ = None;
10779 while let Some(k) = map_.next_key()? {
10780 match k {
10781 GeneratedField::AggCalls => {
10782 if agg_calls__.is_some() {
10783 return Err(serde::de::Error::duplicate_field("aggCalls"));
10784 }
10785 agg_calls__ = Some(map_.next_value()?);
10786 }
10787 GeneratedField::AggCallStates => {
10788 if agg_call_states__.is_some() {
10789 return Err(serde::de::Error::duplicate_field("aggCallStates"));
10790 }
10791 agg_call_states__ = Some(map_.next_value()?);
10792 }
10793 GeneratedField::IntermediateStateTable => {
10794 if intermediate_state_table__.is_some() {
10795 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
10796 }
10797 intermediate_state_table__ = map_.next_value()?;
10798 }
10799 GeneratedField::IsAppendOnly => {
10800 if is_append_only__.is_some() {
10801 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
10802 }
10803 is_append_only__ = Some(map_.next_value()?);
10804 }
10805 GeneratedField::DistinctDedupTables => {
10806 if distinct_dedup_tables__.is_some() {
10807 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
10808 }
10809 distinct_dedup_tables__ = Some(
10810 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10811 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
10812 );
10813 }
10814 GeneratedField::RowCountIndex => {
10815 if row_count_index__.is_some() {
10816 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
10817 }
10818 row_count_index__ =
10819 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10820 ;
10821 }
10822 GeneratedField::Version => {
10823 if version__.is_some() {
10824 return Err(serde::de::Error::duplicate_field("version"));
10825 }
10826 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
10827 }
10828 GeneratedField::MustOutputPerBarrier => {
10829 if must_output_per_barrier__.is_some() {
10830 return Err(serde::de::Error::duplicate_field("mustOutputPerBarrier"));
10831 }
10832 must_output_per_barrier__ = Some(map_.next_value()?);
10833 }
10834 }
10835 }
10836 Ok(SimpleAggNode {
10837 agg_calls: agg_calls__.unwrap_or_default(),
10838 agg_call_states: agg_call_states__.unwrap_or_default(),
10839 intermediate_state_table: intermediate_state_table__,
10840 is_append_only: is_append_only__.unwrap_or_default(),
10841 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
10842 row_count_index: row_count_index__.unwrap_or_default(),
10843 version: version__.unwrap_or_default(),
10844 must_output_per_barrier: must_output_per_barrier__.unwrap_or_default(),
10845 })
10846 }
10847 }
10848 deserializer.deserialize_struct("stream_plan.SimpleAggNode", FIELDS, GeneratedVisitor)
10849 }
10850}
10851impl serde::Serialize for SinkAddColumnsOp {
10852 #[allow(deprecated)]
10853 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10854 where
10855 S: serde::Serializer,
10856 {
10857 use serde::ser::SerializeStruct;
10858 let mut len = 0;
10859 if !self.fields.is_empty() {
10860 len += 1;
10861 }
10862 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkAddColumnsOp", len)?;
10863 if !self.fields.is_empty() {
10864 struct_ser.serialize_field("fields", &self.fields)?;
10865 }
10866 struct_ser.end()
10867 }
10868}
10869impl<'de> serde::Deserialize<'de> for SinkAddColumnsOp {
10870 #[allow(deprecated)]
10871 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10872 where
10873 D: serde::Deserializer<'de>,
10874 {
10875 const FIELDS: &[&str] = &[
10876 "fields",
10877 ];
10878
10879 #[allow(clippy::enum_variant_names)]
10880 enum GeneratedField {
10881 Fields,
10882 }
10883 impl<'de> serde::Deserialize<'de> for GeneratedField {
10884 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10885 where
10886 D: serde::Deserializer<'de>,
10887 {
10888 struct GeneratedVisitor;
10889
10890 impl serde::de::Visitor<'_> for GeneratedVisitor {
10891 type Value = GeneratedField;
10892
10893 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10894 write!(formatter, "expected one of: {:?}", &FIELDS)
10895 }
10896
10897 #[allow(unused_variables)]
10898 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10899 where
10900 E: serde::de::Error,
10901 {
10902 match value {
10903 "fields" => Ok(GeneratedField::Fields),
10904 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10905 }
10906 }
10907 }
10908 deserializer.deserialize_identifier(GeneratedVisitor)
10909 }
10910 }
10911 struct GeneratedVisitor;
10912 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10913 type Value = SinkAddColumnsOp;
10914
10915 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10916 formatter.write_str("struct stream_plan.SinkAddColumnsOp")
10917 }
10918
10919 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkAddColumnsOp, V::Error>
10920 where
10921 V: serde::de::MapAccess<'de>,
10922 {
10923 let mut fields__ = None;
10924 while let Some(k) = map_.next_key()? {
10925 match k {
10926 GeneratedField::Fields => {
10927 if fields__.is_some() {
10928 return Err(serde::de::Error::duplicate_field("fields"));
10929 }
10930 fields__ = Some(map_.next_value()?);
10931 }
10932 }
10933 }
10934 Ok(SinkAddColumnsOp {
10935 fields: fields__.unwrap_or_default(),
10936 })
10937 }
10938 }
10939 deserializer.deserialize_struct("stream_plan.SinkAddColumnsOp", FIELDS, GeneratedVisitor)
10940 }
10941}
10942impl serde::Serialize for SinkDesc {
10943 #[allow(deprecated)]
10944 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10945 where
10946 S: serde::Serializer,
10947 {
10948 use serde::ser::SerializeStruct;
10949 let mut len = 0;
10950 if self.id != 0 {
10951 len += 1;
10952 }
10953 if !self.name.is_empty() {
10954 len += 1;
10955 }
10956 if !self.definition.is_empty() {
10957 len += 1;
10958 }
10959 if !self.plan_pk.is_empty() {
10960 len += 1;
10961 }
10962 if !self.downstream_pk.is_empty() {
10963 len += 1;
10964 }
10965 if !self.distribution_key.is_empty() {
10966 len += 1;
10967 }
10968 if !self.properties.is_empty() {
10969 len += 1;
10970 }
10971 if self.sink_type != 0 {
10972 len += 1;
10973 }
10974 if !self.column_catalogs.is_empty() {
10975 len += 1;
10976 }
10977 if !self.db_name.is_empty() {
10978 len += 1;
10979 }
10980 if !self.sink_from_name.is_empty() {
10981 len += 1;
10982 }
10983 if self.format_desc.is_some() {
10984 len += 1;
10985 }
10986 if self.target_table.is_some() {
10987 len += 1;
10988 }
10989 if self.extra_partition_col_idx.is_some() {
10990 len += 1;
10991 }
10992 if !self.secret_refs.is_empty() {
10993 len += 1;
10994 }
10995 if self.raw_ignore_delete {
10996 len += 1;
10997 }
10998 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDesc", len)?;
10999 if self.id != 0 {
11000 struct_ser.serialize_field("id", &self.id)?;
11001 }
11002 if !self.name.is_empty() {
11003 struct_ser.serialize_field("name", &self.name)?;
11004 }
11005 if !self.definition.is_empty() {
11006 struct_ser.serialize_field("definition", &self.definition)?;
11007 }
11008 if !self.plan_pk.is_empty() {
11009 struct_ser.serialize_field("planPk", &self.plan_pk)?;
11010 }
11011 if !self.downstream_pk.is_empty() {
11012 struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
11013 }
11014 if !self.distribution_key.is_empty() {
11015 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
11016 }
11017 if !self.properties.is_empty() {
11018 struct_ser.serialize_field("properties", &self.properties)?;
11019 }
11020 if self.sink_type != 0 {
11021 let v = super::catalog::SinkType::try_from(self.sink_type)
11022 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
11023 struct_ser.serialize_field("sinkType", &v)?;
11024 }
11025 if !self.column_catalogs.is_empty() {
11026 struct_ser.serialize_field("columnCatalogs", &self.column_catalogs)?;
11027 }
11028 if !self.db_name.is_empty() {
11029 struct_ser.serialize_field("dbName", &self.db_name)?;
11030 }
11031 if !self.sink_from_name.is_empty() {
11032 struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
11033 }
11034 if let Some(v) = self.format_desc.as_ref() {
11035 struct_ser.serialize_field("formatDesc", v)?;
11036 }
11037 if let Some(v) = self.target_table.as_ref() {
11038 struct_ser.serialize_field("targetTable", v)?;
11039 }
11040 if let Some(v) = self.extra_partition_col_idx.as_ref() {
11041 #[allow(clippy::needless_borrow)]
11042 #[allow(clippy::needless_borrows_for_generic_args)]
11043 struct_ser.serialize_field("extraPartitionColIdx", ToString::to_string(&v).as_str())?;
11044 }
11045 if !self.secret_refs.is_empty() {
11046 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
11047 }
11048 if self.raw_ignore_delete {
11049 struct_ser.serialize_field("rawIgnoreDelete", &self.raw_ignore_delete)?;
11050 }
11051 struct_ser.end()
11052 }
11053}
11054impl<'de> serde::Deserialize<'de> for SinkDesc {
11055 #[allow(deprecated)]
11056 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11057 where
11058 D: serde::Deserializer<'de>,
11059 {
11060 const FIELDS: &[&str] = &[
11061 "id",
11062 "name",
11063 "definition",
11064 "plan_pk",
11065 "planPk",
11066 "downstream_pk",
11067 "downstreamPk",
11068 "distribution_key",
11069 "distributionKey",
11070 "properties",
11071 "sink_type",
11072 "sinkType",
11073 "column_catalogs",
11074 "columnCatalogs",
11075 "db_name",
11076 "dbName",
11077 "sink_from_name",
11078 "sinkFromName",
11079 "format_desc",
11080 "formatDesc",
11081 "target_table",
11082 "targetTable",
11083 "extra_partition_col_idx",
11084 "extraPartitionColIdx",
11085 "secret_refs",
11086 "secretRefs",
11087 "raw_ignore_delete",
11088 "rawIgnoreDelete",
11089 ];
11090
11091 #[allow(clippy::enum_variant_names)]
11092 enum GeneratedField {
11093 Id,
11094 Name,
11095 Definition,
11096 PlanPk,
11097 DownstreamPk,
11098 DistributionKey,
11099 Properties,
11100 SinkType,
11101 ColumnCatalogs,
11102 DbName,
11103 SinkFromName,
11104 FormatDesc,
11105 TargetTable,
11106 ExtraPartitionColIdx,
11107 SecretRefs,
11108 RawIgnoreDelete,
11109 }
11110 impl<'de> serde::Deserialize<'de> for GeneratedField {
11111 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11112 where
11113 D: serde::Deserializer<'de>,
11114 {
11115 struct GeneratedVisitor;
11116
11117 impl serde::de::Visitor<'_> for GeneratedVisitor {
11118 type Value = GeneratedField;
11119
11120 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11121 write!(formatter, "expected one of: {:?}", &FIELDS)
11122 }
11123
11124 #[allow(unused_variables)]
11125 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11126 where
11127 E: serde::de::Error,
11128 {
11129 match value {
11130 "id" => Ok(GeneratedField::Id),
11131 "name" => Ok(GeneratedField::Name),
11132 "definition" => Ok(GeneratedField::Definition),
11133 "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
11134 "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
11135 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
11136 "properties" => Ok(GeneratedField::Properties),
11137 "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
11138 "columnCatalogs" | "column_catalogs" => Ok(GeneratedField::ColumnCatalogs),
11139 "dbName" | "db_name" => Ok(GeneratedField::DbName),
11140 "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
11141 "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
11142 "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
11143 "extraPartitionColIdx" | "extra_partition_col_idx" => Ok(GeneratedField::ExtraPartitionColIdx),
11144 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
11145 "rawIgnoreDelete" | "raw_ignore_delete" => Ok(GeneratedField::RawIgnoreDelete),
11146 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11147 }
11148 }
11149 }
11150 deserializer.deserialize_identifier(GeneratedVisitor)
11151 }
11152 }
11153 struct GeneratedVisitor;
11154 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11155 type Value = SinkDesc;
11156
11157 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11158 formatter.write_str("struct stream_plan.SinkDesc")
11159 }
11160
11161 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDesc, V::Error>
11162 where
11163 V: serde::de::MapAccess<'de>,
11164 {
11165 let mut id__ = None;
11166 let mut name__ = None;
11167 let mut definition__ = None;
11168 let mut plan_pk__ = None;
11169 let mut downstream_pk__ = None;
11170 let mut distribution_key__ = None;
11171 let mut properties__ = None;
11172 let mut sink_type__ = None;
11173 let mut column_catalogs__ = None;
11174 let mut db_name__ = None;
11175 let mut sink_from_name__ = None;
11176 let mut format_desc__ = None;
11177 let mut target_table__ = None;
11178 let mut extra_partition_col_idx__ = None;
11179 let mut secret_refs__ = None;
11180 let mut raw_ignore_delete__ = None;
11181 while let Some(k) = map_.next_key()? {
11182 match k {
11183 GeneratedField::Id => {
11184 if id__.is_some() {
11185 return Err(serde::de::Error::duplicate_field("id"));
11186 }
11187 id__ =
11188 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11189 ;
11190 }
11191 GeneratedField::Name => {
11192 if name__.is_some() {
11193 return Err(serde::de::Error::duplicate_field("name"));
11194 }
11195 name__ = Some(map_.next_value()?);
11196 }
11197 GeneratedField::Definition => {
11198 if definition__.is_some() {
11199 return Err(serde::de::Error::duplicate_field("definition"));
11200 }
11201 definition__ = Some(map_.next_value()?);
11202 }
11203 GeneratedField::PlanPk => {
11204 if plan_pk__.is_some() {
11205 return Err(serde::de::Error::duplicate_field("planPk"));
11206 }
11207 plan_pk__ = Some(map_.next_value()?);
11208 }
11209 GeneratedField::DownstreamPk => {
11210 if downstream_pk__.is_some() {
11211 return Err(serde::de::Error::duplicate_field("downstreamPk"));
11212 }
11213 downstream_pk__ =
11214 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11215 .into_iter().map(|x| x.0).collect())
11216 ;
11217 }
11218 GeneratedField::DistributionKey => {
11219 if distribution_key__.is_some() {
11220 return Err(serde::de::Error::duplicate_field("distributionKey"));
11221 }
11222 distribution_key__ =
11223 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11224 .into_iter().map(|x| x.0).collect())
11225 ;
11226 }
11227 GeneratedField::Properties => {
11228 if properties__.is_some() {
11229 return Err(serde::de::Error::duplicate_field("properties"));
11230 }
11231 properties__ = Some(
11232 map_.next_value::<std::collections::BTreeMap<_, _>>()?
11233 );
11234 }
11235 GeneratedField::SinkType => {
11236 if sink_type__.is_some() {
11237 return Err(serde::de::Error::duplicate_field("sinkType"));
11238 }
11239 sink_type__ = Some(map_.next_value::<super::catalog::SinkType>()? as i32);
11240 }
11241 GeneratedField::ColumnCatalogs => {
11242 if column_catalogs__.is_some() {
11243 return Err(serde::de::Error::duplicate_field("columnCatalogs"));
11244 }
11245 column_catalogs__ = Some(map_.next_value()?);
11246 }
11247 GeneratedField::DbName => {
11248 if db_name__.is_some() {
11249 return Err(serde::de::Error::duplicate_field("dbName"));
11250 }
11251 db_name__ = Some(map_.next_value()?);
11252 }
11253 GeneratedField::SinkFromName => {
11254 if sink_from_name__.is_some() {
11255 return Err(serde::de::Error::duplicate_field("sinkFromName"));
11256 }
11257 sink_from_name__ = Some(map_.next_value()?);
11258 }
11259 GeneratedField::FormatDesc => {
11260 if format_desc__.is_some() {
11261 return Err(serde::de::Error::duplicate_field("formatDesc"));
11262 }
11263 format_desc__ = map_.next_value()?;
11264 }
11265 GeneratedField::TargetTable => {
11266 if target_table__.is_some() {
11267 return Err(serde::de::Error::duplicate_field("targetTable"));
11268 }
11269 target_table__ =
11270 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11271 ;
11272 }
11273 GeneratedField::ExtraPartitionColIdx => {
11274 if extra_partition_col_idx__.is_some() {
11275 return Err(serde::de::Error::duplicate_field("extraPartitionColIdx"));
11276 }
11277 extra_partition_col_idx__ =
11278 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11279 ;
11280 }
11281 GeneratedField::SecretRefs => {
11282 if secret_refs__.is_some() {
11283 return Err(serde::de::Error::duplicate_field("secretRefs"));
11284 }
11285 secret_refs__ = Some(
11286 map_.next_value::<std::collections::BTreeMap<_, _>>()?
11287 );
11288 }
11289 GeneratedField::RawIgnoreDelete => {
11290 if raw_ignore_delete__.is_some() {
11291 return Err(serde::de::Error::duplicate_field("rawIgnoreDelete"));
11292 }
11293 raw_ignore_delete__ = Some(map_.next_value()?);
11294 }
11295 }
11296 }
11297 Ok(SinkDesc {
11298 id: id__.unwrap_or_default(),
11299 name: name__.unwrap_or_default(),
11300 definition: definition__.unwrap_or_default(),
11301 plan_pk: plan_pk__.unwrap_or_default(),
11302 downstream_pk: downstream_pk__.unwrap_or_default(),
11303 distribution_key: distribution_key__.unwrap_or_default(),
11304 properties: properties__.unwrap_or_default(),
11305 sink_type: sink_type__.unwrap_or_default(),
11306 column_catalogs: column_catalogs__.unwrap_or_default(),
11307 db_name: db_name__.unwrap_or_default(),
11308 sink_from_name: sink_from_name__.unwrap_or_default(),
11309 format_desc: format_desc__,
11310 target_table: target_table__,
11311 extra_partition_col_idx: extra_partition_col_idx__,
11312 secret_refs: secret_refs__.unwrap_or_default(),
11313 raw_ignore_delete: raw_ignore_delete__.unwrap_or_default(),
11314 })
11315 }
11316 }
11317 deserializer.deserialize_struct("stream_plan.SinkDesc", FIELDS, GeneratedVisitor)
11318 }
11319}
11320impl serde::Serialize for SinkDropColumnsOp {
11321 #[allow(deprecated)]
11322 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11323 where
11324 S: serde::Serializer,
11325 {
11326 use serde::ser::SerializeStruct;
11327 let mut len = 0;
11328 if !self.column_names.is_empty() {
11329 len += 1;
11330 }
11331 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDropColumnsOp", len)?;
11332 if !self.column_names.is_empty() {
11333 struct_ser.serialize_field("columnNames", &self.column_names)?;
11334 }
11335 struct_ser.end()
11336 }
11337}
11338impl<'de> serde::Deserialize<'de> for SinkDropColumnsOp {
11339 #[allow(deprecated)]
11340 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11341 where
11342 D: serde::Deserializer<'de>,
11343 {
11344 const FIELDS: &[&str] = &[
11345 "column_names",
11346 "columnNames",
11347 ];
11348
11349 #[allow(clippy::enum_variant_names)]
11350 enum GeneratedField {
11351 ColumnNames,
11352 }
11353 impl<'de> serde::Deserialize<'de> for GeneratedField {
11354 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11355 where
11356 D: serde::Deserializer<'de>,
11357 {
11358 struct GeneratedVisitor;
11359
11360 impl serde::de::Visitor<'_> for GeneratedVisitor {
11361 type Value = GeneratedField;
11362
11363 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11364 write!(formatter, "expected one of: {:?}", &FIELDS)
11365 }
11366
11367 #[allow(unused_variables)]
11368 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11369 where
11370 E: serde::de::Error,
11371 {
11372 match value {
11373 "columnNames" | "column_names" => Ok(GeneratedField::ColumnNames),
11374 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11375 }
11376 }
11377 }
11378 deserializer.deserialize_identifier(GeneratedVisitor)
11379 }
11380 }
11381 struct GeneratedVisitor;
11382 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11383 type Value = SinkDropColumnsOp;
11384
11385 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11386 formatter.write_str("struct stream_plan.SinkDropColumnsOp")
11387 }
11388
11389 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDropColumnsOp, V::Error>
11390 where
11391 V: serde::de::MapAccess<'de>,
11392 {
11393 let mut column_names__ = None;
11394 while let Some(k) = map_.next_key()? {
11395 match k {
11396 GeneratedField::ColumnNames => {
11397 if column_names__.is_some() {
11398 return Err(serde::de::Error::duplicate_field("columnNames"));
11399 }
11400 column_names__ = Some(map_.next_value()?);
11401 }
11402 }
11403 }
11404 Ok(SinkDropColumnsOp {
11405 column_names: column_names__.unwrap_or_default(),
11406 })
11407 }
11408 }
11409 deserializer.deserialize_struct("stream_plan.SinkDropColumnsOp", FIELDS, GeneratedVisitor)
11410 }
11411}
11412impl serde::Serialize for SinkLogStoreType {
11413 #[allow(deprecated)]
11414 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11415 where
11416 S: serde::Serializer,
11417 {
11418 let variant = match self {
11419 Self::Unspecified => "SINK_LOG_STORE_TYPE_UNSPECIFIED",
11420 Self::KvLogStore => "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
11421 Self::InMemoryLogStore => "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
11422 };
11423 serializer.serialize_str(variant)
11424 }
11425}
11426impl<'de> serde::Deserialize<'de> for SinkLogStoreType {
11427 #[allow(deprecated)]
11428 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11429 where
11430 D: serde::Deserializer<'de>,
11431 {
11432 const FIELDS: &[&str] = &[
11433 "SINK_LOG_STORE_TYPE_UNSPECIFIED",
11434 "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
11435 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
11436 ];
11437
11438 struct GeneratedVisitor;
11439
11440 impl serde::de::Visitor<'_> for GeneratedVisitor {
11441 type Value = SinkLogStoreType;
11442
11443 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11444 write!(formatter, "expected one of: {:?}", &FIELDS)
11445 }
11446
11447 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
11448 where
11449 E: serde::de::Error,
11450 {
11451 i32::try_from(v)
11452 .ok()
11453 .and_then(|x| x.try_into().ok())
11454 .ok_or_else(|| {
11455 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
11456 })
11457 }
11458
11459 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
11460 where
11461 E: serde::de::Error,
11462 {
11463 i32::try_from(v)
11464 .ok()
11465 .and_then(|x| x.try_into().ok())
11466 .ok_or_else(|| {
11467 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
11468 })
11469 }
11470
11471 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
11472 where
11473 E: serde::de::Error,
11474 {
11475 match value {
11476 "SINK_LOG_STORE_TYPE_UNSPECIFIED" => Ok(SinkLogStoreType::Unspecified),
11477 "SINK_LOG_STORE_TYPE_KV_LOG_STORE" => Ok(SinkLogStoreType::KvLogStore),
11478 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE" => Ok(SinkLogStoreType::InMemoryLogStore),
11479 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
11480 }
11481 }
11482 }
11483 deserializer.deserialize_any(GeneratedVisitor)
11484 }
11485}
11486impl serde::Serialize for SinkNode {
11487 #[allow(deprecated)]
11488 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11489 where
11490 S: serde::Serializer,
11491 {
11492 use serde::ser::SerializeStruct;
11493 let mut len = 0;
11494 if self.sink_desc.is_some() {
11495 len += 1;
11496 }
11497 if self.table.is_some() {
11498 len += 1;
11499 }
11500 if self.log_store_type != 0 {
11501 len += 1;
11502 }
11503 if self.rate_limit.is_some() {
11504 len += 1;
11505 }
11506 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkNode", len)?;
11507 if let Some(v) = self.sink_desc.as_ref() {
11508 struct_ser.serialize_field("sinkDesc", v)?;
11509 }
11510 if let Some(v) = self.table.as_ref() {
11511 struct_ser.serialize_field("table", v)?;
11512 }
11513 if self.log_store_type != 0 {
11514 let v = SinkLogStoreType::try_from(self.log_store_type)
11515 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.log_store_type)))?;
11516 struct_ser.serialize_field("logStoreType", &v)?;
11517 }
11518 if let Some(v) = self.rate_limit.as_ref() {
11519 struct_ser.serialize_field("rateLimit", v)?;
11520 }
11521 struct_ser.end()
11522 }
11523}
11524impl<'de> serde::Deserialize<'de> for SinkNode {
11525 #[allow(deprecated)]
11526 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11527 where
11528 D: serde::Deserializer<'de>,
11529 {
11530 const FIELDS: &[&str] = &[
11531 "sink_desc",
11532 "sinkDesc",
11533 "table",
11534 "log_store_type",
11535 "logStoreType",
11536 "rate_limit",
11537 "rateLimit",
11538 ];
11539
11540 #[allow(clippy::enum_variant_names)]
11541 enum GeneratedField {
11542 SinkDesc,
11543 Table,
11544 LogStoreType,
11545 RateLimit,
11546 }
11547 impl<'de> serde::Deserialize<'de> for GeneratedField {
11548 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11549 where
11550 D: serde::Deserializer<'de>,
11551 {
11552 struct GeneratedVisitor;
11553
11554 impl serde::de::Visitor<'_> for GeneratedVisitor {
11555 type Value = GeneratedField;
11556
11557 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11558 write!(formatter, "expected one of: {:?}", &FIELDS)
11559 }
11560
11561 #[allow(unused_variables)]
11562 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11563 where
11564 E: serde::de::Error,
11565 {
11566 match value {
11567 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
11568 "table" => Ok(GeneratedField::Table),
11569 "logStoreType" | "log_store_type" => Ok(GeneratedField::LogStoreType),
11570 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11571 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11572 }
11573 }
11574 }
11575 deserializer.deserialize_identifier(GeneratedVisitor)
11576 }
11577 }
11578 struct GeneratedVisitor;
11579 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11580 type Value = SinkNode;
11581
11582 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11583 formatter.write_str("struct stream_plan.SinkNode")
11584 }
11585
11586 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkNode, V::Error>
11587 where
11588 V: serde::de::MapAccess<'de>,
11589 {
11590 let mut sink_desc__ = None;
11591 let mut table__ = None;
11592 let mut log_store_type__ = None;
11593 let mut rate_limit__ = None;
11594 while let Some(k) = map_.next_key()? {
11595 match k {
11596 GeneratedField::SinkDesc => {
11597 if sink_desc__.is_some() {
11598 return Err(serde::de::Error::duplicate_field("sinkDesc"));
11599 }
11600 sink_desc__ = map_.next_value()?;
11601 }
11602 GeneratedField::Table => {
11603 if table__.is_some() {
11604 return Err(serde::de::Error::duplicate_field("table"));
11605 }
11606 table__ = map_.next_value()?;
11607 }
11608 GeneratedField::LogStoreType => {
11609 if log_store_type__.is_some() {
11610 return Err(serde::de::Error::duplicate_field("logStoreType"));
11611 }
11612 log_store_type__ = Some(map_.next_value::<SinkLogStoreType>()? as i32);
11613 }
11614 GeneratedField::RateLimit => {
11615 if rate_limit__.is_some() {
11616 return Err(serde::de::Error::duplicate_field("rateLimit"));
11617 }
11618 rate_limit__ =
11619 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11620 ;
11621 }
11622 }
11623 }
11624 Ok(SinkNode {
11625 sink_desc: sink_desc__,
11626 table: table__,
11627 log_store_type: log_store_type__.unwrap_or_default(),
11628 rate_limit: rate_limit__,
11629 })
11630 }
11631 }
11632 deserializer.deserialize_struct("stream_plan.SinkNode", FIELDS, GeneratedVisitor)
11633 }
11634}
11635impl serde::Serialize for SinkSchemaChange {
11636 #[allow(deprecated)]
11637 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11638 where
11639 S: serde::Serializer,
11640 {
11641 use serde::ser::SerializeStruct;
11642 let mut len = 0;
11643 if !self.original_schema.is_empty() {
11644 len += 1;
11645 }
11646 if self.op.is_some() {
11647 len += 1;
11648 }
11649 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkSchemaChange", len)?;
11650 if !self.original_schema.is_empty() {
11651 struct_ser.serialize_field("originalSchema", &self.original_schema)?;
11652 }
11653 if let Some(v) = self.op.as_ref() {
11654 match v {
11655 sink_schema_change::Op::AddColumns(v) => {
11656 struct_ser.serialize_field("addColumns", v)?;
11657 }
11658 sink_schema_change::Op::DropColumns(v) => {
11659 struct_ser.serialize_field("dropColumns", v)?;
11660 }
11661 }
11662 }
11663 struct_ser.end()
11664 }
11665}
11666impl<'de> serde::Deserialize<'de> for SinkSchemaChange {
11667 #[allow(deprecated)]
11668 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11669 where
11670 D: serde::Deserializer<'de>,
11671 {
11672 const FIELDS: &[&str] = &[
11673 "original_schema",
11674 "originalSchema",
11675 "add_columns",
11676 "addColumns",
11677 "drop_columns",
11678 "dropColumns",
11679 ];
11680
11681 #[allow(clippy::enum_variant_names)]
11682 enum GeneratedField {
11683 OriginalSchema,
11684 AddColumns,
11685 DropColumns,
11686 }
11687 impl<'de> serde::Deserialize<'de> for GeneratedField {
11688 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11689 where
11690 D: serde::Deserializer<'de>,
11691 {
11692 struct GeneratedVisitor;
11693
11694 impl serde::de::Visitor<'_> for GeneratedVisitor {
11695 type Value = GeneratedField;
11696
11697 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11698 write!(formatter, "expected one of: {:?}", &FIELDS)
11699 }
11700
11701 #[allow(unused_variables)]
11702 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11703 where
11704 E: serde::de::Error,
11705 {
11706 match value {
11707 "originalSchema" | "original_schema" => Ok(GeneratedField::OriginalSchema),
11708 "addColumns" | "add_columns" => Ok(GeneratedField::AddColumns),
11709 "dropColumns" | "drop_columns" => Ok(GeneratedField::DropColumns),
11710 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11711 }
11712 }
11713 }
11714 deserializer.deserialize_identifier(GeneratedVisitor)
11715 }
11716 }
11717 struct GeneratedVisitor;
11718 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11719 type Value = SinkSchemaChange;
11720
11721 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11722 formatter.write_str("struct stream_plan.SinkSchemaChange")
11723 }
11724
11725 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkSchemaChange, V::Error>
11726 where
11727 V: serde::de::MapAccess<'de>,
11728 {
11729 let mut original_schema__ = None;
11730 let mut op__ = None;
11731 while let Some(k) = map_.next_key()? {
11732 match k {
11733 GeneratedField::OriginalSchema => {
11734 if original_schema__.is_some() {
11735 return Err(serde::de::Error::duplicate_field("originalSchema"));
11736 }
11737 original_schema__ = Some(map_.next_value()?);
11738 }
11739 GeneratedField::AddColumns => {
11740 if op__.is_some() {
11741 return Err(serde::de::Error::duplicate_field("addColumns"));
11742 }
11743 op__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_schema_change::Op::AddColumns)
11744;
11745 }
11746 GeneratedField::DropColumns => {
11747 if op__.is_some() {
11748 return Err(serde::de::Error::duplicate_field("dropColumns"));
11749 }
11750 op__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_schema_change::Op::DropColumns)
11751;
11752 }
11753 }
11754 }
11755 Ok(SinkSchemaChange {
11756 original_schema: original_schema__.unwrap_or_default(),
11757 op: op__,
11758 })
11759 }
11760 }
11761 deserializer.deserialize_struct("stream_plan.SinkSchemaChange", FIELDS, GeneratedVisitor)
11762 }
11763}
11764impl serde::Serialize for SortNode {
11765 #[allow(deprecated)]
11766 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11767 where
11768 S: serde::Serializer,
11769 {
11770 use serde::ser::SerializeStruct;
11771 let mut len = 0;
11772 if self.state_table.is_some() {
11773 len += 1;
11774 }
11775 if self.sort_column_index != 0 {
11776 len += 1;
11777 }
11778 let mut struct_ser = serializer.serialize_struct("stream_plan.SortNode", len)?;
11779 if let Some(v) = self.state_table.as_ref() {
11780 struct_ser.serialize_field("stateTable", v)?;
11781 }
11782 if self.sort_column_index != 0 {
11783 struct_ser.serialize_field("sortColumnIndex", &self.sort_column_index)?;
11784 }
11785 struct_ser.end()
11786 }
11787}
11788impl<'de> serde::Deserialize<'de> for SortNode {
11789 #[allow(deprecated)]
11790 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11791 where
11792 D: serde::Deserializer<'de>,
11793 {
11794 const FIELDS: &[&str] = &[
11795 "state_table",
11796 "stateTable",
11797 "sort_column_index",
11798 "sortColumnIndex",
11799 ];
11800
11801 #[allow(clippy::enum_variant_names)]
11802 enum GeneratedField {
11803 StateTable,
11804 SortColumnIndex,
11805 }
11806 impl<'de> serde::Deserialize<'de> for GeneratedField {
11807 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11808 where
11809 D: serde::Deserializer<'de>,
11810 {
11811 struct GeneratedVisitor;
11812
11813 impl serde::de::Visitor<'_> for GeneratedVisitor {
11814 type Value = GeneratedField;
11815
11816 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11817 write!(formatter, "expected one of: {:?}", &FIELDS)
11818 }
11819
11820 #[allow(unused_variables)]
11821 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11822 where
11823 E: serde::de::Error,
11824 {
11825 match value {
11826 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11827 "sortColumnIndex" | "sort_column_index" => Ok(GeneratedField::SortColumnIndex),
11828 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11829 }
11830 }
11831 }
11832 deserializer.deserialize_identifier(GeneratedVisitor)
11833 }
11834 }
11835 struct GeneratedVisitor;
11836 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11837 type Value = SortNode;
11838
11839 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11840 formatter.write_str("struct stream_plan.SortNode")
11841 }
11842
11843 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
11844 where
11845 V: serde::de::MapAccess<'de>,
11846 {
11847 let mut state_table__ = None;
11848 let mut sort_column_index__ = None;
11849 while let Some(k) = map_.next_key()? {
11850 match k {
11851 GeneratedField::StateTable => {
11852 if state_table__.is_some() {
11853 return Err(serde::de::Error::duplicate_field("stateTable"));
11854 }
11855 state_table__ = map_.next_value()?;
11856 }
11857 GeneratedField::SortColumnIndex => {
11858 if sort_column_index__.is_some() {
11859 return Err(serde::de::Error::duplicate_field("sortColumnIndex"));
11860 }
11861 sort_column_index__ =
11862 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11863 ;
11864 }
11865 }
11866 }
11867 Ok(SortNode {
11868 state_table: state_table__,
11869 sort_column_index: sort_column_index__.unwrap_or_default(),
11870 })
11871 }
11872 }
11873 deserializer.deserialize_struct("stream_plan.SortNode", FIELDS, GeneratedVisitor)
11874 }
11875}
11876impl serde::Serialize for SourceBackfillNode {
11877 #[allow(deprecated)]
11878 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11879 where
11880 S: serde::Serializer,
11881 {
11882 use serde::ser::SerializeStruct;
11883 let mut len = 0;
11884 if self.upstream_source_id != 0 {
11885 len += 1;
11886 }
11887 if self.row_id_index.is_some() {
11888 len += 1;
11889 }
11890 if !self.columns.is_empty() {
11891 len += 1;
11892 }
11893 if self.info.is_some() {
11894 len += 1;
11895 }
11896 if !self.source_name.is_empty() {
11897 len += 1;
11898 }
11899 if !self.with_properties.is_empty() {
11900 len += 1;
11901 }
11902 if self.rate_limit.is_some() {
11903 len += 1;
11904 }
11905 if self.state_table.is_some() {
11906 len += 1;
11907 }
11908 if !self.secret_refs.is_empty() {
11909 len += 1;
11910 }
11911 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceBackfillNode", len)?;
11912 if self.upstream_source_id != 0 {
11913 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
11914 }
11915 if let Some(v) = self.row_id_index.as_ref() {
11916 struct_ser.serialize_field("rowIdIndex", v)?;
11917 }
11918 if !self.columns.is_empty() {
11919 struct_ser.serialize_field("columns", &self.columns)?;
11920 }
11921 if let Some(v) = self.info.as_ref() {
11922 struct_ser.serialize_field("info", v)?;
11923 }
11924 if !self.source_name.is_empty() {
11925 struct_ser.serialize_field("sourceName", &self.source_name)?;
11926 }
11927 if !self.with_properties.is_empty() {
11928 struct_ser.serialize_field("withProperties", &self.with_properties)?;
11929 }
11930 if let Some(v) = self.rate_limit.as_ref() {
11931 struct_ser.serialize_field("rateLimit", v)?;
11932 }
11933 if let Some(v) = self.state_table.as_ref() {
11934 struct_ser.serialize_field("stateTable", v)?;
11935 }
11936 if !self.secret_refs.is_empty() {
11937 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
11938 }
11939 struct_ser.end()
11940 }
11941}
11942impl<'de> serde::Deserialize<'de> for SourceBackfillNode {
11943 #[allow(deprecated)]
11944 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11945 where
11946 D: serde::Deserializer<'de>,
11947 {
11948 const FIELDS: &[&str] = &[
11949 "upstream_source_id",
11950 "upstreamSourceId",
11951 "row_id_index",
11952 "rowIdIndex",
11953 "columns",
11954 "info",
11955 "source_name",
11956 "sourceName",
11957 "with_properties",
11958 "withProperties",
11959 "rate_limit",
11960 "rateLimit",
11961 "state_table",
11962 "stateTable",
11963 "secret_refs",
11964 "secretRefs",
11965 ];
11966
11967 #[allow(clippy::enum_variant_names)]
11968 enum GeneratedField {
11969 UpstreamSourceId,
11970 RowIdIndex,
11971 Columns,
11972 Info,
11973 SourceName,
11974 WithProperties,
11975 RateLimit,
11976 StateTable,
11977 SecretRefs,
11978 }
11979 impl<'de> serde::Deserialize<'de> for GeneratedField {
11980 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11981 where
11982 D: serde::Deserializer<'de>,
11983 {
11984 struct GeneratedVisitor;
11985
11986 impl serde::de::Visitor<'_> for GeneratedVisitor {
11987 type Value = GeneratedField;
11988
11989 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11990 write!(formatter, "expected one of: {:?}", &FIELDS)
11991 }
11992
11993 #[allow(unused_variables)]
11994 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11995 where
11996 E: serde::de::Error,
11997 {
11998 match value {
11999 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
12000 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
12001 "columns" => Ok(GeneratedField::Columns),
12002 "info" => Ok(GeneratedField::Info),
12003 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
12004 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
12005 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
12006 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
12007 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
12008 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12009 }
12010 }
12011 }
12012 deserializer.deserialize_identifier(GeneratedVisitor)
12013 }
12014 }
12015 struct GeneratedVisitor;
12016 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12017 type Value = SourceBackfillNode;
12018
12019 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12020 formatter.write_str("struct stream_plan.SourceBackfillNode")
12021 }
12022
12023 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceBackfillNode, V::Error>
12024 where
12025 V: serde::de::MapAccess<'de>,
12026 {
12027 let mut upstream_source_id__ = None;
12028 let mut row_id_index__ = None;
12029 let mut columns__ = None;
12030 let mut info__ = None;
12031 let mut source_name__ = None;
12032 let mut with_properties__ = None;
12033 let mut rate_limit__ = None;
12034 let mut state_table__ = None;
12035 let mut secret_refs__ = None;
12036 while let Some(k) = map_.next_key()? {
12037 match k {
12038 GeneratedField::UpstreamSourceId => {
12039 if upstream_source_id__.is_some() {
12040 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
12041 }
12042 upstream_source_id__ =
12043 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12044 ;
12045 }
12046 GeneratedField::RowIdIndex => {
12047 if row_id_index__.is_some() {
12048 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
12049 }
12050 row_id_index__ =
12051 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12052 ;
12053 }
12054 GeneratedField::Columns => {
12055 if columns__.is_some() {
12056 return Err(serde::de::Error::duplicate_field("columns"));
12057 }
12058 columns__ = Some(map_.next_value()?);
12059 }
12060 GeneratedField::Info => {
12061 if info__.is_some() {
12062 return Err(serde::de::Error::duplicate_field("info"));
12063 }
12064 info__ = map_.next_value()?;
12065 }
12066 GeneratedField::SourceName => {
12067 if source_name__.is_some() {
12068 return Err(serde::de::Error::duplicate_field("sourceName"));
12069 }
12070 source_name__ = Some(map_.next_value()?);
12071 }
12072 GeneratedField::WithProperties => {
12073 if with_properties__.is_some() {
12074 return Err(serde::de::Error::duplicate_field("withProperties"));
12075 }
12076 with_properties__ = Some(
12077 map_.next_value::<std::collections::BTreeMap<_, _>>()?
12078 );
12079 }
12080 GeneratedField::RateLimit => {
12081 if rate_limit__.is_some() {
12082 return Err(serde::de::Error::duplicate_field("rateLimit"));
12083 }
12084 rate_limit__ =
12085 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12086 ;
12087 }
12088 GeneratedField::StateTable => {
12089 if state_table__.is_some() {
12090 return Err(serde::de::Error::duplicate_field("stateTable"));
12091 }
12092 state_table__ = map_.next_value()?;
12093 }
12094 GeneratedField::SecretRefs => {
12095 if secret_refs__.is_some() {
12096 return Err(serde::de::Error::duplicate_field("secretRefs"));
12097 }
12098 secret_refs__ = Some(
12099 map_.next_value::<std::collections::BTreeMap<_, _>>()?
12100 );
12101 }
12102 }
12103 }
12104 Ok(SourceBackfillNode {
12105 upstream_source_id: upstream_source_id__.unwrap_or_default(),
12106 row_id_index: row_id_index__,
12107 columns: columns__.unwrap_or_default(),
12108 info: info__,
12109 source_name: source_name__.unwrap_or_default(),
12110 with_properties: with_properties__.unwrap_or_default(),
12111 rate_limit: rate_limit__,
12112 state_table: state_table__,
12113 secret_refs: secret_refs__.unwrap_or_default(),
12114 })
12115 }
12116 }
12117 deserializer.deserialize_struct("stream_plan.SourceBackfillNode", FIELDS, GeneratedVisitor)
12118 }
12119}
12120impl serde::Serialize for SourceChangeSplitMutation {
12121 #[allow(deprecated)]
12122 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12123 where
12124 S: serde::Serializer,
12125 {
12126 use serde::ser::SerializeStruct;
12127 let mut len = 0;
12128 if !self.actor_splits.is_empty() {
12129 len += 1;
12130 }
12131 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceChangeSplitMutation", len)?;
12132 if !self.actor_splits.is_empty() {
12133 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
12134 }
12135 struct_ser.end()
12136 }
12137}
12138impl<'de> serde::Deserialize<'de> for SourceChangeSplitMutation {
12139 #[allow(deprecated)]
12140 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12141 where
12142 D: serde::Deserializer<'de>,
12143 {
12144 const FIELDS: &[&str] = &[
12145 "actor_splits",
12146 "actorSplits",
12147 ];
12148
12149 #[allow(clippy::enum_variant_names)]
12150 enum GeneratedField {
12151 ActorSplits,
12152 }
12153 impl<'de> serde::Deserialize<'de> for GeneratedField {
12154 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12155 where
12156 D: serde::Deserializer<'de>,
12157 {
12158 struct GeneratedVisitor;
12159
12160 impl serde::de::Visitor<'_> for GeneratedVisitor {
12161 type Value = GeneratedField;
12162
12163 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12164 write!(formatter, "expected one of: {:?}", &FIELDS)
12165 }
12166
12167 #[allow(unused_variables)]
12168 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12169 where
12170 E: serde::de::Error,
12171 {
12172 match value {
12173 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
12174 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12175 }
12176 }
12177 }
12178 deserializer.deserialize_identifier(GeneratedVisitor)
12179 }
12180 }
12181 struct GeneratedVisitor;
12182 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12183 type Value = SourceChangeSplitMutation;
12184
12185 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12186 formatter.write_str("struct stream_plan.SourceChangeSplitMutation")
12187 }
12188
12189 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceChangeSplitMutation, V::Error>
12190 where
12191 V: serde::de::MapAccess<'de>,
12192 {
12193 let mut actor_splits__ = None;
12194 while let Some(k) = map_.next_key()? {
12195 match k {
12196 GeneratedField::ActorSplits => {
12197 if actor_splits__.is_some() {
12198 return Err(serde::de::Error::duplicate_field("actorSplits"));
12199 }
12200 actor_splits__ = Some(
12201 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
12202 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
12203 );
12204 }
12205 }
12206 }
12207 Ok(SourceChangeSplitMutation {
12208 actor_splits: actor_splits__.unwrap_or_default(),
12209 })
12210 }
12211 }
12212 deserializer.deserialize_struct("stream_plan.SourceChangeSplitMutation", FIELDS, GeneratedVisitor)
12213 }
12214}
12215impl serde::Serialize for SourceNode {
12216 #[allow(deprecated)]
12217 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12218 where
12219 S: serde::Serializer,
12220 {
12221 use serde::ser::SerializeStruct;
12222 let mut len = 0;
12223 if self.source_inner.is_some() {
12224 len += 1;
12225 }
12226 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceNode", len)?;
12227 if let Some(v) = self.source_inner.as_ref() {
12228 struct_ser.serialize_field("sourceInner", v)?;
12229 }
12230 struct_ser.end()
12231 }
12232}
12233impl<'de> serde::Deserialize<'de> for SourceNode {
12234 #[allow(deprecated)]
12235 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12236 where
12237 D: serde::Deserializer<'de>,
12238 {
12239 const FIELDS: &[&str] = &[
12240 "source_inner",
12241 "sourceInner",
12242 ];
12243
12244 #[allow(clippy::enum_variant_names)]
12245 enum GeneratedField {
12246 SourceInner,
12247 }
12248 impl<'de> serde::Deserialize<'de> for GeneratedField {
12249 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12250 where
12251 D: serde::Deserializer<'de>,
12252 {
12253 struct GeneratedVisitor;
12254
12255 impl serde::de::Visitor<'_> for GeneratedVisitor {
12256 type Value = GeneratedField;
12257
12258 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12259 write!(formatter, "expected one of: {:?}", &FIELDS)
12260 }
12261
12262 #[allow(unused_variables)]
12263 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12264 where
12265 E: serde::de::Error,
12266 {
12267 match value {
12268 "sourceInner" | "source_inner" => Ok(GeneratedField::SourceInner),
12269 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12270 }
12271 }
12272 }
12273 deserializer.deserialize_identifier(GeneratedVisitor)
12274 }
12275 }
12276 struct GeneratedVisitor;
12277 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12278 type Value = SourceNode;
12279
12280 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12281 formatter.write_str("struct stream_plan.SourceNode")
12282 }
12283
12284 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
12285 where
12286 V: serde::de::MapAccess<'de>,
12287 {
12288 let mut source_inner__ = None;
12289 while let Some(k) = map_.next_key()? {
12290 match k {
12291 GeneratedField::SourceInner => {
12292 if source_inner__.is_some() {
12293 return Err(serde::de::Error::duplicate_field("sourceInner"));
12294 }
12295 source_inner__ = map_.next_value()?;
12296 }
12297 }
12298 }
12299 Ok(SourceNode {
12300 source_inner: source_inner__,
12301 })
12302 }
12303 }
12304 deserializer.deserialize_struct("stream_plan.SourceNode", FIELDS, GeneratedVisitor)
12305 }
12306}
12307impl serde::Serialize for StartFragmentBackfillMutation {
12308 #[allow(deprecated)]
12309 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12310 where
12311 S: serde::Serializer,
12312 {
12313 use serde::ser::SerializeStruct;
12314 let mut len = 0;
12315 if !self.fragment_ids.is_empty() {
12316 len += 1;
12317 }
12318 let mut struct_ser = serializer.serialize_struct("stream_plan.StartFragmentBackfillMutation", len)?;
12319 if !self.fragment_ids.is_empty() {
12320 struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
12321 }
12322 struct_ser.end()
12323 }
12324}
12325impl<'de> serde::Deserialize<'de> for StartFragmentBackfillMutation {
12326 #[allow(deprecated)]
12327 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12328 where
12329 D: serde::Deserializer<'de>,
12330 {
12331 const FIELDS: &[&str] = &[
12332 "fragment_ids",
12333 "fragmentIds",
12334 ];
12335
12336 #[allow(clippy::enum_variant_names)]
12337 enum GeneratedField {
12338 FragmentIds,
12339 }
12340 impl<'de> serde::Deserialize<'de> for GeneratedField {
12341 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12342 where
12343 D: serde::Deserializer<'de>,
12344 {
12345 struct GeneratedVisitor;
12346
12347 impl serde::de::Visitor<'_> for GeneratedVisitor {
12348 type Value = GeneratedField;
12349
12350 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12351 write!(formatter, "expected one of: {:?}", &FIELDS)
12352 }
12353
12354 #[allow(unused_variables)]
12355 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12356 where
12357 E: serde::de::Error,
12358 {
12359 match value {
12360 "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
12361 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12362 }
12363 }
12364 }
12365 deserializer.deserialize_identifier(GeneratedVisitor)
12366 }
12367 }
12368 struct GeneratedVisitor;
12369 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12370 type Value = StartFragmentBackfillMutation;
12371
12372 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12373 formatter.write_str("struct stream_plan.StartFragmentBackfillMutation")
12374 }
12375
12376 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StartFragmentBackfillMutation, V::Error>
12377 where
12378 V: serde::de::MapAccess<'de>,
12379 {
12380 let mut fragment_ids__ = None;
12381 while let Some(k) = map_.next_key()? {
12382 match k {
12383 GeneratedField::FragmentIds => {
12384 if fragment_ids__.is_some() {
12385 return Err(serde::de::Error::duplicate_field("fragmentIds"));
12386 }
12387 fragment_ids__ =
12388 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12389 .into_iter().map(|x| x.0).collect())
12390 ;
12391 }
12392 }
12393 }
12394 Ok(StartFragmentBackfillMutation {
12395 fragment_ids: fragment_ids__.unwrap_or_default(),
12396 })
12397 }
12398 }
12399 deserializer.deserialize_struct("stream_plan.StartFragmentBackfillMutation", FIELDS, GeneratedVisitor)
12400 }
12401}
12402impl serde::Serialize for StopMutation {
12403 #[allow(deprecated)]
12404 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12405 where
12406 S: serde::Serializer,
12407 {
12408 use serde::ser::SerializeStruct;
12409 let mut len = 0;
12410 if !self.actors.is_empty() {
12411 len += 1;
12412 }
12413 if !self.dropped_sink_fragments.is_empty() {
12414 len += 1;
12415 }
12416 let mut struct_ser = serializer.serialize_struct("stream_plan.StopMutation", len)?;
12417 if !self.actors.is_empty() {
12418 struct_ser.serialize_field("actors", &self.actors)?;
12419 }
12420 if !self.dropped_sink_fragments.is_empty() {
12421 struct_ser.serialize_field("droppedSinkFragments", &self.dropped_sink_fragments)?;
12422 }
12423 struct_ser.end()
12424 }
12425}
12426impl<'de> serde::Deserialize<'de> for StopMutation {
12427 #[allow(deprecated)]
12428 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12429 where
12430 D: serde::Deserializer<'de>,
12431 {
12432 const FIELDS: &[&str] = &[
12433 "actors",
12434 "dropped_sink_fragments",
12435 "droppedSinkFragments",
12436 ];
12437
12438 #[allow(clippy::enum_variant_names)]
12439 enum GeneratedField {
12440 Actors,
12441 DroppedSinkFragments,
12442 }
12443 impl<'de> serde::Deserialize<'de> for GeneratedField {
12444 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12445 where
12446 D: serde::Deserializer<'de>,
12447 {
12448 struct GeneratedVisitor;
12449
12450 impl serde::de::Visitor<'_> for GeneratedVisitor {
12451 type Value = GeneratedField;
12452
12453 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12454 write!(formatter, "expected one of: {:?}", &FIELDS)
12455 }
12456
12457 #[allow(unused_variables)]
12458 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12459 where
12460 E: serde::de::Error,
12461 {
12462 match value {
12463 "actors" => Ok(GeneratedField::Actors),
12464 "droppedSinkFragments" | "dropped_sink_fragments" => Ok(GeneratedField::DroppedSinkFragments),
12465 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12466 }
12467 }
12468 }
12469 deserializer.deserialize_identifier(GeneratedVisitor)
12470 }
12471 }
12472 struct GeneratedVisitor;
12473 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12474 type Value = StopMutation;
12475
12476 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12477 formatter.write_str("struct stream_plan.StopMutation")
12478 }
12479
12480 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopMutation, V::Error>
12481 where
12482 V: serde::de::MapAccess<'de>,
12483 {
12484 let mut actors__ = None;
12485 let mut dropped_sink_fragments__ = None;
12486 while let Some(k) = map_.next_key()? {
12487 match k {
12488 GeneratedField::Actors => {
12489 if actors__.is_some() {
12490 return Err(serde::de::Error::duplicate_field("actors"));
12491 }
12492 actors__ =
12493 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12494 .into_iter().map(|x| x.0).collect())
12495 ;
12496 }
12497 GeneratedField::DroppedSinkFragments => {
12498 if dropped_sink_fragments__.is_some() {
12499 return Err(serde::de::Error::duplicate_field("droppedSinkFragments"));
12500 }
12501 dropped_sink_fragments__ =
12502 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12503 .into_iter().map(|x| x.0).collect())
12504 ;
12505 }
12506 }
12507 }
12508 Ok(StopMutation {
12509 actors: actors__.unwrap_or_default(),
12510 dropped_sink_fragments: dropped_sink_fragments__.unwrap_or_default(),
12511 })
12512 }
12513 }
12514 deserializer.deserialize_struct("stream_plan.StopMutation", FIELDS, GeneratedVisitor)
12515 }
12516}
12517impl serde::Serialize for StreamActor {
12518 #[allow(deprecated)]
12519 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12520 where
12521 S: serde::Serializer,
12522 {
12523 use serde::ser::SerializeStruct;
12524 let mut len = 0;
12525 if self.actor_id != 0 {
12526 len += 1;
12527 }
12528 if self.fragment_id != 0 {
12529 len += 1;
12530 }
12531 if !self.dispatcher.is_empty() {
12532 len += 1;
12533 }
12534 if self.vnode_bitmap.is_some() {
12535 len += 1;
12536 }
12537 if !self.mview_definition.is_empty() {
12538 len += 1;
12539 }
12540 if self.expr_context.is_some() {
12541 len += 1;
12542 }
12543 if !self.config_override.is_empty() {
12544 len += 1;
12545 }
12546 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamActor", len)?;
12547 if self.actor_id != 0 {
12548 struct_ser.serialize_field("actorId", &self.actor_id)?;
12549 }
12550 if self.fragment_id != 0 {
12551 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
12552 }
12553 if !self.dispatcher.is_empty() {
12554 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
12555 }
12556 if let Some(v) = self.vnode_bitmap.as_ref() {
12557 struct_ser.serialize_field("vnodeBitmap", v)?;
12558 }
12559 if !self.mview_definition.is_empty() {
12560 struct_ser.serialize_field("mviewDefinition", &self.mview_definition)?;
12561 }
12562 if let Some(v) = self.expr_context.as_ref() {
12563 struct_ser.serialize_field("exprContext", v)?;
12564 }
12565 if !self.config_override.is_empty() {
12566 struct_ser.serialize_field("configOverride", &self.config_override)?;
12567 }
12568 struct_ser.end()
12569 }
12570}
12571impl<'de> serde::Deserialize<'de> for StreamActor {
12572 #[allow(deprecated)]
12573 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12574 where
12575 D: serde::Deserializer<'de>,
12576 {
12577 const FIELDS: &[&str] = &[
12578 "actor_id",
12579 "actorId",
12580 "fragment_id",
12581 "fragmentId",
12582 "dispatcher",
12583 "vnode_bitmap",
12584 "vnodeBitmap",
12585 "mview_definition",
12586 "mviewDefinition",
12587 "expr_context",
12588 "exprContext",
12589 "config_override",
12590 "configOverride",
12591 ];
12592
12593 #[allow(clippy::enum_variant_names)]
12594 enum GeneratedField {
12595 ActorId,
12596 FragmentId,
12597 Dispatcher,
12598 VnodeBitmap,
12599 MviewDefinition,
12600 ExprContext,
12601 ConfigOverride,
12602 }
12603 impl<'de> serde::Deserialize<'de> for GeneratedField {
12604 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12605 where
12606 D: serde::Deserializer<'de>,
12607 {
12608 struct GeneratedVisitor;
12609
12610 impl serde::de::Visitor<'_> for GeneratedVisitor {
12611 type Value = GeneratedField;
12612
12613 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12614 write!(formatter, "expected one of: {:?}", &FIELDS)
12615 }
12616
12617 #[allow(unused_variables)]
12618 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12619 where
12620 E: serde::de::Error,
12621 {
12622 match value {
12623 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
12624 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
12625 "dispatcher" => Ok(GeneratedField::Dispatcher),
12626 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
12627 "mviewDefinition" | "mview_definition" => Ok(GeneratedField::MviewDefinition),
12628 "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
12629 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
12630 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12631 }
12632 }
12633 }
12634 deserializer.deserialize_identifier(GeneratedVisitor)
12635 }
12636 }
12637 struct GeneratedVisitor;
12638 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12639 type Value = StreamActor;
12640
12641 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12642 formatter.write_str("struct stream_plan.StreamActor")
12643 }
12644
12645 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamActor, V::Error>
12646 where
12647 V: serde::de::MapAccess<'de>,
12648 {
12649 let mut actor_id__ = None;
12650 let mut fragment_id__ = None;
12651 let mut dispatcher__ = None;
12652 let mut vnode_bitmap__ = None;
12653 let mut mview_definition__ = None;
12654 let mut expr_context__ = None;
12655 let mut config_override__ = None;
12656 while let Some(k) = map_.next_key()? {
12657 match k {
12658 GeneratedField::ActorId => {
12659 if actor_id__.is_some() {
12660 return Err(serde::de::Error::duplicate_field("actorId"));
12661 }
12662 actor_id__ =
12663 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12664 ;
12665 }
12666 GeneratedField::FragmentId => {
12667 if fragment_id__.is_some() {
12668 return Err(serde::de::Error::duplicate_field("fragmentId"));
12669 }
12670 fragment_id__ =
12671 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12672 ;
12673 }
12674 GeneratedField::Dispatcher => {
12675 if dispatcher__.is_some() {
12676 return Err(serde::de::Error::duplicate_field("dispatcher"));
12677 }
12678 dispatcher__ = Some(map_.next_value()?);
12679 }
12680 GeneratedField::VnodeBitmap => {
12681 if vnode_bitmap__.is_some() {
12682 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
12683 }
12684 vnode_bitmap__ = map_.next_value()?;
12685 }
12686 GeneratedField::MviewDefinition => {
12687 if mview_definition__.is_some() {
12688 return Err(serde::de::Error::duplicate_field("mviewDefinition"));
12689 }
12690 mview_definition__ = Some(map_.next_value()?);
12691 }
12692 GeneratedField::ExprContext => {
12693 if expr_context__.is_some() {
12694 return Err(serde::de::Error::duplicate_field("exprContext"));
12695 }
12696 expr_context__ = map_.next_value()?;
12697 }
12698 GeneratedField::ConfigOverride => {
12699 if config_override__.is_some() {
12700 return Err(serde::de::Error::duplicate_field("configOverride"));
12701 }
12702 config_override__ = Some(map_.next_value()?);
12703 }
12704 }
12705 }
12706 Ok(StreamActor {
12707 actor_id: actor_id__.unwrap_or_default(),
12708 fragment_id: fragment_id__.unwrap_or_default(),
12709 dispatcher: dispatcher__.unwrap_or_default(),
12710 vnode_bitmap: vnode_bitmap__,
12711 mview_definition: mview_definition__.unwrap_or_default(),
12712 expr_context: expr_context__,
12713 config_override: config_override__.unwrap_or_default(),
12714 })
12715 }
12716 }
12717 deserializer.deserialize_struct("stream_plan.StreamActor", FIELDS, GeneratedVisitor)
12718 }
12719}
12720impl serde::Serialize for StreamCdcScanNode {
12721 #[allow(deprecated)]
12722 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12723 where
12724 S: serde::Serializer,
12725 {
12726 use serde::ser::SerializeStruct;
12727 let mut len = 0;
12728 if self.table_id != 0 {
12729 len += 1;
12730 }
12731 if !self.upstream_column_ids.is_empty() {
12732 len += 1;
12733 }
12734 if !self.output_indices.is_empty() {
12735 len += 1;
12736 }
12737 if self.state_table.is_some() {
12738 len += 1;
12739 }
12740 if self.cdc_table_desc.is_some() {
12741 len += 1;
12742 }
12743 if self.rate_limit.is_some() {
12744 len += 1;
12745 }
12746 if self.disable_backfill {
12747 len += 1;
12748 }
12749 if self.options.is_some() {
12750 len += 1;
12751 }
12752 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanNode", len)?;
12753 if self.table_id != 0 {
12754 struct_ser.serialize_field("tableId", &self.table_id)?;
12755 }
12756 if !self.upstream_column_ids.is_empty() {
12757 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
12758 }
12759 if !self.output_indices.is_empty() {
12760 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
12761 }
12762 if let Some(v) = self.state_table.as_ref() {
12763 struct_ser.serialize_field("stateTable", v)?;
12764 }
12765 if let Some(v) = self.cdc_table_desc.as_ref() {
12766 struct_ser.serialize_field("cdcTableDesc", v)?;
12767 }
12768 if let Some(v) = self.rate_limit.as_ref() {
12769 struct_ser.serialize_field("rateLimit", v)?;
12770 }
12771 if self.disable_backfill {
12772 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
12773 }
12774 if let Some(v) = self.options.as_ref() {
12775 struct_ser.serialize_field("options", v)?;
12776 }
12777 struct_ser.end()
12778 }
12779}
12780impl<'de> serde::Deserialize<'de> for StreamCdcScanNode {
12781 #[allow(deprecated)]
12782 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12783 where
12784 D: serde::Deserializer<'de>,
12785 {
12786 const FIELDS: &[&str] = &[
12787 "table_id",
12788 "tableId",
12789 "upstream_column_ids",
12790 "upstreamColumnIds",
12791 "output_indices",
12792 "outputIndices",
12793 "state_table",
12794 "stateTable",
12795 "cdc_table_desc",
12796 "cdcTableDesc",
12797 "rate_limit",
12798 "rateLimit",
12799 "disable_backfill",
12800 "disableBackfill",
12801 "options",
12802 ];
12803
12804 #[allow(clippy::enum_variant_names)]
12805 enum GeneratedField {
12806 TableId,
12807 UpstreamColumnIds,
12808 OutputIndices,
12809 StateTable,
12810 CdcTableDesc,
12811 RateLimit,
12812 DisableBackfill,
12813 Options,
12814 }
12815 impl<'de> serde::Deserialize<'de> for GeneratedField {
12816 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12817 where
12818 D: serde::Deserializer<'de>,
12819 {
12820 struct GeneratedVisitor;
12821
12822 impl serde::de::Visitor<'_> for GeneratedVisitor {
12823 type Value = GeneratedField;
12824
12825 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12826 write!(formatter, "expected one of: {:?}", &FIELDS)
12827 }
12828
12829 #[allow(unused_variables)]
12830 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12831 where
12832 E: serde::de::Error,
12833 {
12834 match value {
12835 "tableId" | "table_id" => Ok(GeneratedField::TableId),
12836 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
12837 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
12838 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
12839 "cdcTableDesc" | "cdc_table_desc" => Ok(GeneratedField::CdcTableDesc),
12840 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
12841 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
12842 "options" => Ok(GeneratedField::Options),
12843 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12844 }
12845 }
12846 }
12847 deserializer.deserialize_identifier(GeneratedVisitor)
12848 }
12849 }
12850 struct GeneratedVisitor;
12851 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12852 type Value = StreamCdcScanNode;
12853
12854 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12855 formatter.write_str("struct stream_plan.StreamCdcScanNode")
12856 }
12857
12858 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanNode, V::Error>
12859 where
12860 V: serde::de::MapAccess<'de>,
12861 {
12862 let mut table_id__ = None;
12863 let mut upstream_column_ids__ = None;
12864 let mut output_indices__ = None;
12865 let mut state_table__ = None;
12866 let mut cdc_table_desc__ = None;
12867 let mut rate_limit__ = None;
12868 let mut disable_backfill__ = None;
12869 let mut options__ = None;
12870 while let Some(k) = map_.next_key()? {
12871 match k {
12872 GeneratedField::TableId => {
12873 if table_id__.is_some() {
12874 return Err(serde::de::Error::duplicate_field("tableId"));
12875 }
12876 table_id__ =
12877 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12878 ;
12879 }
12880 GeneratedField::UpstreamColumnIds => {
12881 if upstream_column_ids__.is_some() {
12882 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
12883 }
12884 upstream_column_ids__ =
12885 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12886 .into_iter().map(|x| x.0).collect())
12887 ;
12888 }
12889 GeneratedField::OutputIndices => {
12890 if output_indices__.is_some() {
12891 return Err(serde::de::Error::duplicate_field("outputIndices"));
12892 }
12893 output_indices__ =
12894 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12895 .into_iter().map(|x| x.0).collect())
12896 ;
12897 }
12898 GeneratedField::StateTable => {
12899 if state_table__.is_some() {
12900 return Err(serde::de::Error::duplicate_field("stateTable"));
12901 }
12902 state_table__ = map_.next_value()?;
12903 }
12904 GeneratedField::CdcTableDesc => {
12905 if cdc_table_desc__.is_some() {
12906 return Err(serde::de::Error::duplicate_field("cdcTableDesc"));
12907 }
12908 cdc_table_desc__ = map_.next_value()?;
12909 }
12910 GeneratedField::RateLimit => {
12911 if rate_limit__.is_some() {
12912 return Err(serde::de::Error::duplicate_field("rateLimit"));
12913 }
12914 rate_limit__ =
12915 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12916 ;
12917 }
12918 GeneratedField::DisableBackfill => {
12919 if disable_backfill__.is_some() {
12920 return Err(serde::de::Error::duplicate_field("disableBackfill"));
12921 }
12922 disable_backfill__ = Some(map_.next_value()?);
12923 }
12924 GeneratedField::Options => {
12925 if options__.is_some() {
12926 return Err(serde::de::Error::duplicate_field("options"));
12927 }
12928 options__ = map_.next_value()?;
12929 }
12930 }
12931 }
12932 Ok(StreamCdcScanNode {
12933 table_id: table_id__.unwrap_or_default(),
12934 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
12935 output_indices: output_indices__.unwrap_or_default(),
12936 state_table: state_table__,
12937 cdc_table_desc: cdc_table_desc__,
12938 rate_limit: rate_limit__,
12939 disable_backfill: disable_backfill__.unwrap_or_default(),
12940 options: options__,
12941 })
12942 }
12943 }
12944 deserializer.deserialize_struct("stream_plan.StreamCdcScanNode", FIELDS, GeneratedVisitor)
12945 }
12946}
12947impl serde::Serialize for StreamCdcScanOptions {
12948 #[allow(deprecated)]
12949 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12950 where
12951 S: serde::Serializer,
12952 {
12953 use serde::ser::SerializeStruct;
12954 let mut len = 0;
12955 if self.disable_backfill {
12956 len += 1;
12957 }
12958 if self.snapshot_barrier_interval != 0 {
12959 len += 1;
12960 }
12961 if self.snapshot_batch_size != 0 {
12962 len += 1;
12963 }
12964 if self.backfill_parallelism != 0 {
12965 len += 1;
12966 }
12967 if self.backfill_num_rows_per_split != 0 {
12968 len += 1;
12969 }
12970 if self.backfill_as_even_splits {
12971 len += 1;
12972 }
12973 if self.backfill_split_pk_column_index != 0 {
12974 len += 1;
12975 }
12976 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanOptions", len)?;
12977 if self.disable_backfill {
12978 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
12979 }
12980 if self.snapshot_barrier_interval != 0 {
12981 struct_ser.serialize_field("snapshotBarrierInterval", &self.snapshot_barrier_interval)?;
12982 }
12983 if self.snapshot_batch_size != 0 {
12984 struct_ser.serialize_field("snapshotBatchSize", &self.snapshot_batch_size)?;
12985 }
12986 if self.backfill_parallelism != 0 {
12987 struct_ser.serialize_field("backfillParallelism", &self.backfill_parallelism)?;
12988 }
12989 if self.backfill_num_rows_per_split != 0 {
12990 #[allow(clippy::needless_borrow)]
12991 #[allow(clippy::needless_borrows_for_generic_args)]
12992 struct_ser.serialize_field("backfillNumRowsPerSplit", ToString::to_string(&self.backfill_num_rows_per_split).as_str())?;
12993 }
12994 if self.backfill_as_even_splits {
12995 struct_ser.serialize_field("backfillAsEvenSplits", &self.backfill_as_even_splits)?;
12996 }
12997 if self.backfill_split_pk_column_index != 0 {
12998 struct_ser.serialize_field("backfillSplitPkColumnIndex", &self.backfill_split_pk_column_index)?;
12999 }
13000 struct_ser.end()
13001 }
13002}
13003impl<'de> serde::Deserialize<'de> for StreamCdcScanOptions {
13004 #[allow(deprecated)]
13005 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13006 where
13007 D: serde::Deserializer<'de>,
13008 {
13009 const FIELDS: &[&str] = &[
13010 "disable_backfill",
13011 "disableBackfill",
13012 "snapshot_barrier_interval",
13013 "snapshotBarrierInterval",
13014 "snapshot_batch_size",
13015 "snapshotBatchSize",
13016 "backfill_parallelism",
13017 "backfillParallelism",
13018 "backfill_num_rows_per_split",
13019 "backfillNumRowsPerSplit",
13020 "backfill_as_even_splits",
13021 "backfillAsEvenSplits",
13022 "backfill_split_pk_column_index",
13023 "backfillSplitPkColumnIndex",
13024 ];
13025
13026 #[allow(clippy::enum_variant_names)]
13027 enum GeneratedField {
13028 DisableBackfill,
13029 SnapshotBarrierInterval,
13030 SnapshotBatchSize,
13031 BackfillParallelism,
13032 BackfillNumRowsPerSplit,
13033 BackfillAsEvenSplits,
13034 BackfillSplitPkColumnIndex,
13035 }
13036 impl<'de> serde::Deserialize<'de> for GeneratedField {
13037 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13038 where
13039 D: serde::Deserializer<'de>,
13040 {
13041 struct GeneratedVisitor;
13042
13043 impl serde::de::Visitor<'_> for GeneratedVisitor {
13044 type Value = GeneratedField;
13045
13046 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13047 write!(formatter, "expected one of: {:?}", &FIELDS)
13048 }
13049
13050 #[allow(unused_variables)]
13051 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13052 where
13053 E: serde::de::Error,
13054 {
13055 match value {
13056 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
13057 "snapshotBarrierInterval" | "snapshot_barrier_interval" => Ok(GeneratedField::SnapshotBarrierInterval),
13058 "snapshotBatchSize" | "snapshot_batch_size" => Ok(GeneratedField::SnapshotBatchSize),
13059 "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
13060 "backfillNumRowsPerSplit" | "backfill_num_rows_per_split" => Ok(GeneratedField::BackfillNumRowsPerSplit),
13061 "backfillAsEvenSplits" | "backfill_as_even_splits" => Ok(GeneratedField::BackfillAsEvenSplits),
13062 "backfillSplitPkColumnIndex" | "backfill_split_pk_column_index" => Ok(GeneratedField::BackfillSplitPkColumnIndex),
13063 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13064 }
13065 }
13066 }
13067 deserializer.deserialize_identifier(GeneratedVisitor)
13068 }
13069 }
13070 struct GeneratedVisitor;
13071 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13072 type Value = StreamCdcScanOptions;
13073
13074 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13075 formatter.write_str("struct stream_plan.StreamCdcScanOptions")
13076 }
13077
13078 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanOptions, V::Error>
13079 where
13080 V: serde::de::MapAccess<'de>,
13081 {
13082 let mut disable_backfill__ = None;
13083 let mut snapshot_barrier_interval__ = None;
13084 let mut snapshot_batch_size__ = None;
13085 let mut backfill_parallelism__ = None;
13086 let mut backfill_num_rows_per_split__ = None;
13087 let mut backfill_as_even_splits__ = None;
13088 let mut backfill_split_pk_column_index__ = None;
13089 while let Some(k) = map_.next_key()? {
13090 match k {
13091 GeneratedField::DisableBackfill => {
13092 if disable_backfill__.is_some() {
13093 return Err(serde::de::Error::duplicate_field("disableBackfill"));
13094 }
13095 disable_backfill__ = Some(map_.next_value()?);
13096 }
13097 GeneratedField::SnapshotBarrierInterval => {
13098 if snapshot_barrier_interval__.is_some() {
13099 return Err(serde::de::Error::duplicate_field("snapshotBarrierInterval"));
13100 }
13101 snapshot_barrier_interval__ =
13102 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13103 ;
13104 }
13105 GeneratedField::SnapshotBatchSize => {
13106 if snapshot_batch_size__.is_some() {
13107 return Err(serde::de::Error::duplicate_field("snapshotBatchSize"));
13108 }
13109 snapshot_batch_size__ =
13110 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13111 ;
13112 }
13113 GeneratedField::BackfillParallelism => {
13114 if backfill_parallelism__.is_some() {
13115 return Err(serde::de::Error::duplicate_field("backfillParallelism"));
13116 }
13117 backfill_parallelism__ =
13118 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13119 ;
13120 }
13121 GeneratedField::BackfillNumRowsPerSplit => {
13122 if backfill_num_rows_per_split__.is_some() {
13123 return Err(serde::de::Error::duplicate_field("backfillNumRowsPerSplit"));
13124 }
13125 backfill_num_rows_per_split__ =
13126 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13127 ;
13128 }
13129 GeneratedField::BackfillAsEvenSplits => {
13130 if backfill_as_even_splits__.is_some() {
13131 return Err(serde::de::Error::duplicate_field("backfillAsEvenSplits"));
13132 }
13133 backfill_as_even_splits__ = Some(map_.next_value()?);
13134 }
13135 GeneratedField::BackfillSplitPkColumnIndex => {
13136 if backfill_split_pk_column_index__.is_some() {
13137 return Err(serde::de::Error::duplicate_field("backfillSplitPkColumnIndex"));
13138 }
13139 backfill_split_pk_column_index__ =
13140 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13141 ;
13142 }
13143 }
13144 }
13145 Ok(StreamCdcScanOptions {
13146 disable_backfill: disable_backfill__.unwrap_or_default(),
13147 snapshot_barrier_interval: snapshot_barrier_interval__.unwrap_or_default(),
13148 snapshot_batch_size: snapshot_batch_size__.unwrap_or_default(),
13149 backfill_parallelism: backfill_parallelism__.unwrap_or_default(),
13150 backfill_num_rows_per_split: backfill_num_rows_per_split__.unwrap_or_default(),
13151 backfill_as_even_splits: backfill_as_even_splits__.unwrap_or_default(),
13152 backfill_split_pk_column_index: backfill_split_pk_column_index__.unwrap_or_default(),
13153 })
13154 }
13155 }
13156 deserializer.deserialize_struct("stream_plan.StreamCdcScanOptions", FIELDS, GeneratedVisitor)
13157 }
13158}
13159impl serde::Serialize for StreamContext {
13160 #[allow(deprecated)]
13161 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13162 where
13163 S: serde::Serializer,
13164 {
13165 use serde::ser::SerializeStruct;
13166 let mut len = 0;
13167 if !self.timezone.is_empty() {
13168 len += 1;
13169 }
13170 if !self.config_override.is_empty() {
13171 len += 1;
13172 }
13173 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamContext", len)?;
13174 if !self.timezone.is_empty() {
13175 struct_ser.serialize_field("timezone", &self.timezone)?;
13176 }
13177 if !self.config_override.is_empty() {
13178 struct_ser.serialize_field("configOverride", &self.config_override)?;
13179 }
13180 struct_ser.end()
13181 }
13182}
13183impl<'de> serde::Deserialize<'de> for StreamContext {
13184 #[allow(deprecated)]
13185 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13186 where
13187 D: serde::Deserializer<'de>,
13188 {
13189 const FIELDS: &[&str] = &[
13190 "timezone",
13191 "config_override",
13192 "configOverride",
13193 ];
13194
13195 #[allow(clippy::enum_variant_names)]
13196 enum GeneratedField {
13197 Timezone,
13198 ConfigOverride,
13199 }
13200 impl<'de> serde::Deserialize<'de> for GeneratedField {
13201 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13202 where
13203 D: serde::Deserializer<'de>,
13204 {
13205 struct GeneratedVisitor;
13206
13207 impl serde::de::Visitor<'_> for GeneratedVisitor {
13208 type Value = GeneratedField;
13209
13210 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13211 write!(formatter, "expected one of: {:?}", &FIELDS)
13212 }
13213
13214 #[allow(unused_variables)]
13215 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13216 where
13217 E: serde::de::Error,
13218 {
13219 match value {
13220 "timezone" => Ok(GeneratedField::Timezone),
13221 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
13222 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13223 }
13224 }
13225 }
13226 deserializer.deserialize_identifier(GeneratedVisitor)
13227 }
13228 }
13229 struct GeneratedVisitor;
13230 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13231 type Value = StreamContext;
13232
13233 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13234 formatter.write_str("struct stream_plan.StreamContext")
13235 }
13236
13237 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamContext, V::Error>
13238 where
13239 V: serde::de::MapAccess<'de>,
13240 {
13241 let mut timezone__ = None;
13242 let mut config_override__ = None;
13243 while let Some(k) = map_.next_key()? {
13244 match k {
13245 GeneratedField::Timezone => {
13246 if timezone__.is_some() {
13247 return Err(serde::de::Error::duplicate_field("timezone"));
13248 }
13249 timezone__ = Some(map_.next_value()?);
13250 }
13251 GeneratedField::ConfigOverride => {
13252 if config_override__.is_some() {
13253 return Err(serde::de::Error::duplicate_field("configOverride"));
13254 }
13255 config_override__ = Some(map_.next_value()?);
13256 }
13257 }
13258 }
13259 Ok(StreamContext {
13260 timezone: timezone__.unwrap_or_default(),
13261 config_override: config_override__.unwrap_or_default(),
13262 })
13263 }
13264 }
13265 deserializer.deserialize_struct("stream_plan.StreamContext", FIELDS, GeneratedVisitor)
13266 }
13267}
13268impl serde::Serialize for StreamFragmentGraph {
13269 #[allow(deprecated)]
13270 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13271 where
13272 S: serde::Serializer,
13273 {
13274 use serde::ser::SerializeStruct;
13275 let mut len = 0;
13276 if !self.fragments.is_empty() {
13277 len += 1;
13278 }
13279 if !self.edges.is_empty() {
13280 len += 1;
13281 }
13282 if !self.dependent_table_ids.is_empty() {
13283 len += 1;
13284 }
13285 if self.table_ids_cnt != 0 {
13286 len += 1;
13287 }
13288 if self.ctx.is_some() {
13289 len += 1;
13290 }
13291 if self.parallelism.is_some() {
13292 len += 1;
13293 }
13294 if self.backfill_parallelism.is_some() {
13295 len += 1;
13296 }
13297 if !self.adaptive_parallelism_strategy.is_empty() {
13298 len += 1;
13299 }
13300 if !self.backfill_adaptive_parallelism_strategy.is_empty() {
13301 len += 1;
13302 }
13303 if self.max_parallelism != 0 {
13304 len += 1;
13305 }
13306 if self.backfill_order.is_some() {
13307 len += 1;
13308 }
13309 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph", len)?;
13310 if !self.fragments.is_empty() {
13311 struct_ser.serialize_field("fragments", &self.fragments)?;
13312 }
13313 if !self.edges.is_empty() {
13314 struct_ser.serialize_field("edges", &self.edges)?;
13315 }
13316 if !self.dependent_table_ids.is_empty() {
13317 struct_ser.serialize_field("dependentTableIds", &self.dependent_table_ids)?;
13318 }
13319 if self.table_ids_cnt != 0 {
13320 struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
13321 }
13322 if let Some(v) = self.ctx.as_ref() {
13323 struct_ser.serialize_field("ctx", v)?;
13324 }
13325 if let Some(v) = self.parallelism.as_ref() {
13326 struct_ser.serialize_field("parallelism", v)?;
13327 }
13328 if let Some(v) = self.backfill_parallelism.as_ref() {
13329 struct_ser.serialize_field("backfillParallelism", v)?;
13330 }
13331 if !self.adaptive_parallelism_strategy.is_empty() {
13332 struct_ser.serialize_field("adaptiveParallelismStrategy", &self.adaptive_parallelism_strategy)?;
13333 }
13334 if !self.backfill_adaptive_parallelism_strategy.is_empty() {
13335 struct_ser.serialize_field("backfillAdaptiveParallelismStrategy", &self.backfill_adaptive_parallelism_strategy)?;
13336 }
13337 if self.max_parallelism != 0 {
13338 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
13339 }
13340 if let Some(v) = self.backfill_order.as_ref() {
13341 struct_ser.serialize_field("backfillOrder", v)?;
13342 }
13343 struct_ser.end()
13344 }
13345}
13346impl<'de> serde::Deserialize<'de> for StreamFragmentGraph {
13347 #[allow(deprecated)]
13348 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13349 where
13350 D: serde::Deserializer<'de>,
13351 {
13352 const FIELDS: &[&str] = &[
13353 "fragments",
13354 "edges",
13355 "dependent_table_ids",
13356 "dependentTableIds",
13357 "table_ids_cnt",
13358 "tableIdsCnt",
13359 "ctx",
13360 "parallelism",
13361 "backfill_parallelism",
13362 "backfillParallelism",
13363 "adaptive_parallelism_strategy",
13364 "adaptiveParallelismStrategy",
13365 "backfill_adaptive_parallelism_strategy",
13366 "backfillAdaptiveParallelismStrategy",
13367 "max_parallelism",
13368 "maxParallelism",
13369 "backfill_order",
13370 "backfillOrder",
13371 ];
13372
13373 #[allow(clippy::enum_variant_names)]
13374 enum GeneratedField {
13375 Fragments,
13376 Edges,
13377 DependentTableIds,
13378 TableIdsCnt,
13379 Ctx,
13380 Parallelism,
13381 BackfillParallelism,
13382 AdaptiveParallelismStrategy,
13383 BackfillAdaptiveParallelismStrategy,
13384 MaxParallelism,
13385 BackfillOrder,
13386 }
13387 impl<'de> serde::Deserialize<'de> for GeneratedField {
13388 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13389 where
13390 D: serde::Deserializer<'de>,
13391 {
13392 struct GeneratedVisitor;
13393
13394 impl serde::de::Visitor<'_> for GeneratedVisitor {
13395 type Value = GeneratedField;
13396
13397 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13398 write!(formatter, "expected one of: {:?}", &FIELDS)
13399 }
13400
13401 #[allow(unused_variables)]
13402 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13403 where
13404 E: serde::de::Error,
13405 {
13406 match value {
13407 "fragments" => Ok(GeneratedField::Fragments),
13408 "edges" => Ok(GeneratedField::Edges),
13409 "dependentTableIds" | "dependent_table_ids" => Ok(GeneratedField::DependentTableIds),
13410 "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
13411 "ctx" => Ok(GeneratedField::Ctx),
13412 "parallelism" => Ok(GeneratedField::Parallelism),
13413 "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
13414 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
13415 "backfillAdaptiveParallelismStrategy" | "backfill_adaptive_parallelism_strategy" => Ok(GeneratedField::BackfillAdaptiveParallelismStrategy),
13416 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
13417 "backfillOrder" | "backfill_order" => Ok(GeneratedField::BackfillOrder),
13418 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13419 }
13420 }
13421 }
13422 deserializer.deserialize_identifier(GeneratedVisitor)
13423 }
13424 }
13425 struct GeneratedVisitor;
13426 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13427 type Value = StreamFragmentGraph;
13428
13429 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13430 formatter.write_str("struct stream_plan.StreamFragmentGraph")
13431 }
13432
13433 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFragmentGraph, V::Error>
13434 where
13435 V: serde::de::MapAccess<'de>,
13436 {
13437 let mut fragments__ = None;
13438 let mut edges__ = None;
13439 let mut dependent_table_ids__ = None;
13440 let mut table_ids_cnt__ = None;
13441 let mut ctx__ = None;
13442 let mut parallelism__ = None;
13443 let mut backfill_parallelism__ = None;
13444 let mut adaptive_parallelism_strategy__ = None;
13445 let mut backfill_adaptive_parallelism_strategy__ = None;
13446 let mut max_parallelism__ = None;
13447 let mut backfill_order__ = None;
13448 while let Some(k) = map_.next_key()? {
13449 match k {
13450 GeneratedField::Fragments => {
13451 if fragments__.is_some() {
13452 return Err(serde::de::Error::duplicate_field("fragments"));
13453 }
13454 fragments__ = Some(
13455 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
13456 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
13457 );
13458 }
13459 GeneratedField::Edges => {
13460 if edges__.is_some() {
13461 return Err(serde::de::Error::duplicate_field("edges"));
13462 }
13463 edges__ = Some(map_.next_value()?);
13464 }
13465 GeneratedField::DependentTableIds => {
13466 if dependent_table_ids__.is_some() {
13467 return Err(serde::de::Error::duplicate_field("dependentTableIds"));
13468 }
13469 dependent_table_ids__ =
13470 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13471 .into_iter().map(|x| x.0).collect())
13472 ;
13473 }
13474 GeneratedField::TableIdsCnt => {
13475 if table_ids_cnt__.is_some() {
13476 return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
13477 }
13478 table_ids_cnt__ =
13479 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13480 ;
13481 }
13482 GeneratedField::Ctx => {
13483 if ctx__.is_some() {
13484 return Err(serde::de::Error::duplicate_field("ctx"));
13485 }
13486 ctx__ = map_.next_value()?;
13487 }
13488 GeneratedField::Parallelism => {
13489 if parallelism__.is_some() {
13490 return Err(serde::de::Error::duplicate_field("parallelism"));
13491 }
13492 parallelism__ = map_.next_value()?;
13493 }
13494 GeneratedField::BackfillParallelism => {
13495 if backfill_parallelism__.is_some() {
13496 return Err(serde::de::Error::duplicate_field("backfillParallelism"));
13497 }
13498 backfill_parallelism__ = map_.next_value()?;
13499 }
13500 GeneratedField::AdaptiveParallelismStrategy => {
13501 if adaptive_parallelism_strategy__.is_some() {
13502 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
13503 }
13504 adaptive_parallelism_strategy__ = Some(map_.next_value()?);
13505 }
13506 GeneratedField::BackfillAdaptiveParallelismStrategy => {
13507 if backfill_adaptive_parallelism_strategy__.is_some() {
13508 return Err(serde::de::Error::duplicate_field("backfillAdaptiveParallelismStrategy"));
13509 }
13510 backfill_adaptive_parallelism_strategy__ = Some(map_.next_value()?);
13511 }
13512 GeneratedField::MaxParallelism => {
13513 if max_parallelism__.is_some() {
13514 return Err(serde::de::Error::duplicate_field("maxParallelism"));
13515 }
13516 max_parallelism__ =
13517 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13518 ;
13519 }
13520 GeneratedField::BackfillOrder => {
13521 if backfill_order__.is_some() {
13522 return Err(serde::de::Error::duplicate_field("backfillOrder"));
13523 }
13524 backfill_order__ = map_.next_value()?;
13525 }
13526 }
13527 }
13528 Ok(StreamFragmentGraph {
13529 fragments: fragments__.unwrap_or_default(),
13530 edges: edges__.unwrap_or_default(),
13531 dependent_table_ids: dependent_table_ids__.unwrap_or_default(),
13532 table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
13533 ctx: ctx__,
13534 parallelism: parallelism__,
13535 backfill_parallelism: backfill_parallelism__,
13536 adaptive_parallelism_strategy: adaptive_parallelism_strategy__.unwrap_or_default(),
13537 backfill_adaptive_parallelism_strategy: backfill_adaptive_parallelism_strategy__.unwrap_or_default(),
13538 max_parallelism: max_parallelism__.unwrap_or_default(),
13539 backfill_order: backfill_order__,
13540 })
13541 }
13542 }
13543 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph", FIELDS, GeneratedVisitor)
13544 }
13545}
13546impl serde::Serialize for stream_fragment_graph::Parallelism {
13547 #[allow(deprecated)]
13548 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13549 where
13550 S: serde::Serializer,
13551 {
13552 use serde::ser::SerializeStruct;
13553 let mut len = 0;
13554 if self.parallelism != 0 {
13555 len += 1;
13556 }
13557 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.Parallelism", len)?;
13558 if self.parallelism != 0 {
13559 #[allow(clippy::needless_borrow)]
13560 #[allow(clippy::needless_borrows_for_generic_args)]
13561 struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
13562 }
13563 struct_ser.end()
13564 }
13565}
13566impl<'de> serde::Deserialize<'de> for stream_fragment_graph::Parallelism {
13567 #[allow(deprecated)]
13568 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13569 where
13570 D: serde::Deserializer<'de>,
13571 {
13572 const FIELDS: &[&str] = &[
13573 "parallelism",
13574 ];
13575
13576 #[allow(clippy::enum_variant_names)]
13577 enum GeneratedField {
13578 Parallelism,
13579 }
13580 impl<'de> serde::Deserialize<'de> for GeneratedField {
13581 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13582 where
13583 D: serde::Deserializer<'de>,
13584 {
13585 struct GeneratedVisitor;
13586
13587 impl serde::de::Visitor<'_> for GeneratedVisitor {
13588 type Value = GeneratedField;
13589
13590 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13591 write!(formatter, "expected one of: {:?}", &FIELDS)
13592 }
13593
13594 #[allow(unused_variables)]
13595 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13596 where
13597 E: serde::de::Error,
13598 {
13599 match value {
13600 "parallelism" => Ok(GeneratedField::Parallelism),
13601 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13602 }
13603 }
13604 }
13605 deserializer.deserialize_identifier(GeneratedVisitor)
13606 }
13607 }
13608 struct GeneratedVisitor;
13609 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13610 type Value = stream_fragment_graph::Parallelism;
13611
13612 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13613 formatter.write_str("struct stream_plan.StreamFragmentGraph.Parallelism")
13614 }
13615
13616 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::Parallelism, V::Error>
13617 where
13618 V: serde::de::MapAccess<'de>,
13619 {
13620 let mut parallelism__ = None;
13621 while let Some(k) = map_.next_key()? {
13622 match k {
13623 GeneratedField::Parallelism => {
13624 if parallelism__.is_some() {
13625 return Err(serde::de::Error::duplicate_field("parallelism"));
13626 }
13627 parallelism__ =
13628 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13629 ;
13630 }
13631 }
13632 }
13633 Ok(stream_fragment_graph::Parallelism {
13634 parallelism: parallelism__.unwrap_or_default(),
13635 })
13636 }
13637 }
13638 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.Parallelism", FIELDS, GeneratedVisitor)
13639 }
13640}
13641impl serde::Serialize for stream_fragment_graph::StreamFragment {
13642 #[allow(deprecated)]
13643 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13644 where
13645 S: serde::Serializer,
13646 {
13647 use serde::ser::SerializeStruct;
13648 let mut len = 0;
13649 if self.fragment_id != 0 {
13650 len += 1;
13651 }
13652 if self.node.is_some() {
13653 len += 1;
13654 }
13655 if self.fragment_type_mask != 0 {
13656 len += 1;
13657 }
13658 if self.requires_singleton {
13659 len += 1;
13660 }
13661 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", len)?;
13662 if self.fragment_id != 0 {
13663 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
13664 }
13665 if let Some(v) = self.node.as_ref() {
13666 struct_ser.serialize_field("node", v)?;
13667 }
13668 if self.fragment_type_mask != 0 {
13669 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
13670 }
13671 if self.requires_singleton {
13672 struct_ser.serialize_field("requiresSingleton", &self.requires_singleton)?;
13673 }
13674 struct_ser.end()
13675 }
13676}
13677impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragment {
13678 #[allow(deprecated)]
13679 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13680 where
13681 D: serde::Deserializer<'de>,
13682 {
13683 const FIELDS: &[&str] = &[
13684 "fragment_id",
13685 "fragmentId",
13686 "node",
13687 "fragment_type_mask",
13688 "fragmentTypeMask",
13689 "requires_singleton",
13690 "requiresSingleton",
13691 ];
13692
13693 #[allow(clippy::enum_variant_names)]
13694 enum GeneratedField {
13695 FragmentId,
13696 Node,
13697 FragmentTypeMask,
13698 RequiresSingleton,
13699 }
13700 impl<'de> serde::Deserialize<'de> for GeneratedField {
13701 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13702 where
13703 D: serde::Deserializer<'de>,
13704 {
13705 struct GeneratedVisitor;
13706
13707 impl serde::de::Visitor<'_> for GeneratedVisitor {
13708 type Value = GeneratedField;
13709
13710 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13711 write!(formatter, "expected one of: {:?}", &FIELDS)
13712 }
13713
13714 #[allow(unused_variables)]
13715 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13716 where
13717 E: serde::de::Error,
13718 {
13719 match value {
13720 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
13721 "node" => Ok(GeneratedField::Node),
13722 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
13723 "requiresSingleton" | "requires_singleton" => Ok(GeneratedField::RequiresSingleton),
13724 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13725 }
13726 }
13727 }
13728 deserializer.deserialize_identifier(GeneratedVisitor)
13729 }
13730 }
13731 struct GeneratedVisitor;
13732 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13733 type Value = stream_fragment_graph::StreamFragment;
13734
13735 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13736 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragment")
13737 }
13738
13739 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragment, V::Error>
13740 where
13741 V: serde::de::MapAccess<'de>,
13742 {
13743 let mut fragment_id__ = None;
13744 let mut node__ = None;
13745 let mut fragment_type_mask__ = None;
13746 let mut requires_singleton__ = None;
13747 while let Some(k) = map_.next_key()? {
13748 match k {
13749 GeneratedField::FragmentId => {
13750 if fragment_id__.is_some() {
13751 return Err(serde::de::Error::duplicate_field("fragmentId"));
13752 }
13753 fragment_id__ =
13754 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13755 ;
13756 }
13757 GeneratedField::Node => {
13758 if node__.is_some() {
13759 return Err(serde::de::Error::duplicate_field("node"));
13760 }
13761 node__ = map_.next_value()?;
13762 }
13763 GeneratedField::FragmentTypeMask => {
13764 if fragment_type_mask__.is_some() {
13765 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
13766 }
13767 fragment_type_mask__ =
13768 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13769 ;
13770 }
13771 GeneratedField::RequiresSingleton => {
13772 if requires_singleton__.is_some() {
13773 return Err(serde::de::Error::duplicate_field("requiresSingleton"));
13774 }
13775 requires_singleton__ = Some(map_.next_value()?);
13776 }
13777 }
13778 }
13779 Ok(stream_fragment_graph::StreamFragment {
13780 fragment_id: fragment_id__.unwrap_or_default(),
13781 node: node__,
13782 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
13783 requires_singleton: requires_singleton__.unwrap_or_default(),
13784 })
13785 }
13786 }
13787 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", FIELDS, GeneratedVisitor)
13788 }
13789}
13790impl serde::Serialize for stream_fragment_graph::StreamFragmentEdge {
13791 #[allow(deprecated)]
13792 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13793 where
13794 S: serde::Serializer,
13795 {
13796 use serde::ser::SerializeStruct;
13797 let mut len = 0;
13798 if self.dispatch_strategy.is_some() {
13799 len += 1;
13800 }
13801 if self.link_id != 0 {
13802 len += 1;
13803 }
13804 if self.upstream_id != 0 {
13805 len += 1;
13806 }
13807 if self.downstream_id != 0 {
13808 len += 1;
13809 }
13810 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", len)?;
13811 if let Some(v) = self.dispatch_strategy.as_ref() {
13812 struct_ser.serialize_field("dispatchStrategy", v)?;
13813 }
13814 if self.link_id != 0 {
13815 #[allow(clippy::needless_borrow)]
13816 #[allow(clippy::needless_borrows_for_generic_args)]
13817 struct_ser.serialize_field("linkId", ToString::to_string(&self.link_id).as_str())?;
13818 }
13819 if self.upstream_id != 0 {
13820 struct_ser.serialize_field("upstreamId", &self.upstream_id)?;
13821 }
13822 if self.downstream_id != 0 {
13823 struct_ser.serialize_field("downstreamId", &self.downstream_id)?;
13824 }
13825 struct_ser.end()
13826 }
13827}
13828impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragmentEdge {
13829 #[allow(deprecated)]
13830 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13831 where
13832 D: serde::Deserializer<'de>,
13833 {
13834 const FIELDS: &[&str] = &[
13835 "dispatch_strategy",
13836 "dispatchStrategy",
13837 "link_id",
13838 "linkId",
13839 "upstream_id",
13840 "upstreamId",
13841 "downstream_id",
13842 "downstreamId",
13843 ];
13844
13845 #[allow(clippy::enum_variant_names)]
13846 enum GeneratedField {
13847 DispatchStrategy,
13848 LinkId,
13849 UpstreamId,
13850 DownstreamId,
13851 }
13852 impl<'de> serde::Deserialize<'de> for GeneratedField {
13853 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13854 where
13855 D: serde::Deserializer<'de>,
13856 {
13857 struct GeneratedVisitor;
13858
13859 impl serde::de::Visitor<'_> for GeneratedVisitor {
13860 type Value = GeneratedField;
13861
13862 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13863 write!(formatter, "expected one of: {:?}", &FIELDS)
13864 }
13865
13866 #[allow(unused_variables)]
13867 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13868 where
13869 E: serde::de::Error,
13870 {
13871 match value {
13872 "dispatchStrategy" | "dispatch_strategy" => Ok(GeneratedField::DispatchStrategy),
13873 "linkId" | "link_id" => Ok(GeneratedField::LinkId),
13874 "upstreamId" | "upstream_id" => Ok(GeneratedField::UpstreamId),
13875 "downstreamId" | "downstream_id" => Ok(GeneratedField::DownstreamId),
13876 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13877 }
13878 }
13879 }
13880 deserializer.deserialize_identifier(GeneratedVisitor)
13881 }
13882 }
13883 struct GeneratedVisitor;
13884 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13885 type Value = stream_fragment_graph::StreamFragmentEdge;
13886
13887 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13888 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragmentEdge")
13889 }
13890
13891 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragmentEdge, V::Error>
13892 where
13893 V: serde::de::MapAccess<'de>,
13894 {
13895 let mut dispatch_strategy__ = None;
13896 let mut link_id__ = None;
13897 let mut upstream_id__ = None;
13898 let mut downstream_id__ = None;
13899 while let Some(k) = map_.next_key()? {
13900 match k {
13901 GeneratedField::DispatchStrategy => {
13902 if dispatch_strategy__.is_some() {
13903 return Err(serde::de::Error::duplicate_field("dispatchStrategy"));
13904 }
13905 dispatch_strategy__ = map_.next_value()?;
13906 }
13907 GeneratedField::LinkId => {
13908 if link_id__.is_some() {
13909 return Err(serde::de::Error::duplicate_field("linkId"));
13910 }
13911 link_id__ =
13912 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13913 ;
13914 }
13915 GeneratedField::UpstreamId => {
13916 if upstream_id__.is_some() {
13917 return Err(serde::de::Error::duplicate_field("upstreamId"));
13918 }
13919 upstream_id__ =
13920 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13921 ;
13922 }
13923 GeneratedField::DownstreamId => {
13924 if downstream_id__.is_some() {
13925 return Err(serde::de::Error::duplicate_field("downstreamId"));
13926 }
13927 downstream_id__ =
13928 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13929 ;
13930 }
13931 }
13932 }
13933 Ok(stream_fragment_graph::StreamFragmentEdge {
13934 dispatch_strategy: dispatch_strategy__,
13935 link_id: link_id__.unwrap_or_default(),
13936 upstream_id: upstream_id__.unwrap_or_default(),
13937 downstream_id: downstream_id__.unwrap_or_default(),
13938 })
13939 }
13940 }
13941 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", FIELDS, GeneratedVisitor)
13942 }
13943}
13944impl serde::Serialize for StreamFsFetch {
13945 #[allow(deprecated)]
13946 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13947 where
13948 S: serde::Serializer,
13949 {
13950 use serde::ser::SerializeStruct;
13951 let mut len = 0;
13952 if self.source_id != 0 {
13953 len += 1;
13954 }
13955 if self.state_table.is_some() {
13956 len += 1;
13957 }
13958 if self.row_id_index.is_some() {
13959 len += 1;
13960 }
13961 if !self.columns.is_empty() {
13962 len += 1;
13963 }
13964 if !self.with_properties.is_empty() {
13965 len += 1;
13966 }
13967 if self.info.is_some() {
13968 len += 1;
13969 }
13970 if !self.source_name.is_empty() {
13971 len += 1;
13972 }
13973 if self.rate_limit.is_some() {
13974 len += 1;
13975 }
13976 if !self.secret_refs.is_empty() {
13977 len += 1;
13978 }
13979 if self.refresh_mode.is_some() {
13980 len += 1;
13981 }
13982 if self.associated_table_id.is_some() {
13983 len += 1;
13984 }
13985 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetch", len)?;
13986 if self.source_id != 0 {
13987 struct_ser.serialize_field("sourceId", &self.source_id)?;
13988 }
13989 if let Some(v) = self.state_table.as_ref() {
13990 struct_ser.serialize_field("stateTable", v)?;
13991 }
13992 if let Some(v) = self.row_id_index.as_ref() {
13993 struct_ser.serialize_field("rowIdIndex", v)?;
13994 }
13995 if !self.columns.is_empty() {
13996 struct_ser.serialize_field("columns", &self.columns)?;
13997 }
13998 if !self.with_properties.is_empty() {
13999 struct_ser.serialize_field("withProperties", &self.with_properties)?;
14000 }
14001 if let Some(v) = self.info.as_ref() {
14002 struct_ser.serialize_field("info", v)?;
14003 }
14004 if !self.source_name.is_empty() {
14005 struct_ser.serialize_field("sourceName", &self.source_name)?;
14006 }
14007 if let Some(v) = self.rate_limit.as_ref() {
14008 struct_ser.serialize_field("rateLimit", v)?;
14009 }
14010 if !self.secret_refs.is_empty() {
14011 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
14012 }
14013 if let Some(v) = self.refresh_mode.as_ref() {
14014 struct_ser.serialize_field("refreshMode", v)?;
14015 }
14016 if let Some(v) = self.associated_table_id.as_ref() {
14017 struct_ser.serialize_field("associatedTableId", v)?;
14018 }
14019 struct_ser.end()
14020 }
14021}
14022impl<'de> serde::Deserialize<'de> for StreamFsFetch {
14023 #[allow(deprecated)]
14024 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14025 where
14026 D: serde::Deserializer<'de>,
14027 {
14028 const FIELDS: &[&str] = &[
14029 "source_id",
14030 "sourceId",
14031 "state_table",
14032 "stateTable",
14033 "row_id_index",
14034 "rowIdIndex",
14035 "columns",
14036 "with_properties",
14037 "withProperties",
14038 "info",
14039 "source_name",
14040 "sourceName",
14041 "rate_limit",
14042 "rateLimit",
14043 "secret_refs",
14044 "secretRefs",
14045 "refresh_mode",
14046 "refreshMode",
14047 "associated_table_id",
14048 "associatedTableId",
14049 ];
14050
14051 #[allow(clippy::enum_variant_names)]
14052 enum GeneratedField {
14053 SourceId,
14054 StateTable,
14055 RowIdIndex,
14056 Columns,
14057 WithProperties,
14058 Info,
14059 SourceName,
14060 RateLimit,
14061 SecretRefs,
14062 RefreshMode,
14063 AssociatedTableId,
14064 }
14065 impl<'de> serde::Deserialize<'de> for GeneratedField {
14066 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14067 where
14068 D: serde::Deserializer<'de>,
14069 {
14070 struct GeneratedVisitor;
14071
14072 impl serde::de::Visitor<'_> for GeneratedVisitor {
14073 type Value = GeneratedField;
14074
14075 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14076 write!(formatter, "expected one of: {:?}", &FIELDS)
14077 }
14078
14079 #[allow(unused_variables)]
14080 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14081 where
14082 E: serde::de::Error,
14083 {
14084 match value {
14085 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
14086 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
14087 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
14088 "columns" => Ok(GeneratedField::Columns),
14089 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
14090 "info" => Ok(GeneratedField::Info),
14091 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
14092 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
14093 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
14094 "refreshMode" | "refresh_mode" => Ok(GeneratedField::RefreshMode),
14095 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
14096 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14097 }
14098 }
14099 }
14100 deserializer.deserialize_identifier(GeneratedVisitor)
14101 }
14102 }
14103 struct GeneratedVisitor;
14104 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14105 type Value = StreamFsFetch;
14106
14107 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14108 formatter.write_str("struct stream_plan.StreamFsFetch")
14109 }
14110
14111 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetch, V::Error>
14112 where
14113 V: serde::de::MapAccess<'de>,
14114 {
14115 let mut source_id__ = None;
14116 let mut state_table__ = None;
14117 let mut row_id_index__ = None;
14118 let mut columns__ = None;
14119 let mut with_properties__ = None;
14120 let mut info__ = None;
14121 let mut source_name__ = None;
14122 let mut rate_limit__ = None;
14123 let mut secret_refs__ = None;
14124 let mut refresh_mode__ = None;
14125 let mut associated_table_id__ = None;
14126 while let Some(k) = map_.next_key()? {
14127 match k {
14128 GeneratedField::SourceId => {
14129 if source_id__.is_some() {
14130 return Err(serde::de::Error::duplicate_field("sourceId"));
14131 }
14132 source_id__ =
14133 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14134 ;
14135 }
14136 GeneratedField::StateTable => {
14137 if state_table__.is_some() {
14138 return Err(serde::de::Error::duplicate_field("stateTable"));
14139 }
14140 state_table__ = map_.next_value()?;
14141 }
14142 GeneratedField::RowIdIndex => {
14143 if row_id_index__.is_some() {
14144 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
14145 }
14146 row_id_index__ =
14147 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14148 ;
14149 }
14150 GeneratedField::Columns => {
14151 if columns__.is_some() {
14152 return Err(serde::de::Error::duplicate_field("columns"));
14153 }
14154 columns__ = Some(map_.next_value()?);
14155 }
14156 GeneratedField::WithProperties => {
14157 if with_properties__.is_some() {
14158 return Err(serde::de::Error::duplicate_field("withProperties"));
14159 }
14160 with_properties__ = Some(
14161 map_.next_value::<std::collections::BTreeMap<_, _>>()?
14162 );
14163 }
14164 GeneratedField::Info => {
14165 if info__.is_some() {
14166 return Err(serde::de::Error::duplicate_field("info"));
14167 }
14168 info__ = map_.next_value()?;
14169 }
14170 GeneratedField::SourceName => {
14171 if source_name__.is_some() {
14172 return Err(serde::de::Error::duplicate_field("sourceName"));
14173 }
14174 source_name__ = Some(map_.next_value()?);
14175 }
14176 GeneratedField::RateLimit => {
14177 if rate_limit__.is_some() {
14178 return Err(serde::de::Error::duplicate_field("rateLimit"));
14179 }
14180 rate_limit__ =
14181 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14182 ;
14183 }
14184 GeneratedField::SecretRefs => {
14185 if secret_refs__.is_some() {
14186 return Err(serde::de::Error::duplicate_field("secretRefs"));
14187 }
14188 secret_refs__ = Some(
14189 map_.next_value::<std::collections::BTreeMap<_, _>>()?
14190 );
14191 }
14192 GeneratedField::RefreshMode => {
14193 if refresh_mode__.is_some() {
14194 return Err(serde::de::Error::duplicate_field("refreshMode"));
14195 }
14196 refresh_mode__ = map_.next_value()?;
14197 }
14198 GeneratedField::AssociatedTableId => {
14199 if associated_table_id__.is_some() {
14200 return Err(serde::de::Error::duplicate_field("associatedTableId"));
14201 }
14202 associated_table_id__ =
14203 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14204 ;
14205 }
14206 }
14207 }
14208 Ok(StreamFsFetch {
14209 source_id: source_id__.unwrap_or_default(),
14210 state_table: state_table__,
14211 row_id_index: row_id_index__,
14212 columns: columns__.unwrap_or_default(),
14213 with_properties: with_properties__.unwrap_or_default(),
14214 info: info__,
14215 source_name: source_name__.unwrap_or_default(),
14216 rate_limit: rate_limit__,
14217 secret_refs: secret_refs__.unwrap_or_default(),
14218 refresh_mode: refresh_mode__,
14219 associated_table_id: associated_table_id__,
14220 })
14221 }
14222 }
14223 deserializer.deserialize_struct("stream_plan.StreamFsFetch", FIELDS, GeneratedVisitor)
14224 }
14225}
14226impl serde::Serialize for StreamFsFetchNode {
14227 #[allow(deprecated)]
14228 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14229 where
14230 S: serde::Serializer,
14231 {
14232 use serde::ser::SerializeStruct;
14233 let mut len = 0;
14234 if self.node_inner.is_some() {
14235 len += 1;
14236 }
14237 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetchNode", len)?;
14238 if let Some(v) = self.node_inner.as_ref() {
14239 struct_ser.serialize_field("nodeInner", v)?;
14240 }
14241 struct_ser.end()
14242 }
14243}
14244impl<'de> serde::Deserialize<'de> for StreamFsFetchNode {
14245 #[allow(deprecated)]
14246 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14247 where
14248 D: serde::Deserializer<'de>,
14249 {
14250 const FIELDS: &[&str] = &[
14251 "node_inner",
14252 "nodeInner",
14253 ];
14254
14255 #[allow(clippy::enum_variant_names)]
14256 enum GeneratedField {
14257 NodeInner,
14258 }
14259 impl<'de> serde::Deserialize<'de> for GeneratedField {
14260 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14261 where
14262 D: serde::Deserializer<'de>,
14263 {
14264 struct GeneratedVisitor;
14265
14266 impl serde::de::Visitor<'_> for GeneratedVisitor {
14267 type Value = GeneratedField;
14268
14269 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14270 write!(formatter, "expected one of: {:?}", &FIELDS)
14271 }
14272
14273 #[allow(unused_variables)]
14274 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14275 where
14276 E: serde::de::Error,
14277 {
14278 match value {
14279 "nodeInner" | "node_inner" => Ok(GeneratedField::NodeInner),
14280 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14281 }
14282 }
14283 }
14284 deserializer.deserialize_identifier(GeneratedVisitor)
14285 }
14286 }
14287 struct GeneratedVisitor;
14288 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14289 type Value = StreamFsFetchNode;
14290
14291 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14292 formatter.write_str("struct stream_plan.StreamFsFetchNode")
14293 }
14294
14295 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetchNode, V::Error>
14296 where
14297 V: serde::de::MapAccess<'de>,
14298 {
14299 let mut node_inner__ = None;
14300 while let Some(k) = map_.next_key()? {
14301 match k {
14302 GeneratedField::NodeInner => {
14303 if node_inner__.is_some() {
14304 return Err(serde::de::Error::duplicate_field("nodeInner"));
14305 }
14306 node_inner__ = map_.next_value()?;
14307 }
14308 }
14309 }
14310 Ok(StreamFsFetchNode {
14311 node_inner: node_inner__,
14312 })
14313 }
14314 }
14315 deserializer.deserialize_struct("stream_plan.StreamFsFetchNode", FIELDS, GeneratedVisitor)
14316 }
14317}
14318impl serde::Serialize for StreamMessage {
14319 #[allow(deprecated)]
14320 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14321 where
14322 S: serde::Serializer,
14323 {
14324 use serde::ser::SerializeStruct;
14325 let mut len = 0;
14326 if self.stream_message.is_some() {
14327 len += 1;
14328 }
14329 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessage", len)?;
14330 if let Some(v) = self.stream_message.as_ref() {
14331 match v {
14332 stream_message::StreamMessage::StreamChunk(v) => {
14333 struct_ser.serialize_field("streamChunk", v)?;
14334 }
14335 stream_message::StreamMessage::Barrier(v) => {
14336 struct_ser.serialize_field("barrier", v)?;
14337 }
14338 stream_message::StreamMessage::Watermark(v) => {
14339 struct_ser.serialize_field("watermark", v)?;
14340 }
14341 }
14342 }
14343 struct_ser.end()
14344 }
14345}
14346impl<'de> serde::Deserialize<'de> for StreamMessage {
14347 #[allow(deprecated)]
14348 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14349 where
14350 D: serde::Deserializer<'de>,
14351 {
14352 const FIELDS: &[&str] = &[
14353 "stream_chunk",
14354 "streamChunk",
14355 "barrier",
14356 "watermark",
14357 ];
14358
14359 #[allow(clippy::enum_variant_names)]
14360 enum GeneratedField {
14361 StreamChunk,
14362 Barrier,
14363 Watermark,
14364 }
14365 impl<'de> serde::Deserialize<'de> for GeneratedField {
14366 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14367 where
14368 D: serde::Deserializer<'de>,
14369 {
14370 struct GeneratedVisitor;
14371
14372 impl serde::de::Visitor<'_> for GeneratedVisitor {
14373 type Value = GeneratedField;
14374
14375 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14376 write!(formatter, "expected one of: {:?}", &FIELDS)
14377 }
14378
14379 #[allow(unused_variables)]
14380 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14381 where
14382 E: serde::de::Error,
14383 {
14384 match value {
14385 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
14386 "barrier" => Ok(GeneratedField::Barrier),
14387 "watermark" => Ok(GeneratedField::Watermark),
14388 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14389 }
14390 }
14391 }
14392 deserializer.deserialize_identifier(GeneratedVisitor)
14393 }
14394 }
14395 struct GeneratedVisitor;
14396 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14397 type Value = StreamMessage;
14398
14399 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14400 formatter.write_str("struct stream_plan.StreamMessage")
14401 }
14402
14403 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessage, V::Error>
14404 where
14405 V: serde::de::MapAccess<'de>,
14406 {
14407 let mut stream_message__ = None;
14408 while let Some(k) = map_.next_key()? {
14409 match k {
14410 GeneratedField::StreamChunk => {
14411 if stream_message__.is_some() {
14412 return Err(serde::de::Error::duplicate_field("streamChunk"));
14413 }
14414 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::StreamChunk)
14415;
14416 }
14417 GeneratedField::Barrier => {
14418 if stream_message__.is_some() {
14419 return Err(serde::de::Error::duplicate_field("barrier"));
14420 }
14421 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Barrier)
14422;
14423 }
14424 GeneratedField::Watermark => {
14425 if stream_message__.is_some() {
14426 return Err(serde::de::Error::duplicate_field("watermark"));
14427 }
14428 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Watermark)
14429;
14430 }
14431 }
14432 }
14433 Ok(StreamMessage {
14434 stream_message: stream_message__,
14435 })
14436 }
14437 }
14438 deserializer.deserialize_struct("stream_plan.StreamMessage", FIELDS, GeneratedVisitor)
14439 }
14440}
14441impl serde::Serialize for StreamMessageBatch {
14442 #[allow(deprecated)]
14443 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14444 where
14445 S: serde::Serializer,
14446 {
14447 use serde::ser::SerializeStruct;
14448 let mut len = 0;
14449 if self.stream_message_batch.is_some() {
14450 len += 1;
14451 }
14452 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch", len)?;
14453 if let Some(v) = self.stream_message_batch.as_ref() {
14454 match v {
14455 stream_message_batch::StreamMessageBatch::StreamChunk(v) => {
14456 struct_ser.serialize_field("streamChunk", v)?;
14457 }
14458 stream_message_batch::StreamMessageBatch::BarrierBatch(v) => {
14459 struct_ser.serialize_field("barrierBatch", v)?;
14460 }
14461 stream_message_batch::StreamMessageBatch::Watermark(v) => {
14462 struct_ser.serialize_field("watermark", v)?;
14463 }
14464 }
14465 }
14466 struct_ser.end()
14467 }
14468}
14469impl<'de> serde::Deserialize<'de> for StreamMessageBatch {
14470 #[allow(deprecated)]
14471 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14472 where
14473 D: serde::Deserializer<'de>,
14474 {
14475 const FIELDS: &[&str] = &[
14476 "stream_chunk",
14477 "streamChunk",
14478 "barrier_batch",
14479 "barrierBatch",
14480 "watermark",
14481 ];
14482
14483 #[allow(clippy::enum_variant_names)]
14484 enum GeneratedField {
14485 StreamChunk,
14486 BarrierBatch,
14487 Watermark,
14488 }
14489 impl<'de> serde::Deserialize<'de> for GeneratedField {
14490 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14491 where
14492 D: serde::Deserializer<'de>,
14493 {
14494 struct GeneratedVisitor;
14495
14496 impl serde::de::Visitor<'_> for GeneratedVisitor {
14497 type Value = GeneratedField;
14498
14499 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14500 write!(formatter, "expected one of: {:?}", &FIELDS)
14501 }
14502
14503 #[allow(unused_variables)]
14504 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14505 where
14506 E: serde::de::Error,
14507 {
14508 match value {
14509 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
14510 "barrierBatch" | "barrier_batch" => Ok(GeneratedField::BarrierBatch),
14511 "watermark" => Ok(GeneratedField::Watermark),
14512 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14513 }
14514 }
14515 }
14516 deserializer.deserialize_identifier(GeneratedVisitor)
14517 }
14518 }
14519 struct GeneratedVisitor;
14520 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14521 type Value = StreamMessageBatch;
14522
14523 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14524 formatter.write_str("struct stream_plan.StreamMessageBatch")
14525 }
14526
14527 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessageBatch, V::Error>
14528 where
14529 V: serde::de::MapAccess<'de>,
14530 {
14531 let mut stream_message_batch__ = None;
14532 while let Some(k) = map_.next_key()? {
14533 match k {
14534 GeneratedField::StreamChunk => {
14535 if stream_message_batch__.is_some() {
14536 return Err(serde::de::Error::duplicate_field("streamChunk"));
14537 }
14538 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::StreamChunk)
14539;
14540 }
14541 GeneratedField::BarrierBatch => {
14542 if stream_message_batch__.is_some() {
14543 return Err(serde::de::Error::duplicate_field("barrierBatch"));
14544 }
14545 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::BarrierBatch)
14546;
14547 }
14548 GeneratedField::Watermark => {
14549 if stream_message_batch__.is_some() {
14550 return Err(serde::de::Error::duplicate_field("watermark"));
14551 }
14552 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::Watermark)
14553;
14554 }
14555 }
14556 }
14557 Ok(StreamMessageBatch {
14558 stream_message_batch: stream_message_batch__,
14559 })
14560 }
14561 }
14562 deserializer.deserialize_struct("stream_plan.StreamMessageBatch", FIELDS, GeneratedVisitor)
14563 }
14564}
14565impl serde::Serialize for stream_message_batch::BarrierBatch {
14566 #[allow(deprecated)]
14567 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14568 where
14569 S: serde::Serializer,
14570 {
14571 use serde::ser::SerializeStruct;
14572 let mut len = 0;
14573 if !self.barriers.is_empty() {
14574 len += 1;
14575 }
14576 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", len)?;
14577 if !self.barriers.is_empty() {
14578 struct_ser.serialize_field("barriers", &self.barriers)?;
14579 }
14580 struct_ser.end()
14581 }
14582}
14583impl<'de> serde::Deserialize<'de> for stream_message_batch::BarrierBatch {
14584 #[allow(deprecated)]
14585 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14586 where
14587 D: serde::Deserializer<'de>,
14588 {
14589 const FIELDS: &[&str] = &[
14590 "barriers",
14591 ];
14592
14593 #[allow(clippy::enum_variant_names)]
14594 enum GeneratedField {
14595 Barriers,
14596 }
14597 impl<'de> serde::Deserialize<'de> for GeneratedField {
14598 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14599 where
14600 D: serde::Deserializer<'de>,
14601 {
14602 struct GeneratedVisitor;
14603
14604 impl serde::de::Visitor<'_> for GeneratedVisitor {
14605 type Value = GeneratedField;
14606
14607 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14608 write!(formatter, "expected one of: {:?}", &FIELDS)
14609 }
14610
14611 #[allow(unused_variables)]
14612 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14613 where
14614 E: serde::de::Error,
14615 {
14616 match value {
14617 "barriers" => Ok(GeneratedField::Barriers),
14618 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14619 }
14620 }
14621 }
14622 deserializer.deserialize_identifier(GeneratedVisitor)
14623 }
14624 }
14625 struct GeneratedVisitor;
14626 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14627 type Value = stream_message_batch::BarrierBatch;
14628
14629 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14630 formatter.write_str("struct stream_plan.StreamMessageBatch.BarrierBatch")
14631 }
14632
14633 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_message_batch::BarrierBatch, V::Error>
14634 where
14635 V: serde::de::MapAccess<'de>,
14636 {
14637 let mut barriers__ = None;
14638 while let Some(k) = map_.next_key()? {
14639 match k {
14640 GeneratedField::Barriers => {
14641 if barriers__.is_some() {
14642 return Err(serde::de::Error::duplicate_field("barriers"));
14643 }
14644 barriers__ = Some(map_.next_value()?);
14645 }
14646 }
14647 }
14648 Ok(stream_message_batch::BarrierBatch {
14649 barriers: barriers__.unwrap_or_default(),
14650 })
14651 }
14652 }
14653 deserializer.deserialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", FIELDS, GeneratedVisitor)
14654 }
14655}
14656impl serde::Serialize for StreamNode {
14657 #[allow(deprecated)]
14658 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14659 where
14660 S: serde::Serializer,
14661 {
14662 use serde::ser::SerializeStruct;
14663 let mut len = 0;
14664 if self.operator_id != 0 {
14665 len += 1;
14666 }
14667 if !self.input.is_empty() {
14668 len += 1;
14669 }
14670 if !self.stream_key.is_empty() {
14671 len += 1;
14672 }
14673 if self.stream_kind != 0 {
14674 len += 1;
14675 }
14676 if !self.identity.is_empty() {
14677 len += 1;
14678 }
14679 if !self.fields.is_empty() {
14680 len += 1;
14681 }
14682 if self.node_body.is_some() {
14683 len += 1;
14684 }
14685 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamNode", len)?;
14686 if self.operator_id != 0 {
14687 #[allow(clippy::needless_borrow)]
14688 #[allow(clippy::needless_borrows_for_generic_args)]
14689 struct_ser.serialize_field("operatorId", ToString::to_string(&self.operator_id).as_str())?;
14690 }
14691 if !self.input.is_empty() {
14692 struct_ser.serialize_field("input", &self.input)?;
14693 }
14694 if !self.stream_key.is_empty() {
14695 struct_ser.serialize_field("streamKey", &self.stream_key)?;
14696 }
14697 if self.stream_kind != 0 {
14698 let v = stream_node::StreamKind::try_from(self.stream_kind)
14699 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_kind)))?;
14700 struct_ser.serialize_field("streamKind", &v)?;
14701 }
14702 if !self.identity.is_empty() {
14703 struct_ser.serialize_field("identity", &self.identity)?;
14704 }
14705 if !self.fields.is_empty() {
14706 struct_ser.serialize_field("fields", &self.fields)?;
14707 }
14708 if let Some(v) = self.node_body.as_ref() {
14709 match v {
14710 stream_node::NodeBody::Source(v) => {
14711 struct_ser.serialize_field("source", v)?;
14712 }
14713 stream_node::NodeBody::Project(v) => {
14714 struct_ser.serialize_field("project", v)?;
14715 }
14716 stream_node::NodeBody::Filter(v) => {
14717 struct_ser.serialize_field("filter", v)?;
14718 }
14719 stream_node::NodeBody::Materialize(v) => {
14720 struct_ser.serialize_field("materialize", v)?;
14721 }
14722 stream_node::NodeBody::StatelessSimpleAgg(v) => {
14723 struct_ser.serialize_field("statelessSimpleAgg", v)?;
14724 }
14725 stream_node::NodeBody::SimpleAgg(v) => {
14726 struct_ser.serialize_field("simpleAgg", v)?;
14727 }
14728 stream_node::NodeBody::HashAgg(v) => {
14729 struct_ser.serialize_field("hashAgg", v)?;
14730 }
14731 stream_node::NodeBody::AppendOnlyTopN(v) => {
14732 struct_ser.serialize_field("appendOnlyTopN", v)?;
14733 }
14734 stream_node::NodeBody::HashJoin(v) => {
14735 struct_ser.serialize_field("hashJoin", v)?;
14736 }
14737 stream_node::NodeBody::TopN(v) => {
14738 struct_ser.serialize_field("topN", v)?;
14739 }
14740 stream_node::NodeBody::HopWindow(v) => {
14741 struct_ser.serialize_field("hopWindow", v)?;
14742 }
14743 stream_node::NodeBody::Merge(v) => {
14744 struct_ser.serialize_field("merge", v)?;
14745 }
14746 stream_node::NodeBody::Exchange(v) => {
14747 struct_ser.serialize_field("exchange", v)?;
14748 }
14749 stream_node::NodeBody::StreamScan(v) => {
14750 struct_ser.serialize_field("streamScan", v)?;
14751 }
14752 stream_node::NodeBody::BatchPlan(v) => {
14753 struct_ser.serialize_field("batchPlan", v)?;
14754 }
14755 stream_node::NodeBody::Lookup(v) => {
14756 struct_ser.serialize_field("lookup", v)?;
14757 }
14758 stream_node::NodeBody::Arrange(v) => {
14759 struct_ser.serialize_field("arrange", v)?;
14760 }
14761 stream_node::NodeBody::LookupUnion(v) => {
14762 struct_ser.serialize_field("lookupUnion", v)?;
14763 }
14764 stream_node::NodeBody::Union(v) => {
14765 struct_ser.serialize_field("union", v)?;
14766 }
14767 stream_node::NodeBody::DeltaIndexJoin(v) => {
14768 struct_ser.serialize_field("deltaIndexJoin", v)?;
14769 }
14770 stream_node::NodeBody::Sink(v) => {
14771 struct_ser.serialize_field("sink", v)?;
14772 }
14773 stream_node::NodeBody::Expand(v) => {
14774 struct_ser.serialize_field("expand", v)?;
14775 }
14776 stream_node::NodeBody::DynamicFilter(v) => {
14777 struct_ser.serialize_field("dynamicFilter", v)?;
14778 }
14779 stream_node::NodeBody::ProjectSet(v) => {
14780 struct_ser.serialize_field("projectSet", v)?;
14781 }
14782 stream_node::NodeBody::GroupTopN(v) => {
14783 struct_ser.serialize_field("groupTopN", v)?;
14784 }
14785 stream_node::NodeBody::Sort(v) => {
14786 struct_ser.serialize_field("sort", v)?;
14787 }
14788 stream_node::NodeBody::WatermarkFilter(v) => {
14789 struct_ser.serialize_field("watermarkFilter", v)?;
14790 }
14791 stream_node::NodeBody::Dml(v) => {
14792 struct_ser.serialize_field("dml", v)?;
14793 }
14794 stream_node::NodeBody::RowIdGen(v) => {
14795 struct_ser.serialize_field("rowIdGen", v)?;
14796 }
14797 stream_node::NodeBody::Now(v) => {
14798 struct_ser.serialize_field("now", v)?;
14799 }
14800 stream_node::NodeBody::AppendOnlyGroupTopN(v) => {
14801 struct_ser.serialize_field("appendOnlyGroupTopN", v)?;
14802 }
14803 stream_node::NodeBody::TemporalJoin(v) => {
14804 struct_ser.serialize_field("temporalJoin", v)?;
14805 }
14806 stream_node::NodeBody::BarrierRecv(v) => {
14807 struct_ser.serialize_field("barrierRecv", v)?;
14808 }
14809 stream_node::NodeBody::Values(v) => {
14810 struct_ser.serialize_field("values", v)?;
14811 }
14812 stream_node::NodeBody::AppendOnlyDedup(v) => {
14813 struct_ser.serialize_field("appendOnlyDedup", v)?;
14814 }
14815 stream_node::NodeBody::NoOp(v) => {
14816 struct_ser.serialize_field("noOp", v)?;
14817 }
14818 stream_node::NodeBody::EowcOverWindow(v) => {
14819 struct_ser.serialize_field("eowcOverWindow", v)?;
14820 }
14821 stream_node::NodeBody::OverWindow(v) => {
14822 struct_ser.serialize_field("overWindow", v)?;
14823 }
14824 stream_node::NodeBody::StreamFsFetch(v) => {
14825 struct_ser.serialize_field("streamFsFetch", v)?;
14826 }
14827 stream_node::NodeBody::StreamCdcScan(v) => {
14828 struct_ser.serialize_field("streamCdcScan", v)?;
14829 }
14830 stream_node::NodeBody::CdcFilter(v) => {
14831 struct_ser.serialize_field("cdcFilter", v)?;
14832 }
14833 stream_node::NodeBody::SourceBackfill(v) => {
14834 struct_ser.serialize_field("sourceBackfill", v)?;
14835 }
14836 stream_node::NodeBody::Changelog(v) => {
14837 struct_ser.serialize_field("changelog", v)?;
14838 }
14839 stream_node::NodeBody::LocalApproxPercentile(v) => {
14840 struct_ser.serialize_field("localApproxPercentile", v)?;
14841 }
14842 stream_node::NodeBody::GlobalApproxPercentile(v) => {
14843 struct_ser.serialize_field("globalApproxPercentile", v)?;
14844 }
14845 stream_node::NodeBody::RowMerge(v) => {
14846 struct_ser.serialize_field("rowMerge", v)?;
14847 }
14848 stream_node::NodeBody::AsOfJoin(v) => {
14849 struct_ser.serialize_field("asOfJoin", v)?;
14850 }
14851 stream_node::NodeBody::SyncLogStore(v) => {
14852 struct_ser.serialize_field("syncLogStore", v)?;
14853 }
14854 stream_node::NodeBody::MaterializedExprs(v) => {
14855 struct_ser.serialize_field("materializedExprs", v)?;
14856 }
14857 stream_node::NodeBody::VectorIndexWrite(v) => {
14858 struct_ser.serialize_field("vectorIndexWrite", v)?;
14859 }
14860 stream_node::NodeBody::UpstreamSinkUnion(v) => {
14861 struct_ser.serialize_field("upstreamSinkUnion", v)?;
14862 }
14863 stream_node::NodeBody::LocalityProvider(v) => {
14864 struct_ser.serialize_field("localityProvider", v)?;
14865 }
14866 stream_node::NodeBody::EowcGapFill(v) => {
14867 struct_ser.serialize_field("eowcGapFill", v)?;
14868 }
14869 stream_node::NodeBody::GapFill(v) => {
14870 struct_ser.serialize_field("gapFill", v)?;
14871 }
14872 stream_node::NodeBody::VectorIndexLookupJoin(v) => {
14873 struct_ser.serialize_field("vectorIndexLookupJoin", v)?;
14874 }
14875 stream_node::NodeBody::IcebergWithPkIndexWriter(v) => {
14876 struct_ser.serialize_field("icebergWithPkIndexWriter", v)?;
14877 }
14878 stream_node::NodeBody::IcebergWithPkIndexPositionDeleteMerger(v) => {
14879 struct_ser.serialize_field("icebergWithPkIndexPositionDeleteMerger", v)?;
14880 }
14881 stream_node::NodeBody::CompactionResolver(v) => {
14882 struct_ser.serialize_field("compactionResolver", v)?;
14883 }
14884 }
14885 }
14886 struct_ser.end()
14887 }
14888}
14889impl<'de> serde::Deserialize<'de> for StreamNode {
14890 #[allow(deprecated)]
14891 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14892 where
14893 D: serde::Deserializer<'de>,
14894 {
14895 const FIELDS: &[&str] = &[
14896 "operator_id",
14897 "operatorId",
14898 "input",
14899 "stream_key",
14900 "streamKey",
14901 "stream_kind",
14902 "streamKind",
14903 "identity",
14904 "fields",
14905 "source",
14906 "project",
14907 "filter",
14908 "materialize",
14909 "stateless_simple_agg",
14910 "statelessSimpleAgg",
14911 "simple_agg",
14912 "simpleAgg",
14913 "hash_agg",
14914 "hashAgg",
14915 "append_only_top_n",
14916 "appendOnlyTopN",
14917 "hash_join",
14918 "hashJoin",
14919 "top_n",
14920 "topN",
14921 "hop_window",
14922 "hopWindow",
14923 "merge",
14924 "exchange",
14925 "stream_scan",
14926 "streamScan",
14927 "batch_plan",
14928 "batchPlan",
14929 "lookup",
14930 "arrange",
14931 "lookup_union",
14932 "lookupUnion",
14933 "union",
14934 "delta_index_join",
14935 "deltaIndexJoin",
14936 "sink",
14937 "expand",
14938 "dynamic_filter",
14939 "dynamicFilter",
14940 "project_set",
14941 "projectSet",
14942 "group_top_n",
14943 "groupTopN",
14944 "sort",
14945 "watermark_filter",
14946 "watermarkFilter",
14947 "dml",
14948 "row_id_gen",
14949 "rowIdGen",
14950 "now",
14951 "append_only_group_top_n",
14952 "appendOnlyGroupTopN",
14953 "temporal_join",
14954 "temporalJoin",
14955 "barrier_recv",
14956 "barrierRecv",
14957 "values",
14958 "append_only_dedup",
14959 "appendOnlyDedup",
14960 "no_op",
14961 "noOp",
14962 "eowc_over_window",
14963 "eowcOverWindow",
14964 "over_window",
14965 "overWindow",
14966 "stream_fs_fetch",
14967 "streamFsFetch",
14968 "stream_cdc_scan",
14969 "streamCdcScan",
14970 "cdc_filter",
14971 "cdcFilter",
14972 "source_backfill",
14973 "sourceBackfill",
14974 "changelog",
14975 "local_approx_percentile",
14976 "localApproxPercentile",
14977 "global_approx_percentile",
14978 "globalApproxPercentile",
14979 "row_merge",
14980 "rowMerge",
14981 "as_of_join",
14982 "asOfJoin",
14983 "sync_log_store",
14984 "syncLogStore",
14985 "materialized_exprs",
14986 "materializedExprs",
14987 "vector_index_write",
14988 "vectorIndexWrite",
14989 "upstream_sink_union",
14990 "upstreamSinkUnion",
14991 "locality_provider",
14992 "localityProvider",
14993 "eowc_gap_fill",
14994 "eowcGapFill",
14995 "gap_fill",
14996 "gapFill",
14997 "vector_index_lookup_join",
14998 "vectorIndexLookupJoin",
14999 "iceberg_with_pk_index_writer",
15000 "icebergWithPkIndexWriter",
15001 "iceberg_with_pk_index_position_delete_merger",
15002 "icebergWithPkIndexPositionDeleteMerger",
15003 "compaction_resolver",
15004 "compactionResolver",
15005 ];
15006
15007 #[allow(clippy::enum_variant_names)]
15008 enum GeneratedField {
15009 OperatorId,
15010 Input,
15011 StreamKey,
15012 StreamKind,
15013 Identity,
15014 Fields,
15015 Source,
15016 Project,
15017 Filter,
15018 Materialize,
15019 StatelessSimpleAgg,
15020 SimpleAgg,
15021 HashAgg,
15022 AppendOnlyTopN,
15023 HashJoin,
15024 TopN,
15025 HopWindow,
15026 Merge,
15027 Exchange,
15028 StreamScan,
15029 BatchPlan,
15030 Lookup,
15031 Arrange,
15032 LookupUnion,
15033 Union,
15034 DeltaIndexJoin,
15035 Sink,
15036 Expand,
15037 DynamicFilter,
15038 ProjectSet,
15039 GroupTopN,
15040 Sort,
15041 WatermarkFilter,
15042 Dml,
15043 RowIdGen,
15044 Now,
15045 AppendOnlyGroupTopN,
15046 TemporalJoin,
15047 BarrierRecv,
15048 Values,
15049 AppendOnlyDedup,
15050 NoOp,
15051 EowcOverWindow,
15052 OverWindow,
15053 StreamFsFetch,
15054 StreamCdcScan,
15055 CdcFilter,
15056 SourceBackfill,
15057 Changelog,
15058 LocalApproxPercentile,
15059 GlobalApproxPercentile,
15060 RowMerge,
15061 AsOfJoin,
15062 SyncLogStore,
15063 MaterializedExprs,
15064 VectorIndexWrite,
15065 UpstreamSinkUnion,
15066 LocalityProvider,
15067 EowcGapFill,
15068 GapFill,
15069 VectorIndexLookupJoin,
15070 IcebergWithPkIndexWriter,
15071 IcebergWithPkIndexPositionDeleteMerger,
15072 CompactionResolver,
15073 }
15074 impl<'de> serde::Deserialize<'de> for GeneratedField {
15075 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15076 where
15077 D: serde::Deserializer<'de>,
15078 {
15079 struct GeneratedVisitor;
15080
15081 impl serde::de::Visitor<'_> for GeneratedVisitor {
15082 type Value = GeneratedField;
15083
15084 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15085 write!(formatter, "expected one of: {:?}", &FIELDS)
15086 }
15087
15088 #[allow(unused_variables)]
15089 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15090 where
15091 E: serde::de::Error,
15092 {
15093 match value {
15094 "operatorId" | "operator_id" => Ok(GeneratedField::OperatorId),
15095 "input" => Ok(GeneratedField::Input),
15096 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
15097 "streamKind" | "stream_kind" => Ok(GeneratedField::StreamKind),
15098 "identity" => Ok(GeneratedField::Identity),
15099 "fields" => Ok(GeneratedField::Fields),
15100 "source" => Ok(GeneratedField::Source),
15101 "project" => Ok(GeneratedField::Project),
15102 "filter" => Ok(GeneratedField::Filter),
15103 "materialize" => Ok(GeneratedField::Materialize),
15104 "statelessSimpleAgg" | "stateless_simple_agg" => Ok(GeneratedField::StatelessSimpleAgg),
15105 "simpleAgg" | "simple_agg" => Ok(GeneratedField::SimpleAgg),
15106 "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
15107 "appendOnlyTopN" | "append_only_top_n" => Ok(GeneratedField::AppendOnlyTopN),
15108 "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
15109 "topN" | "top_n" => Ok(GeneratedField::TopN),
15110 "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
15111 "merge" => Ok(GeneratedField::Merge),
15112 "exchange" => Ok(GeneratedField::Exchange),
15113 "streamScan" | "stream_scan" => Ok(GeneratedField::StreamScan),
15114 "batchPlan" | "batch_plan" => Ok(GeneratedField::BatchPlan),
15115 "lookup" => Ok(GeneratedField::Lookup),
15116 "arrange" => Ok(GeneratedField::Arrange),
15117 "lookupUnion" | "lookup_union" => Ok(GeneratedField::LookupUnion),
15118 "union" => Ok(GeneratedField::Union),
15119 "deltaIndexJoin" | "delta_index_join" => Ok(GeneratedField::DeltaIndexJoin),
15120 "sink" => Ok(GeneratedField::Sink),
15121 "expand" => Ok(GeneratedField::Expand),
15122 "dynamicFilter" | "dynamic_filter" => Ok(GeneratedField::DynamicFilter),
15123 "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
15124 "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
15125 "sort" => Ok(GeneratedField::Sort),
15126 "watermarkFilter" | "watermark_filter" => Ok(GeneratedField::WatermarkFilter),
15127 "dml" => Ok(GeneratedField::Dml),
15128 "rowIdGen" | "row_id_gen" => Ok(GeneratedField::RowIdGen),
15129 "now" => Ok(GeneratedField::Now),
15130 "appendOnlyGroupTopN" | "append_only_group_top_n" => Ok(GeneratedField::AppendOnlyGroupTopN),
15131 "temporalJoin" | "temporal_join" => Ok(GeneratedField::TemporalJoin),
15132 "barrierRecv" | "barrier_recv" => Ok(GeneratedField::BarrierRecv),
15133 "values" => Ok(GeneratedField::Values),
15134 "appendOnlyDedup" | "append_only_dedup" => Ok(GeneratedField::AppendOnlyDedup),
15135 "noOp" | "no_op" => Ok(GeneratedField::NoOp),
15136 "eowcOverWindow" | "eowc_over_window" => Ok(GeneratedField::EowcOverWindow),
15137 "overWindow" | "over_window" => Ok(GeneratedField::OverWindow),
15138 "streamFsFetch" | "stream_fs_fetch" => Ok(GeneratedField::StreamFsFetch),
15139 "streamCdcScan" | "stream_cdc_scan" => Ok(GeneratedField::StreamCdcScan),
15140 "cdcFilter" | "cdc_filter" => Ok(GeneratedField::CdcFilter),
15141 "sourceBackfill" | "source_backfill" => Ok(GeneratedField::SourceBackfill),
15142 "changelog" => Ok(GeneratedField::Changelog),
15143 "localApproxPercentile" | "local_approx_percentile" => Ok(GeneratedField::LocalApproxPercentile),
15144 "globalApproxPercentile" | "global_approx_percentile" => Ok(GeneratedField::GlobalApproxPercentile),
15145 "rowMerge" | "row_merge" => Ok(GeneratedField::RowMerge),
15146 "asOfJoin" | "as_of_join" => Ok(GeneratedField::AsOfJoin),
15147 "syncLogStore" | "sync_log_store" => Ok(GeneratedField::SyncLogStore),
15148 "materializedExprs" | "materialized_exprs" => Ok(GeneratedField::MaterializedExprs),
15149 "vectorIndexWrite" | "vector_index_write" => Ok(GeneratedField::VectorIndexWrite),
15150 "upstreamSinkUnion" | "upstream_sink_union" => Ok(GeneratedField::UpstreamSinkUnion),
15151 "localityProvider" | "locality_provider" => Ok(GeneratedField::LocalityProvider),
15152 "eowcGapFill" | "eowc_gap_fill" => Ok(GeneratedField::EowcGapFill),
15153 "gapFill" | "gap_fill" => Ok(GeneratedField::GapFill),
15154 "vectorIndexLookupJoin" | "vector_index_lookup_join" => Ok(GeneratedField::VectorIndexLookupJoin),
15155 "icebergWithPkIndexWriter" | "iceberg_with_pk_index_writer" => Ok(GeneratedField::IcebergWithPkIndexWriter),
15156 "icebergWithPkIndexPositionDeleteMerger" | "iceberg_with_pk_index_position_delete_merger" => Ok(GeneratedField::IcebergWithPkIndexPositionDeleteMerger),
15157 "compactionResolver" | "compaction_resolver" => Ok(GeneratedField::CompactionResolver),
15158 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15159 }
15160 }
15161 }
15162 deserializer.deserialize_identifier(GeneratedVisitor)
15163 }
15164 }
15165 struct GeneratedVisitor;
15166 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15167 type Value = StreamNode;
15168
15169 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15170 formatter.write_str("struct stream_plan.StreamNode")
15171 }
15172
15173 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamNode, V::Error>
15174 where
15175 V: serde::de::MapAccess<'de>,
15176 {
15177 let mut operator_id__ = None;
15178 let mut input__ = None;
15179 let mut stream_key__ = None;
15180 let mut stream_kind__ = None;
15181 let mut identity__ = None;
15182 let mut fields__ = None;
15183 let mut node_body__ = None;
15184 while let Some(k) = map_.next_key()? {
15185 match k {
15186 GeneratedField::OperatorId => {
15187 if operator_id__.is_some() {
15188 return Err(serde::de::Error::duplicate_field("operatorId"));
15189 }
15190 operator_id__ =
15191 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15192 ;
15193 }
15194 GeneratedField::Input => {
15195 if input__.is_some() {
15196 return Err(serde::de::Error::duplicate_field("input"));
15197 }
15198 input__ = Some(map_.next_value()?);
15199 }
15200 GeneratedField::StreamKey => {
15201 if stream_key__.is_some() {
15202 return Err(serde::de::Error::duplicate_field("streamKey"));
15203 }
15204 stream_key__ =
15205 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15206 .into_iter().map(|x| x.0).collect())
15207 ;
15208 }
15209 GeneratedField::StreamKind => {
15210 if stream_kind__.is_some() {
15211 return Err(serde::de::Error::duplicate_field("streamKind"));
15212 }
15213 stream_kind__ = Some(map_.next_value::<stream_node::StreamKind>()? as i32);
15214 }
15215 GeneratedField::Identity => {
15216 if identity__.is_some() {
15217 return Err(serde::de::Error::duplicate_field("identity"));
15218 }
15219 identity__ = Some(map_.next_value()?);
15220 }
15221 GeneratedField::Fields => {
15222 if fields__.is_some() {
15223 return Err(serde::de::Error::duplicate_field("fields"));
15224 }
15225 fields__ = Some(map_.next_value()?);
15226 }
15227 GeneratedField::Source => {
15228 if node_body__.is_some() {
15229 return Err(serde::de::Error::duplicate_field("source"));
15230 }
15231 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Source)
15232;
15233 }
15234 GeneratedField::Project => {
15235 if node_body__.is_some() {
15236 return Err(serde::de::Error::duplicate_field("project"));
15237 }
15238 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Project)
15239;
15240 }
15241 GeneratedField::Filter => {
15242 if node_body__.is_some() {
15243 return Err(serde::de::Error::duplicate_field("filter"));
15244 }
15245 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Filter)
15246;
15247 }
15248 GeneratedField::Materialize => {
15249 if node_body__.is_some() {
15250 return Err(serde::de::Error::duplicate_field("materialize"));
15251 }
15252 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Materialize)
15253;
15254 }
15255 GeneratedField::StatelessSimpleAgg => {
15256 if node_body__.is_some() {
15257 return Err(serde::de::Error::duplicate_field("statelessSimpleAgg"));
15258 }
15259 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StatelessSimpleAgg)
15260;
15261 }
15262 GeneratedField::SimpleAgg => {
15263 if node_body__.is_some() {
15264 return Err(serde::de::Error::duplicate_field("simpleAgg"));
15265 }
15266 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SimpleAgg)
15267;
15268 }
15269 GeneratedField::HashAgg => {
15270 if node_body__.is_some() {
15271 return Err(serde::de::Error::duplicate_field("hashAgg"));
15272 }
15273 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashAgg)
15274;
15275 }
15276 GeneratedField::AppendOnlyTopN => {
15277 if node_body__.is_some() {
15278 return Err(serde::de::Error::duplicate_field("appendOnlyTopN"));
15279 }
15280 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyTopN)
15281;
15282 }
15283 GeneratedField::HashJoin => {
15284 if node_body__.is_some() {
15285 return Err(serde::de::Error::duplicate_field("hashJoin"));
15286 }
15287 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashJoin)
15288;
15289 }
15290 GeneratedField::TopN => {
15291 if node_body__.is_some() {
15292 return Err(serde::de::Error::duplicate_field("topN"));
15293 }
15294 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TopN)
15295;
15296 }
15297 GeneratedField::HopWindow => {
15298 if node_body__.is_some() {
15299 return Err(serde::de::Error::duplicate_field("hopWindow"));
15300 }
15301 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HopWindow)
15302;
15303 }
15304 GeneratedField::Merge => {
15305 if node_body__.is_some() {
15306 return Err(serde::de::Error::duplicate_field("merge"));
15307 }
15308 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Merge)
15309;
15310 }
15311 GeneratedField::Exchange => {
15312 if node_body__.is_some() {
15313 return Err(serde::de::Error::duplicate_field("exchange"));
15314 }
15315 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Exchange)
15316;
15317 }
15318 GeneratedField::StreamScan => {
15319 if node_body__.is_some() {
15320 return Err(serde::de::Error::duplicate_field("streamScan"));
15321 }
15322 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamScan)
15323;
15324 }
15325 GeneratedField::BatchPlan => {
15326 if node_body__.is_some() {
15327 return Err(serde::de::Error::duplicate_field("batchPlan"));
15328 }
15329 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BatchPlan)
15330;
15331 }
15332 GeneratedField::Lookup => {
15333 if node_body__.is_some() {
15334 return Err(serde::de::Error::duplicate_field("lookup"));
15335 }
15336 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Lookup)
15337;
15338 }
15339 GeneratedField::Arrange => {
15340 if node_body__.is_some() {
15341 return Err(serde::de::Error::duplicate_field("arrange"));
15342 }
15343 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Arrange)
15344;
15345 }
15346 GeneratedField::LookupUnion => {
15347 if node_body__.is_some() {
15348 return Err(serde::de::Error::duplicate_field("lookupUnion"));
15349 }
15350 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LookupUnion)
15351;
15352 }
15353 GeneratedField::Union => {
15354 if node_body__.is_some() {
15355 return Err(serde::de::Error::duplicate_field("union"));
15356 }
15357 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Union)
15358;
15359 }
15360 GeneratedField::DeltaIndexJoin => {
15361 if node_body__.is_some() {
15362 return Err(serde::de::Error::duplicate_field("deltaIndexJoin"));
15363 }
15364 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DeltaIndexJoin)
15365;
15366 }
15367 GeneratedField::Sink => {
15368 if node_body__.is_some() {
15369 return Err(serde::de::Error::duplicate_field("sink"));
15370 }
15371 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sink)
15372;
15373 }
15374 GeneratedField::Expand => {
15375 if node_body__.is_some() {
15376 return Err(serde::de::Error::duplicate_field("expand"));
15377 }
15378 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Expand)
15379;
15380 }
15381 GeneratedField::DynamicFilter => {
15382 if node_body__.is_some() {
15383 return Err(serde::de::Error::duplicate_field("dynamicFilter"));
15384 }
15385 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DynamicFilter)
15386;
15387 }
15388 GeneratedField::ProjectSet => {
15389 if node_body__.is_some() {
15390 return Err(serde::de::Error::duplicate_field("projectSet"));
15391 }
15392 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::ProjectSet)
15393;
15394 }
15395 GeneratedField::GroupTopN => {
15396 if node_body__.is_some() {
15397 return Err(serde::de::Error::duplicate_field("groupTopN"));
15398 }
15399 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GroupTopN)
15400;
15401 }
15402 GeneratedField::Sort => {
15403 if node_body__.is_some() {
15404 return Err(serde::de::Error::duplicate_field("sort"));
15405 }
15406 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sort)
15407;
15408 }
15409 GeneratedField::WatermarkFilter => {
15410 if node_body__.is_some() {
15411 return Err(serde::de::Error::duplicate_field("watermarkFilter"));
15412 }
15413 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::WatermarkFilter)
15414;
15415 }
15416 GeneratedField::Dml => {
15417 if node_body__.is_some() {
15418 return Err(serde::de::Error::duplicate_field("dml"));
15419 }
15420 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Dml)
15421;
15422 }
15423 GeneratedField::RowIdGen => {
15424 if node_body__.is_some() {
15425 return Err(serde::de::Error::duplicate_field("rowIdGen"));
15426 }
15427 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowIdGen)
15428;
15429 }
15430 GeneratedField::Now => {
15431 if node_body__.is_some() {
15432 return Err(serde::de::Error::duplicate_field("now"));
15433 }
15434 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Now)
15435;
15436 }
15437 GeneratedField::AppendOnlyGroupTopN => {
15438 if node_body__.is_some() {
15439 return Err(serde::de::Error::duplicate_field("appendOnlyGroupTopN"));
15440 }
15441 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyGroupTopN)
15442;
15443 }
15444 GeneratedField::TemporalJoin => {
15445 if node_body__.is_some() {
15446 return Err(serde::de::Error::duplicate_field("temporalJoin"));
15447 }
15448 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TemporalJoin)
15449;
15450 }
15451 GeneratedField::BarrierRecv => {
15452 if node_body__.is_some() {
15453 return Err(serde::de::Error::duplicate_field("barrierRecv"));
15454 }
15455 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BarrierRecv)
15456;
15457 }
15458 GeneratedField::Values => {
15459 if node_body__.is_some() {
15460 return Err(serde::de::Error::duplicate_field("values"));
15461 }
15462 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Values)
15463;
15464 }
15465 GeneratedField::AppendOnlyDedup => {
15466 if node_body__.is_some() {
15467 return Err(serde::de::Error::duplicate_field("appendOnlyDedup"));
15468 }
15469 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyDedup)
15470;
15471 }
15472 GeneratedField::NoOp => {
15473 if node_body__.is_some() {
15474 return Err(serde::de::Error::duplicate_field("noOp"));
15475 }
15476 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::NoOp)
15477;
15478 }
15479 GeneratedField::EowcOverWindow => {
15480 if node_body__.is_some() {
15481 return Err(serde::de::Error::duplicate_field("eowcOverWindow"));
15482 }
15483 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcOverWindow)
15484;
15485 }
15486 GeneratedField::OverWindow => {
15487 if node_body__.is_some() {
15488 return Err(serde::de::Error::duplicate_field("overWindow"));
15489 }
15490 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::OverWindow)
15491;
15492 }
15493 GeneratedField::StreamFsFetch => {
15494 if node_body__.is_some() {
15495 return Err(serde::de::Error::duplicate_field("streamFsFetch"));
15496 }
15497 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamFsFetch)
15498;
15499 }
15500 GeneratedField::StreamCdcScan => {
15501 if node_body__.is_some() {
15502 return Err(serde::de::Error::duplicate_field("streamCdcScan"));
15503 }
15504 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamCdcScan)
15505;
15506 }
15507 GeneratedField::CdcFilter => {
15508 if node_body__.is_some() {
15509 return Err(serde::de::Error::duplicate_field("cdcFilter"));
15510 }
15511 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CdcFilter)
15512;
15513 }
15514 GeneratedField::SourceBackfill => {
15515 if node_body__.is_some() {
15516 return Err(serde::de::Error::duplicate_field("sourceBackfill"));
15517 }
15518 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SourceBackfill)
15519;
15520 }
15521 GeneratedField::Changelog => {
15522 if node_body__.is_some() {
15523 return Err(serde::de::Error::duplicate_field("changelog"));
15524 }
15525 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Changelog)
15526;
15527 }
15528 GeneratedField::LocalApproxPercentile => {
15529 if node_body__.is_some() {
15530 return Err(serde::de::Error::duplicate_field("localApproxPercentile"));
15531 }
15532 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalApproxPercentile)
15533;
15534 }
15535 GeneratedField::GlobalApproxPercentile => {
15536 if node_body__.is_some() {
15537 return Err(serde::de::Error::duplicate_field("globalApproxPercentile"));
15538 }
15539 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GlobalApproxPercentile)
15540;
15541 }
15542 GeneratedField::RowMerge => {
15543 if node_body__.is_some() {
15544 return Err(serde::de::Error::duplicate_field("rowMerge"));
15545 }
15546 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowMerge)
15547;
15548 }
15549 GeneratedField::AsOfJoin => {
15550 if node_body__.is_some() {
15551 return Err(serde::de::Error::duplicate_field("asOfJoin"));
15552 }
15553 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AsOfJoin)
15554;
15555 }
15556 GeneratedField::SyncLogStore => {
15557 if node_body__.is_some() {
15558 return Err(serde::de::Error::duplicate_field("syncLogStore"));
15559 }
15560 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SyncLogStore)
15561;
15562 }
15563 GeneratedField::MaterializedExprs => {
15564 if node_body__.is_some() {
15565 return Err(serde::de::Error::duplicate_field("materializedExprs"));
15566 }
15567 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MaterializedExprs)
15568;
15569 }
15570 GeneratedField::VectorIndexWrite => {
15571 if node_body__.is_some() {
15572 return Err(serde::de::Error::duplicate_field("vectorIndexWrite"));
15573 }
15574 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexWrite)
15575;
15576 }
15577 GeneratedField::UpstreamSinkUnion => {
15578 if node_body__.is_some() {
15579 return Err(serde::de::Error::duplicate_field("upstreamSinkUnion"));
15580 }
15581 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::UpstreamSinkUnion)
15582;
15583 }
15584 GeneratedField::LocalityProvider => {
15585 if node_body__.is_some() {
15586 return Err(serde::de::Error::duplicate_field("localityProvider"));
15587 }
15588 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalityProvider)
15589;
15590 }
15591 GeneratedField::EowcGapFill => {
15592 if node_body__.is_some() {
15593 return Err(serde::de::Error::duplicate_field("eowcGapFill"));
15594 }
15595 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcGapFill)
15596;
15597 }
15598 GeneratedField::GapFill => {
15599 if node_body__.is_some() {
15600 return Err(serde::de::Error::duplicate_field("gapFill"));
15601 }
15602 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GapFill)
15603;
15604 }
15605 GeneratedField::VectorIndexLookupJoin => {
15606 if node_body__.is_some() {
15607 return Err(serde::de::Error::duplicate_field("vectorIndexLookupJoin"));
15608 }
15609 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexLookupJoin)
15610;
15611 }
15612 GeneratedField::IcebergWithPkIndexWriter => {
15613 if node_body__.is_some() {
15614 return Err(serde::de::Error::duplicate_field("icebergWithPkIndexWriter"));
15615 }
15616 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::IcebergWithPkIndexWriter)
15617;
15618 }
15619 GeneratedField::IcebergWithPkIndexPositionDeleteMerger => {
15620 if node_body__.is_some() {
15621 return Err(serde::de::Error::duplicate_field("icebergWithPkIndexPositionDeleteMerger"));
15622 }
15623 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::IcebergWithPkIndexPositionDeleteMerger)
15624;
15625 }
15626 GeneratedField::CompactionResolver => {
15627 if node_body__.is_some() {
15628 return Err(serde::de::Error::duplicate_field("compactionResolver"));
15629 }
15630 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CompactionResolver)
15631;
15632 }
15633 }
15634 }
15635 Ok(StreamNode {
15636 operator_id: operator_id__.unwrap_or_default(),
15637 input: input__.unwrap_or_default(),
15638 stream_key: stream_key__.unwrap_or_default(),
15639 stream_kind: stream_kind__.unwrap_or_default(),
15640 identity: identity__.unwrap_or_default(),
15641 fields: fields__.unwrap_or_default(),
15642 node_body: node_body__,
15643 })
15644 }
15645 }
15646 deserializer.deserialize_struct("stream_plan.StreamNode", FIELDS, GeneratedVisitor)
15647 }
15648}
15649impl serde::Serialize for stream_node::StreamKind {
15650 #[allow(deprecated)]
15651 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15652 where
15653 S: serde::Serializer,
15654 {
15655 let variant = match self {
15656 Self::Retract => "STREAM_KIND_RETRACT",
15657 Self::AppendOnly => "STREAM_KIND_APPEND_ONLY",
15658 Self::Upsert => "STREAM_KIND_UPSERT",
15659 };
15660 serializer.serialize_str(variant)
15661 }
15662}
15663impl<'de> serde::Deserialize<'de> for stream_node::StreamKind {
15664 #[allow(deprecated)]
15665 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15666 where
15667 D: serde::Deserializer<'de>,
15668 {
15669 const FIELDS: &[&str] = &[
15670 "STREAM_KIND_RETRACT",
15671 "STREAM_KIND_APPEND_ONLY",
15672 "STREAM_KIND_UPSERT",
15673 ];
15674
15675 struct GeneratedVisitor;
15676
15677 impl serde::de::Visitor<'_> for GeneratedVisitor {
15678 type Value = stream_node::StreamKind;
15679
15680 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15681 write!(formatter, "expected one of: {:?}", &FIELDS)
15682 }
15683
15684 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15685 where
15686 E: serde::de::Error,
15687 {
15688 i32::try_from(v)
15689 .ok()
15690 .and_then(|x| x.try_into().ok())
15691 .ok_or_else(|| {
15692 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15693 })
15694 }
15695
15696 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15697 where
15698 E: serde::de::Error,
15699 {
15700 i32::try_from(v)
15701 .ok()
15702 .and_then(|x| x.try_into().ok())
15703 .ok_or_else(|| {
15704 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15705 })
15706 }
15707
15708 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15709 where
15710 E: serde::de::Error,
15711 {
15712 match value {
15713 "STREAM_KIND_RETRACT" => Ok(stream_node::StreamKind::Retract),
15714 "STREAM_KIND_APPEND_ONLY" => Ok(stream_node::StreamKind::AppendOnly),
15715 "STREAM_KIND_UPSERT" => Ok(stream_node::StreamKind::Upsert),
15716 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15717 }
15718 }
15719 }
15720 deserializer.deserialize_any(GeneratedVisitor)
15721 }
15722}
15723impl serde::Serialize for StreamScanNode {
15724 #[allow(deprecated)]
15725 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15726 where
15727 S: serde::Serializer,
15728 {
15729 use serde::ser::SerializeStruct;
15730 let mut len = 0;
15731 if self.table_id != 0 {
15732 len += 1;
15733 }
15734 if !self.upstream_column_ids.is_empty() {
15735 len += 1;
15736 }
15737 if !self.output_indices.is_empty() {
15738 len += 1;
15739 }
15740 if self.stream_scan_type != 0 {
15741 len += 1;
15742 }
15743 if self.state_table.is_some() {
15744 len += 1;
15745 }
15746 if self.table_desc.is_some() {
15747 len += 1;
15748 }
15749 if self.rate_limit.is_some() {
15750 len += 1;
15751 }
15752 if self.snapshot_read_barrier_interval != 0 {
15753 len += 1;
15754 }
15755 if self.arrangement_table.is_some() {
15756 len += 1;
15757 }
15758 if self.snapshot_backfill_epoch.is_some() {
15759 len += 1;
15760 }
15761 if self.pk_scan_range.is_some() {
15762 len += 1;
15763 }
15764 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamScanNode", len)?;
15765 if self.table_id != 0 {
15766 struct_ser.serialize_field("tableId", &self.table_id)?;
15767 }
15768 if !self.upstream_column_ids.is_empty() {
15769 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
15770 }
15771 if !self.output_indices.is_empty() {
15772 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
15773 }
15774 if self.stream_scan_type != 0 {
15775 let v = StreamScanType::try_from(self.stream_scan_type)
15776 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_scan_type)))?;
15777 struct_ser.serialize_field("streamScanType", &v)?;
15778 }
15779 if let Some(v) = self.state_table.as_ref() {
15780 struct_ser.serialize_field("stateTable", v)?;
15781 }
15782 if let Some(v) = self.table_desc.as_ref() {
15783 struct_ser.serialize_field("tableDesc", v)?;
15784 }
15785 if let Some(v) = self.rate_limit.as_ref() {
15786 struct_ser.serialize_field("rateLimit", v)?;
15787 }
15788 if self.snapshot_read_barrier_interval != 0 {
15789 struct_ser.serialize_field("snapshotReadBarrierInterval", &self.snapshot_read_barrier_interval)?;
15790 }
15791 if let Some(v) = self.arrangement_table.as_ref() {
15792 struct_ser.serialize_field("arrangementTable", v)?;
15793 }
15794 if let Some(v) = self.snapshot_backfill_epoch.as_ref() {
15795 #[allow(clippy::needless_borrow)]
15796 #[allow(clippy::needless_borrows_for_generic_args)]
15797 struct_ser.serialize_field("snapshotBackfillEpoch", ToString::to_string(&v).as_str())?;
15798 }
15799 if let Some(v) = self.pk_scan_range.as_ref() {
15800 struct_ser.serialize_field("pkScanRange", v)?;
15801 }
15802 struct_ser.end()
15803 }
15804}
15805impl<'de> serde::Deserialize<'de> for StreamScanNode {
15806 #[allow(deprecated)]
15807 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15808 where
15809 D: serde::Deserializer<'de>,
15810 {
15811 const FIELDS: &[&str] = &[
15812 "table_id",
15813 "tableId",
15814 "upstream_column_ids",
15815 "upstreamColumnIds",
15816 "output_indices",
15817 "outputIndices",
15818 "stream_scan_type",
15819 "streamScanType",
15820 "state_table",
15821 "stateTable",
15822 "table_desc",
15823 "tableDesc",
15824 "rate_limit",
15825 "rateLimit",
15826 "snapshot_read_barrier_interval",
15827 "snapshotReadBarrierInterval",
15828 "arrangement_table",
15829 "arrangementTable",
15830 "snapshot_backfill_epoch",
15831 "snapshotBackfillEpoch",
15832 "pk_scan_range",
15833 "pkScanRange",
15834 ];
15835
15836 #[allow(clippy::enum_variant_names)]
15837 enum GeneratedField {
15838 TableId,
15839 UpstreamColumnIds,
15840 OutputIndices,
15841 StreamScanType,
15842 StateTable,
15843 TableDesc,
15844 RateLimit,
15845 SnapshotReadBarrierInterval,
15846 ArrangementTable,
15847 SnapshotBackfillEpoch,
15848 PkScanRange,
15849 }
15850 impl<'de> serde::Deserialize<'de> for GeneratedField {
15851 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15852 where
15853 D: serde::Deserializer<'de>,
15854 {
15855 struct GeneratedVisitor;
15856
15857 impl serde::de::Visitor<'_> for GeneratedVisitor {
15858 type Value = GeneratedField;
15859
15860 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15861 write!(formatter, "expected one of: {:?}", &FIELDS)
15862 }
15863
15864 #[allow(unused_variables)]
15865 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15866 where
15867 E: serde::de::Error,
15868 {
15869 match value {
15870 "tableId" | "table_id" => Ok(GeneratedField::TableId),
15871 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
15872 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
15873 "streamScanType" | "stream_scan_type" => Ok(GeneratedField::StreamScanType),
15874 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
15875 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
15876 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
15877 "snapshotReadBarrierInterval" | "snapshot_read_barrier_interval" => Ok(GeneratedField::SnapshotReadBarrierInterval),
15878 "arrangementTable" | "arrangement_table" => Ok(GeneratedField::ArrangementTable),
15879 "snapshotBackfillEpoch" | "snapshot_backfill_epoch" => Ok(GeneratedField::SnapshotBackfillEpoch),
15880 "pkScanRange" | "pk_scan_range" => Ok(GeneratedField::PkScanRange),
15881 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15882 }
15883 }
15884 }
15885 deserializer.deserialize_identifier(GeneratedVisitor)
15886 }
15887 }
15888 struct GeneratedVisitor;
15889 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15890 type Value = StreamScanNode;
15891
15892 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15893 formatter.write_str("struct stream_plan.StreamScanNode")
15894 }
15895
15896 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamScanNode, V::Error>
15897 where
15898 V: serde::de::MapAccess<'de>,
15899 {
15900 let mut table_id__ = None;
15901 let mut upstream_column_ids__ = None;
15902 let mut output_indices__ = None;
15903 let mut stream_scan_type__ = None;
15904 let mut state_table__ = None;
15905 let mut table_desc__ = None;
15906 let mut rate_limit__ = None;
15907 let mut snapshot_read_barrier_interval__ = None;
15908 let mut arrangement_table__ = None;
15909 let mut snapshot_backfill_epoch__ = None;
15910 let mut pk_scan_range__ = None;
15911 while let Some(k) = map_.next_key()? {
15912 match k {
15913 GeneratedField::TableId => {
15914 if table_id__.is_some() {
15915 return Err(serde::de::Error::duplicate_field("tableId"));
15916 }
15917 table_id__ =
15918 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15919 ;
15920 }
15921 GeneratedField::UpstreamColumnIds => {
15922 if upstream_column_ids__.is_some() {
15923 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
15924 }
15925 upstream_column_ids__ =
15926 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15927 .into_iter().map(|x| x.0).collect())
15928 ;
15929 }
15930 GeneratedField::OutputIndices => {
15931 if output_indices__.is_some() {
15932 return Err(serde::de::Error::duplicate_field("outputIndices"));
15933 }
15934 output_indices__ =
15935 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15936 .into_iter().map(|x| x.0).collect())
15937 ;
15938 }
15939 GeneratedField::StreamScanType => {
15940 if stream_scan_type__.is_some() {
15941 return Err(serde::de::Error::duplicate_field("streamScanType"));
15942 }
15943 stream_scan_type__ = Some(map_.next_value::<StreamScanType>()? as i32);
15944 }
15945 GeneratedField::StateTable => {
15946 if state_table__.is_some() {
15947 return Err(serde::de::Error::duplicate_field("stateTable"));
15948 }
15949 state_table__ = map_.next_value()?;
15950 }
15951 GeneratedField::TableDesc => {
15952 if table_desc__.is_some() {
15953 return Err(serde::de::Error::duplicate_field("tableDesc"));
15954 }
15955 table_desc__ = map_.next_value()?;
15956 }
15957 GeneratedField::RateLimit => {
15958 if rate_limit__.is_some() {
15959 return Err(serde::de::Error::duplicate_field("rateLimit"));
15960 }
15961 rate_limit__ =
15962 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15963 ;
15964 }
15965 GeneratedField::SnapshotReadBarrierInterval => {
15966 if snapshot_read_barrier_interval__.is_some() {
15967 return Err(serde::de::Error::duplicate_field("snapshotReadBarrierInterval"));
15968 }
15969 snapshot_read_barrier_interval__ =
15970 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15971 ;
15972 }
15973 GeneratedField::ArrangementTable => {
15974 if arrangement_table__.is_some() {
15975 return Err(serde::de::Error::duplicate_field("arrangementTable"));
15976 }
15977 arrangement_table__ = map_.next_value()?;
15978 }
15979 GeneratedField::SnapshotBackfillEpoch => {
15980 if snapshot_backfill_epoch__.is_some() {
15981 return Err(serde::de::Error::duplicate_field("snapshotBackfillEpoch"));
15982 }
15983 snapshot_backfill_epoch__ =
15984 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15985 ;
15986 }
15987 GeneratedField::PkScanRange => {
15988 if pk_scan_range__.is_some() {
15989 return Err(serde::de::Error::duplicate_field("pkScanRange"));
15990 }
15991 pk_scan_range__ = map_.next_value()?;
15992 }
15993 }
15994 }
15995 Ok(StreamScanNode {
15996 table_id: table_id__.unwrap_or_default(),
15997 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
15998 output_indices: output_indices__.unwrap_or_default(),
15999 stream_scan_type: stream_scan_type__.unwrap_or_default(),
16000 state_table: state_table__,
16001 table_desc: table_desc__,
16002 rate_limit: rate_limit__,
16003 snapshot_read_barrier_interval: snapshot_read_barrier_interval__.unwrap_or_default(),
16004 arrangement_table: arrangement_table__,
16005 snapshot_backfill_epoch: snapshot_backfill_epoch__,
16006 pk_scan_range: pk_scan_range__,
16007 })
16008 }
16009 }
16010 deserializer.deserialize_struct("stream_plan.StreamScanNode", FIELDS, GeneratedVisitor)
16011 }
16012}
16013impl serde::Serialize for StreamScanType {
16014 #[allow(deprecated)]
16015 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16016 where
16017 S: serde::Serializer,
16018 {
16019 let variant = match self {
16020 Self::Unspecified => "STREAM_SCAN_TYPE_UNSPECIFIED",
16021 Self::Chain => "STREAM_SCAN_TYPE_CHAIN",
16022 Self::Rearrange => "STREAM_SCAN_TYPE_REARRANGE",
16023 Self::Backfill => "STREAM_SCAN_TYPE_BACKFILL",
16024 Self::UpstreamOnly => "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
16025 Self::ArrangementBackfill => "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
16026 Self::SnapshotBackfill => "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
16027 Self::CrossDbSnapshotBackfill => "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
16028 };
16029 serializer.serialize_str(variant)
16030 }
16031}
16032impl<'de> serde::Deserialize<'de> for StreamScanType {
16033 #[allow(deprecated)]
16034 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16035 where
16036 D: serde::Deserializer<'de>,
16037 {
16038 const FIELDS: &[&str] = &[
16039 "STREAM_SCAN_TYPE_UNSPECIFIED",
16040 "STREAM_SCAN_TYPE_CHAIN",
16041 "STREAM_SCAN_TYPE_REARRANGE",
16042 "STREAM_SCAN_TYPE_BACKFILL",
16043 "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
16044 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
16045 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
16046 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
16047 ];
16048
16049 struct GeneratedVisitor;
16050
16051 impl serde::de::Visitor<'_> for GeneratedVisitor {
16052 type Value = StreamScanType;
16053
16054 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16055 write!(formatter, "expected one of: {:?}", &FIELDS)
16056 }
16057
16058 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16059 where
16060 E: serde::de::Error,
16061 {
16062 i32::try_from(v)
16063 .ok()
16064 .and_then(|x| x.try_into().ok())
16065 .ok_or_else(|| {
16066 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16067 })
16068 }
16069
16070 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16071 where
16072 E: serde::de::Error,
16073 {
16074 i32::try_from(v)
16075 .ok()
16076 .and_then(|x| x.try_into().ok())
16077 .ok_or_else(|| {
16078 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16079 })
16080 }
16081
16082 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16083 where
16084 E: serde::de::Error,
16085 {
16086 match value {
16087 "STREAM_SCAN_TYPE_UNSPECIFIED" => Ok(StreamScanType::Unspecified),
16088 "STREAM_SCAN_TYPE_CHAIN" => Ok(StreamScanType::Chain),
16089 "STREAM_SCAN_TYPE_REARRANGE" => Ok(StreamScanType::Rearrange),
16090 "STREAM_SCAN_TYPE_BACKFILL" => Ok(StreamScanType::Backfill),
16091 "STREAM_SCAN_TYPE_UPSTREAM_ONLY" => Ok(StreamScanType::UpstreamOnly),
16092 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL" => Ok(StreamScanType::ArrangementBackfill),
16093 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL" => Ok(StreamScanType::SnapshotBackfill),
16094 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL" => Ok(StreamScanType::CrossDbSnapshotBackfill),
16095 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16096 }
16097 }
16098 }
16099 deserializer.deserialize_any(GeneratedVisitor)
16100 }
16101}
16102impl serde::Serialize for StreamSource {
16103 #[allow(deprecated)]
16104 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16105 where
16106 S: serde::Serializer,
16107 {
16108 use serde::ser::SerializeStruct;
16109 let mut len = 0;
16110 if self.source_id != 0 {
16111 len += 1;
16112 }
16113 if self.state_table.is_some() {
16114 len += 1;
16115 }
16116 if self.row_id_index.is_some() {
16117 len += 1;
16118 }
16119 if !self.columns.is_empty() {
16120 len += 1;
16121 }
16122 if !self.with_properties.is_empty() {
16123 len += 1;
16124 }
16125 if self.info.is_some() {
16126 len += 1;
16127 }
16128 if !self.source_name.is_empty() {
16129 len += 1;
16130 }
16131 if self.rate_limit.is_some() {
16132 len += 1;
16133 }
16134 if !self.secret_refs.is_empty() {
16135 len += 1;
16136 }
16137 if self.downstream_columns.is_some() {
16138 len += 1;
16139 }
16140 if self.refresh_mode.is_some() {
16141 len += 1;
16142 }
16143 if self.associated_table_id.is_some() {
16144 len += 1;
16145 }
16146 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamSource", len)?;
16147 if self.source_id != 0 {
16148 struct_ser.serialize_field("sourceId", &self.source_id)?;
16149 }
16150 if let Some(v) = self.state_table.as_ref() {
16151 struct_ser.serialize_field("stateTable", v)?;
16152 }
16153 if let Some(v) = self.row_id_index.as_ref() {
16154 struct_ser.serialize_field("rowIdIndex", v)?;
16155 }
16156 if !self.columns.is_empty() {
16157 struct_ser.serialize_field("columns", &self.columns)?;
16158 }
16159 if !self.with_properties.is_empty() {
16160 struct_ser.serialize_field("withProperties", &self.with_properties)?;
16161 }
16162 if let Some(v) = self.info.as_ref() {
16163 struct_ser.serialize_field("info", v)?;
16164 }
16165 if !self.source_name.is_empty() {
16166 struct_ser.serialize_field("sourceName", &self.source_name)?;
16167 }
16168 if let Some(v) = self.rate_limit.as_ref() {
16169 struct_ser.serialize_field("rateLimit", v)?;
16170 }
16171 if !self.secret_refs.is_empty() {
16172 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
16173 }
16174 if let Some(v) = self.downstream_columns.as_ref() {
16175 struct_ser.serialize_field("downstreamColumns", v)?;
16176 }
16177 if let Some(v) = self.refresh_mode.as_ref() {
16178 struct_ser.serialize_field("refreshMode", v)?;
16179 }
16180 if let Some(v) = self.associated_table_id.as_ref() {
16181 struct_ser.serialize_field("associatedTableId", v)?;
16182 }
16183 struct_ser.end()
16184 }
16185}
16186impl<'de> serde::Deserialize<'de> for StreamSource {
16187 #[allow(deprecated)]
16188 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16189 where
16190 D: serde::Deserializer<'de>,
16191 {
16192 const FIELDS: &[&str] = &[
16193 "source_id",
16194 "sourceId",
16195 "state_table",
16196 "stateTable",
16197 "row_id_index",
16198 "rowIdIndex",
16199 "columns",
16200 "with_properties",
16201 "withProperties",
16202 "info",
16203 "source_name",
16204 "sourceName",
16205 "rate_limit",
16206 "rateLimit",
16207 "secret_refs",
16208 "secretRefs",
16209 "downstream_columns",
16210 "downstreamColumns",
16211 "refresh_mode",
16212 "refreshMode",
16213 "associated_table_id",
16214 "associatedTableId",
16215 ];
16216
16217 #[allow(clippy::enum_variant_names)]
16218 enum GeneratedField {
16219 SourceId,
16220 StateTable,
16221 RowIdIndex,
16222 Columns,
16223 WithProperties,
16224 Info,
16225 SourceName,
16226 RateLimit,
16227 SecretRefs,
16228 DownstreamColumns,
16229 RefreshMode,
16230 AssociatedTableId,
16231 }
16232 impl<'de> serde::Deserialize<'de> for GeneratedField {
16233 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16234 where
16235 D: serde::Deserializer<'de>,
16236 {
16237 struct GeneratedVisitor;
16238
16239 impl serde::de::Visitor<'_> for GeneratedVisitor {
16240 type Value = GeneratedField;
16241
16242 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16243 write!(formatter, "expected one of: {:?}", &FIELDS)
16244 }
16245
16246 #[allow(unused_variables)]
16247 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16248 where
16249 E: serde::de::Error,
16250 {
16251 match value {
16252 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
16253 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
16254 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
16255 "columns" => Ok(GeneratedField::Columns),
16256 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
16257 "info" => Ok(GeneratedField::Info),
16258 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
16259 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
16260 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
16261 "downstreamColumns" | "downstream_columns" => Ok(GeneratedField::DownstreamColumns),
16262 "refreshMode" | "refresh_mode" => Ok(GeneratedField::RefreshMode),
16263 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
16264 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16265 }
16266 }
16267 }
16268 deserializer.deserialize_identifier(GeneratedVisitor)
16269 }
16270 }
16271 struct GeneratedVisitor;
16272 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16273 type Value = StreamSource;
16274
16275 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16276 formatter.write_str("struct stream_plan.StreamSource")
16277 }
16278
16279 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSource, V::Error>
16280 where
16281 V: serde::de::MapAccess<'de>,
16282 {
16283 let mut source_id__ = None;
16284 let mut state_table__ = None;
16285 let mut row_id_index__ = None;
16286 let mut columns__ = None;
16287 let mut with_properties__ = None;
16288 let mut info__ = None;
16289 let mut source_name__ = None;
16290 let mut rate_limit__ = None;
16291 let mut secret_refs__ = None;
16292 let mut downstream_columns__ = None;
16293 let mut refresh_mode__ = None;
16294 let mut associated_table_id__ = None;
16295 while let Some(k) = map_.next_key()? {
16296 match k {
16297 GeneratedField::SourceId => {
16298 if source_id__.is_some() {
16299 return Err(serde::de::Error::duplicate_field("sourceId"));
16300 }
16301 source_id__ =
16302 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16303 ;
16304 }
16305 GeneratedField::StateTable => {
16306 if state_table__.is_some() {
16307 return Err(serde::de::Error::duplicate_field("stateTable"));
16308 }
16309 state_table__ = map_.next_value()?;
16310 }
16311 GeneratedField::RowIdIndex => {
16312 if row_id_index__.is_some() {
16313 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
16314 }
16315 row_id_index__ =
16316 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16317 ;
16318 }
16319 GeneratedField::Columns => {
16320 if columns__.is_some() {
16321 return Err(serde::de::Error::duplicate_field("columns"));
16322 }
16323 columns__ = Some(map_.next_value()?);
16324 }
16325 GeneratedField::WithProperties => {
16326 if with_properties__.is_some() {
16327 return Err(serde::de::Error::duplicate_field("withProperties"));
16328 }
16329 with_properties__ = Some(
16330 map_.next_value::<std::collections::BTreeMap<_, _>>()?
16331 );
16332 }
16333 GeneratedField::Info => {
16334 if info__.is_some() {
16335 return Err(serde::de::Error::duplicate_field("info"));
16336 }
16337 info__ = map_.next_value()?;
16338 }
16339 GeneratedField::SourceName => {
16340 if source_name__.is_some() {
16341 return Err(serde::de::Error::duplicate_field("sourceName"));
16342 }
16343 source_name__ = Some(map_.next_value()?);
16344 }
16345 GeneratedField::RateLimit => {
16346 if rate_limit__.is_some() {
16347 return Err(serde::de::Error::duplicate_field("rateLimit"));
16348 }
16349 rate_limit__ =
16350 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16351 ;
16352 }
16353 GeneratedField::SecretRefs => {
16354 if secret_refs__.is_some() {
16355 return Err(serde::de::Error::duplicate_field("secretRefs"));
16356 }
16357 secret_refs__ = Some(
16358 map_.next_value::<std::collections::BTreeMap<_, _>>()?
16359 );
16360 }
16361 GeneratedField::DownstreamColumns => {
16362 if downstream_columns__.is_some() {
16363 return Err(serde::de::Error::duplicate_field("downstreamColumns"));
16364 }
16365 downstream_columns__ = map_.next_value()?;
16366 }
16367 GeneratedField::RefreshMode => {
16368 if refresh_mode__.is_some() {
16369 return Err(serde::de::Error::duplicate_field("refreshMode"));
16370 }
16371 refresh_mode__ = map_.next_value()?;
16372 }
16373 GeneratedField::AssociatedTableId => {
16374 if associated_table_id__.is_some() {
16375 return Err(serde::de::Error::duplicate_field("associatedTableId"));
16376 }
16377 associated_table_id__ =
16378 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16379 ;
16380 }
16381 }
16382 }
16383 Ok(StreamSource {
16384 source_id: source_id__.unwrap_or_default(),
16385 state_table: state_table__,
16386 row_id_index: row_id_index__,
16387 columns: columns__.unwrap_or_default(),
16388 with_properties: with_properties__.unwrap_or_default(),
16389 info: info__,
16390 source_name: source_name__.unwrap_or_default(),
16391 rate_limit: rate_limit__,
16392 secret_refs: secret_refs__.unwrap_or_default(),
16393 downstream_columns: downstream_columns__,
16394 refresh_mode: refresh_mode__,
16395 associated_table_id: associated_table_id__,
16396 })
16397 }
16398 }
16399 deserializer.deserialize_struct("stream_plan.StreamSource", FIELDS, GeneratedVisitor)
16400 }
16401}
16402impl serde::Serialize for SubscriptionUpstreamInfo {
16403 #[allow(deprecated)]
16404 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16405 where
16406 S: serde::Serializer,
16407 {
16408 use serde::ser::SerializeStruct;
16409 let mut len = 0;
16410 if self.subscriber_id != 0 {
16411 len += 1;
16412 }
16413 if self.upstream_mv_table_id != 0 {
16414 len += 1;
16415 }
16416 let mut struct_ser = serializer.serialize_struct("stream_plan.SubscriptionUpstreamInfo", len)?;
16417 if self.subscriber_id != 0 {
16418 struct_ser.serialize_field("subscriberId", &self.subscriber_id)?;
16419 }
16420 if self.upstream_mv_table_id != 0 {
16421 struct_ser.serialize_field("upstreamMvTableId", &self.upstream_mv_table_id)?;
16422 }
16423 struct_ser.end()
16424 }
16425}
16426impl<'de> serde::Deserialize<'de> for SubscriptionUpstreamInfo {
16427 #[allow(deprecated)]
16428 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16429 where
16430 D: serde::Deserializer<'de>,
16431 {
16432 const FIELDS: &[&str] = &[
16433 "subscriber_id",
16434 "subscriberId",
16435 "upstream_mv_table_id",
16436 "upstreamMvTableId",
16437 ];
16438
16439 #[allow(clippy::enum_variant_names)]
16440 enum GeneratedField {
16441 SubscriberId,
16442 UpstreamMvTableId,
16443 }
16444 impl<'de> serde::Deserialize<'de> for GeneratedField {
16445 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16446 where
16447 D: serde::Deserializer<'de>,
16448 {
16449 struct GeneratedVisitor;
16450
16451 impl serde::de::Visitor<'_> for GeneratedVisitor {
16452 type Value = GeneratedField;
16453
16454 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16455 write!(formatter, "expected one of: {:?}", &FIELDS)
16456 }
16457
16458 #[allow(unused_variables)]
16459 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16460 where
16461 E: serde::de::Error,
16462 {
16463 match value {
16464 "subscriberId" | "subscriber_id" => Ok(GeneratedField::SubscriberId),
16465 "upstreamMvTableId" | "upstream_mv_table_id" => Ok(GeneratedField::UpstreamMvTableId),
16466 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16467 }
16468 }
16469 }
16470 deserializer.deserialize_identifier(GeneratedVisitor)
16471 }
16472 }
16473 struct GeneratedVisitor;
16474 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16475 type Value = SubscriptionUpstreamInfo;
16476
16477 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16478 formatter.write_str("struct stream_plan.SubscriptionUpstreamInfo")
16479 }
16480
16481 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscriptionUpstreamInfo, V::Error>
16482 where
16483 V: serde::de::MapAccess<'de>,
16484 {
16485 let mut subscriber_id__ = None;
16486 let mut upstream_mv_table_id__ = None;
16487 while let Some(k) = map_.next_key()? {
16488 match k {
16489 GeneratedField::SubscriberId => {
16490 if subscriber_id__.is_some() {
16491 return Err(serde::de::Error::duplicate_field("subscriberId"));
16492 }
16493 subscriber_id__ =
16494 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16495 ;
16496 }
16497 GeneratedField::UpstreamMvTableId => {
16498 if upstream_mv_table_id__.is_some() {
16499 return Err(serde::de::Error::duplicate_field("upstreamMvTableId"));
16500 }
16501 upstream_mv_table_id__ =
16502 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16503 ;
16504 }
16505 }
16506 }
16507 Ok(SubscriptionUpstreamInfo {
16508 subscriber_id: subscriber_id__.unwrap_or_default(),
16509 upstream_mv_table_id: upstream_mv_table_id__.unwrap_or_default(),
16510 })
16511 }
16512 }
16513 deserializer.deserialize_struct("stream_plan.SubscriptionUpstreamInfo", FIELDS, GeneratedVisitor)
16514 }
16515}
16516impl serde::Serialize for SyncLogStoreNode {
16517 #[allow(deprecated)]
16518 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16519 where
16520 S: serde::Serializer,
16521 {
16522 use serde::ser::SerializeStruct;
16523 let mut len = 0;
16524 if self.log_store_table.is_some() {
16525 len += 1;
16526 }
16527 if self.pause_duration_ms.is_some() {
16528 len += 1;
16529 }
16530 if self.buffer_size.is_some() {
16531 len += 1;
16532 }
16533 if self.aligned {
16534 len += 1;
16535 }
16536 let mut struct_ser = serializer.serialize_struct("stream_plan.SyncLogStoreNode", len)?;
16537 if let Some(v) = self.log_store_table.as_ref() {
16538 struct_ser.serialize_field("logStoreTable", v)?;
16539 }
16540 if let Some(v) = self.pause_duration_ms.as_ref() {
16541 struct_ser.serialize_field("pauseDurationMs", v)?;
16542 }
16543 if let Some(v) = self.buffer_size.as_ref() {
16544 struct_ser.serialize_field("bufferSize", v)?;
16545 }
16546 if self.aligned {
16547 struct_ser.serialize_field("aligned", &self.aligned)?;
16548 }
16549 struct_ser.end()
16550 }
16551}
16552impl<'de> serde::Deserialize<'de> for SyncLogStoreNode {
16553 #[allow(deprecated)]
16554 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16555 where
16556 D: serde::Deserializer<'de>,
16557 {
16558 const FIELDS: &[&str] = &[
16559 "log_store_table",
16560 "logStoreTable",
16561 "pause_duration_ms",
16562 "pauseDurationMs",
16563 "buffer_size",
16564 "bufferSize",
16565 "aligned",
16566 ];
16567
16568 #[allow(clippy::enum_variant_names)]
16569 enum GeneratedField {
16570 LogStoreTable,
16571 PauseDurationMs,
16572 BufferSize,
16573 Aligned,
16574 }
16575 impl<'de> serde::Deserialize<'de> for GeneratedField {
16576 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16577 where
16578 D: serde::Deserializer<'de>,
16579 {
16580 struct GeneratedVisitor;
16581
16582 impl serde::de::Visitor<'_> for GeneratedVisitor {
16583 type Value = GeneratedField;
16584
16585 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16586 write!(formatter, "expected one of: {:?}", &FIELDS)
16587 }
16588
16589 #[allow(unused_variables)]
16590 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16591 where
16592 E: serde::de::Error,
16593 {
16594 match value {
16595 "logStoreTable" | "log_store_table" => Ok(GeneratedField::LogStoreTable),
16596 "pauseDurationMs" | "pause_duration_ms" => Ok(GeneratedField::PauseDurationMs),
16597 "bufferSize" | "buffer_size" => Ok(GeneratedField::BufferSize),
16598 "aligned" => Ok(GeneratedField::Aligned),
16599 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16600 }
16601 }
16602 }
16603 deserializer.deserialize_identifier(GeneratedVisitor)
16604 }
16605 }
16606 struct GeneratedVisitor;
16607 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16608 type Value = SyncLogStoreNode;
16609
16610 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16611 formatter.write_str("struct stream_plan.SyncLogStoreNode")
16612 }
16613
16614 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SyncLogStoreNode, V::Error>
16615 where
16616 V: serde::de::MapAccess<'de>,
16617 {
16618 let mut log_store_table__ = None;
16619 let mut pause_duration_ms__ = None;
16620 let mut buffer_size__ = None;
16621 let mut aligned__ = None;
16622 while let Some(k) = map_.next_key()? {
16623 match k {
16624 GeneratedField::LogStoreTable => {
16625 if log_store_table__.is_some() {
16626 return Err(serde::de::Error::duplicate_field("logStoreTable"));
16627 }
16628 log_store_table__ = map_.next_value()?;
16629 }
16630 GeneratedField::PauseDurationMs => {
16631 if pause_duration_ms__.is_some() {
16632 return Err(serde::de::Error::duplicate_field("pauseDurationMs"));
16633 }
16634 pause_duration_ms__ =
16635 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16636 ;
16637 }
16638 GeneratedField::BufferSize => {
16639 if buffer_size__.is_some() {
16640 return Err(serde::de::Error::duplicate_field("bufferSize"));
16641 }
16642 buffer_size__ =
16643 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16644 ;
16645 }
16646 GeneratedField::Aligned => {
16647 if aligned__.is_some() {
16648 return Err(serde::de::Error::duplicate_field("aligned"));
16649 }
16650 aligned__ = Some(map_.next_value()?);
16651 }
16652 }
16653 }
16654 Ok(SyncLogStoreNode {
16655 log_store_table: log_store_table__,
16656 pause_duration_ms: pause_duration_ms__,
16657 buffer_size: buffer_size__,
16658 aligned: aligned__.unwrap_or_default(),
16659 })
16660 }
16661 }
16662 deserializer.deserialize_struct("stream_plan.SyncLogStoreNode", FIELDS, GeneratedVisitor)
16663 }
16664}
16665impl serde::Serialize for TemporalJoinNode {
16666 #[allow(deprecated)]
16667 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16668 where
16669 S: serde::Serializer,
16670 {
16671 use serde::ser::SerializeStruct;
16672 let mut len = 0;
16673 if self.join_type != 0 {
16674 len += 1;
16675 }
16676 if !self.left_key.is_empty() {
16677 len += 1;
16678 }
16679 if !self.right_key.is_empty() {
16680 len += 1;
16681 }
16682 if !self.null_safe.is_empty() {
16683 len += 1;
16684 }
16685 if self.condition.is_some() {
16686 len += 1;
16687 }
16688 if !self.output_indices.is_empty() {
16689 len += 1;
16690 }
16691 if self.table_desc.is_some() {
16692 len += 1;
16693 }
16694 if !self.table_output_indices.is_empty() {
16695 len += 1;
16696 }
16697 if self.memo_table.is_some() {
16698 len += 1;
16699 }
16700 if self.is_nested_loop {
16701 len += 1;
16702 }
16703 let mut struct_ser = serializer.serialize_struct("stream_plan.TemporalJoinNode", len)?;
16704 if self.join_type != 0 {
16705 let v = super::plan_common::JoinType::try_from(self.join_type)
16706 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
16707 struct_ser.serialize_field("joinType", &v)?;
16708 }
16709 if !self.left_key.is_empty() {
16710 struct_ser.serialize_field("leftKey", &self.left_key)?;
16711 }
16712 if !self.right_key.is_empty() {
16713 struct_ser.serialize_field("rightKey", &self.right_key)?;
16714 }
16715 if !self.null_safe.is_empty() {
16716 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
16717 }
16718 if let Some(v) = self.condition.as_ref() {
16719 struct_ser.serialize_field("condition", v)?;
16720 }
16721 if !self.output_indices.is_empty() {
16722 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
16723 }
16724 if let Some(v) = self.table_desc.as_ref() {
16725 struct_ser.serialize_field("tableDesc", v)?;
16726 }
16727 if !self.table_output_indices.is_empty() {
16728 struct_ser.serialize_field("tableOutputIndices", &self.table_output_indices)?;
16729 }
16730 if let Some(v) = self.memo_table.as_ref() {
16731 struct_ser.serialize_field("memoTable", v)?;
16732 }
16733 if self.is_nested_loop {
16734 struct_ser.serialize_field("isNestedLoop", &self.is_nested_loop)?;
16735 }
16736 struct_ser.end()
16737 }
16738}
16739impl<'de> serde::Deserialize<'de> for TemporalJoinNode {
16740 #[allow(deprecated)]
16741 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16742 where
16743 D: serde::Deserializer<'de>,
16744 {
16745 const FIELDS: &[&str] = &[
16746 "join_type",
16747 "joinType",
16748 "left_key",
16749 "leftKey",
16750 "right_key",
16751 "rightKey",
16752 "null_safe",
16753 "nullSafe",
16754 "condition",
16755 "output_indices",
16756 "outputIndices",
16757 "table_desc",
16758 "tableDesc",
16759 "table_output_indices",
16760 "tableOutputIndices",
16761 "memo_table",
16762 "memoTable",
16763 "is_nested_loop",
16764 "isNestedLoop",
16765 ];
16766
16767 #[allow(clippy::enum_variant_names)]
16768 enum GeneratedField {
16769 JoinType,
16770 LeftKey,
16771 RightKey,
16772 NullSafe,
16773 Condition,
16774 OutputIndices,
16775 TableDesc,
16776 TableOutputIndices,
16777 MemoTable,
16778 IsNestedLoop,
16779 }
16780 impl<'de> serde::Deserialize<'de> for GeneratedField {
16781 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16782 where
16783 D: serde::Deserializer<'de>,
16784 {
16785 struct GeneratedVisitor;
16786
16787 impl serde::de::Visitor<'_> for GeneratedVisitor {
16788 type Value = GeneratedField;
16789
16790 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16791 write!(formatter, "expected one of: {:?}", &FIELDS)
16792 }
16793
16794 #[allow(unused_variables)]
16795 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16796 where
16797 E: serde::de::Error,
16798 {
16799 match value {
16800 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
16801 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
16802 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
16803 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
16804 "condition" => Ok(GeneratedField::Condition),
16805 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
16806 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
16807 "tableOutputIndices" | "table_output_indices" => Ok(GeneratedField::TableOutputIndices),
16808 "memoTable" | "memo_table" => Ok(GeneratedField::MemoTable),
16809 "isNestedLoop" | "is_nested_loop" => Ok(GeneratedField::IsNestedLoop),
16810 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16811 }
16812 }
16813 }
16814 deserializer.deserialize_identifier(GeneratedVisitor)
16815 }
16816 }
16817 struct GeneratedVisitor;
16818 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16819 type Value = TemporalJoinNode;
16820
16821 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16822 formatter.write_str("struct stream_plan.TemporalJoinNode")
16823 }
16824
16825 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TemporalJoinNode, V::Error>
16826 where
16827 V: serde::de::MapAccess<'de>,
16828 {
16829 let mut join_type__ = None;
16830 let mut left_key__ = None;
16831 let mut right_key__ = None;
16832 let mut null_safe__ = None;
16833 let mut condition__ = None;
16834 let mut output_indices__ = None;
16835 let mut table_desc__ = None;
16836 let mut table_output_indices__ = None;
16837 let mut memo_table__ = None;
16838 let mut is_nested_loop__ = None;
16839 while let Some(k) = map_.next_key()? {
16840 match k {
16841 GeneratedField::JoinType => {
16842 if join_type__.is_some() {
16843 return Err(serde::de::Error::duplicate_field("joinType"));
16844 }
16845 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
16846 }
16847 GeneratedField::LeftKey => {
16848 if left_key__.is_some() {
16849 return Err(serde::de::Error::duplicate_field("leftKey"));
16850 }
16851 left_key__ =
16852 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16853 .into_iter().map(|x| x.0).collect())
16854 ;
16855 }
16856 GeneratedField::RightKey => {
16857 if right_key__.is_some() {
16858 return Err(serde::de::Error::duplicate_field("rightKey"));
16859 }
16860 right_key__ =
16861 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16862 .into_iter().map(|x| x.0).collect())
16863 ;
16864 }
16865 GeneratedField::NullSafe => {
16866 if null_safe__.is_some() {
16867 return Err(serde::de::Error::duplicate_field("nullSafe"));
16868 }
16869 null_safe__ = Some(map_.next_value()?);
16870 }
16871 GeneratedField::Condition => {
16872 if condition__.is_some() {
16873 return Err(serde::de::Error::duplicate_field("condition"));
16874 }
16875 condition__ = map_.next_value()?;
16876 }
16877 GeneratedField::OutputIndices => {
16878 if output_indices__.is_some() {
16879 return Err(serde::de::Error::duplicate_field("outputIndices"));
16880 }
16881 output_indices__ =
16882 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16883 .into_iter().map(|x| x.0).collect())
16884 ;
16885 }
16886 GeneratedField::TableDesc => {
16887 if table_desc__.is_some() {
16888 return Err(serde::de::Error::duplicate_field("tableDesc"));
16889 }
16890 table_desc__ = map_.next_value()?;
16891 }
16892 GeneratedField::TableOutputIndices => {
16893 if table_output_indices__.is_some() {
16894 return Err(serde::de::Error::duplicate_field("tableOutputIndices"));
16895 }
16896 table_output_indices__ =
16897 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16898 .into_iter().map(|x| x.0).collect())
16899 ;
16900 }
16901 GeneratedField::MemoTable => {
16902 if memo_table__.is_some() {
16903 return Err(serde::de::Error::duplicate_field("memoTable"));
16904 }
16905 memo_table__ = map_.next_value()?;
16906 }
16907 GeneratedField::IsNestedLoop => {
16908 if is_nested_loop__.is_some() {
16909 return Err(serde::de::Error::duplicate_field("isNestedLoop"));
16910 }
16911 is_nested_loop__ = Some(map_.next_value()?);
16912 }
16913 }
16914 }
16915 Ok(TemporalJoinNode {
16916 join_type: join_type__.unwrap_or_default(),
16917 left_key: left_key__.unwrap_or_default(),
16918 right_key: right_key__.unwrap_or_default(),
16919 null_safe: null_safe__.unwrap_or_default(),
16920 condition: condition__,
16921 output_indices: output_indices__.unwrap_or_default(),
16922 table_desc: table_desc__,
16923 table_output_indices: table_output_indices__.unwrap_or_default(),
16924 memo_table: memo_table__,
16925 is_nested_loop: is_nested_loop__.unwrap_or_default(),
16926 })
16927 }
16928 }
16929 deserializer.deserialize_struct("stream_plan.TemporalJoinNode", FIELDS, GeneratedVisitor)
16930 }
16931}
16932impl serde::Serialize for ThrottleMutation {
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.fragment_throttle.is_empty() {
16941 len += 1;
16942 }
16943 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation", len)?;
16944 if !self.fragment_throttle.is_empty() {
16945 struct_ser.serialize_field("fragmentThrottle", &self.fragment_throttle)?;
16946 }
16947 struct_ser.end()
16948 }
16949}
16950impl<'de> serde::Deserialize<'de> for ThrottleMutation {
16951 #[allow(deprecated)]
16952 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16953 where
16954 D: serde::Deserializer<'de>,
16955 {
16956 const FIELDS: &[&str] = &[
16957 "fragment_throttle",
16958 "fragmentThrottle",
16959 ];
16960
16961 #[allow(clippy::enum_variant_names)]
16962 enum GeneratedField {
16963 FragmentThrottle,
16964 }
16965 impl<'de> serde::Deserialize<'de> for GeneratedField {
16966 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16967 where
16968 D: serde::Deserializer<'de>,
16969 {
16970 struct GeneratedVisitor;
16971
16972 impl serde::de::Visitor<'_> for GeneratedVisitor {
16973 type Value = GeneratedField;
16974
16975 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16976 write!(formatter, "expected one of: {:?}", &FIELDS)
16977 }
16978
16979 #[allow(unused_variables)]
16980 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16981 where
16982 E: serde::de::Error,
16983 {
16984 match value {
16985 "fragmentThrottle" | "fragment_throttle" => Ok(GeneratedField::FragmentThrottle),
16986 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16987 }
16988 }
16989 }
16990 deserializer.deserialize_identifier(GeneratedVisitor)
16991 }
16992 }
16993 struct GeneratedVisitor;
16994 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16995 type Value = ThrottleMutation;
16996
16997 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16998 formatter.write_str("struct stream_plan.ThrottleMutation")
16999 }
17000
17001 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ThrottleMutation, V::Error>
17002 where
17003 V: serde::de::MapAccess<'de>,
17004 {
17005 let mut fragment_throttle__ = None;
17006 while let Some(k) = map_.next_key()? {
17007 match k {
17008 GeneratedField::FragmentThrottle => {
17009 if fragment_throttle__.is_some() {
17010 return Err(serde::de::Error::duplicate_field("fragmentThrottle"));
17011 }
17012 fragment_throttle__ = Some(
17013 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
17014 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
17015 );
17016 }
17017 }
17018 }
17019 Ok(ThrottleMutation {
17020 fragment_throttle: fragment_throttle__.unwrap_or_default(),
17021 })
17022 }
17023 }
17024 deserializer.deserialize_struct("stream_plan.ThrottleMutation", FIELDS, GeneratedVisitor)
17025 }
17026}
17027impl serde::Serialize for throttle_mutation::ThrottleConfig {
17028 #[allow(deprecated)]
17029 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17030 where
17031 S: serde::Serializer,
17032 {
17033 use serde::ser::SerializeStruct;
17034 let mut len = 0;
17035 if self.rate_limit.is_some() {
17036 len += 1;
17037 }
17038 if self.throttle_type != 0 {
17039 len += 1;
17040 }
17041 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation.ThrottleConfig", len)?;
17042 if let Some(v) = self.rate_limit.as_ref() {
17043 struct_ser.serialize_field("rateLimit", v)?;
17044 }
17045 if self.throttle_type != 0 {
17046 let v = super::common::ThrottleType::try_from(self.throttle_type)
17047 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.throttle_type)))?;
17048 struct_ser.serialize_field("throttleType", &v)?;
17049 }
17050 struct_ser.end()
17051 }
17052}
17053impl<'de> serde::Deserialize<'de> for throttle_mutation::ThrottleConfig {
17054 #[allow(deprecated)]
17055 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17056 where
17057 D: serde::Deserializer<'de>,
17058 {
17059 const FIELDS: &[&str] = &[
17060 "rate_limit",
17061 "rateLimit",
17062 "throttle_type",
17063 "throttleType",
17064 ];
17065
17066 #[allow(clippy::enum_variant_names)]
17067 enum GeneratedField {
17068 RateLimit,
17069 ThrottleType,
17070 }
17071 impl<'de> serde::Deserialize<'de> for GeneratedField {
17072 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17073 where
17074 D: serde::Deserializer<'de>,
17075 {
17076 struct GeneratedVisitor;
17077
17078 impl serde::de::Visitor<'_> for GeneratedVisitor {
17079 type Value = GeneratedField;
17080
17081 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17082 write!(formatter, "expected one of: {:?}", &FIELDS)
17083 }
17084
17085 #[allow(unused_variables)]
17086 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17087 where
17088 E: serde::de::Error,
17089 {
17090 match value {
17091 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
17092 "throttleType" | "throttle_type" => Ok(GeneratedField::ThrottleType),
17093 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17094 }
17095 }
17096 }
17097 deserializer.deserialize_identifier(GeneratedVisitor)
17098 }
17099 }
17100 struct GeneratedVisitor;
17101 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17102 type Value = throttle_mutation::ThrottleConfig;
17103
17104 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17105 formatter.write_str("struct stream_plan.ThrottleMutation.ThrottleConfig")
17106 }
17107
17108 fn visit_map<V>(self, mut map_: V) -> std::result::Result<throttle_mutation::ThrottleConfig, V::Error>
17109 where
17110 V: serde::de::MapAccess<'de>,
17111 {
17112 let mut rate_limit__ = None;
17113 let mut throttle_type__ = None;
17114 while let Some(k) = map_.next_key()? {
17115 match k {
17116 GeneratedField::RateLimit => {
17117 if rate_limit__.is_some() {
17118 return Err(serde::de::Error::duplicate_field("rateLimit"));
17119 }
17120 rate_limit__ =
17121 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17122 ;
17123 }
17124 GeneratedField::ThrottleType => {
17125 if throttle_type__.is_some() {
17126 return Err(serde::de::Error::duplicate_field("throttleType"));
17127 }
17128 throttle_type__ = Some(map_.next_value::<super::common::ThrottleType>()? as i32);
17129 }
17130 }
17131 }
17132 Ok(throttle_mutation::ThrottleConfig {
17133 rate_limit: rate_limit__,
17134 throttle_type: throttle_type__.unwrap_or_default(),
17135 })
17136 }
17137 }
17138 deserializer.deserialize_struct("stream_plan.ThrottleMutation.ThrottleConfig", FIELDS, GeneratedVisitor)
17139 }
17140}
17141impl serde::Serialize for TopNNode {
17142 #[allow(deprecated)]
17143 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17144 where
17145 S: serde::Serializer,
17146 {
17147 use serde::ser::SerializeStruct;
17148 let mut len = 0;
17149 if self.limit != 0 {
17150 len += 1;
17151 }
17152 if self.offset != 0 {
17153 len += 1;
17154 }
17155 if self.table.is_some() {
17156 len += 1;
17157 }
17158 if !self.order_by.is_empty() {
17159 len += 1;
17160 }
17161 if self.with_ties {
17162 len += 1;
17163 }
17164 let mut struct_ser = serializer.serialize_struct("stream_plan.TopNNode", len)?;
17165 if self.limit != 0 {
17166 #[allow(clippy::needless_borrow)]
17167 #[allow(clippy::needless_borrows_for_generic_args)]
17168 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
17169 }
17170 if self.offset != 0 {
17171 #[allow(clippy::needless_borrow)]
17172 #[allow(clippy::needless_borrows_for_generic_args)]
17173 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
17174 }
17175 if let Some(v) = self.table.as_ref() {
17176 struct_ser.serialize_field("table", v)?;
17177 }
17178 if !self.order_by.is_empty() {
17179 struct_ser.serialize_field("orderBy", &self.order_by)?;
17180 }
17181 if self.with_ties {
17182 struct_ser.serialize_field("withTies", &self.with_ties)?;
17183 }
17184 struct_ser.end()
17185 }
17186}
17187impl<'de> serde::Deserialize<'de> for TopNNode {
17188 #[allow(deprecated)]
17189 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17190 where
17191 D: serde::Deserializer<'de>,
17192 {
17193 const FIELDS: &[&str] = &[
17194 "limit",
17195 "offset",
17196 "table",
17197 "order_by",
17198 "orderBy",
17199 "with_ties",
17200 "withTies",
17201 ];
17202
17203 #[allow(clippy::enum_variant_names)]
17204 enum GeneratedField {
17205 Limit,
17206 Offset,
17207 Table,
17208 OrderBy,
17209 WithTies,
17210 }
17211 impl<'de> serde::Deserialize<'de> for GeneratedField {
17212 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17213 where
17214 D: serde::Deserializer<'de>,
17215 {
17216 struct GeneratedVisitor;
17217
17218 impl serde::de::Visitor<'_> for GeneratedVisitor {
17219 type Value = GeneratedField;
17220
17221 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17222 write!(formatter, "expected one of: {:?}", &FIELDS)
17223 }
17224
17225 #[allow(unused_variables)]
17226 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17227 where
17228 E: serde::de::Error,
17229 {
17230 match value {
17231 "limit" => Ok(GeneratedField::Limit),
17232 "offset" => Ok(GeneratedField::Offset),
17233 "table" => Ok(GeneratedField::Table),
17234 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
17235 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
17236 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17237 }
17238 }
17239 }
17240 deserializer.deserialize_identifier(GeneratedVisitor)
17241 }
17242 }
17243 struct GeneratedVisitor;
17244 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17245 type Value = TopNNode;
17246
17247 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17248 formatter.write_str("struct stream_plan.TopNNode")
17249 }
17250
17251 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
17252 where
17253 V: serde::de::MapAccess<'de>,
17254 {
17255 let mut limit__ = None;
17256 let mut offset__ = None;
17257 let mut table__ = None;
17258 let mut order_by__ = None;
17259 let mut with_ties__ = None;
17260 while let Some(k) = map_.next_key()? {
17261 match k {
17262 GeneratedField::Limit => {
17263 if limit__.is_some() {
17264 return Err(serde::de::Error::duplicate_field("limit"));
17265 }
17266 limit__ =
17267 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17268 ;
17269 }
17270 GeneratedField::Offset => {
17271 if offset__.is_some() {
17272 return Err(serde::de::Error::duplicate_field("offset"));
17273 }
17274 offset__ =
17275 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17276 ;
17277 }
17278 GeneratedField::Table => {
17279 if table__.is_some() {
17280 return Err(serde::de::Error::duplicate_field("table"));
17281 }
17282 table__ = map_.next_value()?;
17283 }
17284 GeneratedField::OrderBy => {
17285 if order_by__.is_some() {
17286 return Err(serde::de::Error::duplicate_field("orderBy"));
17287 }
17288 order_by__ = Some(map_.next_value()?);
17289 }
17290 GeneratedField::WithTies => {
17291 if with_ties__.is_some() {
17292 return Err(serde::de::Error::duplicate_field("withTies"));
17293 }
17294 with_ties__ = Some(map_.next_value()?);
17295 }
17296 }
17297 }
17298 Ok(TopNNode {
17299 limit: limit__.unwrap_or_default(),
17300 offset: offset__.unwrap_or_default(),
17301 table: table__,
17302 order_by: order_by__.unwrap_or_default(),
17303 with_ties: with_ties__.unwrap_or_default(),
17304 })
17305 }
17306 }
17307 deserializer.deserialize_struct("stream_plan.TopNNode", FIELDS, GeneratedVisitor)
17308 }
17309}
17310impl serde::Serialize for UnionNode {
17311 #[allow(deprecated)]
17312 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17313 where
17314 S: serde::Serializer,
17315 {
17316 use serde::ser::SerializeStruct;
17317 let len = 0;
17318 let struct_ser = serializer.serialize_struct("stream_plan.UnionNode", len)?;
17319 struct_ser.end()
17320 }
17321}
17322impl<'de> serde::Deserialize<'de> for UnionNode {
17323 #[allow(deprecated)]
17324 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17325 where
17326 D: serde::Deserializer<'de>,
17327 {
17328 const FIELDS: &[&str] = &[
17329 ];
17330
17331 #[allow(clippy::enum_variant_names)]
17332 enum GeneratedField {
17333 }
17334 impl<'de> serde::Deserialize<'de> for GeneratedField {
17335 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17336 where
17337 D: serde::Deserializer<'de>,
17338 {
17339 struct GeneratedVisitor;
17340
17341 impl serde::de::Visitor<'_> for GeneratedVisitor {
17342 type Value = GeneratedField;
17343
17344 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17345 write!(formatter, "expected one of: {:?}", &FIELDS)
17346 }
17347
17348 #[allow(unused_variables)]
17349 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17350 where
17351 E: serde::de::Error,
17352 {
17353 Err(serde::de::Error::unknown_field(value, FIELDS))
17354 }
17355 }
17356 deserializer.deserialize_identifier(GeneratedVisitor)
17357 }
17358 }
17359 struct GeneratedVisitor;
17360 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17361 type Value = UnionNode;
17362
17363 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17364 formatter.write_str("struct stream_plan.UnionNode")
17365 }
17366
17367 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
17368 where
17369 V: serde::de::MapAccess<'de>,
17370 {
17371 while map_.next_key::<GeneratedField>()?.is_some() {
17372 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
17373 }
17374 Ok(UnionNode {
17375 })
17376 }
17377 }
17378 deserializer.deserialize_struct("stream_plan.UnionNode", FIELDS, GeneratedVisitor)
17379 }
17380}
17381impl serde::Serialize for UpdateMutation {
17382 #[allow(deprecated)]
17383 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17384 where
17385 S: serde::Serializer,
17386 {
17387 use serde::ser::SerializeStruct;
17388 let mut len = 0;
17389 if !self.dispatcher_update.is_empty() {
17390 len += 1;
17391 }
17392 if !self.merge_update.is_empty() {
17393 len += 1;
17394 }
17395 if !self.actor_vnode_bitmap_update.is_empty() {
17396 len += 1;
17397 }
17398 if !self.dropped_actors.is_empty() {
17399 len += 1;
17400 }
17401 if !self.actor_splits.is_empty() {
17402 len += 1;
17403 }
17404 if !self.actor_new_dispatchers.is_empty() {
17405 len += 1;
17406 }
17407 if self.actor_cdc_table_snapshot_splits.is_some() {
17408 len += 1;
17409 }
17410 if !self.sink_schema_change.is_empty() {
17411 len += 1;
17412 }
17413 if !self.subscriptions_to_drop.is_empty() {
17414 len += 1;
17415 }
17416 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation", len)?;
17417 if !self.dispatcher_update.is_empty() {
17418 struct_ser.serialize_field("dispatcherUpdate", &self.dispatcher_update)?;
17419 }
17420 if !self.merge_update.is_empty() {
17421 struct_ser.serialize_field("mergeUpdate", &self.merge_update)?;
17422 }
17423 if !self.actor_vnode_bitmap_update.is_empty() {
17424 struct_ser.serialize_field("actorVnodeBitmapUpdate", &self.actor_vnode_bitmap_update)?;
17425 }
17426 if !self.dropped_actors.is_empty() {
17427 struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
17428 }
17429 if !self.actor_splits.is_empty() {
17430 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
17431 }
17432 if !self.actor_new_dispatchers.is_empty() {
17433 struct_ser.serialize_field("actorNewDispatchers", &self.actor_new_dispatchers)?;
17434 }
17435 if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
17436 struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
17437 }
17438 if !self.sink_schema_change.is_empty() {
17439 struct_ser.serialize_field("sinkSchemaChange", &self.sink_schema_change)?;
17440 }
17441 if !self.subscriptions_to_drop.is_empty() {
17442 struct_ser.serialize_field("subscriptionsToDrop", &self.subscriptions_to_drop)?;
17443 }
17444 struct_ser.end()
17445 }
17446}
17447impl<'de> serde::Deserialize<'de> for UpdateMutation {
17448 #[allow(deprecated)]
17449 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17450 where
17451 D: serde::Deserializer<'de>,
17452 {
17453 const FIELDS: &[&str] = &[
17454 "dispatcher_update",
17455 "dispatcherUpdate",
17456 "merge_update",
17457 "mergeUpdate",
17458 "actor_vnode_bitmap_update",
17459 "actorVnodeBitmapUpdate",
17460 "dropped_actors",
17461 "droppedActors",
17462 "actor_splits",
17463 "actorSplits",
17464 "actor_new_dispatchers",
17465 "actorNewDispatchers",
17466 "actor_cdc_table_snapshot_splits",
17467 "actorCdcTableSnapshotSplits",
17468 "sink_schema_change",
17469 "sinkSchemaChange",
17470 "subscriptions_to_drop",
17471 "subscriptionsToDrop",
17472 ];
17473
17474 #[allow(clippy::enum_variant_names)]
17475 enum GeneratedField {
17476 DispatcherUpdate,
17477 MergeUpdate,
17478 ActorVnodeBitmapUpdate,
17479 DroppedActors,
17480 ActorSplits,
17481 ActorNewDispatchers,
17482 ActorCdcTableSnapshotSplits,
17483 SinkSchemaChange,
17484 SubscriptionsToDrop,
17485 }
17486 impl<'de> serde::Deserialize<'de> for GeneratedField {
17487 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17488 where
17489 D: serde::Deserializer<'de>,
17490 {
17491 struct GeneratedVisitor;
17492
17493 impl serde::de::Visitor<'_> for GeneratedVisitor {
17494 type Value = GeneratedField;
17495
17496 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17497 write!(formatter, "expected one of: {:?}", &FIELDS)
17498 }
17499
17500 #[allow(unused_variables)]
17501 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17502 where
17503 E: serde::de::Error,
17504 {
17505 match value {
17506 "dispatcherUpdate" | "dispatcher_update" => Ok(GeneratedField::DispatcherUpdate),
17507 "mergeUpdate" | "merge_update" => Ok(GeneratedField::MergeUpdate),
17508 "actorVnodeBitmapUpdate" | "actor_vnode_bitmap_update" => Ok(GeneratedField::ActorVnodeBitmapUpdate),
17509 "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
17510 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
17511 "actorNewDispatchers" | "actor_new_dispatchers" => Ok(GeneratedField::ActorNewDispatchers),
17512 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
17513 "sinkSchemaChange" | "sink_schema_change" => Ok(GeneratedField::SinkSchemaChange),
17514 "subscriptionsToDrop" | "subscriptions_to_drop" => Ok(GeneratedField::SubscriptionsToDrop),
17515 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17516 }
17517 }
17518 }
17519 deserializer.deserialize_identifier(GeneratedVisitor)
17520 }
17521 }
17522 struct GeneratedVisitor;
17523 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17524 type Value = UpdateMutation;
17525
17526 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17527 formatter.write_str("struct stream_plan.UpdateMutation")
17528 }
17529
17530 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateMutation, V::Error>
17531 where
17532 V: serde::de::MapAccess<'de>,
17533 {
17534 let mut dispatcher_update__ = None;
17535 let mut merge_update__ = None;
17536 let mut actor_vnode_bitmap_update__ = None;
17537 let mut dropped_actors__ = None;
17538 let mut actor_splits__ = None;
17539 let mut actor_new_dispatchers__ = None;
17540 let mut actor_cdc_table_snapshot_splits__ = None;
17541 let mut sink_schema_change__ = None;
17542 let mut subscriptions_to_drop__ = None;
17543 while let Some(k) = map_.next_key()? {
17544 match k {
17545 GeneratedField::DispatcherUpdate => {
17546 if dispatcher_update__.is_some() {
17547 return Err(serde::de::Error::duplicate_field("dispatcherUpdate"));
17548 }
17549 dispatcher_update__ = Some(map_.next_value()?);
17550 }
17551 GeneratedField::MergeUpdate => {
17552 if merge_update__.is_some() {
17553 return Err(serde::de::Error::duplicate_field("mergeUpdate"));
17554 }
17555 merge_update__ = Some(map_.next_value()?);
17556 }
17557 GeneratedField::ActorVnodeBitmapUpdate => {
17558 if actor_vnode_bitmap_update__.is_some() {
17559 return Err(serde::de::Error::duplicate_field("actorVnodeBitmapUpdate"));
17560 }
17561 actor_vnode_bitmap_update__ = Some(
17562 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
17563 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
17564 );
17565 }
17566 GeneratedField::DroppedActors => {
17567 if dropped_actors__.is_some() {
17568 return Err(serde::de::Error::duplicate_field("droppedActors"));
17569 }
17570 dropped_actors__ =
17571 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17572 .into_iter().map(|x| x.0).collect())
17573 ;
17574 }
17575 GeneratedField::ActorSplits => {
17576 if actor_splits__.is_some() {
17577 return Err(serde::de::Error::duplicate_field("actorSplits"));
17578 }
17579 actor_splits__ = Some(
17580 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
17581 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
17582 );
17583 }
17584 GeneratedField::ActorNewDispatchers => {
17585 if actor_new_dispatchers__.is_some() {
17586 return Err(serde::de::Error::duplicate_field("actorNewDispatchers"));
17587 }
17588 actor_new_dispatchers__ = Some(
17589 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
17590 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
17591 );
17592 }
17593 GeneratedField::ActorCdcTableSnapshotSplits => {
17594 if actor_cdc_table_snapshot_splits__.is_some() {
17595 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
17596 }
17597 actor_cdc_table_snapshot_splits__ = map_.next_value()?;
17598 }
17599 GeneratedField::SinkSchemaChange => {
17600 if sink_schema_change__.is_some() {
17601 return Err(serde::de::Error::duplicate_field("sinkSchemaChange"));
17602 }
17603 sink_schema_change__ = Some(
17604 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
17605 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
17606 );
17607 }
17608 GeneratedField::SubscriptionsToDrop => {
17609 if subscriptions_to_drop__.is_some() {
17610 return Err(serde::de::Error::duplicate_field("subscriptionsToDrop"));
17611 }
17612 subscriptions_to_drop__ = Some(map_.next_value()?);
17613 }
17614 }
17615 }
17616 Ok(UpdateMutation {
17617 dispatcher_update: dispatcher_update__.unwrap_or_default(),
17618 merge_update: merge_update__.unwrap_or_default(),
17619 actor_vnode_bitmap_update: actor_vnode_bitmap_update__.unwrap_or_default(),
17620 dropped_actors: dropped_actors__.unwrap_or_default(),
17621 actor_splits: actor_splits__.unwrap_or_default(),
17622 actor_new_dispatchers: actor_new_dispatchers__.unwrap_or_default(),
17623 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
17624 sink_schema_change: sink_schema_change__.unwrap_or_default(),
17625 subscriptions_to_drop: subscriptions_to_drop__.unwrap_or_default(),
17626 })
17627 }
17628 }
17629 deserializer.deserialize_struct("stream_plan.UpdateMutation", FIELDS, GeneratedVisitor)
17630 }
17631}
17632impl serde::Serialize for update_mutation::DispatcherUpdate {
17633 #[allow(deprecated)]
17634 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17635 where
17636 S: serde::Serializer,
17637 {
17638 use serde::ser::SerializeStruct;
17639 let mut len = 0;
17640 if self.actor_id != 0 {
17641 len += 1;
17642 }
17643 if self.dispatcher_id != 0 {
17644 len += 1;
17645 }
17646 if self.hash_mapping.is_some() {
17647 len += 1;
17648 }
17649 if !self.added_downstream_actor_id.is_empty() {
17650 len += 1;
17651 }
17652 if !self.removed_downstream_actor_id.is_empty() {
17653 len += 1;
17654 }
17655 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", len)?;
17656 if self.actor_id != 0 {
17657 struct_ser.serialize_field("actorId", &self.actor_id)?;
17658 }
17659 if self.dispatcher_id != 0 {
17660 struct_ser.serialize_field("dispatcherId", &self.dispatcher_id)?;
17661 }
17662 if let Some(v) = self.hash_mapping.as_ref() {
17663 struct_ser.serialize_field("hashMapping", v)?;
17664 }
17665 if !self.added_downstream_actor_id.is_empty() {
17666 struct_ser.serialize_field("addedDownstreamActorId", &self.added_downstream_actor_id)?;
17667 }
17668 if !self.removed_downstream_actor_id.is_empty() {
17669 struct_ser.serialize_field("removedDownstreamActorId", &self.removed_downstream_actor_id)?;
17670 }
17671 struct_ser.end()
17672 }
17673}
17674impl<'de> serde::Deserialize<'de> for update_mutation::DispatcherUpdate {
17675 #[allow(deprecated)]
17676 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17677 where
17678 D: serde::Deserializer<'de>,
17679 {
17680 const FIELDS: &[&str] = &[
17681 "actor_id",
17682 "actorId",
17683 "dispatcher_id",
17684 "dispatcherId",
17685 "hash_mapping",
17686 "hashMapping",
17687 "added_downstream_actor_id",
17688 "addedDownstreamActorId",
17689 "removed_downstream_actor_id",
17690 "removedDownstreamActorId",
17691 ];
17692
17693 #[allow(clippy::enum_variant_names)]
17694 enum GeneratedField {
17695 ActorId,
17696 DispatcherId,
17697 HashMapping,
17698 AddedDownstreamActorId,
17699 RemovedDownstreamActorId,
17700 }
17701 impl<'de> serde::Deserialize<'de> for GeneratedField {
17702 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17703 where
17704 D: serde::Deserializer<'de>,
17705 {
17706 struct GeneratedVisitor;
17707
17708 impl serde::de::Visitor<'_> for GeneratedVisitor {
17709 type Value = GeneratedField;
17710
17711 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17712 write!(formatter, "expected one of: {:?}", &FIELDS)
17713 }
17714
17715 #[allow(unused_variables)]
17716 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17717 where
17718 E: serde::de::Error,
17719 {
17720 match value {
17721 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
17722 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
17723 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
17724 "addedDownstreamActorId" | "added_downstream_actor_id" => Ok(GeneratedField::AddedDownstreamActorId),
17725 "removedDownstreamActorId" | "removed_downstream_actor_id" => Ok(GeneratedField::RemovedDownstreamActorId),
17726 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17727 }
17728 }
17729 }
17730 deserializer.deserialize_identifier(GeneratedVisitor)
17731 }
17732 }
17733 struct GeneratedVisitor;
17734 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17735 type Value = update_mutation::DispatcherUpdate;
17736
17737 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17738 formatter.write_str("struct stream_plan.UpdateMutation.DispatcherUpdate")
17739 }
17740
17741 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::DispatcherUpdate, V::Error>
17742 where
17743 V: serde::de::MapAccess<'de>,
17744 {
17745 let mut actor_id__ = None;
17746 let mut dispatcher_id__ = None;
17747 let mut hash_mapping__ = None;
17748 let mut added_downstream_actor_id__ = None;
17749 let mut removed_downstream_actor_id__ = None;
17750 while let Some(k) = map_.next_key()? {
17751 match k {
17752 GeneratedField::ActorId => {
17753 if actor_id__.is_some() {
17754 return Err(serde::de::Error::duplicate_field("actorId"));
17755 }
17756 actor_id__ =
17757 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17758 ;
17759 }
17760 GeneratedField::DispatcherId => {
17761 if dispatcher_id__.is_some() {
17762 return Err(serde::de::Error::duplicate_field("dispatcherId"));
17763 }
17764 dispatcher_id__ =
17765 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17766 ;
17767 }
17768 GeneratedField::HashMapping => {
17769 if hash_mapping__.is_some() {
17770 return Err(serde::de::Error::duplicate_field("hashMapping"));
17771 }
17772 hash_mapping__ = map_.next_value()?;
17773 }
17774 GeneratedField::AddedDownstreamActorId => {
17775 if added_downstream_actor_id__.is_some() {
17776 return Err(serde::de::Error::duplicate_field("addedDownstreamActorId"));
17777 }
17778 added_downstream_actor_id__ =
17779 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17780 .into_iter().map(|x| x.0).collect())
17781 ;
17782 }
17783 GeneratedField::RemovedDownstreamActorId => {
17784 if removed_downstream_actor_id__.is_some() {
17785 return Err(serde::de::Error::duplicate_field("removedDownstreamActorId"));
17786 }
17787 removed_downstream_actor_id__ =
17788 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17789 .into_iter().map(|x| x.0).collect())
17790 ;
17791 }
17792 }
17793 }
17794 Ok(update_mutation::DispatcherUpdate {
17795 actor_id: actor_id__.unwrap_or_default(),
17796 dispatcher_id: dispatcher_id__.unwrap_or_default(),
17797 hash_mapping: hash_mapping__,
17798 added_downstream_actor_id: added_downstream_actor_id__.unwrap_or_default(),
17799 removed_downstream_actor_id: removed_downstream_actor_id__.unwrap_or_default(),
17800 })
17801 }
17802 }
17803 deserializer.deserialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", FIELDS, GeneratedVisitor)
17804 }
17805}
17806impl serde::Serialize for update_mutation::MergeUpdate {
17807 #[allow(deprecated)]
17808 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17809 where
17810 S: serde::Serializer,
17811 {
17812 use serde::ser::SerializeStruct;
17813 let mut len = 0;
17814 if self.actor_id != 0 {
17815 len += 1;
17816 }
17817 if self.upstream_fragment_id != 0 {
17818 len += 1;
17819 }
17820 if self.new_upstream_fragment_id.is_some() {
17821 len += 1;
17822 }
17823 if !self.added_upstream_actors.is_empty() {
17824 len += 1;
17825 }
17826 if !self.removed_upstream_actor_id.is_empty() {
17827 len += 1;
17828 }
17829 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.MergeUpdate", len)?;
17830 if self.actor_id != 0 {
17831 struct_ser.serialize_field("actorId", &self.actor_id)?;
17832 }
17833 if self.upstream_fragment_id != 0 {
17834 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
17835 }
17836 if let Some(v) = self.new_upstream_fragment_id.as_ref() {
17837 struct_ser.serialize_field("newUpstreamFragmentId", v)?;
17838 }
17839 if !self.added_upstream_actors.is_empty() {
17840 struct_ser.serialize_field("addedUpstreamActors", &self.added_upstream_actors)?;
17841 }
17842 if !self.removed_upstream_actor_id.is_empty() {
17843 struct_ser.serialize_field("removedUpstreamActorId", &self.removed_upstream_actor_id)?;
17844 }
17845 struct_ser.end()
17846 }
17847}
17848impl<'de> serde::Deserialize<'de> for update_mutation::MergeUpdate {
17849 #[allow(deprecated)]
17850 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17851 where
17852 D: serde::Deserializer<'de>,
17853 {
17854 const FIELDS: &[&str] = &[
17855 "actor_id",
17856 "actorId",
17857 "upstream_fragment_id",
17858 "upstreamFragmentId",
17859 "new_upstream_fragment_id",
17860 "newUpstreamFragmentId",
17861 "added_upstream_actors",
17862 "addedUpstreamActors",
17863 "removed_upstream_actor_id",
17864 "removedUpstreamActorId",
17865 ];
17866
17867 #[allow(clippy::enum_variant_names)]
17868 enum GeneratedField {
17869 ActorId,
17870 UpstreamFragmentId,
17871 NewUpstreamFragmentId,
17872 AddedUpstreamActors,
17873 RemovedUpstreamActorId,
17874 }
17875 impl<'de> serde::Deserialize<'de> for GeneratedField {
17876 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17877 where
17878 D: serde::Deserializer<'de>,
17879 {
17880 struct GeneratedVisitor;
17881
17882 impl serde::de::Visitor<'_> for GeneratedVisitor {
17883 type Value = GeneratedField;
17884
17885 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17886 write!(formatter, "expected one of: {:?}", &FIELDS)
17887 }
17888
17889 #[allow(unused_variables)]
17890 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17891 where
17892 E: serde::de::Error,
17893 {
17894 match value {
17895 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
17896 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
17897 "newUpstreamFragmentId" | "new_upstream_fragment_id" => Ok(GeneratedField::NewUpstreamFragmentId),
17898 "addedUpstreamActors" | "added_upstream_actors" => Ok(GeneratedField::AddedUpstreamActors),
17899 "removedUpstreamActorId" | "removed_upstream_actor_id" => Ok(GeneratedField::RemovedUpstreamActorId),
17900 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17901 }
17902 }
17903 }
17904 deserializer.deserialize_identifier(GeneratedVisitor)
17905 }
17906 }
17907 struct GeneratedVisitor;
17908 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17909 type Value = update_mutation::MergeUpdate;
17910
17911 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17912 formatter.write_str("struct stream_plan.UpdateMutation.MergeUpdate")
17913 }
17914
17915 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::MergeUpdate, V::Error>
17916 where
17917 V: serde::de::MapAccess<'de>,
17918 {
17919 let mut actor_id__ = None;
17920 let mut upstream_fragment_id__ = None;
17921 let mut new_upstream_fragment_id__ = None;
17922 let mut added_upstream_actors__ = None;
17923 let mut removed_upstream_actor_id__ = None;
17924 while let Some(k) = map_.next_key()? {
17925 match k {
17926 GeneratedField::ActorId => {
17927 if actor_id__.is_some() {
17928 return Err(serde::de::Error::duplicate_field("actorId"));
17929 }
17930 actor_id__ =
17931 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17932 ;
17933 }
17934 GeneratedField::UpstreamFragmentId => {
17935 if upstream_fragment_id__.is_some() {
17936 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
17937 }
17938 upstream_fragment_id__ =
17939 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17940 ;
17941 }
17942 GeneratedField::NewUpstreamFragmentId => {
17943 if new_upstream_fragment_id__.is_some() {
17944 return Err(serde::de::Error::duplicate_field("newUpstreamFragmentId"));
17945 }
17946 new_upstream_fragment_id__ =
17947 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17948 ;
17949 }
17950 GeneratedField::AddedUpstreamActors => {
17951 if added_upstream_actors__.is_some() {
17952 return Err(serde::de::Error::duplicate_field("addedUpstreamActors"));
17953 }
17954 added_upstream_actors__ = Some(map_.next_value()?);
17955 }
17956 GeneratedField::RemovedUpstreamActorId => {
17957 if removed_upstream_actor_id__.is_some() {
17958 return Err(serde::de::Error::duplicate_field("removedUpstreamActorId"));
17959 }
17960 removed_upstream_actor_id__ =
17961 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17962 .into_iter().map(|x| x.0).collect())
17963 ;
17964 }
17965 }
17966 }
17967 Ok(update_mutation::MergeUpdate {
17968 actor_id: actor_id__.unwrap_or_default(),
17969 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
17970 new_upstream_fragment_id: new_upstream_fragment_id__,
17971 added_upstream_actors: added_upstream_actors__.unwrap_or_default(),
17972 removed_upstream_actor_id: removed_upstream_actor_id__.unwrap_or_default(),
17973 })
17974 }
17975 }
17976 deserializer.deserialize_struct("stream_plan.UpdateMutation.MergeUpdate", FIELDS, GeneratedVisitor)
17977 }
17978}
17979impl serde::Serialize for UpstreamSinkInfo {
17980 #[allow(deprecated)]
17981 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17982 where
17983 S: serde::Serializer,
17984 {
17985 use serde::ser::SerializeStruct;
17986 let mut len = 0;
17987 if self.upstream_fragment_id != 0 {
17988 len += 1;
17989 }
17990 if !self.sink_output_schema.is_empty() {
17991 len += 1;
17992 }
17993 if !self.project_exprs.is_empty() {
17994 len += 1;
17995 }
17996 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkInfo", len)?;
17997 if self.upstream_fragment_id != 0 {
17998 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
17999 }
18000 if !self.sink_output_schema.is_empty() {
18001 struct_ser.serialize_field("sinkOutputSchema", &self.sink_output_schema)?;
18002 }
18003 if !self.project_exprs.is_empty() {
18004 struct_ser.serialize_field("projectExprs", &self.project_exprs)?;
18005 }
18006 struct_ser.end()
18007 }
18008}
18009impl<'de> serde::Deserialize<'de> for UpstreamSinkInfo {
18010 #[allow(deprecated)]
18011 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18012 where
18013 D: serde::Deserializer<'de>,
18014 {
18015 const FIELDS: &[&str] = &[
18016 "upstream_fragment_id",
18017 "upstreamFragmentId",
18018 "sink_output_schema",
18019 "sinkOutputSchema",
18020 "project_exprs",
18021 "projectExprs",
18022 ];
18023
18024 #[allow(clippy::enum_variant_names)]
18025 enum GeneratedField {
18026 UpstreamFragmentId,
18027 SinkOutputSchema,
18028 ProjectExprs,
18029 }
18030 impl<'de> serde::Deserialize<'de> for GeneratedField {
18031 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18032 where
18033 D: serde::Deserializer<'de>,
18034 {
18035 struct GeneratedVisitor;
18036
18037 impl serde::de::Visitor<'_> for GeneratedVisitor {
18038 type Value = GeneratedField;
18039
18040 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18041 write!(formatter, "expected one of: {:?}", &FIELDS)
18042 }
18043
18044 #[allow(unused_variables)]
18045 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18046 where
18047 E: serde::de::Error,
18048 {
18049 match value {
18050 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
18051 "sinkOutputSchema" | "sink_output_schema" => Ok(GeneratedField::SinkOutputSchema),
18052 "projectExprs" | "project_exprs" => Ok(GeneratedField::ProjectExprs),
18053 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18054 }
18055 }
18056 }
18057 deserializer.deserialize_identifier(GeneratedVisitor)
18058 }
18059 }
18060 struct GeneratedVisitor;
18061 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18062 type Value = UpstreamSinkInfo;
18063
18064 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18065 formatter.write_str("struct stream_plan.UpstreamSinkInfo")
18066 }
18067
18068 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkInfo, V::Error>
18069 where
18070 V: serde::de::MapAccess<'de>,
18071 {
18072 let mut upstream_fragment_id__ = None;
18073 let mut sink_output_schema__ = None;
18074 let mut project_exprs__ = None;
18075 while let Some(k) = map_.next_key()? {
18076 match k {
18077 GeneratedField::UpstreamFragmentId => {
18078 if upstream_fragment_id__.is_some() {
18079 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
18080 }
18081 upstream_fragment_id__ =
18082 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18083 ;
18084 }
18085 GeneratedField::SinkOutputSchema => {
18086 if sink_output_schema__.is_some() {
18087 return Err(serde::de::Error::duplicate_field("sinkOutputSchema"));
18088 }
18089 sink_output_schema__ = Some(map_.next_value()?);
18090 }
18091 GeneratedField::ProjectExprs => {
18092 if project_exprs__.is_some() {
18093 return Err(serde::de::Error::duplicate_field("projectExprs"));
18094 }
18095 project_exprs__ = Some(map_.next_value()?);
18096 }
18097 }
18098 }
18099 Ok(UpstreamSinkInfo {
18100 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
18101 sink_output_schema: sink_output_schema__.unwrap_or_default(),
18102 project_exprs: project_exprs__.unwrap_or_default(),
18103 })
18104 }
18105 }
18106 deserializer.deserialize_struct("stream_plan.UpstreamSinkInfo", FIELDS, GeneratedVisitor)
18107 }
18108}
18109impl serde::Serialize for UpstreamSinkUnionNode {
18110 #[allow(deprecated)]
18111 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18112 where
18113 S: serde::Serializer,
18114 {
18115 use serde::ser::SerializeStruct;
18116 let mut len = 0;
18117 if !self.init_upstreams.is_empty() {
18118 len += 1;
18119 }
18120 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkUnionNode", len)?;
18121 if !self.init_upstreams.is_empty() {
18122 struct_ser.serialize_field("initUpstreams", &self.init_upstreams)?;
18123 }
18124 struct_ser.end()
18125 }
18126}
18127impl<'de> serde::Deserialize<'de> for UpstreamSinkUnionNode {
18128 #[allow(deprecated)]
18129 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18130 where
18131 D: serde::Deserializer<'de>,
18132 {
18133 const FIELDS: &[&str] = &[
18134 "init_upstreams",
18135 "initUpstreams",
18136 ];
18137
18138 #[allow(clippy::enum_variant_names)]
18139 enum GeneratedField {
18140 InitUpstreams,
18141 }
18142 impl<'de> serde::Deserialize<'de> for GeneratedField {
18143 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18144 where
18145 D: serde::Deserializer<'de>,
18146 {
18147 struct GeneratedVisitor;
18148
18149 impl serde::de::Visitor<'_> for GeneratedVisitor {
18150 type Value = GeneratedField;
18151
18152 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18153 write!(formatter, "expected one of: {:?}", &FIELDS)
18154 }
18155
18156 #[allow(unused_variables)]
18157 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18158 where
18159 E: serde::de::Error,
18160 {
18161 match value {
18162 "initUpstreams" | "init_upstreams" => Ok(GeneratedField::InitUpstreams),
18163 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18164 }
18165 }
18166 }
18167 deserializer.deserialize_identifier(GeneratedVisitor)
18168 }
18169 }
18170 struct GeneratedVisitor;
18171 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18172 type Value = UpstreamSinkUnionNode;
18173
18174 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18175 formatter.write_str("struct stream_plan.UpstreamSinkUnionNode")
18176 }
18177
18178 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkUnionNode, V::Error>
18179 where
18180 V: serde::de::MapAccess<'de>,
18181 {
18182 let mut init_upstreams__ = None;
18183 while let Some(k) = map_.next_key()? {
18184 match k {
18185 GeneratedField::InitUpstreams => {
18186 if init_upstreams__.is_some() {
18187 return Err(serde::de::Error::duplicate_field("initUpstreams"));
18188 }
18189 init_upstreams__ = Some(map_.next_value()?);
18190 }
18191 }
18192 }
18193 Ok(UpstreamSinkUnionNode {
18194 init_upstreams: init_upstreams__.unwrap_or_default(),
18195 })
18196 }
18197 }
18198 deserializer.deserialize_struct("stream_plan.UpstreamSinkUnionNode", FIELDS, GeneratedVisitor)
18199 }
18200}
18201impl serde::Serialize for ValuesNode {
18202 #[allow(deprecated)]
18203 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18204 where
18205 S: serde::Serializer,
18206 {
18207 use serde::ser::SerializeStruct;
18208 let mut len = 0;
18209 if !self.tuples.is_empty() {
18210 len += 1;
18211 }
18212 if !self.fields.is_empty() {
18213 len += 1;
18214 }
18215 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode", len)?;
18216 if !self.tuples.is_empty() {
18217 struct_ser.serialize_field("tuples", &self.tuples)?;
18218 }
18219 if !self.fields.is_empty() {
18220 struct_ser.serialize_field("fields", &self.fields)?;
18221 }
18222 struct_ser.end()
18223 }
18224}
18225impl<'de> serde::Deserialize<'de> for ValuesNode {
18226 #[allow(deprecated)]
18227 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18228 where
18229 D: serde::Deserializer<'de>,
18230 {
18231 const FIELDS: &[&str] = &[
18232 "tuples",
18233 "fields",
18234 ];
18235
18236 #[allow(clippy::enum_variant_names)]
18237 enum GeneratedField {
18238 Tuples,
18239 Fields,
18240 }
18241 impl<'de> serde::Deserialize<'de> for GeneratedField {
18242 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18243 where
18244 D: serde::Deserializer<'de>,
18245 {
18246 struct GeneratedVisitor;
18247
18248 impl serde::de::Visitor<'_> for GeneratedVisitor {
18249 type Value = GeneratedField;
18250
18251 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18252 write!(formatter, "expected one of: {:?}", &FIELDS)
18253 }
18254
18255 #[allow(unused_variables)]
18256 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18257 where
18258 E: serde::de::Error,
18259 {
18260 match value {
18261 "tuples" => Ok(GeneratedField::Tuples),
18262 "fields" => Ok(GeneratedField::Fields),
18263 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18264 }
18265 }
18266 }
18267 deserializer.deserialize_identifier(GeneratedVisitor)
18268 }
18269 }
18270 struct GeneratedVisitor;
18271 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18272 type Value = ValuesNode;
18273
18274 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18275 formatter.write_str("struct stream_plan.ValuesNode")
18276 }
18277
18278 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
18279 where
18280 V: serde::de::MapAccess<'de>,
18281 {
18282 let mut tuples__ = None;
18283 let mut fields__ = None;
18284 while let Some(k) = map_.next_key()? {
18285 match k {
18286 GeneratedField::Tuples => {
18287 if tuples__.is_some() {
18288 return Err(serde::de::Error::duplicate_field("tuples"));
18289 }
18290 tuples__ = Some(map_.next_value()?);
18291 }
18292 GeneratedField::Fields => {
18293 if fields__.is_some() {
18294 return Err(serde::de::Error::duplicate_field("fields"));
18295 }
18296 fields__ = Some(map_.next_value()?);
18297 }
18298 }
18299 }
18300 Ok(ValuesNode {
18301 tuples: tuples__.unwrap_or_default(),
18302 fields: fields__.unwrap_or_default(),
18303 })
18304 }
18305 }
18306 deserializer.deserialize_struct("stream_plan.ValuesNode", FIELDS, GeneratedVisitor)
18307 }
18308}
18309impl serde::Serialize for values_node::ExprTuple {
18310 #[allow(deprecated)]
18311 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18312 where
18313 S: serde::Serializer,
18314 {
18315 use serde::ser::SerializeStruct;
18316 let mut len = 0;
18317 if !self.cells.is_empty() {
18318 len += 1;
18319 }
18320 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode.ExprTuple", len)?;
18321 if !self.cells.is_empty() {
18322 struct_ser.serialize_field("cells", &self.cells)?;
18323 }
18324 struct_ser.end()
18325 }
18326}
18327impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
18328 #[allow(deprecated)]
18329 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18330 where
18331 D: serde::Deserializer<'de>,
18332 {
18333 const FIELDS: &[&str] = &[
18334 "cells",
18335 ];
18336
18337 #[allow(clippy::enum_variant_names)]
18338 enum GeneratedField {
18339 Cells,
18340 }
18341 impl<'de> serde::Deserialize<'de> for GeneratedField {
18342 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18343 where
18344 D: serde::Deserializer<'de>,
18345 {
18346 struct GeneratedVisitor;
18347
18348 impl serde::de::Visitor<'_> for GeneratedVisitor {
18349 type Value = GeneratedField;
18350
18351 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18352 write!(formatter, "expected one of: {:?}", &FIELDS)
18353 }
18354
18355 #[allow(unused_variables)]
18356 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18357 where
18358 E: serde::de::Error,
18359 {
18360 match value {
18361 "cells" => Ok(GeneratedField::Cells),
18362 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18363 }
18364 }
18365 }
18366 deserializer.deserialize_identifier(GeneratedVisitor)
18367 }
18368 }
18369 struct GeneratedVisitor;
18370 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18371 type Value = values_node::ExprTuple;
18372
18373 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18374 formatter.write_str("struct stream_plan.ValuesNode.ExprTuple")
18375 }
18376
18377 fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
18378 where
18379 V: serde::de::MapAccess<'de>,
18380 {
18381 let mut cells__ = None;
18382 while let Some(k) = map_.next_key()? {
18383 match k {
18384 GeneratedField::Cells => {
18385 if cells__.is_some() {
18386 return Err(serde::de::Error::duplicate_field("cells"));
18387 }
18388 cells__ = Some(map_.next_value()?);
18389 }
18390 }
18391 }
18392 Ok(values_node::ExprTuple {
18393 cells: cells__.unwrap_or_default(),
18394 })
18395 }
18396 }
18397 deserializer.deserialize_struct("stream_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
18398 }
18399}
18400impl serde::Serialize for VectorIndexLookupJoinNode {
18401 #[allow(deprecated)]
18402 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18403 where
18404 S: serde::Serializer,
18405 {
18406 use serde::ser::SerializeStruct;
18407 let mut len = 0;
18408 if self.reader_desc.is_some() {
18409 len += 1;
18410 }
18411 if self.vector_column_idx != 0 {
18412 len += 1;
18413 }
18414 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexLookupJoinNode", len)?;
18415 if let Some(v) = self.reader_desc.as_ref() {
18416 struct_ser.serialize_field("readerDesc", v)?;
18417 }
18418 if self.vector_column_idx != 0 {
18419 struct_ser.serialize_field("vectorColumnIdx", &self.vector_column_idx)?;
18420 }
18421 struct_ser.end()
18422 }
18423}
18424impl<'de> serde::Deserialize<'de> for VectorIndexLookupJoinNode {
18425 #[allow(deprecated)]
18426 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18427 where
18428 D: serde::Deserializer<'de>,
18429 {
18430 const FIELDS: &[&str] = &[
18431 "reader_desc",
18432 "readerDesc",
18433 "vector_column_idx",
18434 "vectorColumnIdx",
18435 ];
18436
18437 #[allow(clippy::enum_variant_names)]
18438 enum GeneratedField {
18439 ReaderDesc,
18440 VectorColumnIdx,
18441 }
18442 impl<'de> serde::Deserialize<'de> for GeneratedField {
18443 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18444 where
18445 D: serde::Deserializer<'de>,
18446 {
18447 struct GeneratedVisitor;
18448
18449 impl serde::de::Visitor<'_> for GeneratedVisitor {
18450 type Value = GeneratedField;
18451
18452 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18453 write!(formatter, "expected one of: {:?}", &FIELDS)
18454 }
18455
18456 #[allow(unused_variables)]
18457 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18458 where
18459 E: serde::de::Error,
18460 {
18461 match value {
18462 "readerDesc" | "reader_desc" => Ok(GeneratedField::ReaderDesc),
18463 "vectorColumnIdx" | "vector_column_idx" => Ok(GeneratedField::VectorColumnIdx),
18464 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18465 }
18466 }
18467 }
18468 deserializer.deserialize_identifier(GeneratedVisitor)
18469 }
18470 }
18471 struct GeneratedVisitor;
18472 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18473 type Value = VectorIndexLookupJoinNode;
18474
18475 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18476 formatter.write_str("struct stream_plan.VectorIndexLookupJoinNode")
18477 }
18478
18479 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexLookupJoinNode, V::Error>
18480 where
18481 V: serde::de::MapAccess<'de>,
18482 {
18483 let mut reader_desc__ = None;
18484 let mut vector_column_idx__ = None;
18485 while let Some(k) = map_.next_key()? {
18486 match k {
18487 GeneratedField::ReaderDesc => {
18488 if reader_desc__.is_some() {
18489 return Err(serde::de::Error::duplicate_field("readerDesc"));
18490 }
18491 reader_desc__ = map_.next_value()?;
18492 }
18493 GeneratedField::VectorColumnIdx => {
18494 if vector_column_idx__.is_some() {
18495 return Err(serde::de::Error::duplicate_field("vectorColumnIdx"));
18496 }
18497 vector_column_idx__ =
18498 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18499 ;
18500 }
18501 }
18502 }
18503 Ok(VectorIndexLookupJoinNode {
18504 reader_desc: reader_desc__,
18505 vector_column_idx: vector_column_idx__.unwrap_or_default(),
18506 })
18507 }
18508 }
18509 deserializer.deserialize_struct("stream_plan.VectorIndexLookupJoinNode", FIELDS, GeneratedVisitor)
18510 }
18511}
18512impl serde::Serialize for VectorIndexWriteNode {
18513 #[allow(deprecated)]
18514 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18515 where
18516 S: serde::Serializer,
18517 {
18518 use serde::ser::SerializeStruct;
18519 let mut len = 0;
18520 if self.table.is_some() {
18521 len += 1;
18522 }
18523 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexWriteNode", len)?;
18524 if let Some(v) = self.table.as_ref() {
18525 struct_ser.serialize_field("table", v)?;
18526 }
18527 struct_ser.end()
18528 }
18529}
18530impl<'de> serde::Deserialize<'de> for VectorIndexWriteNode {
18531 #[allow(deprecated)]
18532 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18533 where
18534 D: serde::Deserializer<'de>,
18535 {
18536 const FIELDS: &[&str] = &[
18537 "table",
18538 ];
18539
18540 #[allow(clippy::enum_variant_names)]
18541 enum GeneratedField {
18542 Table,
18543 }
18544 impl<'de> serde::Deserialize<'de> for GeneratedField {
18545 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18546 where
18547 D: serde::Deserializer<'de>,
18548 {
18549 struct GeneratedVisitor;
18550
18551 impl serde::de::Visitor<'_> for GeneratedVisitor {
18552 type Value = GeneratedField;
18553
18554 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18555 write!(formatter, "expected one of: {:?}", &FIELDS)
18556 }
18557
18558 #[allow(unused_variables)]
18559 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18560 where
18561 E: serde::de::Error,
18562 {
18563 match value {
18564 "table" => Ok(GeneratedField::Table),
18565 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18566 }
18567 }
18568 }
18569 deserializer.deserialize_identifier(GeneratedVisitor)
18570 }
18571 }
18572 struct GeneratedVisitor;
18573 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18574 type Value = VectorIndexWriteNode;
18575
18576 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18577 formatter.write_str("struct stream_plan.VectorIndexWriteNode")
18578 }
18579
18580 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexWriteNode, V::Error>
18581 where
18582 V: serde::de::MapAccess<'de>,
18583 {
18584 let mut table__ = None;
18585 while let Some(k) = map_.next_key()? {
18586 match k {
18587 GeneratedField::Table => {
18588 if table__.is_some() {
18589 return Err(serde::de::Error::duplicate_field("table"));
18590 }
18591 table__ = map_.next_value()?;
18592 }
18593 }
18594 }
18595 Ok(VectorIndexWriteNode {
18596 table: table__,
18597 })
18598 }
18599 }
18600 deserializer.deserialize_struct("stream_plan.VectorIndexWriteNode", FIELDS, GeneratedVisitor)
18601 }
18602}
18603impl serde::Serialize for Watermark {
18604 #[allow(deprecated)]
18605 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18606 where
18607 S: serde::Serializer,
18608 {
18609 use serde::ser::SerializeStruct;
18610 let mut len = 0;
18611 if self.column.is_some() {
18612 len += 1;
18613 }
18614 if self.val.is_some() {
18615 len += 1;
18616 }
18617 let mut struct_ser = serializer.serialize_struct("stream_plan.Watermark", len)?;
18618 if let Some(v) = self.column.as_ref() {
18619 struct_ser.serialize_field("column", v)?;
18620 }
18621 if let Some(v) = self.val.as_ref() {
18622 struct_ser.serialize_field("val", v)?;
18623 }
18624 struct_ser.end()
18625 }
18626}
18627impl<'de> serde::Deserialize<'de> for Watermark {
18628 #[allow(deprecated)]
18629 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18630 where
18631 D: serde::Deserializer<'de>,
18632 {
18633 const FIELDS: &[&str] = &[
18634 "column",
18635 "val",
18636 ];
18637
18638 #[allow(clippy::enum_variant_names)]
18639 enum GeneratedField {
18640 Column,
18641 Val,
18642 }
18643 impl<'de> serde::Deserialize<'de> for GeneratedField {
18644 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18645 where
18646 D: serde::Deserializer<'de>,
18647 {
18648 struct GeneratedVisitor;
18649
18650 impl serde::de::Visitor<'_> for GeneratedVisitor {
18651 type Value = GeneratedField;
18652
18653 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18654 write!(formatter, "expected one of: {:?}", &FIELDS)
18655 }
18656
18657 #[allow(unused_variables)]
18658 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18659 where
18660 E: serde::de::Error,
18661 {
18662 match value {
18663 "column" => Ok(GeneratedField::Column),
18664 "val" => Ok(GeneratedField::Val),
18665 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18666 }
18667 }
18668 }
18669 deserializer.deserialize_identifier(GeneratedVisitor)
18670 }
18671 }
18672 struct GeneratedVisitor;
18673 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18674 type Value = Watermark;
18675
18676 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18677 formatter.write_str("struct stream_plan.Watermark")
18678 }
18679
18680 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Watermark, V::Error>
18681 where
18682 V: serde::de::MapAccess<'de>,
18683 {
18684 let mut column__ = None;
18685 let mut val__ = None;
18686 while let Some(k) = map_.next_key()? {
18687 match k {
18688 GeneratedField::Column => {
18689 if column__.is_some() {
18690 return Err(serde::de::Error::duplicate_field("column"));
18691 }
18692 column__ = map_.next_value()?;
18693 }
18694 GeneratedField::Val => {
18695 if val__.is_some() {
18696 return Err(serde::de::Error::duplicate_field("val"));
18697 }
18698 val__ = map_.next_value()?;
18699 }
18700 }
18701 }
18702 Ok(Watermark {
18703 column: column__,
18704 val: val__,
18705 })
18706 }
18707 }
18708 deserializer.deserialize_struct("stream_plan.Watermark", FIELDS, GeneratedVisitor)
18709 }
18710}
18711impl serde::Serialize for WatermarkFilterNode {
18712 #[allow(deprecated)]
18713 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18714 where
18715 S: serde::Serializer,
18716 {
18717 use serde::ser::SerializeStruct;
18718 let mut len = 0;
18719 if !self.watermark_descs.is_empty() {
18720 len += 1;
18721 }
18722 if !self.tables.is_empty() {
18723 len += 1;
18724 }
18725 let mut struct_ser = serializer.serialize_struct("stream_plan.WatermarkFilterNode", len)?;
18726 if !self.watermark_descs.is_empty() {
18727 struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
18728 }
18729 if !self.tables.is_empty() {
18730 struct_ser.serialize_field("tables", &self.tables)?;
18731 }
18732 struct_ser.end()
18733 }
18734}
18735impl<'de> serde::Deserialize<'de> for WatermarkFilterNode {
18736 #[allow(deprecated)]
18737 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18738 where
18739 D: serde::Deserializer<'de>,
18740 {
18741 const FIELDS: &[&str] = &[
18742 "watermark_descs",
18743 "watermarkDescs",
18744 "tables",
18745 ];
18746
18747 #[allow(clippy::enum_variant_names)]
18748 enum GeneratedField {
18749 WatermarkDescs,
18750 Tables,
18751 }
18752 impl<'de> serde::Deserialize<'de> for GeneratedField {
18753 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18754 where
18755 D: serde::Deserializer<'de>,
18756 {
18757 struct GeneratedVisitor;
18758
18759 impl serde::de::Visitor<'_> for GeneratedVisitor {
18760 type Value = GeneratedField;
18761
18762 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18763 write!(formatter, "expected one of: {:?}", &FIELDS)
18764 }
18765
18766 #[allow(unused_variables)]
18767 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18768 where
18769 E: serde::de::Error,
18770 {
18771 match value {
18772 "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
18773 "tables" => Ok(GeneratedField::Tables),
18774 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18775 }
18776 }
18777 }
18778 deserializer.deserialize_identifier(GeneratedVisitor)
18779 }
18780 }
18781 struct GeneratedVisitor;
18782 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18783 type Value = WatermarkFilterNode;
18784
18785 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18786 formatter.write_str("struct stream_plan.WatermarkFilterNode")
18787 }
18788
18789 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkFilterNode, V::Error>
18790 where
18791 V: serde::de::MapAccess<'de>,
18792 {
18793 let mut watermark_descs__ = None;
18794 let mut tables__ = None;
18795 while let Some(k) = map_.next_key()? {
18796 match k {
18797 GeneratedField::WatermarkDescs => {
18798 if watermark_descs__.is_some() {
18799 return Err(serde::de::Error::duplicate_field("watermarkDescs"));
18800 }
18801 watermark_descs__ = Some(map_.next_value()?);
18802 }
18803 GeneratedField::Tables => {
18804 if tables__.is_some() {
18805 return Err(serde::de::Error::duplicate_field("tables"));
18806 }
18807 tables__ = Some(map_.next_value()?);
18808 }
18809 }
18810 }
18811 Ok(WatermarkFilterNode {
18812 watermark_descs: watermark_descs__.unwrap_or_default(),
18813 tables: tables__.unwrap_or_default(),
18814 })
18815 }
18816 }
18817 deserializer.deserialize_struct("stream_plan.WatermarkFilterNode", FIELDS, GeneratedVisitor)
18818 }
18819}