1#![allow(clippy::useless_conversion)]
2#![allow(clippy::useless_borrows_in_formatting)]
3use crate::stream_plan::*;
4impl serde::Serialize for ActorMapping {
5 #[allow(deprecated)]
6 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7 where
8 S: serde::Serializer,
9 {
10 use serde::ser::SerializeStruct;
11 let mut len = 0;
12 if !self.original_indices.is_empty() {
13 len += 1;
14 }
15 if !self.data.is_empty() {
16 len += 1;
17 }
18 let mut struct_ser = serializer.serialize_struct("stream_plan.ActorMapping", len)?;
19 if !self.original_indices.is_empty() {
20 struct_ser.serialize_field("originalIndices", &self.original_indices)?;
21 }
22 if !self.data.is_empty() {
23 struct_ser.serialize_field("data", &self.data)?;
24 }
25 struct_ser.end()
26 }
27}
28impl<'de> serde::Deserialize<'de> for ActorMapping {
29 #[allow(deprecated)]
30 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
31 where
32 D: serde::Deserializer<'de>,
33 {
34 const FIELDS: &[&str] = &[
35 "original_indices",
36 "originalIndices",
37 "data",
38 ];
39
40 #[allow(clippy::enum_variant_names)]
41 enum GeneratedField {
42 OriginalIndices,
43 Data,
44 }
45 impl<'de> serde::Deserialize<'de> for GeneratedField {
46 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
47 where
48 D: serde::Deserializer<'de>,
49 {
50 struct GeneratedVisitor;
51
52 impl serde::de::Visitor<'_> for GeneratedVisitor {
53 type Value = GeneratedField;
54
55 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
56 write!(formatter, "expected one of: {:?}", &FIELDS)
57 }
58
59 #[allow(unused_variables)]
60 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
61 where
62 E: serde::de::Error,
63 {
64 match value {
65 "originalIndices" | "original_indices" => Ok(GeneratedField::OriginalIndices),
66 "data" => Ok(GeneratedField::Data),
67 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
68 }
69 }
70 }
71 deserializer.deserialize_identifier(GeneratedVisitor)
72 }
73 }
74 struct GeneratedVisitor;
75 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
76 type Value = ActorMapping;
77
78 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
79 formatter.write_str("struct stream_plan.ActorMapping")
80 }
81
82 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorMapping, V::Error>
83 where
84 V: serde::de::MapAccess<'de>,
85 {
86 let mut original_indices__ = None;
87 let mut data__ = None;
88 while let Some(k) = map_.next_key()? {
89 match k {
90 GeneratedField::OriginalIndices => {
91 if original_indices__.is_some() {
92 return Err(serde::de::Error::duplicate_field("originalIndices"));
93 }
94 original_indices__ =
95 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
96 .into_iter().map(|x| x.0).collect())
97 ;
98 }
99 GeneratedField::Data => {
100 if data__.is_some() {
101 return Err(serde::de::Error::duplicate_field("data"));
102 }
103 data__ =
104 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
105 .into_iter().map(|x| x.0).collect())
106 ;
107 }
108 }
109 }
110 Ok(ActorMapping {
111 original_indices: original_indices__.unwrap_or_default(),
112 data: data__.unwrap_or_default(),
113 })
114 }
115 }
116 deserializer.deserialize_struct("stream_plan.ActorMapping", FIELDS, GeneratedVisitor)
117 }
118}
119impl serde::Serialize for AddMutation {
120 #[allow(deprecated)]
121 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
122 where
123 S: serde::Serializer,
124 {
125 use serde::ser::SerializeStruct;
126 let mut len = 0;
127 if !self.actor_dispatchers.is_empty() {
128 len += 1;
129 }
130 if !self.added_actors.is_empty() {
131 len += 1;
132 }
133 if !self.actor_splits.is_empty() {
134 len += 1;
135 }
136 if self.pause {
137 len += 1;
138 }
139 if !self.subscriptions_to_add.is_empty() {
140 len += 1;
141 }
142 if !self.backfill_nodes_to_pause.is_empty() {
143 len += 1;
144 }
145 if self.actor_cdc_table_snapshot_splits.is_some() {
146 len += 1;
147 }
148 if !self.new_upstream_sinks.is_empty() {
149 len += 1;
150 }
151 if !self.dropped_actors.is_empty() {
152 len += 1;
153 }
154 if !self.sink_log_store_flush.is_empty() {
155 len += 1;
156 }
157 let mut struct_ser = serializer.serialize_struct("stream_plan.AddMutation", len)?;
158 if !self.actor_dispatchers.is_empty() {
159 struct_ser.serialize_field("actorDispatchers", &self.actor_dispatchers)?;
160 }
161 if !self.added_actors.is_empty() {
162 struct_ser.serialize_field("addedActors", &self.added_actors)?;
163 }
164 if !self.actor_splits.is_empty() {
165 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
166 }
167 if self.pause {
168 struct_ser.serialize_field("pause", &self.pause)?;
169 }
170 if !self.subscriptions_to_add.is_empty() {
171 struct_ser.serialize_field("subscriptionsToAdd", &self.subscriptions_to_add)?;
172 }
173 if !self.backfill_nodes_to_pause.is_empty() {
174 struct_ser.serialize_field("backfillNodesToPause", &self.backfill_nodes_to_pause)?;
175 }
176 if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
177 struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
178 }
179 if !self.new_upstream_sinks.is_empty() {
180 struct_ser.serialize_field("newUpstreamSinks", &self.new_upstream_sinks)?;
181 }
182 if !self.dropped_actors.is_empty() {
183 struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
184 }
185 if !self.sink_log_store_flush.is_empty() {
186 struct_ser.serialize_field("sinkLogStoreFlush", &self.sink_log_store_flush)?;
187 }
188 struct_ser.end()
189 }
190}
191impl<'de> serde::Deserialize<'de> for AddMutation {
192 #[allow(deprecated)]
193 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
194 where
195 D: serde::Deserializer<'de>,
196 {
197 const FIELDS: &[&str] = &[
198 "actor_dispatchers",
199 "actorDispatchers",
200 "added_actors",
201 "addedActors",
202 "actor_splits",
203 "actorSplits",
204 "pause",
205 "subscriptions_to_add",
206 "subscriptionsToAdd",
207 "backfill_nodes_to_pause",
208 "backfillNodesToPause",
209 "actor_cdc_table_snapshot_splits",
210 "actorCdcTableSnapshotSplits",
211 "new_upstream_sinks",
212 "newUpstreamSinks",
213 "dropped_actors",
214 "droppedActors",
215 "sink_log_store_flush",
216 "sinkLogStoreFlush",
217 ];
218
219 #[allow(clippy::enum_variant_names)]
220 enum GeneratedField {
221 ActorDispatchers,
222 AddedActors,
223 ActorSplits,
224 Pause,
225 SubscriptionsToAdd,
226 BackfillNodesToPause,
227 ActorCdcTableSnapshotSplits,
228 NewUpstreamSinks,
229 DroppedActors,
230 SinkLogStoreFlush,
231 }
232 impl<'de> serde::Deserialize<'de> for GeneratedField {
233 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
234 where
235 D: serde::Deserializer<'de>,
236 {
237 struct GeneratedVisitor;
238
239 impl serde::de::Visitor<'_> for GeneratedVisitor {
240 type Value = GeneratedField;
241
242 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
243 write!(formatter, "expected one of: {:?}", &FIELDS)
244 }
245
246 #[allow(unused_variables)]
247 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
248 where
249 E: serde::de::Error,
250 {
251 match value {
252 "actorDispatchers" | "actor_dispatchers" => Ok(GeneratedField::ActorDispatchers),
253 "addedActors" | "added_actors" => Ok(GeneratedField::AddedActors),
254 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
255 "pause" => Ok(GeneratedField::Pause),
256 "subscriptionsToAdd" | "subscriptions_to_add" => Ok(GeneratedField::SubscriptionsToAdd),
257 "backfillNodesToPause" | "backfill_nodes_to_pause" => Ok(GeneratedField::BackfillNodesToPause),
258 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
259 "newUpstreamSinks" | "new_upstream_sinks" => Ok(GeneratedField::NewUpstreamSinks),
260 "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
261 "sinkLogStoreFlush" | "sink_log_store_flush" => Ok(GeneratedField::SinkLogStoreFlush),
262 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
263 }
264 }
265 }
266 deserializer.deserialize_identifier(GeneratedVisitor)
267 }
268 }
269 struct GeneratedVisitor;
270 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
271 type Value = AddMutation;
272
273 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
274 formatter.write_str("struct stream_plan.AddMutation")
275 }
276
277 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddMutation, V::Error>
278 where
279 V: serde::de::MapAccess<'de>,
280 {
281 let mut actor_dispatchers__ = None;
282 let mut added_actors__ = None;
283 let mut actor_splits__ = None;
284 let mut pause__ = None;
285 let mut subscriptions_to_add__ = None;
286 let mut backfill_nodes_to_pause__ = None;
287 let mut actor_cdc_table_snapshot_splits__ = None;
288 let mut new_upstream_sinks__ = None;
289 let mut dropped_actors__ = None;
290 let mut sink_log_store_flush__ = None;
291 while let Some(k) = map_.next_key()? {
292 match k {
293 GeneratedField::ActorDispatchers => {
294 if actor_dispatchers__.is_some() {
295 return Err(serde::de::Error::duplicate_field("actorDispatchers"));
296 }
297 actor_dispatchers__ = Some(
298 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
299 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
300 );
301 }
302 GeneratedField::AddedActors => {
303 if added_actors__.is_some() {
304 return Err(serde::de::Error::duplicate_field("addedActors"));
305 }
306 added_actors__ =
307 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
308 .into_iter().map(|x| x.0).collect())
309 ;
310 }
311 GeneratedField::ActorSplits => {
312 if actor_splits__.is_some() {
313 return Err(serde::de::Error::duplicate_field("actorSplits"));
314 }
315 actor_splits__ = Some(
316 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
317 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
318 );
319 }
320 GeneratedField::Pause => {
321 if pause__.is_some() {
322 return Err(serde::de::Error::duplicate_field("pause"));
323 }
324 pause__ = Some(map_.next_value()?);
325 }
326 GeneratedField::SubscriptionsToAdd => {
327 if subscriptions_to_add__.is_some() {
328 return Err(serde::de::Error::duplicate_field("subscriptionsToAdd"));
329 }
330 subscriptions_to_add__ = Some(map_.next_value()?);
331 }
332 GeneratedField::BackfillNodesToPause => {
333 if backfill_nodes_to_pause__.is_some() {
334 return Err(serde::de::Error::duplicate_field("backfillNodesToPause"));
335 }
336 backfill_nodes_to_pause__ =
337 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
338 .into_iter().map(|x| x.0).collect())
339 ;
340 }
341 GeneratedField::ActorCdcTableSnapshotSplits => {
342 if actor_cdc_table_snapshot_splits__.is_some() {
343 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
344 }
345 actor_cdc_table_snapshot_splits__ = map_.next_value()?;
346 }
347 GeneratedField::NewUpstreamSinks => {
348 if new_upstream_sinks__.is_some() {
349 return Err(serde::de::Error::duplicate_field("newUpstreamSinks"));
350 }
351 new_upstream_sinks__ = Some(
352 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
353 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
354 );
355 }
356 GeneratedField::DroppedActors => {
357 if dropped_actors__.is_some() {
358 return Err(serde::de::Error::duplicate_field("droppedActors"));
359 }
360 dropped_actors__ =
361 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
362 .into_iter().map(|x| x.0).collect())
363 ;
364 }
365 GeneratedField::SinkLogStoreFlush => {
366 if sink_log_store_flush__.is_some() {
367 return Err(serde::de::Error::duplicate_field("sinkLogStoreFlush"));
368 }
369 sink_log_store_flush__ =
370 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
371 .into_iter().map(|x| x.0).collect())
372 ;
373 }
374 }
375 }
376 Ok(AddMutation {
377 actor_dispatchers: actor_dispatchers__.unwrap_or_default(),
378 added_actors: added_actors__.unwrap_or_default(),
379 actor_splits: actor_splits__.unwrap_or_default(),
380 pause: pause__.unwrap_or_default(),
381 subscriptions_to_add: subscriptions_to_add__.unwrap_or_default(),
382 backfill_nodes_to_pause: backfill_nodes_to_pause__.unwrap_or_default(),
383 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
384 new_upstream_sinks: new_upstream_sinks__.unwrap_or_default(),
385 dropped_actors: dropped_actors__.unwrap_or_default(),
386 sink_log_store_flush: sink_log_store_flush__.unwrap_or_default(),
387 })
388 }
389 }
390 deserializer.deserialize_struct("stream_plan.AddMutation", FIELDS, GeneratedVisitor)
391 }
392}
393impl serde::Serialize for add_mutation::NewUpstreamSink {
394 #[allow(deprecated)]
395 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
396 where
397 S: serde::Serializer,
398 {
399 use serde::ser::SerializeStruct;
400 let mut len = 0;
401 if self.info.is_some() {
402 len += 1;
403 }
404 if !self.upstream_actors.is_empty() {
405 len += 1;
406 }
407 let mut struct_ser = serializer.serialize_struct("stream_plan.AddMutation.NewUpstreamSink", len)?;
408 if let Some(v) = self.info.as_ref() {
409 struct_ser.serialize_field("info", v)?;
410 }
411 if !self.upstream_actors.is_empty() {
412 struct_ser.serialize_field("upstreamActors", &self.upstream_actors)?;
413 }
414 struct_ser.end()
415 }
416}
417impl<'de> serde::Deserialize<'de> for add_mutation::NewUpstreamSink {
418 #[allow(deprecated)]
419 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
420 where
421 D: serde::Deserializer<'de>,
422 {
423 const FIELDS: &[&str] = &[
424 "info",
425 "upstream_actors",
426 "upstreamActors",
427 ];
428
429 #[allow(clippy::enum_variant_names)]
430 enum GeneratedField {
431 Info,
432 UpstreamActors,
433 }
434 impl<'de> serde::Deserialize<'de> for GeneratedField {
435 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
436 where
437 D: serde::Deserializer<'de>,
438 {
439 struct GeneratedVisitor;
440
441 impl serde::de::Visitor<'_> for GeneratedVisitor {
442 type Value = GeneratedField;
443
444 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
445 write!(formatter, "expected one of: {:?}", &FIELDS)
446 }
447
448 #[allow(unused_variables)]
449 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
450 where
451 E: serde::de::Error,
452 {
453 match value {
454 "info" => Ok(GeneratedField::Info),
455 "upstreamActors" | "upstream_actors" => Ok(GeneratedField::UpstreamActors),
456 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
457 }
458 }
459 }
460 deserializer.deserialize_identifier(GeneratedVisitor)
461 }
462 }
463 struct GeneratedVisitor;
464 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
465 type Value = add_mutation::NewUpstreamSink;
466
467 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
468 formatter.write_str("struct stream_plan.AddMutation.NewUpstreamSink")
469 }
470
471 fn visit_map<V>(self, mut map_: V) -> std::result::Result<add_mutation::NewUpstreamSink, V::Error>
472 where
473 V: serde::de::MapAccess<'de>,
474 {
475 let mut info__ = None;
476 let mut upstream_actors__ = None;
477 while let Some(k) = map_.next_key()? {
478 match k {
479 GeneratedField::Info => {
480 if info__.is_some() {
481 return Err(serde::de::Error::duplicate_field("info"));
482 }
483 info__ = map_.next_value()?;
484 }
485 GeneratedField::UpstreamActors => {
486 if upstream_actors__.is_some() {
487 return Err(serde::de::Error::duplicate_field("upstreamActors"));
488 }
489 upstream_actors__ = Some(map_.next_value()?);
490 }
491 }
492 }
493 Ok(add_mutation::NewUpstreamSink {
494 info: info__,
495 upstream_actors: upstream_actors__.unwrap_or_default(),
496 })
497 }
498 }
499 deserializer.deserialize_struct("stream_plan.AddMutation.NewUpstreamSink", FIELDS, GeneratedVisitor)
500 }
501}
502impl serde::Serialize for AggCallState {
503 #[allow(deprecated)]
504 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
505 where
506 S: serde::Serializer,
507 {
508 use serde::ser::SerializeStruct;
509 let mut len = 0;
510 if self.inner.is_some() {
511 len += 1;
512 }
513 let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState", len)?;
514 if let Some(v) = self.inner.as_ref() {
515 match v {
516 agg_call_state::Inner::ValueState(v) => {
517 struct_ser.serialize_field("valueState", v)?;
518 }
519 agg_call_state::Inner::MaterializedInputState(v) => {
520 struct_ser.serialize_field("materializedInputState", v)?;
521 }
522 }
523 }
524 struct_ser.end()
525 }
526}
527impl<'de> serde::Deserialize<'de> for AggCallState {
528 #[allow(deprecated)]
529 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
530 where
531 D: serde::Deserializer<'de>,
532 {
533 const FIELDS: &[&str] = &[
534 "value_state",
535 "valueState",
536 "materialized_input_state",
537 "materializedInputState",
538 ];
539
540 #[allow(clippy::enum_variant_names)]
541 enum GeneratedField {
542 ValueState,
543 MaterializedInputState,
544 }
545 impl<'de> serde::Deserialize<'de> for GeneratedField {
546 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
547 where
548 D: serde::Deserializer<'de>,
549 {
550 struct GeneratedVisitor;
551
552 impl serde::de::Visitor<'_> for GeneratedVisitor {
553 type Value = GeneratedField;
554
555 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
556 write!(formatter, "expected one of: {:?}", &FIELDS)
557 }
558
559 #[allow(unused_variables)]
560 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
561 where
562 E: serde::de::Error,
563 {
564 match value {
565 "valueState" | "value_state" => Ok(GeneratedField::ValueState),
566 "materializedInputState" | "materialized_input_state" => Ok(GeneratedField::MaterializedInputState),
567 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
568 }
569 }
570 }
571 deserializer.deserialize_identifier(GeneratedVisitor)
572 }
573 }
574 struct GeneratedVisitor;
575 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
576 type Value = AggCallState;
577
578 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
579 formatter.write_str("struct stream_plan.AggCallState")
580 }
581
582 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AggCallState, V::Error>
583 where
584 V: serde::de::MapAccess<'de>,
585 {
586 let mut inner__ = None;
587 while let Some(k) = map_.next_key()? {
588 match k {
589 GeneratedField::ValueState => {
590 if inner__.is_some() {
591 return Err(serde::de::Error::duplicate_field("valueState"));
592 }
593 inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::ValueState)
594;
595 }
596 GeneratedField::MaterializedInputState => {
597 if inner__.is_some() {
598 return Err(serde::de::Error::duplicate_field("materializedInputState"));
599 }
600 inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::MaterializedInputState)
601;
602 }
603 }
604 }
605 Ok(AggCallState {
606 inner: inner__,
607 })
608 }
609 }
610 deserializer.deserialize_struct("stream_plan.AggCallState", FIELDS, GeneratedVisitor)
611 }
612}
613impl serde::Serialize for agg_call_state::MaterializedInputState {
614 #[allow(deprecated)]
615 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
616 where
617 S: serde::Serializer,
618 {
619 use serde::ser::SerializeStruct;
620 let mut len = 0;
621 if self.table.is_some() {
622 len += 1;
623 }
624 if !self.included_upstream_indices.is_empty() {
625 len += 1;
626 }
627 if !self.table_value_indices.is_empty() {
628 len += 1;
629 }
630 if !self.order_columns.is_empty() {
631 len += 1;
632 }
633 let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState.MaterializedInputState", len)?;
634 if let Some(v) = self.table.as_ref() {
635 struct_ser.serialize_field("table", v)?;
636 }
637 if !self.included_upstream_indices.is_empty() {
638 struct_ser.serialize_field("includedUpstreamIndices", &self.included_upstream_indices)?;
639 }
640 if !self.table_value_indices.is_empty() {
641 struct_ser.serialize_field("tableValueIndices", &self.table_value_indices)?;
642 }
643 if !self.order_columns.is_empty() {
644 struct_ser.serialize_field("orderColumns", &self.order_columns)?;
645 }
646 struct_ser.end()
647 }
648}
649impl<'de> serde::Deserialize<'de> for agg_call_state::MaterializedInputState {
650 #[allow(deprecated)]
651 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
652 where
653 D: serde::Deserializer<'de>,
654 {
655 const FIELDS: &[&str] = &[
656 "table",
657 "included_upstream_indices",
658 "includedUpstreamIndices",
659 "table_value_indices",
660 "tableValueIndices",
661 "order_columns",
662 "orderColumns",
663 ];
664
665 #[allow(clippy::enum_variant_names)]
666 enum GeneratedField {
667 Table,
668 IncludedUpstreamIndices,
669 TableValueIndices,
670 OrderColumns,
671 }
672 impl<'de> serde::Deserialize<'de> for GeneratedField {
673 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
674 where
675 D: serde::Deserializer<'de>,
676 {
677 struct GeneratedVisitor;
678
679 impl serde::de::Visitor<'_> for GeneratedVisitor {
680 type Value = GeneratedField;
681
682 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
683 write!(formatter, "expected one of: {:?}", &FIELDS)
684 }
685
686 #[allow(unused_variables)]
687 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
688 where
689 E: serde::de::Error,
690 {
691 match value {
692 "table" => Ok(GeneratedField::Table),
693 "includedUpstreamIndices" | "included_upstream_indices" => Ok(GeneratedField::IncludedUpstreamIndices),
694 "tableValueIndices" | "table_value_indices" => Ok(GeneratedField::TableValueIndices),
695 "orderColumns" | "order_columns" => Ok(GeneratedField::OrderColumns),
696 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
697 }
698 }
699 }
700 deserializer.deserialize_identifier(GeneratedVisitor)
701 }
702 }
703 struct GeneratedVisitor;
704 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
705 type Value = agg_call_state::MaterializedInputState;
706
707 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
708 formatter.write_str("struct stream_plan.AggCallState.MaterializedInputState")
709 }
710
711 fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::MaterializedInputState, V::Error>
712 where
713 V: serde::de::MapAccess<'de>,
714 {
715 let mut table__ = None;
716 let mut included_upstream_indices__ = None;
717 let mut table_value_indices__ = None;
718 let mut order_columns__ = None;
719 while let Some(k) = map_.next_key()? {
720 match k {
721 GeneratedField::Table => {
722 if table__.is_some() {
723 return Err(serde::de::Error::duplicate_field("table"));
724 }
725 table__ = map_.next_value()?;
726 }
727 GeneratedField::IncludedUpstreamIndices => {
728 if included_upstream_indices__.is_some() {
729 return Err(serde::de::Error::duplicate_field("includedUpstreamIndices"));
730 }
731 included_upstream_indices__ =
732 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
733 .into_iter().map(|x| x.0).collect())
734 ;
735 }
736 GeneratedField::TableValueIndices => {
737 if table_value_indices__.is_some() {
738 return Err(serde::de::Error::duplicate_field("tableValueIndices"));
739 }
740 table_value_indices__ =
741 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
742 .into_iter().map(|x| x.0).collect())
743 ;
744 }
745 GeneratedField::OrderColumns => {
746 if order_columns__.is_some() {
747 return Err(serde::de::Error::duplicate_field("orderColumns"));
748 }
749 order_columns__ = Some(map_.next_value()?);
750 }
751 }
752 }
753 Ok(agg_call_state::MaterializedInputState {
754 table: table__,
755 included_upstream_indices: included_upstream_indices__.unwrap_or_default(),
756 table_value_indices: table_value_indices__.unwrap_or_default(),
757 order_columns: order_columns__.unwrap_or_default(),
758 })
759 }
760 }
761 deserializer.deserialize_struct("stream_plan.AggCallState.MaterializedInputState", FIELDS, GeneratedVisitor)
762 }
763}
764impl serde::Serialize for agg_call_state::ValueState {
765 #[allow(deprecated)]
766 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
767 where
768 S: serde::Serializer,
769 {
770 use serde::ser::SerializeStruct;
771 let len = 0;
772 let struct_ser = serializer.serialize_struct("stream_plan.AggCallState.ValueState", len)?;
773 struct_ser.end()
774 }
775}
776impl<'de> serde::Deserialize<'de> for agg_call_state::ValueState {
777 #[allow(deprecated)]
778 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
779 where
780 D: serde::Deserializer<'de>,
781 {
782 const FIELDS: &[&str] = &[
783 ];
784
785 #[allow(clippy::enum_variant_names)]
786 enum GeneratedField {
787 }
788 impl<'de> serde::Deserialize<'de> for GeneratedField {
789 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
790 where
791 D: serde::Deserializer<'de>,
792 {
793 struct GeneratedVisitor;
794
795 impl serde::de::Visitor<'_> for GeneratedVisitor {
796 type Value = GeneratedField;
797
798 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
799 write!(formatter, "expected one of: {:?}", &FIELDS)
800 }
801
802 #[allow(unused_variables)]
803 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
804 where
805 E: serde::de::Error,
806 {
807 Err(serde::de::Error::unknown_field(value, FIELDS))
808 }
809 }
810 deserializer.deserialize_identifier(GeneratedVisitor)
811 }
812 }
813 struct GeneratedVisitor;
814 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
815 type Value = agg_call_state::ValueState;
816
817 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
818 formatter.write_str("struct stream_plan.AggCallState.ValueState")
819 }
820
821 fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::ValueState, V::Error>
822 where
823 V: serde::de::MapAccess<'de>,
824 {
825 while map_.next_key::<GeneratedField>()?.is_some() {
826 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
827 }
828 Ok(agg_call_state::ValueState {
829 })
830 }
831 }
832 deserializer.deserialize_struct("stream_plan.AggCallState.ValueState", FIELDS, GeneratedVisitor)
833 }
834}
835impl serde::Serialize for AggNodeVersion {
836 #[allow(deprecated)]
837 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
838 where
839 S: serde::Serializer,
840 {
841 let variant = match self {
842 Self::Unspecified => "AGG_NODE_VERSION_UNSPECIFIED",
843 Self::Issue12140 => "AGG_NODE_VERSION_ISSUE_12140",
844 Self::Issue13465 => "AGG_NODE_VERSION_ISSUE_13465",
845 };
846 serializer.serialize_str(variant)
847 }
848}
849impl<'de> serde::Deserialize<'de> for AggNodeVersion {
850 #[allow(deprecated)]
851 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
852 where
853 D: serde::Deserializer<'de>,
854 {
855 const FIELDS: &[&str] = &[
856 "AGG_NODE_VERSION_UNSPECIFIED",
857 "AGG_NODE_VERSION_ISSUE_12140",
858 "AGG_NODE_VERSION_ISSUE_13465",
859 ];
860
861 struct GeneratedVisitor;
862
863 impl serde::de::Visitor<'_> for GeneratedVisitor {
864 type Value = AggNodeVersion;
865
866 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
867 write!(formatter, "expected one of: {:?}", &FIELDS)
868 }
869
870 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
871 where
872 E: serde::de::Error,
873 {
874 i32::try_from(v)
875 .ok()
876 .and_then(|x| x.try_into().ok())
877 .ok_or_else(|| {
878 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
879 })
880 }
881
882 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
883 where
884 E: serde::de::Error,
885 {
886 i32::try_from(v)
887 .ok()
888 .and_then(|x| x.try_into().ok())
889 .ok_or_else(|| {
890 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
891 })
892 }
893
894 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
895 where
896 E: serde::de::Error,
897 {
898 match value {
899 "AGG_NODE_VERSION_UNSPECIFIED" => Ok(AggNodeVersion::Unspecified),
900 "AGG_NODE_VERSION_ISSUE_12140" => Ok(AggNodeVersion::Issue12140),
901 "AGG_NODE_VERSION_ISSUE_13465" => Ok(AggNodeVersion::Issue13465),
902 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
903 }
904 }
905 }
906 deserializer.deserialize_any(GeneratedVisitor)
907 }
908}
909impl serde::Serialize for ArrangeNode {
910 #[allow(deprecated)]
911 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
912 where
913 S: serde::Serializer,
914 {
915 use serde::ser::SerializeStruct;
916 let mut len = 0;
917 if self.table_info.is_some() {
918 len += 1;
919 }
920 if !self.distribution_key.is_empty() {
921 len += 1;
922 }
923 if self.table.is_some() {
924 len += 1;
925 }
926 let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangeNode", len)?;
927 if let Some(v) = self.table_info.as_ref() {
928 struct_ser.serialize_field("tableInfo", v)?;
929 }
930 if !self.distribution_key.is_empty() {
931 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
932 }
933 if let Some(v) = self.table.as_ref() {
934 struct_ser.serialize_field("table", v)?;
935 }
936 struct_ser.end()
937 }
938}
939impl<'de> serde::Deserialize<'de> for ArrangeNode {
940 #[allow(deprecated)]
941 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
942 where
943 D: serde::Deserializer<'de>,
944 {
945 const FIELDS: &[&str] = &[
946 "table_info",
947 "tableInfo",
948 "distribution_key",
949 "distributionKey",
950 "table",
951 ];
952
953 #[allow(clippy::enum_variant_names)]
954 enum GeneratedField {
955 TableInfo,
956 DistributionKey,
957 Table,
958 }
959 impl<'de> serde::Deserialize<'de> for GeneratedField {
960 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
961 where
962 D: serde::Deserializer<'de>,
963 {
964 struct GeneratedVisitor;
965
966 impl serde::de::Visitor<'_> for GeneratedVisitor {
967 type Value = GeneratedField;
968
969 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
970 write!(formatter, "expected one of: {:?}", &FIELDS)
971 }
972
973 #[allow(unused_variables)]
974 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
975 where
976 E: serde::de::Error,
977 {
978 match value {
979 "tableInfo" | "table_info" => Ok(GeneratedField::TableInfo),
980 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
981 "table" => Ok(GeneratedField::Table),
982 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
983 }
984 }
985 }
986 deserializer.deserialize_identifier(GeneratedVisitor)
987 }
988 }
989 struct GeneratedVisitor;
990 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
991 type Value = ArrangeNode;
992
993 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
994 formatter.write_str("struct stream_plan.ArrangeNode")
995 }
996
997 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangeNode, V::Error>
998 where
999 V: serde::de::MapAccess<'de>,
1000 {
1001 let mut table_info__ = None;
1002 let mut distribution_key__ = None;
1003 let mut table__ = None;
1004 while let Some(k) = map_.next_key()? {
1005 match k {
1006 GeneratedField::TableInfo => {
1007 if table_info__.is_some() {
1008 return Err(serde::de::Error::duplicate_field("tableInfo"));
1009 }
1010 table_info__ = map_.next_value()?;
1011 }
1012 GeneratedField::DistributionKey => {
1013 if distribution_key__.is_some() {
1014 return Err(serde::de::Error::duplicate_field("distributionKey"));
1015 }
1016 distribution_key__ =
1017 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1018 .into_iter().map(|x| x.0).collect())
1019 ;
1020 }
1021 GeneratedField::Table => {
1022 if table__.is_some() {
1023 return Err(serde::de::Error::duplicate_field("table"));
1024 }
1025 table__ = map_.next_value()?;
1026 }
1027 }
1028 }
1029 Ok(ArrangeNode {
1030 table_info: table_info__,
1031 distribution_key: distribution_key__.unwrap_or_default(),
1032 table: table__,
1033 })
1034 }
1035 }
1036 deserializer.deserialize_struct("stream_plan.ArrangeNode", FIELDS, GeneratedVisitor)
1037 }
1038}
1039impl serde::Serialize for ArrangementInfo {
1040 #[allow(deprecated)]
1041 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1042 where
1043 S: serde::Serializer,
1044 {
1045 use serde::ser::SerializeStruct;
1046 let mut len = 0;
1047 if !self.arrange_key_orders.is_empty() {
1048 len += 1;
1049 }
1050 if !self.column_descs.is_empty() {
1051 len += 1;
1052 }
1053 if self.table_desc.is_some() {
1054 len += 1;
1055 }
1056 if !self.output_col_idx.is_empty() {
1057 len += 1;
1058 }
1059 let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangementInfo", len)?;
1060 if !self.arrange_key_orders.is_empty() {
1061 struct_ser.serialize_field("arrangeKeyOrders", &self.arrange_key_orders)?;
1062 }
1063 if !self.column_descs.is_empty() {
1064 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
1065 }
1066 if let Some(v) = self.table_desc.as_ref() {
1067 struct_ser.serialize_field("tableDesc", v)?;
1068 }
1069 if !self.output_col_idx.is_empty() {
1070 struct_ser.serialize_field("outputColIdx", &self.output_col_idx)?;
1071 }
1072 struct_ser.end()
1073 }
1074}
1075impl<'de> serde::Deserialize<'de> for ArrangementInfo {
1076 #[allow(deprecated)]
1077 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1078 where
1079 D: serde::Deserializer<'de>,
1080 {
1081 const FIELDS: &[&str] = &[
1082 "arrange_key_orders",
1083 "arrangeKeyOrders",
1084 "column_descs",
1085 "columnDescs",
1086 "table_desc",
1087 "tableDesc",
1088 "output_col_idx",
1089 "outputColIdx",
1090 ];
1091
1092 #[allow(clippy::enum_variant_names)]
1093 enum GeneratedField {
1094 ArrangeKeyOrders,
1095 ColumnDescs,
1096 TableDesc,
1097 OutputColIdx,
1098 }
1099 impl<'de> serde::Deserialize<'de> for GeneratedField {
1100 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1101 where
1102 D: serde::Deserializer<'de>,
1103 {
1104 struct GeneratedVisitor;
1105
1106 impl serde::de::Visitor<'_> for GeneratedVisitor {
1107 type Value = GeneratedField;
1108
1109 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1110 write!(formatter, "expected one of: {:?}", &FIELDS)
1111 }
1112
1113 #[allow(unused_variables)]
1114 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1115 where
1116 E: serde::de::Error,
1117 {
1118 match value {
1119 "arrangeKeyOrders" | "arrange_key_orders" => Ok(GeneratedField::ArrangeKeyOrders),
1120 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
1121 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
1122 "outputColIdx" | "output_col_idx" => Ok(GeneratedField::OutputColIdx),
1123 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1124 }
1125 }
1126 }
1127 deserializer.deserialize_identifier(GeneratedVisitor)
1128 }
1129 }
1130 struct GeneratedVisitor;
1131 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1132 type Value = ArrangementInfo;
1133
1134 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1135 formatter.write_str("struct stream_plan.ArrangementInfo")
1136 }
1137
1138 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangementInfo, V::Error>
1139 where
1140 V: serde::de::MapAccess<'de>,
1141 {
1142 let mut arrange_key_orders__ = None;
1143 let mut column_descs__ = None;
1144 let mut table_desc__ = None;
1145 let mut output_col_idx__ = None;
1146 while let Some(k) = map_.next_key()? {
1147 match k {
1148 GeneratedField::ArrangeKeyOrders => {
1149 if arrange_key_orders__.is_some() {
1150 return Err(serde::de::Error::duplicate_field("arrangeKeyOrders"));
1151 }
1152 arrange_key_orders__ = Some(map_.next_value()?);
1153 }
1154 GeneratedField::ColumnDescs => {
1155 if column_descs__.is_some() {
1156 return Err(serde::de::Error::duplicate_field("columnDescs"));
1157 }
1158 column_descs__ = Some(map_.next_value()?);
1159 }
1160 GeneratedField::TableDesc => {
1161 if table_desc__.is_some() {
1162 return Err(serde::de::Error::duplicate_field("tableDesc"));
1163 }
1164 table_desc__ = map_.next_value()?;
1165 }
1166 GeneratedField::OutputColIdx => {
1167 if output_col_idx__.is_some() {
1168 return Err(serde::de::Error::duplicate_field("outputColIdx"));
1169 }
1170 output_col_idx__ =
1171 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1172 .into_iter().map(|x| x.0).collect())
1173 ;
1174 }
1175 }
1176 }
1177 Ok(ArrangementInfo {
1178 arrange_key_orders: arrange_key_orders__.unwrap_or_default(),
1179 column_descs: column_descs__.unwrap_or_default(),
1180 table_desc: table_desc__,
1181 output_col_idx: output_col_idx__.unwrap_or_default(),
1182 })
1183 }
1184 }
1185 deserializer.deserialize_struct("stream_plan.ArrangementInfo", FIELDS, GeneratedVisitor)
1186 }
1187}
1188impl serde::Serialize for AsOfJoinNode {
1189 #[allow(deprecated)]
1190 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1191 where
1192 S: serde::Serializer,
1193 {
1194 use serde::ser::SerializeStruct;
1195 let mut len = 0;
1196 if self.join_type != 0 {
1197 len += 1;
1198 }
1199 if !self.left_key.is_empty() {
1200 len += 1;
1201 }
1202 if !self.right_key.is_empty() {
1203 len += 1;
1204 }
1205 if self.left_table.is_some() {
1206 len += 1;
1207 }
1208 if self.right_table.is_some() {
1209 len += 1;
1210 }
1211 if !self.output_indices.is_empty() {
1212 len += 1;
1213 }
1214 if !self.left_deduped_input_pk_indices.is_empty() {
1215 len += 1;
1216 }
1217 if !self.right_deduped_input_pk_indices.is_empty() {
1218 len += 1;
1219 }
1220 if !self.null_safe.is_empty() {
1221 len += 1;
1222 }
1223 if self.asof_desc.is_some() {
1224 len += 1;
1225 }
1226 if self.join_encoding_type != 0 {
1227 len += 1;
1228 }
1229 if self.use_cache.is_some() {
1230 len += 1;
1231 }
1232 let mut struct_ser = serializer.serialize_struct("stream_plan.AsOfJoinNode", len)?;
1233 if self.join_type != 0 {
1234 let v = super::plan_common::AsOfJoinType::try_from(self.join_type)
1235 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
1236 struct_ser.serialize_field("joinType", &v)?;
1237 }
1238 if !self.left_key.is_empty() {
1239 struct_ser.serialize_field("leftKey", &self.left_key)?;
1240 }
1241 if !self.right_key.is_empty() {
1242 struct_ser.serialize_field("rightKey", &self.right_key)?;
1243 }
1244 if let Some(v) = self.left_table.as_ref() {
1245 struct_ser.serialize_field("leftTable", v)?;
1246 }
1247 if let Some(v) = self.right_table.as_ref() {
1248 struct_ser.serialize_field("rightTable", v)?;
1249 }
1250 if !self.output_indices.is_empty() {
1251 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
1252 }
1253 if !self.left_deduped_input_pk_indices.is_empty() {
1254 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
1255 }
1256 if !self.right_deduped_input_pk_indices.is_empty() {
1257 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
1258 }
1259 if !self.null_safe.is_empty() {
1260 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
1261 }
1262 if let Some(v) = self.asof_desc.as_ref() {
1263 struct_ser.serialize_field("asofDesc", v)?;
1264 }
1265 if self.join_encoding_type != 0 {
1266 let v = JoinEncodingType::try_from(self.join_encoding_type)
1267 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
1268 struct_ser.serialize_field("joinEncodingType", &v)?;
1269 }
1270 if let Some(v) = self.use_cache.as_ref() {
1271 struct_ser.serialize_field("useCache", v)?;
1272 }
1273 struct_ser.end()
1274 }
1275}
1276impl<'de> serde::Deserialize<'de> for AsOfJoinNode {
1277 #[allow(deprecated)]
1278 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1279 where
1280 D: serde::Deserializer<'de>,
1281 {
1282 const FIELDS: &[&str] = &[
1283 "join_type",
1284 "joinType",
1285 "left_key",
1286 "leftKey",
1287 "right_key",
1288 "rightKey",
1289 "left_table",
1290 "leftTable",
1291 "right_table",
1292 "rightTable",
1293 "output_indices",
1294 "outputIndices",
1295 "left_deduped_input_pk_indices",
1296 "leftDedupedInputPkIndices",
1297 "right_deduped_input_pk_indices",
1298 "rightDedupedInputPkIndices",
1299 "null_safe",
1300 "nullSafe",
1301 "asof_desc",
1302 "asofDesc",
1303 "join_encoding_type",
1304 "joinEncodingType",
1305 "use_cache",
1306 "useCache",
1307 ];
1308
1309 #[allow(clippy::enum_variant_names)]
1310 enum GeneratedField {
1311 JoinType,
1312 LeftKey,
1313 RightKey,
1314 LeftTable,
1315 RightTable,
1316 OutputIndices,
1317 LeftDedupedInputPkIndices,
1318 RightDedupedInputPkIndices,
1319 NullSafe,
1320 AsofDesc,
1321 JoinEncodingType,
1322 UseCache,
1323 }
1324 impl<'de> serde::Deserialize<'de> for GeneratedField {
1325 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1326 where
1327 D: serde::Deserializer<'de>,
1328 {
1329 struct GeneratedVisitor;
1330
1331 impl serde::de::Visitor<'_> for GeneratedVisitor {
1332 type Value = GeneratedField;
1333
1334 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1335 write!(formatter, "expected one of: {:?}", &FIELDS)
1336 }
1337
1338 #[allow(unused_variables)]
1339 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1340 where
1341 E: serde::de::Error,
1342 {
1343 match value {
1344 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
1345 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
1346 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
1347 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
1348 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
1349 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
1350 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
1351 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
1352 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
1353 "asofDesc" | "asof_desc" => Ok(GeneratedField::AsofDesc),
1354 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
1355 "useCache" | "use_cache" => Ok(GeneratedField::UseCache),
1356 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1357 }
1358 }
1359 }
1360 deserializer.deserialize_identifier(GeneratedVisitor)
1361 }
1362 }
1363 struct GeneratedVisitor;
1364 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1365 type Value = AsOfJoinNode;
1366
1367 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1368 formatter.write_str("struct stream_plan.AsOfJoinNode")
1369 }
1370
1371 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AsOfJoinNode, V::Error>
1372 where
1373 V: serde::de::MapAccess<'de>,
1374 {
1375 let mut join_type__ = None;
1376 let mut left_key__ = None;
1377 let mut right_key__ = None;
1378 let mut left_table__ = None;
1379 let mut right_table__ = None;
1380 let mut output_indices__ = None;
1381 let mut left_deduped_input_pk_indices__ = None;
1382 let mut right_deduped_input_pk_indices__ = None;
1383 let mut null_safe__ = None;
1384 let mut asof_desc__ = None;
1385 let mut join_encoding_type__ = None;
1386 let mut use_cache__ = None;
1387 while let Some(k) = map_.next_key()? {
1388 match k {
1389 GeneratedField::JoinType => {
1390 if join_type__.is_some() {
1391 return Err(serde::de::Error::duplicate_field("joinType"));
1392 }
1393 join_type__ = Some(map_.next_value::<super::plan_common::AsOfJoinType>()? as i32);
1394 }
1395 GeneratedField::LeftKey => {
1396 if left_key__.is_some() {
1397 return Err(serde::de::Error::duplicate_field("leftKey"));
1398 }
1399 left_key__ =
1400 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1401 .into_iter().map(|x| x.0).collect())
1402 ;
1403 }
1404 GeneratedField::RightKey => {
1405 if right_key__.is_some() {
1406 return Err(serde::de::Error::duplicate_field("rightKey"));
1407 }
1408 right_key__ =
1409 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1410 .into_iter().map(|x| x.0).collect())
1411 ;
1412 }
1413 GeneratedField::LeftTable => {
1414 if left_table__.is_some() {
1415 return Err(serde::de::Error::duplicate_field("leftTable"));
1416 }
1417 left_table__ = map_.next_value()?;
1418 }
1419 GeneratedField::RightTable => {
1420 if right_table__.is_some() {
1421 return Err(serde::de::Error::duplicate_field("rightTable"));
1422 }
1423 right_table__ = map_.next_value()?;
1424 }
1425 GeneratedField::OutputIndices => {
1426 if output_indices__.is_some() {
1427 return Err(serde::de::Error::duplicate_field("outputIndices"));
1428 }
1429 output_indices__ =
1430 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1431 .into_iter().map(|x| x.0).collect())
1432 ;
1433 }
1434 GeneratedField::LeftDedupedInputPkIndices => {
1435 if left_deduped_input_pk_indices__.is_some() {
1436 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
1437 }
1438 left_deduped_input_pk_indices__ =
1439 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1440 .into_iter().map(|x| x.0).collect())
1441 ;
1442 }
1443 GeneratedField::RightDedupedInputPkIndices => {
1444 if right_deduped_input_pk_indices__.is_some() {
1445 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
1446 }
1447 right_deduped_input_pk_indices__ =
1448 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1449 .into_iter().map(|x| x.0).collect())
1450 ;
1451 }
1452 GeneratedField::NullSafe => {
1453 if null_safe__.is_some() {
1454 return Err(serde::de::Error::duplicate_field("nullSafe"));
1455 }
1456 null_safe__ = Some(map_.next_value()?);
1457 }
1458 GeneratedField::AsofDesc => {
1459 if asof_desc__.is_some() {
1460 return Err(serde::de::Error::duplicate_field("asofDesc"));
1461 }
1462 asof_desc__ = map_.next_value()?;
1463 }
1464 GeneratedField::JoinEncodingType => {
1465 if join_encoding_type__.is_some() {
1466 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
1467 }
1468 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
1469 }
1470 GeneratedField::UseCache => {
1471 if use_cache__.is_some() {
1472 return Err(serde::de::Error::duplicate_field("useCache"));
1473 }
1474 use_cache__ = map_.next_value()?;
1475 }
1476 }
1477 }
1478 Ok(AsOfJoinNode {
1479 join_type: join_type__.unwrap_or_default(),
1480 left_key: left_key__.unwrap_or_default(),
1481 right_key: right_key__.unwrap_or_default(),
1482 left_table: left_table__,
1483 right_table: right_table__,
1484 output_indices: output_indices__.unwrap_or_default(),
1485 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
1486 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
1487 null_safe: null_safe__.unwrap_or_default(),
1488 asof_desc: asof_desc__,
1489 join_encoding_type: join_encoding_type__.unwrap_or_default(),
1490 use_cache: use_cache__,
1491 })
1492 }
1493 }
1494 deserializer.deserialize_struct("stream_plan.AsOfJoinNode", FIELDS, GeneratedVisitor)
1495 }
1496}
1497impl serde::Serialize for BackfillOrder {
1498 #[allow(deprecated)]
1499 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1500 where
1501 S: serde::Serializer,
1502 {
1503 use serde::ser::SerializeStruct;
1504 let mut len = 0;
1505 if !self.order.is_empty() {
1506 len += 1;
1507 }
1508 let mut struct_ser = serializer.serialize_struct("stream_plan.BackfillOrder", len)?;
1509 if !self.order.is_empty() {
1510 struct_ser.serialize_field("order", &self.order)?;
1511 }
1512 struct_ser.end()
1513 }
1514}
1515impl<'de> serde::Deserialize<'de> for BackfillOrder {
1516 #[allow(deprecated)]
1517 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1518 where
1519 D: serde::Deserializer<'de>,
1520 {
1521 const FIELDS: &[&str] = &[
1522 "order",
1523 ];
1524
1525 #[allow(clippy::enum_variant_names)]
1526 enum GeneratedField {
1527 Order,
1528 }
1529 impl<'de> serde::Deserialize<'de> for GeneratedField {
1530 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1531 where
1532 D: serde::Deserializer<'de>,
1533 {
1534 struct GeneratedVisitor;
1535
1536 impl serde::de::Visitor<'_> for GeneratedVisitor {
1537 type Value = GeneratedField;
1538
1539 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1540 write!(formatter, "expected one of: {:?}", &FIELDS)
1541 }
1542
1543 #[allow(unused_variables)]
1544 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1545 where
1546 E: serde::de::Error,
1547 {
1548 match value {
1549 "order" => Ok(GeneratedField::Order),
1550 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1551 }
1552 }
1553 }
1554 deserializer.deserialize_identifier(GeneratedVisitor)
1555 }
1556 }
1557 struct GeneratedVisitor;
1558 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1559 type Value = BackfillOrder;
1560
1561 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1562 formatter.write_str("struct stream_plan.BackfillOrder")
1563 }
1564
1565 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BackfillOrder, V::Error>
1566 where
1567 V: serde::de::MapAccess<'de>,
1568 {
1569 let mut order__ = None;
1570 while let Some(k) = map_.next_key()? {
1571 match k {
1572 GeneratedField::Order => {
1573 if order__.is_some() {
1574 return Err(serde::de::Error::duplicate_field("order"));
1575 }
1576 order__ = Some(
1577 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1578 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1579 );
1580 }
1581 }
1582 }
1583 Ok(BackfillOrder {
1584 order: order__.unwrap_or_default(),
1585 })
1586 }
1587 }
1588 deserializer.deserialize_struct("stream_plan.BackfillOrder", FIELDS, GeneratedVisitor)
1589 }
1590}
1591impl serde::Serialize for Barrier {
1592 #[allow(deprecated)]
1593 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1594 where
1595 S: serde::Serializer,
1596 {
1597 use serde::ser::SerializeStruct;
1598 let mut len = 0;
1599 if self.epoch.is_some() {
1600 len += 1;
1601 }
1602 if self.mutation.is_some() {
1603 len += 1;
1604 }
1605 if !self.tracing_context.is_empty() {
1606 len += 1;
1607 }
1608 if self.kind != 0 {
1609 len += 1;
1610 }
1611 let mut struct_ser = serializer.serialize_struct("stream_plan.Barrier", len)?;
1612 if let Some(v) = self.epoch.as_ref() {
1613 struct_ser.serialize_field("epoch", v)?;
1614 }
1615 if let Some(v) = self.mutation.as_ref() {
1616 struct_ser.serialize_field("mutation", v)?;
1617 }
1618 if !self.tracing_context.is_empty() {
1619 struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
1620 }
1621 if self.kind != 0 {
1622 let v = barrier::BarrierKind::try_from(self.kind)
1623 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
1624 struct_ser.serialize_field("kind", &v)?;
1625 }
1626 struct_ser.end()
1627 }
1628}
1629impl<'de> serde::Deserialize<'de> for Barrier {
1630 #[allow(deprecated)]
1631 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1632 where
1633 D: serde::Deserializer<'de>,
1634 {
1635 const FIELDS: &[&str] = &[
1636 "epoch",
1637 "mutation",
1638 "tracing_context",
1639 "tracingContext",
1640 "kind",
1641 ];
1642
1643 #[allow(clippy::enum_variant_names)]
1644 enum GeneratedField {
1645 Epoch,
1646 Mutation,
1647 TracingContext,
1648 Kind,
1649 }
1650 impl<'de> serde::Deserialize<'de> for GeneratedField {
1651 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1652 where
1653 D: serde::Deserializer<'de>,
1654 {
1655 struct GeneratedVisitor;
1656
1657 impl serde::de::Visitor<'_> for GeneratedVisitor {
1658 type Value = GeneratedField;
1659
1660 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1661 write!(formatter, "expected one of: {:?}", &FIELDS)
1662 }
1663
1664 #[allow(unused_variables)]
1665 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1666 where
1667 E: serde::de::Error,
1668 {
1669 match value {
1670 "epoch" => Ok(GeneratedField::Epoch),
1671 "mutation" => Ok(GeneratedField::Mutation),
1672 "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
1673 "kind" => Ok(GeneratedField::Kind),
1674 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1675 }
1676 }
1677 }
1678 deserializer.deserialize_identifier(GeneratedVisitor)
1679 }
1680 }
1681 struct GeneratedVisitor;
1682 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1683 type Value = Barrier;
1684
1685 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1686 formatter.write_str("struct stream_plan.Barrier")
1687 }
1688
1689 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Barrier, V::Error>
1690 where
1691 V: serde::de::MapAccess<'de>,
1692 {
1693 let mut epoch__ = None;
1694 let mut mutation__ = None;
1695 let mut tracing_context__ = None;
1696 let mut kind__ = None;
1697 while let Some(k) = map_.next_key()? {
1698 match k {
1699 GeneratedField::Epoch => {
1700 if epoch__.is_some() {
1701 return Err(serde::de::Error::duplicate_field("epoch"));
1702 }
1703 epoch__ = map_.next_value()?;
1704 }
1705 GeneratedField::Mutation => {
1706 if mutation__.is_some() {
1707 return Err(serde::de::Error::duplicate_field("mutation"));
1708 }
1709 mutation__ = map_.next_value()?;
1710 }
1711 GeneratedField::TracingContext => {
1712 if tracing_context__.is_some() {
1713 return Err(serde::de::Error::duplicate_field("tracingContext"));
1714 }
1715 tracing_context__ = Some(
1716 map_.next_value::<std::collections::HashMap<_, _>>()?
1717 );
1718 }
1719 GeneratedField::Kind => {
1720 if kind__.is_some() {
1721 return Err(serde::de::Error::duplicate_field("kind"));
1722 }
1723 kind__ = Some(map_.next_value::<barrier::BarrierKind>()? as i32);
1724 }
1725 }
1726 }
1727 Ok(Barrier {
1728 epoch: epoch__,
1729 mutation: mutation__,
1730 tracing_context: tracing_context__.unwrap_or_default(),
1731 kind: kind__.unwrap_or_default(),
1732 })
1733 }
1734 }
1735 deserializer.deserialize_struct("stream_plan.Barrier", FIELDS, GeneratedVisitor)
1736 }
1737}
1738impl serde::Serialize for barrier::BarrierKind {
1739 #[allow(deprecated)]
1740 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1741 where
1742 S: serde::Serializer,
1743 {
1744 let variant = match self {
1745 Self::Unspecified => "BARRIER_KIND_UNSPECIFIED",
1746 Self::Initial => "BARRIER_KIND_INITIAL",
1747 Self::Barrier => "BARRIER_KIND_BARRIER",
1748 Self::Checkpoint => "BARRIER_KIND_CHECKPOINT",
1749 };
1750 serializer.serialize_str(variant)
1751 }
1752}
1753impl<'de> serde::Deserialize<'de> for barrier::BarrierKind {
1754 #[allow(deprecated)]
1755 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1756 where
1757 D: serde::Deserializer<'de>,
1758 {
1759 const FIELDS: &[&str] = &[
1760 "BARRIER_KIND_UNSPECIFIED",
1761 "BARRIER_KIND_INITIAL",
1762 "BARRIER_KIND_BARRIER",
1763 "BARRIER_KIND_CHECKPOINT",
1764 ];
1765
1766 struct GeneratedVisitor;
1767
1768 impl serde::de::Visitor<'_> for GeneratedVisitor {
1769 type Value = barrier::BarrierKind;
1770
1771 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1772 write!(formatter, "expected one of: {:?}", &FIELDS)
1773 }
1774
1775 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1776 where
1777 E: serde::de::Error,
1778 {
1779 i32::try_from(v)
1780 .ok()
1781 .and_then(|x| x.try_into().ok())
1782 .ok_or_else(|| {
1783 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1784 })
1785 }
1786
1787 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1788 where
1789 E: serde::de::Error,
1790 {
1791 i32::try_from(v)
1792 .ok()
1793 .and_then(|x| x.try_into().ok())
1794 .ok_or_else(|| {
1795 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1796 })
1797 }
1798
1799 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1800 where
1801 E: serde::de::Error,
1802 {
1803 match value {
1804 "BARRIER_KIND_UNSPECIFIED" => Ok(barrier::BarrierKind::Unspecified),
1805 "BARRIER_KIND_INITIAL" => Ok(barrier::BarrierKind::Initial),
1806 "BARRIER_KIND_BARRIER" => Ok(barrier::BarrierKind::Barrier),
1807 "BARRIER_KIND_CHECKPOINT" => Ok(barrier::BarrierKind::Checkpoint),
1808 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1809 }
1810 }
1811 }
1812 deserializer.deserialize_any(GeneratedVisitor)
1813 }
1814}
1815impl serde::Serialize for BarrierMutation {
1816 #[allow(deprecated)]
1817 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1818 where
1819 S: serde::Serializer,
1820 {
1821 use serde::ser::SerializeStruct;
1822 let mut len = 0;
1823 if self.mutation.is_some() {
1824 len += 1;
1825 }
1826 let mut struct_ser = serializer.serialize_struct("stream_plan.BarrierMutation", len)?;
1827 if let Some(v) = self.mutation.as_ref() {
1828 match v {
1829 barrier_mutation::Mutation::Add(v) => {
1830 struct_ser.serialize_field("add", v)?;
1831 }
1832 barrier_mutation::Mutation::Stop(v) => {
1833 struct_ser.serialize_field("stop", v)?;
1834 }
1835 barrier_mutation::Mutation::Update(v) => {
1836 struct_ser.serialize_field("update", v)?;
1837 }
1838 barrier_mutation::Mutation::Splits(v) => {
1839 struct_ser.serialize_field("splits", v)?;
1840 }
1841 barrier_mutation::Mutation::Pause(v) => {
1842 struct_ser.serialize_field("pause", v)?;
1843 }
1844 barrier_mutation::Mutation::Resume(v) => {
1845 struct_ser.serialize_field("resume", v)?;
1846 }
1847 barrier_mutation::Mutation::Throttle(v) => {
1848 struct_ser.serialize_field("throttle", v)?;
1849 }
1850 barrier_mutation::Mutation::DropSubscriptions(v) => {
1851 struct_ser.serialize_field("dropSubscriptions", v)?;
1852 }
1853 barrier_mutation::Mutation::ConnectorPropsChange(v) => {
1854 struct_ser.serialize_field("connectorPropsChange", v)?;
1855 }
1856 barrier_mutation::Mutation::StartFragmentBackfill(v) => {
1857 struct_ser.serialize_field("startFragmentBackfill", v)?;
1858 }
1859 barrier_mutation::Mutation::RefreshStart(v) => {
1860 struct_ser.serialize_field("refreshStart", v)?;
1861 }
1862 barrier_mutation::Mutation::LoadFinish(v) => {
1863 struct_ser.serialize_field("loadFinish", v)?;
1864 }
1865 barrier_mutation::Mutation::ListFinish(v) => {
1866 struct_ser.serialize_field("listFinish", v)?;
1867 }
1868 barrier_mutation::Mutation::ResetSource(v) => {
1869 struct_ser.serialize_field("resetSource", v)?;
1870 }
1871 barrier_mutation::Mutation::InjectSourceOffsets(v) => {
1872 struct_ser.serialize_field("injectSourceOffsets", v)?;
1873 }
1874 }
1875 }
1876 struct_ser.end()
1877 }
1878}
1879impl<'de> serde::Deserialize<'de> for BarrierMutation {
1880 #[allow(deprecated)]
1881 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1882 where
1883 D: serde::Deserializer<'de>,
1884 {
1885 const FIELDS: &[&str] = &[
1886 "add",
1887 "stop",
1888 "update",
1889 "splits",
1890 "pause",
1891 "resume",
1892 "throttle",
1893 "drop_subscriptions",
1894 "dropSubscriptions",
1895 "connector_props_change",
1896 "connectorPropsChange",
1897 "start_fragment_backfill",
1898 "startFragmentBackfill",
1899 "refresh_start",
1900 "refreshStart",
1901 "load_finish",
1902 "loadFinish",
1903 "list_finish",
1904 "listFinish",
1905 "reset_source",
1906 "resetSource",
1907 "inject_source_offsets",
1908 "injectSourceOffsets",
1909 ];
1910
1911 #[allow(clippy::enum_variant_names)]
1912 enum GeneratedField {
1913 Add,
1914 Stop,
1915 Update,
1916 Splits,
1917 Pause,
1918 Resume,
1919 Throttle,
1920 DropSubscriptions,
1921 ConnectorPropsChange,
1922 StartFragmentBackfill,
1923 RefreshStart,
1924 LoadFinish,
1925 ListFinish,
1926 ResetSource,
1927 InjectSourceOffsets,
1928 }
1929 impl<'de> serde::Deserialize<'de> for GeneratedField {
1930 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1931 where
1932 D: serde::Deserializer<'de>,
1933 {
1934 struct GeneratedVisitor;
1935
1936 impl serde::de::Visitor<'_> for GeneratedVisitor {
1937 type Value = GeneratedField;
1938
1939 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1940 write!(formatter, "expected one of: {:?}", &FIELDS)
1941 }
1942
1943 #[allow(unused_variables)]
1944 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1945 where
1946 E: serde::de::Error,
1947 {
1948 match value {
1949 "add" => Ok(GeneratedField::Add),
1950 "stop" => Ok(GeneratedField::Stop),
1951 "update" => Ok(GeneratedField::Update),
1952 "splits" => Ok(GeneratedField::Splits),
1953 "pause" => Ok(GeneratedField::Pause),
1954 "resume" => Ok(GeneratedField::Resume),
1955 "throttle" => Ok(GeneratedField::Throttle),
1956 "dropSubscriptions" | "drop_subscriptions" => Ok(GeneratedField::DropSubscriptions),
1957 "connectorPropsChange" | "connector_props_change" => Ok(GeneratedField::ConnectorPropsChange),
1958 "startFragmentBackfill" | "start_fragment_backfill" => Ok(GeneratedField::StartFragmentBackfill),
1959 "refreshStart" | "refresh_start" => Ok(GeneratedField::RefreshStart),
1960 "loadFinish" | "load_finish" => Ok(GeneratedField::LoadFinish),
1961 "listFinish" | "list_finish" => Ok(GeneratedField::ListFinish),
1962 "resetSource" | "reset_source" => Ok(GeneratedField::ResetSource),
1963 "injectSourceOffsets" | "inject_source_offsets" => Ok(GeneratedField::InjectSourceOffsets),
1964 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1965 }
1966 }
1967 }
1968 deserializer.deserialize_identifier(GeneratedVisitor)
1969 }
1970 }
1971 struct GeneratedVisitor;
1972 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1973 type Value = BarrierMutation;
1974
1975 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1976 formatter.write_str("struct stream_plan.BarrierMutation")
1977 }
1978
1979 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierMutation, V::Error>
1980 where
1981 V: serde::de::MapAccess<'de>,
1982 {
1983 let mut mutation__ = None;
1984 while let Some(k) = map_.next_key()? {
1985 match k {
1986 GeneratedField::Add => {
1987 if mutation__.is_some() {
1988 return Err(serde::de::Error::duplicate_field("add"));
1989 }
1990 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Add)
1991;
1992 }
1993 GeneratedField::Stop => {
1994 if mutation__.is_some() {
1995 return Err(serde::de::Error::duplicate_field("stop"));
1996 }
1997 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Stop)
1998;
1999 }
2000 GeneratedField::Update => {
2001 if mutation__.is_some() {
2002 return Err(serde::de::Error::duplicate_field("update"));
2003 }
2004 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Update)
2005;
2006 }
2007 GeneratedField::Splits => {
2008 if mutation__.is_some() {
2009 return Err(serde::de::Error::duplicate_field("splits"));
2010 }
2011 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Splits)
2012;
2013 }
2014 GeneratedField::Pause => {
2015 if mutation__.is_some() {
2016 return Err(serde::de::Error::duplicate_field("pause"));
2017 }
2018 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Pause)
2019;
2020 }
2021 GeneratedField::Resume => {
2022 if mutation__.is_some() {
2023 return Err(serde::de::Error::duplicate_field("resume"));
2024 }
2025 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Resume)
2026;
2027 }
2028 GeneratedField::Throttle => {
2029 if mutation__.is_some() {
2030 return Err(serde::de::Error::duplicate_field("throttle"));
2031 }
2032 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Throttle)
2033;
2034 }
2035 GeneratedField::DropSubscriptions => {
2036 if mutation__.is_some() {
2037 return Err(serde::de::Error::duplicate_field("dropSubscriptions"));
2038 }
2039 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::DropSubscriptions)
2040;
2041 }
2042 GeneratedField::ConnectorPropsChange => {
2043 if mutation__.is_some() {
2044 return Err(serde::de::Error::duplicate_field("connectorPropsChange"));
2045 }
2046 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ConnectorPropsChange)
2047;
2048 }
2049 GeneratedField::StartFragmentBackfill => {
2050 if mutation__.is_some() {
2051 return Err(serde::de::Error::duplicate_field("startFragmentBackfill"));
2052 }
2053 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::StartFragmentBackfill)
2054;
2055 }
2056 GeneratedField::RefreshStart => {
2057 if mutation__.is_some() {
2058 return Err(serde::de::Error::duplicate_field("refreshStart"));
2059 }
2060 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::RefreshStart)
2061;
2062 }
2063 GeneratedField::LoadFinish => {
2064 if mutation__.is_some() {
2065 return Err(serde::de::Error::duplicate_field("loadFinish"));
2066 }
2067 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::LoadFinish)
2068;
2069 }
2070 GeneratedField::ListFinish => {
2071 if mutation__.is_some() {
2072 return Err(serde::de::Error::duplicate_field("listFinish"));
2073 }
2074 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ListFinish)
2075;
2076 }
2077 GeneratedField::ResetSource => {
2078 if mutation__.is_some() {
2079 return Err(serde::de::Error::duplicate_field("resetSource"));
2080 }
2081 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ResetSource)
2082;
2083 }
2084 GeneratedField::InjectSourceOffsets => {
2085 if mutation__.is_some() {
2086 return Err(serde::de::Error::duplicate_field("injectSourceOffsets"));
2087 }
2088 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::InjectSourceOffsets)
2089;
2090 }
2091 }
2092 }
2093 Ok(BarrierMutation {
2094 mutation: mutation__,
2095 })
2096 }
2097 }
2098 deserializer.deserialize_struct("stream_plan.BarrierMutation", FIELDS, GeneratedVisitor)
2099 }
2100}
2101impl serde::Serialize for BarrierRecvNode {
2102 #[allow(deprecated)]
2103 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2104 where
2105 S: serde::Serializer,
2106 {
2107 use serde::ser::SerializeStruct;
2108 let len = 0;
2109 let struct_ser = serializer.serialize_struct("stream_plan.BarrierRecvNode", len)?;
2110 struct_ser.end()
2111 }
2112}
2113impl<'de> serde::Deserialize<'de> for BarrierRecvNode {
2114 #[allow(deprecated)]
2115 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2116 where
2117 D: serde::Deserializer<'de>,
2118 {
2119 const FIELDS: &[&str] = &[
2120 ];
2121
2122 #[allow(clippy::enum_variant_names)]
2123 enum GeneratedField {
2124 }
2125 impl<'de> serde::Deserialize<'de> for GeneratedField {
2126 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2127 where
2128 D: serde::Deserializer<'de>,
2129 {
2130 struct GeneratedVisitor;
2131
2132 impl serde::de::Visitor<'_> for GeneratedVisitor {
2133 type Value = GeneratedField;
2134
2135 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2136 write!(formatter, "expected one of: {:?}", &FIELDS)
2137 }
2138
2139 #[allow(unused_variables)]
2140 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2141 where
2142 E: serde::de::Error,
2143 {
2144 Err(serde::de::Error::unknown_field(value, FIELDS))
2145 }
2146 }
2147 deserializer.deserialize_identifier(GeneratedVisitor)
2148 }
2149 }
2150 struct GeneratedVisitor;
2151 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2152 type Value = BarrierRecvNode;
2153
2154 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2155 formatter.write_str("struct stream_plan.BarrierRecvNode")
2156 }
2157
2158 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierRecvNode, V::Error>
2159 where
2160 V: serde::de::MapAccess<'de>,
2161 {
2162 while map_.next_key::<GeneratedField>()?.is_some() {
2163 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2164 }
2165 Ok(BarrierRecvNode {
2166 })
2167 }
2168 }
2169 deserializer.deserialize_struct("stream_plan.BarrierRecvNode", FIELDS, GeneratedVisitor)
2170 }
2171}
2172impl serde::Serialize for BatchPlanNode {
2173 #[allow(deprecated)]
2174 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2175 where
2176 S: serde::Serializer,
2177 {
2178 use serde::ser::SerializeStruct;
2179 let mut len = 0;
2180 if self.table_desc.is_some() {
2181 len += 1;
2182 }
2183 if !self.column_ids.is_empty() {
2184 len += 1;
2185 }
2186 let mut struct_ser = serializer.serialize_struct("stream_plan.BatchPlanNode", len)?;
2187 if let Some(v) = self.table_desc.as_ref() {
2188 struct_ser.serialize_field("tableDesc", v)?;
2189 }
2190 if !self.column_ids.is_empty() {
2191 struct_ser.serialize_field("columnIds", &self.column_ids)?;
2192 }
2193 struct_ser.end()
2194 }
2195}
2196impl<'de> serde::Deserialize<'de> for BatchPlanNode {
2197 #[allow(deprecated)]
2198 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2199 where
2200 D: serde::Deserializer<'de>,
2201 {
2202 const FIELDS: &[&str] = &[
2203 "table_desc",
2204 "tableDesc",
2205 "column_ids",
2206 "columnIds",
2207 ];
2208
2209 #[allow(clippy::enum_variant_names)]
2210 enum GeneratedField {
2211 TableDesc,
2212 ColumnIds,
2213 }
2214 impl<'de> serde::Deserialize<'de> for GeneratedField {
2215 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2216 where
2217 D: serde::Deserializer<'de>,
2218 {
2219 struct GeneratedVisitor;
2220
2221 impl serde::de::Visitor<'_> for GeneratedVisitor {
2222 type Value = GeneratedField;
2223
2224 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2225 write!(formatter, "expected one of: {:?}", &FIELDS)
2226 }
2227
2228 #[allow(unused_variables)]
2229 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2230 where
2231 E: serde::de::Error,
2232 {
2233 match value {
2234 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
2235 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
2236 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2237 }
2238 }
2239 }
2240 deserializer.deserialize_identifier(GeneratedVisitor)
2241 }
2242 }
2243 struct GeneratedVisitor;
2244 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2245 type Value = BatchPlanNode;
2246
2247 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2248 formatter.write_str("struct stream_plan.BatchPlanNode")
2249 }
2250
2251 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BatchPlanNode, V::Error>
2252 where
2253 V: serde::de::MapAccess<'de>,
2254 {
2255 let mut table_desc__ = None;
2256 let mut column_ids__ = None;
2257 while let Some(k) = map_.next_key()? {
2258 match k {
2259 GeneratedField::TableDesc => {
2260 if table_desc__.is_some() {
2261 return Err(serde::de::Error::duplicate_field("tableDesc"));
2262 }
2263 table_desc__ = map_.next_value()?;
2264 }
2265 GeneratedField::ColumnIds => {
2266 if column_ids__.is_some() {
2267 return Err(serde::de::Error::duplicate_field("columnIds"));
2268 }
2269 column_ids__ =
2270 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2271 .into_iter().map(|x| x.0).collect())
2272 ;
2273 }
2274 }
2275 }
2276 Ok(BatchPlanNode {
2277 table_desc: table_desc__,
2278 column_ids: column_ids__.unwrap_or_default(),
2279 })
2280 }
2281 }
2282 deserializer.deserialize_struct("stream_plan.BatchPlanNode", FIELDS, GeneratedVisitor)
2283 }
2284}
2285impl serde::Serialize for CdcFilterNode {
2286 #[allow(deprecated)]
2287 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2288 where
2289 S: serde::Serializer,
2290 {
2291 use serde::ser::SerializeStruct;
2292 let mut len = 0;
2293 if self.search_condition.is_some() {
2294 len += 1;
2295 }
2296 if self.upstream_source_id != 0 {
2297 len += 1;
2298 }
2299 let mut struct_ser = serializer.serialize_struct("stream_plan.CdcFilterNode", len)?;
2300 if let Some(v) = self.search_condition.as_ref() {
2301 struct_ser.serialize_field("searchCondition", v)?;
2302 }
2303 if self.upstream_source_id != 0 {
2304 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
2305 }
2306 struct_ser.end()
2307 }
2308}
2309impl<'de> serde::Deserialize<'de> for CdcFilterNode {
2310 #[allow(deprecated)]
2311 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2312 where
2313 D: serde::Deserializer<'de>,
2314 {
2315 const FIELDS: &[&str] = &[
2316 "search_condition",
2317 "searchCondition",
2318 "upstream_source_id",
2319 "upstreamSourceId",
2320 ];
2321
2322 #[allow(clippy::enum_variant_names)]
2323 enum GeneratedField {
2324 SearchCondition,
2325 UpstreamSourceId,
2326 }
2327 impl<'de> serde::Deserialize<'de> for GeneratedField {
2328 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2329 where
2330 D: serde::Deserializer<'de>,
2331 {
2332 struct GeneratedVisitor;
2333
2334 impl serde::de::Visitor<'_> for GeneratedVisitor {
2335 type Value = GeneratedField;
2336
2337 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2338 write!(formatter, "expected one of: {:?}", &FIELDS)
2339 }
2340
2341 #[allow(unused_variables)]
2342 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2343 where
2344 E: serde::de::Error,
2345 {
2346 match value {
2347 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
2348 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
2349 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2350 }
2351 }
2352 }
2353 deserializer.deserialize_identifier(GeneratedVisitor)
2354 }
2355 }
2356 struct GeneratedVisitor;
2357 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2358 type Value = CdcFilterNode;
2359
2360 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2361 formatter.write_str("struct stream_plan.CdcFilterNode")
2362 }
2363
2364 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcFilterNode, V::Error>
2365 where
2366 V: serde::de::MapAccess<'de>,
2367 {
2368 let mut search_condition__ = None;
2369 let mut upstream_source_id__ = None;
2370 while let Some(k) = map_.next_key()? {
2371 match k {
2372 GeneratedField::SearchCondition => {
2373 if search_condition__.is_some() {
2374 return Err(serde::de::Error::duplicate_field("searchCondition"));
2375 }
2376 search_condition__ = map_.next_value()?;
2377 }
2378 GeneratedField::UpstreamSourceId => {
2379 if upstream_source_id__.is_some() {
2380 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
2381 }
2382 upstream_source_id__ =
2383 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2384 ;
2385 }
2386 }
2387 }
2388 Ok(CdcFilterNode {
2389 search_condition: search_condition__,
2390 upstream_source_id: upstream_source_id__.unwrap_or_default(),
2391 })
2392 }
2393 }
2394 deserializer.deserialize_struct("stream_plan.CdcFilterNode", FIELDS, GeneratedVisitor)
2395 }
2396}
2397impl serde::Serialize for ChangeLogNode {
2398 #[allow(deprecated)]
2399 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2400 where
2401 S: serde::Serializer,
2402 {
2403 use serde::ser::SerializeStruct;
2404 let mut len = 0;
2405 if self.need_op {
2406 len += 1;
2407 }
2408 if !self.distribution_keys.is_empty() {
2409 len += 1;
2410 }
2411 if !self.stream_keys.is_empty() {
2412 len += 1;
2413 }
2414 if self.mode.is_some() {
2415 len += 1;
2416 }
2417 let mut struct_ser = serializer.serialize_struct("stream_plan.ChangeLogNode", len)?;
2418 if self.need_op {
2419 struct_ser.serialize_field("needOp", &self.need_op)?;
2420 }
2421 if !self.distribution_keys.is_empty() {
2422 struct_ser.serialize_field("distributionKeys", &self.distribution_keys)?;
2423 }
2424 if !self.stream_keys.is_empty() {
2425 struct_ser.serialize_field("streamKeys", &self.stream_keys)?;
2426 }
2427 if let Some(v) = self.mode.as_ref() {
2428 match v {
2429 change_log_node::Mode::Keyed(v) => {
2430 struct_ser.serialize_field("keyed", v)?;
2431 }
2432 }
2433 }
2434 struct_ser.end()
2435 }
2436}
2437impl<'de> serde::Deserialize<'de> for ChangeLogNode {
2438 #[allow(deprecated)]
2439 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2440 where
2441 D: serde::Deserializer<'de>,
2442 {
2443 const FIELDS: &[&str] = &[
2444 "need_op",
2445 "needOp",
2446 "distribution_keys",
2447 "distributionKeys",
2448 "stream_keys",
2449 "streamKeys",
2450 "keyed",
2451 ];
2452
2453 #[allow(clippy::enum_variant_names)]
2454 enum GeneratedField {
2455 NeedOp,
2456 DistributionKeys,
2457 StreamKeys,
2458 Keyed,
2459 }
2460 impl<'de> serde::Deserialize<'de> for GeneratedField {
2461 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2462 where
2463 D: serde::Deserializer<'de>,
2464 {
2465 struct GeneratedVisitor;
2466
2467 impl serde::de::Visitor<'_> for GeneratedVisitor {
2468 type Value = GeneratedField;
2469
2470 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2471 write!(formatter, "expected one of: {:?}", &FIELDS)
2472 }
2473
2474 #[allow(unused_variables)]
2475 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2476 where
2477 E: serde::de::Error,
2478 {
2479 match value {
2480 "needOp" | "need_op" => Ok(GeneratedField::NeedOp),
2481 "distributionKeys" | "distribution_keys" => Ok(GeneratedField::DistributionKeys),
2482 "streamKeys" | "stream_keys" => Ok(GeneratedField::StreamKeys),
2483 "keyed" => Ok(GeneratedField::Keyed),
2484 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2485 }
2486 }
2487 }
2488 deserializer.deserialize_identifier(GeneratedVisitor)
2489 }
2490 }
2491 struct GeneratedVisitor;
2492 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2493 type Value = ChangeLogNode;
2494
2495 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2496 formatter.write_str("struct stream_plan.ChangeLogNode")
2497 }
2498
2499 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ChangeLogNode, V::Error>
2500 where
2501 V: serde::de::MapAccess<'de>,
2502 {
2503 let mut need_op__ = None;
2504 let mut distribution_keys__ = None;
2505 let mut stream_keys__ = None;
2506 let mut mode__ = None;
2507 while let Some(k) = map_.next_key()? {
2508 match k {
2509 GeneratedField::NeedOp => {
2510 if need_op__.is_some() {
2511 return Err(serde::de::Error::duplicate_field("needOp"));
2512 }
2513 need_op__ = Some(map_.next_value()?);
2514 }
2515 GeneratedField::DistributionKeys => {
2516 if distribution_keys__.is_some() {
2517 return Err(serde::de::Error::duplicate_field("distributionKeys"));
2518 }
2519 distribution_keys__ =
2520 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2521 .into_iter().map(|x| x.0).collect())
2522 ;
2523 }
2524 GeneratedField::StreamKeys => {
2525 if stream_keys__.is_some() {
2526 return Err(serde::de::Error::duplicate_field("streamKeys"));
2527 }
2528 stream_keys__ =
2529 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2530 .into_iter().map(|x| x.0).collect())
2531 ;
2532 }
2533 GeneratedField::Keyed => {
2534 if mode__.is_some() {
2535 return Err(serde::de::Error::duplicate_field("keyed"));
2536 }
2537 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(change_log_node::Mode::Keyed)
2538;
2539 }
2540 }
2541 }
2542 Ok(ChangeLogNode {
2543 need_op: need_op__.unwrap_or_default(),
2544 distribution_keys: distribution_keys__.unwrap_or_default(),
2545 stream_keys: stream_keys__.unwrap_or_default(),
2546 mode: mode__,
2547 })
2548 }
2549 }
2550 deserializer.deserialize_struct("stream_plan.ChangeLogNode", FIELDS, GeneratedVisitor)
2551 }
2552}
2553impl serde::Serialize for change_log_node::Keyed {
2554 #[allow(deprecated)]
2555 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2556 where
2557 S: serde::Serializer,
2558 {
2559 use serde::ser::SerializeStruct;
2560 let len = 0;
2561 let struct_ser = serializer.serialize_struct("stream_plan.ChangeLogNode.Keyed", len)?;
2562 struct_ser.end()
2563 }
2564}
2565impl<'de> serde::Deserialize<'de> for change_log_node::Keyed {
2566 #[allow(deprecated)]
2567 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2568 where
2569 D: serde::Deserializer<'de>,
2570 {
2571 const FIELDS: &[&str] = &[
2572 ];
2573
2574 #[allow(clippy::enum_variant_names)]
2575 enum GeneratedField {
2576 }
2577 impl<'de> serde::Deserialize<'de> for GeneratedField {
2578 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2579 where
2580 D: serde::Deserializer<'de>,
2581 {
2582 struct GeneratedVisitor;
2583
2584 impl serde::de::Visitor<'_> for GeneratedVisitor {
2585 type Value = GeneratedField;
2586
2587 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2588 write!(formatter, "expected one of: {:?}", &FIELDS)
2589 }
2590
2591 #[allow(unused_variables)]
2592 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2593 where
2594 E: serde::de::Error,
2595 {
2596 Err(serde::de::Error::unknown_field(value, FIELDS))
2597 }
2598 }
2599 deserializer.deserialize_identifier(GeneratedVisitor)
2600 }
2601 }
2602 struct GeneratedVisitor;
2603 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2604 type Value = change_log_node::Keyed;
2605
2606 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2607 formatter.write_str("struct stream_plan.ChangeLogNode.Keyed")
2608 }
2609
2610 fn visit_map<V>(self, mut map_: V) -> std::result::Result<change_log_node::Keyed, V::Error>
2611 where
2612 V: serde::de::MapAccess<'de>,
2613 {
2614 while map_.next_key::<GeneratedField>()?.is_some() {
2615 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2616 }
2617 Ok(change_log_node::Keyed {
2618 })
2619 }
2620 }
2621 deserializer.deserialize_struct("stream_plan.ChangeLogNode.Keyed", FIELDS, GeneratedVisitor)
2622 }
2623}
2624impl serde::Serialize for Columns {
2625 #[allow(deprecated)]
2626 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2627 where
2628 S: serde::Serializer,
2629 {
2630 use serde::ser::SerializeStruct;
2631 let mut len = 0;
2632 if !self.columns.is_empty() {
2633 len += 1;
2634 }
2635 let mut struct_ser = serializer.serialize_struct("stream_plan.Columns", len)?;
2636 if !self.columns.is_empty() {
2637 struct_ser.serialize_field("columns", &self.columns)?;
2638 }
2639 struct_ser.end()
2640 }
2641}
2642impl<'de> serde::Deserialize<'de> for Columns {
2643 #[allow(deprecated)]
2644 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2645 where
2646 D: serde::Deserializer<'de>,
2647 {
2648 const FIELDS: &[&str] = &[
2649 "columns",
2650 ];
2651
2652 #[allow(clippy::enum_variant_names)]
2653 enum GeneratedField {
2654 Columns,
2655 }
2656 impl<'de> serde::Deserialize<'de> for GeneratedField {
2657 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2658 where
2659 D: serde::Deserializer<'de>,
2660 {
2661 struct GeneratedVisitor;
2662
2663 impl serde::de::Visitor<'_> for GeneratedVisitor {
2664 type Value = GeneratedField;
2665
2666 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2667 write!(formatter, "expected one of: {:?}", &FIELDS)
2668 }
2669
2670 #[allow(unused_variables)]
2671 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2672 where
2673 E: serde::de::Error,
2674 {
2675 match value {
2676 "columns" => Ok(GeneratedField::Columns),
2677 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2678 }
2679 }
2680 }
2681 deserializer.deserialize_identifier(GeneratedVisitor)
2682 }
2683 }
2684 struct GeneratedVisitor;
2685 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2686 type Value = Columns;
2687
2688 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2689 formatter.write_str("struct stream_plan.Columns")
2690 }
2691
2692 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Columns, V::Error>
2693 where
2694 V: serde::de::MapAccess<'de>,
2695 {
2696 let mut columns__ = None;
2697 while let Some(k) = map_.next_key()? {
2698 match k {
2699 GeneratedField::Columns => {
2700 if columns__.is_some() {
2701 return Err(serde::de::Error::duplicate_field("columns"));
2702 }
2703 columns__ = Some(map_.next_value()?);
2704 }
2705 }
2706 }
2707 Ok(Columns {
2708 columns: columns__.unwrap_or_default(),
2709 })
2710 }
2711 }
2712 deserializer.deserialize_struct("stream_plan.Columns", FIELDS, GeneratedVisitor)
2713 }
2714}
2715impl serde::Serialize for CompactionResolverNode {
2716 #[allow(deprecated)]
2717 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2718 where
2719 S: serde::Serializer,
2720 {
2721 use serde::ser::SerializeStruct;
2722 let mut len = 0;
2723 if self.sink_id != 0 {
2724 len += 1;
2725 }
2726 if !self.properties.is_empty() {
2727 len += 1;
2728 }
2729 if !self.secret_refs.is_empty() {
2730 len += 1;
2731 }
2732 if !self.pk_columns.is_empty() {
2733 len += 1;
2734 }
2735 let mut struct_ser = serializer.serialize_struct("stream_plan.CompactionResolverNode", len)?;
2736 if self.sink_id != 0 {
2737 struct_ser.serialize_field("sinkId", &self.sink_id)?;
2738 }
2739 if !self.properties.is_empty() {
2740 struct_ser.serialize_field("properties", &self.properties)?;
2741 }
2742 if !self.secret_refs.is_empty() {
2743 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
2744 }
2745 if !self.pk_columns.is_empty() {
2746 struct_ser.serialize_field("pkColumns", &self.pk_columns)?;
2747 }
2748 struct_ser.end()
2749 }
2750}
2751impl<'de> serde::Deserialize<'de> for CompactionResolverNode {
2752 #[allow(deprecated)]
2753 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2754 where
2755 D: serde::Deserializer<'de>,
2756 {
2757 const FIELDS: &[&str] = &[
2758 "sink_id",
2759 "sinkId",
2760 "properties",
2761 "secret_refs",
2762 "secretRefs",
2763 "pk_columns",
2764 "pkColumns",
2765 ];
2766
2767 #[allow(clippy::enum_variant_names)]
2768 enum GeneratedField {
2769 SinkId,
2770 Properties,
2771 SecretRefs,
2772 PkColumns,
2773 }
2774 impl<'de> serde::Deserialize<'de> for GeneratedField {
2775 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2776 where
2777 D: serde::Deserializer<'de>,
2778 {
2779 struct GeneratedVisitor;
2780
2781 impl serde::de::Visitor<'_> for GeneratedVisitor {
2782 type Value = GeneratedField;
2783
2784 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2785 write!(formatter, "expected one of: {:?}", &FIELDS)
2786 }
2787
2788 #[allow(unused_variables)]
2789 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2790 where
2791 E: serde::de::Error,
2792 {
2793 match value {
2794 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
2795 "properties" => Ok(GeneratedField::Properties),
2796 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
2797 "pkColumns" | "pk_columns" => Ok(GeneratedField::PkColumns),
2798 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2799 }
2800 }
2801 }
2802 deserializer.deserialize_identifier(GeneratedVisitor)
2803 }
2804 }
2805 struct GeneratedVisitor;
2806 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2807 type Value = CompactionResolverNode;
2808
2809 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2810 formatter.write_str("struct stream_plan.CompactionResolverNode")
2811 }
2812
2813 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionResolverNode, V::Error>
2814 where
2815 V: serde::de::MapAccess<'de>,
2816 {
2817 let mut sink_id__ = None;
2818 let mut properties__ = None;
2819 let mut secret_refs__ = None;
2820 let mut pk_columns__ = None;
2821 while let Some(k) = map_.next_key()? {
2822 match k {
2823 GeneratedField::SinkId => {
2824 if sink_id__.is_some() {
2825 return Err(serde::de::Error::duplicate_field("sinkId"));
2826 }
2827 sink_id__ =
2828 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2829 ;
2830 }
2831 GeneratedField::Properties => {
2832 if properties__.is_some() {
2833 return Err(serde::de::Error::duplicate_field("properties"));
2834 }
2835 properties__ = Some(
2836 map_.next_value::<std::collections::BTreeMap<_, _>>()?
2837 );
2838 }
2839 GeneratedField::SecretRefs => {
2840 if secret_refs__.is_some() {
2841 return Err(serde::de::Error::duplicate_field("secretRefs"));
2842 }
2843 secret_refs__ = Some(
2844 map_.next_value::<std::collections::BTreeMap<_, _>>()?
2845 );
2846 }
2847 GeneratedField::PkColumns => {
2848 if pk_columns__.is_some() {
2849 return Err(serde::de::Error::duplicate_field("pkColumns"));
2850 }
2851 pk_columns__ = Some(map_.next_value()?);
2852 }
2853 }
2854 }
2855 Ok(CompactionResolverNode {
2856 sink_id: sink_id__.unwrap_or_default(),
2857 properties: properties__.unwrap_or_default(),
2858 secret_refs: secret_refs__.unwrap_or_default(),
2859 pk_columns: pk_columns__.unwrap_or_default(),
2860 })
2861 }
2862 }
2863 deserializer.deserialize_struct("stream_plan.CompactionResolverNode", FIELDS, GeneratedVisitor)
2864 }
2865}
2866impl serde::Serialize for compaction_resolver_node::PkColumn {
2867 #[allow(deprecated)]
2868 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2869 where
2870 S: serde::Serializer,
2871 {
2872 use serde::ser::SerializeStruct;
2873 let mut len = 0;
2874 if self.data_file_index != 0 {
2875 len += 1;
2876 }
2877 if self.column_desc.is_some() {
2878 len += 1;
2879 }
2880 let mut struct_ser = serializer.serialize_struct("stream_plan.CompactionResolverNode.PkColumn", len)?;
2881 if self.data_file_index != 0 {
2882 struct_ser.serialize_field("dataFileIndex", &self.data_file_index)?;
2883 }
2884 if let Some(v) = self.column_desc.as_ref() {
2885 struct_ser.serialize_field("columnDesc", v)?;
2886 }
2887 struct_ser.end()
2888 }
2889}
2890impl<'de> serde::Deserialize<'de> for compaction_resolver_node::PkColumn {
2891 #[allow(deprecated)]
2892 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2893 where
2894 D: serde::Deserializer<'de>,
2895 {
2896 const FIELDS: &[&str] = &[
2897 "data_file_index",
2898 "dataFileIndex",
2899 "column_desc",
2900 "columnDesc",
2901 ];
2902
2903 #[allow(clippy::enum_variant_names)]
2904 enum GeneratedField {
2905 DataFileIndex,
2906 ColumnDesc,
2907 }
2908 impl<'de> serde::Deserialize<'de> for GeneratedField {
2909 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2910 where
2911 D: serde::Deserializer<'de>,
2912 {
2913 struct GeneratedVisitor;
2914
2915 impl serde::de::Visitor<'_> for GeneratedVisitor {
2916 type Value = GeneratedField;
2917
2918 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2919 write!(formatter, "expected one of: {:?}", &FIELDS)
2920 }
2921
2922 #[allow(unused_variables)]
2923 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2924 where
2925 E: serde::de::Error,
2926 {
2927 match value {
2928 "dataFileIndex" | "data_file_index" => Ok(GeneratedField::DataFileIndex),
2929 "columnDesc" | "column_desc" => Ok(GeneratedField::ColumnDesc),
2930 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2931 }
2932 }
2933 }
2934 deserializer.deserialize_identifier(GeneratedVisitor)
2935 }
2936 }
2937 struct GeneratedVisitor;
2938 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2939 type Value = compaction_resolver_node::PkColumn;
2940
2941 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2942 formatter.write_str("struct stream_plan.CompactionResolverNode.PkColumn")
2943 }
2944
2945 fn visit_map<V>(self, mut map_: V) -> std::result::Result<compaction_resolver_node::PkColumn, V::Error>
2946 where
2947 V: serde::de::MapAccess<'de>,
2948 {
2949 let mut data_file_index__ = None;
2950 let mut column_desc__ = None;
2951 while let Some(k) = map_.next_key()? {
2952 match k {
2953 GeneratedField::DataFileIndex => {
2954 if data_file_index__.is_some() {
2955 return Err(serde::de::Error::duplicate_field("dataFileIndex"));
2956 }
2957 data_file_index__ =
2958 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2959 ;
2960 }
2961 GeneratedField::ColumnDesc => {
2962 if column_desc__.is_some() {
2963 return Err(serde::de::Error::duplicate_field("columnDesc"));
2964 }
2965 column_desc__ = map_.next_value()?;
2966 }
2967 }
2968 }
2969 Ok(compaction_resolver_node::PkColumn {
2970 data_file_index: data_file_index__.unwrap_or_default(),
2971 column_desc: column_desc__,
2972 })
2973 }
2974 }
2975 deserializer.deserialize_struct("stream_plan.CompactionResolverNode.PkColumn", FIELDS, GeneratedVisitor)
2976 }
2977}
2978impl serde::Serialize for ConnectorPropsChangeMutation {
2979 #[allow(deprecated)]
2980 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2981 where
2982 S: serde::Serializer,
2983 {
2984 use serde::ser::SerializeStruct;
2985 let mut len = 0;
2986 if !self.connector_props_infos.is_empty() {
2987 len += 1;
2988 }
2989 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation", len)?;
2990 if !self.connector_props_infos.is_empty() {
2991 struct_ser.serialize_field("connectorPropsInfos", &self.connector_props_infos)?;
2992 }
2993 struct_ser.end()
2994 }
2995}
2996impl<'de> serde::Deserialize<'de> for ConnectorPropsChangeMutation {
2997 #[allow(deprecated)]
2998 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2999 where
3000 D: serde::Deserializer<'de>,
3001 {
3002 const FIELDS: &[&str] = &[
3003 "connector_props_infos",
3004 "connectorPropsInfos",
3005 ];
3006
3007 #[allow(clippy::enum_variant_names)]
3008 enum GeneratedField {
3009 ConnectorPropsInfos,
3010 }
3011 impl<'de> serde::Deserialize<'de> for GeneratedField {
3012 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3013 where
3014 D: serde::Deserializer<'de>,
3015 {
3016 struct GeneratedVisitor;
3017
3018 impl serde::de::Visitor<'_> for GeneratedVisitor {
3019 type Value = GeneratedField;
3020
3021 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3022 write!(formatter, "expected one of: {:?}", &FIELDS)
3023 }
3024
3025 #[allow(unused_variables)]
3026 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3027 where
3028 E: serde::de::Error,
3029 {
3030 match value {
3031 "connectorPropsInfos" | "connector_props_infos" => Ok(GeneratedField::ConnectorPropsInfos),
3032 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3033 }
3034 }
3035 }
3036 deserializer.deserialize_identifier(GeneratedVisitor)
3037 }
3038 }
3039 struct GeneratedVisitor;
3040 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3041 type Value = ConnectorPropsChangeMutation;
3042
3043 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3044 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation")
3045 }
3046
3047 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectorPropsChangeMutation, V::Error>
3048 where
3049 V: serde::de::MapAccess<'de>,
3050 {
3051 let mut connector_props_infos__ = None;
3052 while let Some(k) = map_.next_key()? {
3053 match k {
3054 GeneratedField::ConnectorPropsInfos => {
3055 if connector_props_infos__.is_some() {
3056 return Err(serde::de::Error::duplicate_field("connectorPropsInfos"));
3057 }
3058 connector_props_infos__ = Some(
3059 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
3060 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
3061 );
3062 }
3063 }
3064 }
3065 Ok(ConnectorPropsChangeMutation {
3066 connector_props_infos: connector_props_infos__.unwrap_or_default(),
3067 })
3068 }
3069 }
3070 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation", FIELDS, GeneratedVisitor)
3071 }
3072}
3073impl serde::Serialize for connector_props_change_mutation::ConnectorPropsInfo {
3074 #[allow(deprecated)]
3075 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3076 where
3077 S: serde::Serializer,
3078 {
3079 use serde::ser::SerializeStruct;
3080 let mut len = 0;
3081 if !self.connector_props_info.is_empty() {
3082 len += 1;
3083 }
3084 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", len)?;
3085 if !self.connector_props_info.is_empty() {
3086 struct_ser.serialize_field("connectorPropsInfo", &self.connector_props_info)?;
3087 }
3088 struct_ser.end()
3089 }
3090}
3091impl<'de> serde::Deserialize<'de> for connector_props_change_mutation::ConnectorPropsInfo {
3092 #[allow(deprecated)]
3093 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3094 where
3095 D: serde::Deserializer<'de>,
3096 {
3097 const FIELDS: &[&str] = &[
3098 "connector_props_info",
3099 "connectorPropsInfo",
3100 ];
3101
3102 #[allow(clippy::enum_variant_names)]
3103 enum GeneratedField {
3104 ConnectorPropsInfo,
3105 }
3106 impl<'de> serde::Deserialize<'de> for GeneratedField {
3107 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3108 where
3109 D: serde::Deserializer<'de>,
3110 {
3111 struct GeneratedVisitor;
3112
3113 impl serde::de::Visitor<'_> for GeneratedVisitor {
3114 type Value = GeneratedField;
3115
3116 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3117 write!(formatter, "expected one of: {:?}", &FIELDS)
3118 }
3119
3120 #[allow(unused_variables)]
3121 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3122 where
3123 E: serde::de::Error,
3124 {
3125 match value {
3126 "connectorPropsInfo" | "connector_props_info" => Ok(GeneratedField::ConnectorPropsInfo),
3127 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3128 }
3129 }
3130 }
3131 deserializer.deserialize_identifier(GeneratedVisitor)
3132 }
3133 }
3134 struct GeneratedVisitor;
3135 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3136 type Value = connector_props_change_mutation::ConnectorPropsInfo;
3137
3138 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3139 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo")
3140 }
3141
3142 fn visit_map<V>(self, mut map_: V) -> std::result::Result<connector_props_change_mutation::ConnectorPropsInfo, V::Error>
3143 where
3144 V: serde::de::MapAccess<'de>,
3145 {
3146 let mut connector_props_info__ = None;
3147 while let Some(k) = map_.next_key()? {
3148 match k {
3149 GeneratedField::ConnectorPropsInfo => {
3150 if connector_props_info__.is_some() {
3151 return Err(serde::de::Error::duplicate_field("connectorPropsInfo"));
3152 }
3153 connector_props_info__ = Some(
3154 map_.next_value::<std::collections::HashMap<_, _>>()?
3155 );
3156 }
3157 }
3158 }
3159 Ok(connector_props_change_mutation::ConnectorPropsInfo {
3160 connector_props_info: connector_props_info__.unwrap_or_default(),
3161 })
3162 }
3163 }
3164 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", FIELDS, GeneratedVisitor)
3165 }
3166}
3167impl serde::Serialize for DedupNode {
3168 #[allow(deprecated)]
3169 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3170 where
3171 S: serde::Serializer,
3172 {
3173 use serde::ser::SerializeStruct;
3174 let mut len = 0;
3175 if self.state_table.is_some() {
3176 len += 1;
3177 }
3178 if !self.dedup_column_indices.is_empty() {
3179 len += 1;
3180 }
3181 let mut struct_ser = serializer.serialize_struct("stream_plan.DedupNode", len)?;
3182 if let Some(v) = self.state_table.as_ref() {
3183 struct_ser.serialize_field("stateTable", v)?;
3184 }
3185 if !self.dedup_column_indices.is_empty() {
3186 struct_ser.serialize_field("dedupColumnIndices", &self.dedup_column_indices)?;
3187 }
3188 struct_ser.end()
3189 }
3190}
3191impl<'de> serde::Deserialize<'de> for DedupNode {
3192 #[allow(deprecated)]
3193 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3194 where
3195 D: serde::Deserializer<'de>,
3196 {
3197 const FIELDS: &[&str] = &[
3198 "state_table",
3199 "stateTable",
3200 "dedup_column_indices",
3201 "dedupColumnIndices",
3202 ];
3203
3204 #[allow(clippy::enum_variant_names)]
3205 enum GeneratedField {
3206 StateTable,
3207 DedupColumnIndices,
3208 }
3209 impl<'de> serde::Deserialize<'de> for GeneratedField {
3210 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3211 where
3212 D: serde::Deserializer<'de>,
3213 {
3214 struct GeneratedVisitor;
3215
3216 impl serde::de::Visitor<'_> for GeneratedVisitor {
3217 type Value = GeneratedField;
3218
3219 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3220 write!(formatter, "expected one of: {:?}", &FIELDS)
3221 }
3222
3223 #[allow(unused_variables)]
3224 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3225 where
3226 E: serde::de::Error,
3227 {
3228 match value {
3229 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
3230 "dedupColumnIndices" | "dedup_column_indices" => Ok(GeneratedField::DedupColumnIndices),
3231 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3232 }
3233 }
3234 }
3235 deserializer.deserialize_identifier(GeneratedVisitor)
3236 }
3237 }
3238 struct GeneratedVisitor;
3239 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3240 type Value = DedupNode;
3241
3242 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3243 formatter.write_str("struct stream_plan.DedupNode")
3244 }
3245
3246 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DedupNode, V::Error>
3247 where
3248 V: serde::de::MapAccess<'de>,
3249 {
3250 let mut state_table__ = None;
3251 let mut dedup_column_indices__ = None;
3252 while let Some(k) = map_.next_key()? {
3253 match k {
3254 GeneratedField::StateTable => {
3255 if state_table__.is_some() {
3256 return Err(serde::de::Error::duplicate_field("stateTable"));
3257 }
3258 state_table__ = map_.next_value()?;
3259 }
3260 GeneratedField::DedupColumnIndices => {
3261 if dedup_column_indices__.is_some() {
3262 return Err(serde::de::Error::duplicate_field("dedupColumnIndices"));
3263 }
3264 dedup_column_indices__ =
3265 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3266 .into_iter().map(|x| x.0).collect())
3267 ;
3268 }
3269 }
3270 }
3271 Ok(DedupNode {
3272 state_table: state_table__,
3273 dedup_column_indices: dedup_column_indices__.unwrap_or_default(),
3274 })
3275 }
3276 }
3277 deserializer.deserialize_struct("stream_plan.DedupNode", FIELDS, GeneratedVisitor)
3278 }
3279}
3280impl serde::Serialize for DeltaExpression {
3281 #[allow(deprecated)]
3282 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3283 where
3284 S: serde::Serializer,
3285 {
3286 use serde::ser::SerializeStruct;
3287 let mut len = 0;
3288 if self.delta_type != 0 {
3289 len += 1;
3290 }
3291 if self.delta.is_some() {
3292 len += 1;
3293 }
3294 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaExpression", len)?;
3295 if self.delta_type != 0 {
3296 let v = super::expr::expr_node::Type::try_from(self.delta_type)
3297 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.delta_type)))?;
3298 struct_ser.serialize_field("deltaType", &v)?;
3299 }
3300 if let Some(v) = self.delta.as_ref() {
3301 struct_ser.serialize_field("delta", v)?;
3302 }
3303 struct_ser.end()
3304 }
3305}
3306impl<'de> serde::Deserialize<'de> for DeltaExpression {
3307 #[allow(deprecated)]
3308 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3309 where
3310 D: serde::Deserializer<'de>,
3311 {
3312 const FIELDS: &[&str] = &[
3313 "delta_type",
3314 "deltaType",
3315 "delta",
3316 ];
3317
3318 #[allow(clippy::enum_variant_names)]
3319 enum GeneratedField {
3320 DeltaType,
3321 Delta,
3322 }
3323 impl<'de> serde::Deserialize<'de> for GeneratedField {
3324 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3325 where
3326 D: serde::Deserializer<'de>,
3327 {
3328 struct GeneratedVisitor;
3329
3330 impl serde::de::Visitor<'_> for GeneratedVisitor {
3331 type Value = GeneratedField;
3332
3333 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3334 write!(formatter, "expected one of: {:?}", &FIELDS)
3335 }
3336
3337 #[allow(unused_variables)]
3338 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3339 where
3340 E: serde::de::Error,
3341 {
3342 match value {
3343 "deltaType" | "delta_type" => Ok(GeneratedField::DeltaType),
3344 "delta" => Ok(GeneratedField::Delta),
3345 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3346 }
3347 }
3348 }
3349 deserializer.deserialize_identifier(GeneratedVisitor)
3350 }
3351 }
3352 struct GeneratedVisitor;
3353 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3354 type Value = DeltaExpression;
3355
3356 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3357 formatter.write_str("struct stream_plan.DeltaExpression")
3358 }
3359
3360 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaExpression, V::Error>
3361 where
3362 V: serde::de::MapAccess<'de>,
3363 {
3364 let mut delta_type__ = None;
3365 let mut delta__ = None;
3366 while let Some(k) = map_.next_key()? {
3367 match k {
3368 GeneratedField::DeltaType => {
3369 if delta_type__.is_some() {
3370 return Err(serde::de::Error::duplicate_field("deltaType"));
3371 }
3372 delta_type__ = Some(map_.next_value::<super::expr::expr_node::Type>()? as i32);
3373 }
3374 GeneratedField::Delta => {
3375 if delta__.is_some() {
3376 return Err(serde::de::Error::duplicate_field("delta"));
3377 }
3378 delta__ = map_.next_value()?;
3379 }
3380 }
3381 }
3382 Ok(DeltaExpression {
3383 delta_type: delta_type__.unwrap_or_default(),
3384 delta: delta__,
3385 })
3386 }
3387 }
3388 deserializer.deserialize_struct("stream_plan.DeltaExpression", FIELDS, GeneratedVisitor)
3389 }
3390}
3391impl serde::Serialize for DeltaIndexJoinNode {
3392 #[allow(deprecated)]
3393 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3394 where
3395 S: serde::Serializer,
3396 {
3397 use serde::ser::SerializeStruct;
3398 let mut len = 0;
3399 if self.join_type != 0 {
3400 len += 1;
3401 }
3402 if !self.left_key.is_empty() {
3403 len += 1;
3404 }
3405 if !self.right_key.is_empty() {
3406 len += 1;
3407 }
3408 if self.condition.is_some() {
3409 len += 1;
3410 }
3411 if self.left_table_id != 0 {
3412 len += 1;
3413 }
3414 if self.right_table_id != 0 {
3415 len += 1;
3416 }
3417 if self.left_info.is_some() {
3418 len += 1;
3419 }
3420 if self.right_info.is_some() {
3421 len += 1;
3422 }
3423 if !self.output_indices.is_empty() {
3424 len += 1;
3425 }
3426 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaIndexJoinNode", len)?;
3427 if self.join_type != 0 {
3428 let v = super::plan_common::JoinType::try_from(self.join_type)
3429 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
3430 struct_ser.serialize_field("joinType", &v)?;
3431 }
3432 if !self.left_key.is_empty() {
3433 struct_ser.serialize_field("leftKey", &self.left_key)?;
3434 }
3435 if !self.right_key.is_empty() {
3436 struct_ser.serialize_field("rightKey", &self.right_key)?;
3437 }
3438 if let Some(v) = self.condition.as_ref() {
3439 struct_ser.serialize_field("condition", v)?;
3440 }
3441 if self.left_table_id != 0 {
3442 struct_ser.serialize_field("leftTableId", &self.left_table_id)?;
3443 }
3444 if self.right_table_id != 0 {
3445 struct_ser.serialize_field("rightTableId", &self.right_table_id)?;
3446 }
3447 if let Some(v) = self.left_info.as_ref() {
3448 struct_ser.serialize_field("leftInfo", v)?;
3449 }
3450 if let Some(v) = self.right_info.as_ref() {
3451 struct_ser.serialize_field("rightInfo", v)?;
3452 }
3453 if !self.output_indices.is_empty() {
3454 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
3455 }
3456 struct_ser.end()
3457 }
3458}
3459impl<'de> serde::Deserialize<'de> for DeltaIndexJoinNode {
3460 #[allow(deprecated)]
3461 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3462 where
3463 D: serde::Deserializer<'de>,
3464 {
3465 const FIELDS: &[&str] = &[
3466 "join_type",
3467 "joinType",
3468 "left_key",
3469 "leftKey",
3470 "right_key",
3471 "rightKey",
3472 "condition",
3473 "left_table_id",
3474 "leftTableId",
3475 "right_table_id",
3476 "rightTableId",
3477 "left_info",
3478 "leftInfo",
3479 "right_info",
3480 "rightInfo",
3481 "output_indices",
3482 "outputIndices",
3483 ];
3484
3485 #[allow(clippy::enum_variant_names)]
3486 enum GeneratedField {
3487 JoinType,
3488 LeftKey,
3489 RightKey,
3490 Condition,
3491 LeftTableId,
3492 RightTableId,
3493 LeftInfo,
3494 RightInfo,
3495 OutputIndices,
3496 }
3497 impl<'de> serde::Deserialize<'de> for GeneratedField {
3498 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3499 where
3500 D: serde::Deserializer<'de>,
3501 {
3502 struct GeneratedVisitor;
3503
3504 impl serde::de::Visitor<'_> for GeneratedVisitor {
3505 type Value = GeneratedField;
3506
3507 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3508 write!(formatter, "expected one of: {:?}", &FIELDS)
3509 }
3510
3511 #[allow(unused_variables)]
3512 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3513 where
3514 E: serde::de::Error,
3515 {
3516 match value {
3517 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
3518 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
3519 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
3520 "condition" => Ok(GeneratedField::Condition),
3521 "leftTableId" | "left_table_id" => Ok(GeneratedField::LeftTableId),
3522 "rightTableId" | "right_table_id" => Ok(GeneratedField::RightTableId),
3523 "leftInfo" | "left_info" => Ok(GeneratedField::LeftInfo),
3524 "rightInfo" | "right_info" => Ok(GeneratedField::RightInfo),
3525 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
3526 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3527 }
3528 }
3529 }
3530 deserializer.deserialize_identifier(GeneratedVisitor)
3531 }
3532 }
3533 struct GeneratedVisitor;
3534 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3535 type Value = DeltaIndexJoinNode;
3536
3537 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3538 formatter.write_str("struct stream_plan.DeltaIndexJoinNode")
3539 }
3540
3541 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaIndexJoinNode, V::Error>
3542 where
3543 V: serde::de::MapAccess<'de>,
3544 {
3545 let mut join_type__ = None;
3546 let mut left_key__ = None;
3547 let mut right_key__ = None;
3548 let mut condition__ = None;
3549 let mut left_table_id__ = None;
3550 let mut right_table_id__ = None;
3551 let mut left_info__ = None;
3552 let mut right_info__ = None;
3553 let mut output_indices__ = None;
3554 while let Some(k) = map_.next_key()? {
3555 match k {
3556 GeneratedField::JoinType => {
3557 if join_type__.is_some() {
3558 return Err(serde::de::Error::duplicate_field("joinType"));
3559 }
3560 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
3561 }
3562 GeneratedField::LeftKey => {
3563 if left_key__.is_some() {
3564 return Err(serde::de::Error::duplicate_field("leftKey"));
3565 }
3566 left_key__ =
3567 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3568 .into_iter().map(|x| x.0).collect())
3569 ;
3570 }
3571 GeneratedField::RightKey => {
3572 if right_key__.is_some() {
3573 return Err(serde::de::Error::duplicate_field("rightKey"));
3574 }
3575 right_key__ =
3576 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3577 .into_iter().map(|x| x.0).collect())
3578 ;
3579 }
3580 GeneratedField::Condition => {
3581 if condition__.is_some() {
3582 return Err(serde::de::Error::duplicate_field("condition"));
3583 }
3584 condition__ = map_.next_value()?;
3585 }
3586 GeneratedField::LeftTableId => {
3587 if left_table_id__.is_some() {
3588 return Err(serde::de::Error::duplicate_field("leftTableId"));
3589 }
3590 left_table_id__ =
3591 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3592 ;
3593 }
3594 GeneratedField::RightTableId => {
3595 if right_table_id__.is_some() {
3596 return Err(serde::de::Error::duplicate_field("rightTableId"));
3597 }
3598 right_table_id__ =
3599 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3600 ;
3601 }
3602 GeneratedField::LeftInfo => {
3603 if left_info__.is_some() {
3604 return Err(serde::de::Error::duplicate_field("leftInfo"));
3605 }
3606 left_info__ = map_.next_value()?;
3607 }
3608 GeneratedField::RightInfo => {
3609 if right_info__.is_some() {
3610 return Err(serde::de::Error::duplicate_field("rightInfo"));
3611 }
3612 right_info__ = map_.next_value()?;
3613 }
3614 GeneratedField::OutputIndices => {
3615 if output_indices__.is_some() {
3616 return Err(serde::de::Error::duplicate_field("outputIndices"));
3617 }
3618 output_indices__ =
3619 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3620 .into_iter().map(|x| x.0).collect())
3621 ;
3622 }
3623 }
3624 }
3625 Ok(DeltaIndexJoinNode {
3626 join_type: join_type__.unwrap_or_default(),
3627 left_key: left_key__.unwrap_or_default(),
3628 right_key: right_key__.unwrap_or_default(),
3629 condition: condition__,
3630 left_table_id: left_table_id__.unwrap_or_default(),
3631 right_table_id: right_table_id__.unwrap_or_default(),
3632 left_info: left_info__,
3633 right_info: right_info__,
3634 output_indices: output_indices__.unwrap_or_default(),
3635 })
3636 }
3637 }
3638 deserializer.deserialize_struct("stream_plan.DeltaIndexJoinNode", FIELDS, GeneratedVisitor)
3639 }
3640}
3641impl serde::Serialize for DispatchOutputMapping {
3642 #[allow(deprecated)]
3643 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3644 where
3645 S: serde::Serializer,
3646 {
3647 use serde::ser::SerializeStruct;
3648 let mut len = 0;
3649 if !self.indices.is_empty() {
3650 len += 1;
3651 }
3652 if !self.types.is_empty() {
3653 len += 1;
3654 }
3655 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping", len)?;
3656 if !self.indices.is_empty() {
3657 struct_ser.serialize_field("indices", &self.indices)?;
3658 }
3659 if !self.types.is_empty() {
3660 struct_ser.serialize_field("types", &self.types)?;
3661 }
3662 struct_ser.end()
3663 }
3664}
3665impl<'de> serde::Deserialize<'de> for DispatchOutputMapping {
3666 #[allow(deprecated)]
3667 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3668 where
3669 D: serde::Deserializer<'de>,
3670 {
3671 const FIELDS: &[&str] = &[
3672 "indices",
3673 "types",
3674 ];
3675
3676 #[allow(clippy::enum_variant_names)]
3677 enum GeneratedField {
3678 Indices,
3679 Types,
3680 }
3681 impl<'de> serde::Deserialize<'de> for GeneratedField {
3682 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3683 where
3684 D: serde::Deserializer<'de>,
3685 {
3686 struct GeneratedVisitor;
3687
3688 impl serde::de::Visitor<'_> for GeneratedVisitor {
3689 type Value = GeneratedField;
3690
3691 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3692 write!(formatter, "expected one of: {:?}", &FIELDS)
3693 }
3694
3695 #[allow(unused_variables)]
3696 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3697 where
3698 E: serde::de::Error,
3699 {
3700 match value {
3701 "indices" => Ok(GeneratedField::Indices),
3702 "types" => Ok(GeneratedField::Types),
3703 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3704 }
3705 }
3706 }
3707 deserializer.deserialize_identifier(GeneratedVisitor)
3708 }
3709 }
3710 struct GeneratedVisitor;
3711 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3712 type Value = DispatchOutputMapping;
3713
3714 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3715 formatter.write_str("struct stream_plan.DispatchOutputMapping")
3716 }
3717
3718 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchOutputMapping, V::Error>
3719 where
3720 V: serde::de::MapAccess<'de>,
3721 {
3722 let mut indices__ = None;
3723 let mut types__ = None;
3724 while let Some(k) = map_.next_key()? {
3725 match k {
3726 GeneratedField::Indices => {
3727 if indices__.is_some() {
3728 return Err(serde::de::Error::duplicate_field("indices"));
3729 }
3730 indices__ =
3731 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3732 .into_iter().map(|x| x.0).collect())
3733 ;
3734 }
3735 GeneratedField::Types => {
3736 if types__.is_some() {
3737 return Err(serde::de::Error::duplicate_field("types"));
3738 }
3739 types__ = Some(map_.next_value()?);
3740 }
3741 }
3742 }
3743 Ok(DispatchOutputMapping {
3744 indices: indices__.unwrap_or_default(),
3745 types: types__.unwrap_or_default(),
3746 })
3747 }
3748 }
3749 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping", FIELDS, GeneratedVisitor)
3750 }
3751}
3752impl serde::Serialize for dispatch_output_mapping::TypePair {
3753 #[allow(deprecated)]
3754 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3755 where
3756 S: serde::Serializer,
3757 {
3758 use serde::ser::SerializeStruct;
3759 let mut len = 0;
3760 if self.upstream.is_some() {
3761 len += 1;
3762 }
3763 if self.downstream.is_some() {
3764 len += 1;
3765 }
3766 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping.TypePair", len)?;
3767 if let Some(v) = self.upstream.as_ref() {
3768 struct_ser.serialize_field("upstream", v)?;
3769 }
3770 if let Some(v) = self.downstream.as_ref() {
3771 struct_ser.serialize_field("downstream", v)?;
3772 }
3773 struct_ser.end()
3774 }
3775}
3776impl<'de> serde::Deserialize<'de> for dispatch_output_mapping::TypePair {
3777 #[allow(deprecated)]
3778 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3779 where
3780 D: serde::Deserializer<'de>,
3781 {
3782 const FIELDS: &[&str] = &[
3783 "upstream",
3784 "downstream",
3785 ];
3786
3787 #[allow(clippy::enum_variant_names)]
3788 enum GeneratedField {
3789 Upstream,
3790 Downstream,
3791 }
3792 impl<'de> serde::Deserialize<'de> for GeneratedField {
3793 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3794 where
3795 D: serde::Deserializer<'de>,
3796 {
3797 struct GeneratedVisitor;
3798
3799 impl serde::de::Visitor<'_> for GeneratedVisitor {
3800 type Value = GeneratedField;
3801
3802 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3803 write!(formatter, "expected one of: {:?}", &FIELDS)
3804 }
3805
3806 #[allow(unused_variables)]
3807 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3808 where
3809 E: serde::de::Error,
3810 {
3811 match value {
3812 "upstream" => Ok(GeneratedField::Upstream),
3813 "downstream" => Ok(GeneratedField::Downstream),
3814 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3815 }
3816 }
3817 }
3818 deserializer.deserialize_identifier(GeneratedVisitor)
3819 }
3820 }
3821 struct GeneratedVisitor;
3822 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3823 type Value = dispatch_output_mapping::TypePair;
3824
3825 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3826 formatter.write_str("struct stream_plan.DispatchOutputMapping.TypePair")
3827 }
3828
3829 fn visit_map<V>(self, mut map_: V) -> std::result::Result<dispatch_output_mapping::TypePair, V::Error>
3830 where
3831 V: serde::de::MapAccess<'de>,
3832 {
3833 let mut upstream__ = None;
3834 let mut downstream__ = None;
3835 while let Some(k) = map_.next_key()? {
3836 match k {
3837 GeneratedField::Upstream => {
3838 if upstream__.is_some() {
3839 return Err(serde::de::Error::duplicate_field("upstream"));
3840 }
3841 upstream__ = map_.next_value()?;
3842 }
3843 GeneratedField::Downstream => {
3844 if downstream__.is_some() {
3845 return Err(serde::de::Error::duplicate_field("downstream"));
3846 }
3847 downstream__ = map_.next_value()?;
3848 }
3849 }
3850 }
3851 Ok(dispatch_output_mapping::TypePair {
3852 upstream: upstream__,
3853 downstream: downstream__,
3854 })
3855 }
3856 }
3857 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping.TypePair", FIELDS, GeneratedVisitor)
3858 }
3859}
3860impl serde::Serialize for DispatchStrategy {
3861 #[allow(deprecated)]
3862 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3863 where
3864 S: serde::Serializer,
3865 {
3866 use serde::ser::SerializeStruct;
3867 let mut len = 0;
3868 if self.r#type != 0 {
3869 len += 1;
3870 }
3871 if !self.dist_key_indices.is_empty() {
3872 len += 1;
3873 }
3874 if self.output_mapping.is_some() {
3875 len += 1;
3876 }
3877 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchStrategy", len)?;
3878 if self.r#type != 0 {
3879 let v = DispatcherType::try_from(self.r#type)
3880 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3881 struct_ser.serialize_field("type", &v)?;
3882 }
3883 if !self.dist_key_indices.is_empty() {
3884 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3885 }
3886 if let Some(v) = self.output_mapping.as_ref() {
3887 struct_ser.serialize_field("outputMapping", v)?;
3888 }
3889 struct_ser.end()
3890 }
3891}
3892impl<'de> serde::Deserialize<'de> for DispatchStrategy {
3893 #[allow(deprecated)]
3894 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3895 where
3896 D: serde::Deserializer<'de>,
3897 {
3898 const FIELDS: &[&str] = &[
3899 "type",
3900 "dist_key_indices",
3901 "distKeyIndices",
3902 "output_mapping",
3903 "outputMapping",
3904 ];
3905
3906 #[allow(clippy::enum_variant_names)]
3907 enum GeneratedField {
3908 Type,
3909 DistKeyIndices,
3910 OutputMapping,
3911 }
3912 impl<'de> serde::Deserialize<'de> for GeneratedField {
3913 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3914 where
3915 D: serde::Deserializer<'de>,
3916 {
3917 struct GeneratedVisitor;
3918
3919 impl serde::de::Visitor<'_> for GeneratedVisitor {
3920 type Value = GeneratedField;
3921
3922 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3923 write!(formatter, "expected one of: {:?}", &FIELDS)
3924 }
3925
3926 #[allow(unused_variables)]
3927 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3928 where
3929 E: serde::de::Error,
3930 {
3931 match value {
3932 "type" => Ok(GeneratedField::Type),
3933 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3934 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3935 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3936 }
3937 }
3938 }
3939 deserializer.deserialize_identifier(GeneratedVisitor)
3940 }
3941 }
3942 struct GeneratedVisitor;
3943 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3944 type Value = DispatchStrategy;
3945
3946 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3947 formatter.write_str("struct stream_plan.DispatchStrategy")
3948 }
3949
3950 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchStrategy, V::Error>
3951 where
3952 V: serde::de::MapAccess<'de>,
3953 {
3954 let mut r#type__ = None;
3955 let mut dist_key_indices__ = None;
3956 let mut output_mapping__ = None;
3957 while let Some(k) = map_.next_key()? {
3958 match k {
3959 GeneratedField::Type => {
3960 if r#type__.is_some() {
3961 return Err(serde::de::Error::duplicate_field("type"));
3962 }
3963 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3964 }
3965 GeneratedField::DistKeyIndices => {
3966 if dist_key_indices__.is_some() {
3967 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3968 }
3969 dist_key_indices__ =
3970 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3971 .into_iter().map(|x| x.0).collect())
3972 ;
3973 }
3974 GeneratedField::OutputMapping => {
3975 if output_mapping__.is_some() {
3976 return Err(serde::de::Error::duplicate_field("outputMapping"));
3977 }
3978 output_mapping__ = map_.next_value()?;
3979 }
3980 }
3981 }
3982 Ok(DispatchStrategy {
3983 r#type: r#type__.unwrap_or_default(),
3984 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3985 output_mapping: output_mapping__,
3986 })
3987 }
3988 }
3989 deserializer.deserialize_struct("stream_plan.DispatchStrategy", FIELDS, GeneratedVisitor)
3990 }
3991}
3992impl serde::Serialize for Dispatcher {
3993 #[allow(deprecated)]
3994 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3995 where
3996 S: serde::Serializer,
3997 {
3998 use serde::ser::SerializeStruct;
3999 let mut len = 0;
4000 if self.r#type != 0 {
4001 len += 1;
4002 }
4003 if !self.dist_key_indices.is_empty() {
4004 len += 1;
4005 }
4006 if self.output_mapping.is_some() {
4007 len += 1;
4008 }
4009 if self.hash_mapping.is_some() {
4010 len += 1;
4011 }
4012 if self.dispatcher_id != 0 {
4013 len += 1;
4014 }
4015 if !self.downstream_actor_id.is_empty() {
4016 len += 1;
4017 }
4018 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatcher", len)?;
4019 if self.r#type != 0 {
4020 let v = DispatcherType::try_from(self.r#type)
4021 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
4022 struct_ser.serialize_field("type", &v)?;
4023 }
4024 if !self.dist_key_indices.is_empty() {
4025 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
4026 }
4027 if let Some(v) = self.output_mapping.as_ref() {
4028 struct_ser.serialize_field("outputMapping", v)?;
4029 }
4030 if let Some(v) = self.hash_mapping.as_ref() {
4031 struct_ser.serialize_field("hashMapping", v)?;
4032 }
4033 if self.dispatcher_id != 0 {
4034 struct_ser.serialize_field("dispatcherId", &self.dispatcher_id)?;
4035 }
4036 if !self.downstream_actor_id.is_empty() {
4037 struct_ser.serialize_field("downstreamActorId", &self.downstream_actor_id)?;
4038 }
4039 struct_ser.end()
4040 }
4041}
4042impl<'de> serde::Deserialize<'de> for Dispatcher {
4043 #[allow(deprecated)]
4044 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4045 where
4046 D: serde::Deserializer<'de>,
4047 {
4048 const FIELDS: &[&str] = &[
4049 "type",
4050 "dist_key_indices",
4051 "distKeyIndices",
4052 "output_mapping",
4053 "outputMapping",
4054 "hash_mapping",
4055 "hashMapping",
4056 "dispatcher_id",
4057 "dispatcherId",
4058 "downstream_actor_id",
4059 "downstreamActorId",
4060 ];
4061
4062 #[allow(clippy::enum_variant_names)]
4063 enum GeneratedField {
4064 Type,
4065 DistKeyIndices,
4066 OutputMapping,
4067 HashMapping,
4068 DispatcherId,
4069 DownstreamActorId,
4070 }
4071 impl<'de> serde::Deserialize<'de> for GeneratedField {
4072 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4073 where
4074 D: serde::Deserializer<'de>,
4075 {
4076 struct GeneratedVisitor;
4077
4078 impl serde::de::Visitor<'_> for GeneratedVisitor {
4079 type Value = GeneratedField;
4080
4081 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4082 write!(formatter, "expected one of: {:?}", &FIELDS)
4083 }
4084
4085 #[allow(unused_variables)]
4086 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4087 where
4088 E: serde::de::Error,
4089 {
4090 match value {
4091 "type" => Ok(GeneratedField::Type),
4092 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
4093 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
4094 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
4095 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
4096 "downstreamActorId" | "downstream_actor_id" => Ok(GeneratedField::DownstreamActorId),
4097 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4098 }
4099 }
4100 }
4101 deserializer.deserialize_identifier(GeneratedVisitor)
4102 }
4103 }
4104 struct GeneratedVisitor;
4105 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4106 type Value = Dispatcher;
4107
4108 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4109 formatter.write_str("struct stream_plan.Dispatcher")
4110 }
4111
4112 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatcher, V::Error>
4113 where
4114 V: serde::de::MapAccess<'de>,
4115 {
4116 let mut r#type__ = None;
4117 let mut dist_key_indices__ = None;
4118 let mut output_mapping__ = None;
4119 let mut hash_mapping__ = None;
4120 let mut dispatcher_id__ = None;
4121 let mut downstream_actor_id__ = None;
4122 while let Some(k) = map_.next_key()? {
4123 match k {
4124 GeneratedField::Type => {
4125 if r#type__.is_some() {
4126 return Err(serde::de::Error::duplicate_field("type"));
4127 }
4128 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
4129 }
4130 GeneratedField::DistKeyIndices => {
4131 if dist_key_indices__.is_some() {
4132 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
4133 }
4134 dist_key_indices__ =
4135 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4136 .into_iter().map(|x| x.0).collect())
4137 ;
4138 }
4139 GeneratedField::OutputMapping => {
4140 if output_mapping__.is_some() {
4141 return Err(serde::de::Error::duplicate_field("outputMapping"));
4142 }
4143 output_mapping__ = map_.next_value()?;
4144 }
4145 GeneratedField::HashMapping => {
4146 if hash_mapping__.is_some() {
4147 return Err(serde::de::Error::duplicate_field("hashMapping"));
4148 }
4149 hash_mapping__ = map_.next_value()?;
4150 }
4151 GeneratedField::DispatcherId => {
4152 if dispatcher_id__.is_some() {
4153 return Err(serde::de::Error::duplicate_field("dispatcherId"));
4154 }
4155 dispatcher_id__ =
4156 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4157 ;
4158 }
4159 GeneratedField::DownstreamActorId => {
4160 if downstream_actor_id__.is_some() {
4161 return Err(serde::de::Error::duplicate_field("downstreamActorId"));
4162 }
4163 downstream_actor_id__ =
4164 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4165 .into_iter().map(|x| x.0).collect())
4166 ;
4167 }
4168 }
4169 }
4170 Ok(Dispatcher {
4171 r#type: r#type__.unwrap_or_default(),
4172 dist_key_indices: dist_key_indices__.unwrap_or_default(),
4173 output_mapping: output_mapping__,
4174 hash_mapping: hash_mapping__,
4175 dispatcher_id: dispatcher_id__.unwrap_or_default(),
4176 downstream_actor_id: downstream_actor_id__.unwrap_or_default(),
4177 })
4178 }
4179 }
4180 deserializer.deserialize_struct("stream_plan.Dispatcher", FIELDS, GeneratedVisitor)
4181 }
4182}
4183impl serde::Serialize for DispatcherType {
4184 #[allow(deprecated)]
4185 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4186 where
4187 S: serde::Serializer,
4188 {
4189 let variant = match self {
4190 Self::Unspecified => "DISPATCHER_TYPE_UNSPECIFIED",
4191 Self::Hash => "DISPATCHER_TYPE_HASH",
4192 Self::Broadcast => "DISPATCHER_TYPE_BROADCAST",
4193 Self::Simple => "DISPATCHER_TYPE_SIMPLE",
4194 Self::NoShuffle => "DISPATCHER_TYPE_NO_SHUFFLE",
4195 };
4196 serializer.serialize_str(variant)
4197 }
4198}
4199impl<'de> serde::Deserialize<'de> for DispatcherType {
4200 #[allow(deprecated)]
4201 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4202 where
4203 D: serde::Deserializer<'de>,
4204 {
4205 const FIELDS: &[&str] = &[
4206 "DISPATCHER_TYPE_UNSPECIFIED",
4207 "DISPATCHER_TYPE_HASH",
4208 "DISPATCHER_TYPE_BROADCAST",
4209 "DISPATCHER_TYPE_SIMPLE",
4210 "DISPATCHER_TYPE_NO_SHUFFLE",
4211 ];
4212
4213 struct GeneratedVisitor;
4214
4215 impl serde::de::Visitor<'_> for GeneratedVisitor {
4216 type Value = DispatcherType;
4217
4218 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4219 write!(formatter, "expected one of: {:?}", &FIELDS)
4220 }
4221
4222 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
4223 where
4224 E: serde::de::Error,
4225 {
4226 i32::try_from(v)
4227 .ok()
4228 .and_then(|x| x.try_into().ok())
4229 .ok_or_else(|| {
4230 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
4231 })
4232 }
4233
4234 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
4235 where
4236 E: serde::de::Error,
4237 {
4238 i32::try_from(v)
4239 .ok()
4240 .and_then(|x| x.try_into().ok())
4241 .ok_or_else(|| {
4242 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
4243 })
4244 }
4245
4246 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
4247 where
4248 E: serde::de::Error,
4249 {
4250 match value {
4251 "DISPATCHER_TYPE_UNSPECIFIED" => Ok(DispatcherType::Unspecified),
4252 "DISPATCHER_TYPE_HASH" => Ok(DispatcherType::Hash),
4253 "DISPATCHER_TYPE_BROADCAST" => Ok(DispatcherType::Broadcast),
4254 "DISPATCHER_TYPE_SIMPLE" => Ok(DispatcherType::Simple),
4255 "DISPATCHER_TYPE_NO_SHUFFLE" => Ok(DispatcherType::NoShuffle),
4256 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
4257 }
4258 }
4259 }
4260 deserializer.deserialize_any(GeneratedVisitor)
4261 }
4262}
4263impl serde::Serialize for Dispatchers {
4264 #[allow(deprecated)]
4265 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4266 where
4267 S: serde::Serializer,
4268 {
4269 use serde::ser::SerializeStruct;
4270 let mut len = 0;
4271 if !self.dispatchers.is_empty() {
4272 len += 1;
4273 }
4274 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatchers", len)?;
4275 if !self.dispatchers.is_empty() {
4276 struct_ser.serialize_field("dispatchers", &self.dispatchers)?;
4277 }
4278 struct_ser.end()
4279 }
4280}
4281impl<'de> serde::Deserialize<'de> for Dispatchers {
4282 #[allow(deprecated)]
4283 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4284 where
4285 D: serde::Deserializer<'de>,
4286 {
4287 const FIELDS: &[&str] = &[
4288 "dispatchers",
4289 ];
4290
4291 #[allow(clippy::enum_variant_names)]
4292 enum GeneratedField {
4293 Dispatchers,
4294 }
4295 impl<'de> serde::Deserialize<'de> for GeneratedField {
4296 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4297 where
4298 D: serde::Deserializer<'de>,
4299 {
4300 struct GeneratedVisitor;
4301
4302 impl serde::de::Visitor<'_> for GeneratedVisitor {
4303 type Value = GeneratedField;
4304
4305 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4306 write!(formatter, "expected one of: {:?}", &FIELDS)
4307 }
4308
4309 #[allow(unused_variables)]
4310 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4311 where
4312 E: serde::de::Error,
4313 {
4314 match value {
4315 "dispatchers" => Ok(GeneratedField::Dispatchers),
4316 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4317 }
4318 }
4319 }
4320 deserializer.deserialize_identifier(GeneratedVisitor)
4321 }
4322 }
4323 struct GeneratedVisitor;
4324 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4325 type Value = Dispatchers;
4326
4327 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4328 formatter.write_str("struct stream_plan.Dispatchers")
4329 }
4330
4331 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatchers, V::Error>
4332 where
4333 V: serde::de::MapAccess<'de>,
4334 {
4335 let mut dispatchers__ = None;
4336 while let Some(k) = map_.next_key()? {
4337 match k {
4338 GeneratedField::Dispatchers => {
4339 if dispatchers__.is_some() {
4340 return Err(serde::de::Error::duplicate_field("dispatchers"));
4341 }
4342 dispatchers__ = Some(map_.next_value()?);
4343 }
4344 }
4345 }
4346 Ok(Dispatchers {
4347 dispatchers: dispatchers__.unwrap_or_default(),
4348 })
4349 }
4350 }
4351 deserializer.deserialize_struct("stream_plan.Dispatchers", FIELDS, GeneratedVisitor)
4352 }
4353}
4354impl serde::Serialize for DmlNode {
4355 #[allow(deprecated)]
4356 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4357 where
4358 S: serde::Serializer,
4359 {
4360 use serde::ser::SerializeStruct;
4361 let mut len = 0;
4362 if self.table_id != 0 {
4363 len += 1;
4364 }
4365 if self.table_version_id != 0 {
4366 len += 1;
4367 }
4368 if !self.column_descs.is_empty() {
4369 len += 1;
4370 }
4371 if self.rate_limit.is_some() {
4372 len += 1;
4373 }
4374 let mut struct_ser = serializer.serialize_struct("stream_plan.DmlNode", len)?;
4375 if self.table_id != 0 {
4376 struct_ser.serialize_field("tableId", &self.table_id)?;
4377 }
4378 if self.table_version_id != 0 {
4379 #[allow(clippy::needless_borrow)]
4380 #[allow(clippy::needless_borrows_for_generic_args)]
4381 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
4382 }
4383 if !self.column_descs.is_empty() {
4384 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
4385 }
4386 if let Some(v) = self.rate_limit.as_ref() {
4387 struct_ser.serialize_field("rateLimit", v)?;
4388 }
4389 struct_ser.end()
4390 }
4391}
4392impl<'de> serde::Deserialize<'de> for DmlNode {
4393 #[allow(deprecated)]
4394 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4395 where
4396 D: serde::Deserializer<'de>,
4397 {
4398 const FIELDS: &[&str] = &[
4399 "table_id",
4400 "tableId",
4401 "table_version_id",
4402 "tableVersionId",
4403 "column_descs",
4404 "columnDescs",
4405 "rate_limit",
4406 "rateLimit",
4407 ];
4408
4409 #[allow(clippy::enum_variant_names)]
4410 enum GeneratedField {
4411 TableId,
4412 TableVersionId,
4413 ColumnDescs,
4414 RateLimit,
4415 }
4416 impl<'de> serde::Deserialize<'de> for GeneratedField {
4417 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4418 where
4419 D: serde::Deserializer<'de>,
4420 {
4421 struct GeneratedVisitor;
4422
4423 impl serde::de::Visitor<'_> for GeneratedVisitor {
4424 type Value = GeneratedField;
4425
4426 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4427 write!(formatter, "expected one of: {:?}", &FIELDS)
4428 }
4429
4430 #[allow(unused_variables)]
4431 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4432 where
4433 E: serde::de::Error,
4434 {
4435 match value {
4436 "tableId" | "table_id" => Ok(GeneratedField::TableId),
4437 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
4438 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
4439 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
4440 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4441 }
4442 }
4443 }
4444 deserializer.deserialize_identifier(GeneratedVisitor)
4445 }
4446 }
4447 struct GeneratedVisitor;
4448 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4449 type Value = DmlNode;
4450
4451 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4452 formatter.write_str("struct stream_plan.DmlNode")
4453 }
4454
4455 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DmlNode, V::Error>
4456 where
4457 V: serde::de::MapAccess<'de>,
4458 {
4459 let mut table_id__ = None;
4460 let mut table_version_id__ = None;
4461 let mut column_descs__ = None;
4462 let mut rate_limit__ = None;
4463 while let Some(k) = map_.next_key()? {
4464 match k {
4465 GeneratedField::TableId => {
4466 if table_id__.is_some() {
4467 return Err(serde::de::Error::duplicate_field("tableId"));
4468 }
4469 table_id__ =
4470 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4471 ;
4472 }
4473 GeneratedField::TableVersionId => {
4474 if table_version_id__.is_some() {
4475 return Err(serde::de::Error::duplicate_field("tableVersionId"));
4476 }
4477 table_version_id__ =
4478 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4479 ;
4480 }
4481 GeneratedField::ColumnDescs => {
4482 if column_descs__.is_some() {
4483 return Err(serde::de::Error::duplicate_field("columnDescs"));
4484 }
4485 column_descs__ = Some(map_.next_value()?);
4486 }
4487 GeneratedField::RateLimit => {
4488 if rate_limit__.is_some() {
4489 return Err(serde::de::Error::duplicate_field("rateLimit"));
4490 }
4491 rate_limit__ =
4492 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4493 ;
4494 }
4495 }
4496 }
4497 Ok(DmlNode {
4498 table_id: table_id__.unwrap_or_default(),
4499 table_version_id: table_version_id__.unwrap_or_default(),
4500 column_descs: column_descs__.unwrap_or_default(),
4501 rate_limit: rate_limit__,
4502 })
4503 }
4504 }
4505 deserializer.deserialize_struct("stream_plan.DmlNode", FIELDS, GeneratedVisitor)
4506 }
4507}
4508impl serde::Serialize for DropSubscriptionsMutation {
4509 #[allow(deprecated)]
4510 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4511 where
4512 S: serde::Serializer,
4513 {
4514 use serde::ser::SerializeStruct;
4515 let mut len = 0;
4516 if !self.info.is_empty() {
4517 len += 1;
4518 }
4519 let mut struct_ser = serializer.serialize_struct("stream_plan.DropSubscriptionsMutation", len)?;
4520 if !self.info.is_empty() {
4521 struct_ser.serialize_field("info", &self.info)?;
4522 }
4523 struct_ser.end()
4524 }
4525}
4526impl<'de> serde::Deserialize<'de> for DropSubscriptionsMutation {
4527 #[allow(deprecated)]
4528 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4529 where
4530 D: serde::Deserializer<'de>,
4531 {
4532 const FIELDS: &[&str] = &[
4533 "info",
4534 ];
4535
4536 #[allow(clippy::enum_variant_names)]
4537 enum GeneratedField {
4538 Info,
4539 }
4540 impl<'de> serde::Deserialize<'de> for GeneratedField {
4541 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4542 where
4543 D: serde::Deserializer<'de>,
4544 {
4545 struct GeneratedVisitor;
4546
4547 impl serde::de::Visitor<'_> for GeneratedVisitor {
4548 type Value = GeneratedField;
4549
4550 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4551 write!(formatter, "expected one of: {:?}", &FIELDS)
4552 }
4553
4554 #[allow(unused_variables)]
4555 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4556 where
4557 E: serde::de::Error,
4558 {
4559 match value {
4560 "info" => Ok(GeneratedField::Info),
4561 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4562 }
4563 }
4564 }
4565 deserializer.deserialize_identifier(GeneratedVisitor)
4566 }
4567 }
4568 struct GeneratedVisitor;
4569 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4570 type Value = DropSubscriptionsMutation;
4571
4572 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4573 formatter.write_str("struct stream_plan.DropSubscriptionsMutation")
4574 }
4575
4576 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionsMutation, V::Error>
4577 where
4578 V: serde::de::MapAccess<'de>,
4579 {
4580 let mut info__ = None;
4581 while let Some(k) = map_.next_key()? {
4582 match k {
4583 GeneratedField::Info => {
4584 if info__.is_some() {
4585 return Err(serde::de::Error::duplicate_field("info"));
4586 }
4587 info__ = Some(map_.next_value()?);
4588 }
4589 }
4590 }
4591 Ok(DropSubscriptionsMutation {
4592 info: info__.unwrap_or_default(),
4593 })
4594 }
4595 }
4596 deserializer.deserialize_struct("stream_plan.DropSubscriptionsMutation", FIELDS, GeneratedVisitor)
4597 }
4598}
4599impl serde::Serialize for DynamicFilterNode {
4600 #[allow(deprecated)]
4601 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4602 where
4603 S: serde::Serializer,
4604 {
4605 use serde::ser::SerializeStruct;
4606 let mut len = 0;
4607 if self.left_key != 0 {
4608 len += 1;
4609 }
4610 if self.condition.is_some() {
4611 len += 1;
4612 }
4613 if self.left_table.is_some() {
4614 len += 1;
4615 }
4616 if self.right_table.is_some() {
4617 len += 1;
4618 }
4619 if self.condition_always_relax {
4620 len += 1;
4621 }
4622 if self.cleaned_by_watermark {
4623 len += 1;
4624 }
4625 let mut struct_ser = serializer.serialize_struct("stream_plan.DynamicFilterNode", len)?;
4626 if self.left_key != 0 {
4627 struct_ser.serialize_field("leftKey", &self.left_key)?;
4628 }
4629 if let Some(v) = self.condition.as_ref() {
4630 struct_ser.serialize_field("condition", v)?;
4631 }
4632 if let Some(v) = self.left_table.as_ref() {
4633 struct_ser.serialize_field("leftTable", v)?;
4634 }
4635 if let Some(v) = self.right_table.as_ref() {
4636 struct_ser.serialize_field("rightTable", v)?;
4637 }
4638 if self.condition_always_relax {
4639 struct_ser.serialize_field("conditionAlwaysRelax", &self.condition_always_relax)?;
4640 }
4641 if self.cleaned_by_watermark {
4642 struct_ser.serialize_field("cleanedByWatermark", &self.cleaned_by_watermark)?;
4643 }
4644 struct_ser.end()
4645 }
4646}
4647impl<'de> serde::Deserialize<'de> for DynamicFilterNode {
4648 #[allow(deprecated)]
4649 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4650 where
4651 D: serde::Deserializer<'de>,
4652 {
4653 const FIELDS: &[&str] = &[
4654 "left_key",
4655 "leftKey",
4656 "condition",
4657 "left_table",
4658 "leftTable",
4659 "right_table",
4660 "rightTable",
4661 "condition_always_relax",
4662 "conditionAlwaysRelax",
4663 "cleaned_by_watermark",
4664 "cleanedByWatermark",
4665 ];
4666
4667 #[allow(clippy::enum_variant_names)]
4668 enum GeneratedField {
4669 LeftKey,
4670 Condition,
4671 LeftTable,
4672 RightTable,
4673 ConditionAlwaysRelax,
4674 CleanedByWatermark,
4675 }
4676 impl<'de> serde::Deserialize<'de> for GeneratedField {
4677 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4678 where
4679 D: serde::Deserializer<'de>,
4680 {
4681 struct GeneratedVisitor;
4682
4683 impl serde::de::Visitor<'_> for GeneratedVisitor {
4684 type Value = GeneratedField;
4685
4686 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4687 write!(formatter, "expected one of: {:?}", &FIELDS)
4688 }
4689
4690 #[allow(unused_variables)]
4691 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4692 where
4693 E: serde::de::Error,
4694 {
4695 match value {
4696 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
4697 "condition" => Ok(GeneratedField::Condition),
4698 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
4699 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
4700 "conditionAlwaysRelax" | "condition_always_relax" => Ok(GeneratedField::ConditionAlwaysRelax),
4701 "cleanedByWatermark" | "cleaned_by_watermark" => Ok(GeneratedField::CleanedByWatermark),
4702 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4703 }
4704 }
4705 }
4706 deserializer.deserialize_identifier(GeneratedVisitor)
4707 }
4708 }
4709 struct GeneratedVisitor;
4710 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4711 type Value = DynamicFilterNode;
4712
4713 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4714 formatter.write_str("struct stream_plan.DynamicFilterNode")
4715 }
4716
4717 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DynamicFilterNode, V::Error>
4718 where
4719 V: serde::de::MapAccess<'de>,
4720 {
4721 let mut left_key__ = None;
4722 let mut condition__ = None;
4723 let mut left_table__ = None;
4724 let mut right_table__ = None;
4725 let mut condition_always_relax__ = None;
4726 let mut cleaned_by_watermark__ = None;
4727 while let Some(k) = map_.next_key()? {
4728 match k {
4729 GeneratedField::LeftKey => {
4730 if left_key__.is_some() {
4731 return Err(serde::de::Error::duplicate_field("leftKey"));
4732 }
4733 left_key__ =
4734 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4735 ;
4736 }
4737 GeneratedField::Condition => {
4738 if condition__.is_some() {
4739 return Err(serde::de::Error::duplicate_field("condition"));
4740 }
4741 condition__ = map_.next_value()?;
4742 }
4743 GeneratedField::LeftTable => {
4744 if left_table__.is_some() {
4745 return Err(serde::de::Error::duplicate_field("leftTable"));
4746 }
4747 left_table__ = map_.next_value()?;
4748 }
4749 GeneratedField::RightTable => {
4750 if right_table__.is_some() {
4751 return Err(serde::de::Error::duplicate_field("rightTable"));
4752 }
4753 right_table__ = map_.next_value()?;
4754 }
4755 GeneratedField::ConditionAlwaysRelax => {
4756 if condition_always_relax__.is_some() {
4757 return Err(serde::de::Error::duplicate_field("conditionAlwaysRelax"));
4758 }
4759 condition_always_relax__ = Some(map_.next_value()?);
4760 }
4761 GeneratedField::CleanedByWatermark => {
4762 if cleaned_by_watermark__.is_some() {
4763 return Err(serde::de::Error::duplicate_field("cleanedByWatermark"));
4764 }
4765 cleaned_by_watermark__ = Some(map_.next_value()?);
4766 }
4767 }
4768 }
4769 Ok(DynamicFilterNode {
4770 left_key: left_key__.unwrap_or_default(),
4771 condition: condition__,
4772 left_table: left_table__,
4773 right_table: right_table__,
4774 condition_always_relax: condition_always_relax__.unwrap_or_default(),
4775 cleaned_by_watermark: cleaned_by_watermark__.unwrap_or_default(),
4776 })
4777 }
4778 }
4779 deserializer.deserialize_struct("stream_plan.DynamicFilterNode", FIELDS, GeneratedVisitor)
4780 }
4781}
4782impl serde::Serialize for EowcGapFillNode {
4783 #[allow(deprecated)]
4784 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4785 where
4786 S: serde::Serializer,
4787 {
4788 use serde::ser::SerializeStruct;
4789 let mut len = 0;
4790 if self.time_column_index != 0 {
4791 len += 1;
4792 }
4793 if self.interval.is_some() {
4794 len += 1;
4795 }
4796 if !self.fill_columns.is_empty() {
4797 len += 1;
4798 }
4799 if !self.fill_strategies.is_empty() {
4800 len += 1;
4801 }
4802 if self.prev_row_table.is_some() {
4803 len += 1;
4804 }
4805 if !self.partition_by_indices.is_empty() {
4806 len += 1;
4807 }
4808 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcGapFillNode", len)?;
4809 if self.time_column_index != 0 {
4810 struct_ser.serialize_field("timeColumnIndex", &self.time_column_index)?;
4811 }
4812 if let Some(v) = self.interval.as_ref() {
4813 struct_ser.serialize_field("interval", v)?;
4814 }
4815 if !self.fill_columns.is_empty() {
4816 struct_ser.serialize_field("fillColumns", &self.fill_columns)?;
4817 }
4818 if !self.fill_strategies.is_empty() {
4819 struct_ser.serialize_field("fillStrategies", &self.fill_strategies)?;
4820 }
4821 if let Some(v) = self.prev_row_table.as_ref() {
4822 struct_ser.serialize_field("prevRowTable", v)?;
4823 }
4824 if !self.partition_by_indices.is_empty() {
4825 struct_ser.serialize_field("partitionByIndices", &self.partition_by_indices)?;
4826 }
4827 struct_ser.end()
4828 }
4829}
4830impl<'de> serde::Deserialize<'de> for EowcGapFillNode {
4831 #[allow(deprecated)]
4832 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4833 where
4834 D: serde::Deserializer<'de>,
4835 {
4836 const FIELDS: &[&str] = &[
4837 "time_column_index",
4838 "timeColumnIndex",
4839 "interval",
4840 "fill_columns",
4841 "fillColumns",
4842 "fill_strategies",
4843 "fillStrategies",
4844 "prev_row_table",
4845 "prevRowTable",
4846 "partition_by_indices",
4847 "partitionByIndices",
4848 ];
4849
4850 #[allow(clippy::enum_variant_names)]
4851 enum GeneratedField {
4852 TimeColumnIndex,
4853 Interval,
4854 FillColumns,
4855 FillStrategies,
4856 PrevRowTable,
4857 PartitionByIndices,
4858 }
4859 impl<'de> serde::Deserialize<'de> for GeneratedField {
4860 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4861 where
4862 D: serde::Deserializer<'de>,
4863 {
4864 struct GeneratedVisitor;
4865
4866 impl serde::de::Visitor<'_> for GeneratedVisitor {
4867 type Value = GeneratedField;
4868
4869 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4870 write!(formatter, "expected one of: {:?}", &FIELDS)
4871 }
4872
4873 #[allow(unused_variables)]
4874 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4875 where
4876 E: serde::de::Error,
4877 {
4878 match value {
4879 "timeColumnIndex" | "time_column_index" => Ok(GeneratedField::TimeColumnIndex),
4880 "interval" => Ok(GeneratedField::Interval),
4881 "fillColumns" | "fill_columns" => Ok(GeneratedField::FillColumns),
4882 "fillStrategies" | "fill_strategies" => Ok(GeneratedField::FillStrategies),
4883 "prevRowTable" | "prev_row_table" => Ok(GeneratedField::PrevRowTable),
4884 "partitionByIndices" | "partition_by_indices" => Ok(GeneratedField::PartitionByIndices),
4885 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4886 }
4887 }
4888 }
4889 deserializer.deserialize_identifier(GeneratedVisitor)
4890 }
4891 }
4892 struct GeneratedVisitor;
4893 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4894 type Value = EowcGapFillNode;
4895
4896 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4897 formatter.write_str("struct stream_plan.EowcGapFillNode")
4898 }
4899
4900 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcGapFillNode, V::Error>
4901 where
4902 V: serde::de::MapAccess<'de>,
4903 {
4904 let mut time_column_index__ = None;
4905 let mut interval__ = None;
4906 let mut fill_columns__ = None;
4907 let mut fill_strategies__ = None;
4908 let mut prev_row_table__ = None;
4909 let mut partition_by_indices__ = None;
4910 while let Some(k) = map_.next_key()? {
4911 match k {
4912 GeneratedField::TimeColumnIndex => {
4913 if time_column_index__.is_some() {
4914 return Err(serde::de::Error::duplicate_field("timeColumnIndex"));
4915 }
4916 time_column_index__ =
4917 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4918 ;
4919 }
4920 GeneratedField::Interval => {
4921 if interval__.is_some() {
4922 return Err(serde::de::Error::duplicate_field("interval"));
4923 }
4924 interval__ = map_.next_value()?;
4925 }
4926 GeneratedField::FillColumns => {
4927 if fill_columns__.is_some() {
4928 return Err(serde::de::Error::duplicate_field("fillColumns"));
4929 }
4930 fill_columns__ =
4931 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4932 .into_iter().map(|x| x.0).collect())
4933 ;
4934 }
4935 GeneratedField::FillStrategies => {
4936 if fill_strategies__.is_some() {
4937 return Err(serde::de::Error::duplicate_field("fillStrategies"));
4938 }
4939 fill_strategies__ = Some(map_.next_value()?);
4940 }
4941 GeneratedField::PrevRowTable => {
4942 if prev_row_table__.is_some() {
4943 return Err(serde::de::Error::duplicate_field("prevRowTable"));
4944 }
4945 prev_row_table__ = map_.next_value()?;
4946 }
4947 GeneratedField::PartitionByIndices => {
4948 if partition_by_indices__.is_some() {
4949 return Err(serde::de::Error::duplicate_field("partitionByIndices"));
4950 }
4951 partition_by_indices__ =
4952 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4953 .into_iter().map(|x| x.0).collect())
4954 ;
4955 }
4956 }
4957 }
4958 Ok(EowcGapFillNode {
4959 time_column_index: time_column_index__.unwrap_or_default(),
4960 interval: interval__,
4961 fill_columns: fill_columns__.unwrap_or_default(),
4962 fill_strategies: fill_strategies__.unwrap_or_default(),
4963 prev_row_table: prev_row_table__,
4964 partition_by_indices: partition_by_indices__.unwrap_or_default(),
4965 })
4966 }
4967 }
4968 deserializer.deserialize_struct("stream_plan.EowcGapFillNode", FIELDS, GeneratedVisitor)
4969 }
4970}
4971impl serde::Serialize for EowcOverWindowNode {
4972 #[allow(deprecated)]
4973 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4974 where
4975 S: serde::Serializer,
4976 {
4977 use serde::ser::SerializeStruct;
4978 let mut len = 0;
4979 if !self.calls.is_empty() {
4980 len += 1;
4981 }
4982 if !self.partition_by.is_empty() {
4983 len += 1;
4984 }
4985 if !self.order_by.is_empty() {
4986 len += 1;
4987 }
4988 if self.state_table.is_some() {
4989 len += 1;
4990 }
4991 if self.intermediate_state_table.is_some() {
4992 len += 1;
4993 }
4994 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcOverWindowNode", len)?;
4995 if !self.calls.is_empty() {
4996 struct_ser.serialize_field("calls", &self.calls)?;
4997 }
4998 if !self.partition_by.is_empty() {
4999 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
5000 }
5001 if !self.order_by.is_empty() {
5002 struct_ser.serialize_field("orderBy", &self.order_by)?;
5003 }
5004 if let Some(v) = self.state_table.as_ref() {
5005 struct_ser.serialize_field("stateTable", v)?;
5006 }
5007 if let Some(v) = self.intermediate_state_table.as_ref() {
5008 struct_ser.serialize_field("intermediateStateTable", v)?;
5009 }
5010 struct_ser.end()
5011 }
5012}
5013impl<'de> serde::Deserialize<'de> for EowcOverWindowNode {
5014 #[allow(deprecated)]
5015 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5016 where
5017 D: serde::Deserializer<'de>,
5018 {
5019 const FIELDS: &[&str] = &[
5020 "calls",
5021 "partition_by",
5022 "partitionBy",
5023 "order_by",
5024 "orderBy",
5025 "state_table",
5026 "stateTable",
5027 "intermediate_state_table",
5028 "intermediateStateTable",
5029 ];
5030
5031 #[allow(clippy::enum_variant_names)]
5032 enum GeneratedField {
5033 Calls,
5034 PartitionBy,
5035 OrderBy,
5036 StateTable,
5037 IntermediateStateTable,
5038 }
5039 impl<'de> serde::Deserialize<'de> for GeneratedField {
5040 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5041 where
5042 D: serde::Deserializer<'de>,
5043 {
5044 struct GeneratedVisitor;
5045
5046 impl serde::de::Visitor<'_> for GeneratedVisitor {
5047 type Value = GeneratedField;
5048
5049 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5050 write!(formatter, "expected one of: {:?}", &FIELDS)
5051 }
5052
5053 #[allow(unused_variables)]
5054 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5055 where
5056 E: serde::de::Error,
5057 {
5058 match value {
5059 "calls" => Ok(GeneratedField::Calls),
5060 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
5061 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
5062 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
5063 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
5064 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5065 }
5066 }
5067 }
5068 deserializer.deserialize_identifier(GeneratedVisitor)
5069 }
5070 }
5071 struct GeneratedVisitor;
5072 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5073 type Value = EowcOverWindowNode;
5074
5075 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5076 formatter.write_str("struct stream_plan.EowcOverWindowNode")
5077 }
5078
5079 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcOverWindowNode, V::Error>
5080 where
5081 V: serde::de::MapAccess<'de>,
5082 {
5083 let mut calls__ = None;
5084 let mut partition_by__ = None;
5085 let mut order_by__ = None;
5086 let mut state_table__ = None;
5087 let mut intermediate_state_table__ = None;
5088 while let Some(k) = map_.next_key()? {
5089 match k {
5090 GeneratedField::Calls => {
5091 if calls__.is_some() {
5092 return Err(serde::de::Error::duplicate_field("calls"));
5093 }
5094 calls__ = Some(map_.next_value()?);
5095 }
5096 GeneratedField::PartitionBy => {
5097 if partition_by__.is_some() {
5098 return Err(serde::de::Error::duplicate_field("partitionBy"));
5099 }
5100 partition_by__ =
5101 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5102 .into_iter().map(|x| x.0).collect())
5103 ;
5104 }
5105 GeneratedField::OrderBy => {
5106 if order_by__.is_some() {
5107 return Err(serde::de::Error::duplicate_field("orderBy"));
5108 }
5109 order_by__ = Some(map_.next_value()?);
5110 }
5111 GeneratedField::StateTable => {
5112 if state_table__.is_some() {
5113 return Err(serde::de::Error::duplicate_field("stateTable"));
5114 }
5115 state_table__ = map_.next_value()?;
5116 }
5117 GeneratedField::IntermediateStateTable => {
5118 if intermediate_state_table__.is_some() {
5119 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
5120 }
5121 intermediate_state_table__ = map_.next_value()?;
5122 }
5123 }
5124 }
5125 Ok(EowcOverWindowNode {
5126 calls: calls__.unwrap_or_default(),
5127 partition_by: partition_by__.unwrap_or_default(),
5128 order_by: order_by__.unwrap_or_default(),
5129 state_table: state_table__,
5130 intermediate_state_table: intermediate_state_table__,
5131 })
5132 }
5133 }
5134 deserializer.deserialize_struct("stream_plan.EowcOverWindowNode", FIELDS, GeneratedVisitor)
5135 }
5136}
5137impl serde::Serialize for ExchangeNode {
5138 #[allow(deprecated)]
5139 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5140 where
5141 S: serde::Serializer,
5142 {
5143 use serde::ser::SerializeStruct;
5144 let mut len = 0;
5145 if self.strategy.is_some() {
5146 len += 1;
5147 }
5148 let mut struct_ser = serializer.serialize_struct("stream_plan.ExchangeNode", len)?;
5149 if let Some(v) = self.strategy.as_ref() {
5150 struct_ser.serialize_field("strategy", v)?;
5151 }
5152 struct_ser.end()
5153 }
5154}
5155impl<'de> serde::Deserialize<'de> for ExchangeNode {
5156 #[allow(deprecated)]
5157 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5158 where
5159 D: serde::Deserializer<'de>,
5160 {
5161 const FIELDS: &[&str] = &[
5162 "strategy",
5163 ];
5164
5165 #[allow(clippy::enum_variant_names)]
5166 enum GeneratedField {
5167 Strategy,
5168 }
5169 impl<'de> serde::Deserialize<'de> for GeneratedField {
5170 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5171 where
5172 D: serde::Deserializer<'de>,
5173 {
5174 struct GeneratedVisitor;
5175
5176 impl serde::de::Visitor<'_> for GeneratedVisitor {
5177 type Value = GeneratedField;
5178
5179 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5180 write!(formatter, "expected one of: {:?}", &FIELDS)
5181 }
5182
5183 #[allow(unused_variables)]
5184 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5185 where
5186 E: serde::de::Error,
5187 {
5188 match value {
5189 "strategy" => Ok(GeneratedField::Strategy),
5190 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5191 }
5192 }
5193 }
5194 deserializer.deserialize_identifier(GeneratedVisitor)
5195 }
5196 }
5197 struct GeneratedVisitor;
5198 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5199 type Value = ExchangeNode;
5200
5201 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5202 formatter.write_str("struct stream_plan.ExchangeNode")
5203 }
5204
5205 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExchangeNode, V::Error>
5206 where
5207 V: serde::de::MapAccess<'de>,
5208 {
5209 let mut strategy__ = None;
5210 while let Some(k) = map_.next_key()? {
5211 match k {
5212 GeneratedField::Strategy => {
5213 if strategy__.is_some() {
5214 return Err(serde::de::Error::duplicate_field("strategy"));
5215 }
5216 strategy__ = map_.next_value()?;
5217 }
5218 }
5219 }
5220 Ok(ExchangeNode {
5221 strategy: strategy__,
5222 })
5223 }
5224 }
5225 deserializer.deserialize_struct("stream_plan.ExchangeNode", FIELDS, GeneratedVisitor)
5226 }
5227}
5228impl serde::Serialize for ExpandNode {
5229 #[allow(deprecated)]
5230 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5231 where
5232 S: serde::Serializer,
5233 {
5234 use serde::ser::SerializeStruct;
5235 let mut len = 0;
5236 if !self.column_subsets.is_empty() {
5237 len += 1;
5238 }
5239 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode", len)?;
5240 if !self.column_subsets.is_empty() {
5241 struct_ser.serialize_field("columnSubsets", &self.column_subsets)?;
5242 }
5243 struct_ser.end()
5244 }
5245}
5246impl<'de> serde::Deserialize<'de> for ExpandNode {
5247 #[allow(deprecated)]
5248 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5249 where
5250 D: serde::Deserializer<'de>,
5251 {
5252 const FIELDS: &[&str] = &[
5253 "column_subsets",
5254 "columnSubsets",
5255 ];
5256
5257 #[allow(clippy::enum_variant_names)]
5258 enum GeneratedField {
5259 ColumnSubsets,
5260 }
5261 impl<'de> serde::Deserialize<'de> for GeneratedField {
5262 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5263 where
5264 D: serde::Deserializer<'de>,
5265 {
5266 struct GeneratedVisitor;
5267
5268 impl serde::de::Visitor<'_> for GeneratedVisitor {
5269 type Value = GeneratedField;
5270
5271 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5272 write!(formatter, "expected one of: {:?}", &FIELDS)
5273 }
5274
5275 #[allow(unused_variables)]
5276 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5277 where
5278 E: serde::de::Error,
5279 {
5280 match value {
5281 "columnSubsets" | "column_subsets" => Ok(GeneratedField::ColumnSubsets),
5282 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5283 }
5284 }
5285 }
5286 deserializer.deserialize_identifier(GeneratedVisitor)
5287 }
5288 }
5289 struct GeneratedVisitor;
5290 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5291 type Value = ExpandNode;
5292
5293 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5294 formatter.write_str("struct stream_plan.ExpandNode")
5295 }
5296
5297 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpandNode, V::Error>
5298 where
5299 V: serde::de::MapAccess<'de>,
5300 {
5301 let mut column_subsets__ = None;
5302 while let Some(k) = map_.next_key()? {
5303 match k {
5304 GeneratedField::ColumnSubsets => {
5305 if column_subsets__.is_some() {
5306 return Err(serde::de::Error::duplicate_field("columnSubsets"));
5307 }
5308 column_subsets__ = Some(map_.next_value()?);
5309 }
5310 }
5311 }
5312 Ok(ExpandNode {
5313 column_subsets: column_subsets__.unwrap_or_default(),
5314 })
5315 }
5316 }
5317 deserializer.deserialize_struct("stream_plan.ExpandNode", FIELDS, GeneratedVisitor)
5318 }
5319}
5320impl serde::Serialize for expand_node::Subset {
5321 #[allow(deprecated)]
5322 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5323 where
5324 S: serde::Serializer,
5325 {
5326 use serde::ser::SerializeStruct;
5327 let mut len = 0;
5328 if !self.column_indices.is_empty() {
5329 len += 1;
5330 }
5331 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode.Subset", len)?;
5332 if !self.column_indices.is_empty() {
5333 struct_ser.serialize_field("columnIndices", &self.column_indices)?;
5334 }
5335 struct_ser.end()
5336 }
5337}
5338impl<'de> serde::Deserialize<'de> for expand_node::Subset {
5339 #[allow(deprecated)]
5340 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5341 where
5342 D: serde::Deserializer<'de>,
5343 {
5344 const FIELDS: &[&str] = &[
5345 "column_indices",
5346 "columnIndices",
5347 ];
5348
5349 #[allow(clippy::enum_variant_names)]
5350 enum GeneratedField {
5351 ColumnIndices,
5352 }
5353 impl<'de> serde::Deserialize<'de> for GeneratedField {
5354 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5355 where
5356 D: serde::Deserializer<'de>,
5357 {
5358 struct GeneratedVisitor;
5359
5360 impl serde::de::Visitor<'_> for GeneratedVisitor {
5361 type Value = GeneratedField;
5362
5363 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5364 write!(formatter, "expected one of: {:?}", &FIELDS)
5365 }
5366
5367 #[allow(unused_variables)]
5368 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5369 where
5370 E: serde::de::Error,
5371 {
5372 match value {
5373 "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
5374 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5375 }
5376 }
5377 }
5378 deserializer.deserialize_identifier(GeneratedVisitor)
5379 }
5380 }
5381 struct GeneratedVisitor;
5382 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5383 type Value = expand_node::Subset;
5384
5385 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5386 formatter.write_str("struct stream_plan.ExpandNode.Subset")
5387 }
5388
5389 fn visit_map<V>(self, mut map_: V) -> std::result::Result<expand_node::Subset, V::Error>
5390 where
5391 V: serde::de::MapAccess<'de>,
5392 {
5393 let mut column_indices__ = None;
5394 while let Some(k) = map_.next_key()? {
5395 match k {
5396 GeneratedField::ColumnIndices => {
5397 if column_indices__.is_some() {
5398 return Err(serde::de::Error::duplicate_field("columnIndices"));
5399 }
5400 column_indices__ =
5401 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5402 .into_iter().map(|x| x.0).collect())
5403 ;
5404 }
5405 }
5406 }
5407 Ok(expand_node::Subset {
5408 column_indices: column_indices__.unwrap_or_default(),
5409 })
5410 }
5411 }
5412 deserializer.deserialize_struct("stream_plan.ExpandNode.Subset", FIELDS, GeneratedVisitor)
5413 }
5414}
5415impl serde::Serialize for FilterNode {
5416 #[allow(deprecated)]
5417 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5418 where
5419 S: serde::Serializer,
5420 {
5421 use serde::ser::SerializeStruct;
5422 let mut len = 0;
5423 if self.search_condition.is_some() {
5424 len += 1;
5425 }
5426 let mut struct_ser = serializer.serialize_struct("stream_plan.FilterNode", len)?;
5427 if let Some(v) = self.search_condition.as_ref() {
5428 struct_ser.serialize_field("searchCondition", v)?;
5429 }
5430 struct_ser.end()
5431 }
5432}
5433impl<'de> serde::Deserialize<'de> for FilterNode {
5434 #[allow(deprecated)]
5435 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5436 where
5437 D: serde::Deserializer<'de>,
5438 {
5439 const FIELDS: &[&str] = &[
5440 "search_condition",
5441 "searchCondition",
5442 ];
5443
5444 #[allow(clippy::enum_variant_names)]
5445 enum GeneratedField {
5446 SearchCondition,
5447 }
5448 impl<'de> serde::Deserialize<'de> for GeneratedField {
5449 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5450 where
5451 D: serde::Deserializer<'de>,
5452 {
5453 struct GeneratedVisitor;
5454
5455 impl serde::de::Visitor<'_> for GeneratedVisitor {
5456 type Value = GeneratedField;
5457
5458 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5459 write!(formatter, "expected one of: {:?}", &FIELDS)
5460 }
5461
5462 #[allow(unused_variables)]
5463 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5464 where
5465 E: serde::de::Error,
5466 {
5467 match value {
5468 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
5469 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5470 }
5471 }
5472 }
5473 deserializer.deserialize_identifier(GeneratedVisitor)
5474 }
5475 }
5476 struct GeneratedVisitor;
5477 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5478 type Value = FilterNode;
5479
5480 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5481 formatter.write_str("struct stream_plan.FilterNode")
5482 }
5483
5484 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FilterNode, V::Error>
5485 where
5486 V: serde::de::MapAccess<'de>,
5487 {
5488 let mut search_condition__ = None;
5489 while let Some(k) = map_.next_key()? {
5490 match k {
5491 GeneratedField::SearchCondition => {
5492 if search_condition__.is_some() {
5493 return Err(serde::de::Error::duplicate_field("searchCondition"));
5494 }
5495 search_condition__ = map_.next_value()?;
5496 }
5497 }
5498 }
5499 Ok(FilterNode {
5500 search_condition: search_condition__,
5501 })
5502 }
5503 }
5504 deserializer.deserialize_struct("stream_plan.FilterNode", FIELDS, GeneratedVisitor)
5505 }
5506}
5507impl serde::Serialize for GapFillNode {
5508 #[allow(deprecated)]
5509 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5510 where
5511 S: serde::Serializer,
5512 {
5513 use serde::ser::SerializeStruct;
5514 let mut len = 0;
5515 if self.time_column_index != 0 {
5516 len += 1;
5517 }
5518 if self.interval.is_some() {
5519 len += 1;
5520 }
5521 if !self.fill_columns.is_empty() {
5522 len += 1;
5523 }
5524 if !self.fill_strategies.is_empty() {
5525 len += 1;
5526 }
5527 if self.state_table.is_some() {
5528 len += 1;
5529 }
5530 if !self.partition_by_indices.is_empty() {
5531 len += 1;
5532 }
5533 if !self.pointer_key_indices.is_empty() {
5534 len += 1;
5535 }
5536 let mut struct_ser = serializer.serialize_struct("stream_plan.GapFillNode", len)?;
5537 if self.time_column_index != 0 {
5538 struct_ser.serialize_field("timeColumnIndex", &self.time_column_index)?;
5539 }
5540 if let Some(v) = self.interval.as_ref() {
5541 struct_ser.serialize_field("interval", v)?;
5542 }
5543 if !self.fill_columns.is_empty() {
5544 struct_ser.serialize_field("fillColumns", &self.fill_columns)?;
5545 }
5546 if !self.fill_strategies.is_empty() {
5547 struct_ser.serialize_field("fillStrategies", &self.fill_strategies)?;
5548 }
5549 if let Some(v) = self.state_table.as_ref() {
5550 struct_ser.serialize_field("stateTable", v)?;
5551 }
5552 if !self.partition_by_indices.is_empty() {
5553 struct_ser.serialize_field("partitionByIndices", &self.partition_by_indices)?;
5554 }
5555 if !self.pointer_key_indices.is_empty() {
5556 struct_ser.serialize_field("pointerKeyIndices", &self.pointer_key_indices)?;
5557 }
5558 struct_ser.end()
5559 }
5560}
5561impl<'de> serde::Deserialize<'de> for GapFillNode {
5562 #[allow(deprecated)]
5563 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5564 where
5565 D: serde::Deserializer<'de>,
5566 {
5567 const FIELDS: &[&str] = &[
5568 "time_column_index",
5569 "timeColumnIndex",
5570 "interval",
5571 "fill_columns",
5572 "fillColumns",
5573 "fill_strategies",
5574 "fillStrategies",
5575 "state_table",
5576 "stateTable",
5577 "partition_by_indices",
5578 "partitionByIndices",
5579 "pointer_key_indices",
5580 "pointerKeyIndices",
5581 ];
5582
5583 #[allow(clippy::enum_variant_names)]
5584 enum GeneratedField {
5585 TimeColumnIndex,
5586 Interval,
5587 FillColumns,
5588 FillStrategies,
5589 StateTable,
5590 PartitionByIndices,
5591 PointerKeyIndices,
5592 }
5593 impl<'de> serde::Deserialize<'de> for GeneratedField {
5594 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5595 where
5596 D: serde::Deserializer<'de>,
5597 {
5598 struct GeneratedVisitor;
5599
5600 impl serde::de::Visitor<'_> for GeneratedVisitor {
5601 type Value = GeneratedField;
5602
5603 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5604 write!(formatter, "expected one of: {:?}", &FIELDS)
5605 }
5606
5607 #[allow(unused_variables)]
5608 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5609 where
5610 E: serde::de::Error,
5611 {
5612 match value {
5613 "timeColumnIndex" | "time_column_index" => Ok(GeneratedField::TimeColumnIndex),
5614 "interval" => Ok(GeneratedField::Interval),
5615 "fillColumns" | "fill_columns" => Ok(GeneratedField::FillColumns),
5616 "fillStrategies" | "fill_strategies" => Ok(GeneratedField::FillStrategies),
5617 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
5618 "partitionByIndices" | "partition_by_indices" => Ok(GeneratedField::PartitionByIndices),
5619 "pointerKeyIndices" | "pointer_key_indices" => Ok(GeneratedField::PointerKeyIndices),
5620 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5621 }
5622 }
5623 }
5624 deserializer.deserialize_identifier(GeneratedVisitor)
5625 }
5626 }
5627 struct GeneratedVisitor;
5628 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5629 type Value = GapFillNode;
5630
5631 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5632 formatter.write_str("struct stream_plan.GapFillNode")
5633 }
5634
5635 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GapFillNode, V::Error>
5636 where
5637 V: serde::de::MapAccess<'de>,
5638 {
5639 let mut time_column_index__ = None;
5640 let mut interval__ = None;
5641 let mut fill_columns__ = None;
5642 let mut fill_strategies__ = None;
5643 let mut state_table__ = None;
5644 let mut partition_by_indices__ = None;
5645 let mut pointer_key_indices__ = None;
5646 while let Some(k) = map_.next_key()? {
5647 match k {
5648 GeneratedField::TimeColumnIndex => {
5649 if time_column_index__.is_some() {
5650 return Err(serde::de::Error::duplicate_field("timeColumnIndex"));
5651 }
5652 time_column_index__ =
5653 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5654 ;
5655 }
5656 GeneratedField::Interval => {
5657 if interval__.is_some() {
5658 return Err(serde::de::Error::duplicate_field("interval"));
5659 }
5660 interval__ = map_.next_value()?;
5661 }
5662 GeneratedField::FillColumns => {
5663 if fill_columns__.is_some() {
5664 return Err(serde::de::Error::duplicate_field("fillColumns"));
5665 }
5666 fill_columns__ =
5667 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5668 .into_iter().map(|x| x.0).collect())
5669 ;
5670 }
5671 GeneratedField::FillStrategies => {
5672 if fill_strategies__.is_some() {
5673 return Err(serde::de::Error::duplicate_field("fillStrategies"));
5674 }
5675 fill_strategies__ = Some(map_.next_value()?);
5676 }
5677 GeneratedField::StateTable => {
5678 if state_table__.is_some() {
5679 return Err(serde::de::Error::duplicate_field("stateTable"));
5680 }
5681 state_table__ = map_.next_value()?;
5682 }
5683 GeneratedField::PartitionByIndices => {
5684 if partition_by_indices__.is_some() {
5685 return Err(serde::de::Error::duplicate_field("partitionByIndices"));
5686 }
5687 partition_by_indices__ =
5688 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5689 .into_iter().map(|x| x.0).collect())
5690 ;
5691 }
5692 GeneratedField::PointerKeyIndices => {
5693 if pointer_key_indices__.is_some() {
5694 return Err(serde::de::Error::duplicate_field("pointerKeyIndices"));
5695 }
5696 pointer_key_indices__ =
5697 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5698 .into_iter().map(|x| x.0).collect())
5699 ;
5700 }
5701 }
5702 }
5703 Ok(GapFillNode {
5704 time_column_index: time_column_index__.unwrap_or_default(),
5705 interval: interval__,
5706 fill_columns: fill_columns__.unwrap_or_default(),
5707 fill_strategies: fill_strategies__.unwrap_or_default(),
5708 state_table: state_table__,
5709 partition_by_indices: partition_by_indices__.unwrap_or_default(),
5710 pointer_key_indices: pointer_key_indices__.unwrap_or_default(),
5711 })
5712 }
5713 }
5714 deserializer.deserialize_struct("stream_plan.GapFillNode", FIELDS, GeneratedVisitor)
5715 }
5716}
5717impl serde::Serialize for GlobalApproxPercentileNode {
5718 #[allow(deprecated)]
5719 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5720 where
5721 S: serde::Serializer,
5722 {
5723 use serde::ser::SerializeStruct;
5724 let mut len = 0;
5725 if self.base != 0. {
5726 len += 1;
5727 }
5728 if self.quantile != 0. {
5729 len += 1;
5730 }
5731 if self.bucket_state_table.is_some() {
5732 len += 1;
5733 }
5734 if self.count_state_table.is_some() {
5735 len += 1;
5736 }
5737 let mut struct_ser = serializer.serialize_struct("stream_plan.GlobalApproxPercentileNode", len)?;
5738 if self.base != 0. {
5739 struct_ser.serialize_field("base", &self.base)?;
5740 }
5741 if self.quantile != 0. {
5742 struct_ser.serialize_field("quantile", &self.quantile)?;
5743 }
5744 if let Some(v) = self.bucket_state_table.as_ref() {
5745 struct_ser.serialize_field("bucketStateTable", v)?;
5746 }
5747 if let Some(v) = self.count_state_table.as_ref() {
5748 struct_ser.serialize_field("countStateTable", v)?;
5749 }
5750 struct_ser.end()
5751 }
5752}
5753impl<'de> serde::Deserialize<'de> for GlobalApproxPercentileNode {
5754 #[allow(deprecated)]
5755 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5756 where
5757 D: serde::Deserializer<'de>,
5758 {
5759 const FIELDS: &[&str] = &[
5760 "base",
5761 "quantile",
5762 "bucket_state_table",
5763 "bucketStateTable",
5764 "count_state_table",
5765 "countStateTable",
5766 ];
5767
5768 #[allow(clippy::enum_variant_names)]
5769 enum GeneratedField {
5770 Base,
5771 Quantile,
5772 BucketStateTable,
5773 CountStateTable,
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 "base" => Ok(GeneratedField::Base),
5796 "quantile" => Ok(GeneratedField::Quantile),
5797 "bucketStateTable" | "bucket_state_table" => Ok(GeneratedField::BucketStateTable),
5798 "countStateTable" | "count_state_table" => Ok(GeneratedField::CountStateTable),
5799 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5800 }
5801 }
5802 }
5803 deserializer.deserialize_identifier(GeneratedVisitor)
5804 }
5805 }
5806 struct GeneratedVisitor;
5807 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5808 type Value = GlobalApproxPercentileNode;
5809
5810 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5811 formatter.write_str("struct stream_plan.GlobalApproxPercentileNode")
5812 }
5813
5814 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GlobalApproxPercentileNode, V::Error>
5815 where
5816 V: serde::de::MapAccess<'de>,
5817 {
5818 let mut base__ = None;
5819 let mut quantile__ = None;
5820 let mut bucket_state_table__ = None;
5821 let mut count_state_table__ = None;
5822 while let Some(k) = map_.next_key()? {
5823 match k {
5824 GeneratedField::Base => {
5825 if base__.is_some() {
5826 return Err(serde::de::Error::duplicate_field("base"));
5827 }
5828 base__ =
5829 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5830 ;
5831 }
5832 GeneratedField::Quantile => {
5833 if quantile__.is_some() {
5834 return Err(serde::de::Error::duplicate_field("quantile"));
5835 }
5836 quantile__ =
5837 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5838 ;
5839 }
5840 GeneratedField::BucketStateTable => {
5841 if bucket_state_table__.is_some() {
5842 return Err(serde::de::Error::duplicate_field("bucketStateTable"));
5843 }
5844 bucket_state_table__ = map_.next_value()?;
5845 }
5846 GeneratedField::CountStateTable => {
5847 if count_state_table__.is_some() {
5848 return Err(serde::de::Error::duplicate_field("countStateTable"));
5849 }
5850 count_state_table__ = map_.next_value()?;
5851 }
5852 }
5853 }
5854 Ok(GlobalApproxPercentileNode {
5855 base: base__.unwrap_or_default(),
5856 quantile: quantile__.unwrap_or_default(),
5857 bucket_state_table: bucket_state_table__,
5858 count_state_table: count_state_table__,
5859 })
5860 }
5861 }
5862 deserializer.deserialize_struct("stream_plan.GlobalApproxPercentileNode", FIELDS, GeneratedVisitor)
5863 }
5864}
5865impl serde::Serialize for GroupTopNNode {
5866 #[allow(deprecated)]
5867 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5868 where
5869 S: serde::Serializer,
5870 {
5871 use serde::ser::SerializeStruct;
5872 let mut len = 0;
5873 if self.limit != 0 {
5874 len += 1;
5875 }
5876 if self.offset != 0 {
5877 len += 1;
5878 }
5879 if !self.group_key.is_empty() {
5880 len += 1;
5881 }
5882 if self.table.is_some() {
5883 len += 1;
5884 }
5885 if !self.order_by.is_empty() {
5886 len += 1;
5887 }
5888 if self.with_ties {
5889 len += 1;
5890 }
5891 let mut struct_ser = serializer.serialize_struct("stream_plan.GroupTopNNode", len)?;
5892 if self.limit != 0 {
5893 #[allow(clippy::needless_borrow)]
5894 #[allow(clippy::needless_borrows_for_generic_args)]
5895 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
5896 }
5897 if self.offset != 0 {
5898 #[allow(clippy::needless_borrow)]
5899 #[allow(clippy::needless_borrows_for_generic_args)]
5900 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
5901 }
5902 if !self.group_key.is_empty() {
5903 struct_ser.serialize_field("groupKey", &self.group_key)?;
5904 }
5905 if let Some(v) = self.table.as_ref() {
5906 struct_ser.serialize_field("table", v)?;
5907 }
5908 if !self.order_by.is_empty() {
5909 struct_ser.serialize_field("orderBy", &self.order_by)?;
5910 }
5911 if self.with_ties {
5912 struct_ser.serialize_field("withTies", &self.with_ties)?;
5913 }
5914 struct_ser.end()
5915 }
5916}
5917impl<'de> serde::Deserialize<'de> for GroupTopNNode {
5918 #[allow(deprecated)]
5919 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5920 where
5921 D: serde::Deserializer<'de>,
5922 {
5923 const FIELDS: &[&str] = &[
5924 "limit",
5925 "offset",
5926 "group_key",
5927 "groupKey",
5928 "table",
5929 "order_by",
5930 "orderBy",
5931 "with_ties",
5932 "withTies",
5933 ];
5934
5935 #[allow(clippy::enum_variant_names)]
5936 enum GeneratedField {
5937 Limit,
5938 Offset,
5939 GroupKey,
5940 Table,
5941 OrderBy,
5942 WithTies,
5943 }
5944 impl<'de> serde::Deserialize<'de> for GeneratedField {
5945 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5946 where
5947 D: serde::Deserializer<'de>,
5948 {
5949 struct GeneratedVisitor;
5950
5951 impl serde::de::Visitor<'_> for GeneratedVisitor {
5952 type Value = GeneratedField;
5953
5954 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5955 write!(formatter, "expected one of: {:?}", &FIELDS)
5956 }
5957
5958 #[allow(unused_variables)]
5959 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5960 where
5961 E: serde::de::Error,
5962 {
5963 match value {
5964 "limit" => Ok(GeneratedField::Limit),
5965 "offset" => Ok(GeneratedField::Offset),
5966 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5967 "table" => Ok(GeneratedField::Table),
5968 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
5969 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
5970 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5971 }
5972 }
5973 }
5974 deserializer.deserialize_identifier(GeneratedVisitor)
5975 }
5976 }
5977 struct GeneratedVisitor;
5978 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5979 type Value = GroupTopNNode;
5980
5981 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5982 formatter.write_str("struct stream_plan.GroupTopNNode")
5983 }
5984
5985 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupTopNNode, V::Error>
5986 where
5987 V: serde::de::MapAccess<'de>,
5988 {
5989 let mut limit__ = None;
5990 let mut offset__ = None;
5991 let mut group_key__ = None;
5992 let mut table__ = None;
5993 let mut order_by__ = None;
5994 let mut with_ties__ = None;
5995 while let Some(k) = map_.next_key()? {
5996 match k {
5997 GeneratedField::Limit => {
5998 if limit__.is_some() {
5999 return Err(serde::de::Error::duplicate_field("limit"));
6000 }
6001 limit__ =
6002 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6003 ;
6004 }
6005 GeneratedField::Offset => {
6006 if offset__.is_some() {
6007 return Err(serde::de::Error::duplicate_field("offset"));
6008 }
6009 offset__ =
6010 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6011 ;
6012 }
6013 GeneratedField::GroupKey => {
6014 if group_key__.is_some() {
6015 return Err(serde::de::Error::duplicate_field("groupKey"));
6016 }
6017 group_key__ =
6018 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6019 .into_iter().map(|x| x.0).collect())
6020 ;
6021 }
6022 GeneratedField::Table => {
6023 if table__.is_some() {
6024 return Err(serde::de::Error::duplicate_field("table"));
6025 }
6026 table__ = map_.next_value()?;
6027 }
6028 GeneratedField::OrderBy => {
6029 if order_by__.is_some() {
6030 return Err(serde::de::Error::duplicate_field("orderBy"));
6031 }
6032 order_by__ = Some(map_.next_value()?);
6033 }
6034 GeneratedField::WithTies => {
6035 if with_ties__.is_some() {
6036 return Err(serde::de::Error::duplicate_field("withTies"));
6037 }
6038 with_ties__ = Some(map_.next_value()?);
6039 }
6040 }
6041 }
6042 Ok(GroupTopNNode {
6043 limit: limit__.unwrap_or_default(),
6044 offset: offset__.unwrap_or_default(),
6045 group_key: group_key__.unwrap_or_default(),
6046 table: table__,
6047 order_by: order_by__.unwrap_or_default(),
6048 with_ties: with_ties__.unwrap_or_default(),
6049 })
6050 }
6051 }
6052 deserializer.deserialize_struct("stream_plan.GroupTopNNode", FIELDS, GeneratedVisitor)
6053 }
6054}
6055impl serde::Serialize for HashAggNode {
6056 #[allow(deprecated)]
6057 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6058 where
6059 S: serde::Serializer,
6060 {
6061 use serde::ser::SerializeStruct;
6062 let mut len = 0;
6063 if !self.group_key.is_empty() {
6064 len += 1;
6065 }
6066 if !self.agg_calls.is_empty() {
6067 len += 1;
6068 }
6069 if !self.agg_call_states.is_empty() {
6070 len += 1;
6071 }
6072 if self.intermediate_state_table.is_some() {
6073 len += 1;
6074 }
6075 if self.is_append_only {
6076 len += 1;
6077 }
6078 if !self.distinct_dedup_tables.is_empty() {
6079 len += 1;
6080 }
6081 if self.row_count_index != 0 {
6082 len += 1;
6083 }
6084 if self.emit_on_window_close {
6085 len += 1;
6086 }
6087 if self.version != 0 {
6088 len += 1;
6089 }
6090 let mut struct_ser = serializer.serialize_struct("stream_plan.HashAggNode", len)?;
6091 if !self.group_key.is_empty() {
6092 struct_ser.serialize_field("groupKey", &self.group_key)?;
6093 }
6094 if !self.agg_calls.is_empty() {
6095 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
6096 }
6097 if !self.agg_call_states.is_empty() {
6098 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
6099 }
6100 if let Some(v) = self.intermediate_state_table.as_ref() {
6101 struct_ser.serialize_field("intermediateStateTable", v)?;
6102 }
6103 if self.is_append_only {
6104 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
6105 }
6106 if !self.distinct_dedup_tables.is_empty() {
6107 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
6108 }
6109 if self.row_count_index != 0 {
6110 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
6111 }
6112 if self.emit_on_window_close {
6113 struct_ser.serialize_field("emitOnWindowClose", &self.emit_on_window_close)?;
6114 }
6115 if self.version != 0 {
6116 let v = AggNodeVersion::try_from(self.version)
6117 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
6118 struct_ser.serialize_field("version", &v)?;
6119 }
6120 struct_ser.end()
6121 }
6122}
6123impl<'de> serde::Deserialize<'de> for HashAggNode {
6124 #[allow(deprecated)]
6125 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6126 where
6127 D: serde::Deserializer<'de>,
6128 {
6129 const FIELDS: &[&str] = &[
6130 "group_key",
6131 "groupKey",
6132 "agg_calls",
6133 "aggCalls",
6134 "agg_call_states",
6135 "aggCallStates",
6136 "intermediate_state_table",
6137 "intermediateStateTable",
6138 "is_append_only",
6139 "isAppendOnly",
6140 "distinct_dedup_tables",
6141 "distinctDedupTables",
6142 "row_count_index",
6143 "rowCountIndex",
6144 "emit_on_window_close",
6145 "emitOnWindowClose",
6146 "version",
6147 ];
6148
6149 #[allow(clippy::enum_variant_names)]
6150 enum GeneratedField {
6151 GroupKey,
6152 AggCalls,
6153 AggCallStates,
6154 IntermediateStateTable,
6155 IsAppendOnly,
6156 DistinctDedupTables,
6157 RowCountIndex,
6158 EmitOnWindowClose,
6159 Version,
6160 }
6161 impl<'de> serde::Deserialize<'de> for GeneratedField {
6162 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6163 where
6164 D: serde::Deserializer<'de>,
6165 {
6166 struct GeneratedVisitor;
6167
6168 impl serde::de::Visitor<'_> for GeneratedVisitor {
6169 type Value = GeneratedField;
6170
6171 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6172 write!(formatter, "expected one of: {:?}", &FIELDS)
6173 }
6174
6175 #[allow(unused_variables)]
6176 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6177 where
6178 E: serde::de::Error,
6179 {
6180 match value {
6181 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
6182 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
6183 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
6184 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
6185 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
6186 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
6187 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
6188 "emitOnWindowClose" | "emit_on_window_close" => Ok(GeneratedField::EmitOnWindowClose),
6189 "version" => Ok(GeneratedField::Version),
6190 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6191 }
6192 }
6193 }
6194 deserializer.deserialize_identifier(GeneratedVisitor)
6195 }
6196 }
6197 struct GeneratedVisitor;
6198 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6199 type Value = HashAggNode;
6200
6201 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6202 formatter.write_str("struct stream_plan.HashAggNode")
6203 }
6204
6205 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashAggNode, V::Error>
6206 where
6207 V: serde::de::MapAccess<'de>,
6208 {
6209 let mut group_key__ = None;
6210 let mut agg_calls__ = None;
6211 let mut agg_call_states__ = None;
6212 let mut intermediate_state_table__ = None;
6213 let mut is_append_only__ = None;
6214 let mut distinct_dedup_tables__ = None;
6215 let mut row_count_index__ = None;
6216 let mut emit_on_window_close__ = None;
6217 let mut version__ = None;
6218 while let Some(k) = map_.next_key()? {
6219 match k {
6220 GeneratedField::GroupKey => {
6221 if group_key__.is_some() {
6222 return Err(serde::de::Error::duplicate_field("groupKey"));
6223 }
6224 group_key__ =
6225 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6226 .into_iter().map(|x| x.0).collect())
6227 ;
6228 }
6229 GeneratedField::AggCalls => {
6230 if agg_calls__.is_some() {
6231 return Err(serde::de::Error::duplicate_field("aggCalls"));
6232 }
6233 agg_calls__ = Some(map_.next_value()?);
6234 }
6235 GeneratedField::AggCallStates => {
6236 if agg_call_states__.is_some() {
6237 return Err(serde::de::Error::duplicate_field("aggCallStates"));
6238 }
6239 agg_call_states__ = Some(map_.next_value()?);
6240 }
6241 GeneratedField::IntermediateStateTable => {
6242 if intermediate_state_table__.is_some() {
6243 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
6244 }
6245 intermediate_state_table__ = map_.next_value()?;
6246 }
6247 GeneratedField::IsAppendOnly => {
6248 if is_append_only__.is_some() {
6249 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
6250 }
6251 is_append_only__ = Some(map_.next_value()?);
6252 }
6253 GeneratedField::DistinctDedupTables => {
6254 if distinct_dedup_tables__.is_some() {
6255 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
6256 }
6257 distinct_dedup_tables__ = Some(
6258 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6259 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
6260 );
6261 }
6262 GeneratedField::RowCountIndex => {
6263 if row_count_index__.is_some() {
6264 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
6265 }
6266 row_count_index__ =
6267 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6268 ;
6269 }
6270 GeneratedField::EmitOnWindowClose => {
6271 if emit_on_window_close__.is_some() {
6272 return Err(serde::de::Error::duplicate_field("emitOnWindowClose"));
6273 }
6274 emit_on_window_close__ = Some(map_.next_value()?);
6275 }
6276 GeneratedField::Version => {
6277 if version__.is_some() {
6278 return Err(serde::de::Error::duplicate_field("version"));
6279 }
6280 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
6281 }
6282 }
6283 }
6284 Ok(HashAggNode {
6285 group_key: group_key__.unwrap_or_default(),
6286 agg_calls: agg_calls__.unwrap_or_default(),
6287 agg_call_states: agg_call_states__.unwrap_or_default(),
6288 intermediate_state_table: intermediate_state_table__,
6289 is_append_only: is_append_only__.unwrap_or_default(),
6290 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
6291 row_count_index: row_count_index__.unwrap_or_default(),
6292 emit_on_window_close: emit_on_window_close__.unwrap_or_default(),
6293 version: version__.unwrap_or_default(),
6294 })
6295 }
6296 }
6297 deserializer.deserialize_struct("stream_plan.HashAggNode", FIELDS, GeneratedVisitor)
6298 }
6299}
6300impl serde::Serialize for HashJoinNode {
6301 #[allow(deprecated)]
6302 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6303 where
6304 S: serde::Serializer,
6305 {
6306 use serde::ser::SerializeStruct;
6307 let mut len = 0;
6308 if self.join_type != 0 {
6309 len += 1;
6310 }
6311 if !self.left_key.is_empty() {
6312 len += 1;
6313 }
6314 if !self.right_key.is_empty() {
6315 len += 1;
6316 }
6317 if self.condition.is_some() {
6318 len += 1;
6319 }
6320 if self.left_table.is_some() {
6321 len += 1;
6322 }
6323 if self.right_table.is_some() {
6324 len += 1;
6325 }
6326 if self.left_degree_table.is_some() {
6327 len += 1;
6328 }
6329 if self.right_degree_table.is_some() {
6330 len += 1;
6331 }
6332 if !self.output_indices.is_empty() {
6333 len += 1;
6334 }
6335 if !self.left_deduped_input_pk_indices.is_empty() {
6336 len += 1;
6337 }
6338 if !self.right_deduped_input_pk_indices.is_empty() {
6339 len += 1;
6340 }
6341 if !self.null_safe.is_empty() {
6342 len += 1;
6343 }
6344 if self.is_append_only {
6345 len += 1;
6346 }
6347 if self.join_encoding_type != 0 {
6348 len += 1;
6349 }
6350 if self.watermark_handle_desc.is_some() {
6351 len += 1;
6352 }
6353 let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinNode", len)?;
6354 if self.join_type != 0 {
6355 let v = super::plan_common::JoinType::try_from(self.join_type)
6356 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
6357 struct_ser.serialize_field("joinType", &v)?;
6358 }
6359 if !self.left_key.is_empty() {
6360 struct_ser.serialize_field("leftKey", &self.left_key)?;
6361 }
6362 if !self.right_key.is_empty() {
6363 struct_ser.serialize_field("rightKey", &self.right_key)?;
6364 }
6365 if let Some(v) = self.condition.as_ref() {
6366 struct_ser.serialize_field("condition", v)?;
6367 }
6368 if let Some(v) = self.left_table.as_ref() {
6369 struct_ser.serialize_field("leftTable", v)?;
6370 }
6371 if let Some(v) = self.right_table.as_ref() {
6372 struct_ser.serialize_field("rightTable", v)?;
6373 }
6374 if let Some(v) = self.left_degree_table.as_ref() {
6375 struct_ser.serialize_field("leftDegreeTable", v)?;
6376 }
6377 if let Some(v) = self.right_degree_table.as_ref() {
6378 struct_ser.serialize_field("rightDegreeTable", v)?;
6379 }
6380 if !self.output_indices.is_empty() {
6381 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
6382 }
6383 if !self.left_deduped_input_pk_indices.is_empty() {
6384 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
6385 }
6386 if !self.right_deduped_input_pk_indices.is_empty() {
6387 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
6388 }
6389 if !self.null_safe.is_empty() {
6390 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
6391 }
6392 if self.is_append_only {
6393 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
6394 }
6395 if self.join_encoding_type != 0 {
6396 let v = JoinEncodingType::try_from(self.join_encoding_type)
6397 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
6398 struct_ser.serialize_field("joinEncodingType", &v)?;
6399 }
6400 if let Some(v) = self.watermark_handle_desc.as_ref() {
6401 struct_ser.serialize_field("watermarkHandleDesc", v)?;
6402 }
6403 struct_ser.end()
6404 }
6405}
6406impl<'de> serde::Deserialize<'de> for HashJoinNode {
6407 #[allow(deprecated)]
6408 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6409 where
6410 D: serde::Deserializer<'de>,
6411 {
6412 const FIELDS: &[&str] = &[
6413 "join_type",
6414 "joinType",
6415 "left_key",
6416 "leftKey",
6417 "right_key",
6418 "rightKey",
6419 "condition",
6420 "left_table",
6421 "leftTable",
6422 "right_table",
6423 "rightTable",
6424 "left_degree_table",
6425 "leftDegreeTable",
6426 "right_degree_table",
6427 "rightDegreeTable",
6428 "output_indices",
6429 "outputIndices",
6430 "left_deduped_input_pk_indices",
6431 "leftDedupedInputPkIndices",
6432 "right_deduped_input_pk_indices",
6433 "rightDedupedInputPkIndices",
6434 "null_safe",
6435 "nullSafe",
6436 "is_append_only",
6437 "isAppendOnly",
6438 "join_encoding_type",
6439 "joinEncodingType",
6440 "watermark_handle_desc",
6441 "watermarkHandleDesc",
6442 ];
6443
6444 #[allow(clippy::enum_variant_names)]
6445 enum GeneratedField {
6446 JoinType,
6447 LeftKey,
6448 RightKey,
6449 Condition,
6450 LeftTable,
6451 RightTable,
6452 LeftDegreeTable,
6453 RightDegreeTable,
6454 OutputIndices,
6455 LeftDedupedInputPkIndices,
6456 RightDedupedInputPkIndices,
6457 NullSafe,
6458 IsAppendOnly,
6459 JoinEncodingType,
6460 WatermarkHandleDesc,
6461 }
6462 impl<'de> serde::Deserialize<'de> for GeneratedField {
6463 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6464 where
6465 D: serde::Deserializer<'de>,
6466 {
6467 struct GeneratedVisitor;
6468
6469 impl serde::de::Visitor<'_> for GeneratedVisitor {
6470 type Value = GeneratedField;
6471
6472 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6473 write!(formatter, "expected one of: {:?}", &FIELDS)
6474 }
6475
6476 #[allow(unused_variables)]
6477 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6478 where
6479 E: serde::de::Error,
6480 {
6481 match value {
6482 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
6483 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
6484 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
6485 "condition" => Ok(GeneratedField::Condition),
6486 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
6487 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
6488 "leftDegreeTable" | "left_degree_table" => Ok(GeneratedField::LeftDegreeTable),
6489 "rightDegreeTable" | "right_degree_table" => Ok(GeneratedField::RightDegreeTable),
6490 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
6491 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
6492 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
6493 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
6494 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
6495 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
6496 "watermarkHandleDesc" | "watermark_handle_desc" => Ok(GeneratedField::WatermarkHandleDesc),
6497 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6498 }
6499 }
6500 }
6501 deserializer.deserialize_identifier(GeneratedVisitor)
6502 }
6503 }
6504 struct GeneratedVisitor;
6505 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6506 type Value = HashJoinNode;
6507
6508 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6509 formatter.write_str("struct stream_plan.HashJoinNode")
6510 }
6511
6512 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinNode, V::Error>
6513 where
6514 V: serde::de::MapAccess<'de>,
6515 {
6516 let mut join_type__ = None;
6517 let mut left_key__ = None;
6518 let mut right_key__ = None;
6519 let mut condition__ = None;
6520 let mut left_table__ = None;
6521 let mut right_table__ = None;
6522 let mut left_degree_table__ = None;
6523 let mut right_degree_table__ = None;
6524 let mut output_indices__ = None;
6525 let mut left_deduped_input_pk_indices__ = None;
6526 let mut right_deduped_input_pk_indices__ = None;
6527 let mut null_safe__ = None;
6528 let mut is_append_only__ = None;
6529 let mut join_encoding_type__ = None;
6530 let mut watermark_handle_desc__ = None;
6531 while let Some(k) = map_.next_key()? {
6532 match k {
6533 GeneratedField::JoinType => {
6534 if join_type__.is_some() {
6535 return Err(serde::de::Error::duplicate_field("joinType"));
6536 }
6537 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
6538 }
6539 GeneratedField::LeftKey => {
6540 if left_key__.is_some() {
6541 return Err(serde::de::Error::duplicate_field("leftKey"));
6542 }
6543 left_key__ =
6544 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6545 .into_iter().map(|x| x.0).collect())
6546 ;
6547 }
6548 GeneratedField::RightKey => {
6549 if right_key__.is_some() {
6550 return Err(serde::de::Error::duplicate_field("rightKey"));
6551 }
6552 right_key__ =
6553 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6554 .into_iter().map(|x| x.0).collect())
6555 ;
6556 }
6557 GeneratedField::Condition => {
6558 if condition__.is_some() {
6559 return Err(serde::de::Error::duplicate_field("condition"));
6560 }
6561 condition__ = map_.next_value()?;
6562 }
6563 GeneratedField::LeftTable => {
6564 if left_table__.is_some() {
6565 return Err(serde::de::Error::duplicate_field("leftTable"));
6566 }
6567 left_table__ = map_.next_value()?;
6568 }
6569 GeneratedField::RightTable => {
6570 if right_table__.is_some() {
6571 return Err(serde::de::Error::duplicate_field("rightTable"));
6572 }
6573 right_table__ = map_.next_value()?;
6574 }
6575 GeneratedField::LeftDegreeTable => {
6576 if left_degree_table__.is_some() {
6577 return Err(serde::de::Error::duplicate_field("leftDegreeTable"));
6578 }
6579 left_degree_table__ = map_.next_value()?;
6580 }
6581 GeneratedField::RightDegreeTable => {
6582 if right_degree_table__.is_some() {
6583 return Err(serde::de::Error::duplicate_field("rightDegreeTable"));
6584 }
6585 right_degree_table__ = map_.next_value()?;
6586 }
6587 GeneratedField::OutputIndices => {
6588 if output_indices__.is_some() {
6589 return Err(serde::de::Error::duplicate_field("outputIndices"));
6590 }
6591 output_indices__ =
6592 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6593 .into_iter().map(|x| x.0).collect())
6594 ;
6595 }
6596 GeneratedField::LeftDedupedInputPkIndices => {
6597 if left_deduped_input_pk_indices__.is_some() {
6598 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
6599 }
6600 left_deduped_input_pk_indices__ =
6601 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6602 .into_iter().map(|x| x.0).collect())
6603 ;
6604 }
6605 GeneratedField::RightDedupedInputPkIndices => {
6606 if right_deduped_input_pk_indices__.is_some() {
6607 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
6608 }
6609 right_deduped_input_pk_indices__ =
6610 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6611 .into_iter().map(|x| x.0).collect())
6612 ;
6613 }
6614 GeneratedField::NullSafe => {
6615 if null_safe__.is_some() {
6616 return Err(serde::de::Error::duplicate_field("nullSafe"));
6617 }
6618 null_safe__ = Some(map_.next_value()?);
6619 }
6620 GeneratedField::IsAppendOnly => {
6621 if is_append_only__.is_some() {
6622 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
6623 }
6624 is_append_only__ = Some(map_.next_value()?);
6625 }
6626 GeneratedField::JoinEncodingType => {
6627 if join_encoding_type__.is_some() {
6628 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
6629 }
6630 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
6631 }
6632 GeneratedField::WatermarkHandleDesc => {
6633 if watermark_handle_desc__.is_some() {
6634 return Err(serde::de::Error::duplicate_field("watermarkHandleDesc"));
6635 }
6636 watermark_handle_desc__ = map_.next_value()?;
6637 }
6638 }
6639 }
6640 Ok(HashJoinNode {
6641 join_type: join_type__.unwrap_or_default(),
6642 left_key: left_key__.unwrap_or_default(),
6643 right_key: right_key__.unwrap_or_default(),
6644 condition: condition__,
6645 left_table: left_table__,
6646 right_table: right_table__,
6647 left_degree_table: left_degree_table__,
6648 right_degree_table: right_degree_table__,
6649 output_indices: output_indices__.unwrap_or_default(),
6650 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
6651 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
6652 null_safe: null_safe__.unwrap_or_default(),
6653 is_append_only: is_append_only__.unwrap_or_default(),
6654 join_encoding_type: join_encoding_type__.unwrap_or_default(),
6655 watermark_handle_desc: watermark_handle_desc__,
6656 })
6657 }
6658 }
6659 deserializer.deserialize_struct("stream_plan.HashJoinNode", FIELDS, GeneratedVisitor)
6660 }
6661}
6662impl serde::Serialize for HashJoinWatermarkHandleDesc {
6663 #[allow(deprecated)]
6664 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6665 where
6666 S: serde::Serializer,
6667 {
6668 use serde::ser::SerializeStruct;
6669 let mut len = 0;
6670 if !self.watermark_indices_in_jk.is_empty() {
6671 len += 1;
6672 }
6673 if !self.inequality_pairs.is_empty() {
6674 len += 1;
6675 }
6676 let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinWatermarkHandleDesc", len)?;
6677 if !self.watermark_indices_in_jk.is_empty() {
6678 struct_ser.serialize_field("watermarkIndicesInJk", &self.watermark_indices_in_jk)?;
6679 }
6680 if !self.inequality_pairs.is_empty() {
6681 struct_ser.serialize_field("inequalityPairs", &self.inequality_pairs)?;
6682 }
6683 struct_ser.end()
6684 }
6685}
6686impl<'de> serde::Deserialize<'de> for HashJoinWatermarkHandleDesc {
6687 #[allow(deprecated)]
6688 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6689 where
6690 D: serde::Deserializer<'de>,
6691 {
6692 const FIELDS: &[&str] = &[
6693 "watermark_indices_in_jk",
6694 "watermarkIndicesInJk",
6695 "inequality_pairs",
6696 "inequalityPairs",
6697 ];
6698
6699 #[allow(clippy::enum_variant_names)]
6700 enum GeneratedField {
6701 WatermarkIndicesInJk,
6702 InequalityPairs,
6703 }
6704 impl<'de> serde::Deserialize<'de> for GeneratedField {
6705 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6706 where
6707 D: serde::Deserializer<'de>,
6708 {
6709 struct GeneratedVisitor;
6710
6711 impl serde::de::Visitor<'_> for GeneratedVisitor {
6712 type Value = GeneratedField;
6713
6714 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6715 write!(formatter, "expected one of: {:?}", &FIELDS)
6716 }
6717
6718 #[allow(unused_variables)]
6719 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6720 where
6721 E: serde::de::Error,
6722 {
6723 match value {
6724 "watermarkIndicesInJk" | "watermark_indices_in_jk" => Ok(GeneratedField::WatermarkIndicesInJk),
6725 "inequalityPairs" | "inequality_pairs" => Ok(GeneratedField::InequalityPairs),
6726 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6727 }
6728 }
6729 }
6730 deserializer.deserialize_identifier(GeneratedVisitor)
6731 }
6732 }
6733 struct GeneratedVisitor;
6734 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6735 type Value = HashJoinWatermarkHandleDesc;
6736
6737 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6738 formatter.write_str("struct stream_plan.HashJoinWatermarkHandleDesc")
6739 }
6740
6741 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinWatermarkHandleDesc, V::Error>
6742 where
6743 V: serde::de::MapAccess<'de>,
6744 {
6745 let mut watermark_indices_in_jk__ = None;
6746 let mut inequality_pairs__ = None;
6747 while let Some(k) = map_.next_key()? {
6748 match k {
6749 GeneratedField::WatermarkIndicesInJk => {
6750 if watermark_indices_in_jk__.is_some() {
6751 return Err(serde::de::Error::duplicate_field("watermarkIndicesInJk"));
6752 }
6753 watermark_indices_in_jk__ = Some(map_.next_value()?);
6754 }
6755 GeneratedField::InequalityPairs => {
6756 if inequality_pairs__.is_some() {
6757 return Err(serde::de::Error::duplicate_field("inequalityPairs"));
6758 }
6759 inequality_pairs__ = Some(map_.next_value()?);
6760 }
6761 }
6762 }
6763 Ok(HashJoinWatermarkHandleDesc {
6764 watermark_indices_in_jk: watermark_indices_in_jk__.unwrap_or_default(),
6765 inequality_pairs: inequality_pairs__.unwrap_or_default(),
6766 })
6767 }
6768 }
6769 deserializer.deserialize_struct("stream_plan.HashJoinWatermarkHandleDesc", FIELDS, GeneratedVisitor)
6770 }
6771}
6772impl serde::Serialize for HopWindowNode {
6773 #[allow(deprecated)]
6774 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6775 where
6776 S: serde::Serializer,
6777 {
6778 use serde::ser::SerializeStruct;
6779 let mut len = 0;
6780 if self.time_col != 0 {
6781 len += 1;
6782 }
6783 if self.window_slide.is_some() {
6784 len += 1;
6785 }
6786 if self.window_size.is_some() {
6787 len += 1;
6788 }
6789 if !self.output_indices.is_empty() {
6790 len += 1;
6791 }
6792 if !self.window_start_exprs.is_empty() {
6793 len += 1;
6794 }
6795 if !self.window_end_exprs.is_empty() {
6796 len += 1;
6797 }
6798 let mut struct_ser = serializer.serialize_struct("stream_plan.HopWindowNode", len)?;
6799 if self.time_col != 0 {
6800 struct_ser.serialize_field("timeCol", &self.time_col)?;
6801 }
6802 if let Some(v) = self.window_slide.as_ref() {
6803 struct_ser.serialize_field("windowSlide", v)?;
6804 }
6805 if let Some(v) = self.window_size.as_ref() {
6806 struct_ser.serialize_field("windowSize", v)?;
6807 }
6808 if !self.output_indices.is_empty() {
6809 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
6810 }
6811 if !self.window_start_exprs.is_empty() {
6812 struct_ser.serialize_field("windowStartExprs", &self.window_start_exprs)?;
6813 }
6814 if !self.window_end_exprs.is_empty() {
6815 struct_ser.serialize_field("windowEndExprs", &self.window_end_exprs)?;
6816 }
6817 struct_ser.end()
6818 }
6819}
6820impl<'de> serde::Deserialize<'de> for HopWindowNode {
6821 #[allow(deprecated)]
6822 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6823 where
6824 D: serde::Deserializer<'de>,
6825 {
6826 const FIELDS: &[&str] = &[
6827 "time_col",
6828 "timeCol",
6829 "window_slide",
6830 "windowSlide",
6831 "window_size",
6832 "windowSize",
6833 "output_indices",
6834 "outputIndices",
6835 "window_start_exprs",
6836 "windowStartExprs",
6837 "window_end_exprs",
6838 "windowEndExprs",
6839 ];
6840
6841 #[allow(clippy::enum_variant_names)]
6842 enum GeneratedField {
6843 TimeCol,
6844 WindowSlide,
6845 WindowSize,
6846 OutputIndices,
6847 WindowStartExprs,
6848 WindowEndExprs,
6849 }
6850 impl<'de> serde::Deserialize<'de> for GeneratedField {
6851 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6852 where
6853 D: serde::Deserializer<'de>,
6854 {
6855 struct GeneratedVisitor;
6856
6857 impl serde::de::Visitor<'_> for GeneratedVisitor {
6858 type Value = GeneratedField;
6859
6860 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6861 write!(formatter, "expected one of: {:?}", &FIELDS)
6862 }
6863
6864 #[allow(unused_variables)]
6865 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6866 where
6867 E: serde::de::Error,
6868 {
6869 match value {
6870 "timeCol" | "time_col" => Ok(GeneratedField::TimeCol),
6871 "windowSlide" | "window_slide" => Ok(GeneratedField::WindowSlide),
6872 "windowSize" | "window_size" => Ok(GeneratedField::WindowSize),
6873 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
6874 "windowStartExprs" | "window_start_exprs" => Ok(GeneratedField::WindowStartExprs),
6875 "windowEndExprs" | "window_end_exprs" => Ok(GeneratedField::WindowEndExprs),
6876 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6877 }
6878 }
6879 }
6880 deserializer.deserialize_identifier(GeneratedVisitor)
6881 }
6882 }
6883 struct GeneratedVisitor;
6884 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6885 type Value = HopWindowNode;
6886
6887 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6888 formatter.write_str("struct stream_plan.HopWindowNode")
6889 }
6890
6891 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HopWindowNode, V::Error>
6892 where
6893 V: serde::de::MapAccess<'de>,
6894 {
6895 let mut time_col__ = None;
6896 let mut window_slide__ = None;
6897 let mut window_size__ = None;
6898 let mut output_indices__ = None;
6899 let mut window_start_exprs__ = None;
6900 let mut window_end_exprs__ = None;
6901 while let Some(k) = map_.next_key()? {
6902 match k {
6903 GeneratedField::TimeCol => {
6904 if time_col__.is_some() {
6905 return Err(serde::de::Error::duplicate_field("timeCol"));
6906 }
6907 time_col__ =
6908 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6909 ;
6910 }
6911 GeneratedField::WindowSlide => {
6912 if window_slide__.is_some() {
6913 return Err(serde::de::Error::duplicate_field("windowSlide"));
6914 }
6915 window_slide__ = map_.next_value()?;
6916 }
6917 GeneratedField::WindowSize => {
6918 if window_size__.is_some() {
6919 return Err(serde::de::Error::duplicate_field("windowSize"));
6920 }
6921 window_size__ = map_.next_value()?;
6922 }
6923 GeneratedField::OutputIndices => {
6924 if output_indices__.is_some() {
6925 return Err(serde::de::Error::duplicate_field("outputIndices"));
6926 }
6927 output_indices__ =
6928 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6929 .into_iter().map(|x| x.0).collect())
6930 ;
6931 }
6932 GeneratedField::WindowStartExprs => {
6933 if window_start_exprs__.is_some() {
6934 return Err(serde::de::Error::duplicate_field("windowStartExprs"));
6935 }
6936 window_start_exprs__ = Some(map_.next_value()?);
6937 }
6938 GeneratedField::WindowEndExprs => {
6939 if window_end_exprs__.is_some() {
6940 return Err(serde::de::Error::duplicate_field("windowEndExprs"));
6941 }
6942 window_end_exprs__ = Some(map_.next_value()?);
6943 }
6944 }
6945 }
6946 Ok(HopWindowNode {
6947 time_col: time_col__.unwrap_or_default(),
6948 window_slide: window_slide__,
6949 window_size: window_size__,
6950 output_indices: output_indices__.unwrap_or_default(),
6951 window_start_exprs: window_start_exprs__.unwrap_or_default(),
6952 window_end_exprs: window_end_exprs__.unwrap_or_default(),
6953 })
6954 }
6955 }
6956 deserializer.deserialize_struct("stream_plan.HopWindowNode", FIELDS, GeneratedVisitor)
6957 }
6958}
6959impl serde::Serialize for IcebergPkIndexCompactionContext {
6960 #[allow(deprecated)]
6961 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6962 where
6963 S: serde::Serializer,
6964 {
6965 use serde::ser::SerializeStruct;
6966 let mut len = 0;
6967 if self.sink_id != 0 {
6968 len += 1;
6969 }
6970 if self.task_id != 0 {
6971 len += 1;
6972 }
6973 if self.phase != 0 {
6974 len += 1;
6975 }
6976 if self.resolver_task_input.is_some() {
6977 len += 1;
6978 }
6979 let mut struct_ser = serializer.serialize_struct("stream_plan.IcebergPkIndexCompactionContext", len)?;
6980 if self.sink_id != 0 {
6981 struct_ser.serialize_field("sinkId", &self.sink_id)?;
6982 }
6983 if self.task_id != 0 {
6984 #[allow(clippy::needless_borrow)]
6985 #[allow(clippy::needless_borrows_for_generic_args)]
6986 struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
6987 }
6988 if self.phase != 0 {
6989 let v = iceberg_pk_index_compaction_context::Phase::try_from(self.phase)
6990 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.phase)))?;
6991 struct_ser.serialize_field("phase", &v)?;
6992 }
6993 if let Some(v) = self.resolver_task_input.as_ref() {
6994 struct_ser.serialize_field("resolverTaskInput", v)?;
6995 }
6996 struct_ser.end()
6997 }
6998}
6999impl<'de> serde::Deserialize<'de> for IcebergPkIndexCompactionContext {
7000 #[allow(deprecated)]
7001 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7002 where
7003 D: serde::Deserializer<'de>,
7004 {
7005 const FIELDS: &[&str] = &[
7006 "sink_id",
7007 "sinkId",
7008 "task_id",
7009 "taskId",
7010 "phase",
7011 "resolver_task_input",
7012 "resolverTaskInput",
7013 ];
7014
7015 #[allow(clippy::enum_variant_names)]
7016 enum GeneratedField {
7017 SinkId,
7018 TaskId,
7019 Phase,
7020 ResolverTaskInput,
7021 }
7022 impl<'de> serde::Deserialize<'de> for GeneratedField {
7023 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7024 where
7025 D: serde::Deserializer<'de>,
7026 {
7027 struct GeneratedVisitor;
7028
7029 impl serde::de::Visitor<'_> for GeneratedVisitor {
7030 type Value = GeneratedField;
7031
7032 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7033 write!(formatter, "expected one of: {:?}", &FIELDS)
7034 }
7035
7036 #[allow(unused_variables)]
7037 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7038 where
7039 E: serde::de::Error,
7040 {
7041 match value {
7042 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
7043 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
7044 "phase" => Ok(GeneratedField::Phase),
7045 "resolverTaskInput" | "resolver_task_input" => Ok(GeneratedField::ResolverTaskInput),
7046 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7047 }
7048 }
7049 }
7050 deserializer.deserialize_identifier(GeneratedVisitor)
7051 }
7052 }
7053 struct GeneratedVisitor;
7054 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7055 type Value = IcebergPkIndexCompactionContext;
7056
7057 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7058 formatter.write_str("struct stream_plan.IcebergPkIndexCompactionContext")
7059 }
7060
7061 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IcebergPkIndexCompactionContext, V::Error>
7062 where
7063 V: serde::de::MapAccess<'de>,
7064 {
7065 let mut sink_id__ = None;
7066 let mut task_id__ = None;
7067 let mut phase__ = None;
7068 let mut resolver_task_input__ = None;
7069 while let Some(k) = map_.next_key()? {
7070 match k {
7071 GeneratedField::SinkId => {
7072 if sink_id__.is_some() {
7073 return Err(serde::de::Error::duplicate_field("sinkId"));
7074 }
7075 sink_id__ =
7076 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7077 ;
7078 }
7079 GeneratedField::TaskId => {
7080 if task_id__.is_some() {
7081 return Err(serde::de::Error::duplicate_field("taskId"));
7082 }
7083 task_id__ =
7084 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7085 ;
7086 }
7087 GeneratedField::Phase => {
7088 if phase__.is_some() {
7089 return Err(serde::de::Error::duplicate_field("phase"));
7090 }
7091 phase__ = Some(map_.next_value::<iceberg_pk_index_compaction_context::Phase>()? as i32);
7092 }
7093 GeneratedField::ResolverTaskInput => {
7094 if resolver_task_input__.is_some() {
7095 return Err(serde::de::Error::duplicate_field("resolverTaskInput"));
7096 }
7097 resolver_task_input__ = map_.next_value()?;
7098 }
7099 }
7100 }
7101 Ok(IcebergPkIndexCompactionContext {
7102 sink_id: sink_id__.unwrap_or_default(),
7103 task_id: task_id__.unwrap_or_default(),
7104 phase: phase__.unwrap_or_default(),
7105 resolver_task_input: resolver_task_input__,
7106 })
7107 }
7108 }
7109 deserializer.deserialize_struct("stream_plan.IcebergPkIndexCompactionContext", FIELDS, GeneratedVisitor)
7110 }
7111}
7112impl serde::Serialize for iceberg_pk_index_compaction_context::Phase {
7113 #[allow(deprecated)]
7114 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7115 where
7116 S: serde::Serializer,
7117 {
7118 let variant = match self {
7119 Self::Unspecified => "PHASE_UNSPECIFIED",
7120 Self::Begin => "PHASE_BEGIN",
7121 Self::End => "PHASE_END",
7122 };
7123 serializer.serialize_str(variant)
7124 }
7125}
7126impl<'de> serde::Deserialize<'de> for iceberg_pk_index_compaction_context::Phase {
7127 #[allow(deprecated)]
7128 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7129 where
7130 D: serde::Deserializer<'de>,
7131 {
7132 const FIELDS: &[&str] = &[
7133 "PHASE_UNSPECIFIED",
7134 "PHASE_BEGIN",
7135 "PHASE_END",
7136 ];
7137
7138 struct GeneratedVisitor;
7139
7140 impl serde::de::Visitor<'_> for GeneratedVisitor {
7141 type Value = iceberg_pk_index_compaction_context::Phase;
7142
7143 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7144 write!(formatter, "expected one of: {:?}", &FIELDS)
7145 }
7146
7147 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
7148 where
7149 E: serde::de::Error,
7150 {
7151 i32::try_from(v)
7152 .ok()
7153 .and_then(|x| x.try_into().ok())
7154 .ok_or_else(|| {
7155 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
7156 })
7157 }
7158
7159 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
7160 where
7161 E: serde::de::Error,
7162 {
7163 i32::try_from(v)
7164 .ok()
7165 .and_then(|x| x.try_into().ok())
7166 .ok_or_else(|| {
7167 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
7168 })
7169 }
7170
7171 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
7172 where
7173 E: serde::de::Error,
7174 {
7175 match value {
7176 "PHASE_UNSPECIFIED" => Ok(iceberg_pk_index_compaction_context::Phase::Unspecified),
7177 "PHASE_BEGIN" => Ok(iceberg_pk_index_compaction_context::Phase::Begin),
7178 "PHASE_END" => Ok(iceberg_pk_index_compaction_context::Phase::End),
7179 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
7180 }
7181 }
7182 }
7183 deserializer.deserialize_any(GeneratedVisitor)
7184 }
7185}
7186impl serde::Serialize for iceberg_pk_index_compaction_context::ResolverTaskInput {
7187 #[allow(deprecated)]
7188 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7189 where
7190 S: serde::Serializer,
7191 {
7192 use serde::ser::SerializeStruct;
7193 let mut len = 0;
7194 if !self.output_data_file_paths.is_empty() {
7195 len += 1;
7196 }
7197 if !self.input_data_file_paths.is_empty() {
7198 len += 1;
7199 }
7200 if self.read_snapshot_id != 0 {
7201 len += 1;
7202 }
7203 let mut struct_ser = serializer.serialize_struct("stream_plan.IcebergPkIndexCompactionContext.ResolverTaskInput", len)?;
7204 if !self.output_data_file_paths.is_empty() {
7205 struct_ser.serialize_field("outputDataFilePaths", &self.output_data_file_paths)?;
7206 }
7207 if !self.input_data_file_paths.is_empty() {
7208 struct_ser.serialize_field("inputDataFilePaths", &self.input_data_file_paths)?;
7209 }
7210 if self.read_snapshot_id != 0 {
7211 #[allow(clippy::needless_borrow)]
7212 #[allow(clippy::needless_borrows_for_generic_args)]
7213 struct_ser.serialize_field("readSnapshotId", ToString::to_string(&self.read_snapshot_id).as_str())?;
7214 }
7215 struct_ser.end()
7216 }
7217}
7218impl<'de> serde::Deserialize<'de> for iceberg_pk_index_compaction_context::ResolverTaskInput {
7219 #[allow(deprecated)]
7220 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7221 where
7222 D: serde::Deserializer<'de>,
7223 {
7224 const FIELDS: &[&str] = &[
7225 "output_data_file_paths",
7226 "outputDataFilePaths",
7227 "input_data_file_paths",
7228 "inputDataFilePaths",
7229 "read_snapshot_id",
7230 "readSnapshotId",
7231 ];
7232
7233 #[allow(clippy::enum_variant_names)]
7234 enum GeneratedField {
7235 OutputDataFilePaths,
7236 InputDataFilePaths,
7237 ReadSnapshotId,
7238 }
7239 impl<'de> serde::Deserialize<'de> for GeneratedField {
7240 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7241 where
7242 D: serde::Deserializer<'de>,
7243 {
7244 struct GeneratedVisitor;
7245
7246 impl serde::de::Visitor<'_> for GeneratedVisitor {
7247 type Value = GeneratedField;
7248
7249 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7250 write!(formatter, "expected one of: {:?}", &FIELDS)
7251 }
7252
7253 #[allow(unused_variables)]
7254 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7255 where
7256 E: serde::de::Error,
7257 {
7258 match value {
7259 "outputDataFilePaths" | "output_data_file_paths" => Ok(GeneratedField::OutputDataFilePaths),
7260 "inputDataFilePaths" | "input_data_file_paths" => Ok(GeneratedField::InputDataFilePaths),
7261 "readSnapshotId" | "read_snapshot_id" => Ok(GeneratedField::ReadSnapshotId),
7262 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7263 }
7264 }
7265 }
7266 deserializer.deserialize_identifier(GeneratedVisitor)
7267 }
7268 }
7269 struct GeneratedVisitor;
7270 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7271 type Value = iceberg_pk_index_compaction_context::ResolverTaskInput;
7272
7273 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7274 formatter.write_str("struct stream_plan.IcebergPkIndexCompactionContext.ResolverTaskInput")
7275 }
7276
7277 fn visit_map<V>(self, mut map_: V) -> std::result::Result<iceberg_pk_index_compaction_context::ResolverTaskInput, V::Error>
7278 where
7279 V: serde::de::MapAccess<'de>,
7280 {
7281 let mut output_data_file_paths__ = None;
7282 let mut input_data_file_paths__ = None;
7283 let mut read_snapshot_id__ = None;
7284 while let Some(k) = map_.next_key()? {
7285 match k {
7286 GeneratedField::OutputDataFilePaths => {
7287 if output_data_file_paths__.is_some() {
7288 return Err(serde::de::Error::duplicate_field("outputDataFilePaths"));
7289 }
7290 output_data_file_paths__ = Some(map_.next_value()?);
7291 }
7292 GeneratedField::InputDataFilePaths => {
7293 if input_data_file_paths__.is_some() {
7294 return Err(serde::de::Error::duplicate_field("inputDataFilePaths"));
7295 }
7296 input_data_file_paths__ = Some(map_.next_value()?);
7297 }
7298 GeneratedField::ReadSnapshotId => {
7299 if read_snapshot_id__.is_some() {
7300 return Err(serde::de::Error::duplicate_field("readSnapshotId"));
7301 }
7302 read_snapshot_id__ =
7303 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7304 ;
7305 }
7306 }
7307 }
7308 Ok(iceberg_pk_index_compaction_context::ResolverTaskInput {
7309 output_data_file_paths: output_data_file_paths__.unwrap_or_default(),
7310 input_data_file_paths: input_data_file_paths__.unwrap_or_default(),
7311 read_snapshot_id: read_snapshot_id__.unwrap_or_default(),
7312 })
7313 }
7314 }
7315 deserializer.deserialize_struct("stream_plan.IcebergPkIndexCompactionContext.ResolverTaskInput", FIELDS, GeneratedVisitor)
7316 }
7317}
7318impl serde::Serialize for IcebergWithPkIndexPositionDeleteMergerNode {
7319 #[allow(deprecated)]
7320 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7321 where
7322 S: serde::Serializer,
7323 {
7324 use serde::ser::SerializeStruct;
7325 let mut len = 0;
7326 if self.sink_desc.is_some() {
7327 len += 1;
7328 }
7329 let mut struct_ser = serializer.serialize_struct("stream_plan.IcebergWithPkIndexPositionDeleteMergerNode", len)?;
7330 if let Some(v) = self.sink_desc.as_ref() {
7331 struct_ser.serialize_field("sinkDesc", v)?;
7332 }
7333 struct_ser.end()
7334 }
7335}
7336impl<'de> serde::Deserialize<'de> for IcebergWithPkIndexPositionDeleteMergerNode {
7337 #[allow(deprecated)]
7338 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7339 where
7340 D: serde::Deserializer<'de>,
7341 {
7342 const FIELDS: &[&str] = &[
7343 "sink_desc",
7344 "sinkDesc",
7345 ];
7346
7347 #[allow(clippy::enum_variant_names)]
7348 enum GeneratedField {
7349 SinkDesc,
7350 }
7351 impl<'de> serde::Deserialize<'de> for GeneratedField {
7352 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7353 where
7354 D: serde::Deserializer<'de>,
7355 {
7356 struct GeneratedVisitor;
7357
7358 impl serde::de::Visitor<'_> for GeneratedVisitor {
7359 type Value = GeneratedField;
7360
7361 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7362 write!(formatter, "expected one of: {:?}", &FIELDS)
7363 }
7364
7365 #[allow(unused_variables)]
7366 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7367 where
7368 E: serde::de::Error,
7369 {
7370 match value {
7371 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
7372 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7373 }
7374 }
7375 }
7376 deserializer.deserialize_identifier(GeneratedVisitor)
7377 }
7378 }
7379 struct GeneratedVisitor;
7380 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7381 type Value = IcebergWithPkIndexPositionDeleteMergerNode;
7382
7383 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7384 formatter.write_str("struct stream_plan.IcebergWithPkIndexPositionDeleteMergerNode")
7385 }
7386
7387 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IcebergWithPkIndexPositionDeleteMergerNode, V::Error>
7388 where
7389 V: serde::de::MapAccess<'de>,
7390 {
7391 let mut sink_desc__ = None;
7392 while let Some(k) = map_.next_key()? {
7393 match k {
7394 GeneratedField::SinkDesc => {
7395 if sink_desc__.is_some() {
7396 return Err(serde::de::Error::duplicate_field("sinkDesc"));
7397 }
7398 sink_desc__ = map_.next_value()?;
7399 }
7400 }
7401 }
7402 Ok(IcebergWithPkIndexPositionDeleteMergerNode {
7403 sink_desc: sink_desc__,
7404 })
7405 }
7406 }
7407 deserializer.deserialize_struct("stream_plan.IcebergWithPkIndexPositionDeleteMergerNode", FIELDS, GeneratedVisitor)
7408 }
7409}
7410impl serde::Serialize for IcebergWithPkIndexWriterNode {
7411 #[allow(deprecated)]
7412 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7413 where
7414 S: serde::Serializer,
7415 {
7416 use serde::ser::SerializeStruct;
7417 let mut len = 0;
7418 if self.sink_desc.is_some() {
7419 len += 1;
7420 }
7421 if self.pk_index_table.is_some() {
7422 len += 1;
7423 }
7424 let mut struct_ser = serializer.serialize_struct("stream_plan.IcebergWithPkIndexWriterNode", len)?;
7425 if let Some(v) = self.sink_desc.as_ref() {
7426 struct_ser.serialize_field("sinkDesc", v)?;
7427 }
7428 if let Some(v) = self.pk_index_table.as_ref() {
7429 struct_ser.serialize_field("pkIndexTable", v)?;
7430 }
7431 struct_ser.end()
7432 }
7433}
7434impl<'de> serde::Deserialize<'de> for IcebergWithPkIndexWriterNode {
7435 #[allow(deprecated)]
7436 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7437 where
7438 D: serde::Deserializer<'de>,
7439 {
7440 const FIELDS: &[&str] = &[
7441 "sink_desc",
7442 "sinkDesc",
7443 "pk_index_table",
7444 "pkIndexTable",
7445 ];
7446
7447 #[allow(clippy::enum_variant_names)]
7448 enum GeneratedField {
7449 SinkDesc,
7450 PkIndexTable,
7451 }
7452 impl<'de> serde::Deserialize<'de> for GeneratedField {
7453 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7454 where
7455 D: serde::Deserializer<'de>,
7456 {
7457 struct GeneratedVisitor;
7458
7459 impl serde::de::Visitor<'_> for GeneratedVisitor {
7460 type Value = GeneratedField;
7461
7462 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7463 write!(formatter, "expected one of: {:?}", &FIELDS)
7464 }
7465
7466 #[allow(unused_variables)]
7467 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7468 where
7469 E: serde::de::Error,
7470 {
7471 match value {
7472 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
7473 "pkIndexTable" | "pk_index_table" => Ok(GeneratedField::PkIndexTable),
7474 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7475 }
7476 }
7477 }
7478 deserializer.deserialize_identifier(GeneratedVisitor)
7479 }
7480 }
7481 struct GeneratedVisitor;
7482 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7483 type Value = IcebergWithPkIndexWriterNode;
7484
7485 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7486 formatter.write_str("struct stream_plan.IcebergWithPkIndexWriterNode")
7487 }
7488
7489 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IcebergWithPkIndexWriterNode, V::Error>
7490 where
7491 V: serde::de::MapAccess<'de>,
7492 {
7493 let mut sink_desc__ = None;
7494 let mut pk_index_table__ = None;
7495 while let Some(k) = map_.next_key()? {
7496 match k {
7497 GeneratedField::SinkDesc => {
7498 if sink_desc__.is_some() {
7499 return Err(serde::de::Error::duplicate_field("sinkDesc"));
7500 }
7501 sink_desc__ = map_.next_value()?;
7502 }
7503 GeneratedField::PkIndexTable => {
7504 if pk_index_table__.is_some() {
7505 return Err(serde::de::Error::duplicate_field("pkIndexTable"));
7506 }
7507 pk_index_table__ = map_.next_value()?;
7508 }
7509 }
7510 }
7511 Ok(IcebergWithPkIndexWriterNode {
7512 sink_desc: sink_desc__,
7513 pk_index_table: pk_index_table__,
7514 })
7515 }
7516 }
7517 deserializer.deserialize_struct("stream_plan.IcebergWithPkIndexWriterNode", FIELDS, GeneratedVisitor)
7518 }
7519}
7520impl serde::Serialize for InequalityPair {
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 use serde::ser::SerializeStruct;
7527 let mut len = 0;
7528 if self.key_required_larger != 0 {
7529 len += 1;
7530 }
7531 if self.key_required_smaller != 0 {
7532 len += 1;
7533 }
7534 if self.clean_state {
7535 len += 1;
7536 }
7537 if self.delta_expression.is_some() {
7538 len += 1;
7539 }
7540 let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPair", len)?;
7541 if self.key_required_larger != 0 {
7542 struct_ser.serialize_field("keyRequiredLarger", &self.key_required_larger)?;
7543 }
7544 if self.key_required_smaller != 0 {
7545 struct_ser.serialize_field("keyRequiredSmaller", &self.key_required_smaller)?;
7546 }
7547 if self.clean_state {
7548 struct_ser.serialize_field("cleanState", &self.clean_state)?;
7549 }
7550 if let Some(v) = self.delta_expression.as_ref() {
7551 struct_ser.serialize_field("deltaExpression", v)?;
7552 }
7553 struct_ser.end()
7554 }
7555}
7556impl<'de> serde::Deserialize<'de> for InequalityPair {
7557 #[allow(deprecated)]
7558 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7559 where
7560 D: serde::Deserializer<'de>,
7561 {
7562 const FIELDS: &[&str] = &[
7563 "key_required_larger",
7564 "keyRequiredLarger",
7565 "key_required_smaller",
7566 "keyRequiredSmaller",
7567 "clean_state",
7568 "cleanState",
7569 "delta_expression",
7570 "deltaExpression",
7571 ];
7572
7573 #[allow(clippy::enum_variant_names)]
7574 enum GeneratedField {
7575 KeyRequiredLarger,
7576 KeyRequiredSmaller,
7577 CleanState,
7578 DeltaExpression,
7579 }
7580 impl<'de> serde::Deserialize<'de> for GeneratedField {
7581 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7582 where
7583 D: serde::Deserializer<'de>,
7584 {
7585 struct GeneratedVisitor;
7586
7587 impl serde::de::Visitor<'_> for GeneratedVisitor {
7588 type Value = GeneratedField;
7589
7590 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7591 write!(formatter, "expected one of: {:?}", &FIELDS)
7592 }
7593
7594 #[allow(unused_variables)]
7595 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7596 where
7597 E: serde::de::Error,
7598 {
7599 match value {
7600 "keyRequiredLarger" | "key_required_larger" => Ok(GeneratedField::KeyRequiredLarger),
7601 "keyRequiredSmaller" | "key_required_smaller" => Ok(GeneratedField::KeyRequiredSmaller),
7602 "cleanState" | "clean_state" => Ok(GeneratedField::CleanState),
7603 "deltaExpression" | "delta_expression" => Ok(GeneratedField::DeltaExpression),
7604 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7605 }
7606 }
7607 }
7608 deserializer.deserialize_identifier(GeneratedVisitor)
7609 }
7610 }
7611 struct GeneratedVisitor;
7612 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7613 type Value = InequalityPair;
7614
7615 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7616 formatter.write_str("struct stream_plan.InequalityPair")
7617 }
7618
7619 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPair, V::Error>
7620 where
7621 V: serde::de::MapAccess<'de>,
7622 {
7623 let mut key_required_larger__ = None;
7624 let mut key_required_smaller__ = None;
7625 let mut clean_state__ = None;
7626 let mut delta_expression__ = None;
7627 while let Some(k) = map_.next_key()? {
7628 match k {
7629 GeneratedField::KeyRequiredLarger => {
7630 if key_required_larger__.is_some() {
7631 return Err(serde::de::Error::duplicate_field("keyRequiredLarger"));
7632 }
7633 key_required_larger__ =
7634 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7635 ;
7636 }
7637 GeneratedField::KeyRequiredSmaller => {
7638 if key_required_smaller__.is_some() {
7639 return Err(serde::de::Error::duplicate_field("keyRequiredSmaller"));
7640 }
7641 key_required_smaller__ =
7642 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7643 ;
7644 }
7645 GeneratedField::CleanState => {
7646 if clean_state__.is_some() {
7647 return Err(serde::de::Error::duplicate_field("cleanState"));
7648 }
7649 clean_state__ = Some(map_.next_value()?);
7650 }
7651 GeneratedField::DeltaExpression => {
7652 if delta_expression__.is_some() {
7653 return Err(serde::de::Error::duplicate_field("deltaExpression"));
7654 }
7655 delta_expression__ = map_.next_value()?;
7656 }
7657 }
7658 }
7659 Ok(InequalityPair {
7660 key_required_larger: key_required_larger__.unwrap_or_default(),
7661 key_required_smaller: key_required_smaller__.unwrap_or_default(),
7662 clean_state: clean_state__.unwrap_or_default(),
7663 delta_expression: delta_expression__,
7664 })
7665 }
7666 }
7667 deserializer.deserialize_struct("stream_plan.InequalityPair", FIELDS, GeneratedVisitor)
7668 }
7669}
7670impl serde::Serialize for InequalityPairV2 {
7671 #[allow(deprecated)]
7672 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7673 where
7674 S: serde::Serializer,
7675 {
7676 use serde::ser::SerializeStruct;
7677 let mut len = 0;
7678 if self.left_idx != 0 {
7679 len += 1;
7680 }
7681 if self.right_idx != 0 {
7682 len += 1;
7683 }
7684 if self.clean_left_state {
7685 len += 1;
7686 }
7687 if self.clean_right_state {
7688 len += 1;
7689 }
7690 if self.op != 0 {
7691 len += 1;
7692 }
7693 let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPairV2", len)?;
7694 if self.left_idx != 0 {
7695 struct_ser.serialize_field("leftIdx", &self.left_idx)?;
7696 }
7697 if self.right_idx != 0 {
7698 struct_ser.serialize_field("rightIdx", &self.right_idx)?;
7699 }
7700 if self.clean_left_state {
7701 struct_ser.serialize_field("cleanLeftState", &self.clean_left_state)?;
7702 }
7703 if self.clean_right_state {
7704 struct_ser.serialize_field("cleanRightState", &self.clean_right_state)?;
7705 }
7706 if self.op != 0 {
7707 let v = InequalityType::try_from(self.op)
7708 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.op)))?;
7709 struct_ser.serialize_field("op", &v)?;
7710 }
7711 struct_ser.end()
7712 }
7713}
7714impl<'de> serde::Deserialize<'de> for InequalityPairV2 {
7715 #[allow(deprecated)]
7716 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7717 where
7718 D: serde::Deserializer<'de>,
7719 {
7720 const FIELDS: &[&str] = &[
7721 "left_idx",
7722 "leftIdx",
7723 "right_idx",
7724 "rightIdx",
7725 "clean_left_state",
7726 "cleanLeftState",
7727 "clean_right_state",
7728 "cleanRightState",
7729 "op",
7730 ];
7731
7732 #[allow(clippy::enum_variant_names)]
7733 enum GeneratedField {
7734 LeftIdx,
7735 RightIdx,
7736 CleanLeftState,
7737 CleanRightState,
7738 Op,
7739 }
7740 impl<'de> serde::Deserialize<'de> for GeneratedField {
7741 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7742 where
7743 D: serde::Deserializer<'de>,
7744 {
7745 struct GeneratedVisitor;
7746
7747 impl serde::de::Visitor<'_> for GeneratedVisitor {
7748 type Value = GeneratedField;
7749
7750 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7751 write!(formatter, "expected one of: {:?}", &FIELDS)
7752 }
7753
7754 #[allow(unused_variables)]
7755 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7756 where
7757 E: serde::de::Error,
7758 {
7759 match value {
7760 "leftIdx" | "left_idx" => Ok(GeneratedField::LeftIdx),
7761 "rightIdx" | "right_idx" => Ok(GeneratedField::RightIdx),
7762 "cleanLeftState" | "clean_left_state" => Ok(GeneratedField::CleanLeftState),
7763 "cleanRightState" | "clean_right_state" => Ok(GeneratedField::CleanRightState),
7764 "op" => Ok(GeneratedField::Op),
7765 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7766 }
7767 }
7768 }
7769 deserializer.deserialize_identifier(GeneratedVisitor)
7770 }
7771 }
7772 struct GeneratedVisitor;
7773 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7774 type Value = InequalityPairV2;
7775
7776 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7777 formatter.write_str("struct stream_plan.InequalityPairV2")
7778 }
7779
7780 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPairV2, V::Error>
7781 where
7782 V: serde::de::MapAccess<'de>,
7783 {
7784 let mut left_idx__ = None;
7785 let mut right_idx__ = None;
7786 let mut clean_left_state__ = None;
7787 let mut clean_right_state__ = None;
7788 let mut op__ = None;
7789 while let Some(k) = map_.next_key()? {
7790 match k {
7791 GeneratedField::LeftIdx => {
7792 if left_idx__.is_some() {
7793 return Err(serde::de::Error::duplicate_field("leftIdx"));
7794 }
7795 left_idx__ =
7796 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7797 ;
7798 }
7799 GeneratedField::RightIdx => {
7800 if right_idx__.is_some() {
7801 return Err(serde::de::Error::duplicate_field("rightIdx"));
7802 }
7803 right_idx__ =
7804 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7805 ;
7806 }
7807 GeneratedField::CleanLeftState => {
7808 if clean_left_state__.is_some() {
7809 return Err(serde::de::Error::duplicate_field("cleanLeftState"));
7810 }
7811 clean_left_state__ = Some(map_.next_value()?);
7812 }
7813 GeneratedField::CleanRightState => {
7814 if clean_right_state__.is_some() {
7815 return Err(serde::de::Error::duplicate_field("cleanRightState"));
7816 }
7817 clean_right_state__ = Some(map_.next_value()?);
7818 }
7819 GeneratedField::Op => {
7820 if op__.is_some() {
7821 return Err(serde::de::Error::duplicate_field("op"));
7822 }
7823 op__ = Some(map_.next_value::<InequalityType>()? as i32);
7824 }
7825 }
7826 }
7827 Ok(InequalityPairV2 {
7828 left_idx: left_idx__.unwrap_or_default(),
7829 right_idx: right_idx__.unwrap_or_default(),
7830 clean_left_state: clean_left_state__.unwrap_or_default(),
7831 clean_right_state: clean_right_state__.unwrap_or_default(),
7832 op: op__.unwrap_or_default(),
7833 })
7834 }
7835 }
7836 deserializer.deserialize_struct("stream_plan.InequalityPairV2", FIELDS, GeneratedVisitor)
7837 }
7838}
7839impl serde::Serialize for InequalityType {
7840 #[allow(deprecated)]
7841 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7842 where
7843 S: serde::Serializer,
7844 {
7845 let variant = match self {
7846 Self::Unspecified => "INEQUALITY_TYPE_UNSPECIFIED",
7847 Self::LessThan => "INEQUALITY_TYPE_LESS_THAN",
7848 Self::LessThanOrEqual => "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL",
7849 Self::GreaterThan => "INEQUALITY_TYPE_GREATER_THAN",
7850 Self::GreaterThanOrEqual => "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL",
7851 };
7852 serializer.serialize_str(variant)
7853 }
7854}
7855impl<'de> serde::Deserialize<'de> for InequalityType {
7856 #[allow(deprecated)]
7857 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7858 where
7859 D: serde::Deserializer<'de>,
7860 {
7861 const FIELDS: &[&str] = &[
7862 "INEQUALITY_TYPE_UNSPECIFIED",
7863 "INEQUALITY_TYPE_LESS_THAN",
7864 "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL",
7865 "INEQUALITY_TYPE_GREATER_THAN",
7866 "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL",
7867 ];
7868
7869 struct GeneratedVisitor;
7870
7871 impl serde::de::Visitor<'_> for GeneratedVisitor {
7872 type Value = InequalityType;
7873
7874 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7875 write!(formatter, "expected one of: {:?}", &FIELDS)
7876 }
7877
7878 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
7879 where
7880 E: serde::de::Error,
7881 {
7882 i32::try_from(v)
7883 .ok()
7884 .and_then(|x| x.try_into().ok())
7885 .ok_or_else(|| {
7886 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
7887 })
7888 }
7889
7890 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
7891 where
7892 E: serde::de::Error,
7893 {
7894 i32::try_from(v)
7895 .ok()
7896 .and_then(|x| x.try_into().ok())
7897 .ok_or_else(|| {
7898 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
7899 })
7900 }
7901
7902 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
7903 where
7904 E: serde::de::Error,
7905 {
7906 match value {
7907 "INEQUALITY_TYPE_UNSPECIFIED" => Ok(InequalityType::Unspecified),
7908 "INEQUALITY_TYPE_LESS_THAN" => Ok(InequalityType::LessThan),
7909 "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL" => Ok(InequalityType::LessThanOrEqual),
7910 "INEQUALITY_TYPE_GREATER_THAN" => Ok(InequalityType::GreaterThan),
7911 "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL" => Ok(InequalityType::GreaterThanOrEqual),
7912 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
7913 }
7914 }
7915 }
7916 deserializer.deserialize_any(GeneratedVisitor)
7917 }
7918}
7919impl serde::Serialize for InjectSourceOffsetsMutation {
7920 #[allow(deprecated)]
7921 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7922 where
7923 S: serde::Serializer,
7924 {
7925 use serde::ser::SerializeStruct;
7926 let mut len = 0;
7927 if self.source_id != 0 {
7928 len += 1;
7929 }
7930 if !self.split_offsets.is_empty() {
7931 len += 1;
7932 }
7933 let mut struct_ser = serializer.serialize_struct("stream_plan.InjectSourceOffsetsMutation", len)?;
7934 if self.source_id != 0 {
7935 struct_ser.serialize_field("sourceId", &self.source_id)?;
7936 }
7937 if !self.split_offsets.is_empty() {
7938 struct_ser.serialize_field("splitOffsets", &self.split_offsets)?;
7939 }
7940 struct_ser.end()
7941 }
7942}
7943impl<'de> serde::Deserialize<'de> for InjectSourceOffsetsMutation {
7944 #[allow(deprecated)]
7945 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7946 where
7947 D: serde::Deserializer<'de>,
7948 {
7949 const FIELDS: &[&str] = &[
7950 "source_id",
7951 "sourceId",
7952 "split_offsets",
7953 "splitOffsets",
7954 ];
7955
7956 #[allow(clippy::enum_variant_names)]
7957 enum GeneratedField {
7958 SourceId,
7959 SplitOffsets,
7960 }
7961 impl<'de> serde::Deserialize<'de> for GeneratedField {
7962 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7963 where
7964 D: serde::Deserializer<'de>,
7965 {
7966 struct GeneratedVisitor;
7967
7968 impl serde::de::Visitor<'_> for GeneratedVisitor {
7969 type Value = GeneratedField;
7970
7971 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7972 write!(formatter, "expected one of: {:?}", &FIELDS)
7973 }
7974
7975 #[allow(unused_variables)]
7976 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7977 where
7978 E: serde::de::Error,
7979 {
7980 match value {
7981 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
7982 "splitOffsets" | "split_offsets" => Ok(GeneratedField::SplitOffsets),
7983 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7984 }
7985 }
7986 }
7987 deserializer.deserialize_identifier(GeneratedVisitor)
7988 }
7989 }
7990 struct GeneratedVisitor;
7991 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7992 type Value = InjectSourceOffsetsMutation;
7993
7994 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7995 formatter.write_str("struct stream_plan.InjectSourceOffsetsMutation")
7996 }
7997
7998 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InjectSourceOffsetsMutation, V::Error>
7999 where
8000 V: serde::de::MapAccess<'de>,
8001 {
8002 let mut source_id__ = None;
8003 let mut split_offsets__ = None;
8004 while let Some(k) = map_.next_key()? {
8005 match k {
8006 GeneratedField::SourceId => {
8007 if source_id__.is_some() {
8008 return Err(serde::de::Error::duplicate_field("sourceId"));
8009 }
8010 source_id__ =
8011 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8012 ;
8013 }
8014 GeneratedField::SplitOffsets => {
8015 if split_offsets__.is_some() {
8016 return Err(serde::de::Error::duplicate_field("splitOffsets"));
8017 }
8018 split_offsets__ = Some(
8019 map_.next_value::<std::collections::HashMap<_, _>>()?
8020 );
8021 }
8022 }
8023 }
8024 Ok(InjectSourceOffsetsMutation {
8025 source_id: source_id__.unwrap_or_default(),
8026 split_offsets: split_offsets__.unwrap_or_default(),
8027 })
8028 }
8029 }
8030 deserializer.deserialize_struct("stream_plan.InjectSourceOffsetsMutation", FIELDS, GeneratedVisitor)
8031 }
8032}
8033impl serde::Serialize for JoinEncodingType {
8034 #[allow(deprecated)]
8035 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8036 where
8037 S: serde::Serializer,
8038 {
8039 let variant = match self {
8040 Self::Unspecified => "UNSPECIFIED",
8041 Self::MemoryOptimized => "MEMORY_OPTIMIZED",
8042 Self::CpuOptimized => "CPU_OPTIMIZED",
8043 };
8044 serializer.serialize_str(variant)
8045 }
8046}
8047impl<'de> serde::Deserialize<'de> for JoinEncodingType {
8048 #[allow(deprecated)]
8049 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8050 where
8051 D: serde::Deserializer<'de>,
8052 {
8053 const FIELDS: &[&str] = &[
8054 "UNSPECIFIED",
8055 "MEMORY_OPTIMIZED",
8056 "CPU_OPTIMIZED",
8057 ];
8058
8059 struct GeneratedVisitor;
8060
8061 impl serde::de::Visitor<'_> for GeneratedVisitor {
8062 type Value = JoinEncodingType;
8063
8064 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8065 write!(formatter, "expected one of: {:?}", &FIELDS)
8066 }
8067
8068 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8069 where
8070 E: serde::de::Error,
8071 {
8072 i32::try_from(v)
8073 .ok()
8074 .and_then(|x| x.try_into().ok())
8075 .ok_or_else(|| {
8076 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8077 })
8078 }
8079
8080 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8081 where
8082 E: serde::de::Error,
8083 {
8084 i32::try_from(v)
8085 .ok()
8086 .and_then(|x| x.try_into().ok())
8087 .ok_or_else(|| {
8088 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8089 })
8090 }
8091
8092 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8093 where
8094 E: serde::de::Error,
8095 {
8096 match value {
8097 "UNSPECIFIED" => Ok(JoinEncodingType::Unspecified),
8098 "MEMORY_OPTIMIZED" => Ok(JoinEncodingType::MemoryOptimized),
8099 "CPU_OPTIMIZED" => Ok(JoinEncodingType::CpuOptimized),
8100 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8101 }
8102 }
8103 }
8104 deserializer.deserialize_any(GeneratedVisitor)
8105 }
8106}
8107impl serde::Serialize for JoinKeyWatermarkIndex {
8108 #[allow(deprecated)]
8109 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8110 where
8111 S: serde::Serializer,
8112 {
8113 use serde::ser::SerializeStruct;
8114 let mut len = 0;
8115 if self.index != 0 {
8116 len += 1;
8117 }
8118 if self.do_state_cleaning {
8119 len += 1;
8120 }
8121 let mut struct_ser = serializer.serialize_struct("stream_plan.JoinKeyWatermarkIndex", len)?;
8122 if self.index != 0 {
8123 struct_ser.serialize_field("index", &self.index)?;
8124 }
8125 if self.do_state_cleaning {
8126 struct_ser.serialize_field("doStateCleaning", &self.do_state_cleaning)?;
8127 }
8128 struct_ser.end()
8129 }
8130}
8131impl<'de> serde::Deserialize<'de> for JoinKeyWatermarkIndex {
8132 #[allow(deprecated)]
8133 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8134 where
8135 D: serde::Deserializer<'de>,
8136 {
8137 const FIELDS: &[&str] = &[
8138 "index",
8139 "do_state_cleaning",
8140 "doStateCleaning",
8141 ];
8142
8143 #[allow(clippy::enum_variant_names)]
8144 enum GeneratedField {
8145 Index,
8146 DoStateCleaning,
8147 }
8148 impl<'de> serde::Deserialize<'de> for GeneratedField {
8149 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8150 where
8151 D: serde::Deserializer<'de>,
8152 {
8153 struct GeneratedVisitor;
8154
8155 impl serde::de::Visitor<'_> for GeneratedVisitor {
8156 type Value = GeneratedField;
8157
8158 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8159 write!(formatter, "expected one of: {:?}", &FIELDS)
8160 }
8161
8162 #[allow(unused_variables)]
8163 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8164 where
8165 E: serde::de::Error,
8166 {
8167 match value {
8168 "index" => Ok(GeneratedField::Index),
8169 "doStateCleaning" | "do_state_cleaning" => Ok(GeneratedField::DoStateCleaning),
8170 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8171 }
8172 }
8173 }
8174 deserializer.deserialize_identifier(GeneratedVisitor)
8175 }
8176 }
8177 struct GeneratedVisitor;
8178 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8179 type Value = JoinKeyWatermarkIndex;
8180
8181 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8182 formatter.write_str("struct stream_plan.JoinKeyWatermarkIndex")
8183 }
8184
8185 fn visit_map<V>(self, mut map_: V) -> std::result::Result<JoinKeyWatermarkIndex, V::Error>
8186 where
8187 V: serde::de::MapAccess<'de>,
8188 {
8189 let mut index__ = None;
8190 let mut do_state_cleaning__ = None;
8191 while let Some(k) = map_.next_key()? {
8192 match k {
8193 GeneratedField::Index => {
8194 if index__.is_some() {
8195 return Err(serde::de::Error::duplicate_field("index"));
8196 }
8197 index__ =
8198 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8199 ;
8200 }
8201 GeneratedField::DoStateCleaning => {
8202 if do_state_cleaning__.is_some() {
8203 return Err(serde::de::Error::duplicate_field("doStateCleaning"));
8204 }
8205 do_state_cleaning__ = Some(map_.next_value()?);
8206 }
8207 }
8208 }
8209 Ok(JoinKeyWatermarkIndex {
8210 index: index__.unwrap_or_default(),
8211 do_state_cleaning: do_state_cleaning__.unwrap_or_default(),
8212 })
8213 }
8214 }
8215 deserializer.deserialize_struct("stream_plan.JoinKeyWatermarkIndex", FIELDS, GeneratedVisitor)
8216 }
8217}
8218impl serde::Serialize for ListFinishMutation {
8219 #[allow(deprecated)]
8220 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8221 where
8222 S: serde::Serializer,
8223 {
8224 use serde::ser::SerializeStruct;
8225 let mut len = 0;
8226 if self.associated_source_id != 0 {
8227 len += 1;
8228 }
8229 let mut struct_ser = serializer.serialize_struct("stream_plan.ListFinishMutation", len)?;
8230 if self.associated_source_id != 0 {
8231 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
8232 }
8233 struct_ser.end()
8234 }
8235}
8236impl<'de> serde::Deserialize<'de> for ListFinishMutation {
8237 #[allow(deprecated)]
8238 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8239 where
8240 D: serde::Deserializer<'de>,
8241 {
8242 const FIELDS: &[&str] = &[
8243 "associated_source_id",
8244 "associatedSourceId",
8245 ];
8246
8247 #[allow(clippy::enum_variant_names)]
8248 enum GeneratedField {
8249 AssociatedSourceId,
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 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
8272 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8273 }
8274 }
8275 }
8276 deserializer.deserialize_identifier(GeneratedVisitor)
8277 }
8278 }
8279 struct GeneratedVisitor;
8280 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8281 type Value = ListFinishMutation;
8282
8283 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8284 formatter.write_str("struct stream_plan.ListFinishMutation")
8285 }
8286
8287 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFinishMutation, V::Error>
8288 where
8289 V: serde::de::MapAccess<'de>,
8290 {
8291 let mut associated_source_id__ = None;
8292 while let Some(k) = map_.next_key()? {
8293 match k {
8294 GeneratedField::AssociatedSourceId => {
8295 if associated_source_id__.is_some() {
8296 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
8297 }
8298 associated_source_id__ =
8299 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8300 ;
8301 }
8302 }
8303 }
8304 Ok(ListFinishMutation {
8305 associated_source_id: associated_source_id__.unwrap_or_default(),
8306 })
8307 }
8308 }
8309 deserializer.deserialize_struct("stream_plan.ListFinishMutation", FIELDS, GeneratedVisitor)
8310 }
8311}
8312impl serde::Serialize for LoadFinishMutation {
8313 #[allow(deprecated)]
8314 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8315 where
8316 S: serde::Serializer,
8317 {
8318 use serde::ser::SerializeStruct;
8319 let mut len = 0;
8320 if self.associated_source_id != 0 {
8321 len += 1;
8322 }
8323 let mut struct_ser = serializer.serialize_struct("stream_plan.LoadFinishMutation", len)?;
8324 if self.associated_source_id != 0 {
8325 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
8326 }
8327 struct_ser.end()
8328 }
8329}
8330impl<'de> serde::Deserialize<'de> for LoadFinishMutation {
8331 #[allow(deprecated)]
8332 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8333 where
8334 D: serde::Deserializer<'de>,
8335 {
8336 const FIELDS: &[&str] = &[
8337 "associated_source_id",
8338 "associatedSourceId",
8339 ];
8340
8341 #[allow(clippy::enum_variant_names)]
8342 enum GeneratedField {
8343 AssociatedSourceId,
8344 }
8345 impl<'de> serde::Deserialize<'de> for GeneratedField {
8346 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8347 where
8348 D: serde::Deserializer<'de>,
8349 {
8350 struct GeneratedVisitor;
8351
8352 impl serde::de::Visitor<'_> for GeneratedVisitor {
8353 type Value = GeneratedField;
8354
8355 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8356 write!(formatter, "expected one of: {:?}", &FIELDS)
8357 }
8358
8359 #[allow(unused_variables)]
8360 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8361 where
8362 E: serde::de::Error,
8363 {
8364 match value {
8365 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
8366 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8367 }
8368 }
8369 }
8370 deserializer.deserialize_identifier(GeneratedVisitor)
8371 }
8372 }
8373 struct GeneratedVisitor;
8374 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8375 type Value = LoadFinishMutation;
8376
8377 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8378 formatter.write_str("struct stream_plan.LoadFinishMutation")
8379 }
8380
8381 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LoadFinishMutation, V::Error>
8382 where
8383 V: serde::de::MapAccess<'de>,
8384 {
8385 let mut associated_source_id__ = None;
8386 while let Some(k) = map_.next_key()? {
8387 match k {
8388 GeneratedField::AssociatedSourceId => {
8389 if associated_source_id__.is_some() {
8390 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
8391 }
8392 associated_source_id__ =
8393 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8394 ;
8395 }
8396 }
8397 }
8398 Ok(LoadFinishMutation {
8399 associated_source_id: associated_source_id__.unwrap_or_default(),
8400 })
8401 }
8402 }
8403 deserializer.deserialize_struct("stream_plan.LoadFinishMutation", FIELDS, GeneratedVisitor)
8404 }
8405}
8406impl serde::Serialize for LocalApproxPercentileNode {
8407 #[allow(deprecated)]
8408 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8409 where
8410 S: serde::Serializer,
8411 {
8412 use serde::ser::SerializeStruct;
8413 let mut len = 0;
8414 if self.base != 0. {
8415 len += 1;
8416 }
8417 if self.percentile_index != 0 {
8418 len += 1;
8419 }
8420 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalApproxPercentileNode", len)?;
8421 if self.base != 0. {
8422 struct_ser.serialize_field("base", &self.base)?;
8423 }
8424 if self.percentile_index != 0 {
8425 struct_ser.serialize_field("percentileIndex", &self.percentile_index)?;
8426 }
8427 struct_ser.end()
8428 }
8429}
8430impl<'de> serde::Deserialize<'de> for LocalApproxPercentileNode {
8431 #[allow(deprecated)]
8432 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8433 where
8434 D: serde::Deserializer<'de>,
8435 {
8436 const FIELDS: &[&str] = &[
8437 "base",
8438 "percentile_index",
8439 "percentileIndex",
8440 ];
8441
8442 #[allow(clippy::enum_variant_names)]
8443 enum GeneratedField {
8444 Base,
8445 PercentileIndex,
8446 }
8447 impl<'de> serde::Deserialize<'de> for GeneratedField {
8448 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8449 where
8450 D: serde::Deserializer<'de>,
8451 {
8452 struct GeneratedVisitor;
8453
8454 impl serde::de::Visitor<'_> for GeneratedVisitor {
8455 type Value = GeneratedField;
8456
8457 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8458 write!(formatter, "expected one of: {:?}", &FIELDS)
8459 }
8460
8461 #[allow(unused_variables)]
8462 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8463 where
8464 E: serde::de::Error,
8465 {
8466 match value {
8467 "base" => Ok(GeneratedField::Base),
8468 "percentileIndex" | "percentile_index" => Ok(GeneratedField::PercentileIndex),
8469 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8470 }
8471 }
8472 }
8473 deserializer.deserialize_identifier(GeneratedVisitor)
8474 }
8475 }
8476 struct GeneratedVisitor;
8477 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8478 type Value = LocalApproxPercentileNode;
8479
8480 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8481 formatter.write_str("struct stream_plan.LocalApproxPercentileNode")
8482 }
8483
8484 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalApproxPercentileNode, V::Error>
8485 where
8486 V: serde::de::MapAccess<'de>,
8487 {
8488 let mut base__ = None;
8489 let mut percentile_index__ = None;
8490 while let Some(k) = map_.next_key()? {
8491 match k {
8492 GeneratedField::Base => {
8493 if base__.is_some() {
8494 return Err(serde::de::Error::duplicate_field("base"));
8495 }
8496 base__ =
8497 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8498 ;
8499 }
8500 GeneratedField::PercentileIndex => {
8501 if percentile_index__.is_some() {
8502 return Err(serde::de::Error::duplicate_field("percentileIndex"));
8503 }
8504 percentile_index__ =
8505 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8506 ;
8507 }
8508 }
8509 }
8510 Ok(LocalApproxPercentileNode {
8511 base: base__.unwrap_or_default(),
8512 percentile_index: percentile_index__.unwrap_or_default(),
8513 })
8514 }
8515 }
8516 deserializer.deserialize_struct("stream_plan.LocalApproxPercentileNode", FIELDS, GeneratedVisitor)
8517 }
8518}
8519impl serde::Serialize for LocalityProviderNode {
8520 #[allow(deprecated)]
8521 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8522 where
8523 S: serde::Serializer,
8524 {
8525 use serde::ser::SerializeStruct;
8526 let mut len = 0;
8527 if !self.locality_columns.is_empty() {
8528 len += 1;
8529 }
8530 if self.state_table.is_some() {
8531 len += 1;
8532 }
8533 if self.progress_table.is_some() {
8534 len += 1;
8535 }
8536 if self.rate_limit.is_some() {
8537 len += 1;
8538 }
8539 if self.sort_buffer_table.is_some() {
8540 len += 1;
8541 }
8542 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalityProviderNode", len)?;
8543 if !self.locality_columns.is_empty() {
8544 struct_ser.serialize_field("localityColumns", &self.locality_columns)?;
8545 }
8546 if let Some(v) = self.state_table.as_ref() {
8547 struct_ser.serialize_field("stateTable", v)?;
8548 }
8549 if let Some(v) = self.progress_table.as_ref() {
8550 struct_ser.serialize_field("progressTable", v)?;
8551 }
8552 if let Some(v) = self.rate_limit.as_ref() {
8553 struct_ser.serialize_field("rateLimit", v)?;
8554 }
8555 if let Some(v) = self.sort_buffer_table.as_ref() {
8556 struct_ser.serialize_field("sortBufferTable", v)?;
8557 }
8558 struct_ser.end()
8559 }
8560}
8561impl<'de> serde::Deserialize<'de> for LocalityProviderNode {
8562 #[allow(deprecated)]
8563 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8564 where
8565 D: serde::Deserializer<'de>,
8566 {
8567 const FIELDS: &[&str] = &[
8568 "locality_columns",
8569 "localityColumns",
8570 "state_table",
8571 "stateTable",
8572 "progress_table",
8573 "progressTable",
8574 "rate_limit",
8575 "rateLimit",
8576 "sort_buffer_table",
8577 "sortBufferTable",
8578 ];
8579
8580 #[allow(clippy::enum_variant_names)]
8581 enum GeneratedField {
8582 LocalityColumns,
8583 StateTable,
8584 ProgressTable,
8585 RateLimit,
8586 SortBufferTable,
8587 }
8588 impl<'de> serde::Deserialize<'de> for GeneratedField {
8589 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8590 where
8591 D: serde::Deserializer<'de>,
8592 {
8593 struct GeneratedVisitor;
8594
8595 impl serde::de::Visitor<'_> for GeneratedVisitor {
8596 type Value = GeneratedField;
8597
8598 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8599 write!(formatter, "expected one of: {:?}", &FIELDS)
8600 }
8601
8602 #[allow(unused_variables)]
8603 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8604 where
8605 E: serde::de::Error,
8606 {
8607 match value {
8608 "localityColumns" | "locality_columns" => Ok(GeneratedField::LocalityColumns),
8609 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
8610 "progressTable" | "progress_table" => Ok(GeneratedField::ProgressTable),
8611 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
8612 "sortBufferTable" | "sort_buffer_table" => Ok(GeneratedField::SortBufferTable),
8613 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8614 }
8615 }
8616 }
8617 deserializer.deserialize_identifier(GeneratedVisitor)
8618 }
8619 }
8620 struct GeneratedVisitor;
8621 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8622 type Value = LocalityProviderNode;
8623
8624 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8625 formatter.write_str("struct stream_plan.LocalityProviderNode")
8626 }
8627
8628 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalityProviderNode, V::Error>
8629 where
8630 V: serde::de::MapAccess<'de>,
8631 {
8632 let mut locality_columns__ = None;
8633 let mut state_table__ = None;
8634 let mut progress_table__ = None;
8635 let mut rate_limit__ = None;
8636 let mut sort_buffer_table__ = None;
8637 while let Some(k) = map_.next_key()? {
8638 match k {
8639 GeneratedField::LocalityColumns => {
8640 if locality_columns__.is_some() {
8641 return Err(serde::de::Error::duplicate_field("localityColumns"));
8642 }
8643 locality_columns__ =
8644 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8645 .into_iter().map(|x| x.0).collect())
8646 ;
8647 }
8648 GeneratedField::StateTable => {
8649 if state_table__.is_some() {
8650 return Err(serde::de::Error::duplicate_field("stateTable"));
8651 }
8652 state_table__ = map_.next_value()?;
8653 }
8654 GeneratedField::ProgressTable => {
8655 if progress_table__.is_some() {
8656 return Err(serde::de::Error::duplicate_field("progressTable"));
8657 }
8658 progress_table__ = map_.next_value()?;
8659 }
8660 GeneratedField::RateLimit => {
8661 if rate_limit__.is_some() {
8662 return Err(serde::de::Error::duplicate_field("rateLimit"));
8663 }
8664 rate_limit__ =
8665 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
8666 ;
8667 }
8668 GeneratedField::SortBufferTable => {
8669 if sort_buffer_table__.is_some() {
8670 return Err(serde::de::Error::duplicate_field("sortBufferTable"));
8671 }
8672 sort_buffer_table__ = map_.next_value()?;
8673 }
8674 }
8675 }
8676 Ok(LocalityProviderNode {
8677 locality_columns: locality_columns__.unwrap_or_default(),
8678 state_table: state_table__,
8679 progress_table: progress_table__,
8680 rate_limit: rate_limit__,
8681 sort_buffer_table: sort_buffer_table__,
8682 })
8683 }
8684 }
8685 deserializer.deserialize_struct("stream_plan.LocalityProviderNode", FIELDS, GeneratedVisitor)
8686 }
8687}
8688impl serde::Serialize for LookupNode {
8689 #[allow(deprecated)]
8690 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8691 where
8692 S: serde::Serializer,
8693 {
8694 use serde::ser::SerializeStruct;
8695 let mut len = 0;
8696 if !self.arrange_key.is_empty() {
8697 len += 1;
8698 }
8699 if !self.stream_key.is_empty() {
8700 len += 1;
8701 }
8702 if self.use_current_epoch {
8703 len += 1;
8704 }
8705 if !self.column_mapping.is_empty() {
8706 len += 1;
8707 }
8708 if self.arrangement_table_info.is_some() {
8709 len += 1;
8710 }
8711 if self.arrangement_table_id.is_some() {
8712 len += 1;
8713 }
8714 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupNode", len)?;
8715 if !self.arrange_key.is_empty() {
8716 struct_ser.serialize_field("arrangeKey", &self.arrange_key)?;
8717 }
8718 if !self.stream_key.is_empty() {
8719 struct_ser.serialize_field("streamKey", &self.stream_key)?;
8720 }
8721 if self.use_current_epoch {
8722 struct_ser.serialize_field("useCurrentEpoch", &self.use_current_epoch)?;
8723 }
8724 if !self.column_mapping.is_empty() {
8725 struct_ser.serialize_field("columnMapping", &self.column_mapping)?;
8726 }
8727 if let Some(v) = self.arrangement_table_info.as_ref() {
8728 struct_ser.serialize_field("arrangementTableInfo", v)?;
8729 }
8730 if let Some(v) = self.arrangement_table_id.as_ref() {
8731 match v {
8732 lookup_node::ArrangementTableId::TableId(v) => {
8733 struct_ser.serialize_field("tableId", v)?;
8734 }
8735 lookup_node::ArrangementTableId::IndexId(v) => {
8736 struct_ser.serialize_field("indexId", v)?;
8737 }
8738 }
8739 }
8740 struct_ser.end()
8741 }
8742}
8743impl<'de> serde::Deserialize<'de> for LookupNode {
8744 #[allow(deprecated)]
8745 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8746 where
8747 D: serde::Deserializer<'de>,
8748 {
8749 const FIELDS: &[&str] = &[
8750 "arrange_key",
8751 "arrangeKey",
8752 "stream_key",
8753 "streamKey",
8754 "use_current_epoch",
8755 "useCurrentEpoch",
8756 "column_mapping",
8757 "columnMapping",
8758 "arrangement_table_info",
8759 "arrangementTableInfo",
8760 "table_id",
8761 "tableId",
8762 "index_id",
8763 "indexId",
8764 ];
8765
8766 #[allow(clippy::enum_variant_names)]
8767 enum GeneratedField {
8768 ArrangeKey,
8769 StreamKey,
8770 UseCurrentEpoch,
8771 ColumnMapping,
8772 ArrangementTableInfo,
8773 TableId,
8774 IndexId,
8775 }
8776 impl<'de> serde::Deserialize<'de> for GeneratedField {
8777 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8778 where
8779 D: serde::Deserializer<'de>,
8780 {
8781 struct GeneratedVisitor;
8782
8783 impl serde::de::Visitor<'_> for GeneratedVisitor {
8784 type Value = GeneratedField;
8785
8786 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8787 write!(formatter, "expected one of: {:?}", &FIELDS)
8788 }
8789
8790 #[allow(unused_variables)]
8791 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8792 where
8793 E: serde::de::Error,
8794 {
8795 match value {
8796 "arrangeKey" | "arrange_key" => Ok(GeneratedField::ArrangeKey),
8797 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
8798 "useCurrentEpoch" | "use_current_epoch" => Ok(GeneratedField::UseCurrentEpoch),
8799 "columnMapping" | "column_mapping" => Ok(GeneratedField::ColumnMapping),
8800 "arrangementTableInfo" | "arrangement_table_info" => Ok(GeneratedField::ArrangementTableInfo),
8801 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8802 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
8803 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8804 }
8805 }
8806 }
8807 deserializer.deserialize_identifier(GeneratedVisitor)
8808 }
8809 }
8810 struct GeneratedVisitor;
8811 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8812 type Value = LookupNode;
8813
8814 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8815 formatter.write_str("struct stream_plan.LookupNode")
8816 }
8817
8818 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupNode, V::Error>
8819 where
8820 V: serde::de::MapAccess<'de>,
8821 {
8822 let mut arrange_key__ = None;
8823 let mut stream_key__ = None;
8824 let mut use_current_epoch__ = None;
8825 let mut column_mapping__ = None;
8826 let mut arrangement_table_info__ = None;
8827 let mut arrangement_table_id__ = None;
8828 while let Some(k) = map_.next_key()? {
8829 match k {
8830 GeneratedField::ArrangeKey => {
8831 if arrange_key__.is_some() {
8832 return Err(serde::de::Error::duplicate_field("arrangeKey"));
8833 }
8834 arrange_key__ =
8835 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8836 .into_iter().map(|x| x.0).collect())
8837 ;
8838 }
8839 GeneratedField::StreamKey => {
8840 if stream_key__.is_some() {
8841 return Err(serde::de::Error::duplicate_field("streamKey"));
8842 }
8843 stream_key__ =
8844 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8845 .into_iter().map(|x| x.0).collect())
8846 ;
8847 }
8848 GeneratedField::UseCurrentEpoch => {
8849 if use_current_epoch__.is_some() {
8850 return Err(serde::de::Error::duplicate_field("useCurrentEpoch"));
8851 }
8852 use_current_epoch__ = Some(map_.next_value()?);
8853 }
8854 GeneratedField::ColumnMapping => {
8855 if column_mapping__.is_some() {
8856 return Err(serde::de::Error::duplicate_field("columnMapping"));
8857 }
8858 column_mapping__ =
8859 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8860 .into_iter().map(|x| x.0).collect())
8861 ;
8862 }
8863 GeneratedField::ArrangementTableInfo => {
8864 if arrangement_table_info__.is_some() {
8865 return Err(serde::de::Error::duplicate_field("arrangementTableInfo"));
8866 }
8867 arrangement_table_info__ = map_.next_value()?;
8868 }
8869 GeneratedField::TableId => {
8870 if arrangement_table_id__.is_some() {
8871 return Err(serde::de::Error::duplicate_field("tableId"));
8872 }
8873 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::TableId(x.0));
8874 }
8875 GeneratedField::IndexId => {
8876 if arrangement_table_id__.is_some() {
8877 return Err(serde::de::Error::duplicate_field("indexId"));
8878 }
8879 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::IndexId(x.0));
8880 }
8881 }
8882 }
8883 Ok(LookupNode {
8884 arrange_key: arrange_key__.unwrap_or_default(),
8885 stream_key: stream_key__.unwrap_or_default(),
8886 use_current_epoch: use_current_epoch__.unwrap_or_default(),
8887 column_mapping: column_mapping__.unwrap_or_default(),
8888 arrangement_table_info: arrangement_table_info__,
8889 arrangement_table_id: arrangement_table_id__,
8890 })
8891 }
8892 }
8893 deserializer.deserialize_struct("stream_plan.LookupNode", FIELDS, GeneratedVisitor)
8894 }
8895}
8896impl serde::Serialize for LookupUnionNode {
8897 #[allow(deprecated)]
8898 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8899 where
8900 S: serde::Serializer,
8901 {
8902 use serde::ser::SerializeStruct;
8903 let mut len = 0;
8904 if !self.order.is_empty() {
8905 len += 1;
8906 }
8907 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupUnionNode", len)?;
8908 if !self.order.is_empty() {
8909 struct_ser.serialize_field("order", &self.order)?;
8910 }
8911 struct_ser.end()
8912 }
8913}
8914impl<'de> serde::Deserialize<'de> for LookupUnionNode {
8915 #[allow(deprecated)]
8916 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8917 where
8918 D: serde::Deserializer<'de>,
8919 {
8920 const FIELDS: &[&str] = &[
8921 "order",
8922 ];
8923
8924 #[allow(clippy::enum_variant_names)]
8925 enum GeneratedField {
8926 Order,
8927 }
8928 impl<'de> serde::Deserialize<'de> for GeneratedField {
8929 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8930 where
8931 D: serde::Deserializer<'de>,
8932 {
8933 struct GeneratedVisitor;
8934
8935 impl serde::de::Visitor<'_> for GeneratedVisitor {
8936 type Value = GeneratedField;
8937
8938 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8939 write!(formatter, "expected one of: {:?}", &FIELDS)
8940 }
8941
8942 #[allow(unused_variables)]
8943 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8944 where
8945 E: serde::de::Error,
8946 {
8947 match value {
8948 "order" => Ok(GeneratedField::Order),
8949 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8950 }
8951 }
8952 }
8953 deserializer.deserialize_identifier(GeneratedVisitor)
8954 }
8955 }
8956 struct GeneratedVisitor;
8957 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8958 type Value = LookupUnionNode;
8959
8960 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8961 formatter.write_str("struct stream_plan.LookupUnionNode")
8962 }
8963
8964 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupUnionNode, V::Error>
8965 where
8966 V: serde::de::MapAccess<'de>,
8967 {
8968 let mut order__ = None;
8969 while let Some(k) = map_.next_key()? {
8970 match k {
8971 GeneratedField::Order => {
8972 if order__.is_some() {
8973 return Err(serde::de::Error::duplicate_field("order"));
8974 }
8975 order__ =
8976 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8977 .into_iter().map(|x| x.0).collect())
8978 ;
8979 }
8980 }
8981 }
8982 Ok(LookupUnionNode {
8983 order: order__.unwrap_or_default(),
8984 })
8985 }
8986 }
8987 deserializer.deserialize_struct("stream_plan.LookupUnionNode", FIELDS, GeneratedVisitor)
8988 }
8989}
8990impl serde::Serialize for MatchRecognizeAfterMatchSkip {
8991 #[allow(deprecated)]
8992 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8993 where
8994 S: serde::Serializer,
8995 {
8996 use serde::ser::SerializeStruct;
8997 let mut len = 0;
8998 if self.mode != 0 {
8999 len += 1;
9000 }
9001 if self.target.is_some() {
9002 len += 1;
9003 }
9004 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeAfterMatchSkip", len)?;
9005 if self.mode != 0 {
9006 let v = match_recognize_after_match_skip::Mode::try_from(self.mode)
9007 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.mode)))?;
9008 struct_ser.serialize_field("mode", &v)?;
9009 }
9010 if let Some(v) = self.target.as_ref() {
9011 struct_ser.serialize_field("target", v)?;
9012 }
9013 struct_ser.end()
9014 }
9015}
9016impl<'de> serde::Deserialize<'de> for MatchRecognizeAfterMatchSkip {
9017 #[allow(deprecated)]
9018 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9019 where
9020 D: serde::Deserializer<'de>,
9021 {
9022 const FIELDS: &[&str] = &[
9023 "mode",
9024 "target",
9025 ];
9026
9027 #[allow(clippy::enum_variant_names)]
9028 enum GeneratedField {
9029 Mode,
9030 Target,
9031 }
9032 impl<'de> serde::Deserialize<'de> for GeneratedField {
9033 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9034 where
9035 D: serde::Deserializer<'de>,
9036 {
9037 struct GeneratedVisitor;
9038
9039 impl serde::de::Visitor<'_> for GeneratedVisitor {
9040 type Value = GeneratedField;
9041
9042 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9043 write!(formatter, "expected one of: {:?}", &FIELDS)
9044 }
9045
9046 #[allow(unused_variables)]
9047 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9048 where
9049 E: serde::de::Error,
9050 {
9051 match value {
9052 "mode" => Ok(GeneratedField::Mode),
9053 "target" => Ok(GeneratedField::Target),
9054 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9055 }
9056 }
9057 }
9058 deserializer.deserialize_identifier(GeneratedVisitor)
9059 }
9060 }
9061 struct GeneratedVisitor;
9062 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9063 type Value = MatchRecognizeAfterMatchSkip;
9064
9065 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9066 formatter.write_str("struct stream_plan.MatchRecognizeAfterMatchSkip")
9067 }
9068
9069 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeAfterMatchSkip, V::Error>
9070 where
9071 V: serde::de::MapAccess<'de>,
9072 {
9073 let mut mode__ = None;
9074 let mut target__ = None;
9075 while let Some(k) = map_.next_key()? {
9076 match k {
9077 GeneratedField::Mode => {
9078 if mode__.is_some() {
9079 return Err(serde::de::Error::duplicate_field("mode"));
9080 }
9081 mode__ = Some(map_.next_value::<match_recognize_after_match_skip::Mode>()? as i32);
9082 }
9083 GeneratedField::Target => {
9084 if target__.is_some() {
9085 return Err(serde::de::Error::duplicate_field("target"));
9086 }
9087 target__ = map_.next_value()?;
9088 }
9089 }
9090 }
9091 Ok(MatchRecognizeAfterMatchSkip {
9092 mode: mode__.unwrap_or_default(),
9093 target: target__,
9094 })
9095 }
9096 }
9097 deserializer.deserialize_struct("stream_plan.MatchRecognizeAfterMatchSkip", FIELDS, GeneratedVisitor)
9098 }
9099}
9100impl serde::Serialize for match_recognize_after_match_skip::Mode {
9101 #[allow(deprecated)]
9102 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9103 where
9104 S: serde::Serializer,
9105 {
9106 let variant = match self {
9107 Self::Unspecified => "MODE_UNSPECIFIED",
9108 Self::PastLastRow => "MODE_PAST_LAST_ROW",
9109 Self::ToNextRow => "MODE_TO_NEXT_ROW",
9110 Self::ToFirst => "MODE_TO_FIRST",
9111 Self::ToLast => "MODE_TO_LAST",
9112 };
9113 serializer.serialize_str(variant)
9114 }
9115}
9116impl<'de> serde::Deserialize<'de> for match_recognize_after_match_skip::Mode {
9117 #[allow(deprecated)]
9118 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9119 where
9120 D: serde::Deserializer<'de>,
9121 {
9122 const FIELDS: &[&str] = &[
9123 "MODE_UNSPECIFIED",
9124 "MODE_PAST_LAST_ROW",
9125 "MODE_TO_NEXT_ROW",
9126 "MODE_TO_FIRST",
9127 "MODE_TO_LAST",
9128 ];
9129
9130 struct GeneratedVisitor;
9131
9132 impl serde::de::Visitor<'_> for GeneratedVisitor {
9133 type Value = match_recognize_after_match_skip::Mode;
9134
9135 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9136 write!(formatter, "expected one of: {:?}", &FIELDS)
9137 }
9138
9139 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9140 where
9141 E: serde::de::Error,
9142 {
9143 i32::try_from(v)
9144 .ok()
9145 .and_then(|x| x.try_into().ok())
9146 .ok_or_else(|| {
9147 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9148 })
9149 }
9150
9151 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9152 where
9153 E: serde::de::Error,
9154 {
9155 i32::try_from(v)
9156 .ok()
9157 .and_then(|x| x.try_into().ok())
9158 .ok_or_else(|| {
9159 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9160 })
9161 }
9162
9163 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9164 where
9165 E: serde::de::Error,
9166 {
9167 match value {
9168 "MODE_UNSPECIFIED" => Ok(match_recognize_after_match_skip::Mode::Unspecified),
9169 "MODE_PAST_LAST_ROW" => Ok(match_recognize_after_match_skip::Mode::PastLastRow),
9170 "MODE_TO_NEXT_ROW" => Ok(match_recognize_after_match_skip::Mode::ToNextRow),
9171 "MODE_TO_FIRST" => Ok(match_recognize_after_match_skip::Mode::ToFirst),
9172 "MODE_TO_LAST" => Ok(match_recognize_after_match_skip::Mode::ToLast),
9173 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9174 }
9175 }
9176 }
9177 deserializer.deserialize_any(GeneratedVisitor)
9178 }
9179}
9180impl serde::Serialize for MatchRecognizeDefine {
9181 #[allow(deprecated)]
9182 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9183 where
9184 S: serde::Serializer,
9185 {
9186 use serde::ser::SerializeStruct;
9187 let mut len = 0;
9188 if !self.symbol.is_empty() {
9189 len += 1;
9190 }
9191 if self.condition.is_some() {
9192 len += 1;
9193 }
9194 if !self.slots.is_empty() {
9195 len += 1;
9196 }
9197 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeDefine", len)?;
9198 if !self.symbol.is_empty() {
9199 struct_ser.serialize_field("symbol", &self.symbol)?;
9200 }
9201 if let Some(v) = self.condition.as_ref() {
9202 struct_ser.serialize_field("condition", v)?;
9203 }
9204 if !self.slots.is_empty() {
9205 struct_ser.serialize_field("slots", &self.slots)?;
9206 }
9207 struct_ser.end()
9208 }
9209}
9210impl<'de> serde::Deserialize<'de> for MatchRecognizeDefine {
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 "symbol",
9218 "condition",
9219 "slots",
9220 ];
9221
9222 #[allow(clippy::enum_variant_names)]
9223 enum GeneratedField {
9224 Symbol,
9225 Condition,
9226 Slots,
9227 }
9228 impl<'de> serde::Deserialize<'de> for GeneratedField {
9229 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9230 where
9231 D: serde::Deserializer<'de>,
9232 {
9233 struct GeneratedVisitor;
9234
9235 impl serde::de::Visitor<'_> for GeneratedVisitor {
9236 type Value = GeneratedField;
9237
9238 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9239 write!(formatter, "expected one of: {:?}", &FIELDS)
9240 }
9241
9242 #[allow(unused_variables)]
9243 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9244 where
9245 E: serde::de::Error,
9246 {
9247 match value {
9248 "symbol" => Ok(GeneratedField::Symbol),
9249 "condition" => Ok(GeneratedField::Condition),
9250 "slots" => Ok(GeneratedField::Slots),
9251 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9252 }
9253 }
9254 }
9255 deserializer.deserialize_identifier(GeneratedVisitor)
9256 }
9257 }
9258 struct GeneratedVisitor;
9259 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9260 type Value = MatchRecognizeDefine;
9261
9262 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9263 formatter.write_str("struct stream_plan.MatchRecognizeDefine")
9264 }
9265
9266 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeDefine, V::Error>
9267 where
9268 V: serde::de::MapAccess<'de>,
9269 {
9270 let mut symbol__ = None;
9271 let mut condition__ = None;
9272 let mut slots__ = None;
9273 while let Some(k) = map_.next_key()? {
9274 match k {
9275 GeneratedField::Symbol => {
9276 if symbol__.is_some() {
9277 return Err(serde::de::Error::duplicate_field("symbol"));
9278 }
9279 symbol__ = Some(map_.next_value()?);
9280 }
9281 GeneratedField::Condition => {
9282 if condition__.is_some() {
9283 return Err(serde::de::Error::duplicate_field("condition"));
9284 }
9285 condition__ = map_.next_value()?;
9286 }
9287 GeneratedField::Slots => {
9288 if slots__.is_some() {
9289 return Err(serde::de::Error::duplicate_field("slots"));
9290 }
9291 slots__ = Some(map_.next_value()?);
9292 }
9293 }
9294 }
9295 Ok(MatchRecognizeDefine {
9296 symbol: symbol__.unwrap_or_default(),
9297 condition: condition__,
9298 slots: slots__.unwrap_or_default(),
9299 })
9300 }
9301 }
9302 deserializer.deserialize_struct("stream_plan.MatchRecognizeDefine", FIELDS, GeneratedVisitor)
9303 }
9304}
9305impl serde::Serialize for MatchRecognizeDefineSlot {
9306 #[allow(deprecated)]
9307 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9308 where
9309 S: serde::Serializer,
9310 {
9311 use serde::ser::SerializeStruct;
9312 let mut len = 0;
9313 if self.kind != 0 {
9314 len += 1;
9315 }
9316 if !self.vars.is_empty() {
9317 len += 1;
9318 }
9319 if self.col_idx != 0 {
9320 len += 1;
9321 }
9322 if self.offset != 0 {
9323 len += 1;
9324 }
9325 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeDefineSlot", len)?;
9326 if self.kind != 0 {
9327 let v = match_recognize_define_slot::Kind::try_from(self.kind)
9328 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
9329 struct_ser.serialize_field("kind", &v)?;
9330 }
9331 if !self.vars.is_empty() {
9332 struct_ser.serialize_field("vars", &self.vars)?;
9333 }
9334 if self.col_idx != 0 {
9335 struct_ser.serialize_field("colIdx", &self.col_idx)?;
9336 }
9337 if self.offset != 0 {
9338 struct_ser.serialize_field("offset", &self.offset)?;
9339 }
9340 struct_ser.end()
9341 }
9342}
9343impl<'de> serde::Deserialize<'de> for MatchRecognizeDefineSlot {
9344 #[allow(deprecated)]
9345 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9346 where
9347 D: serde::Deserializer<'de>,
9348 {
9349 const FIELDS: &[&str] = &[
9350 "kind",
9351 "vars",
9352 "col_idx",
9353 "colIdx",
9354 "offset",
9355 ];
9356
9357 #[allow(clippy::enum_variant_names)]
9358 enum GeneratedField {
9359 Kind,
9360 Vars,
9361 ColIdx,
9362 Offset,
9363 }
9364 impl<'de> serde::Deserialize<'de> for GeneratedField {
9365 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9366 where
9367 D: serde::Deserializer<'de>,
9368 {
9369 struct GeneratedVisitor;
9370
9371 impl serde::de::Visitor<'_> for GeneratedVisitor {
9372 type Value = GeneratedField;
9373
9374 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9375 write!(formatter, "expected one of: {:?}", &FIELDS)
9376 }
9377
9378 #[allow(unused_variables)]
9379 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9380 where
9381 E: serde::de::Error,
9382 {
9383 match value {
9384 "kind" => Ok(GeneratedField::Kind),
9385 "vars" => Ok(GeneratedField::Vars),
9386 "colIdx" | "col_idx" => Ok(GeneratedField::ColIdx),
9387 "offset" => Ok(GeneratedField::Offset),
9388 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9389 }
9390 }
9391 }
9392 deserializer.deserialize_identifier(GeneratedVisitor)
9393 }
9394 }
9395 struct GeneratedVisitor;
9396 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9397 type Value = MatchRecognizeDefineSlot;
9398
9399 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9400 formatter.write_str("struct stream_plan.MatchRecognizeDefineSlot")
9401 }
9402
9403 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeDefineSlot, V::Error>
9404 where
9405 V: serde::de::MapAccess<'de>,
9406 {
9407 let mut kind__ = None;
9408 let mut vars__ = None;
9409 let mut col_idx__ = None;
9410 let mut offset__ = None;
9411 while let Some(k) = map_.next_key()? {
9412 match k {
9413 GeneratedField::Kind => {
9414 if kind__.is_some() {
9415 return Err(serde::de::Error::duplicate_field("kind"));
9416 }
9417 kind__ = Some(map_.next_value::<match_recognize_define_slot::Kind>()? as i32);
9418 }
9419 GeneratedField::Vars => {
9420 if vars__.is_some() {
9421 return Err(serde::de::Error::duplicate_field("vars"));
9422 }
9423 vars__ = Some(map_.next_value()?);
9424 }
9425 GeneratedField::ColIdx => {
9426 if col_idx__.is_some() {
9427 return Err(serde::de::Error::duplicate_field("colIdx"));
9428 }
9429 col_idx__ =
9430 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9431 ;
9432 }
9433 GeneratedField::Offset => {
9434 if offset__.is_some() {
9435 return Err(serde::de::Error::duplicate_field("offset"));
9436 }
9437 offset__ =
9438 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9439 ;
9440 }
9441 }
9442 }
9443 Ok(MatchRecognizeDefineSlot {
9444 kind: kind__.unwrap_or_default(),
9445 vars: vars__.unwrap_or_default(),
9446 col_idx: col_idx__.unwrap_or_default(),
9447 offset: offset__.unwrap_or_default(),
9448 })
9449 }
9450 }
9451 deserializer.deserialize_struct("stream_plan.MatchRecognizeDefineSlot", FIELDS, GeneratedVisitor)
9452 }
9453}
9454impl serde::Serialize for match_recognize_define_slot::Kind {
9455 #[allow(deprecated)]
9456 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9457 where
9458 S: serde::Serializer,
9459 {
9460 let variant = match self {
9461 Self::Unspecified => "KIND_UNSPECIFIED",
9462 Self::SelfCol => "KIND_SELF_COL",
9463 Self::Prev => "KIND_PREV",
9464 Self::Next => "KIND_NEXT",
9465 Self::RunningFirst => "KIND_RUNNING_FIRST",
9466 Self::RunningLast => "KIND_RUNNING_LAST",
9467 };
9468 serializer.serialize_str(variant)
9469 }
9470}
9471impl<'de> serde::Deserialize<'de> for match_recognize_define_slot::Kind {
9472 #[allow(deprecated)]
9473 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9474 where
9475 D: serde::Deserializer<'de>,
9476 {
9477 const FIELDS: &[&str] = &[
9478 "KIND_UNSPECIFIED",
9479 "KIND_SELF_COL",
9480 "KIND_PREV",
9481 "KIND_NEXT",
9482 "KIND_RUNNING_FIRST",
9483 "KIND_RUNNING_LAST",
9484 ];
9485
9486 struct GeneratedVisitor;
9487
9488 impl serde::de::Visitor<'_> for GeneratedVisitor {
9489 type Value = match_recognize_define_slot::Kind;
9490
9491 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9492 write!(formatter, "expected one of: {:?}", &FIELDS)
9493 }
9494
9495 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9496 where
9497 E: serde::de::Error,
9498 {
9499 i32::try_from(v)
9500 .ok()
9501 .and_then(|x| x.try_into().ok())
9502 .ok_or_else(|| {
9503 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9504 })
9505 }
9506
9507 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9508 where
9509 E: serde::de::Error,
9510 {
9511 i32::try_from(v)
9512 .ok()
9513 .and_then(|x| x.try_into().ok())
9514 .ok_or_else(|| {
9515 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9516 })
9517 }
9518
9519 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9520 where
9521 E: serde::de::Error,
9522 {
9523 match value {
9524 "KIND_UNSPECIFIED" => Ok(match_recognize_define_slot::Kind::Unspecified),
9525 "KIND_SELF_COL" => Ok(match_recognize_define_slot::Kind::SelfCol),
9526 "KIND_PREV" => Ok(match_recognize_define_slot::Kind::Prev),
9527 "KIND_NEXT" => Ok(match_recognize_define_slot::Kind::Next),
9528 "KIND_RUNNING_FIRST" => Ok(match_recognize_define_slot::Kind::RunningFirst),
9529 "KIND_RUNNING_LAST" => Ok(match_recognize_define_slot::Kind::RunningLast),
9530 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9531 }
9532 }
9533 }
9534 deserializer.deserialize_any(GeneratedVisitor)
9535 }
9536}
9537impl serde::Serialize for MatchRecognizeInputMode {
9538 #[allow(deprecated)]
9539 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9540 where
9541 S: serde::Serializer,
9542 {
9543 let variant = match self {
9544 Self::Unspecified => "MATCH_RECOGNIZE_INPUT_MODE_UNSPECIFIED",
9545 Self::EventTime => "MATCH_RECOGNIZE_INPUT_MODE_EVENT_TIME",
9546 Self::ProcessingTime => "MATCH_RECOGNIZE_INPUT_MODE_PROCESSING_TIME",
9547 };
9548 serializer.serialize_str(variant)
9549 }
9550}
9551impl<'de> serde::Deserialize<'de> for MatchRecognizeInputMode {
9552 #[allow(deprecated)]
9553 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9554 where
9555 D: serde::Deserializer<'de>,
9556 {
9557 const FIELDS: &[&str] = &[
9558 "MATCH_RECOGNIZE_INPUT_MODE_UNSPECIFIED",
9559 "MATCH_RECOGNIZE_INPUT_MODE_EVENT_TIME",
9560 "MATCH_RECOGNIZE_INPUT_MODE_PROCESSING_TIME",
9561 ];
9562
9563 struct GeneratedVisitor;
9564
9565 impl serde::de::Visitor<'_> for GeneratedVisitor {
9566 type Value = MatchRecognizeInputMode;
9567
9568 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9569 write!(formatter, "expected one of: {:?}", &FIELDS)
9570 }
9571
9572 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9573 where
9574 E: serde::de::Error,
9575 {
9576 i32::try_from(v)
9577 .ok()
9578 .and_then(|x| x.try_into().ok())
9579 .ok_or_else(|| {
9580 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9581 })
9582 }
9583
9584 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9585 where
9586 E: serde::de::Error,
9587 {
9588 i32::try_from(v)
9589 .ok()
9590 .and_then(|x| x.try_into().ok())
9591 .ok_or_else(|| {
9592 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9593 })
9594 }
9595
9596 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9597 where
9598 E: serde::de::Error,
9599 {
9600 match value {
9601 "MATCH_RECOGNIZE_INPUT_MODE_UNSPECIFIED" => Ok(MatchRecognizeInputMode::Unspecified),
9602 "MATCH_RECOGNIZE_INPUT_MODE_EVENT_TIME" => Ok(MatchRecognizeInputMode::EventTime),
9603 "MATCH_RECOGNIZE_INPUT_MODE_PROCESSING_TIME" => Ok(MatchRecognizeInputMode::ProcessingTime),
9604 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9605 }
9606 }
9607 }
9608 deserializer.deserialize_any(GeneratedVisitor)
9609 }
9610}
9611impl serde::Serialize for MatchRecognizeMeasure {
9612 #[allow(deprecated)]
9613 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9614 where
9615 S: serde::Serializer,
9616 {
9617 use serde::ser::SerializeStruct;
9618 let mut len = 0;
9619 if self.expr.is_some() {
9620 len += 1;
9621 }
9622 if !self.name.is_empty() {
9623 len += 1;
9624 }
9625 if !self.slots.is_empty() {
9626 len += 1;
9627 }
9628 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeMeasure", len)?;
9629 if let Some(v) = self.expr.as_ref() {
9630 struct_ser.serialize_field("expr", v)?;
9631 }
9632 if !self.name.is_empty() {
9633 struct_ser.serialize_field("name", &self.name)?;
9634 }
9635 if !self.slots.is_empty() {
9636 struct_ser.serialize_field("slots", &self.slots)?;
9637 }
9638 struct_ser.end()
9639 }
9640}
9641impl<'de> serde::Deserialize<'de> for MatchRecognizeMeasure {
9642 #[allow(deprecated)]
9643 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9644 where
9645 D: serde::Deserializer<'de>,
9646 {
9647 const FIELDS: &[&str] = &[
9648 "expr",
9649 "name",
9650 "slots",
9651 ];
9652
9653 #[allow(clippy::enum_variant_names)]
9654 enum GeneratedField {
9655 Expr,
9656 Name,
9657 Slots,
9658 }
9659 impl<'de> serde::Deserialize<'de> for GeneratedField {
9660 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9661 where
9662 D: serde::Deserializer<'de>,
9663 {
9664 struct GeneratedVisitor;
9665
9666 impl serde::de::Visitor<'_> for GeneratedVisitor {
9667 type Value = GeneratedField;
9668
9669 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9670 write!(formatter, "expected one of: {:?}", &FIELDS)
9671 }
9672
9673 #[allow(unused_variables)]
9674 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9675 where
9676 E: serde::de::Error,
9677 {
9678 match value {
9679 "expr" => Ok(GeneratedField::Expr),
9680 "name" => Ok(GeneratedField::Name),
9681 "slots" => Ok(GeneratedField::Slots),
9682 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9683 }
9684 }
9685 }
9686 deserializer.deserialize_identifier(GeneratedVisitor)
9687 }
9688 }
9689 struct GeneratedVisitor;
9690 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9691 type Value = MatchRecognizeMeasure;
9692
9693 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9694 formatter.write_str("struct stream_plan.MatchRecognizeMeasure")
9695 }
9696
9697 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeMeasure, V::Error>
9698 where
9699 V: serde::de::MapAccess<'de>,
9700 {
9701 let mut expr__ = None;
9702 let mut name__ = None;
9703 let mut slots__ = None;
9704 while let Some(k) = map_.next_key()? {
9705 match k {
9706 GeneratedField::Expr => {
9707 if expr__.is_some() {
9708 return Err(serde::de::Error::duplicate_field("expr"));
9709 }
9710 expr__ = map_.next_value()?;
9711 }
9712 GeneratedField::Name => {
9713 if name__.is_some() {
9714 return Err(serde::de::Error::duplicate_field("name"));
9715 }
9716 name__ = Some(map_.next_value()?);
9717 }
9718 GeneratedField::Slots => {
9719 if slots__.is_some() {
9720 return Err(serde::de::Error::duplicate_field("slots"));
9721 }
9722 slots__ = Some(map_.next_value()?);
9723 }
9724 }
9725 }
9726 Ok(MatchRecognizeMeasure {
9727 expr: expr__,
9728 name: name__.unwrap_or_default(),
9729 slots: slots__.unwrap_or_default(),
9730 })
9731 }
9732 }
9733 deserializer.deserialize_struct("stream_plan.MatchRecognizeMeasure", FIELDS, GeneratedVisitor)
9734 }
9735}
9736impl serde::Serialize for MatchRecognizeMeasureSlot {
9737 #[allow(deprecated)]
9738 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9739 where
9740 S: serde::Serializer,
9741 {
9742 use serde::ser::SerializeStruct;
9743 let mut len = 0;
9744 if self.kind != 0 {
9745 len += 1;
9746 }
9747 if !self.vars.is_empty() {
9748 len += 1;
9749 }
9750 if self.col_idx != 0 {
9751 len += 1;
9752 }
9753 if self.data_type.is_some() {
9754 len += 1;
9755 }
9756 if self.agg_call.is_some() {
9757 len += 1;
9758 }
9759 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeMeasureSlot", len)?;
9760 if self.kind != 0 {
9761 let v = match_recognize_measure_slot::Kind::try_from(self.kind)
9762 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
9763 struct_ser.serialize_field("kind", &v)?;
9764 }
9765 if !self.vars.is_empty() {
9766 struct_ser.serialize_field("vars", &self.vars)?;
9767 }
9768 if self.col_idx != 0 {
9769 struct_ser.serialize_field("colIdx", &self.col_idx)?;
9770 }
9771 if let Some(v) = self.data_type.as_ref() {
9772 struct_ser.serialize_field("dataType", v)?;
9773 }
9774 if let Some(v) = self.agg_call.as_ref() {
9775 struct_ser.serialize_field("aggCall", v)?;
9776 }
9777 struct_ser.end()
9778 }
9779}
9780impl<'de> serde::Deserialize<'de> for MatchRecognizeMeasureSlot {
9781 #[allow(deprecated)]
9782 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9783 where
9784 D: serde::Deserializer<'de>,
9785 {
9786 const FIELDS: &[&str] = &[
9787 "kind",
9788 "vars",
9789 "col_idx",
9790 "colIdx",
9791 "data_type",
9792 "dataType",
9793 "agg_call",
9794 "aggCall",
9795 ];
9796
9797 #[allow(clippy::enum_variant_names)]
9798 enum GeneratedField {
9799 Kind,
9800 Vars,
9801 ColIdx,
9802 DataType,
9803 AggCall,
9804 }
9805 impl<'de> serde::Deserialize<'de> for GeneratedField {
9806 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9807 where
9808 D: serde::Deserializer<'de>,
9809 {
9810 struct GeneratedVisitor;
9811
9812 impl serde::de::Visitor<'_> for GeneratedVisitor {
9813 type Value = GeneratedField;
9814
9815 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9816 write!(formatter, "expected one of: {:?}", &FIELDS)
9817 }
9818
9819 #[allow(unused_variables)]
9820 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9821 where
9822 E: serde::de::Error,
9823 {
9824 match value {
9825 "kind" => Ok(GeneratedField::Kind),
9826 "vars" => Ok(GeneratedField::Vars),
9827 "colIdx" | "col_idx" => Ok(GeneratedField::ColIdx),
9828 "dataType" | "data_type" => Ok(GeneratedField::DataType),
9829 "aggCall" | "agg_call" => Ok(GeneratedField::AggCall),
9830 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9831 }
9832 }
9833 }
9834 deserializer.deserialize_identifier(GeneratedVisitor)
9835 }
9836 }
9837 struct GeneratedVisitor;
9838 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9839 type Value = MatchRecognizeMeasureSlot;
9840
9841 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9842 formatter.write_str("struct stream_plan.MatchRecognizeMeasureSlot")
9843 }
9844
9845 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeMeasureSlot, V::Error>
9846 where
9847 V: serde::de::MapAccess<'de>,
9848 {
9849 let mut kind__ = None;
9850 let mut vars__ = None;
9851 let mut col_idx__ = None;
9852 let mut data_type__ = None;
9853 let mut agg_call__ = None;
9854 while let Some(k) = map_.next_key()? {
9855 match k {
9856 GeneratedField::Kind => {
9857 if kind__.is_some() {
9858 return Err(serde::de::Error::duplicate_field("kind"));
9859 }
9860 kind__ = Some(map_.next_value::<match_recognize_measure_slot::Kind>()? as i32);
9861 }
9862 GeneratedField::Vars => {
9863 if vars__.is_some() {
9864 return Err(serde::de::Error::duplicate_field("vars"));
9865 }
9866 vars__ = Some(map_.next_value()?);
9867 }
9868 GeneratedField::ColIdx => {
9869 if col_idx__.is_some() {
9870 return Err(serde::de::Error::duplicate_field("colIdx"));
9871 }
9872 col_idx__ =
9873 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9874 ;
9875 }
9876 GeneratedField::DataType => {
9877 if data_type__.is_some() {
9878 return Err(serde::de::Error::duplicate_field("dataType"));
9879 }
9880 data_type__ = map_.next_value()?;
9881 }
9882 GeneratedField::AggCall => {
9883 if agg_call__.is_some() {
9884 return Err(serde::de::Error::duplicate_field("aggCall"));
9885 }
9886 agg_call__ = map_.next_value()?;
9887 }
9888 }
9889 }
9890 Ok(MatchRecognizeMeasureSlot {
9891 kind: kind__.unwrap_or_default(),
9892 vars: vars__.unwrap_or_default(),
9893 col_idx: col_idx__.unwrap_or_default(),
9894 data_type: data_type__,
9895 agg_call: agg_call__,
9896 })
9897 }
9898 }
9899 deserializer.deserialize_struct("stream_plan.MatchRecognizeMeasureSlot", FIELDS, GeneratedVisitor)
9900 }
9901}
9902impl serde::Serialize for match_recognize_measure_slot::Kind {
9903 #[allow(deprecated)]
9904 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9905 where
9906 S: serde::Serializer,
9907 {
9908 let variant = match self {
9909 Self::Unspecified => "KIND_UNSPECIFIED",
9910 Self::Last => "KIND_LAST",
9911 Self::First => "KIND_FIRST",
9912 Self::Classifier => "KIND_CLASSIFIER",
9913 Self::CountStar => "KIND_COUNT_STAR",
9914 Self::Count => "KIND_COUNT",
9915 Self::Min => "KIND_MIN",
9916 Self::Max => "KIND_MAX",
9917 Self::Sum => "KIND_SUM",
9918 };
9919 serializer.serialize_str(variant)
9920 }
9921}
9922impl<'de> serde::Deserialize<'de> for match_recognize_measure_slot::Kind {
9923 #[allow(deprecated)]
9924 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9925 where
9926 D: serde::Deserializer<'de>,
9927 {
9928 const FIELDS: &[&str] = &[
9929 "KIND_UNSPECIFIED",
9930 "KIND_LAST",
9931 "KIND_FIRST",
9932 "KIND_CLASSIFIER",
9933 "KIND_COUNT_STAR",
9934 "KIND_COUNT",
9935 "KIND_MIN",
9936 "KIND_MAX",
9937 "KIND_SUM",
9938 ];
9939
9940 struct GeneratedVisitor;
9941
9942 impl serde::de::Visitor<'_> for GeneratedVisitor {
9943 type Value = match_recognize_measure_slot::Kind;
9944
9945 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9946 write!(formatter, "expected one of: {:?}", &FIELDS)
9947 }
9948
9949 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9950 where
9951 E: serde::de::Error,
9952 {
9953 i32::try_from(v)
9954 .ok()
9955 .and_then(|x| x.try_into().ok())
9956 .ok_or_else(|| {
9957 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9958 })
9959 }
9960
9961 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9962 where
9963 E: serde::de::Error,
9964 {
9965 i32::try_from(v)
9966 .ok()
9967 .and_then(|x| x.try_into().ok())
9968 .ok_or_else(|| {
9969 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9970 })
9971 }
9972
9973 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9974 where
9975 E: serde::de::Error,
9976 {
9977 match value {
9978 "KIND_UNSPECIFIED" => Ok(match_recognize_measure_slot::Kind::Unspecified),
9979 "KIND_LAST" => Ok(match_recognize_measure_slot::Kind::Last),
9980 "KIND_FIRST" => Ok(match_recognize_measure_slot::Kind::First),
9981 "KIND_CLASSIFIER" => Ok(match_recognize_measure_slot::Kind::Classifier),
9982 "KIND_COUNT_STAR" => Ok(match_recognize_measure_slot::Kind::CountStar),
9983 "KIND_COUNT" => Ok(match_recognize_measure_slot::Kind::Count),
9984 "KIND_MIN" => Ok(match_recognize_measure_slot::Kind::Min),
9985 "KIND_MAX" => Ok(match_recognize_measure_slot::Kind::Max),
9986 "KIND_SUM" => Ok(match_recognize_measure_slot::Kind::Sum),
9987 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9988 }
9989 }
9990 }
9991 deserializer.deserialize_any(GeneratedVisitor)
9992 }
9993}
9994impl serde::Serialize for MatchRecognizeNode {
9995 #[allow(deprecated)]
9996 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9997 where
9998 S: serde::Serializer,
9999 {
10000 use serde::ser::SerializeStruct;
10001 let mut len = 0;
10002 if !self.partition_by.is_empty() {
10003 len += 1;
10004 }
10005 if !self.order_by.is_empty() {
10006 len += 1;
10007 }
10008 if !self.measures.is_empty() {
10009 len += 1;
10010 }
10011 if !self.defines.is_empty() {
10012 len += 1;
10013 }
10014 if self.pattern_node.is_some() {
10015 len += 1;
10016 }
10017 if self.state_table.is_some() {
10018 len += 1;
10019 }
10020 if self.after_match_skip.is_some() {
10021 len += 1;
10022 }
10023 if self.within.is_some() {
10024 len += 1;
10025 }
10026 if self.within_deadline.is_some() {
10027 len += 1;
10028 }
10029 if self.input_mode != 0 {
10030 len += 1;
10031 }
10032 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeNode", len)?;
10033 if !self.partition_by.is_empty() {
10034 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
10035 }
10036 if !self.order_by.is_empty() {
10037 struct_ser.serialize_field("orderBy", &self.order_by)?;
10038 }
10039 if !self.measures.is_empty() {
10040 struct_ser.serialize_field("measures", &self.measures)?;
10041 }
10042 if !self.defines.is_empty() {
10043 struct_ser.serialize_field("defines", &self.defines)?;
10044 }
10045 if let Some(v) = self.pattern_node.as_ref() {
10046 struct_ser.serialize_field("patternNode", v)?;
10047 }
10048 if let Some(v) = self.state_table.as_ref() {
10049 struct_ser.serialize_field("stateTable", v)?;
10050 }
10051 if let Some(v) = self.after_match_skip.as_ref() {
10052 struct_ser.serialize_field("afterMatchSkip", v)?;
10053 }
10054 if let Some(v) = self.within.as_ref() {
10055 struct_ser.serialize_field("within", v)?;
10056 }
10057 if let Some(v) = self.within_deadline.as_ref() {
10058 struct_ser.serialize_field("withinDeadline", v)?;
10059 }
10060 if self.input_mode != 0 {
10061 let v = MatchRecognizeInputMode::try_from(self.input_mode)
10062 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.input_mode)))?;
10063 struct_ser.serialize_field("inputMode", &v)?;
10064 }
10065 struct_ser.end()
10066 }
10067}
10068impl<'de> serde::Deserialize<'de> for MatchRecognizeNode {
10069 #[allow(deprecated)]
10070 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10071 where
10072 D: serde::Deserializer<'de>,
10073 {
10074 const FIELDS: &[&str] = &[
10075 "partition_by",
10076 "partitionBy",
10077 "order_by",
10078 "orderBy",
10079 "measures",
10080 "defines",
10081 "pattern_node",
10082 "patternNode",
10083 "state_table",
10084 "stateTable",
10085 "after_match_skip",
10086 "afterMatchSkip",
10087 "within",
10088 "within_deadline",
10089 "withinDeadline",
10090 "input_mode",
10091 "inputMode",
10092 ];
10093
10094 #[allow(clippy::enum_variant_names)]
10095 enum GeneratedField {
10096 PartitionBy,
10097 OrderBy,
10098 Measures,
10099 Defines,
10100 PatternNode,
10101 StateTable,
10102 AfterMatchSkip,
10103 Within,
10104 WithinDeadline,
10105 InputMode,
10106 }
10107 impl<'de> serde::Deserialize<'de> for GeneratedField {
10108 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10109 where
10110 D: serde::Deserializer<'de>,
10111 {
10112 struct GeneratedVisitor;
10113
10114 impl serde::de::Visitor<'_> for GeneratedVisitor {
10115 type Value = GeneratedField;
10116
10117 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10118 write!(formatter, "expected one of: {:?}", &FIELDS)
10119 }
10120
10121 #[allow(unused_variables)]
10122 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10123 where
10124 E: serde::de::Error,
10125 {
10126 match value {
10127 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
10128 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
10129 "measures" => Ok(GeneratedField::Measures),
10130 "defines" => Ok(GeneratedField::Defines),
10131 "patternNode" | "pattern_node" => Ok(GeneratedField::PatternNode),
10132 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
10133 "afterMatchSkip" | "after_match_skip" => Ok(GeneratedField::AfterMatchSkip),
10134 "within" => Ok(GeneratedField::Within),
10135 "withinDeadline" | "within_deadline" => Ok(GeneratedField::WithinDeadline),
10136 "inputMode" | "input_mode" => Ok(GeneratedField::InputMode),
10137 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10138 }
10139 }
10140 }
10141 deserializer.deserialize_identifier(GeneratedVisitor)
10142 }
10143 }
10144 struct GeneratedVisitor;
10145 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10146 type Value = MatchRecognizeNode;
10147
10148 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10149 formatter.write_str("struct stream_plan.MatchRecognizeNode")
10150 }
10151
10152 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeNode, V::Error>
10153 where
10154 V: serde::de::MapAccess<'de>,
10155 {
10156 let mut partition_by__ = None;
10157 let mut order_by__ = None;
10158 let mut measures__ = None;
10159 let mut defines__ = None;
10160 let mut pattern_node__ = None;
10161 let mut state_table__ = None;
10162 let mut after_match_skip__ = None;
10163 let mut within__ = None;
10164 let mut within_deadline__ = None;
10165 let mut input_mode__ = None;
10166 while let Some(k) = map_.next_key()? {
10167 match k {
10168 GeneratedField::PartitionBy => {
10169 if partition_by__.is_some() {
10170 return Err(serde::de::Error::duplicate_field("partitionBy"));
10171 }
10172 partition_by__ =
10173 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10174 .into_iter().map(|x| x.0).collect())
10175 ;
10176 }
10177 GeneratedField::OrderBy => {
10178 if order_by__.is_some() {
10179 return Err(serde::de::Error::duplicate_field("orderBy"));
10180 }
10181 order_by__ = Some(map_.next_value()?);
10182 }
10183 GeneratedField::Measures => {
10184 if measures__.is_some() {
10185 return Err(serde::de::Error::duplicate_field("measures"));
10186 }
10187 measures__ = Some(map_.next_value()?);
10188 }
10189 GeneratedField::Defines => {
10190 if defines__.is_some() {
10191 return Err(serde::de::Error::duplicate_field("defines"));
10192 }
10193 defines__ = Some(map_.next_value()?);
10194 }
10195 GeneratedField::PatternNode => {
10196 if pattern_node__.is_some() {
10197 return Err(serde::de::Error::duplicate_field("patternNode"));
10198 }
10199 pattern_node__ = map_.next_value()?;
10200 }
10201 GeneratedField::StateTable => {
10202 if state_table__.is_some() {
10203 return Err(serde::de::Error::duplicate_field("stateTable"));
10204 }
10205 state_table__ = map_.next_value()?;
10206 }
10207 GeneratedField::AfterMatchSkip => {
10208 if after_match_skip__.is_some() {
10209 return Err(serde::de::Error::duplicate_field("afterMatchSkip"));
10210 }
10211 after_match_skip__ = map_.next_value()?;
10212 }
10213 GeneratedField::Within => {
10214 if within__.is_some() {
10215 return Err(serde::de::Error::duplicate_field("within"));
10216 }
10217 within__ = map_.next_value()?;
10218 }
10219 GeneratedField::WithinDeadline => {
10220 if within_deadline__.is_some() {
10221 return Err(serde::de::Error::duplicate_field("withinDeadline"));
10222 }
10223 within_deadline__ = map_.next_value()?;
10224 }
10225 GeneratedField::InputMode => {
10226 if input_mode__.is_some() {
10227 return Err(serde::de::Error::duplicate_field("inputMode"));
10228 }
10229 input_mode__ = Some(map_.next_value::<MatchRecognizeInputMode>()? as i32);
10230 }
10231 }
10232 }
10233 Ok(MatchRecognizeNode {
10234 partition_by: partition_by__.unwrap_or_default(),
10235 order_by: order_by__.unwrap_or_default(),
10236 measures: measures__.unwrap_or_default(),
10237 defines: defines__.unwrap_or_default(),
10238 pattern_node: pattern_node__,
10239 state_table: state_table__,
10240 after_match_skip: after_match_skip__,
10241 within: within__,
10242 within_deadline: within_deadline__,
10243 input_mode: input_mode__.unwrap_or_default(),
10244 })
10245 }
10246 }
10247 deserializer.deserialize_struct("stream_plan.MatchRecognizeNode", FIELDS, GeneratedVisitor)
10248 }
10249}
10250impl serde::Serialize for MatchRecognizePatternNode {
10251 #[allow(deprecated)]
10252 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10253 where
10254 S: serde::Serializer,
10255 {
10256 use serde::ser::SerializeStruct;
10257 let mut len = 0;
10258 if self.node.is_some() {
10259 len += 1;
10260 }
10261 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizePatternNode", len)?;
10262 if let Some(v) = self.node.as_ref() {
10263 match v {
10264 match_recognize_pattern_node::Node::Var(v) => {
10265 struct_ser.serialize_field("var", v)?;
10266 }
10267 match_recognize_pattern_node::Node::Concat(v) => {
10268 struct_ser.serialize_field("concat", v)?;
10269 }
10270 match_recognize_pattern_node::Node::Alternation(v) => {
10271 struct_ser.serialize_field("alternation", v)?;
10272 }
10273 match_recognize_pattern_node::Node::Quantified(v) => {
10274 struct_ser.serialize_field("quantified", v)?;
10275 }
10276 match_recognize_pattern_node::Node::Permute(v) => {
10277 struct_ser.serialize_field("permute", v)?;
10278 }
10279 }
10280 }
10281 struct_ser.end()
10282 }
10283}
10284impl<'de> serde::Deserialize<'de> for MatchRecognizePatternNode {
10285 #[allow(deprecated)]
10286 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10287 where
10288 D: serde::Deserializer<'de>,
10289 {
10290 const FIELDS: &[&str] = &[
10291 "var",
10292 "concat",
10293 "alternation",
10294 "quantified",
10295 "permute",
10296 ];
10297
10298 #[allow(clippy::enum_variant_names)]
10299 enum GeneratedField {
10300 Var,
10301 Concat,
10302 Alternation,
10303 Quantified,
10304 Permute,
10305 }
10306 impl<'de> serde::Deserialize<'de> for GeneratedField {
10307 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10308 where
10309 D: serde::Deserializer<'de>,
10310 {
10311 struct GeneratedVisitor;
10312
10313 impl serde::de::Visitor<'_> for GeneratedVisitor {
10314 type Value = GeneratedField;
10315
10316 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10317 write!(formatter, "expected one of: {:?}", &FIELDS)
10318 }
10319
10320 #[allow(unused_variables)]
10321 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10322 where
10323 E: serde::de::Error,
10324 {
10325 match value {
10326 "var" => Ok(GeneratedField::Var),
10327 "concat" => Ok(GeneratedField::Concat),
10328 "alternation" => Ok(GeneratedField::Alternation),
10329 "quantified" => Ok(GeneratedField::Quantified),
10330 "permute" => Ok(GeneratedField::Permute),
10331 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10332 }
10333 }
10334 }
10335 deserializer.deserialize_identifier(GeneratedVisitor)
10336 }
10337 }
10338 struct GeneratedVisitor;
10339 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10340 type Value = MatchRecognizePatternNode;
10341
10342 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10343 formatter.write_str("struct stream_plan.MatchRecognizePatternNode")
10344 }
10345
10346 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizePatternNode, V::Error>
10347 where
10348 V: serde::de::MapAccess<'de>,
10349 {
10350 let mut node__ = None;
10351 while let Some(k) = map_.next_key()? {
10352 match k {
10353 GeneratedField::Var => {
10354 if node__.is_some() {
10355 return Err(serde::de::Error::duplicate_field("var"));
10356 }
10357 node__ = map_.next_value::<::std::option::Option<_>>()?.map(match_recognize_pattern_node::Node::Var);
10358 }
10359 GeneratedField::Concat => {
10360 if node__.is_some() {
10361 return Err(serde::de::Error::duplicate_field("concat"));
10362 }
10363 node__ = map_.next_value::<::std::option::Option<_>>()?.map(match_recognize_pattern_node::Node::Concat)
10364;
10365 }
10366 GeneratedField::Alternation => {
10367 if node__.is_some() {
10368 return Err(serde::de::Error::duplicate_field("alternation"));
10369 }
10370 node__ = map_.next_value::<::std::option::Option<_>>()?.map(match_recognize_pattern_node::Node::Alternation)
10371;
10372 }
10373 GeneratedField::Quantified => {
10374 if node__.is_some() {
10375 return Err(serde::de::Error::duplicate_field("quantified"));
10376 }
10377 node__ = map_.next_value::<::std::option::Option<_>>()?.map(match_recognize_pattern_node::Node::Quantified)
10378;
10379 }
10380 GeneratedField::Permute => {
10381 if node__.is_some() {
10382 return Err(serde::de::Error::duplicate_field("permute"));
10383 }
10384 node__ = map_.next_value::<::std::option::Option<_>>()?.map(match_recognize_pattern_node::Node::Permute)
10385;
10386 }
10387 }
10388 }
10389 Ok(MatchRecognizePatternNode {
10390 node: node__,
10391 })
10392 }
10393 }
10394 deserializer.deserialize_struct("stream_plan.MatchRecognizePatternNode", FIELDS, GeneratedVisitor)
10395 }
10396}
10397impl serde::Serialize for MatchRecognizePatternSeq {
10398 #[allow(deprecated)]
10399 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10400 where
10401 S: serde::Serializer,
10402 {
10403 use serde::ser::SerializeStruct;
10404 let mut len = 0;
10405 if !self.patterns.is_empty() {
10406 len += 1;
10407 }
10408 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizePatternSeq", len)?;
10409 if !self.patterns.is_empty() {
10410 struct_ser.serialize_field("patterns", &self.patterns)?;
10411 }
10412 struct_ser.end()
10413 }
10414}
10415impl<'de> serde::Deserialize<'de> for MatchRecognizePatternSeq {
10416 #[allow(deprecated)]
10417 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10418 where
10419 D: serde::Deserializer<'de>,
10420 {
10421 const FIELDS: &[&str] = &[
10422 "patterns",
10423 ];
10424
10425 #[allow(clippy::enum_variant_names)]
10426 enum GeneratedField {
10427 Patterns,
10428 }
10429 impl<'de> serde::Deserialize<'de> for GeneratedField {
10430 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10431 where
10432 D: serde::Deserializer<'de>,
10433 {
10434 struct GeneratedVisitor;
10435
10436 impl serde::de::Visitor<'_> for GeneratedVisitor {
10437 type Value = GeneratedField;
10438
10439 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10440 write!(formatter, "expected one of: {:?}", &FIELDS)
10441 }
10442
10443 #[allow(unused_variables)]
10444 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10445 where
10446 E: serde::de::Error,
10447 {
10448 match value {
10449 "patterns" => Ok(GeneratedField::Patterns),
10450 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10451 }
10452 }
10453 }
10454 deserializer.deserialize_identifier(GeneratedVisitor)
10455 }
10456 }
10457 struct GeneratedVisitor;
10458 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10459 type Value = MatchRecognizePatternSeq;
10460
10461 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10462 formatter.write_str("struct stream_plan.MatchRecognizePatternSeq")
10463 }
10464
10465 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizePatternSeq, V::Error>
10466 where
10467 V: serde::de::MapAccess<'de>,
10468 {
10469 let mut patterns__ = None;
10470 while let Some(k) = map_.next_key()? {
10471 match k {
10472 GeneratedField::Patterns => {
10473 if patterns__.is_some() {
10474 return Err(serde::de::Error::duplicate_field("patterns"));
10475 }
10476 patterns__ = Some(map_.next_value()?);
10477 }
10478 }
10479 }
10480 Ok(MatchRecognizePatternSeq {
10481 patterns: patterns__.unwrap_or_default(),
10482 })
10483 }
10484 }
10485 deserializer.deserialize_struct("stream_plan.MatchRecognizePatternSeq", FIELDS, GeneratedVisitor)
10486 }
10487}
10488impl serde::Serialize for MatchRecognizePermutePattern {
10489 #[allow(deprecated)]
10490 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10491 where
10492 S: serde::Serializer,
10493 {
10494 use serde::ser::SerializeStruct;
10495 let mut len = 0;
10496 if !self.vars.is_empty() {
10497 len += 1;
10498 }
10499 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizePermutePattern", len)?;
10500 if !self.vars.is_empty() {
10501 struct_ser.serialize_field("vars", &self.vars)?;
10502 }
10503 struct_ser.end()
10504 }
10505}
10506impl<'de> serde::Deserialize<'de> for MatchRecognizePermutePattern {
10507 #[allow(deprecated)]
10508 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10509 where
10510 D: serde::Deserializer<'de>,
10511 {
10512 const FIELDS: &[&str] = &[
10513 "vars",
10514 ];
10515
10516 #[allow(clippy::enum_variant_names)]
10517 enum GeneratedField {
10518 Vars,
10519 }
10520 impl<'de> serde::Deserialize<'de> for GeneratedField {
10521 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10522 where
10523 D: serde::Deserializer<'de>,
10524 {
10525 struct GeneratedVisitor;
10526
10527 impl serde::de::Visitor<'_> for GeneratedVisitor {
10528 type Value = GeneratedField;
10529
10530 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10531 write!(formatter, "expected one of: {:?}", &FIELDS)
10532 }
10533
10534 #[allow(unused_variables)]
10535 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10536 where
10537 E: serde::de::Error,
10538 {
10539 match value {
10540 "vars" => Ok(GeneratedField::Vars),
10541 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10542 }
10543 }
10544 }
10545 deserializer.deserialize_identifier(GeneratedVisitor)
10546 }
10547 }
10548 struct GeneratedVisitor;
10549 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10550 type Value = MatchRecognizePermutePattern;
10551
10552 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10553 formatter.write_str("struct stream_plan.MatchRecognizePermutePattern")
10554 }
10555
10556 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizePermutePattern, V::Error>
10557 where
10558 V: serde::de::MapAccess<'de>,
10559 {
10560 let mut vars__ = None;
10561 while let Some(k) = map_.next_key()? {
10562 match k {
10563 GeneratedField::Vars => {
10564 if vars__.is_some() {
10565 return Err(serde::de::Error::duplicate_field("vars"));
10566 }
10567 vars__ = Some(map_.next_value()?);
10568 }
10569 }
10570 }
10571 Ok(MatchRecognizePermutePattern {
10572 vars: vars__.unwrap_or_default(),
10573 })
10574 }
10575 }
10576 deserializer.deserialize_struct("stream_plan.MatchRecognizePermutePattern", FIELDS, GeneratedVisitor)
10577 }
10578}
10579impl serde::Serialize for MatchRecognizeQuantifiedPattern {
10580 #[allow(deprecated)]
10581 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10582 where
10583 S: serde::Serializer,
10584 {
10585 use serde::ser::SerializeStruct;
10586 let mut len = 0;
10587 if self.inner.is_some() {
10588 len += 1;
10589 }
10590 if self.quantifier.is_some() {
10591 len += 1;
10592 }
10593 if self.reluctant {
10594 len += 1;
10595 }
10596 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeQuantifiedPattern", len)?;
10597 if let Some(v) = self.inner.as_ref() {
10598 struct_ser.serialize_field("inner", v)?;
10599 }
10600 if let Some(v) = self.quantifier.as_ref() {
10601 struct_ser.serialize_field("quantifier", v)?;
10602 }
10603 if self.reluctant {
10604 struct_ser.serialize_field("reluctant", &self.reluctant)?;
10605 }
10606 struct_ser.end()
10607 }
10608}
10609impl<'de> serde::Deserialize<'de> for MatchRecognizeQuantifiedPattern {
10610 #[allow(deprecated)]
10611 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10612 where
10613 D: serde::Deserializer<'de>,
10614 {
10615 const FIELDS: &[&str] = &[
10616 "inner",
10617 "quantifier",
10618 "reluctant",
10619 ];
10620
10621 #[allow(clippy::enum_variant_names)]
10622 enum GeneratedField {
10623 Inner,
10624 Quantifier,
10625 Reluctant,
10626 }
10627 impl<'de> serde::Deserialize<'de> for GeneratedField {
10628 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10629 where
10630 D: serde::Deserializer<'de>,
10631 {
10632 struct GeneratedVisitor;
10633
10634 impl serde::de::Visitor<'_> for GeneratedVisitor {
10635 type Value = GeneratedField;
10636
10637 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10638 write!(formatter, "expected one of: {:?}", &FIELDS)
10639 }
10640
10641 #[allow(unused_variables)]
10642 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10643 where
10644 E: serde::de::Error,
10645 {
10646 match value {
10647 "inner" => Ok(GeneratedField::Inner),
10648 "quantifier" => Ok(GeneratedField::Quantifier),
10649 "reluctant" => Ok(GeneratedField::Reluctant),
10650 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10651 }
10652 }
10653 }
10654 deserializer.deserialize_identifier(GeneratedVisitor)
10655 }
10656 }
10657 struct GeneratedVisitor;
10658 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10659 type Value = MatchRecognizeQuantifiedPattern;
10660
10661 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10662 formatter.write_str("struct stream_plan.MatchRecognizeQuantifiedPattern")
10663 }
10664
10665 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeQuantifiedPattern, V::Error>
10666 where
10667 V: serde::de::MapAccess<'de>,
10668 {
10669 let mut inner__ = None;
10670 let mut quantifier__ = None;
10671 let mut reluctant__ = None;
10672 while let Some(k) = map_.next_key()? {
10673 match k {
10674 GeneratedField::Inner => {
10675 if inner__.is_some() {
10676 return Err(serde::de::Error::duplicate_field("inner"));
10677 }
10678 inner__ = map_.next_value()?;
10679 }
10680 GeneratedField::Quantifier => {
10681 if quantifier__.is_some() {
10682 return Err(serde::de::Error::duplicate_field("quantifier"));
10683 }
10684 quantifier__ = map_.next_value()?;
10685 }
10686 GeneratedField::Reluctant => {
10687 if reluctant__.is_some() {
10688 return Err(serde::de::Error::duplicate_field("reluctant"));
10689 }
10690 reluctant__ = Some(map_.next_value()?);
10691 }
10692 }
10693 }
10694 Ok(MatchRecognizeQuantifiedPattern {
10695 inner: inner__,
10696 quantifier: quantifier__,
10697 reluctant: reluctant__.unwrap_or_default(),
10698 })
10699 }
10700 }
10701 deserializer.deserialize_struct("stream_plan.MatchRecognizeQuantifiedPattern", FIELDS, GeneratedVisitor)
10702 }
10703}
10704impl serde::Serialize for MatchRecognizeQuantifier {
10705 #[allow(deprecated)]
10706 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10707 where
10708 S: serde::Serializer,
10709 {
10710 use serde::ser::SerializeStruct;
10711 let mut len = 0;
10712 if self.kind != 0 {
10713 len += 1;
10714 }
10715 if self.min != 0 {
10716 len += 1;
10717 }
10718 if self.max.is_some() {
10719 len += 1;
10720 }
10721 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeQuantifier", len)?;
10722 if self.kind != 0 {
10723 let v = match_recognize_quantifier::Kind::try_from(self.kind)
10724 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
10725 struct_ser.serialize_field("kind", &v)?;
10726 }
10727 if self.min != 0 {
10728 struct_ser.serialize_field("min", &self.min)?;
10729 }
10730 if let Some(v) = self.max.as_ref() {
10731 struct_ser.serialize_field("max", v)?;
10732 }
10733 struct_ser.end()
10734 }
10735}
10736impl<'de> serde::Deserialize<'de> for MatchRecognizeQuantifier {
10737 #[allow(deprecated)]
10738 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10739 where
10740 D: serde::Deserializer<'de>,
10741 {
10742 const FIELDS: &[&str] = &[
10743 "kind",
10744 "min",
10745 "max",
10746 ];
10747
10748 #[allow(clippy::enum_variant_names)]
10749 enum GeneratedField {
10750 Kind,
10751 Min,
10752 Max,
10753 }
10754 impl<'de> serde::Deserialize<'de> for GeneratedField {
10755 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10756 where
10757 D: serde::Deserializer<'de>,
10758 {
10759 struct GeneratedVisitor;
10760
10761 impl serde::de::Visitor<'_> for GeneratedVisitor {
10762 type Value = GeneratedField;
10763
10764 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10765 write!(formatter, "expected one of: {:?}", &FIELDS)
10766 }
10767
10768 #[allow(unused_variables)]
10769 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10770 where
10771 E: serde::de::Error,
10772 {
10773 match value {
10774 "kind" => Ok(GeneratedField::Kind),
10775 "min" => Ok(GeneratedField::Min),
10776 "max" => Ok(GeneratedField::Max),
10777 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10778 }
10779 }
10780 }
10781 deserializer.deserialize_identifier(GeneratedVisitor)
10782 }
10783 }
10784 struct GeneratedVisitor;
10785 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10786 type Value = MatchRecognizeQuantifier;
10787
10788 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10789 formatter.write_str("struct stream_plan.MatchRecognizeQuantifier")
10790 }
10791
10792 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeQuantifier, V::Error>
10793 where
10794 V: serde::de::MapAccess<'de>,
10795 {
10796 let mut kind__ = None;
10797 let mut min__ = None;
10798 let mut max__ = None;
10799 while let Some(k) = map_.next_key()? {
10800 match k {
10801 GeneratedField::Kind => {
10802 if kind__.is_some() {
10803 return Err(serde::de::Error::duplicate_field("kind"));
10804 }
10805 kind__ = Some(map_.next_value::<match_recognize_quantifier::Kind>()? as i32);
10806 }
10807 GeneratedField::Min => {
10808 if min__.is_some() {
10809 return Err(serde::de::Error::duplicate_field("min"));
10810 }
10811 min__ =
10812 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10813 ;
10814 }
10815 GeneratedField::Max => {
10816 if max__.is_some() {
10817 return Err(serde::de::Error::duplicate_field("max"));
10818 }
10819 max__ =
10820 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10821 ;
10822 }
10823 }
10824 }
10825 Ok(MatchRecognizeQuantifier {
10826 kind: kind__.unwrap_or_default(),
10827 min: min__.unwrap_or_default(),
10828 max: max__,
10829 })
10830 }
10831 }
10832 deserializer.deserialize_struct("stream_plan.MatchRecognizeQuantifier", FIELDS, GeneratedVisitor)
10833 }
10834}
10835impl serde::Serialize for match_recognize_quantifier::Kind {
10836 #[allow(deprecated)]
10837 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10838 where
10839 S: serde::Serializer,
10840 {
10841 let variant = match self {
10842 Self::Unspecified => "KIND_UNSPECIFIED",
10843 Self::Star => "KIND_STAR",
10844 Self::Plus => "KIND_PLUS",
10845 Self::Question => "KIND_QUESTION",
10846 Self::Range => "KIND_RANGE",
10847 };
10848 serializer.serialize_str(variant)
10849 }
10850}
10851impl<'de> serde::Deserialize<'de> for match_recognize_quantifier::Kind {
10852 #[allow(deprecated)]
10853 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10854 where
10855 D: serde::Deserializer<'de>,
10856 {
10857 const FIELDS: &[&str] = &[
10858 "KIND_UNSPECIFIED",
10859 "KIND_STAR",
10860 "KIND_PLUS",
10861 "KIND_QUESTION",
10862 "KIND_RANGE",
10863 ];
10864
10865 struct GeneratedVisitor;
10866
10867 impl serde::de::Visitor<'_> for GeneratedVisitor {
10868 type Value = match_recognize_quantifier::Kind;
10869
10870 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10871 write!(formatter, "expected one of: {:?}", &FIELDS)
10872 }
10873
10874 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
10875 where
10876 E: serde::de::Error,
10877 {
10878 i32::try_from(v)
10879 .ok()
10880 .and_then(|x| x.try_into().ok())
10881 .ok_or_else(|| {
10882 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
10883 })
10884 }
10885
10886 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
10887 where
10888 E: serde::de::Error,
10889 {
10890 i32::try_from(v)
10891 .ok()
10892 .and_then(|x| x.try_into().ok())
10893 .ok_or_else(|| {
10894 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
10895 })
10896 }
10897
10898 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
10899 where
10900 E: serde::de::Error,
10901 {
10902 match value {
10903 "KIND_UNSPECIFIED" => Ok(match_recognize_quantifier::Kind::Unspecified),
10904 "KIND_STAR" => Ok(match_recognize_quantifier::Kind::Star),
10905 "KIND_PLUS" => Ok(match_recognize_quantifier::Kind::Plus),
10906 "KIND_QUESTION" => Ok(match_recognize_quantifier::Kind::Question),
10907 "KIND_RANGE" => Ok(match_recognize_quantifier::Kind::Range),
10908 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
10909 }
10910 }
10911 }
10912 deserializer.deserialize_any(GeneratedVisitor)
10913 }
10914}
10915impl serde::Serialize for MaterializeNode {
10916 #[allow(deprecated)]
10917 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10918 where
10919 S: serde::Serializer,
10920 {
10921 use serde::ser::SerializeStruct;
10922 let mut len = 0;
10923 if self.table_id != 0 {
10924 len += 1;
10925 }
10926 if !self.column_orders.is_empty() {
10927 len += 1;
10928 }
10929 if self.table.is_some() {
10930 len += 1;
10931 }
10932 if self.staging_table.is_some() {
10933 len += 1;
10934 }
10935 if self.refresh_progress_table.is_some() {
10936 len += 1;
10937 }
10938 if self.cleaned_by_ttl_watermark {
10939 len += 1;
10940 }
10941 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializeNode", len)?;
10942 if self.table_id != 0 {
10943 struct_ser.serialize_field("tableId", &self.table_id)?;
10944 }
10945 if !self.column_orders.is_empty() {
10946 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
10947 }
10948 if let Some(v) = self.table.as_ref() {
10949 struct_ser.serialize_field("table", v)?;
10950 }
10951 if let Some(v) = self.staging_table.as_ref() {
10952 struct_ser.serialize_field("stagingTable", v)?;
10953 }
10954 if let Some(v) = self.refresh_progress_table.as_ref() {
10955 struct_ser.serialize_field("refreshProgressTable", v)?;
10956 }
10957 if self.cleaned_by_ttl_watermark {
10958 struct_ser.serialize_field("cleanedByTtlWatermark", &self.cleaned_by_ttl_watermark)?;
10959 }
10960 struct_ser.end()
10961 }
10962}
10963impl<'de> serde::Deserialize<'de> for MaterializeNode {
10964 #[allow(deprecated)]
10965 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10966 where
10967 D: serde::Deserializer<'de>,
10968 {
10969 const FIELDS: &[&str] = &[
10970 "table_id",
10971 "tableId",
10972 "column_orders",
10973 "columnOrders",
10974 "table",
10975 "staging_table",
10976 "stagingTable",
10977 "refresh_progress_table",
10978 "refreshProgressTable",
10979 "cleaned_by_ttl_watermark",
10980 "cleanedByTtlWatermark",
10981 ];
10982
10983 #[allow(clippy::enum_variant_names)]
10984 enum GeneratedField {
10985 TableId,
10986 ColumnOrders,
10987 Table,
10988 StagingTable,
10989 RefreshProgressTable,
10990 CleanedByTtlWatermark,
10991 }
10992 impl<'de> serde::Deserialize<'de> for GeneratedField {
10993 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10994 where
10995 D: serde::Deserializer<'de>,
10996 {
10997 struct GeneratedVisitor;
10998
10999 impl serde::de::Visitor<'_> for GeneratedVisitor {
11000 type Value = GeneratedField;
11001
11002 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11003 write!(formatter, "expected one of: {:?}", &FIELDS)
11004 }
11005
11006 #[allow(unused_variables)]
11007 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11008 where
11009 E: serde::de::Error,
11010 {
11011 match value {
11012 "tableId" | "table_id" => Ok(GeneratedField::TableId),
11013 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
11014 "table" => Ok(GeneratedField::Table),
11015 "stagingTable" | "staging_table" => Ok(GeneratedField::StagingTable),
11016 "refreshProgressTable" | "refresh_progress_table" => Ok(GeneratedField::RefreshProgressTable),
11017 "cleanedByTtlWatermark" | "cleaned_by_ttl_watermark" => Ok(GeneratedField::CleanedByTtlWatermark),
11018 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11019 }
11020 }
11021 }
11022 deserializer.deserialize_identifier(GeneratedVisitor)
11023 }
11024 }
11025 struct GeneratedVisitor;
11026 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11027 type Value = MaterializeNode;
11028
11029 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11030 formatter.write_str("struct stream_plan.MaterializeNode")
11031 }
11032
11033 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializeNode, V::Error>
11034 where
11035 V: serde::de::MapAccess<'de>,
11036 {
11037 let mut table_id__ = None;
11038 let mut column_orders__ = None;
11039 let mut table__ = None;
11040 let mut staging_table__ = None;
11041 let mut refresh_progress_table__ = None;
11042 let mut cleaned_by_ttl_watermark__ = None;
11043 while let Some(k) = map_.next_key()? {
11044 match k {
11045 GeneratedField::TableId => {
11046 if table_id__.is_some() {
11047 return Err(serde::de::Error::duplicate_field("tableId"));
11048 }
11049 table_id__ =
11050 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11051 ;
11052 }
11053 GeneratedField::ColumnOrders => {
11054 if column_orders__.is_some() {
11055 return Err(serde::de::Error::duplicate_field("columnOrders"));
11056 }
11057 column_orders__ = Some(map_.next_value()?);
11058 }
11059 GeneratedField::Table => {
11060 if table__.is_some() {
11061 return Err(serde::de::Error::duplicate_field("table"));
11062 }
11063 table__ = map_.next_value()?;
11064 }
11065 GeneratedField::StagingTable => {
11066 if staging_table__.is_some() {
11067 return Err(serde::de::Error::duplicate_field("stagingTable"));
11068 }
11069 staging_table__ = map_.next_value()?;
11070 }
11071 GeneratedField::RefreshProgressTable => {
11072 if refresh_progress_table__.is_some() {
11073 return Err(serde::de::Error::duplicate_field("refreshProgressTable"));
11074 }
11075 refresh_progress_table__ = map_.next_value()?;
11076 }
11077 GeneratedField::CleanedByTtlWatermark => {
11078 if cleaned_by_ttl_watermark__.is_some() {
11079 return Err(serde::de::Error::duplicate_field("cleanedByTtlWatermark"));
11080 }
11081 cleaned_by_ttl_watermark__ = Some(map_.next_value()?);
11082 }
11083 }
11084 }
11085 Ok(MaterializeNode {
11086 table_id: table_id__.unwrap_or_default(),
11087 column_orders: column_orders__.unwrap_or_default(),
11088 table: table__,
11089 staging_table: staging_table__,
11090 refresh_progress_table: refresh_progress_table__,
11091 cleaned_by_ttl_watermark: cleaned_by_ttl_watermark__.unwrap_or_default(),
11092 })
11093 }
11094 }
11095 deserializer.deserialize_struct("stream_plan.MaterializeNode", FIELDS, GeneratedVisitor)
11096 }
11097}
11098impl serde::Serialize for MaterializedExprsNode {
11099 #[allow(deprecated)]
11100 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11101 where
11102 S: serde::Serializer,
11103 {
11104 use serde::ser::SerializeStruct;
11105 let mut len = 0;
11106 if !self.exprs.is_empty() {
11107 len += 1;
11108 }
11109 if self.state_table.is_some() {
11110 len += 1;
11111 }
11112 if self.state_clean_col_idx.is_some() {
11113 len += 1;
11114 }
11115 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializedExprsNode", len)?;
11116 if !self.exprs.is_empty() {
11117 struct_ser.serialize_field("exprs", &self.exprs)?;
11118 }
11119 if let Some(v) = self.state_table.as_ref() {
11120 struct_ser.serialize_field("stateTable", v)?;
11121 }
11122 if let Some(v) = self.state_clean_col_idx.as_ref() {
11123 struct_ser.serialize_field("stateCleanColIdx", v)?;
11124 }
11125 struct_ser.end()
11126 }
11127}
11128impl<'de> serde::Deserialize<'de> for MaterializedExprsNode {
11129 #[allow(deprecated)]
11130 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11131 where
11132 D: serde::Deserializer<'de>,
11133 {
11134 const FIELDS: &[&str] = &[
11135 "exprs",
11136 "state_table",
11137 "stateTable",
11138 "state_clean_col_idx",
11139 "stateCleanColIdx",
11140 ];
11141
11142 #[allow(clippy::enum_variant_names)]
11143 enum GeneratedField {
11144 Exprs,
11145 StateTable,
11146 StateCleanColIdx,
11147 }
11148 impl<'de> serde::Deserialize<'de> for GeneratedField {
11149 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11150 where
11151 D: serde::Deserializer<'de>,
11152 {
11153 struct GeneratedVisitor;
11154
11155 impl serde::de::Visitor<'_> for GeneratedVisitor {
11156 type Value = GeneratedField;
11157
11158 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11159 write!(formatter, "expected one of: {:?}", &FIELDS)
11160 }
11161
11162 #[allow(unused_variables)]
11163 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11164 where
11165 E: serde::de::Error,
11166 {
11167 match value {
11168 "exprs" => Ok(GeneratedField::Exprs),
11169 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11170 "stateCleanColIdx" | "state_clean_col_idx" => Ok(GeneratedField::StateCleanColIdx),
11171 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11172 }
11173 }
11174 }
11175 deserializer.deserialize_identifier(GeneratedVisitor)
11176 }
11177 }
11178 struct GeneratedVisitor;
11179 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11180 type Value = MaterializedExprsNode;
11181
11182 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11183 formatter.write_str("struct stream_plan.MaterializedExprsNode")
11184 }
11185
11186 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializedExprsNode, V::Error>
11187 where
11188 V: serde::de::MapAccess<'de>,
11189 {
11190 let mut exprs__ = None;
11191 let mut state_table__ = None;
11192 let mut state_clean_col_idx__ = None;
11193 while let Some(k) = map_.next_key()? {
11194 match k {
11195 GeneratedField::Exprs => {
11196 if exprs__.is_some() {
11197 return Err(serde::de::Error::duplicate_field("exprs"));
11198 }
11199 exprs__ = Some(map_.next_value()?);
11200 }
11201 GeneratedField::StateTable => {
11202 if state_table__.is_some() {
11203 return Err(serde::de::Error::duplicate_field("stateTable"));
11204 }
11205 state_table__ = map_.next_value()?;
11206 }
11207 GeneratedField::StateCleanColIdx => {
11208 if state_clean_col_idx__.is_some() {
11209 return Err(serde::de::Error::duplicate_field("stateCleanColIdx"));
11210 }
11211 state_clean_col_idx__ =
11212 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11213 ;
11214 }
11215 }
11216 }
11217 Ok(MaterializedExprsNode {
11218 exprs: exprs__.unwrap_or_default(),
11219 state_table: state_table__,
11220 state_clean_col_idx: state_clean_col_idx__,
11221 })
11222 }
11223 }
11224 deserializer.deserialize_struct("stream_plan.MaterializedExprsNode", FIELDS, GeneratedVisitor)
11225 }
11226}
11227impl serde::Serialize for MergeNode {
11228 #[allow(deprecated)]
11229 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11230 where
11231 S: serde::Serializer,
11232 {
11233 use serde::ser::SerializeStruct;
11234 let mut len = 0;
11235 if !self.upstream_actor_id.is_empty() {
11236 len += 1;
11237 }
11238 if self.upstream_fragment_id != 0 {
11239 len += 1;
11240 }
11241 if self.upstream_dispatcher_type != 0 {
11242 len += 1;
11243 }
11244 if !self.fields.is_empty() {
11245 len += 1;
11246 }
11247 if self.allow_empty_upstream {
11248 len += 1;
11249 }
11250 let mut struct_ser = serializer.serialize_struct("stream_plan.MergeNode", len)?;
11251 if !self.upstream_actor_id.is_empty() {
11252 struct_ser.serialize_field("upstreamActorId", &self.upstream_actor_id)?;
11253 }
11254 if self.upstream_fragment_id != 0 {
11255 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
11256 }
11257 if self.upstream_dispatcher_type != 0 {
11258 let v = DispatcherType::try_from(self.upstream_dispatcher_type)
11259 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.upstream_dispatcher_type)))?;
11260 struct_ser.serialize_field("upstreamDispatcherType", &v)?;
11261 }
11262 if !self.fields.is_empty() {
11263 struct_ser.serialize_field("fields", &self.fields)?;
11264 }
11265 if self.allow_empty_upstream {
11266 struct_ser.serialize_field("allowEmptyUpstream", &self.allow_empty_upstream)?;
11267 }
11268 struct_ser.end()
11269 }
11270}
11271impl<'de> serde::Deserialize<'de> for MergeNode {
11272 #[allow(deprecated)]
11273 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11274 where
11275 D: serde::Deserializer<'de>,
11276 {
11277 const FIELDS: &[&str] = &[
11278 "upstream_actor_id",
11279 "upstreamActorId",
11280 "upstream_fragment_id",
11281 "upstreamFragmentId",
11282 "upstream_dispatcher_type",
11283 "upstreamDispatcherType",
11284 "fields",
11285 "allow_empty_upstream",
11286 "allowEmptyUpstream",
11287 ];
11288
11289 #[allow(clippy::enum_variant_names)]
11290 enum GeneratedField {
11291 UpstreamActorId,
11292 UpstreamFragmentId,
11293 UpstreamDispatcherType,
11294 Fields,
11295 AllowEmptyUpstream,
11296 }
11297 impl<'de> serde::Deserialize<'de> for GeneratedField {
11298 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11299 where
11300 D: serde::Deserializer<'de>,
11301 {
11302 struct GeneratedVisitor;
11303
11304 impl serde::de::Visitor<'_> for GeneratedVisitor {
11305 type Value = GeneratedField;
11306
11307 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11308 write!(formatter, "expected one of: {:?}", &FIELDS)
11309 }
11310
11311 #[allow(unused_variables)]
11312 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11313 where
11314 E: serde::de::Error,
11315 {
11316 match value {
11317 "upstreamActorId" | "upstream_actor_id" => Ok(GeneratedField::UpstreamActorId),
11318 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
11319 "upstreamDispatcherType" | "upstream_dispatcher_type" => Ok(GeneratedField::UpstreamDispatcherType),
11320 "fields" => Ok(GeneratedField::Fields),
11321 "allowEmptyUpstream" | "allow_empty_upstream" => Ok(GeneratedField::AllowEmptyUpstream),
11322 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11323 }
11324 }
11325 }
11326 deserializer.deserialize_identifier(GeneratedVisitor)
11327 }
11328 }
11329 struct GeneratedVisitor;
11330 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11331 type Value = MergeNode;
11332
11333 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11334 formatter.write_str("struct stream_plan.MergeNode")
11335 }
11336
11337 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeNode, V::Error>
11338 where
11339 V: serde::de::MapAccess<'de>,
11340 {
11341 let mut upstream_actor_id__ = None;
11342 let mut upstream_fragment_id__ = None;
11343 let mut upstream_dispatcher_type__ = None;
11344 let mut fields__ = None;
11345 let mut allow_empty_upstream__ = None;
11346 while let Some(k) = map_.next_key()? {
11347 match k {
11348 GeneratedField::UpstreamActorId => {
11349 if upstream_actor_id__.is_some() {
11350 return Err(serde::de::Error::duplicate_field("upstreamActorId"));
11351 }
11352 upstream_actor_id__ =
11353 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11354 .into_iter().map(|x| x.0).collect())
11355 ;
11356 }
11357 GeneratedField::UpstreamFragmentId => {
11358 if upstream_fragment_id__.is_some() {
11359 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
11360 }
11361 upstream_fragment_id__ =
11362 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11363 ;
11364 }
11365 GeneratedField::UpstreamDispatcherType => {
11366 if upstream_dispatcher_type__.is_some() {
11367 return Err(serde::de::Error::duplicate_field("upstreamDispatcherType"));
11368 }
11369 upstream_dispatcher_type__ = Some(map_.next_value::<DispatcherType>()? as i32);
11370 }
11371 GeneratedField::Fields => {
11372 if fields__.is_some() {
11373 return Err(serde::de::Error::duplicate_field("fields"));
11374 }
11375 fields__ = Some(map_.next_value()?);
11376 }
11377 GeneratedField::AllowEmptyUpstream => {
11378 if allow_empty_upstream__.is_some() {
11379 return Err(serde::de::Error::duplicate_field("allowEmptyUpstream"));
11380 }
11381 allow_empty_upstream__ = Some(map_.next_value()?);
11382 }
11383 }
11384 }
11385 Ok(MergeNode {
11386 upstream_actor_id: upstream_actor_id__.unwrap_or_default(),
11387 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
11388 upstream_dispatcher_type: upstream_dispatcher_type__.unwrap_or_default(),
11389 fields: fields__.unwrap_or_default(),
11390 allow_empty_upstream: allow_empty_upstream__.unwrap_or_default(),
11391 })
11392 }
11393 }
11394 deserializer.deserialize_struct("stream_plan.MergeNode", FIELDS, GeneratedVisitor)
11395 }
11396}
11397impl serde::Serialize for NoOpNode {
11398 #[allow(deprecated)]
11399 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11400 where
11401 S: serde::Serializer,
11402 {
11403 use serde::ser::SerializeStruct;
11404 let len = 0;
11405 let struct_ser = serializer.serialize_struct("stream_plan.NoOpNode", len)?;
11406 struct_ser.end()
11407 }
11408}
11409impl<'de> serde::Deserialize<'de> for NoOpNode {
11410 #[allow(deprecated)]
11411 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11412 where
11413 D: serde::Deserializer<'de>,
11414 {
11415 const FIELDS: &[&str] = &[
11416 ];
11417
11418 #[allow(clippy::enum_variant_names)]
11419 enum GeneratedField {
11420 }
11421 impl<'de> serde::Deserialize<'de> for GeneratedField {
11422 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11423 where
11424 D: serde::Deserializer<'de>,
11425 {
11426 struct GeneratedVisitor;
11427
11428 impl serde::de::Visitor<'_> for GeneratedVisitor {
11429 type Value = GeneratedField;
11430
11431 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11432 write!(formatter, "expected one of: {:?}", &FIELDS)
11433 }
11434
11435 #[allow(unused_variables)]
11436 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11437 where
11438 E: serde::de::Error,
11439 {
11440 Err(serde::de::Error::unknown_field(value, FIELDS))
11441 }
11442 }
11443 deserializer.deserialize_identifier(GeneratedVisitor)
11444 }
11445 }
11446 struct GeneratedVisitor;
11447 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11448 type Value = NoOpNode;
11449
11450 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11451 formatter.write_str("struct stream_plan.NoOpNode")
11452 }
11453
11454 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NoOpNode, V::Error>
11455 where
11456 V: serde::de::MapAccess<'de>,
11457 {
11458 while map_.next_key::<GeneratedField>()?.is_some() {
11459 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11460 }
11461 Ok(NoOpNode {
11462 })
11463 }
11464 }
11465 deserializer.deserialize_struct("stream_plan.NoOpNode", FIELDS, GeneratedVisitor)
11466 }
11467}
11468impl serde::Serialize for NowModeGenerateSeries {
11469 #[allow(deprecated)]
11470 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11471 where
11472 S: serde::Serializer,
11473 {
11474 use serde::ser::SerializeStruct;
11475 let mut len = 0;
11476 if self.start_timestamp.is_some() {
11477 len += 1;
11478 }
11479 if self.interval.is_some() {
11480 len += 1;
11481 }
11482 let mut struct_ser = serializer.serialize_struct("stream_plan.NowModeGenerateSeries", len)?;
11483 if let Some(v) = self.start_timestamp.as_ref() {
11484 struct_ser.serialize_field("startTimestamp", v)?;
11485 }
11486 if let Some(v) = self.interval.as_ref() {
11487 struct_ser.serialize_field("interval", v)?;
11488 }
11489 struct_ser.end()
11490 }
11491}
11492impl<'de> serde::Deserialize<'de> for NowModeGenerateSeries {
11493 #[allow(deprecated)]
11494 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11495 where
11496 D: serde::Deserializer<'de>,
11497 {
11498 const FIELDS: &[&str] = &[
11499 "start_timestamp",
11500 "startTimestamp",
11501 "interval",
11502 ];
11503
11504 #[allow(clippy::enum_variant_names)]
11505 enum GeneratedField {
11506 StartTimestamp,
11507 Interval,
11508 }
11509 impl<'de> serde::Deserialize<'de> for GeneratedField {
11510 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11511 where
11512 D: serde::Deserializer<'de>,
11513 {
11514 struct GeneratedVisitor;
11515
11516 impl serde::de::Visitor<'_> for GeneratedVisitor {
11517 type Value = GeneratedField;
11518
11519 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11520 write!(formatter, "expected one of: {:?}", &FIELDS)
11521 }
11522
11523 #[allow(unused_variables)]
11524 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11525 where
11526 E: serde::de::Error,
11527 {
11528 match value {
11529 "startTimestamp" | "start_timestamp" => Ok(GeneratedField::StartTimestamp),
11530 "interval" => Ok(GeneratedField::Interval),
11531 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11532 }
11533 }
11534 }
11535 deserializer.deserialize_identifier(GeneratedVisitor)
11536 }
11537 }
11538 struct GeneratedVisitor;
11539 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11540 type Value = NowModeGenerateSeries;
11541
11542 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11543 formatter.write_str("struct stream_plan.NowModeGenerateSeries")
11544 }
11545
11546 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeGenerateSeries, V::Error>
11547 where
11548 V: serde::de::MapAccess<'de>,
11549 {
11550 let mut start_timestamp__ = None;
11551 let mut interval__ = None;
11552 while let Some(k) = map_.next_key()? {
11553 match k {
11554 GeneratedField::StartTimestamp => {
11555 if start_timestamp__.is_some() {
11556 return Err(serde::de::Error::duplicate_field("startTimestamp"));
11557 }
11558 start_timestamp__ = map_.next_value()?;
11559 }
11560 GeneratedField::Interval => {
11561 if interval__.is_some() {
11562 return Err(serde::de::Error::duplicate_field("interval"));
11563 }
11564 interval__ = map_.next_value()?;
11565 }
11566 }
11567 }
11568 Ok(NowModeGenerateSeries {
11569 start_timestamp: start_timestamp__,
11570 interval: interval__,
11571 })
11572 }
11573 }
11574 deserializer.deserialize_struct("stream_plan.NowModeGenerateSeries", FIELDS, GeneratedVisitor)
11575 }
11576}
11577impl serde::Serialize for NowModeUpdateCurrent {
11578 #[allow(deprecated)]
11579 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11580 where
11581 S: serde::Serializer,
11582 {
11583 use serde::ser::SerializeStruct;
11584 let len = 0;
11585 let struct_ser = serializer.serialize_struct("stream_plan.NowModeUpdateCurrent", len)?;
11586 struct_ser.end()
11587 }
11588}
11589impl<'de> serde::Deserialize<'de> for NowModeUpdateCurrent {
11590 #[allow(deprecated)]
11591 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11592 where
11593 D: serde::Deserializer<'de>,
11594 {
11595 const FIELDS: &[&str] = &[
11596 ];
11597
11598 #[allow(clippy::enum_variant_names)]
11599 enum GeneratedField {
11600 }
11601 impl<'de> serde::Deserialize<'de> for GeneratedField {
11602 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11603 where
11604 D: serde::Deserializer<'de>,
11605 {
11606 struct GeneratedVisitor;
11607
11608 impl serde::de::Visitor<'_> for GeneratedVisitor {
11609 type Value = GeneratedField;
11610
11611 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11612 write!(formatter, "expected one of: {:?}", &FIELDS)
11613 }
11614
11615 #[allow(unused_variables)]
11616 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11617 where
11618 E: serde::de::Error,
11619 {
11620 Err(serde::de::Error::unknown_field(value, FIELDS))
11621 }
11622 }
11623 deserializer.deserialize_identifier(GeneratedVisitor)
11624 }
11625 }
11626 struct GeneratedVisitor;
11627 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11628 type Value = NowModeUpdateCurrent;
11629
11630 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11631 formatter.write_str("struct stream_plan.NowModeUpdateCurrent")
11632 }
11633
11634 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeUpdateCurrent, V::Error>
11635 where
11636 V: serde::de::MapAccess<'de>,
11637 {
11638 while map_.next_key::<GeneratedField>()?.is_some() {
11639 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11640 }
11641 Ok(NowModeUpdateCurrent {
11642 })
11643 }
11644 }
11645 deserializer.deserialize_struct("stream_plan.NowModeUpdateCurrent", FIELDS, GeneratedVisitor)
11646 }
11647}
11648impl serde::Serialize for NowNode {
11649 #[allow(deprecated)]
11650 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11651 where
11652 S: serde::Serializer,
11653 {
11654 use serde::ser::SerializeStruct;
11655 let mut len = 0;
11656 if self.state_table.is_some() {
11657 len += 1;
11658 }
11659 if self.mode.is_some() {
11660 len += 1;
11661 }
11662 let mut struct_ser = serializer.serialize_struct("stream_plan.NowNode", len)?;
11663 if let Some(v) = self.state_table.as_ref() {
11664 struct_ser.serialize_field("stateTable", v)?;
11665 }
11666 if let Some(v) = self.mode.as_ref() {
11667 match v {
11668 now_node::Mode::UpdateCurrent(v) => {
11669 struct_ser.serialize_field("updateCurrent", v)?;
11670 }
11671 now_node::Mode::GenerateSeries(v) => {
11672 struct_ser.serialize_field("generateSeries", v)?;
11673 }
11674 }
11675 }
11676 struct_ser.end()
11677 }
11678}
11679impl<'de> serde::Deserialize<'de> for NowNode {
11680 #[allow(deprecated)]
11681 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11682 where
11683 D: serde::Deserializer<'de>,
11684 {
11685 const FIELDS: &[&str] = &[
11686 "state_table",
11687 "stateTable",
11688 "update_current",
11689 "updateCurrent",
11690 "generate_series",
11691 "generateSeries",
11692 ];
11693
11694 #[allow(clippy::enum_variant_names)]
11695 enum GeneratedField {
11696 StateTable,
11697 UpdateCurrent,
11698 GenerateSeries,
11699 }
11700 impl<'de> serde::Deserialize<'de> for GeneratedField {
11701 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11702 where
11703 D: serde::Deserializer<'de>,
11704 {
11705 struct GeneratedVisitor;
11706
11707 impl serde::de::Visitor<'_> for GeneratedVisitor {
11708 type Value = GeneratedField;
11709
11710 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11711 write!(formatter, "expected one of: {:?}", &FIELDS)
11712 }
11713
11714 #[allow(unused_variables)]
11715 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11716 where
11717 E: serde::de::Error,
11718 {
11719 match value {
11720 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11721 "updateCurrent" | "update_current" => Ok(GeneratedField::UpdateCurrent),
11722 "generateSeries" | "generate_series" => Ok(GeneratedField::GenerateSeries),
11723 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11724 }
11725 }
11726 }
11727 deserializer.deserialize_identifier(GeneratedVisitor)
11728 }
11729 }
11730 struct GeneratedVisitor;
11731 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11732 type Value = NowNode;
11733
11734 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11735 formatter.write_str("struct stream_plan.NowNode")
11736 }
11737
11738 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowNode, V::Error>
11739 where
11740 V: serde::de::MapAccess<'de>,
11741 {
11742 let mut state_table__ = None;
11743 let mut mode__ = None;
11744 while let Some(k) = map_.next_key()? {
11745 match k {
11746 GeneratedField::StateTable => {
11747 if state_table__.is_some() {
11748 return Err(serde::de::Error::duplicate_field("stateTable"));
11749 }
11750 state_table__ = map_.next_value()?;
11751 }
11752 GeneratedField::UpdateCurrent => {
11753 if mode__.is_some() {
11754 return Err(serde::de::Error::duplicate_field("updateCurrent"));
11755 }
11756 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::UpdateCurrent)
11757;
11758 }
11759 GeneratedField::GenerateSeries => {
11760 if mode__.is_some() {
11761 return Err(serde::de::Error::duplicate_field("generateSeries"));
11762 }
11763 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::GenerateSeries)
11764;
11765 }
11766 }
11767 }
11768 Ok(NowNode {
11769 state_table: state_table__,
11770 mode: mode__,
11771 })
11772 }
11773 }
11774 deserializer.deserialize_struct("stream_plan.NowNode", FIELDS, GeneratedVisitor)
11775 }
11776}
11777impl serde::Serialize for OverWindowCachePolicy {
11778 #[allow(deprecated)]
11779 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11780 where
11781 S: serde::Serializer,
11782 {
11783 let variant = match self {
11784 Self::Unspecified => "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
11785 Self::Full => "OVER_WINDOW_CACHE_POLICY_FULL",
11786 Self::Recent => "OVER_WINDOW_CACHE_POLICY_RECENT",
11787 Self::RecentFirstN => "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
11788 Self::RecentLastN => "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
11789 };
11790 serializer.serialize_str(variant)
11791 }
11792}
11793impl<'de> serde::Deserialize<'de> for OverWindowCachePolicy {
11794 #[allow(deprecated)]
11795 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11796 where
11797 D: serde::Deserializer<'de>,
11798 {
11799 const FIELDS: &[&str] = &[
11800 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
11801 "OVER_WINDOW_CACHE_POLICY_FULL",
11802 "OVER_WINDOW_CACHE_POLICY_RECENT",
11803 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
11804 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
11805 ];
11806
11807 struct GeneratedVisitor;
11808
11809 impl serde::de::Visitor<'_> for GeneratedVisitor {
11810 type Value = OverWindowCachePolicy;
11811
11812 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11813 write!(formatter, "expected one of: {:?}", &FIELDS)
11814 }
11815
11816 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
11817 where
11818 E: serde::de::Error,
11819 {
11820 i32::try_from(v)
11821 .ok()
11822 .and_then(|x| x.try_into().ok())
11823 .ok_or_else(|| {
11824 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
11825 })
11826 }
11827
11828 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
11829 where
11830 E: serde::de::Error,
11831 {
11832 i32::try_from(v)
11833 .ok()
11834 .and_then(|x| x.try_into().ok())
11835 .ok_or_else(|| {
11836 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
11837 })
11838 }
11839
11840 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
11841 where
11842 E: serde::de::Error,
11843 {
11844 match value {
11845 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED" => Ok(OverWindowCachePolicy::Unspecified),
11846 "OVER_WINDOW_CACHE_POLICY_FULL" => Ok(OverWindowCachePolicy::Full),
11847 "OVER_WINDOW_CACHE_POLICY_RECENT" => Ok(OverWindowCachePolicy::Recent),
11848 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N" => Ok(OverWindowCachePolicy::RecentFirstN),
11849 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N" => Ok(OverWindowCachePolicy::RecentLastN),
11850 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
11851 }
11852 }
11853 }
11854 deserializer.deserialize_any(GeneratedVisitor)
11855 }
11856}
11857impl serde::Serialize for OverWindowNode {
11858 #[allow(deprecated)]
11859 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11860 where
11861 S: serde::Serializer,
11862 {
11863 use serde::ser::SerializeStruct;
11864 let mut len = 0;
11865 if !self.calls.is_empty() {
11866 len += 1;
11867 }
11868 if !self.partition_by.is_empty() {
11869 len += 1;
11870 }
11871 if !self.order_by.is_empty() {
11872 len += 1;
11873 }
11874 if self.state_table.is_some() {
11875 len += 1;
11876 }
11877 if self.cache_policy != 0 {
11878 len += 1;
11879 }
11880 if self.enable_state_cleaning {
11881 len += 1;
11882 }
11883 let mut struct_ser = serializer.serialize_struct("stream_plan.OverWindowNode", len)?;
11884 if !self.calls.is_empty() {
11885 struct_ser.serialize_field("calls", &self.calls)?;
11886 }
11887 if !self.partition_by.is_empty() {
11888 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
11889 }
11890 if !self.order_by.is_empty() {
11891 struct_ser.serialize_field("orderBy", &self.order_by)?;
11892 }
11893 if let Some(v) = self.state_table.as_ref() {
11894 struct_ser.serialize_field("stateTable", v)?;
11895 }
11896 if self.cache_policy != 0 {
11897 let v = OverWindowCachePolicy::try_from(self.cache_policy)
11898 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cache_policy)))?;
11899 struct_ser.serialize_field("cachePolicy", &v)?;
11900 }
11901 if self.enable_state_cleaning {
11902 struct_ser.serialize_field("enableStateCleaning", &self.enable_state_cleaning)?;
11903 }
11904 struct_ser.end()
11905 }
11906}
11907impl<'de> serde::Deserialize<'de> for OverWindowNode {
11908 #[allow(deprecated)]
11909 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11910 where
11911 D: serde::Deserializer<'de>,
11912 {
11913 const FIELDS: &[&str] = &[
11914 "calls",
11915 "partition_by",
11916 "partitionBy",
11917 "order_by",
11918 "orderBy",
11919 "state_table",
11920 "stateTable",
11921 "cache_policy",
11922 "cachePolicy",
11923 "enable_state_cleaning",
11924 "enableStateCleaning",
11925 ];
11926
11927 #[allow(clippy::enum_variant_names)]
11928 enum GeneratedField {
11929 Calls,
11930 PartitionBy,
11931 OrderBy,
11932 StateTable,
11933 CachePolicy,
11934 EnableStateCleaning,
11935 }
11936 impl<'de> serde::Deserialize<'de> for GeneratedField {
11937 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11938 where
11939 D: serde::Deserializer<'de>,
11940 {
11941 struct GeneratedVisitor;
11942
11943 impl serde::de::Visitor<'_> for GeneratedVisitor {
11944 type Value = GeneratedField;
11945
11946 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11947 write!(formatter, "expected one of: {:?}", &FIELDS)
11948 }
11949
11950 #[allow(unused_variables)]
11951 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11952 where
11953 E: serde::de::Error,
11954 {
11955 match value {
11956 "calls" => Ok(GeneratedField::Calls),
11957 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
11958 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
11959 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11960 "cachePolicy" | "cache_policy" => Ok(GeneratedField::CachePolicy),
11961 "enableStateCleaning" | "enable_state_cleaning" => Ok(GeneratedField::EnableStateCleaning),
11962 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11963 }
11964 }
11965 }
11966 deserializer.deserialize_identifier(GeneratedVisitor)
11967 }
11968 }
11969 struct GeneratedVisitor;
11970 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11971 type Value = OverWindowNode;
11972
11973 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11974 formatter.write_str("struct stream_plan.OverWindowNode")
11975 }
11976
11977 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverWindowNode, V::Error>
11978 where
11979 V: serde::de::MapAccess<'de>,
11980 {
11981 let mut calls__ = None;
11982 let mut partition_by__ = None;
11983 let mut order_by__ = None;
11984 let mut state_table__ = None;
11985 let mut cache_policy__ = None;
11986 let mut enable_state_cleaning__ = None;
11987 while let Some(k) = map_.next_key()? {
11988 match k {
11989 GeneratedField::Calls => {
11990 if calls__.is_some() {
11991 return Err(serde::de::Error::duplicate_field("calls"));
11992 }
11993 calls__ = Some(map_.next_value()?);
11994 }
11995 GeneratedField::PartitionBy => {
11996 if partition_by__.is_some() {
11997 return Err(serde::de::Error::duplicate_field("partitionBy"));
11998 }
11999 partition_by__ =
12000 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12001 .into_iter().map(|x| x.0).collect())
12002 ;
12003 }
12004 GeneratedField::OrderBy => {
12005 if order_by__.is_some() {
12006 return Err(serde::de::Error::duplicate_field("orderBy"));
12007 }
12008 order_by__ = Some(map_.next_value()?);
12009 }
12010 GeneratedField::StateTable => {
12011 if state_table__.is_some() {
12012 return Err(serde::de::Error::duplicate_field("stateTable"));
12013 }
12014 state_table__ = map_.next_value()?;
12015 }
12016 GeneratedField::CachePolicy => {
12017 if cache_policy__.is_some() {
12018 return Err(serde::de::Error::duplicate_field("cachePolicy"));
12019 }
12020 cache_policy__ = Some(map_.next_value::<OverWindowCachePolicy>()? as i32);
12021 }
12022 GeneratedField::EnableStateCleaning => {
12023 if enable_state_cleaning__.is_some() {
12024 return Err(serde::de::Error::duplicate_field("enableStateCleaning"));
12025 }
12026 enable_state_cleaning__ = Some(map_.next_value()?);
12027 }
12028 }
12029 }
12030 Ok(OverWindowNode {
12031 calls: calls__.unwrap_or_default(),
12032 partition_by: partition_by__.unwrap_or_default(),
12033 order_by: order_by__.unwrap_or_default(),
12034 state_table: state_table__,
12035 cache_policy: cache_policy__.unwrap_or_default(),
12036 enable_state_cleaning: enable_state_cleaning__.unwrap_or_default(),
12037 })
12038 }
12039 }
12040 deserializer.deserialize_struct("stream_plan.OverWindowNode", FIELDS, GeneratedVisitor)
12041 }
12042}
12043impl serde::Serialize for PauseMutation {
12044 #[allow(deprecated)]
12045 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12046 where
12047 S: serde::Serializer,
12048 {
12049 use serde::ser::SerializeStruct;
12050 let len = 0;
12051 let struct_ser = serializer.serialize_struct("stream_plan.PauseMutation", len)?;
12052 struct_ser.end()
12053 }
12054}
12055impl<'de> serde::Deserialize<'de> for PauseMutation {
12056 #[allow(deprecated)]
12057 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12058 where
12059 D: serde::Deserializer<'de>,
12060 {
12061 const FIELDS: &[&str] = &[
12062 ];
12063
12064 #[allow(clippy::enum_variant_names)]
12065 enum GeneratedField {
12066 }
12067 impl<'de> serde::Deserialize<'de> for GeneratedField {
12068 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12069 where
12070 D: serde::Deserializer<'de>,
12071 {
12072 struct GeneratedVisitor;
12073
12074 impl serde::de::Visitor<'_> for GeneratedVisitor {
12075 type Value = GeneratedField;
12076
12077 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12078 write!(formatter, "expected one of: {:?}", &FIELDS)
12079 }
12080
12081 #[allow(unused_variables)]
12082 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12083 where
12084 E: serde::de::Error,
12085 {
12086 Err(serde::de::Error::unknown_field(value, FIELDS))
12087 }
12088 }
12089 deserializer.deserialize_identifier(GeneratedVisitor)
12090 }
12091 }
12092 struct GeneratedVisitor;
12093 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12094 type Value = PauseMutation;
12095
12096 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12097 formatter.write_str("struct stream_plan.PauseMutation")
12098 }
12099
12100 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseMutation, V::Error>
12101 where
12102 V: serde::de::MapAccess<'de>,
12103 {
12104 while map_.next_key::<GeneratedField>()?.is_some() {
12105 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12106 }
12107 Ok(PauseMutation {
12108 })
12109 }
12110 }
12111 deserializer.deserialize_struct("stream_plan.PauseMutation", FIELDS, GeneratedVisitor)
12112 }
12113}
12114impl serde::Serialize for ProjectNode {
12115 #[allow(deprecated)]
12116 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12117 where
12118 S: serde::Serializer,
12119 {
12120 use serde::ser::SerializeStruct;
12121 let mut len = 0;
12122 if !self.select_list.is_empty() {
12123 len += 1;
12124 }
12125 if !self.watermark_input_cols.is_empty() {
12126 len += 1;
12127 }
12128 if !self.watermark_output_cols.is_empty() {
12129 len += 1;
12130 }
12131 if !self.nondecreasing_exprs.is_empty() {
12132 len += 1;
12133 }
12134 if self.noop_update_hint {
12135 len += 1;
12136 }
12137 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectNode", len)?;
12138 if !self.select_list.is_empty() {
12139 struct_ser.serialize_field("selectList", &self.select_list)?;
12140 }
12141 if !self.watermark_input_cols.is_empty() {
12142 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
12143 }
12144 if !self.watermark_output_cols.is_empty() {
12145 struct_ser.serialize_field("watermarkOutputCols", &self.watermark_output_cols)?;
12146 }
12147 if !self.nondecreasing_exprs.is_empty() {
12148 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
12149 }
12150 if self.noop_update_hint {
12151 struct_ser.serialize_field("noopUpdateHint", &self.noop_update_hint)?;
12152 }
12153 struct_ser.end()
12154 }
12155}
12156impl<'de> serde::Deserialize<'de> for ProjectNode {
12157 #[allow(deprecated)]
12158 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12159 where
12160 D: serde::Deserializer<'de>,
12161 {
12162 const FIELDS: &[&str] = &[
12163 "select_list",
12164 "selectList",
12165 "watermark_input_cols",
12166 "watermarkInputCols",
12167 "watermark_output_cols",
12168 "watermarkOutputCols",
12169 "nondecreasing_exprs",
12170 "nondecreasingExprs",
12171 "noop_update_hint",
12172 "noopUpdateHint",
12173 ];
12174
12175 #[allow(clippy::enum_variant_names)]
12176 enum GeneratedField {
12177 SelectList,
12178 WatermarkInputCols,
12179 WatermarkOutputCols,
12180 NondecreasingExprs,
12181 NoopUpdateHint,
12182 }
12183 impl<'de> serde::Deserialize<'de> for GeneratedField {
12184 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12185 where
12186 D: serde::Deserializer<'de>,
12187 {
12188 struct GeneratedVisitor;
12189
12190 impl serde::de::Visitor<'_> for GeneratedVisitor {
12191 type Value = GeneratedField;
12192
12193 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12194 write!(formatter, "expected one of: {:?}", &FIELDS)
12195 }
12196
12197 #[allow(unused_variables)]
12198 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12199 where
12200 E: serde::de::Error,
12201 {
12202 match value {
12203 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
12204 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
12205 "watermarkOutputCols" | "watermark_output_cols" => Ok(GeneratedField::WatermarkOutputCols),
12206 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
12207 "noopUpdateHint" | "noop_update_hint" => Ok(GeneratedField::NoopUpdateHint),
12208 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12209 }
12210 }
12211 }
12212 deserializer.deserialize_identifier(GeneratedVisitor)
12213 }
12214 }
12215 struct GeneratedVisitor;
12216 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12217 type Value = ProjectNode;
12218
12219 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12220 formatter.write_str("struct stream_plan.ProjectNode")
12221 }
12222
12223 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
12224 where
12225 V: serde::de::MapAccess<'de>,
12226 {
12227 let mut select_list__ = None;
12228 let mut watermark_input_cols__ = None;
12229 let mut watermark_output_cols__ = None;
12230 let mut nondecreasing_exprs__ = None;
12231 let mut noop_update_hint__ = None;
12232 while let Some(k) = map_.next_key()? {
12233 match k {
12234 GeneratedField::SelectList => {
12235 if select_list__.is_some() {
12236 return Err(serde::de::Error::duplicate_field("selectList"));
12237 }
12238 select_list__ = Some(map_.next_value()?);
12239 }
12240 GeneratedField::WatermarkInputCols => {
12241 if watermark_input_cols__.is_some() {
12242 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
12243 }
12244 watermark_input_cols__ =
12245 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12246 .into_iter().map(|x| x.0).collect())
12247 ;
12248 }
12249 GeneratedField::WatermarkOutputCols => {
12250 if watermark_output_cols__.is_some() {
12251 return Err(serde::de::Error::duplicate_field("watermarkOutputCols"));
12252 }
12253 watermark_output_cols__ =
12254 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12255 .into_iter().map(|x| x.0).collect())
12256 ;
12257 }
12258 GeneratedField::NondecreasingExprs => {
12259 if nondecreasing_exprs__.is_some() {
12260 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
12261 }
12262 nondecreasing_exprs__ =
12263 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12264 .into_iter().map(|x| x.0).collect())
12265 ;
12266 }
12267 GeneratedField::NoopUpdateHint => {
12268 if noop_update_hint__.is_some() {
12269 return Err(serde::de::Error::duplicate_field("noopUpdateHint"));
12270 }
12271 noop_update_hint__ = Some(map_.next_value()?);
12272 }
12273 }
12274 }
12275 Ok(ProjectNode {
12276 select_list: select_list__.unwrap_or_default(),
12277 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
12278 watermark_output_cols: watermark_output_cols__.unwrap_or_default(),
12279 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
12280 noop_update_hint: noop_update_hint__.unwrap_or_default(),
12281 })
12282 }
12283 }
12284 deserializer.deserialize_struct("stream_plan.ProjectNode", FIELDS, GeneratedVisitor)
12285 }
12286}
12287impl serde::Serialize for ProjectSetNode {
12288 #[allow(deprecated)]
12289 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12290 where
12291 S: serde::Serializer,
12292 {
12293 use serde::ser::SerializeStruct;
12294 let mut len = 0;
12295 if !self.select_list.is_empty() {
12296 len += 1;
12297 }
12298 if !self.watermark_input_cols.is_empty() {
12299 len += 1;
12300 }
12301 if !self.watermark_expr_indices.is_empty() {
12302 len += 1;
12303 }
12304 if !self.nondecreasing_exprs.is_empty() {
12305 len += 1;
12306 }
12307 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectSetNode", len)?;
12308 if !self.select_list.is_empty() {
12309 struct_ser.serialize_field("selectList", &self.select_list)?;
12310 }
12311 if !self.watermark_input_cols.is_empty() {
12312 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
12313 }
12314 if !self.watermark_expr_indices.is_empty() {
12315 struct_ser.serialize_field("watermarkExprIndices", &self.watermark_expr_indices)?;
12316 }
12317 if !self.nondecreasing_exprs.is_empty() {
12318 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
12319 }
12320 struct_ser.end()
12321 }
12322}
12323impl<'de> serde::Deserialize<'de> for ProjectSetNode {
12324 #[allow(deprecated)]
12325 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12326 where
12327 D: serde::Deserializer<'de>,
12328 {
12329 const FIELDS: &[&str] = &[
12330 "select_list",
12331 "selectList",
12332 "watermark_input_cols",
12333 "watermarkInputCols",
12334 "watermark_expr_indices",
12335 "watermarkExprIndices",
12336 "nondecreasing_exprs",
12337 "nondecreasingExprs",
12338 ];
12339
12340 #[allow(clippy::enum_variant_names)]
12341 enum GeneratedField {
12342 SelectList,
12343 WatermarkInputCols,
12344 WatermarkExprIndices,
12345 NondecreasingExprs,
12346 }
12347 impl<'de> serde::Deserialize<'de> for GeneratedField {
12348 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12349 where
12350 D: serde::Deserializer<'de>,
12351 {
12352 struct GeneratedVisitor;
12353
12354 impl serde::de::Visitor<'_> for GeneratedVisitor {
12355 type Value = GeneratedField;
12356
12357 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12358 write!(formatter, "expected one of: {:?}", &FIELDS)
12359 }
12360
12361 #[allow(unused_variables)]
12362 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12363 where
12364 E: serde::de::Error,
12365 {
12366 match value {
12367 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
12368 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
12369 "watermarkExprIndices" | "watermark_expr_indices" => Ok(GeneratedField::WatermarkExprIndices),
12370 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
12371 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12372 }
12373 }
12374 }
12375 deserializer.deserialize_identifier(GeneratedVisitor)
12376 }
12377 }
12378 struct GeneratedVisitor;
12379 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12380 type Value = ProjectSetNode;
12381
12382 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12383 formatter.write_str("struct stream_plan.ProjectSetNode")
12384 }
12385
12386 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
12387 where
12388 V: serde::de::MapAccess<'de>,
12389 {
12390 let mut select_list__ = None;
12391 let mut watermark_input_cols__ = None;
12392 let mut watermark_expr_indices__ = None;
12393 let mut nondecreasing_exprs__ = None;
12394 while let Some(k) = map_.next_key()? {
12395 match k {
12396 GeneratedField::SelectList => {
12397 if select_list__.is_some() {
12398 return Err(serde::de::Error::duplicate_field("selectList"));
12399 }
12400 select_list__ = Some(map_.next_value()?);
12401 }
12402 GeneratedField::WatermarkInputCols => {
12403 if watermark_input_cols__.is_some() {
12404 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
12405 }
12406 watermark_input_cols__ =
12407 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12408 .into_iter().map(|x| x.0).collect())
12409 ;
12410 }
12411 GeneratedField::WatermarkExprIndices => {
12412 if watermark_expr_indices__.is_some() {
12413 return Err(serde::de::Error::duplicate_field("watermarkExprIndices"));
12414 }
12415 watermark_expr_indices__ =
12416 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12417 .into_iter().map(|x| x.0).collect())
12418 ;
12419 }
12420 GeneratedField::NondecreasingExprs => {
12421 if nondecreasing_exprs__.is_some() {
12422 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
12423 }
12424 nondecreasing_exprs__ =
12425 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12426 .into_iter().map(|x| x.0).collect())
12427 ;
12428 }
12429 }
12430 }
12431 Ok(ProjectSetNode {
12432 select_list: select_list__.unwrap_or_default(),
12433 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
12434 watermark_expr_indices: watermark_expr_indices__.unwrap_or_default(),
12435 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
12436 })
12437 }
12438 }
12439 deserializer.deserialize_struct("stream_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
12440 }
12441}
12442impl serde::Serialize for RefreshStartMutation {
12443 #[allow(deprecated)]
12444 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12445 where
12446 S: serde::Serializer,
12447 {
12448 use serde::ser::SerializeStruct;
12449 let mut len = 0;
12450 if self.table_id != 0 {
12451 len += 1;
12452 }
12453 if self.associated_source_id != 0 {
12454 len += 1;
12455 }
12456 let mut struct_ser = serializer.serialize_struct("stream_plan.RefreshStartMutation", len)?;
12457 if self.table_id != 0 {
12458 struct_ser.serialize_field("tableId", &self.table_id)?;
12459 }
12460 if self.associated_source_id != 0 {
12461 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
12462 }
12463 struct_ser.end()
12464 }
12465}
12466impl<'de> serde::Deserialize<'de> for RefreshStartMutation {
12467 #[allow(deprecated)]
12468 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12469 where
12470 D: serde::Deserializer<'de>,
12471 {
12472 const FIELDS: &[&str] = &[
12473 "table_id",
12474 "tableId",
12475 "associated_source_id",
12476 "associatedSourceId",
12477 ];
12478
12479 #[allow(clippy::enum_variant_names)]
12480 enum GeneratedField {
12481 TableId,
12482 AssociatedSourceId,
12483 }
12484 impl<'de> serde::Deserialize<'de> for GeneratedField {
12485 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12486 where
12487 D: serde::Deserializer<'de>,
12488 {
12489 struct GeneratedVisitor;
12490
12491 impl serde::de::Visitor<'_> for GeneratedVisitor {
12492 type Value = GeneratedField;
12493
12494 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12495 write!(formatter, "expected one of: {:?}", &FIELDS)
12496 }
12497
12498 #[allow(unused_variables)]
12499 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12500 where
12501 E: serde::de::Error,
12502 {
12503 match value {
12504 "tableId" | "table_id" => Ok(GeneratedField::TableId),
12505 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
12506 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12507 }
12508 }
12509 }
12510 deserializer.deserialize_identifier(GeneratedVisitor)
12511 }
12512 }
12513 struct GeneratedVisitor;
12514 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12515 type Value = RefreshStartMutation;
12516
12517 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12518 formatter.write_str("struct stream_plan.RefreshStartMutation")
12519 }
12520
12521 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshStartMutation, V::Error>
12522 where
12523 V: serde::de::MapAccess<'de>,
12524 {
12525 let mut table_id__ = None;
12526 let mut associated_source_id__ = None;
12527 while let Some(k) = map_.next_key()? {
12528 match k {
12529 GeneratedField::TableId => {
12530 if table_id__.is_some() {
12531 return Err(serde::de::Error::duplicate_field("tableId"));
12532 }
12533 table_id__ =
12534 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12535 ;
12536 }
12537 GeneratedField::AssociatedSourceId => {
12538 if associated_source_id__.is_some() {
12539 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
12540 }
12541 associated_source_id__ =
12542 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12543 ;
12544 }
12545 }
12546 }
12547 Ok(RefreshStartMutation {
12548 table_id: table_id__.unwrap_or_default(),
12549 associated_source_id: associated_source_id__.unwrap_or_default(),
12550 })
12551 }
12552 }
12553 deserializer.deserialize_struct("stream_plan.RefreshStartMutation", FIELDS, GeneratedVisitor)
12554 }
12555}
12556impl serde::Serialize for ResetSourceMutation {
12557 #[allow(deprecated)]
12558 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12559 where
12560 S: serde::Serializer,
12561 {
12562 use serde::ser::SerializeStruct;
12563 let mut len = 0;
12564 if self.source_id != 0 {
12565 len += 1;
12566 }
12567 let mut struct_ser = serializer.serialize_struct("stream_plan.ResetSourceMutation", len)?;
12568 if self.source_id != 0 {
12569 struct_ser.serialize_field("sourceId", &self.source_id)?;
12570 }
12571 struct_ser.end()
12572 }
12573}
12574impl<'de> serde::Deserialize<'de> for ResetSourceMutation {
12575 #[allow(deprecated)]
12576 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12577 where
12578 D: serde::Deserializer<'de>,
12579 {
12580 const FIELDS: &[&str] = &[
12581 "source_id",
12582 "sourceId",
12583 ];
12584
12585 #[allow(clippy::enum_variant_names)]
12586 enum GeneratedField {
12587 SourceId,
12588 }
12589 impl<'de> serde::Deserialize<'de> for GeneratedField {
12590 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12591 where
12592 D: serde::Deserializer<'de>,
12593 {
12594 struct GeneratedVisitor;
12595
12596 impl serde::de::Visitor<'_> for GeneratedVisitor {
12597 type Value = GeneratedField;
12598
12599 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12600 write!(formatter, "expected one of: {:?}", &FIELDS)
12601 }
12602
12603 #[allow(unused_variables)]
12604 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12605 where
12606 E: serde::de::Error,
12607 {
12608 match value {
12609 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
12610 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12611 }
12612 }
12613 }
12614 deserializer.deserialize_identifier(GeneratedVisitor)
12615 }
12616 }
12617 struct GeneratedVisitor;
12618 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12619 type Value = ResetSourceMutation;
12620
12621 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12622 formatter.write_str("struct stream_plan.ResetSourceMutation")
12623 }
12624
12625 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceMutation, V::Error>
12626 where
12627 V: serde::de::MapAccess<'de>,
12628 {
12629 let mut source_id__ = None;
12630 while let Some(k) = map_.next_key()? {
12631 match k {
12632 GeneratedField::SourceId => {
12633 if source_id__.is_some() {
12634 return Err(serde::de::Error::duplicate_field("sourceId"));
12635 }
12636 source_id__ =
12637 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12638 ;
12639 }
12640 }
12641 }
12642 Ok(ResetSourceMutation {
12643 source_id: source_id__.unwrap_or_default(),
12644 })
12645 }
12646 }
12647 deserializer.deserialize_struct("stream_plan.ResetSourceMutation", FIELDS, GeneratedVisitor)
12648 }
12649}
12650impl serde::Serialize for ResumeMutation {
12651 #[allow(deprecated)]
12652 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12653 where
12654 S: serde::Serializer,
12655 {
12656 use serde::ser::SerializeStruct;
12657 let len = 0;
12658 let struct_ser = serializer.serialize_struct("stream_plan.ResumeMutation", len)?;
12659 struct_ser.end()
12660 }
12661}
12662impl<'de> serde::Deserialize<'de> for ResumeMutation {
12663 #[allow(deprecated)]
12664 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12665 where
12666 D: serde::Deserializer<'de>,
12667 {
12668 const FIELDS: &[&str] = &[
12669 ];
12670
12671 #[allow(clippy::enum_variant_names)]
12672 enum GeneratedField {
12673 }
12674 impl<'de> serde::Deserialize<'de> for GeneratedField {
12675 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12676 where
12677 D: serde::Deserializer<'de>,
12678 {
12679 struct GeneratedVisitor;
12680
12681 impl serde::de::Visitor<'_> for GeneratedVisitor {
12682 type Value = GeneratedField;
12683
12684 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12685 write!(formatter, "expected one of: {:?}", &FIELDS)
12686 }
12687
12688 #[allow(unused_variables)]
12689 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12690 where
12691 E: serde::de::Error,
12692 {
12693 Err(serde::de::Error::unknown_field(value, FIELDS))
12694 }
12695 }
12696 deserializer.deserialize_identifier(GeneratedVisitor)
12697 }
12698 }
12699 struct GeneratedVisitor;
12700 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12701 type Value = ResumeMutation;
12702
12703 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12704 formatter.write_str("struct stream_plan.ResumeMutation")
12705 }
12706
12707 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeMutation, V::Error>
12708 where
12709 V: serde::de::MapAccess<'de>,
12710 {
12711 while map_.next_key::<GeneratedField>()?.is_some() {
12712 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12713 }
12714 Ok(ResumeMutation {
12715 })
12716 }
12717 }
12718 deserializer.deserialize_struct("stream_plan.ResumeMutation", FIELDS, GeneratedVisitor)
12719 }
12720}
12721impl serde::Serialize for RowIdGenNode {
12722 #[allow(deprecated)]
12723 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12724 where
12725 S: serde::Serializer,
12726 {
12727 use serde::ser::SerializeStruct;
12728 let mut len = 0;
12729 if self.row_id_index != 0 {
12730 len += 1;
12731 }
12732 let mut struct_ser = serializer.serialize_struct("stream_plan.RowIdGenNode", len)?;
12733 if self.row_id_index != 0 {
12734 #[allow(clippy::needless_borrow)]
12735 #[allow(clippy::needless_borrows_for_generic_args)]
12736 struct_ser.serialize_field("rowIdIndex", ToString::to_string(&self.row_id_index).as_str())?;
12737 }
12738 struct_ser.end()
12739 }
12740}
12741impl<'de> serde::Deserialize<'de> for RowIdGenNode {
12742 #[allow(deprecated)]
12743 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12744 where
12745 D: serde::Deserializer<'de>,
12746 {
12747 const FIELDS: &[&str] = &[
12748 "row_id_index",
12749 "rowIdIndex",
12750 ];
12751
12752 #[allow(clippy::enum_variant_names)]
12753 enum GeneratedField {
12754 RowIdIndex,
12755 }
12756 impl<'de> serde::Deserialize<'de> for GeneratedField {
12757 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12758 where
12759 D: serde::Deserializer<'de>,
12760 {
12761 struct GeneratedVisitor;
12762
12763 impl serde::de::Visitor<'_> for GeneratedVisitor {
12764 type Value = GeneratedField;
12765
12766 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12767 write!(formatter, "expected one of: {:?}", &FIELDS)
12768 }
12769
12770 #[allow(unused_variables)]
12771 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12772 where
12773 E: serde::de::Error,
12774 {
12775 match value {
12776 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
12777 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12778 }
12779 }
12780 }
12781 deserializer.deserialize_identifier(GeneratedVisitor)
12782 }
12783 }
12784 struct GeneratedVisitor;
12785 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12786 type Value = RowIdGenNode;
12787
12788 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12789 formatter.write_str("struct stream_plan.RowIdGenNode")
12790 }
12791
12792 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowIdGenNode, V::Error>
12793 where
12794 V: serde::de::MapAccess<'de>,
12795 {
12796 let mut row_id_index__ = None;
12797 while let Some(k) = map_.next_key()? {
12798 match k {
12799 GeneratedField::RowIdIndex => {
12800 if row_id_index__.is_some() {
12801 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
12802 }
12803 row_id_index__ =
12804 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12805 ;
12806 }
12807 }
12808 }
12809 Ok(RowIdGenNode {
12810 row_id_index: row_id_index__.unwrap_or_default(),
12811 })
12812 }
12813 }
12814 deserializer.deserialize_struct("stream_plan.RowIdGenNode", FIELDS, GeneratedVisitor)
12815 }
12816}
12817impl serde::Serialize for RowMergeNode {
12818 #[allow(deprecated)]
12819 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12820 where
12821 S: serde::Serializer,
12822 {
12823 use serde::ser::SerializeStruct;
12824 let mut len = 0;
12825 if self.lhs_mapping.is_some() {
12826 len += 1;
12827 }
12828 if self.rhs_mapping.is_some() {
12829 len += 1;
12830 }
12831 let mut struct_ser = serializer.serialize_struct("stream_plan.RowMergeNode", len)?;
12832 if let Some(v) = self.lhs_mapping.as_ref() {
12833 struct_ser.serialize_field("lhsMapping", v)?;
12834 }
12835 if let Some(v) = self.rhs_mapping.as_ref() {
12836 struct_ser.serialize_field("rhsMapping", v)?;
12837 }
12838 struct_ser.end()
12839 }
12840}
12841impl<'de> serde::Deserialize<'de> for RowMergeNode {
12842 #[allow(deprecated)]
12843 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12844 where
12845 D: serde::Deserializer<'de>,
12846 {
12847 const FIELDS: &[&str] = &[
12848 "lhs_mapping",
12849 "lhsMapping",
12850 "rhs_mapping",
12851 "rhsMapping",
12852 ];
12853
12854 #[allow(clippy::enum_variant_names)]
12855 enum GeneratedField {
12856 LhsMapping,
12857 RhsMapping,
12858 }
12859 impl<'de> serde::Deserialize<'de> for GeneratedField {
12860 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12861 where
12862 D: serde::Deserializer<'de>,
12863 {
12864 struct GeneratedVisitor;
12865
12866 impl serde::de::Visitor<'_> for GeneratedVisitor {
12867 type Value = GeneratedField;
12868
12869 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12870 write!(formatter, "expected one of: {:?}", &FIELDS)
12871 }
12872
12873 #[allow(unused_variables)]
12874 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12875 where
12876 E: serde::de::Error,
12877 {
12878 match value {
12879 "lhsMapping" | "lhs_mapping" => Ok(GeneratedField::LhsMapping),
12880 "rhsMapping" | "rhs_mapping" => Ok(GeneratedField::RhsMapping),
12881 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12882 }
12883 }
12884 }
12885 deserializer.deserialize_identifier(GeneratedVisitor)
12886 }
12887 }
12888 struct GeneratedVisitor;
12889 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12890 type Value = RowMergeNode;
12891
12892 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12893 formatter.write_str("struct stream_plan.RowMergeNode")
12894 }
12895
12896 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowMergeNode, V::Error>
12897 where
12898 V: serde::de::MapAccess<'de>,
12899 {
12900 let mut lhs_mapping__ = None;
12901 let mut rhs_mapping__ = None;
12902 while let Some(k) = map_.next_key()? {
12903 match k {
12904 GeneratedField::LhsMapping => {
12905 if lhs_mapping__.is_some() {
12906 return Err(serde::de::Error::duplicate_field("lhsMapping"));
12907 }
12908 lhs_mapping__ = map_.next_value()?;
12909 }
12910 GeneratedField::RhsMapping => {
12911 if rhs_mapping__.is_some() {
12912 return Err(serde::de::Error::duplicate_field("rhsMapping"));
12913 }
12914 rhs_mapping__ = map_.next_value()?;
12915 }
12916 }
12917 }
12918 Ok(RowMergeNode {
12919 lhs_mapping: lhs_mapping__,
12920 rhs_mapping: rhs_mapping__,
12921 })
12922 }
12923 }
12924 deserializer.deserialize_struct("stream_plan.RowMergeNode", FIELDS, GeneratedVisitor)
12925 }
12926}
12927impl serde::Serialize for SimpleAggNode {
12928 #[allow(deprecated)]
12929 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12930 where
12931 S: serde::Serializer,
12932 {
12933 use serde::ser::SerializeStruct;
12934 let mut len = 0;
12935 if !self.agg_calls.is_empty() {
12936 len += 1;
12937 }
12938 if !self.agg_call_states.is_empty() {
12939 len += 1;
12940 }
12941 if self.intermediate_state_table.is_some() {
12942 len += 1;
12943 }
12944 if self.is_append_only {
12945 len += 1;
12946 }
12947 if !self.distinct_dedup_tables.is_empty() {
12948 len += 1;
12949 }
12950 if self.row_count_index != 0 {
12951 len += 1;
12952 }
12953 if self.version != 0 {
12954 len += 1;
12955 }
12956 if self.must_output_per_barrier {
12957 len += 1;
12958 }
12959 let mut struct_ser = serializer.serialize_struct("stream_plan.SimpleAggNode", len)?;
12960 if !self.agg_calls.is_empty() {
12961 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
12962 }
12963 if !self.agg_call_states.is_empty() {
12964 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
12965 }
12966 if let Some(v) = self.intermediate_state_table.as_ref() {
12967 struct_ser.serialize_field("intermediateStateTable", v)?;
12968 }
12969 if self.is_append_only {
12970 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
12971 }
12972 if !self.distinct_dedup_tables.is_empty() {
12973 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
12974 }
12975 if self.row_count_index != 0 {
12976 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
12977 }
12978 if self.version != 0 {
12979 let v = AggNodeVersion::try_from(self.version)
12980 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
12981 struct_ser.serialize_field("version", &v)?;
12982 }
12983 if self.must_output_per_barrier {
12984 struct_ser.serialize_field("mustOutputPerBarrier", &self.must_output_per_barrier)?;
12985 }
12986 struct_ser.end()
12987 }
12988}
12989impl<'de> serde::Deserialize<'de> for SimpleAggNode {
12990 #[allow(deprecated)]
12991 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12992 where
12993 D: serde::Deserializer<'de>,
12994 {
12995 const FIELDS: &[&str] = &[
12996 "agg_calls",
12997 "aggCalls",
12998 "agg_call_states",
12999 "aggCallStates",
13000 "intermediate_state_table",
13001 "intermediateStateTable",
13002 "is_append_only",
13003 "isAppendOnly",
13004 "distinct_dedup_tables",
13005 "distinctDedupTables",
13006 "row_count_index",
13007 "rowCountIndex",
13008 "version",
13009 "must_output_per_barrier",
13010 "mustOutputPerBarrier",
13011 ];
13012
13013 #[allow(clippy::enum_variant_names)]
13014 enum GeneratedField {
13015 AggCalls,
13016 AggCallStates,
13017 IntermediateStateTable,
13018 IsAppendOnly,
13019 DistinctDedupTables,
13020 RowCountIndex,
13021 Version,
13022 MustOutputPerBarrier,
13023 }
13024 impl<'de> serde::Deserialize<'de> for GeneratedField {
13025 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13026 where
13027 D: serde::Deserializer<'de>,
13028 {
13029 struct GeneratedVisitor;
13030
13031 impl serde::de::Visitor<'_> for GeneratedVisitor {
13032 type Value = GeneratedField;
13033
13034 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13035 write!(formatter, "expected one of: {:?}", &FIELDS)
13036 }
13037
13038 #[allow(unused_variables)]
13039 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13040 where
13041 E: serde::de::Error,
13042 {
13043 match value {
13044 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
13045 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
13046 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
13047 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
13048 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
13049 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
13050 "version" => Ok(GeneratedField::Version),
13051 "mustOutputPerBarrier" | "must_output_per_barrier" => Ok(GeneratedField::MustOutputPerBarrier),
13052 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13053 }
13054 }
13055 }
13056 deserializer.deserialize_identifier(GeneratedVisitor)
13057 }
13058 }
13059 struct GeneratedVisitor;
13060 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13061 type Value = SimpleAggNode;
13062
13063 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13064 formatter.write_str("struct stream_plan.SimpleAggNode")
13065 }
13066
13067 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SimpleAggNode, V::Error>
13068 where
13069 V: serde::de::MapAccess<'de>,
13070 {
13071 let mut agg_calls__ = None;
13072 let mut agg_call_states__ = None;
13073 let mut intermediate_state_table__ = None;
13074 let mut is_append_only__ = None;
13075 let mut distinct_dedup_tables__ = None;
13076 let mut row_count_index__ = None;
13077 let mut version__ = None;
13078 let mut must_output_per_barrier__ = None;
13079 while let Some(k) = map_.next_key()? {
13080 match k {
13081 GeneratedField::AggCalls => {
13082 if agg_calls__.is_some() {
13083 return Err(serde::de::Error::duplicate_field("aggCalls"));
13084 }
13085 agg_calls__ = Some(map_.next_value()?);
13086 }
13087 GeneratedField::AggCallStates => {
13088 if agg_call_states__.is_some() {
13089 return Err(serde::de::Error::duplicate_field("aggCallStates"));
13090 }
13091 agg_call_states__ = Some(map_.next_value()?);
13092 }
13093 GeneratedField::IntermediateStateTable => {
13094 if intermediate_state_table__.is_some() {
13095 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
13096 }
13097 intermediate_state_table__ = map_.next_value()?;
13098 }
13099 GeneratedField::IsAppendOnly => {
13100 if is_append_only__.is_some() {
13101 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
13102 }
13103 is_append_only__ = Some(map_.next_value()?);
13104 }
13105 GeneratedField::DistinctDedupTables => {
13106 if distinct_dedup_tables__.is_some() {
13107 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
13108 }
13109 distinct_dedup_tables__ = Some(
13110 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
13111 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
13112 );
13113 }
13114 GeneratedField::RowCountIndex => {
13115 if row_count_index__.is_some() {
13116 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
13117 }
13118 row_count_index__ =
13119 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13120 ;
13121 }
13122 GeneratedField::Version => {
13123 if version__.is_some() {
13124 return Err(serde::de::Error::duplicate_field("version"));
13125 }
13126 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
13127 }
13128 GeneratedField::MustOutputPerBarrier => {
13129 if must_output_per_barrier__.is_some() {
13130 return Err(serde::de::Error::duplicate_field("mustOutputPerBarrier"));
13131 }
13132 must_output_per_barrier__ = Some(map_.next_value()?);
13133 }
13134 }
13135 }
13136 Ok(SimpleAggNode {
13137 agg_calls: agg_calls__.unwrap_or_default(),
13138 agg_call_states: agg_call_states__.unwrap_or_default(),
13139 intermediate_state_table: intermediate_state_table__,
13140 is_append_only: is_append_only__.unwrap_or_default(),
13141 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
13142 row_count_index: row_count_index__.unwrap_or_default(),
13143 version: version__.unwrap_or_default(),
13144 must_output_per_barrier: must_output_per_barrier__.unwrap_or_default(),
13145 })
13146 }
13147 }
13148 deserializer.deserialize_struct("stream_plan.SimpleAggNode", FIELDS, GeneratedVisitor)
13149 }
13150}
13151impl serde::Serialize for SinkAddColumnsOp {
13152 #[allow(deprecated)]
13153 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13154 where
13155 S: serde::Serializer,
13156 {
13157 use serde::ser::SerializeStruct;
13158 let mut len = 0;
13159 if !self.fields.is_empty() {
13160 len += 1;
13161 }
13162 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkAddColumnsOp", len)?;
13163 if !self.fields.is_empty() {
13164 struct_ser.serialize_field("fields", &self.fields)?;
13165 }
13166 struct_ser.end()
13167 }
13168}
13169impl<'de> serde::Deserialize<'de> for SinkAddColumnsOp {
13170 #[allow(deprecated)]
13171 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13172 where
13173 D: serde::Deserializer<'de>,
13174 {
13175 const FIELDS: &[&str] = &[
13176 "fields",
13177 ];
13178
13179 #[allow(clippy::enum_variant_names)]
13180 enum GeneratedField {
13181 Fields,
13182 }
13183 impl<'de> serde::Deserialize<'de> for GeneratedField {
13184 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13185 where
13186 D: serde::Deserializer<'de>,
13187 {
13188 struct GeneratedVisitor;
13189
13190 impl serde::de::Visitor<'_> for GeneratedVisitor {
13191 type Value = GeneratedField;
13192
13193 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13194 write!(formatter, "expected one of: {:?}", &FIELDS)
13195 }
13196
13197 #[allow(unused_variables)]
13198 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13199 where
13200 E: serde::de::Error,
13201 {
13202 match value {
13203 "fields" => Ok(GeneratedField::Fields),
13204 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13205 }
13206 }
13207 }
13208 deserializer.deserialize_identifier(GeneratedVisitor)
13209 }
13210 }
13211 struct GeneratedVisitor;
13212 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13213 type Value = SinkAddColumnsOp;
13214
13215 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13216 formatter.write_str("struct stream_plan.SinkAddColumnsOp")
13217 }
13218
13219 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkAddColumnsOp, V::Error>
13220 where
13221 V: serde::de::MapAccess<'de>,
13222 {
13223 let mut fields__ = None;
13224 while let Some(k) = map_.next_key()? {
13225 match k {
13226 GeneratedField::Fields => {
13227 if fields__.is_some() {
13228 return Err(serde::de::Error::duplicate_field("fields"));
13229 }
13230 fields__ = Some(map_.next_value()?);
13231 }
13232 }
13233 }
13234 Ok(SinkAddColumnsOp {
13235 fields: fields__.unwrap_or_default(),
13236 })
13237 }
13238 }
13239 deserializer.deserialize_struct("stream_plan.SinkAddColumnsOp", FIELDS, GeneratedVisitor)
13240 }
13241}
13242impl serde::Serialize for SinkDesc {
13243 #[allow(deprecated)]
13244 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13245 where
13246 S: serde::Serializer,
13247 {
13248 use serde::ser::SerializeStruct;
13249 let mut len = 0;
13250 if self.id != 0 {
13251 len += 1;
13252 }
13253 if !self.name.is_empty() {
13254 len += 1;
13255 }
13256 if !self.definition.is_empty() {
13257 len += 1;
13258 }
13259 if !self.plan_pk.is_empty() {
13260 len += 1;
13261 }
13262 if !self.downstream_pk.is_empty() {
13263 len += 1;
13264 }
13265 if !self.distribution_key.is_empty() {
13266 len += 1;
13267 }
13268 if !self.properties.is_empty() {
13269 len += 1;
13270 }
13271 if self.sink_type != 0 {
13272 len += 1;
13273 }
13274 if !self.column_catalogs.is_empty() {
13275 len += 1;
13276 }
13277 if !self.db_name.is_empty() {
13278 len += 1;
13279 }
13280 if !self.sink_from_name.is_empty() {
13281 len += 1;
13282 }
13283 if self.format_desc.is_some() {
13284 len += 1;
13285 }
13286 if self.target_table.is_some() {
13287 len += 1;
13288 }
13289 if self.extra_partition_col_idx.is_some() {
13290 len += 1;
13291 }
13292 if !self.secret_refs.is_empty() {
13293 len += 1;
13294 }
13295 if self.raw_ignore_delete {
13296 len += 1;
13297 }
13298 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDesc", len)?;
13299 if self.id != 0 {
13300 struct_ser.serialize_field("id", &self.id)?;
13301 }
13302 if !self.name.is_empty() {
13303 struct_ser.serialize_field("name", &self.name)?;
13304 }
13305 if !self.definition.is_empty() {
13306 struct_ser.serialize_field("definition", &self.definition)?;
13307 }
13308 if !self.plan_pk.is_empty() {
13309 struct_ser.serialize_field("planPk", &self.plan_pk)?;
13310 }
13311 if !self.downstream_pk.is_empty() {
13312 struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
13313 }
13314 if !self.distribution_key.is_empty() {
13315 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
13316 }
13317 if !self.properties.is_empty() {
13318 struct_ser.serialize_field("properties", &self.properties)?;
13319 }
13320 if self.sink_type != 0 {
13321 let v = super::catalog::SinkType::try_from(self.sink_type)
13322 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
13323 struct_ser.serialize_field("sinkType", &v)?;
13324 }
13325 if !self.column_catalogs.is_empty() {
13326 struct_ser.serialize_field("columnCatalogs", &self.column_catalogs)?;
13327 }
13328 if !self.db_name.is_empty() {
13329 struct_ser.serialize_field("dbName", &self.db_name)?;
13330 }
13331 if !self.sink_from_name.is_empty() {
13332 struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
13333 }
13334 if let Some(v) = self.format_desc.as_ref() {
13335 struct_ser.serialize_field("formatDesc", v)?;
13336 }
13337 if let Some(v) = self.target_table.as_ref() {
13338 struct_ser.serialize_field("targetTable", v)?;
13339 }
13340 if let Some(v) = self.extra_partition_col_idx.as_ref() {
13341 #[allow(clippy::needless_borrow)]
13342 #[allow(clippy::needless_borrows_for_generic_args)]
13343 struct_ser.serialize_field("extraPartitionColIdx", ToString::to_string(&v).as_str())?;
13344 }
13345 if !self.secret_refs.is_empty() {
13346 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
13347 }
13348 if self.raw_ignore_delete {
13349 struct_ser.serialize_field("rawIgnoreDelete", &self.raw_ignore_delete)?;
13350 }
13351 struct_ser.end()
13352 }
13353}
13354impl<'de> serde::Deserialize<'de> for SinkDesc {
13355 #[allow(deprecated)]
13356 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13357 where
13358 D: serde::Deserializer<'de>,
13359 {
13360 const FIELDS: &[&str] = &[
13361 "id",
13362 "name",
13363 "definition",
13364 "plan_pk",
13365 "planPk",
13366 "downstream_pk",
13367 "downstreamPk",
13368 "distribution_key",
13369 "distributionKey",
13370 "properties",
13371 "sink_type",
13372 "sinkType",
13373 "column_catalogs",
13374 "columnCatalogs",
13375 "db_name",
13376 "dbName",
13377 "sink_from_name",
13378 "sinkFromName",
13379 "format_desc",
13380 "formatDesc",
13381 "target_table",
13382 "targetTable",
13383 "extra_partition_col_idx",
13384 "extraPartitionColIdx",
13385 "secret_refs",
13386 "secretRefs",
13387 "raw_ignore_delete",
13388 "rawIgnoreDelete",
13389 ];
13390
13391 #[allow(clippy::enum_variant_names)]
13392 enum GeneratedField {
13393 Id,
13394 Name,
13395 Definition,
13396 PlanPk,
13397 DownstreamPk,
13398 DistributionKey,
13399 Properties,
13400 SinkType,
13401 ColumnCatalogs,
13402 DbName,
13403 SinkFromName,
13404 FormatDesc,
13405 TargetTable,
13406 ExtraPartitionColIdx,
13407 SecretRefs,
13408 RawIgnoreDelete,
13409 }
13410 impl<'de> serde::Deserialize<'de> for GeneratedField {
13411 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13412 where
13413 D: serde::Deserializer<'de>,
13414 {
13415 struct GeneratedVisitor;
13416
13417 impl serde::de::Visitor<'_> for GeneratedVisitor {
13418 type Value = GeneratedField;
13419
13420 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13421 write!(formatter, "expected one of: {:?}", &FIELDS)
13422 }
13423
13424 #[allow(unused_variables)]
13425 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13426 where
13427 E: serde::de::Error,
13428 {
13429 match value {
13430 "id" => Ok(GeneratedField::Id),
13431 "name" => Ok(GeneratedField::Name),
13432 "definition" => Ok(GeneratedField::Definition),
13433 "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
13434 "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
13435 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
13436 "properties" => Ok(GeneratedField::Properties),
13437 "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
13438 "columnCatalogs" | "column_catalogs" => Ok(GeneratedField::ColumnCatalogs),
13439 "dbName" | "db_name" => Ok(GeneratedField::DbName),
13440 "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
13441 "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
13442 "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
13443 "extraPartitionColIdx" | "extra_partition_col_idx" => Ok(GeneratedField::ExtraPartitionColIdx),
13444 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
13445 "rawIgnoreDelete" | "raw_ignore_delete" => Ok(GeneratedField::RawIgnoreDelete),
13446 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13447 }
13448 }
13449 }
13450 deserializer.deserialize_identifier(GeneratedVisitor)
13451 }
13452 }
13453 struct GeneratedVisitor;
13454 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13455 type Value = SinkDesc;
13456
13457 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13458 formatter.write_str("struct stream_plan.SinkDesc")
13459 }
13460
13461 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDesc, V::Error>
13462 where
13463 V: serde::de::MapAccess<'de>,
13464 {
13465 let mut id__ = None;
13466 let mut name__ = None;
13467 let mut definition__ = None;
13468 let mut plan_pk__ = None;
13469 let mut downstream_pk__ = None;
13470 let mut distribution_key__ = None;
13471 let mut properties__ = None;
13472 let mut sink_type__ = None;
13473 let mut column_catalogs__ = None;
13474 let mut db_name__ = None;
13475 let mut sink_from_name__ = None;
13476 let mut format_desc__ = None;
13477 let mut target_table__ = None;
13478 let mut extra_partition_col_idx__ = None;
13479 let mut secret_refs__ = None;
13480 let mut raw_ignore_delete__ = None;
13481 while let Some(k) = map_.next_key()? {
13482 match k {
13483 GeneratedField::Id => {
13484 if id__.is_some() {
13485 return Err(serde::de::Error::duplicate_field("id"));
13486 }
13487 id__ =
13488 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13489 ;
13490 }
13491 GeneratedField::Name => {
13492 if name__.is_some() {
13493 return Err(serde::de::Error::duplicate_field("name"));
13494 }
13495 name__ = Some(map_.next_value()?);
13496 }
13497 GeneratedField::Definition => {
13498 if definition__.is_some() {
13499 return Err(serde::de::Error::duplicate_field("definition"));
13500 }
13501 definition__ = Some(map_.next_value()?);
13502 }
13503 GeneratedField::PlanPk => {
13504 if plan_pk__.is_some() {
13505 return Err(serde::de::Error::duplicate_field("planPk"));
13506 }
13507 plan_pk__ = Some(map_.next_value()?);
13508 }
13509 GeneratedField::DownstreamPk => {
13510 if downstream_pk__.is_some() {
13511 return Err(serde::de::Error::duplicate_field("downstreamPk"));
13512 }
13513 downstream_pk__ =
13514 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13515 .into_iter().map(|x| x.0).collect())
13516 ;
13517 }
13518 GeneratedField::DistributionKey => {
13519 if distribution_key__.is_some() {
13520 return Err(serde::de::Error::duplicate_field("distributionKey"));
13521 }
13522 distribution_key__ =
13523 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13524 .into_iter().map(|x| x.0).collect())
13525 ;
13526 }
13527 GeneratedField::Properties => {
13528 if properties__.is_some() {
13529 return Err(serde::de::Error::duplicate_field("properties"));
13530 }
13531 properties__ = Some(
13532 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13533 );
13534 }
13535 GeneratedField::SinkType => {
13536 if sink_type__.is_some() {
13537 return Err(serde::de::Error::duplicate_field("sinkType"));
13538 }
13539 sink_type__ = Some(map_.next_value::<super::catalog::SinkType>()? as i32);
13540 }
13541 GeneratedField::ColumnCatalogs => {
13542 if column_catalogs__.is_some() {
13543 return Err(serde::de::Error::duplicate_field("columnCatalogs"));
13544 }
13545 column_catalogs__ = Some(map_.next_value()?);
13546 }
13547 GeneratedField::DbName => {
13548 if db_name__.is_some() {
13549 return Err(serde::de::Error::duplicate_field("dbName"));
13550 }
13551 db_name__ = Some(map_.next_value()?);
13552 }
13553 GeneratedField::SinkFromName => {
13554 if sink_from_name__.is_some() {
13555 return Err(serde::de::Error::duplicate_field("sinkFromName"));
13556 }
13557 sink_from_name__ = Some(map_.next_value()?);
13558 }
13559 GeneratedField::FormatDesc => {
13560 if format_desc__.is_some() {
13561 return Err(serde::de::Error::duplicate_field("formatDesc"));
13562 }
13563 format_desc__ = map_.next_value()?;
13564 }
13565 GeneratedField::TargetTable => {
13566 if target_table__.is_some() {
13567 return Err(serde::de::Error::duplicate_field("targetTable"));
13568 }
13569 target_table__ =
13570 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13571 ;
13572 }
13573 GeneratedField::ExtraPartitionColIdx => {
13574 if extra_partition_col_idx__.is_some() {
13575 return Err(serde::de::Error::duplicate_field("extraPartitionColIdx"));
13576 }
13577 extra_partition_col_idx__ =
13578 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13579 ;
13580 }
13581 GeneratedField::SecretRefs => {
13582 if secret_refs__.is_some() {
13583 return Err(serde::de::Error::duplicate_field("secretRefs"));
13584 }
13585 secret_refs__ = Some(
13586 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13587 );
13588 }
13589 GeneratedField::RawIgnoreDelete => {
13590 if raw_ignore_delete__.is_some() {
13591 return Err(serde::de::Error::duplicate_field("rawIgnoreDelete"));
13592 }
13593 raw_ignore_delete__ = Some(map_.next_value()?);
13594 }
13595 }
13596 }
13597 Ok(SinkDesc {
13598 id: id__.unwrap_or_default(),
13599 name: name__.unwrap_or_default(),
13600 definition: definition__.unwrap_or_default(),
13601 plan_pk: plan_pk__.unwrap_or_default(),
13602 downstream_pk: downstream_pk__.unwrap_or_default(),
13603 distribution_key: distribution_key__.unwrap_or_default(),
13604 properties: properties__.unwrap_or_default(),
13605 sink_type: sink_type__.unwrap_or_default(),
13606 column_catalogs: column_catalogs__.unwrap_or_default(),
13607 db_name: db_name__.unwrap_or_default(),
13608 sink_from_name: sink_from_name__.unwrap_or_default(),
13609 format_desc: format_desc__,
13610 target_table: target_table__,
13611 extra_partition_col_idx: extra_partition_col_idx__,
13612 secret_refs: secret_refs__.unwrap_or_default(),
13613 raw_ignore_delete: raw_ignore_delete__.unwrap_or_default(),
13614 })
13615 }
13616 }
13617 deserializer.deserialize_struct("stream_plan.SinkDesc", FIELDS, GeneratedVisitor)
13618 }
13619}
13620impl serde::Serialize for SinkDropColumnsOp {
13621 #[allow(deprecated)]
13622 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13623 where
13624 S: serde::Serializer,
13625 {
13626 use serde::ser::SerializeStruct;
13627 let mut len = 0;
13628 if !self.column_names.is_empty() {
13629 len += 1;
13630 }
13631 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDropColumnsOp", len)?;
13632 if !self.column_names.is_empty() {
13633 struct_ser.serialize_field("columnNames", &self.column_names)?;
13634 }
13635 struct_ser.end()
13636 }
13637}
13638impl<'de> serde::Deserialize<'de> for SinkDropColumnsOp {
13639 #[allow(deprecated)]
13640 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13641 where
13642 D: serde::Deserializer<'de>,
13643 {
13644 const FIELDS: &[&str] = &[
13645 "column_names",
13646 "columnNames",
13647 ];
13648
13649 #[allow(clippy::enum_variant_names)]
13650 enum GeneratedField {
13651 ColumnNames,
13652 }
13653 impl<'de> serde::Deserialize<'de> for GeneratedField {
13654 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13655 where
13656 D: serde::Deserializer<'de>,
13657 {
13658 struct GeneratedVisitor;
13659
13660 impl serde::de::Visitor<'_> for GeneratedVisitor {
13661 type Value = GeneratedField;
13662
13663 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13664 write!(formatter, "expected one of: {:?}", &FIELDS)
13665 }
13666
13667 #[allow(unused_variables)]
13668 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13669 where
13670 E: serde::de::Error,
13671 {
13672 match value {
13673 "columnNames" | "column_names" => Ok(GeneratedField::ColumnNames),
13674 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13675 }
13676 }
13677 }
13678 deserializer.deserialize_identifier(GeneratedVisitor)
13679 }
13680 }
13681 struct GeneratedVisitor;
13682 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13683 type Value = SinkDropColumnsOp;
13684
13685 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13686 formatter.write_str("struct stream_plan.SinkDropColumnsOp")
13687 }
13688
13689 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDropColumnsOp, V::Error>
13690 where
13691 V: serde::de::MapAccess<'de>,
13692 {
13693 let mut column_names__ = None;
13694 while let Some(k) = map_.next_key()? {
13695 match k {
13696 GeneratedField::ColumnNames => {
13697 if column_names__.is_some() {
13698 return Err(serde::de::Error::duplicate_field("columnNames"));
13699 }
13700 column_names__ = Some(map_.next_value()?);
13701 }
13702 }
13703 }
13704 Ok(SinkDropColumnsOp {
13705 column_names: column_names__.unwrap_or_default(),
13706 })
13707 }
13708 }
13709 deserializer.deserialize_struct("stream_plan.SinkDropColumnsOp", FIELDS, GeneratedVisitor)
13710 }
13711}
13712impl serde::Serialize for SinkLogStoreType {
13713 #[allow(deprecated)]
13714 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13715 where
13716 S: serde::Serializer,
13717 {
13718 let variant = match self {
13719 Self::Unspecified => "SINK_LOG_STORE_TYPE_UNSPECIFIED",
13720 Self::KvLogStore => "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
13721 Self::InMemoryLogStore => "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
13722 };
13723 serializer.serialize_str(variant)
13724 }
13725}
13726impl<'de> serde::Deserialize<'de> for SinkLogStoreType {
13727 #[allow(deprecated)]
13728 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13729 where
13730 D: serde::Deserializer<'de>,
13731 {
13732 const FIELDS: &[&str] = &[
13733 "SINK_LOG_STORE_TYPE_UNSPECIFIED",
13734 "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
13735 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
13736 ];
13737
13738 struct GeneratedVisitor;
13739
13740 impl serde::de::Visitor<'_> for GeneratedVisitor {
13741 type Value = SinkLogStoreType;
13742
13743 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13744 write!(formatter, "expected one of: {:?}", &FIELDS)
13745 }
13746
13747 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13748 where
13749 E: serde::de::Error,
13750 {
13751 i32::try_from(v)
13752 .ok()
13753 .and_then(|x| x.try_into().ok())
13754 .ok_or_else(|| {
13755 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13756 })
13757 }
13758
13759 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13760 where
13761 E: serde::de::Error,
13762 {
13763 i32::try_from(v)
13764 .ok()
13765 .and_then(|x| x.try_into().ok())
13766 .ok_or_else(|| {
13767 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13768 })
13769 }
13770
13771 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13772 where
13773 E: serde::de::Error,
13774 {
13775 match value {
13776 "SINK_LOG_STORE_TYPE_UNSPECIFIED" => Ok(SinkLogStoreType::Unspecified),
13777 "SINK_LOG_STORE_TYPE_KV_LOG_STORE" => Ok(SinkLogStoreType::KvLogStore),
13778 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE" => Ok(SinkLogStoreType::InMemoryLogStore),
13779 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13780 }
13781 }
13782 }
13783 deserializer.deserialize_any(GeneratedVisitor)
13784 }
13785}
13786impl serde::Serialize for SinkNode {
13787 #[allow(deprecated)]
13788 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13789 where
13790 S: serde::Serializer,
13791 {
13792 use serde::ser::SerializeStruct;
13793 let mut len = 0;
13794 if self.sink_desc.is_some() {
13795 len += 1;
13796 }
13797 if self.table.is_some() {
13798 len += 1;
13799 }
13800 if self.log_store_type != 0 {
13801 len += 1;
13802 }
13803 if self.rate_limit.is_some() {
13804 len += 1;
13805 }
13806 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkNode", len)?;
13807 if let Some(v) = self.sink_desc.as_ref() {
13808 struct_ser.serialize_field("sinkDesc", v)?;
13809 }
13810 if let Some(v) = self.table.as_ref() {
13811 struct_ser.serialize_field("table", v)?;
13812 }
13813 if self.log_store_type != 0 {
13814 let v = SinkLogStoreType::try_from(self.log_store_type)
13815 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.log_store_type)))?;
13816 struct_ser.serialize_field("logStoreType", &v)?;
13817 }
13818 if let Some(v) = self.rate_limit.as_ref() {
13819 struct_ser.serialize_field("rateLimit", v)?;
13820 }
13821 struct_ser.end()
13822 }
13823}
13824impl<'de> serde::Deserialize<'de> for SinkNode {
13825 #[allow(deprecated)]
13826 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13827 where
13828 D: serde::Deserializer<'de>,
13829 {
13830 const FIELDS: &[&str] = &[
13831 "sink_desc",
13832 "sinkDesc",
13833 "table",
13834 "log_store_type",
13835 "logStoreType",
13836 "rate_limit",
13837 "rateLimit",
13838 ];
13839
13840 #[allow(clippy::enum_variant_names)]
13841 enum GeneratedField {
13842 SinkDesc,
13843 Table,
13844 LogStoreType,
13845 RateLimit,
13846 }
13847 impl<'de> serde::Deserialize<'de> for GeneratedField {
13848 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13849 where
13850 D: serde::Deserializer<'de>,
13851 {
13852 struct GeneratedVisitor;
13853
13854 impl serde::de::Visitor<'_> for GeneratedVisitor {
13855 type Value = GeneratedField;
13856
13857 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13858 write!(formatter, "expected one of: {:?}", &FIELDS)
13859 }
13860
13861 #[allow(unused_variables)]
13862 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13863 where
13864 E: serde::de::Error,
13865 {
13866 match value {
13867 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
13868 "table" => Ok(GeneratedField::Table),
13869 "logStoreType" | "log_store_type" => Ok(GeneratedField::LogStoreType),
13870 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
13871 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13872 }
13873 }
13874 }
13875 deserializer.deserialize_identifier(GeneratedVisitor)
13876 }
13877 }
13878 struct GeneratedVisitor;
13879 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13880 type Value = SinkNode;
13881
13882 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13883 formatter.write_str("struct stream_plan.SinkNode")
13884 }
13885
13886 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkNode, V::Error>
13887 where
13888 V: serde::de::MapAccess<'de>,
13889 {
13890 let mut sink_desc__ = None;
13891 let mut table__ = None;
13892 let mut log_store_type__ = None;
13893 let mut rate_limit__ = None;
13894 while let Some(k) = map_.next_key()? {
13895 match k {
13896 GeneratedField::SinkDesc => {
13897 if sink_desc__.is_some() {
13898 return Err(serde::de::Error::duplicate_field("sinkDesc"));
13899 }
13900 sink_desc__ = map_.next_value()?;
13901 }
13902 GeneratedField::Table => {
13903 if table__.is_some() {
13904 return Err(serde::de::Error::duplicate_field("table"));
13905 }
13906 table__ = map_.next_value()?;
13907 }
13908 GeneratedField::LogStoreType => {
13909 if log_store_type__.is_some() {
13910 return Err(serde::de::Error::duplicate_field("logStoreType"));
13911 }
13912 log_store_type__ = Some(map_.next_value::<SinkLogStoreType>()? as i32);
13913 }
13914 GeneratedField::RateLimit => {
13915 if rate_limit__.is_some() {
13916 return Err(serde::de::Error::duplicate_field("rateLimit"));
13917 }
13918 rate_limit__ =
13919 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13920 ;
13921 }
13922 }
13923 }
13924 Ok(SinkNode {
13925 sink_desc: sink_desc__,
13926 table: table__,
13927 log_store_type: log_store_type__.unwrap_or_default(),
13928 rate_limit: rate_limit__,
13929 })
13930 }
13931 }
13932 deserializer.deserialize_struct("stream_plan.SinkNode", FIELDS, GeneratedVisitor)
13933 }
13934}
13935impl serde::Serialize for SinkSchemaChange {
13936 #[allow(deprecated)]
13937 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13938 where
13939 S: serde::Serializer,
13940 {
13941 use serde::ser::SerializeStruct;
13942 let mut len = 0;
13943 if !self.original_schema.is_empty() {
13944 len += 1;
13945 }
13946 if self.op.is_some() {
13947 len += 1;
13948 }
13949 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkSchemaChange", len)?;
13950 if !self.original_schema.is_empty() {
13951 struct_ser.serialize_field("originalSchema", &self.original_schema)?;
13952 }
13953 if let Some(v) = self.op.as_ref() {
13954 match v {
13955 sink_schema_change::Op::AddColumns(v) => {
13956 struct_ser.serialize_field("addColumns", v)?;
13957 }
13958 sink_schema_change::Op::DropColumns(v) => {
13959 struct_ser.serialize_field("dropColumns", v)?;
13960 }
13961 }
13962 }
13963 struct_ser.end()
13964 }
13965}
13966impl<'de> serde::Deserialize<'de> for SinkSchemaChange {
13967 #[allow(deprecated)]
13968 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13969 where
13970 D: serde::Deserializer<'de>,
13971 {
13972 const FIELDS: &[&str] = &[
13973 "original_schema",
13974 "originalSchema",
13975 "add_columns",
13976 "addColumns",
13977 "drop_columns",
13978 "dropColumns",
13979 ];
13980
13981 #[allow(clippy::enum_variant_names)]
13982 enum GeneratedField {
13983 OriginalSchema,
13984 AddColumns,
13985 DropColumns,
13986 }
13987 impl<'de> serde::Deserialize<'de> for GeneratedField {
13988 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13989 where
13990 D: serde::Deserializer<'de>,
13991 {
13992 struct GeneratedVisitor;
13993
13994 impl serde::de::Visitor<'_> for GeneratedVisitor {
13995 type Value = GeneratedField;
13996
13997 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13998 write!(formatter, "expected one of: {:?}", &FIELDS)
13999 }
14000
14001 #[allow(unused_variables)]
14002 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14003 where
14004 E: serde::de::Error,
14005 {
14006 match value {
14007 "originalSchema" | "original_schema" => Ok(GeneratedField::OriginalSchema),
14008 "addColumns" | "add_columns" => Ok(GeneratedField::AddColumns),
14009 "dropColumns" | "drop_columns" => Ok(GeneratedField::DropColumns),
14010 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14011 }
14012 }
14013 }
14014 deserializer.deserialize_identifier(GeneratedVisitor)
14015 }
14016 }
14017 struct GeneratedVisitor;
14018 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14019 type Value = SinkSchemaChange;
14020
14021 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14022 formatter.write_str("struct stream_plan.SinkSchemaChange")
14023 }
14024
14025 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkSchemaChange, V::Error>
14026 where
14027 V: serde::de::MapAccess<'de>,
14028 {
14029 let mut original_schema__ = None;
14030 let mut op__ = None;
14031 while let Some(k) = map_.next_key()? {
14032 match k {
14033 GeneratedField::OriginalSchema => {
14034 if original_schema__.is_some() {
14035 return Err(serde::de::Error::duplicate_field("originalSchema"));
14036 }
14037 original_schema__ = Some(map_.next_value()?);
14038 }
14039 GeneratedField::AddColumns => {
14040 if op__.is_some() {
14041 return Err(serde::de::Error::duplicate_field("addColumns"));
14042 }
14043 op__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_schema_change::Op::AddColumns)
14044;
14045 }
14046 GeneratedField::DropColumns => {
14047 if op__.is_some() {
14048 return Err(serde::de::Error::duplicate_field("dropColumns"));
14049 }
14050 op__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_schema_change::Op::DropColumns)
14051;
14052 }
14053 }
14054 }
14055 Ok(SinkSchemaChange {
14056 original_schema: original_schema__.unwrap_or_default(),
14057 op: op__,
14058 })
14059 }
14060 }
14061 deserializer.deserialize_struct("stream_plan.SinkSchemaChange", FIELDS, GeneratedVisitor)
14062 }
14063}
14064impl serde::Serialize for SortNode {
14065 #[allow(deprecated)]
14066 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14067 where
14068 S: serde::Serializer,
14069 {
14070 use serde::ser::SerializeStruct;
14071 let mut len = 0;
14072 if self.state_table.is_some() {
14073 len += 1;
14074 }
14075 if self.sort_column_index != 0 {
14076 len += 1;
14077 }
14078 let mut struct_ser = serializer.serialize_struct("stream_plan.SortNode", len)?;
14079 if let Some(v) = self.state_table.as_ref() {
14080 struct_ser.serialize_field("stateTable", v)?;
14081 }
14082 if self.sort_column_index != 0 {
14083 struct_ser.serialize_field("sortColumnIndex", &self.sort_column_index)?;
14084 }
14085 struct_ser.end()
14086 }
14087}
14088impl<'de> serde::Deserialize<'de> for SortNode {
14089 #[allow(deprecated)]
14090 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14091 where
14092 D: serde::Deserializer<'de>,
14093 {
14094 const FIELDS: &[&str] = &[
14095 "state_table",
14096 "stateTable",
14097 "sort_column_index",
14098 "sortColumnIndex",
14099 ];
14100
14101 #[allow(clippy::enum_variant_names)]
14102 enum GeneratedField {
14103 StateTable,
14104 SortColumnIndex,
14105 }
14106 impl<'de> serde::Deserialize<'de> for GeneratedField {
14107 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14108 where
14109 D: serde::Deserializer<'de>,
14110 {
14111 struct GeneratedVisitor;
14112
14113 impl serde::de::Visitor<'_> for GeneratedVisitor {
14114 type Value = GeneratedField;
14115
14116 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14117 write!(formatter, "expected one of: {:?}", &FIELDS)
14118 }
14119
14120 #[allow(unused_variables)]
14121 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14122 where
14123 E: serde::de::Error,
14124 {
14125 match value {
14126 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
14127 "sortColumnIndex" | "sort_column_index" => Ok(GeneratedField::SortColumnIndex),
14128 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14129 }
14130 }
14131 }
14132 deserializer.deserialize_identifier(GeneratedVisitor)
14133 }
14134 }
14135 struct GeneratedVisitor;
14136 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14137 type Value = SortNode;
14138
14139 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14140 formatter.write_str("struct stream_plan.SortNode")
14141 }
14142
14143 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
14144 where
14145 V: serde::de::MapAccess<'de>,
14146 {
14147 let mut state_table__ = None;
14148 let mut sort_column_index__ = None;
14149 while let Some(k) = map_.next_key()? {
14150 match k {
14151 GeneratedField::StateTable => {
14152 if state_table__.is_some() {
14153 return Err(serde::de::Error::duplicate_field("stateTable"));
14154 }
14155 state_table__ = map_.next_value()?;
14156 }
14157 GeneratedField::SortColumnIndex => {
14158 if sort_column_index__.is_some() {
14159 return Err(serde::de::Error::duplicate_field("sortColumnIndex"));
14160 }
14161 sort_column_index__ =
14162 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14163 ;
14164 }
14165 }
14166 }
14167 Ok(SortNode {
14168 state_table: state_table__,
14169 sort_column_index: sort_column_index__.unwrap_or_default(),
14170 })
14171 }
14172 }
14173 deserializer.deserialize_struct("stream_plan.SortNode", FIELDS, GeneratedVisitor)
14174 }
14175}
14176impl serde::Serialize for SourceBackfillNode {
14177 #[allow(deprecated)]
14178 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14179 where
14180 S: serde::Serializer,
14181 {
14182 use serde::ser::SerializeStruct;
14183 let mut len = 0;
14184 if self.upstream_source_id != 0 {
14185 len += 1;
14186 }
14187 if self.row_id_index.is_some() {
14188 len += 1;
14189 }
14190 if !self.columns.is_empty() {
14191 len += 1;
14192 }
14193 if self.info.is_some() {
14194 len += 1;
14195 }
14196 if !self.source_name.is_empty() {
14197 len += 1;
14198 }
14199 if !self.with_properties.is_empty() {
14200 len += 1;
14201 }
14202 if self.rate_limit.is_some() {
14203 len += 1;
14204 }
14205 if self.state_table.is_some() {
14206 len += 1;
14207 }
14208 if !self.secret_refs.is_empty() {
14209 len += 1;
14210 }
14211 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceBackfillNode", len)?;
14212 if self.upstream_source_id != 0 {
14213 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
14214 }
14215 if let Some(v) = self.row_id_index.as_ref() {
14216 struct_ser.serialize_field("rowIdIndex", v)?;
14217 }
14218 if !self.columns.is_empty() {
14219 struct_ser.serialize_field("columns", &self.columns)?;
14220 }
14221 if let Some(v) = self.info.as_ref() {
14222 struct_ser.serialize_field("info", v)?;
14223 }
14224 if !self.source_name.is_empty() {
14225 struct_ser.serialize_field("sourceName", &self.source_name)?;
14226 }
14227 if !self.with_properties.is_empty() {
14228 struct_ser.serialize_field("withProperties", &self.with_properties)?;
14229 }
14230 if let Some(v) = self.rate_limit.as_ref() {
14231 struct_ser.serialize_field("rateLimit", v)?;
14232 }
14233 if let Some(v) = self.state_table.as_ref() {
14234 struct_ser.serialize_field("stateTable", v)?;
14235 }
14236 if !self.secret_refs.is_empty() {
14237 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
14238 }
14239 struct_ser.end()
14240 }
14241}
14242impl<'de> serde::Deserialize<'de> for SourceBackfillNode {
14243 #[allow(deprecated)]
14244 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14245 where
14246 D: serde::Deserializer<'de>,
14247 {
14248 const FIELDS: &[&str] = &[
14249 "upstream_source_id",
14250 "upstreamSourceId",
14251 "row_id_index",
14252 "rowIdIndex",
14253 "columns",
14254 "info",
14255 "source_name",
14256 "sourceName",
14257 "with_properties",
14258 "withProperties",
14259 "rate_limit",
14260 "rateLimit",
14261 "state_table",
14262 "stateTable",
14263 "secret_refs",
14264 "secretRefs",
14265 ];
14266
14267 #[allow(clippy::enum_variant_names)]
14268 enum GeneratedField {
14269 UpstreamSourceId,
14270 RowIdIndex,
14271 Columns,
14272 Info,
14273 SourceName,
14274 WithProperties,
14275 RateLimit,
14276 StateTable,
14277 SecretRefs,
14278 }
14279 impl<'de> serde::Deserialize<'de> for GeneratedField {
14280 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14281 where
14282 D: serde::Deserializer<'de>,
14283 {
14284 struct GeneratedVisitor;
14285
14286 impl serde::de::Visitor<'_> for GeneratedVisitor {
14287 type Value = GeneratedField;
14288
14289 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14290 write!(formatter, "expected one of: {:?}", &FIELDS)
14291 }
14292
14293 #[allow(unused_variables)]
14294 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14295 where
14296 E: serde::de::Error,
14297 {
14298 match value {
14299 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
14300 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
14301 "columns" => Ok(GeneratedField::Columns),
14302 "info" => Ok(GeneratedField::Info),
14303 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
14304 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
14305 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
14306 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
14307 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
14308 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14309 }
14310 }
14311 }
14312 deserializer.deserialize_identifier(GeneratedVisitor)
14313 }
14314 }
14315 struct GeneratedVisitor;
14316 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14317 type Value = SourceBackfillNode;
14318
14319 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14320 formatter.write_str("struct stream_plan.SourceBackfillNode")
14321 }
14322
14323 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceBackfillNode, V::Error>
14324 where
14325 V: serde::de::MapAccess<'de>,
14326 {
14327 let mut upstream_source_id__ = None;
14328 let mut row_id_index__ = None;
14329 let mut columns__ = None;
14330 let mut info__ = None;
14331 let mut source_name__ = None;
14332 let mut with_properties__ = None;
14333 let mut rate_limit__ = None;
14334 let mut state_table__ = None;
14335 let mut secret_refs__ = None;
14336 while let Some(k) = map_.next_key()? {
14337 match k {
14338 GeneratedField::UpstreamSourceId => {
14339 if upstream_source_id__.is_some() {
14340 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
14341 }
14342 upstream_source_id__ =
14343 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14344 ;
14345 }
14346 GeneratedField::RowIdIndex => {
14347 if row_id_index__.is_some() {
14348 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
14349 }
14350 row_id_index__ =
14351 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14352 ;
14353 }
14354 GeneratedField::Columns => {
14355 if columns__.is_some() {
14356 return Err(serde::de::Error::duplicate_field("columns"));
14357 }
14358 columns__ = Some(map_.next_value()?);
14359 }
14360 GeneratedField::Info => {
14361 if info__.is_some() {
14362 return Err(serde::de::Error::duplicate_field("info"));
14363 }
14364 info__ = map_.next_value()?;
14365 }
14366 GeneratedField::SourceName => {
14367 if source_name__.is_some() {
14368 return Err(serde::de::Error::duplicate_field("sourceName"));
14369 }
14370 source_name__ = Some(map_.next_value()?);
14371 }
14372 GeneratedField::WithProperties => {
14373 if with_properties__.is_some() {
14374 return Err(serde::de::Error::duplicate_field("withProperties"));
14375 }
14376 with_properties__ = Some(
14377 map_.next_value::<std::collections::BTreeMap<_, _>>()?
14378 );
14379 }
14380 GeneratedField::RateLimit => {
14381 if rate_limit__.is_some() {
14382 return Err(serde::de::Error::duplicate_field("rateLimit"));
14383 }
14384 rate_limit__ =
14385 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14386 ;
14387 }
14388 GeneratedField::StateTable => {
14389 if state_table__.is_some() {
14390 return Err(serde::de::Error::duplicate_field("stateTable"));
14391 }
14392 state_table__ = map_.next_value()?;
14393 }
14394 GeneratedField::SecretRefs => {
14395 if secret_refs__.is_some() {
14396 return Err(serde::de::Error::duplicate_field("secretRefs"));
14397 }
14398 secret_refs__ = Some(
14399 map_.next_value::<std::collections::BTreeMap<_, _>>()?
14400 );
14401 }
14402 }
14403 }
14404 Ok(SourceBackfillNode {
14405 upstream_source_id: upstream_source_id__.unwrap_or_default(),
14406 row_id_index: row_id_index__,
14407 columns: columns__.unwrap_or_default(),
14408 info: info__,
14409 source_name: source_name__.unwrap_or_default(),
14410 with_properties: with_properties__.unwrap_or_default(),
14411 rate_limit: rate_limit__,
14412 state_table: state_table__,
14413 secret_refs: secret_refs__.unwrap_or_default(),
14414 })
14415 }
14416 }
14417 deserializer.deserialize_struct("stream_plan.SourceBackfillNode", FIELDS, GeneratedVisitor)
14418 }
14419}
14420impl serde::Serialize for SourceChangeSplitMutation {
14421 #[allow(deprecated)]
14422 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14423 where
14424 S: serde::Serializer,
14425 {
14426 use serde::ser::SerializeStruct;
14427 let mut len = 0;
14428 if !self.actor_splits.is_empty() {
14429 len += 1;
14430 }
14431 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceChangeSplitMutation", len)?;
14432 if !self.actor_splits.is_empty() {
14433 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
14434 }
14435 struct_ser.end()
14436 }
14437}
14438impl<'de> serde::Deserialize<'de> for SourceChangeSplitMutation {
14439 #[allow(deprecated)]
14440 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14441 where
14442 D: serde::Deserializer<'de>,
14443 {
14444 const FIELDS: &[&str] = &[
14445 "actor_splits",
14446 "actorSplits",
14447 ];
14448
14449 #[allow(clippy::enum_variant_names)]
14450 enum GeneratedField {
14451 ActorSplits,
14452 }
14453 impl<'de> serde::Deserialize<'de> for GeneratedField {
14454 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14455 where
14456 D: serde::Deserializer<'de>,
14457 {
14458 struct GeneratedVisitor;
14459
14460 impl serde::de::Visitor<'_> for GeneratedVisitor {
14461 type Value = GeneratedField;
14462
14463 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14464 write!(formatter, "expected one of: {:?}", &FIELDS)
14465 }
14466
14467 #[allow(unused_variables)]
14468 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14469 where
14470 E: serde::de::Error,
14471 {
14472 match value {
14473 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
14474 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14475 }
14476 }
14477 }
14478 deserializer.deserialize_identifier(GeneratedVisitor)
14479 }
14480 }
14481 struct GeneratedVisitor;
14482 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14483 type Value = SourceChangeSplitMutation;
14484
14485 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14486 formatter.write_str("struct stream_plan.SourceChangeSplitMutation")
14487 }
14488
14489 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceChangeSplitMutation, V::Error>
14490 where
14491 V: serde::de::MapAccess<'de>,
14492 {
14493 let mut actor_splits__ = None;
14494 while let Some(k) = map_.next_key()? {
14495 match k {
14496 GeneratedField::ActorSplits => {
14497 if actor_splits__.is_some() {
14498 return Err(serde::de::Error::duplicate_field("actorSplits"));
14499 }
14500 actor_splits__ = Some(
14501 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14502 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
14503 );
14504 }
14505 }
14506 }
14507 Ok(SourceChangeSplitMutation {
14508 actor_splits: actor_splits__.unwrap_or_default(),
14509 })
14510 }
14511 }
14512 deserializer.deserialize_struct("stream_plan.SourceChangeSplitMutation", FIELDS, GeneratedVisitor)
14513 }
14514}
14515impl serde::Serialize for SourceNode {
14516 #[allow(deprecated)]
14517 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14518 where
14519 S: serde::Serializer,
14520 {
14521 use serde::ser::SerializeStruct;
14522 let mut len = 0;
14523 if self.source_inner.is_some() {
14524 len += 1;
14525 }
14526 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceNode", len)?;
14527 if let Some(v) = self.source_inner.as_ref() {
14528 struct_ser.serialize_field("sourceInner", v)?;
14529 }
14530 struct_ser.end()
14531 }
14532}
14533impl<'de> serde::Deserialize<'de> for SourceNode {
14534 #[allow(deprecated)]
14535 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14536 where
14537 D: serde::Deserializer<'de>,
14538 {
14539 const FIELDS: &[&str] = &[
14540 "source_inner",
14541 "sourceInner",
14542 ];
14543
14544 #[allow(clippy::enum_variant_names)]
14545 enum GeneratedField {
14546 SourceInner,
14547 }
14548 impl<'de> serde::Deserialize<'de> for GeneratedField {
14549 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14550 where
14551 D: serde::Deserializer<'de>,
14552 {
14553 struct GeneratedVisitor;
14554
14555 impl serde::de::Visitor<'_> for GeneratedVisitor {
14556 type Value = GeneratedField;
14557
14558 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14559 write!(formatter, "expected one of: {:?}", &FIELDS)
14560 }
14561
14562 #[allow(unused_variables)]
14563 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14564 where
14565 E: serde::de::Error,
14566 {
14567 match value {
14568 "sourceInner" | "source_inner" => Ok(GeneratedField::SourceInner),
14569 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14570 }
14571 }
14572 }
14573 deserializer.deserialize_identifier(GeneratedVisitor)
14574 }
14575 }
14576 struct GeneratedVisitor;
14577 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14578 type Value = SourceNode;
14579
14580 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14581 formatter.write_str("struct stream_plan.SourceNode")
14582 }
14583
14584 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
14585 where
14586 V: serde::de::MapAccess<'de>,
14587 {
14588 let mut source_inner__ = None;
14589 while let Some(k) = map_.next_key()? {
14590 match k {
14591 GeneratedField::SourceInner => {
14592 if source_inner__.is_some() {
14593 return Err(serde::de::Error::duplicate_field("sourceInner"));
14594 }
14595 source_inner__ = map_.next_value()?;
14596 }
14597 }
14598 }
14599 Ok(SourceNode {
14600 source_inner: source_inner__,
14601 })
14602 }
14603 }
14604 deserializer.deserialize_struct("stream_plan.SourceNode", FIELDS, GeneratedVisitor)
14605 }
14606}
14607impl serde::Serialize for StartFragmentBackfillMutation {
14608 #[allow(deprecated)]
14609 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14610 where
14611 S: serde::Serializer,
14612 {
14613 use serde::ser::SerializeStruct;
14614 let mut len = 0;
14615 if !self.fragment_ids.is_empty() {
14616 len += 1;
14617 }
14618 let mut struct_ser = serializer.serialize_struct("stream_plan.StartFragmentBackfillMutation", len)?;
14619 if !self.fragment_ids.is_empty() {
14620 struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
14621 }
14622 struct_ser.end()
14623 }
14624}
14625impl<'de> serde::Deserialize<'de> for StartFragmentBackfillMutation {
14626 #[allow(deprecated)]
14627 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14628 where
14629 D: serde::Deserializer<'de>,
14630 {
14631 const FIELDS: &[&str] = &[
14632 "fragment_ids",
14633 "fragmentIds",
14634 ];
14635
14636 #[allow(clippy::enum_variant_names)]
14637 enum GeneratedField {
14638 FragmentIds,
14639 }
14640 impl<'de> serde::Deserialize<'de> for GeneratedField {
14641 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14642 where
14643 D: serde::Deserializer<'de>,
14644 {
14645 struct GeneratedVisitor;
14646
14647 impl serde::de::Visitor<'_> for GeneratedVisitor {
14648 type Value = GeneratedField;
14649
14650 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14651 write!(formatter, "expected one of: {:?}", &FIELDS)
14652 }
14653
14654 #[allow(unused_variables)]
14655 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14656 where
14657 E: serde::de::Error,
14658 {
14659 match value {
14660 "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
14661 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14662 }
14663 }
14664 }
14665 deserializer.deserialize_identifier(GeneratedVisitor)
14666 }
14667 }
14668 struct GeneratedVisitor;
14669 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14670 type Value = StartFragmentBackfillMutation;
14671
14672 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14673 formatter.write_str("struct stream_plan.StartFragmentBackfillMutation")
14674 }
14675
14676 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StartFragmentBackfillMutation, V::Error>
14677 where
14678 V: serde::de::MapAccess<'de>,
14679 {
14680 let mut fragment_ids__ = None;
14681 while let Some(k) = map_.next_key()? {
14682 match k {
14683 GeneratedField::FragmentIds => {
14684 if fragment_ids__.is_some() {
14685 return Err(serde::de::Error::duplicate_field("fragmentIds"));
14686 }
14687 fragment_ids__ =
14688 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14689 .into_iter().map(|x| x.0).collect())
14690 ;
14691 }
14692 }
14693 }
14694 Ok(StartFragmentBackfillMutation {
14695 fragment_ids: fragment_ids__.unwrap_or_default(),
14696 })
14697 }
14698 }
14699 deserializer.deserialize_struct("stream_plan.StartFragmentBackfillMutation", FIELDS, GeneratedVisitor)
14700 }
14701}
14702impl serde::Serialize for StopMutation {
14703 #[allow(deprecated)]
14704 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14705 where
14706 S: serde::Serializer,
14707 {
14708 use serde::ser::SerializeStruct;
14709 let mut len = 0;
14710 if !self.actors.is_empty() {
14711 len += 1;
14712 }
14713 if !self.dropped_sink_fragments.is_empty() {
14714 len += 1;
14715 }
14716 let mut struct_ser = serializer.serialize_struct("stream_plan.StopMutation", len)?;
14717 if !self.actors.is_empty() {
14718 struct_ser.serialize_field("actors", &self.actors)?;
14719 }
14720 if !self.dropped_sink_fragments.is_empty() {
14721 struct_ser.serialize_field("droppedSinkFragments", &self.dropped_sink_fragments)?;
14722 }
14723 struct_ser.end()
14724 }
14725}
14726impl<'de> serde::Deserialize<'de> for StopMutation {
14727 #[allow(deprecated)]
14728 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14729 where
14730 D: serde::Deserializer<'de>,
14731 {
14732 const FIELDS: &[&str] = &[
14733 "actors",
14734 "dropped_sink_fragments",
14735 "droppedSinkFragments",
14736 ];
14737
14738 #[allow(clippy::enum_variant_names)]
14739 enum GeneratedField {
14740 Actors,
14741 DroppedSinkFragments,
14742 }
14743 impl<'de> serde::Deserialize<'de> for GeneratedField {
14744 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14745 where
14746 D: serde::Deserializer<'de>,
14747 {
14748 struct GeneratedVisitor;
14749
14750 impl serde::de::Visitor<'_> for GeneratedVisitor {
14751 type Value = GeneratedField;
14752
14753 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14754 write!(formatter, "expected one of: {:?}", &FIELDS)
14755 }
14756
14757 #[allow(unused_variables)]
14758 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14759 where
14760 E: serde::de::Error,
14761 {
14762 match value {
14763 "actors" => Ok(GeneratedField::Actors),
14764 "droppedSinkFragments" | "dropped_sink_fragments" => Ok(GeneratedField::DroppedSinkFragments),
14765 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14766 }
14767 }
14768 }
14769 deserializer.deserialize_identifier(GeneratedVisitor)
14770 }
14771 }
14772 struct GeneratedVisitor;
14773 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14774 type Value = StopMutation;
14775
14776 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14777 formatter.write_str("struct stream_plan.StopMutation")
14778 }
14779
14780 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopMutation, V::Error>
14781 where
14782 V: serde::de::MapAccess<'de>,
14783 {
14784 let mut actors__ = None;
14785 let mut dropped_sink_fragments__ = None;
14786 while let Some(k) = map_.next_key()? {
14787 match k {
14788 GeneratedField::Actors => {
14789 if actors__.is_some() {
14790 return Err(serde::de::Error::duplicate_field("actors"));
14791 }
14792 actors__ =
14793 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14794 .into_iter().map(|x| x.0).collect())
14795 ;
14796 }
14797 GeneratedField::DroppedSinkFragments => {
14798 if dropped_sink_fragments__.is_some() {
14799 return Err(serde::de::Error::duplicate_field("droppedSinkFragments"));
14800 }
14801 dropped_sink_fragments__ =
14802 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14803 .into_iter().map(|x| x.0).collect())
14804 ;
14805 }
14806 }
14807 }
14808 Ok(StopMutation {
14809 actors: actors__.unwrap_or_default(),
14810 dropped_sink_fragments: dropped_sink_fragments__.unwrap_or_default(),
14811 })
14812 }
14813 }
14814 deserializer.deserialize_struct("stream_plan.StopMutation", FIELDS, GeneratedVisitor)
14815 }
14816}
14817impl serde::Serialize for StreamActor {
14818 #[allow(deprecated)]
14819 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14820 where
14821 S: serde::Serializer,
14822 {
14823 use serde::ser::SerializeStruct;
14824 let mut len = 0;
14825 if self.actor_id != 0 {
14826 len += 1;
14827 }
14828 if self.fragment_id != 0 {
14829 len += 1;
14830 }
14831 if !self.dispatcher.is_empty() {
14832 len += 1;
14833 }
14834 if self.vnode_bitmap.is_some() {
14835 len += 1;
14836 }
14837 if !self.mview_definition.is_empty() {
14838 len += 1;
14839 }
14840 if self.expr_context.is_some() {
14841 len += 1;
14842 }
14843 if !self.config_override.is_empty() {
14844 len += 1;
14845 }
14846 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamActor", len)?;
14847 if self.actor_id != 0 {
14848 struct_ser.serialize_field("actorId", &self.actor_id)?;
14849 }
14850 if self.fragment_id != 0 {
14851 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
14852 }
14853 if !self.dispatcher.is_empty() {
14854 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
14855 }
14856 if let Some(v) = self.vnode_bitmap.as_ref() {
14857 struct_ser.serialize_field("vnodeBitmap", v)?;
14858 }
14859 if !self.mview_definition.is_empty() {
14860 struct_ser.serialize_field("mviewDefinition", &self.mview_definition)?;
14861 }
14862 if let Some(v) = self.expr_context.as_ref() {
14863 struct_ser.serialize_field("exprContext", v)?;
14864 }
14865 if !self.config_override.is_empty() {
14866 struct_ser.serialize_field("configOverride", &self.config_override)?;
14867 }
14868 struct_ser.end()
14869 }
14870}
14871impl<'de> serde::Deserialize<'de> for StreamActor {
14872 #[allow(deprecated)]
14873 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14874 where
14875 D: serde::Deserializer<'de>,
14876 {
14877 const FIELDS: &[&str] = &[
14878 "actor_id",
14879 "actorId",
14880 "fragment_id",
14881 "fragmentId",
14882 "dispatcher",
14883 "vnode_bitmap",
14884 "vnodeBitmap",
14885 "mview_definition",
14886 "mviewDefinition",
14887 "expr_context",
14888 "exprContext",
14889 "config_override",
14890 "configOverride",
14891 ];
14892
14893 #[allow(clippy::enum_variant_names)]
14894 enum GeneratedField {
14895 ActorId,
14896 FragmentId,
14897 Dispatcher,
14898 VnodeBitmap,
14899 MviewDefinition,
14900 ExprContext,
14901 ConfigOverride,
14902 }
14903 impl<'de> serde::Deserialize<'de> for GeneratedField {
14904 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14905 where
14906 D: serde::Deserializer<'de>,
14907 {
14908 struct GeneratedVisitor;
14909
14910 impl serde::de::Visitor<'_> for GeneratedVisitor {
14911 type Value = GeneratedField;
14912
14913 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14914 write!(formatter, "expected one of: {:?}", &FIELDS)
14915 }
14916
14917 #[allow(unused_variables)]
14918 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14919 where
14920 E: serde::de::Error,
14921 {
14922 match value {
14923 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
14924 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
14925 "dispatcher" => Ok(GeneratedField::Dispatcher),
14926 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
14927 "mviewDefinition" | "mview_definition" => Ok(GeneratedField::MviewDefinition),
14928 "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
14929 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
14930 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14931 }
14932 }
14933 }
14934 deserializer.deserialize_identifier(GeneratedVisitor)
14935 }
14936 }
14937 struct GeneratedVisitor;
14938 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14939 type Value = StreamActor;
14940
14941 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14942 formatter.write_str("struct stream_plan.StreamActor")
14943 }
14944
14945 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamActor, V::Error>
14946 where
14947 V: serde::de::MapAccess<'de>,
14948 {
14949 let mut actor_id__ = None;
14950 let mut fragment_id__ = None;
14951 let mut dispatcher__ = None;
14952 let mut vnode_bitmap__ = None;
14953 let mut mview_definition__ = None;
14954 let mut expr_context__ = None;
14955 let mut config_override__ = None;
14956 while let Some(k) = map_.next_key()? {
14957 match k {
14958 GeneratedField::ActorId => {
14959 if actor_id__.is_some() {
14960 return Err(serde::de::Error::duplicate_field("actorId"));
14961 }
14962 actor_id__ =
14963 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14964 ;
14965 }
14966 GeneratedField::FragmentId => {
14967 if fragment_id__.is_some() {
14968 return Err(serde::de::Error::duplicate_field("fragmentId"));
14969 }
14970 fragment_id__ =
14971 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14972 ;
14973 }
14974 GeneratedField::Dispatcher => {
14975 if dispatcher__.is_some() {
14976 return Err(serde::de::Error::duplicate_field("dispatcher"));
14977 }
14978 dispatcher__ = Some(map_.next_value()?);
14979 }
14980 GeneratedField::VnodeBitmap => {
14981 if vnode_bitmap__.is_some() {
14982 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
14983 }
14984 vnode_bitmap__ = map_.next_value()?;
14985 }
14986 GeneratedField::MviewDefinition => {
14987 if mview_definition__.is_some() {
14988 return Err(serde::de::Error::duplicate_field("mviewDefinition"));
14989 }
14990 mview_definition__ = Some(map_.next_value()?);
14991 }
14992 GeneratedField::ExprContext => {
14993 if expr_context__.is_some() {
14994 return Err(serde::de::Error::duplicate_field("exprContext"));
14995 }
14996 expr_context__ = map_.next_value()?;
14997 }
14998 GeneratedField::ConfigOverride => {
14999 if config_override__.is_some() {
15000 return Err(serde::de::Error::duplicate_field("configOverride"));
15001 }
15002 config_override__ = Some(map_.next_value()?);
15003 }
15004 }
15005 }
15006 Ok(StreamActor {
15007 actor_id: actor_id__.unwrap_or_default(),
15008 fragment_id: fragment_id__.unwrap_or_default(),
15009 dispatcher: dispatcher__.unwrap_or_default(),
15010 vnode_bitmap: vnode_bitmap__,
15011 mview_definition: mview_definition__.unwrap_or_default(),
15012 expr_context: expr_context__,
15013 config_override: config_override__.unwrap_or_default(),
15014 })
15015 }
15016 }
15017 deserializer.deserialize_struct("stream_plan.StreamActor", FIELDS, GeneratedVisitor)
15018 }
15019}
15020impl serde::Serialize for StreamCdcScanNode {
15021 #[allow(deprecated)]
15022 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15023 where
15024 S: serde::Serializer,
15025 {
15026 use serde::ser::SerializeStruct;
15027 let mut len = 0;
15028 if self.table_id != 0 {
15029 len += 1;
15030 }
15031 if !self.upstream_column_ids.is_empty() {
15032 len += 1;
15033 }
15034 if !self.output_indices.is_empty() {
15035 len += 1;
15036 }
15037 if self.state_table.is_some() {
15038 len += 1;
15039 }
15040 if self.cdc_table_desc.is_some() {
15041 len += 1;
15042 }
15043 if self.rate_limit.is_some() {
15044 len += 1;
15045 }
15046 if self.disable_backfill {
15047 len += 1;
15048 }
15049 if self.options.is_some() {
15050 len += 1;
15051 }
15052 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanNode", len)?;
15053 if self.table_id != 0 {
15054 struct_ser.serialize_field("tableId", &self.table_id)?;
15055 }
15056 if !self.upstream_column_ids.is_empty() {
15057 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
15058 }
15059 if !self.output_indices.is_empty() {
15060 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
15061 }
15062 if let Some(v) = self.state_table.as_ref() {
15063 struct_ser.serialize_field("stateTable", v)?;
15064 }
15065 if let Some(v) = self.cdc_table_desc.as_ref() {
15066 struct_ser.serialize_field("cdcTableDesc", v)?;
15067 }
15068 if let Some(v) = self.rate_limit.as_ref() {
15069 struct_ser.serialize_field("rateLimit", v)?;
15070 }
15071 if self.disable_backfill {
15072 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
15073 }
15074 if let Some(v) = self.options.as_ref() {
15075 struct_ser.serialize_field("options", v)?;
15076 }
15077 struct_ser.end()
15078 }
15079}
15080impl<'de> serde::Deserialize<'de> for StreamCdcScanNode {
15081 #[allow(deprecated)]
15082 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15083 where
15084 D: serde::Deserializer<'de>,
15085 {
15086 const FIELDS: &[&str] = &[
15087 "table_id",
15088 "tableId",
15089 "upstream_column_ids",
15090 "upstreamColumnIds",
15091 "output_indices",
15092 "outputIndices",
15093 "state_table",
15094 "stateTable",
15095 "cdc_table_desc",
15096 "cdcTableDesc",
15097 "rate_limit",
15098 "rateLimit",
15099 "disable_backfill",
15100 "disableBackfill",
15101 "options",
15102 ];
15103
15104 #[allow(clippy::enum_variant_names)]
15105 enum GeneratedField {
15106 TableId,
15107 UpstreamColumnIds,
15108 OutputIndices,
15109 StateTable,
15110 CdcTableDesc,
15111 RateLimit,
15112 DisableBackfill,
15113 Options,
15114 }
15115 impl<'de> serde::Deserialize<'de> for GeneratedField {
15116 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15117 where
15118 D: serde::Deserializer<'de>,
15119 {
15120 struct GeneratedVisitor;
15121
15122 impl serde::de::Visitor<'_> for GeneratedVisitor {
15123 type Value = GeneratedField;
15124
15125 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15126 write!(formatter, "expected one of: {:?}", &FIELDS)
15127 }
15128
15129 #[allow(unused_variables)]
15130 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15131 where
15132 E: serde::de::Error,
15133 {
15134 match value {
15135 "tableId" | "table_id" => Ok(GeneratedField::TableId),
15136 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
15137 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
15138 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
15139 "cdcTableDesc" | "cdc_table_desc" => Ok(GeneratedField::CdcTableDesc),
15140 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
15141 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
15142 "options" => Ok(GeneratedField::Options),
15143 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15144 }
15145 }
15146 }
15147 deserializer.deserialize_identifier(GeneratedVisitor)
15148 }
15149 }
15150 struct GeneratedVisitor;
15151 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15152 type Value = StreamCdcScanNode;
15153
15154 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15155 formatter.write_str("struct stream_plan.StreamCdcScanNode")
15156 }
15157
15158 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanNode, V::Error>
15159 where
15160 V: serde::de::MapAccess<'de>,
15161 {
15162 let mut table_id__ = None;
15163 let mut upstream_column_ids__ = None;
15164 let mut output_indices__ = None;
15165 let mut state_table__ = None;
15166 let mut cdc_table_desc__ = None;
15167 let mut rate_limit__ = None;
15168 let mut disable_backfill__ = None;
15169 let mut options__ = None;
15170 while let Some(k) = map_.next_key()? {
15171 match k {
15172 GeneratedField::TableId => {
15173 if table_id__.is_some() {
15174 return Err(serde::de::Error::duplicate_field("tableId"));
15175 }
15176 table_id__ =
15177 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15178 ;
15179 }
15180 GeneratedField::UpstreamColumnIds => {
15181 if upstream_column_ids__.is_some() {
15182 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
15183 }
15184 upstream_column_ids__ =
15185 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15186 .into_iter().map(|x| x.0).collect())
15187 ;
15188 }
15189 GeneratedField::OutputIndices => {
15190 if output_indices__.is_some() {
15191 return Err(serde::de::Error::duplicate_field("outputIndices"));
15192 }
15193 output_indices__ =
15194 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15195 .into_iter().map(|x| x.0).collect())
15196 ;
15197 }
15198 GeneratedField::StateTable => {
15199 if state_table__.is_some() {
15200 return Err(serde::de::Error::duplicate_field("stateTable"));
15201 }
15202 state_table__ = map_.next_value()?;
15203 }
15204 GeneratedField::CdcTableDesc => {
15205 if cdc_table_desc__.is_some() {
15206 return Err(serde::de::Error::duplicate_field("cdcTableDesc"));
15207 }
15208 cdc_table_desc__ = map_.next_value()?;
15209 }
15210 GeneratedField::RateLimit => {
15211 if rate_limit__.is_some() {
15212 return Err(serde::de::Error::duplicate_field("rateLimit"));
15213 }
15214 rate_limit__ =
15215 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15216 ;
15217 }
15218 GeneratedField::DisableBackfill => {
15219 if disable_backfill__.is_some() {
15220 return Err(serde::de::Error::duplicate_field("disableBackfill"));
15221 }
15222 disable_backfill__ = Some(map_.next_value()?);
15223 }
15224 GeneratedField::Options => {
15225 if options__.is_some() {
15226 return Err(serde::de::Error::duplicate_field("options"));
15227 }
15228 options__ = map_.next_value()?;
15229 }
15230 }
15231 }
15232 Ok(StreamCdcScanNode {
15233 table_id: table_id__.unwrap_or_default(),
15234 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
15235 output_indices: output_indices__.unwrap_or_default(),
15236 state_table: state_table__,
15237 cdc_table_desc: cdc_table_desc__,
15238 rate_limit: rate_limit__,
15239 disable_backfill: disable_backfill__.unwrap_or_default(),
15240 options: options__,
15241 })
15242 }
15243 }
15244 deserializer.deserialize_struct("stream_plan.StreamCdcScanNode", FIELDS, GeneratedVisitor)
15245 }
15246}
15247impl serde::Serialize for StreamCdcScanOptions {
15248 #[allow(deprecated)]
15249 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15250 where
15251 S: serde::Serializer,
15252 {
15253 use serde::ser::SerializeStruct;
15254 let mut len = 0;
15255 if self.disable_backfill {
15256 len += 1;
15257 }
15258 if self.snapshot_barrier_interval != 0 {
15259 len += 1;
15260 }
15261 if self.snapshot_batch_size != 0 {
15262 len += 1;
15263 }
15264 if self.backfill_parallelism != 0 {
15265 len += 1;
15266 }
15267 if self.backfill_num_rows_per_split != 0 {
15268 len += 1;
15269 }
15270 if self.backfill_as_even_splits {
15271 len += 1;
15272 }
15273 if self.backfill_split_pk_column_index != 0 {
15274 len += 1;
15275 }
15276 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanOptions", len)?;
15277 if self.disable_backfill {
15278 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
15279 }
15280 if self.snapshot_barrier_interval != 0 {
15281 struct_ser.serialize_field("snapshotBarrierInterval", &self.snapshot_barrier_interval)?;
15282 }
15283 if self.snapshot_batch_size != 0 {
15284 struct_ser.serialize_field("snapshotBatchSize", &self.snapshot_batch_size)?;
15285 }
15286 if self.backfill_parallelism != 0 {
15287 struct_ser.serialize_field("backfillParallelism", &self.backfill_parallelism)?;
15288 }
15289 if self.backfill_num_rows_per_split != 0 {
15290 #[allow(clippy::needless_borrow)]
15291 #[allow(clippy::needless_borrows_for_generic_args)]
15292 struct_ser.serialize_field("backfillNumRowsPerSplit", ToString::to_string(&self.backfill_num_rows_per_split).as_str())?;
15293 }
15294 if self.backfill_as_even_splits {
15295 struct_ser.serialize_field("backfillAsEvenSplits", &self.backfill_as_even_splits)?;
15296 }
15297 if self.backfill_split_pk_column_index != 0 {
15298 struct_ser.serialize_field("backfillSplitPkColumnIndex", &self.backfill_split_pk_column_index)?;
15299 }
15300 struct_ser.end()
15301 }
15302}
15303impl<'de> serde::Deserialize<'de> for StreamCdcScanOptions {
15304 #[allow(deprecated)]
15305 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15306 where
15307 D: serde::Deserializer<'de>,
15308 {
15309 const FIELDS: &[&str] = &[
15310 "disable_backfill",
15311 "disableBackfill",
15312 "snapshot_barrier_interval",
15313 "snapshotBarrierInterval",
15314 "snapshot_batch_size",
15315 "snapshotBatchSize",
15316 "backfill_parallelism",
15317 "backfillParallelism",
15318 "backfill_num_rows_per_split",
15319 "backfillNumRowsPerSplit",
15320 "backfill_as_even_splits",
15321 "backfillAsEvenSplits",
15322 "backfill_split_pk_column_index",
15323 "backfillSplitPkColumnIndex",
15324 ];
15325
15326 #[allow(clippy::enum_variant_names)]
15327 enum GeneratedField {
15328 DisableBackfill,
15329 SnapshotBarrierInterval,
15330 SnapshotBatchSize,
15331 BackfillParallelism,
15332 BackfillNumRowsPerSplit,
15333 BackfillAsEvenSplits,
15334 BackfillSplitPkColumnIndex,
15335 }
15336 impl<'de> serde::Deserialize<'de> for GeneratedField {
15337 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15338 where
15339 D: serde::Deserializer<'de>,
15340 {
15341 struct GeneratedVisitor;
15342
15343 impl serde::de::Visitor<'_> for GeneratedVisitor {
15344 type Value = GeneratedField;
15345
15346 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15347 write!(formatter, "expected one of: {:?}", &FIELDS)
15348 }
15349
15350 #[allow(unused_variables)]
15351 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15352 where
15353 E: serde::de::Error,
15354 {
15355 match value {
15356 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
15357 "snapshotBarrierInterval" | "snapshot_barrier_interval" => Ok(GeneratedField::SnapshotBarrierInterval),
15358 "snapshotBatchSize" | "snapshot_batch_size" => Ok(GeneratedField::SnapshotBatchSize),
15359 "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
15360 "backfillNumRowsPerSplit" | "backfill_num_rows_per_split" => Ok(GeneratedField::BackfillNumRowsPerSplit),
15361 "backfillAsEvenSplits" | "backfill_as_even_splits" => Ok(GeneratedField::BackfillAsEvenSplits),
15362 "backfillSplitPkColumnIndex" | "backfill_split_pk_column_index" => Ok(GeneratedField::BackfillSplitPkColumnIndex),
15363 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15364 }
15365 }
15366 }
15367 deserializer.deserialize_identifier(GeneratedVisitor)
15368 }
15369 }
15370 struct GeneratedVisitor;
15371 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15372 type Value = StreamCdcScanOptions;
15373
15374 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15375 formatter.write_str("struct stream_plan.StreamCdcScanOptions")
15376 }
15377
15378 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanOptions, V::Error>
15379 where
15380 V: serde::de::MapAccess<'de>,
15381 {
15382 let mut disable_backfill__ = None;
15383 let mut snapshot_barrier_interval__ = None;
15384 let mut snapshot_batch_size__ = None;
15385 let mut backfill_parallelism__ = None;
15386 let mut backfill_num_rows_per_split__ = None;
15387 let mut backfill_as_even_splits__ = None;
15388 let mut backfill_split_pk_column_index__ = None;
15389 while let Some(k) = map_.next_key()? {
15390 match k {
15391 GeneratedField::DisableBackfill => {
15392 if disable_backfill__.is_some() {
15393 return Err(serde::de::Error::duplicate_field("disableBackfill"));
15394 }
15395 disable_backfill__ = Some(map_.next_value()?);
15396 }
15397 GeneratedField::SnapshotBarrierInterval => {
15398 if snapshot_barrier_interval__.is_some() {
15399 return Err(serde::de::Error::duplicate_field("snapshotBarrierInterval"));
15400 }
15401 snapshot_barrier_interval__ =
15402 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15403 ;
15404 }
15405 GeneratedField::SnapshotBatchSize => {
15406 if snapshot_batch_size__.is_some() {
15407 return Err(serde::de::Error::duplicate_field("snapshotBatchSize"));
15408 }
15409 snapshot_batch_size__ =
15410 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15411 ;
15412 }
15413 GeneratedField::BackfillParallelism => {
15414 if backfill_parallelism__.is_some() {
15415 return Err(serde::de::Error::duplicate_field("backfillParallelism"));
15416 }
15417 backfill_parallelism__ =
15418 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15419 ;
15420 }
15421 GeneratedField::BackfillNumRowsPerSplit => {
15422 if backfill_num_rows_per_split__.is_some() {
15423 return Err(serde::de::Error::duplicate_field("backfillNumRowsPerSplit"));
15424 }
15425 backfill_num_rows_per_split__ =
15426 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15427 ;
15428 }
15429 GeneratedField::BackfillAsEvenSplits => {
15430 if backfill_as_even_splits__.is_some() {
15431 return Err(serde::de::Error::duplicate_field("backfillAsEvenSplits"));
15432 }
15433 backfill_as_even_splits__ = Some(map_.next_value()?);
15434 }
15435 GeneratedField::BackfillSplitPkColumnIndex => {
15436 if backfill_split_pk_column_index__.is_some() {
15437 return Err(serde::de::Error::duplicate_field("backfillSplitPkColumnIndex"));
15438 }
15439 backfill_split_pk_column_index__ =
15440 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15441 ;
15442 }
15443 }
15444 }
15445 Ok(StreamCdcScanOptions {
15446 disable_backfill: disable_backfill__.unwrap_or_default(),
15447 snapshot_barrier_interval: snapshot_barrier_interval__.unwrap_or_default(),
15448 snapshot_batch_size: snapshot_batch_size__.unwrap_or_default(),
15449 backfill_parallelism: backfill_parallelism__.unwrap_or_default(),
15450 backfill_num_rows_per_split: backfill_num_rows_per_split__.unwrap_or_default(),
15451 backfill_as_even_splits: backfill_as_even_splits__.unwrap_or_default(),
15452 backfill_split_pk_column_index: backfill_split_pk_column_index__.unwrap_or_default(),
15453 })
15454 }
15455 }
15456 deserializer.deserialize_struct("stream_plan.StreamCdcScanOptions", FIELDS, GeneratedVisitor)
15457 }
15458}
15459impl serde::Serialize for StreamContext {
15460 #[allow(deprecated)]
15461 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15462 where
15463 S: serde::Serializer,
15464 {
15465 use serde::ser::SerializeStruct;
15466 let mut len = 0;
15467 if !self.timezone.is_empty() {
15468 len += 1;
15469 }
15470 if !self.config_override.is_empty() {
15471 len += 1;
15472 }
15473 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamContext", len)?;
15474 if !self.timezone.is_empty() {
15475 struct_ser.serialize_field("timezone", &self.timezone)?;
15476 }
15477 if !self.config_override.is_empty() {
15478 struct_ser.serialize_field("configOverride", &self.config_override)?;
15479 }
15480 struct_ser.end()
15481 }
15482}
15483impl<'de> serde::Deserialize<'de> for StreamContext {
15484 #[allow(deprecated)]
15485 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15486 where
15487 D: serde::Deserializer<'de>,
15488 {
15489 const FIELDS: &[&str] = &[
15490 "timezone",
15491 "config_override",
15492 "configOverride",
15493 ];
15494
15495 #[allow(clippy::enum_variant_names)]
15496 enum GeneratedField {
15497 Timezone,
15498 ConfigOverride,
15499 }
15500 impl<'de> serde::Deserialize<'de> for GeneratedField {
15501 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15502 where
15503 D: serde::Deserializer<'de>,
15504 {
15505 struct GeneratedVisitor;
15506
15507 impl serde::de::Visitor<'_> for GeneratedVisitor {
15508 type Value = GeneratedField;
15509
15510 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15511 write!(formatter, "expected one of: {:?}", &FIELDS)
15512 }
15513
15514 #[allow(unused_variables)]
15515 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15516 where
15517 E: serde::de::Error,
15518 {
15519 match value {
15520 "timezone" => Ok(GeneratedField::Timezone),
15521 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
15522 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15523 }
15524 }
15525 }
15526 deserializer.deserialize_identifier(GeneratedVisitor)
15527 }
15528 }
15529 struct GeneratedVisitor;
15530 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15531 type Value = StreamContext;
15532
15533 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15534 formatter.write_str("struct stream_plan.StreamContext")
15535 }
15536
15537 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamContext, V::Error>
15538 where
15539 V: serde::de::MapAccess<'de>,
15540 {
15541 let mut timezone__ = None;
15542 let mut config_override__ = None;
15543 while let Some(k) = map_.next_key()? {
15544 match k {
15545 GeneratedField::Timezone => {
15546 if timezone__.is_some() {
15547 return Err(serde::de::Error::duplicate_field("timezone"));
15548 }
15549 timezone__ = Some(map_.next_value()?);
15550 }
15551 GeneratedField::ConfigOverride => {
15552 if config_override__.is_some() {
15553 return Err(serde::de::Error::duplicate_field("configOverride"));
15554 }
15555 config_override__ = Some(map_.next_value()?);
15556 }
15557 }
15558 }
15559 Ok(StreamContext {
15560 timezone: timezone__.unwrap_or_default(),
15561 config_override: config_override__.unwrap_or_default(),
15562 })
15563 }
15564 }
15565 deserializer.deserialize_struct("stream_plan.StreamContext", FIELDS, GeneratedVisitor)
15566 }
15567}
15568impl serde::Serialize for StreamFragmentGraph {
15569 #[allow(deprecated)]
15570 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15571 where
15572 S: serde::Serializer,
15573 {
15574 use serde::ser::SerializeStruct;
15575 let mut len = 0;
15576 if !self.fragments.is_empty() {
15577 len += 1;
15578 }
15579 if !self.edges.is_empty() {
15580 len += 1;
15581 }
15582 if !self.dependent_table_ids.is_empty() {
15583 len += 1;
15584 }
15585 if self.table_ids_cnt != 0 {
15586 len += 1;
15587 }
15588 if self.ctx.is_some() {
15589 len += 1;
15590 }
15591 if self.parallelism.is_some() {
15592 len += 1;
15593 }
15594 if self.backfill_parallelism.is_some() {
15595 len += 1;
15596 }
15597 if !self.adaptive_parallelism_strategy.is_empty() {
15598 len += 1;
15599 }
15600 if !self.backfill_adaptive_parallelism_strategy.is_empty() {
15601 len += 1;
15602 }
15603 if self.max_parallelism != 0 {
15604 len += 1;
15605 }
15606 if self.backfill_order.is_some() {
15607 len += 1;
15608 }
15609 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph", len)?;
15610 if !self.fragments.is_empty() {
15611 struct_ser.serialize_field("fragments", &self.fragments)?;
15612 }
15613 if !self.edges.is_empty() {
15614 struct_ser.serialize_field("edges", &self.edges)?;
15615 }
15616 if !self.dependent_table_ids.is_empty() {
15617 struct_ser.serialize_field("dependentTableIds", &self.dependent_table_ids)?;
15618 }
15619 if self.table_ids_cnt != 0 {
15620 struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
15621 }
15622 if let Some(v) = self.ctx.as_ref() {
15623 struct_ser.serialize_field("ctx", v)?;
15624 }
15625 if let Some(v) = self.parallelism.as_ref() {
15626 struct_ser.serialize_field("parallelism", v)?;
15627 }
15628 if let Some(v) = self.backfill_parallelism.as_ref() {
15629 struct_ser.serialize_field("backfillParallelism", v)?;
15630 }
15631 if !self.adaptive_parallelism_strategy.is_empty() {
15632 struct_ser.serialize_field("adaptiveParallelismStrategy", &self.adaptive_parallelism_strategy)?;
15633 }
15634 if !self.backfill_adaptive_parallelism_strategy.is_empty() {
15635 struct_ser.serialize_field("backfillAdaptiveParallelismStrategy", &self.backfill_adaptive_parallelism_strategy)?;
15636 }
15637 if self.max_parallelism != 0 {
15638 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
15639 }
15640 if let Some(v) = self.backfill_order.as_ref() {
15641 struct_ser.serialize_field("backfillOrder", v)?;
15642 }
15643 struct_ser.end()
15644 }
15645}
15646impl<'de> serde::Deserialize<'de> for StreamFragmentGraph {
15647 #[allow(deprecated)]
15648 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15649 where
15650 D: serde::Deserializer<'de>,
15651 {
15652 const FIELDS: &[&str] = &[
15653 "fragments",
15654 "edges",
15655 "dependent_table_ids",
15656 "dependentTableIds",
15657 "table_ids_cnt",
15658 "tableIdsCnt",
15659 "ctx",
15660 "parallelism",
15661 "backfill_parallelism",
15662 "backfillParallelism",
15663 "adaptive_parallelism_strategy",
15664 "adaptiveParallelismStrategy",
15665 "backfill_adaptive_parallelism_strategy",
15666 "backfillAdaptiveParallelismStrategy",
15667 "max_parallelism",
15668 "maxParallelism",
15669 "backfill_order",
15670 "backfillOrder",
15671 ];
15672
15673 #[allow(clippy::enum_variant_names)]
15674 enum GeneratedField {
15675 Fragments,
15676 Edges,
15677 DependentTableIds,
15678 TableIdsCnt,
15679 Ctx,
15680 Parallelism,
15681 BackfillParallelism,
15682 AdaptiveParallelismStrategy,
15683 BackfillAdaptiveParallelismStrategy,
15684 MaxParallelism,
15685 BackfillOrder,
15686 }
15687 impl<'de> serde::Deserialize<'de> for GeneratedField {
15688 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15689 where
15690 D: serde::Deserializer<'de>,
15691 {
15692 struct GeneratedVisitor;
15693
15694 impl serde::de::Visitor<'_> for GeneratedVisitor {
15695 type Value = GeneratedField;
15696
15697 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15698 write!(formatter, "expected one of: {:?}", &FIELDS)
15699 }
15700
15701 #[allow(unused_variables)]
15702 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15703 where
15704 E: serde::de::Error,
15705 {
15706 match value {
15707 "fragments" => Ok(GeneratedField::Fragments),
15708 "edges" => Ok(GeneratedField::Edges),
15709 "dependentTableIds" | "dependent_table_ids" => Ok(GeneratedField::DependentTableIds),
15710 "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
15711 "ctx" => Ok(GeneratedField::Ctx),
15712 "parallelism" => Ok(GeneratedField::Parallelism),
15713 "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
15714 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
15715 "backfillAdaptiveParallelismStrategy" | "backfill_adaptive_parallelism_strategy" => Ok(GeneratedField::BackfillAdaptiveParallelismStrategy),
15716 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
15717 "backfillOrder" | "backfill_order" => Ok(GeneratedField::BackfillOrder),
15718 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15719 }
15720 }
15721 }
15722 deserializer.deserialize_identifier(GeneratedVisitor)
15723 }
15724 }
15725 struct GeneratedVisitor;
15726 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15727 type Value = StreamFragmentGraph;
15728
15729 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15730 formatter.write_str("struct stream_plan.StreamFragmentGraph")
15731 }
15732
15733 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFragmentGraph, V::Error>
15734 where
15735 V: serde::de::MapAccess<'de>,
15736 {
15737 let mut fragments__ = None;
15738 let mut edges__ = None;
15739 let mut dependent_table_ids__ = None;
15740 let mut table_ids_cnt__ = None;
15741 let mut ctx__ = None;
15742 let mut parallelism__ = None;
15743 let mut backfill_parallelism__ = None;
15744 let mut adaptive_parallelism_strategy__ = None;
15745 let mut backfill_adaptive_parallelism_strategy__ = None;
15746 let mut max_parallelism__ = None;
15747 let mut backfill_order__ = None;
15748 while let Some(k) = map_.next_key()? {
15749 match k {
15750 GeneratedField::Fragments => {
15751 if fragments__.is_some() {
15752 return Err(serde::de::Error::duplicate_field("fragments"));
15753 }
15754 fragments__ = Some(
15755 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15756 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15757 );
15758 }
15759 GeneratedField::Edges => {
15760 if edges__.is_some() {
15761 return Err(serde::de::Error::duplicate_field("edges"));
15762 }
15763 edges__ = Some(map_.next_value()?);
15764 }
15765 GeneratedField::DependentTableIds => {
15766 if dependent_table_ids__.is_some() {
15767 return Err(serde::de::Error::duplicate_field("dependentTableIds"));
15768 }
15769 dependent_table_ids__ =
15770 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15771 .into_iter().map(|x| x.0).collect())
15772 ;
15773 }
15774 GeneratedField::TableIdsCnt => {
15775 if table_ids_cnt__.is_some() {
15776 return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
15777 }
15778 table_ids_cnt__ =
15779 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15780 ;
15781 }
15782 GeneratedField::Ctx => {
15783 if ctx__.is_some() {
15784 return Err(serde::de::Error::duplicate_field("ctx"));
15785 }
15786 ctx__ = map_.next_value()?;
15787 }
15788 GeneratedField::Parallelism => {
15789 if parallelism__.is_some() {
15790 return Err(serde::de::Error::duplicate_field("parallelism"));
15791 }
15792 parallelism__ = map_.next_value()?;
15793 }
15794 GeneratedField::BackfillParallelism => {
15795 if backfill_parallelism__.is_some() {
15796 return Err(serde::de::Error::duplicate_field("backfillParallelism"));
15797 }
15798 backfill_parallelism__ = map_.next_value()?;
15799 }
15800 GeneratedField::AdaptiveParallelismStrategy => {
15801 if adaptive_parallelism_strategy__.is_some() {
15802 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
15803 }
15804 adaptive_parallelism_strategy__ = Some(map_.next_value()?);
15805 }
15806 GeneratedField::BackfillAdaptiveParallelismStrategy => {
15807 if backfill_adaptive_parallelism_strategy__.is_some() {
15808 return Err(serde::de::Error::duplicate_field("backfillAdaptiveParallelismStrategy"));
15809 }
15810 backfill_adaptive_parallelism_strategy__ = Some(map_.next_value()?);
15811 }
15812 GeneratedField::MaxParallelism => {
15813 if max_parallelism__.is_some() {
15814 return Err(serde::de::Error::duplicate_field("maxParallelism"));
15815 }
15816 max_parallelism__ =
15817 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15818 ;
15819 }
15820 GeneratedField::BackfillOrder => {
15821 if backfill_order__.is_some() {
15822 return Err(serde::de::Error::duplicate_field("backfillOrder"));
15823 }
15824 backfill_order__ = map_.next_value()?;
15825 }
15826 }
15827 }
15828 Ok(StreamFragmentGraph {
15829 fragments: fragments__.unwrap_or_default(),
15830 edges: edges__.unwrap_or_default(),
15831 dependent_table_ids: dependent_table_ids__.unwrap_or_default(),
15832 table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
15833 ctx: ctx__,
15834 parallelism: parallelism__,
15835 backfill_parallelism: backfill_parallelism__,
15836 adaptive_parallelism_strategy: adaptive_parallelism_strategy__.unwrap_or_default(),
15837 backfill_adaptive_parallelism_strategy: backfill_adaptive_parallelism_strategy__.unwrap_or_default(),
15838 max_parallelism: max_parallelism__.unwrap_or_default(),
15839 backfill_order: backfill_order__,
15840 })
15841 }
15842 }
15843 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph", FIELDS, GeneratedVisitor)
15844 }
15845}
15846impl serde::Serialize for stream_fragment_graph::Parallelism {
15847 #[allow(deprecated)]
15848 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15849 where
15850 S: serde::Serializer,
15851 {
15852 use serde::ser::SerializeStruct;
15853 let mut len = 0;
15854 if self.parallelism != 0 {
15855 len += 1;
15856 }
15857 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.Parallelism", len)?;
15858 if self.parallelism != 0 {
15859 #[allow(clippy::needless_borrow)]
15860 #[allow(clippy::needless_borrows_for_generic_args)]
15861 struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
15862 }
15863 struct_ser.end()
15864 }
15865}
15866impl<'de> serde::Deserialize<'de> for stream_fragment_graph::Parallelism {
15867 #[allow(deprecated)]
15868 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15869 where
15870 D: serde::Deserializer<'de>,
15871 {
15872 const FIELDS: &[&str] = &[
15873 "parallelism",
15874 ];
15875
15876 #[allow(clippy::enum_variant_names)]
15877 enum GeneratedField {
15878 Parallelism,
15879 }
15880 impl<'de> serde::Deserialize<'de> for GeneratedField {
15881 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15882 where
15883 D: serde::Deserializer<'de>,
15884 {
15885 struct GeneratedVisitor;
15886
15887 impl serde::de::Visitor<'_> for GeneratedVisitor {
15888 type Value = GeneratedField;
15889
15890 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15891 write!(formatter, "expected one of: {:?}", &FIELDS)
15892 }
15893
15894 #[allow(unused_variables)]
15895 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15896 where
15897 E: serde::de::Error,
15898 {
15899 match value {
15900 "parallelism" => Ok(GeneratedField::Parallelism),
15901 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15902 }
15903 }
15904 }
15905 deserializer.deserialize_identifier(GeneratedVisitor)
15906 }
15907 }
15908 struct GeneratedVisitor;
15909 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15910 type Value = stream_fragment_graph::Parallelism;
15911
15912 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15913 formatter.write_str("struct stream_plan.StreamFragmentGraph.Parallelism")
15914 }
15915
15916 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::Parallelism, V::Error>
15917 where
15918 V: serde::de::MapAccess<'de>,
15919 {
15920 let mut parallelism__ = None;
15921 while let Some(k) = map_.next_key()? {
15922 match k {
15923 GeneratedField::Parallelism => {
15924 if parallelism__.is_some() {
15925 return Err(serde::de::Error::duplicate_field("parallelism"));
15926 }
15927 parallelism__ =
15928 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15929 ;
15930 }
15931 }
15932 }
15933 Ok(stream_fragment_graph::Parallelism {
15934 parallelism: parallelism__.unwrap_or_default(),
15935 })
15936 }
15937 }
15938 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.Parallelism", FIELDS, GeneratedVisitor)
15939 }
15940}
15941impl serde::Serialize for stream_fragment_graph::StreamFragment {
15942 #[allow(deprecated)]
15943 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15944 where
15945 S: serde::Serializer,
15946 {
15947 use serde::ser::SerializeStruct;
15948 let mut len = 0;
15949 if self.fragment_id != 0 {
15950 len += 1;
15951 }
15952 if self.node.is_some() {
15953 len += 1;
15954 }
15955 if self.fragment_type_mask != 0 {
15956 len += 1;
15957 }
15958 if self.requires_singleton {
15959 len += 1;
15960 }
15961 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", len)?;
15962 if self.fragment_id != 0 {
15963 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
15964 }
15965 if let Some(v) = self.node.as_ref() {
15966 struct_ser.serialize_field("node", v)?;
15967 }
15968 if self.fragment_type_mask != 0 {
15969 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
15970 }
15971 if self.requires_singleton {
15972 struct_ser.serialize_field("requiresSingleton", &self.requires_singleton)?;
15973 }
15974 struct_ser.end()
15975 }
15976}
15977impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragment {
15978 #[allow(deprecated)]
15979 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15980 where
15981 D: serde::Deserializer<'de>,
15982 {
15983 const FIELDS: &[&str] = &[
15984 "fragment_id",
15985 "fragmentId",
15986 "node",
15987 "fragment_type_mask",
15988 "fragmentTypeMask",
15989 "requires_singleton",
15990 "requiresSingleton",
15991 ];
15992
15993 #[allow(clippy::enum_variant_names)]
15994 enum GeneratedField {
15995 FragmentId,
15996 Node,
15997 FragmentTypeMask,
15998 RequiresSingleton,
15999 }
16000 impl<'de> serde::Deserialize<'de> for GeneratedField {
16001 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16002 where
16003 D: serde::Deserializer<'de>,
16004 {
16005 struct GeneratedVisitor;
16006
16007 impl serde::de::Visitor<'_> for GeneratedVisitor {
16008 type Value = GeneratedField;
16009
16010 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16011 write!(formatter, "expected one of: {:?}", &FIELDS)
16012 }
16013
16014 #[allow(unused_variables)]
16015 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16016 where
16017 E: serde::de::Error,
16018 {
16019 match value {
16020 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
16021 "node" => Ok(GeneratedField::Node),
16022 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
16023 "requiresSingleton" | "requires_singleton" => Ok(GeneratedField::RequiresSingleton),
16024 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16025 }
16026 }
16027 }
16028 deserializer.deserialize_identifier(GeneratedVisitor)
16029 }
16030 }
16031 struct GeneratedVisitor;
16032 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16033 type Value = stream_fragment_graph::StreamFragment;
16034
16035 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16036 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragment")
16037 }
16038
16039 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragment, V::Error>
16040 where
16041 V: serde::de::MapAccess<'de>,
16042 {
16043 let mut fragment_id__ = None;
16044 let mut node__ = None;
16045 let mut fragment_type_mask__ = None;
16046 let mut requires_singleton__ = None;
16047 while let Some(k) = map_.next_key()? {
16048 match k {
16049 GeneratedField::FragmentId => {
16050 if fragment_id__.is_some() {
16051 return Err(serde::de::Error::duplicate_field("fragmentId"));
16052 }
16053 fragment_id__ =
16054 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16055 ;
16056 }
16057 GeneratedField::Node => {
16058 if node__.is_some() {
16059 return Err(serde::de::Error::duplicate_field("node"));
16060 }
16061 node__ = map_.next_value()?;
16062 }
16063 GeneratedField::FragmentTypeMask => {
16064 if fragment_type_mask__.is_some() {
16065 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
16066 }
16067 fragment_type_mask__ =
16068 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16069 ;
16070 }
16071 GeneratedField::RequiresSingleton => {
16072 if requires_singleton__.is_some() {
16073 return Err(serde::de::Error::duplicate_field("requiresSingleton"));
16074 }
16075 requires_singleton__ = Some(map_.next_value()?);
16076 }
16077 }
16078 }
16079 Ok(stream_fragment_graph::StreamFragment {
16080 fragment_id: fragment_id__.unwrap_or_default(),
16081 node: node__,
16082 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
16083 requires_singleton: requires_singleton__.unwrap_or_default(),
16084 })
16085 }
16086 }
16087 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", FIELDS, GeneratedVisitor)
16088 }
16089}
16090impl serde::Serialize for stream_fragment_graph::StreamFragmentEdge {
16091 #[allow(deprecated)]
16092 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16093 where
16094 S: serde::Serializer,
16095 {
16096 use serde::ser::SerializeStruct;
16097 let mut len = 0;
16098 if self.dispatch_strategy.is_some() {
16099 len += 1;
16100 }
16101 if self.link_id != 0 {
16102 len += 1;
16103 }
16104 if self.upstream_id != 0 {
16105 len += 1;
16106 }
16107 if self.downstream_id != 0 {
16108 len += 1;
16109 }
16110 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", len)?;
16111 if let Some(v) = self.dispatch_strategy.as_ref() {
16112 struct_ser.serialize_field("dispatchStrategy", v)?;
16113 }
16114 if self.link_id != 0 {
16115 #[allow(clippy::needless_borrow)]
16116 #[allow(clippy::needless_borrows_for_generic_args)]
16117 struct_ser.serialize_field("linkId", ToString::to_string(&self.link_id).as_str())?;
16118 }
16119 if self.upstream_id != 0 {
16120 struct_ser.serialize_field("upstreamId", &self.upstream_id)?;
16121 }
16122 if self.downstream_id != 0 {
16123 struct_ser.serialize_field("downstreamId", &self.downstream_id)?;
16124 }
16125 struct_ser.end()
16126 }
16127}
16128impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragmentEdge {
16129 #[allow(deprecated)]
16130 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16131 where
16132 D: serde::Deserializer<'de>,
16133 {
16134 const FIELDS: &[&str] = &[
16135 "dispatch_strategy",
16136 "dispatchStrategy",
16137 "link_id",
16138 "linkId",
16139 "upstream_id",
16140 "upstreamId",
16141 "downstream_id",
16142 "downstreamId",
16143 ];
16144
16145 #[allow(clippy::enum_variant_names)]
16146 enum GeneratedField {
16147 DispatchStrategy,
16148 LinkId,
16149 UpstreamId,
16150 DownstreamId,
16151 }
16152 impl<'de> serde::Deserialize<'de> for GeneratedField {
16153 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16154 where
16155 D: serde::Deserializer<'de>,
16156 {
16157 struct GeneratedVisitor;
16158
16159 impl serde::de::Visitor<'_> for GeneratedVisitor {
16160 type Value = GeneratedField;
16161
16162 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16163 write!(formatter, "expected one of: {:?}", &FIELDS)
16164 }
16165
16166 #[allow(unused_variables)]
16167 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16168 where
16169 E: serde::de::Error,
16170 {
16171 match value {
16172 "dispatchStrategy" | "dispatch_strategy" => Ok(GeneratedField::DispatchStrategy),
16173 "linkId" | "link_id" => Ok(GeneratedField::LinkId),
16174 "upstreamId" | "upstream_id" => Ok(GeneratedField::UpstreamId),
16175 "downstreamId" | "downstream_id" => Ok(GeneratedField::DownstreamId),
16176 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16177 }
16178 }
16179 }
16180 deserializer.deserialize_identifier(GeneratedVisitor)
16181 }
16182 }
16183 struct GeneratedVisitor;
16184 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16185 type Value = stream_fragment_graph::StreamFragmentEdge;
16186
16187 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16188 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragmentEdge")
16189 }
16190
16191 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragmentEdge, V::Error>
16192 where
16193 V: serde::de::MapAccess<'de>,
16194 {
16195 let mut dispatch_strategy__ = None;
16196 let mut link_id__ = None;
16197 let mut upstream_id__ = None;
16198 let mut downstream_id__ = None;
16199 while let Some(k) = map_.next_key()? {
16200 match k {
16201 GeneratedField::DispatchStrategy => {
16202 if dispatch_strategy__.is_some() {
16203 return Err(serde::de::Error::duplicate_field("dispatchStrategy"));
16204 }
16205 dispatch_strategy__ = map_.next_value()?;
16206 }
16207 GeneratedField::LinkId => {
16208 if link_id__.is_some() {
16209 return Err(serde::de::Error::duplicate_field("linkId"));
16210 }
16211 link_id__ =
16212 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16213 ;
16214 }
16215 GeneratedField::UpstreamId => {
16216 if upstream_id__.is_some() {
16217 return Err(serde::de::Error::duplicate_field("upstreamId"));
16218 }
16219 upstream_id__ =
16220 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16221 ;
16222 }
16223 GeneratedField::DownstreamId => {
16224 if downstream_id__.is_some() {
16225 return Err(serde::de::Error::duplicate_field("downstreamId"));
16226 }
16227 downstream_id__ =
16228 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16229 ;
16230 }
16231 }
16232 }
16233 Ok(stream_fragment_graph::StreamFragmentEdge {
16234 dispatch_strategy: dispatch_strategy__,
16235 link_id: link_id__.unwrap_or_default(),
16236 upstream_id: upstream_id__.unwrap_or_default(),
16237 downstream_id: downstream_id__.unwrap_or_default(),
16238 })
16239 }
16240 }
16241 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", FIELDS, GeneratedVisitor)
16242 }
16243}
16244impl serde::Serialize for StreamFsFetch {
16245 #[allow(deprecated)]
16246 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16247 where
16248 S: serde::Serializer,
16249 {
16250 use serde::ser::SerializeStruct;
16251 let mut len = 0;
16252 if self.source_id != 0 {
16253 len += 1;
16254 }
16255 if self.state_table.is_some() {
16256 len += 1;
16257 }
16258 if self.row_id_index.is_some() {
16259 len += 1;
16260 }
16261 if !self.columns.is_empty() {
16262 len += 1;
16263 }
16264 if !self.with_properties.is_empty() {
16265 len += 1;
16266 }
16267 if self.info.is_some() {
16268 len += 1;
16269 }
16270 if !self.source_name.is_empty() {
16271 len += 1;
16272 }
16273 if self.rate_limit.is_some() {
16274 len += 1;
16275 }
16276 if !self.secret_refs.is_empty() {
16277 len += 1;
16278 }
16279 if self.refresh_mode.is_some() {
16280 len += 1;
16281 }
16282 if self.associated_table_id.is_some() {
16283 len += 1;
16284 }
16285 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetch", len)?;
16286 if self.source_id != 0 {
16287 struct_ser.serialize_field("sourceId", &self.source_id)?;
16288 }
16289 if let Some(v) = self.state_table.as_ref() {
16290 struct_ser.serialize_field("stateTable", v)?;
16291 }
16292 if let Some(v) = self.row_id_index.as_ref() {
16293 struct_ser.serialize_field("rowIdIndex", v)?;
16294 }
16295 if !self.columns.is_empty() {
16296 struct_ser.serialize_field("columns", &self.columns)?;
16297 }
16298 if !self.with_properties.is_empty() {
16299 struct_ser.serialize_field("withProperties", &self.with_properties)?;
16300 }
16301 if let Some(v) = self.info.as_ref() {
16302 struct_ser.serialize_field("info", v)?;
16303 }
16304 if !self.source_name.is_empty() {
16305 struct_ser.serialize_field("sourceName", &self.source_name)?;
16306 }
16307 if let Some(v) = self.rate_limit.as_ref() {
16308 struct_ser.serialize_field("rateLimit", v)?;
16309 }
16310 if !self.secret_refs.is_empty() {
16311 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
16312 }
16313 if let Some(v) = self.refresh_mode.as_ref() {
16314 struct_ser.serialize_field("refreshMode", v)?;
16315 }
16316 if let Some(v) = self.associated_table_id.as_ref() {
16317 struct_ser.serialize_field("associatedTableId", v)?;
16318 }
16319 struct_ser.end()
16320 }
16321}
16322impl<'de> serde::Deserialize<'de> for StreamFsFetch {
16323 #[allow(deprecated)]
16324 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16325 where
16326 D: serde::Deserializer<'de>,
16327 {
16328 const FIELDS: &[&str] = &[
16329 "source_id",
16330 "sourceId",
16331 "state_table",
16332 "stateTable",
16333 "row_id_index",
16334 "rowIdIndex",
16335 "columns",
16336 "with_properties",
16337 "withProperties",
16338 "info",
16339 "source_name",
16340 "sourceName",
16341 "rate_limit",
16342 "rateLimit",
16343 "secret_refs",
16344 "secretRefs",
16345 "refresh_mode",
16346 "refreshMode",
16347 "associated_table_id",
16348 "associatedTableId",
16349 ];
16350
16351 #[allow(clippy::enum_variant_names)]
16352 enum GeneratedField {
16353 SourceId,
16354 StateTable,
16355 RowIdIndex,
16356 Columns,
16357 WithProperties,
16358 Info,
16359 SourceName,
16360 RateLimit,
16361 SecretRefs,
16362 RefreshMode,
16363 AssociatedTableId,
16364 }
16365 impl<'de> serde::Deserialize<'de> for GeneratedField {
16366 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16367 where
16368 D: serde::Deserializer<'de>,
16369 {
16370 struct GeneratedVisitor;
16371
16372 impl serde::de::Visitor<'_> for GeneratedVisitor {
16373 type Value = GeneratedField;
16374
16375 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16376 write!(formatter, "expected one of: {:?}", &FIELDS)
16377 }
16378
16379 #[allow(unused_variables)]
16380 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16381 where
16382 E: serde::de::Error,
16383 {
16384 match value {
16385 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
16386 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
16387 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
16388 "columns" => Ok(GeneratedField::Columns),
16389 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
16390 "info" => Ok(GeneratedField::Info),
16391 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
16392 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
16393 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
16394 "refreshMode" | "refresh_mode" => Ok(GeneratedField::RefreshMode),
16395 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
16396 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16397 }
16398 }
16399 }
16400 deserializer.deserialize_identifier(GeneratedVisitor)
16401 }
16402 }
16403 struct GeneratedVisitor;
16404 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16405 type Value = StreamFsFetch;
16406
16407 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16408 formatter.write_str("struct stream_plan.StreamFsFetch")
16409 }
16410
16411 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetch, V::Error>
16412 where
16413 V: serde::de::MapAccess<'de>,
16414 {
16415 let mut source_id__ = None;
16416 let mut state_table__ = None;
16417 let mut row_id_index__ = None;
16418 let mut columns__ = None;
16419 let mut with_properties__ = None;
16420 let mut info__ = None;
16421 let mut source_name__ = None;
16422 let mut rate_limit__ = None;
16423 let mut secret_refs__ = None;
16424 let mut refresh_mode__ = None;
16425 let mut associated_table_id__ = None;
16426 while let Some(k) = map_.next_key()? {
16427 match k {
16428 GeneratedField::SourceId => {
16429 if source_id__.is_some() {
16430 return Err(serde::de::Error::duplicate_field("sourceId"));
16431 }
16432 source_id__ =
16433 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16434 ;
16435 }
16436 GeneratedField::StateTable => {
16437 if state_table__.is_some() {
16438 return Err(serde::de::Error::duplicate_field("stateTable"));
16439 }
16440 state_table__ = map_.next_value()?;
16441 }
16442 GeneratedField::RowIdIndex => {
16443 if row_id_index__.is_some() {
16444 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
16445 }
16446 row_id_index__ =
16447 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16448 ;
16449 }
16450 GeneratedField::Columns => {
16451 if columns__.is_some() {
16452 return Err(serde::de::Error::duplicate_field("columns"));
16453 }
16454 columns__ = Some(map_.next_value()?);
16455 }
16456 GeneratedField::WithProperties => {
16457 if with_properties__.is_some() {
16458 return Err(serde::de::Error::duplicate_field("withProperties"));
16459 }
16460 with_properties__ = Some(
16461 map_.next_value::<std::collections::BTreeMap<_, _>>()?
16462 );
16463 }
16464 GeneratedField::Info => {
16465 if info__.is_some() {
16466 return Err(serde::de::Error::duplicate_field("info"));
16467 }
16468 info__ = map_.next_value()?;
16469 }
16470 GeneratedField::SourceName => {
16471 if source_name__.is_some() {
16472 return Err(serde::de::Error::duplicate_field("sourceName"));
16473 }
16474 source_name__ = Some(map_.next_value()?);
16475 }
16476 GeneratedField::RateLimit => {
16477 if rate_limit__.is_some() {
16478 return Err(serde::de::Error::duplicate_field("rateLimit"));
16479 }
16480 rate_limit__ =
16481 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16482 ;
16483 }
16484 GeneratedField::SecretRefs => {
16485 if secret_refs__.is_some() {
16486 return Err(serde::de::Error::duplicate_field("secretRefs"));
16487 }
16488 secret_refs__ = Some(
16489 map_.next_value::<std::collections::BTreeMap<_, _>>()?
16490 );
16491 }
16492 GeneratedField::RefreshMode => {
16493 if refresh_mode__.is_some() {
16494 return Err(serde::de::Error::duplicate_field("refreshMode"));
16495 }
16496 refresh_mode__ = map_.next_value()?;
16497 }
16498 GeneratedField::AssociatedTableId => {
16499 if associated_table_id__.is_some() {
16500 return Err(serde::de::Error::duplicate_field("associatedTableId"));
16501 }
16502 associated_table_id__ =
16503 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16504 ;
16505 }
16506 }
16507 }
16508 Ok(StreamFsFetch {
16509 source_id: source_id__.unwrap_or_default(),
16510 state_table: state_table__,
16511 row_id_index: row_id_index__,
16512 columns: columns__.unwrap_or_default(),
16513 with_properties: with_properties__.unwrap_or_default(),
16514 info: info__,
16515 source_name: source_name__.unwrap_or_default(),
16516 rate_limit: rate_limit__,
16517 secret_refs: secret_refs__.unwrap_or_default(),
16518 refresh_mode: refresh_mode__,
16519 associated_table_id: associated_table_id__,
16520 })
16521 }
16522 }
16523 deserializer.deserialize_struct("stream_plan.StreamFsFetch", FIELDS, GeneratedVisitor)
16524 }
16525}
16526impl serde::Serialize for StreamFsFetchNode {
16527 #[allow(deprecated)]
16528 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16529 where
16530 S: serde::Serializer,
16531 {
16532 use serde::ser::SerializeStruct;
16533 let mut len = 0;
16534 if self.node_inner.is_some() {
16535 len += 1;
16536 }
16537 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetchNode", len)?;
16538 if let Some(v) = self.node_inner.as_ref() {
16539 struct_ser.serialize_field("nodeInner", v)?;
16540 }
16541 struct_ser.end()
16542 }
16543}
16544impl<'de> serde::Deserialize<'de> for StreamFsFetchNode {
16545 #[allow(deprecated)]
16546 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16547 where
16548 D: serde::Deserializer<'de>,
16549 {
16550 const FIELDS: &[&str] = &[
16551 "node_inner",
16552 "nodeInner",
16553 ];
16554
16555 #[allow(clippy::enum_variant_names)]
16556 enum GeneratedField {
16557 NodeInner,
16558 }
16559 impl<'de> serde::Deserialize<'de> for GeneratedField {
16560 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16561 where
16562 D: serde::Deserializer<'de>,
16563 {
16564 struct GeneratedVisitor;
16565
16566 impl serde::de::Visitor<'_> for GeneratedVisitor {
16567 type Value = GeneratedField;
16568
16569 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16570 write!(formatter, "expected one of: {:?}", &FIELDS)
16571 }
16572
16573 #[allow(unused_variables)]
16574 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16575 where
16576 E: serde::de::Error,
16577 {
16578 match value {
16579 "nodeInner" | "node_inner" => Ok(GeneratedField::NodeInner),
16580 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16581 }
16582 }
16583 }
16584 deserializer.deserialize_identifier(GeneratedVisitor)
16585 }
16586 }
16587 struct GeneratedVisitor;
16588 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16589 type Value = StreamFsFetchNode;
16590
16591 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16592 formatter.write_str("struct stream_plan.StreamFsFetchNode")
16593 }
16594
16595 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetchNode, V::Error>
16596 where
16597 V: serde::de::MapAccess<'de>,
16598 {
16599 let mut node_inner__ = None;
16600 while let Some(k) = map_.next_key()? {
16601 match k {
16602 GeneratedField::NodeInner => {
16603 if node_inner__.is_some() {
16604 return Err(serde::de::Error::duplicate_field("nodeInner"));
16605 }
16606 node_inner__ = map_.next_value()?;
16607 }
16608 }
16609 }
16610 Ok(StreamFsFetchNode {
16611 node_inner: node_inner__,
16612 })
16613 }
16614 }
16615 deserializer.deserialize_struct("stream_plan.StreamFsFetchNode", FIELDS, GeneratedVisitor)
16616 }
16617}
16618impl serde::Serialize for StreamMessage {
16619 #[allow(deprecated)]
16620 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16621 where
16622 S: serde::Serializer,
16623 {
16624 use serde::ser::SerializeStruct;
16625 let mut len = 0;
16626 if self.stream_message.is_some() {
16627 len += 1;
16628 }
16629 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessage", len)?;
16630 if let Some(v) = self.stream_message.as_ref() {
16631 match v {
16632 stream_message::StreamMessage::StreamChunk(v) => {
16633 struct_ser.serialize_field("streamChunk", v)?;
16634 }
16635 stream_message::StreamMessage::Barrier(v) => {
16636 struct_ser.serialize_field("barrier", v)?;
16637 }
16638 stream_message::StreamMessage::Watermark(v) => {
16639 struct_ser.serialize_field("watermark", v)?;
16640 }
16641 }
16642 }
16643 struct_ser.end()
16644 }
16645}
16646impl<'de> serde::Deserialize<'de> for StreamMessage {
16647 #[allow(deprecated)]
16648 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16649 where
16650 D: serde::Deserializer<'de>,
16651 {
16652 const FIELDS: &[&str] = &[
16653 "stream_chunk",
16654 "streamChunk",
16655 "barrier",
16656 "watermark",
16657 ];
16658
16659 #[allow(clippy::enum_variant_names)]
16660 enum GeneratedField {
16661 StreamChunk,
16662 Barrier,
16663 Watermark,
16664 }
16665 impl<'de> serde::Deserialize<'de> for GeneratedField {
16666 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16667 where
16668 D: serde::Deserializer<'de>,
16669 {
16670 struct GeneratedVisitor;
16671
16672 impl serde::de::Visitor<'_> for GeneratedVisitor {
16673 type Value = GeneratedField;
16674
16675 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16676 write!(formatter, "expected one of: {:?}", &FIELDS)
16677 }
16678
16679 #[allow(unused_variables)]
16680 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16681 where
16682 E: serde::de::Error,
16683 {
16684 match value {
16685 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
16686 "barrier" => Ok(GeneratedField::Barrier),
16687 "watermark" => Ok(GeneratedField::Watermark),
16688 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16689 }
16690 }
16691 }
16692 deserializer.deserialize_identifier(GeneratedVisitor)
16693 }
16694 }
16695 struct GeneratedVisitor;
16696 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16697 type Value = StreamMessage;
16698
16699 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16700 formatter.write_str("struct stream_plan.StreamMessage")
16701 }
16702
16703 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessage, V::Error>
16704 where
16705 V: serde::de::MapAccess<'de>,
16706 {
16707 let mut stream_message__ = None;
16708 while let Some(k) = map_.next_key()? {
16709 match k {
16710 GeneratedField::StreamChunk => {
16711 if stream_message__.is_some() {
16712 return Err(serde::de::Error::duplicate_field("streamChunk"));
16713 }
16714 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::StreamChunk)
16715;
16716 }
16717 GeneratedField::Barrier => {
16718 if stream_message__.is_some() {
16719 return Err(serde::de::Error::duplicate_field("barrier"));
16720 }
16721 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Barrier)
16722;
16723 }
16724 GeneratedField::Watermark => {
16725 if stream_message__.is_some() {
16726 return Err(serde::de::Error::duplicate_field("watermark"));
16727 }
16728 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Watermark)
16729;
16730 }
16731 }
16732 }
16733 Ok(StreamMessage {
16734 stream_message: stream_message__,
16735 })
16736 }
16737 }
16738 deserializer.deserialize_struct("stream_plan.StreamMessage", FIELDS, GeneratedVisitor)
16739 }
16740}
16741impl serde::Serialize for StreamMessageBatch {
16742 #[allow(deprecated)]
16743 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16744 where
16745 S: serde::Serializer,
16746 {
16747 use serde::ser::SerializeStruct;
16748 let mut len = 0;
16749 if self.stream_message_batch.is_some() {
16750 len += 1;
16751 }
16752 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch", len)?;
16753 if let Some(v) = self.stream_message_batch.as_ref() {
16754 match v {
16755 stream_message_batch::StreamMessageBatch::StreamChunk(v) => {
16756 struct_ser.serialize_field("streamChunk", v)?;
16757 }
16758 stream_message_batch::StreamMessageBatch::BarrierBatch(v) => {
16759 struct_ser.serialize_field("barrierBatch", v)?;
16760 }
16761 stream_message_batch::StreamMessageBatch::Watermark(v) => {
16762 struct_ser.serialize_field("watermark", v)?;
16763 }
16764 }
16765 }
16766 struct_ser.end()
16767 }
16768}
16769impl<'de> serde::Deserialize<'de> for StreamMessageBatch {
16770 #[allow(deprecated)]
16771 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16772 where
16773 D: serde::Deserializer<'de>,
16774 {
16775 const FIELDS: &[&str] = &[
16776 "stream_chunk",
16777 "streamChunk",
16778 "barrier_batch",
16779 "barrierBatch",
16780 "watermark",
16781 ];
16782
16783 #[allow(clippy::enum_variant_names)]
16784 enum GeneratedField {
16785 StreamChunk,
16786 BarrierBatch,
16787 Watermark,
16788 }
16789 impl<'de> serde::Deserialize<'de> for GeneratedField {
16790 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16791 where
16792 D: serde::Deserializer<'de>,
16793 {
16794 struct GeneratedVisitor;
16795
16796 impl serde::de::Visitor<'_> for GeneratedVisitor {
16797 type Value = GeneratedField;
16798
16799 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16800 write!(formatter, "expected one of: {:?}", &FIELDS)
16801 }
16802
16803 #[allow(unused_variables)]
16804 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16805 where
16806 E: serde::de::Error,
16807 {
16808 match value {
16809 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
16810 "barrierBatch" | "barrier_batch" => Ok(GeneratedField::BarrierBatch),
16811 "watermark" => Ok(GeneratedField::Watermark),
16812 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16813 }
16814 }
16815 }
16816 deserializer.deserialize_identifier(GeneratedVisitor)
16817 }
16818 }
16819 struct GeneratedVisitor;
16820 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16821 type Value = StreamMessageBatch;
16822
16823 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16824 formatter.write_str("struct stream_plan.StreamMessageBatch")
16825 }
16826
16827 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessageBatch, V::Error>
16828 where
16829 V: serde::de::MapAccess<'de>,
16830 {
16831 let mut stream_message_batch__ = None;
16832 while let Some(k) = map_.next_key()? {
16833 match k {
16834 GeneratedField::StreamChunk => {
16835 if stream_message_batch__.is_some() {
16836 return Err(serde::de::Error::duplicate_field("streamChunk"));
16837 }
16838 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::StreamChunk)
16839;
16840 }
16841 GeneratedField::BarrierBatch => {
16842 if stream_message_batch__.is_some() {
16843 return Err(serde::de::Error::duplicate_field("barrierBatch"));
16844 }
16845 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::BarrierBatch)
16846;
16847 }
16848 GeneratedField::Watermark => {
16849 if stream_message_batch__.is_some() {
16850 return Err(serde::de::Error::duplicate_field("watermark"));
16851 }
16852 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::Watermark)
16853;
16854 }
16855 }
16856 }
16857 Ok(StreamMessageBatch {
16858 stream_message_batch: stream_message_batch__,
16859 })
16860 }
16861 }
16862 deserializer.deserialize_struct("stream_plan.StreamMessageBatch", FIELDS, GeneratedVisitor)
16863 }
16864}
16865impl serde::Serialize for stream_message_batch::BarrierBatch {
16866 #[allow(deprecated)]
16867 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16868 where
16869 S: serde::Serializer,
16870 {
16871 use serde::ser::SerializeStruct;
16872 let mut len = 0;
16873 if !self.barriers.is_empty() {
16874 len += 1;
16875 }
16876 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", len)?;
16877 if !self.barriers.is_empty() {
16878 struct_ser.serialize_field("barriers", &self.barriers)?;
16879 }
16880 struct_ser.end()
16881 }
16882}
16883impl<'de> serde::Deserialize<'de> for stream_message_batch::BarrierBatch {
16884 #[allow(deprecated)]
16885 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16886 where
16887 D: serde::Deserializer<'de>,
16888 {
16889 const FIELDS: &[&str] = &[
16890 "barriers",
16891 ];
16892
16893 #[allow(clippy::enum_variant_names)]
16894 enum GeneratedField {
16895 Barriers,
16896 }
16897 impl<'de> serde::Deserialize<'de> for GeneratedField {
16898 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16899 where
16900 D: serde::Deserializer<'de>,
16901 {
16902 struct GeneratedVisitor;
16903
16904 impl serde::de::Visitor<'_> for GeneratedVisitor {
16905 type Value = GeneratedField;
16906
16907 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16908 write!(formatter, "expected one of: {:?}", &FIELDS)
16909 }
16910
16911 #[allow(unused_variables)]
16912 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16913 where
16914 E: serde::de::Error,
16915 {
16916 match value {
16917 "barriers" => Ok(GeneratedField::Barriers),
16918 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16919 }
16920 }
16921 }
16922 deserializer.deserialize_identifier(GeneratedVisitor)
16923 }
16924 }
16925 struct GeneratedVisitor;
16926 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16927 type Value = stream_message_batch::BarrierBatch;
16928
16929 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16930 formatter.write_str("struct stream_plan.StreamMessageBatch.BarrierBatch")
16931 }
16932
16933 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_message_batch::BarrierBatch, V::Error>
16934 where
16935 V: serde::de::MapAccess<'de>,
16936 {
16937 let mut barriers__ = None;
16938 while let Some(k) = map_.next_key()? {
16939 match k {
16940 GeneratedField::Barriers => {
16941 if barriers__.is_some() {
16942 return Err(serde::de::Error::duplicate_field("barriers"));
16943 }
16944 barriers__ = Some(map_.next_value()?);
16945 }
16946 }
16947 }
16948 Ok(stream_message_batch::BarrierBatch {
16949 barriers: barriers__.unwrap_or_default(),
16950 })
16951 }
16952 }
16953 deserializer.deserialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", FIELDS, GeneratedVisitor)
16954 }
16955}
16956impl serde::Serialize for StreamNode {
16957 #[allow(deprecated)]
16958 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16959 where
16960 S: serde::Serializer,
16961 {
16962 use serde::ser::SerializeStruct;
16963 let mut len = 0;
16964 if self.operator_id != 0 {
16965 len += 1;
16966 }
16967 if !self.input.is_empty() {
16968 len += 1;
16969 }
16970 if !self.stream_key.is_empty() {
16971 len += 1;
16972 }
16973 if self.stream_kind != 0 {
16974 len += 1;
16975 }
16976 if !self.identity.is_empty() {
16977 len += 1;
16978 }
16979 if !self.fields.is_empty() {
16980 len += 1;
16981 }
16982 if self.node_body.is_some() {
16983 len += 1;
16984 }
16985 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamNode", len)?;
16986 if self.operator_id != 0 {
16987 #[allow(clippy::needless_borrow)]
16988 #[allow(clippy::needless_borrows_for_generic_args)]
16989 struct_ser.serialize_field("operatorId", ToString::to_string(&self.operator_id).as_str())?;
16990 }
16991 if !self.input.is_empty() {
16992 struct_ser.serialize_field("input", &self.input)?;
16993 }
16994 if !self.stream_key.is_empty() {
16995 struct_ser.serialize_field("streamKey", &self.stream_key)?;
16996 }
16997 if self.stream_kind != 0 {
16998 let v = stream_node::StreamKind::try_from(self.stream_kind)
16999 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_kind)))?;
17000 struct_ser.serialize_field("streamKind", &v)?;
17001 }
17002 if !self.identity.is_empty() {
17003 struct_ser.serialize_field("identity", &self.identity)?;
17004 }
17005 if !self.fields.is_empty() {
17006 struct_ser.serialize_field("fields", &self.fields)?;
17007 }
17008 if let Some(v) = self.node_body.as_ref() {
17009 match v {
17010 stream_node::NodeBody::Source(v) => {
17011 struct_ser.serialize_field("source", v)?;
17012 }
17013 stream_node::NodeBody::Project(v) => {
17014 struct_ser.serialize_field("project", v)?;
17015 }
17016 stream_node::NodeBody::Filter(v) => {
17017 struct_ser.serialize_field("filter", v)?;
17018 }
17019 stream_node::NodeBody::Materialize(v) => {
17020 struct_ser.serialize_field("materialize", v)?;
17021 }
17022 stream_node::NodeBody::StatelessSimpleAgg(v) => {
17023 struct_ser.serialize_field("statelessSimpleAgg", v)?;
17024 }
17025 stream_node::NodeBody::SimpleAgg(v) => {
17026 struct_ser.serialize_field("simpleAgg", v)?;
17027 }
17028 stream_node::NodeBody::HashAgg(v) => {
17029 struct_ser.serialize_field("hashAgg", v)?;
17030 }
17031 stream_node::NodeBody::AppendOnlyTopN(v) => {
17032 struct_ser.serialize_field("appendOnlyTopN", v)?;
17033 }
17034 stream_node::NodeBody::HashJoin(v) => {
17035 struct_ser.serialize_field("hashJoin", v)?;
17036 }
17037 stream_node::NodeBody::TopN(v) => {
17038 struct_ser.serialize_field("topN", v)?;
17039 }
17040 stream_node::NodeBody::HopWindow(v) => {
17041 struct_ser.serialize_field("hopWindow", v)?;
17042 }
17043 stream_node::NodeBody::Merge(v) => {
17044 struct_ser.serialize_field("merge", v)?;
17045 }
17046 stream_node::NodeBody::Exchange(v) => {
17047 struct_ser.serialize_field("exchange", v)?;
17048 }
17049 stream_node::NodeBody::StreamScan(v) => {
17050 struct_ser.serialize_field("streamScan", v)?;
17051 }
17052 stream_node::NodeBody::BatchPlan(v) => {
17053 struct_ser.serialize_field("batchPlan", v)?;
17054 }
17055 stream_node::NodeBody::Lookup(v) => {
17056 struct_ser.serialize_field("lookup", v)?;
17057 }
17058 stream_node::NodeBody::Arrange(v) => {
17059 struct_ser.serialize_field("arrange", v)?;
17060 }
17061 stream_node::NodeBody::LookupUnion(v) => {
17062 struct_ser.serialize_field("lookupUnion", v)?;
17063 }
17064 stream_node::NodeBody::Union(v) => {
17065 struct_ser.serialize_field("union", v)?;
17066 }
17067 stream_node::NodeBody::DeltaIndexJoin(v) => {
17068 struct_ser.serialize_field("deltaIndexJoin", v)?;
17069 }
17070 stream_node::NodeBody::Sink(v) => {
17071 struct_ser.serialize_field("sink", v)?;
17072 }
17073 stream_node::NodeBody::Expand(v) => {
17074 struct_ser.serialize_field("expand", v)?;
17075 }
17076 stream_node::NodeBody::DynamicFilter(v) => {
17077 struct_ser.serialize_field("dynamicFilter", v)?;
17078 }
17079 stream_node::NodeBody::ProjectSet(v) => {
17080 struct_ser.serialize_field("projectSet", v)?;
17081 }
17082 stream_node::NodeBody::GroupTopN(v) => {
17083 struct_ser.serialize_field("groupTopN", v)?;
17084 }
17085 stream_node::NodeBody::Sort(v) => {
17086 struct_ser.serialize_field("sort", v)?;
17087 }
17088 stream_node::NodeBody::WatermarkFilter(v) => {
17089 struct_ser.serialize_field("watermarkFilter", v)?;
17090 }
17091 stream_node::NodeBody::Dml(v) => {
17092 struct_ser.serialize_field("dml", v)?;
17093 }
17094 stream_node::NodeBody::RowIdGen(v) => {
17095 struct_ser.serialize_field("rowIdGen", v)?;
17096 }
17097 stream_node::NodeBody::Now(v) => {
17098 struct_ser.serialize_field("now", v)?;
17099 }
17100 stream_node::NodeBody::AppendOnlyGroupTopN(v) => {
17101 struct_ser.serialize_field("appendOnlyGroupTopN", v)?;
17102 }
17103 stream_node::NodeBody::TemporalJoin(v) => {
17104 struct_ser.serialize_field("temporalJoin", v)?;
17105 }
17106 stream_node::NodeBody::BarrierRecv(v) => {
17107 struct_ser.serialize_field("barrierRecv", v)?;
17108 }
17109 stream_node::NodeBody::Values(v) => {
17110 struct_ser.serialize_field("values", v)?;
17111 }
17112 stream_node::NodeBody::AppendOnlyDedup(v) => {
17113 struct_ser.serialize_field("appendOnlyDedup", v)?;
17114 }
17115 stream_node::NodeBody::NoOp(v) => {
17116 struct_ser.serialize_field("noOp", v)?;
17117 }
17118 stream_node::NodeBody::EowcOverWindow(v) => {
17119 struct_ser.serialize_field("eowcOverWindow", v)?;
17120 }
17121 stream_node::NodeBody::OverWindow(v) => {
17122 struct_ser.serialize_field("overWindow", v)?;
17123 }
17124 stream_node::NodeBody::StreamFsFetch(v) => {
17125 struct_ser.serialize_field("streamFsFetch", v)?;
17126 }
17127 stream_node::NodeBody::StreamCdcScan(v) => {
17128 struct_ser.serialize_field("streamCdcScan", v)?;
17129 }
17130 stream_node::NodeBody::CdcFilter(v) => {
17131 struct_ser.serialize_field("cdcFilter", v)?;
17132 }
17133 stream_node::NodeBody::SourceBackfill(v) => {
17134 struct_ser.serialize_field("sourceBackfill", v)?;
17135 }
17136 stream_node::NodeBody::Changelog(v) => {
17137 struct_ser.serialize_field("changelog", v)?;
17138 }
17139 stream_node::NodeBody::LocalApproxPercentile(v) => {
17140 struct_ser.serialize_field("localApproxPercentile", v)?;
17141 }
17142 stream_node::NodeBody::GlobalApproxPercentile(v) => {
17143 struct_ser.serialize_field("globalApproxPercentile", v)?;
17144 }
17145 stream_node::NodeBody::RowMerge(v) => {
17146 struct_ser.serialize_field("rowMerge", v)?;
17147 }
17148 stream_node::NodeBody::AsOfJoin(v) => {
17149 struct_ser.serialize_field("asOfJoin", v)?;
17150 }
17151 stream_node::NodeBody::SyncLogStore(v) => {
17152 struct_ser.serialize_field("syncLogStore", v)?;
17153 }
17154 stream_node::NodeBody::MaterializedExprs(v) => {
17155 struct_ser.serialize_field("materializedExprs", v)?;
17156 }
17157 stream_node::NodeBody::VectorIndexWrite(v) => {
17158 struct_ser.serialize_field("vectorIndexWrite", v)?;
17159 }
17160 stream_node::NodeBody::UpstreamSinkUnion(v) => {
17161 struct_ser.serialize_field("upstreamSinkUnion", v)?;
17162 }
17163 stream_node::NodeBody::LocalityProvider(v) => {
17164 struct_ser.serialize_field("localityProvider", v)?;
17165 }
17166 stream_node::NodeBody::EowcGapFill(v) => {
17167 struct_ser.serialize_field("eowcGapFill", v)?;
17168 }
17169 stream_node::NodeBody::GapFill(v) => {
17170 struct_ser.serialize_field("gapFill", v)?;
17171 }
17172 stream_node::NodeBody::VectorIndexLookupJoin(v) => {
17173 struct_ser.serialize_field("vectorIndexLookupJoin", v)?;
17174 }
17175 stream_node::NodeBody::IcebergWithPkIndexWriter(v) => {
17176 struct_ser.serialize_field("icebergWithPkIndexWriter", v)?;
17177 }
17178 stream_node::NodeBody::IcebergWithPkIndexPositionDeleteMerger(v) => {
17179 struct_ser.serialize_field("icebergWithPkIndexPositionDeleteMerger", v)?;
17180 }
17181 stream_node::NodeBody::MatchRecognize(v) => {
17182 struct_ser.serialize_field("matchRecognize", v)?;
17183 }
17184 stream_node::NodeBody::CompactionResolver(v) => {
17185 struct_ser.serialize_field("compactionResolver", v)?;
17186 }
17187 }
17188 }
17189 struct_ser.end()
17190 }
17191}
17192impl<'de> serde::Deserialize<'de> for StreamNode {
17193 #[allow(deprecated)]
17194 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17195 where
17196 D: serde::Deserializer<'de>,
17197 {
17198 const FIELDS: &[&str] = &[
17199 "operator_id",
17200 "operatorId",
17201 "input",
17202 "stream_key",
17203 "streamKey",
17204 "stream_kind",
17205 "streamKind",
17206 "identity",
17207 "fields",
17208 "source",
17209 "project",
17210 "filter",
17211 "materialize",
17212 "stateless_simple_agg",
17213 "statelessSimpleAgg",
17214 "simple_agg",
17215 "simpleAgg",
17216 "hash_agg",
17217 "hashAgg",
17218 "append_only_top_n",
17219 "appendOnlyTopN",
17220 "hash_join",
17221 "hashJoin",
17222 "top_n",
17223 "topN",
17224 "hop_window",
17225 "hopWindow",
17226 "merge",
17227 "exchange",
17228 "stream_scan",
17229 "streamScan",
17230 "batch_plan",
17231 "batchPlan",
17232 "lookup",
17233 "arrange",
17234 "lookup_union",
17235 "lookupUnion",
17236 "union",
17237 "delta_index_join",
17238 "deltaIndexJoin",
17239 "sink",
17240 "expand",
17241 "dynamic_filter",
17242 "dynamicFilter",
17243 "project_set",
17244 "projectSet",
17245 "group_top_n",
17246 "groupTopN",
17247 "sort",
17248 "watermark_filter",
17249 "watermarkFilter",
17250 "dml",
17251 "row_id_gen",
17252 "rowIdGen",
17253 "now",
17254 "append_only_group_top_n",
17255 "appendOnlyGroupTopN",
17256 "temporal_join",
17257 "temporalJoin",
17258 "barrier_recv",
17259 "barrierRecv",
17260 "values",
17261 "append_only_dedup",
17262 "appendOnlyDedup",
17263 "no_op",
17264 "noOp",
17265 "eowc_over_window",
17266 "eowcOverWindow",
17267 "over_window",
17268 "overWindow",
17269 "stream_fs_fetch",
17270 "streamFsFetch",
17271 "stream_cdc_scan",
17272 "streamCdcScan",
17273 "cdc_filter",
17274 "cdcFilter",
17275 "source_backfill",
17276 "sourceBackfill",
17277 "changelog",
17278 "local_approx_percentile",
17279 "localApproxPercentile",
17280 "global_approx_percentile",
17281 "globalApproxPercentile",
17282 "row_merge",
17283 "rowMerge",
17284 "as_of_join",
17285 "asOfJoin",
17286 "sync_log_store",
17287 "syncLogStore",
17288 "materialized_exprs",
17289 "materializedExprs",
17290 "vector_index_write",
17291 "vectorIndexWrite",
17292 "upstream_sink_union",
17293 "upstreamSinkUnion",
17294 "locality_provider",
17295 "localityProvider",
17296 "eowc_gap_fill",
17297 "eowcGapFill",
17298 "gap_fill",
17299 "gapFill",
17300 "vector_index_lookup_join",
17301 "vectorIndexLookupJoin",
17302 "iceberg_with_pk_index_writer",
17303 "icebergWithPkIndexWriter",
17304 "iceberg_with_pk_index_position_delete_merger",
17305 "icebergWithPkIndexPositionDeleteMerger",
17306 "match_recognize",
17307 "matchRecognize",
17308 "compaction_resolver",
17309 "compactionResolver",
17310 ];
17311
17312 #[allow(clippy::enum_variant_names)]
17313 enum GeneratedField {
17314 OperatorId,
17315 Input,
17316 StreamKey,
17317 StreamKind,
17318 Identity,
17319 Fields,
17320 Source,
17321 Project,
17322 Filter,
17323 Materialize,
17324 StatelessSimpleAgg,
17325 SimpleAgg,
17326 HashAgg,
17327 AppendOnlyTopN,
17328 HashJoin,
17329 TopN,
17330 HopWindow,
17331 Merge,
17332 Exchange,
17333 StreamScan,
17334 BatchPlan,
17335 Lookup,
17336 Arrange,
17337 LookupUnion,
17338 Union,
17339 DeltaIndexJoin,
17340 Sink,
17341 Expand,
17342 DynamicFilter,
17343 ProjectSet,
17344 GroupTopN,
17345 Sort,
17346 WatermarkFilter,
17347 Dml,
17348 RowIdGen,
17349 Now,
17350 AppendOnlyGroupTopN,
17351 TemporalJoin,
17352 BarrierRecv,
17353 Values,
17354 AppendOnlyDedup,
17355 NoOp,
17356 EowcOverWindow,
17357 OverWindow,
17358 StreamFsFetch,
17359 StreamCdcScan,
17360 CdcFilter,
17361 SourceBackfill,
17362 Changelog,
17363 LocalApproxPercentile,
17364 GlobalApproxPercentile,
17365 RowMerge,
17366 AsOfJoin,
17367 SyncLogStore,
17368 MaterializedExprs,
17369 VectorIndexWrite,
17370 UpstreamSinkUnion,
17371 LocalityProvider,
17372 EowcGapFill,
17373 GapFill,
17374 VectorIndexLookupJoin,
17375 IcebergWithPkIndexWriter,
17376 IcebergWithPkIndexPositionDeleteMerger,
17377 MatchRecognize,
17378 CompactionResolver,
17379 }
17380 impl<'de> serde::Deserialize<'de> for GeneratedField {
17381 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17382 where
17383 D: serde::Deserializer<'de>,
17384 {
17385 struct GeneratedVisitor;
17386
17387 impl serde::de::Visitor<'_> for GeneratedVisitor {
17388 type Value = GeneratedField;
17389
17390 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17391 write!(formatter, "expected one of: {:?}", &FIELDS)
17392 }
17393
17394 #[allow(unused_variables)]
17395 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17396 where
17397 E: serde::de::Error,
17398 {
17399 match value {
17400 "operatorId" | "operator_id" => Ok(GeneratedField::OperatorId),
17401 "input" => Ok(GeneratedField::Input),
17402 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
17403 "streamKind" | "stream_kind" => Ok(GeneratedField::StreamKind),
17404 "identity" => Ok(GeneratedField::Identity),
17405 "fields" => Ok(GeneratedField::Fields),
17406 "source" => Ok(GeneratedField::Source),
17407 "project" => Ok(GeneratedField::Project),
17408 "filter" => Ok(GeneratedField::Filter),
17409 "materialize" => Ok(GeneratedField::Materialize),
17410 "statelessSimpleAgg" | "stateless_simple_agg" => Ok(GeneratedField::StatelessSimpleAgg),
17411 "simpleAgg" | "simple_agg" => Ok(GeneratedField::SimpleAgg),
17412 "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
17413 "appendOnlyTopN" | "append_only_top_n" => Ok(GeneratedField::AppendOnlyTopN),
17414 "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
17415 "topN" | "top_n" => Ok(GeneratedField::TopN),
17416 "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
17417 "merge" => Ok(GeneratedField::Merge),
17418 "exchange" => Ok(GeneratedField::Exchange),
17419 "streamScan" | "stream_scan" => Ok(GeneratedField::StreamScan),
17420 "batchPlan" | "batch_plan" => Ok(GeneratedField::BatchPlan),
17421 "lookup" => Ok(GeneratedField::Lookup),
17422 "arrange" => Ok(GeneratedField::Arrange),
17423 "lookupUnion" | "lookup_union" => Ok(GeneratedField::LookupUnion),
17424 "union" => Ok(GeneratedField::Union),
17425 "deltaIndexJoin" | "delta_index_join" => Ok(GeneratedField::DeltaIndexJoin),
17426 "sink" => Ok(GeneratedField::Sink),
17427 "expand" => Ok(GeneratedField::Expand),
17428 "dynamicFilter" | "dynamic_filter" => Ok(GeneratedField::DynamicFilter),
17429 "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
17430 "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
17431 "sort" => Ok(GeneratedField::Sort),
17432 "watermarkFilter" | "watermark_filter" => Ok(GeneratedField::WatermarkFilter),
17433 "dml" => Ok(GeneratedField::Dml),
17434 "rowIdGen" | "row_id_gen" => Ok(GeneratedField::RowIdGen),
17435 "now" => Ok(GeneratedField::Now),
17436 "appendOnlyGroupTopN" | "append_only_group_top_n" => Ok(GeneratedField::AppendOnlyGroupTopN),
17437 "temporalJoin" | "temporal_join" => Ok(GeneratedField::TemporalJoin),
17438 "barrierRecv" | "barrier_recv" => Ok(GeneratedField::BarrierRecv),
17439 "values" => Ok(GeneratedField::Values),
17440 "appendOnlyDedup" | "append_only_dedup" => Ok(GeneratedField::AppendOnlyDedup),
17441 "noOp" | "no_op" => Ok(GeneratedField::NoOp),
17442 "eowcOverWindow" | "eowc_over_window" => Ok(GeneratedField::EowcOverWindow),
17443 "overWindow" | "over_window" => Ok(GeneratedField::OverWindow),
17444 "streamFsFetch" | "stream_fs_fetch" => Ok(GeneratedField::StreamFsFetch),
17445 "streamCdcScan" | "stream_cdc_scan" => Ok(GeneratedField::StreamCdcScan),
17446 "cdcFilter" | "cdc_filter" => Ok(GeneratedField::CdcFilter),
17447 "sourceBackfill" | "source_backfill" => Ok(GeneratedField::SourceBackfill),
17448 "changelog" => Ok(GeneratedField::Changelog),
17449 "localApproxPercentile" | "local_approx_percentile" => Ok(GeneratedField::LocalApproxPercentile),
17450 "globalApproxPercentile" | "global_approx_percentile" => Ok(GeneratedField::GlobalApproxPercentile),
17451 "rowMerge" | "row_merge" => Ok(GeneratedField::RowMerge),
17452 "asOfJoin" | "as_of_join" => Ok(GeneratedField::AsOfJoin),
17453 "syncLogStore" | "sync_log_store" => Ok(GeneratedField::SyncLogStore),
17454 "materializedExprs" | "materialized_exprs" => Ok(GeneratedField::MaterializedExprs),
17455 "vectorIndexWrite" | "vector_index_write" => Ok(GeneratedField::VectorIndexWrite),
17456 "upstreamSinkUnion" | "upstream_sink_union" => Ok(GeneratedField::UpstreamSinkUnion),
17457 "localityProvider" | "locality_provider" => Ok(GeneratedField::LocalityProvider),
17458 "eowcGapFill" | "eowc_gap_fill" => Ok(GeneratedField::EowcGapFill),
17459 "gapFill" | "gap_fill" => Ok(GeneratedField::GapFill),
17460 "vectorIndexLookupJoin" | "vector_index_lookup_join" => Ok(GeneratedField::VectorIndexLookupJoin),
17461 "icebergWithPkIndexWriter" | "iceberg_with_pk_index_writer" => Ok(GeneratedField::IcebergWithPkIndexWriter),
17462 "icebergWithPkIndexPositionDeleteMerger" | "iceberg_with_pk_index_position_delete_merger" => Ok(GeneratedField::IcebergWithPkIndexPositionDeleteMerger),
17463 "matchRecognize" | "match_recognize" => Ok(GeneratedField::MatchRecognize),
17464 "compactionResolver" | "compaction_resolver" => Ok(GeneratedField::CompactionResolver),
17465 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17466 }
17467 }
17468 }
17469 deserializer.deserialize_identifier(GeneratedVisitor)
17470 }
17471 }
17472 struct GeneratedVisitor;
17473 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17474 type Value = StreamNode;
17475
17476 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17477 formatter.write_str("struct stream_plan.StreamNode")
17478 }
17479
17480 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamNode, V::Error>
17481 where
17482 V: serde::de::MapAccess<'de>,
17483 {
17484 let mut operator_id__ = None;
17485 let mut input__ = None;
17486 let mut stream_key__ = None;
17487 let mut stream_kind__ = None;
17488 let mut identity__ = None;
17489 let mut fields__ = None;
17490 let mut node_body__ = None;
17491 while let Some(k) = map_.next_key()? {
17492 match k {
17493 GeneratedField::OperatorId => {
17494 if operator_id__.is_some() {
17495 return Err(serde::de::Error::duplicate_field("operatorId"));
17496 }
17497 operator_id__ =
17498 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17499 ;
17500 }
17501 GeneratedField::Input => {
17502 if input__.is_some() {
17503 return Err(serde::de::Error::duplicate_field("input"));
17504 }
17505 input__ = Some(map_.next_value()?);
17506 }
17507 GeneratedField::StreamKey => {
17508 if stream_key__.is_some() {
17509 return Err(serde::de::Error::duplicate_field("streamKey"));
17510 }
17511 stream_key__ =
17512 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17513 .into_iter().map(|x| x.0).collect())
17514 ;
17515 }
17516 GeneratedField::StreamKind => {
17517 if stream_kind__.is_some() {
17518 return Err(serde::de::Error::duplicate_field("streamKind"));
17519 }
17520 stream_kind__ = Some(map_.next_value::<stream_node::StreamKind>()? as i32);
17521 }
17522 GeneratedField::Identity => {
17523 if identity__.is_some() {
17524 return Err(serde::de::Error::duplicate_field("identity"));
17525 }
17526 identity__ = Some(map_.next_value()?);
17527 }
17528 GeneratedField::Fields => {
17529 if fields__.is_some() {
17530 return Err(serde::de::Error::duplicate_field("fields"));
17531 }
17532 fields__ = Some(map_.next_value()?);
17533 }
17534 GeneratedField::Source => {
17535 if node_body__.is_some() {
17536 return Err(serde::de::Error::duplicate_field("source"));
17537 }
17538 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Source)
17539;
17540 }
17541 GeneratedField::Project => {
17542 if node_body__.is_some() {
17543 return Err(serde::de::Error::duplicate_field("project"));
17544 }
17545 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Project)
17546;
17547 }
17548 GeneratedField::Filter => {
17549 if node_body__.is_some() {
17550 return Err(serde::de::Error::duplicate_field("filter"));
17551 }
17552 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Filter)
17553;
17554 }
17555 GeneratedField::Materialize => {
17556 if node_body__.is_some() {
17557 return Err(serde::de::Error::duplicate_field("materialize"));
17558 }
17559 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Materialize)
17560;
17561 }
17562 GeneratedField::StatelessSimpleAgg => {
17563 if node_body__.is_some() {
17564 return Err(serde::de::Error::duplicate_field("statelessSimpleAgg"));
17565 }
17566 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StatelessSimpleAgg)
17567;
17568 }
17569 GeneratedField::SimpleAgg => {
17570 if node_body__.is_some() {
17571 return Err(serde::de::Error::duplicate_field("simpleAgg"));
17572 }
17573 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SimpleAgg)
17574;
17575 }
17576 GeneratedField::HashAgg => {
17577 if node_body__.is_some() {
17578 return Err(serde::de::Error::duplicate_field("hashAgg"));
17579 }
17580 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashAgg)
17581;
17582 }
17583 GeneratedField::AppendOnlyTopN => {
17584 if node_body__.is_some() {
17585 return Err(serde::de::Error::duplicate_field("appendOnlyTopN"));
17586 }
17587 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyTopN)
17588;
17589 }
17590 GeneratedField::HashJoin => {
17591 if node_body__.is_some() {
17592 return Err(serde::de::Error::duplicate_field("hashJoin"));
17593 }
17594 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashJoin)
17595;
17596 }
17597 GeneratedField::TopN => {
17598 if node_body__.is_some() {
17599 return Err(serde::de::Error::duplicate_field("topN"));
17600 }
17601 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TopN)
17602;
17603 }
17604 GeneratedField::HopWindow => {
17605 if node_body__.is_some() {
17606 return Err(serde::de::Error::duplicate_field("hopWindow"));
17607 }
17608 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HopWindow)
17609;
17610 }
17611 GeneratedField::Merge => {
17612 if node_body__.is_some() {
17613 return Err(serde::de::Error::duplicate_field("merge"));
17614 }
17615 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Merge)
17616;
17617 }
17618 GeneratedField::Exchange => {
17619 if node_body__.is_some() {
17620 return Err(serde::de::Error::duplicate_field("exchange"));
17621 }
17622 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Exchange)
17623;
17624 }
17625 GeneratedField::StreamScan => {
17626 if node_body__.is_some() {
17627 return Err(serde::de::Error::duplicate_field("streamScan"));
17628 }
17629 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamScan)
17630;
17631 }
17632 GeneratedField::BatchPlan => {
17633 if node_body__.is_some() {
17634 return Err(serde::de::Error::duplicate_field("batchPlan"));
17635 }
17636 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BatchPlan)
17637;
17638 }
17639 GeneratedField::Lookup => {
17640 if node_body__.is_some() {
17641 return Err(serde::de::Error::duplicate_field("lookup"));
17642 }
17643 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Lookup)
17644;
17645 }
17646 GeneratedField::Arrange => {
17647 if node_body__.is_some() {
17648 return Err(serde::de::Error::duplicate_field("arrange"));
17649 }
17650 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Arrange)
17651;
17652 }
17653 GeneratedField::LookupUnion => {
17654 if node_body__.is_some() {
17655 return Err(serde::de::Error::duplicate_field("lookupUnion"));
17656 }
17657 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LookupUnion)
17658;
17659 }
17660 GeneratedField::Union => {
17661 if node_body__.is_some() {
17662 return Err(serde::de::Error::duplicate_field("union"));
17663 }
17664 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Union)
17665;
17666 }
17667 GeneratedField::DeltaIndexJoin => {
17668 if node_body__.is_some() {
17669 return Err(serde::de::Error::duplicate_field("deltaIndexJoin"));
17670 }
17671 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DeltaIndexJoin)
17672;
17673 }
17674 GeneratedField::Sink => {
17675 if node_body__.is_some() {
17676 return Err(serde::de::Error::duplicate_field("sink"));
17677 }
17678 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sink)
17679;
17680 }
17681 GeneratedField::Expand => {
17682 if node_body__.is_some() {
17683 return Err(serde::de::Error::duplicate_field("expand"));
17684 }
17685 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Expand)
17686;
17687 }
17688 GeneratedField::DynamicFilter => {
17689 if node_body__.is_some() {
17690 return Err(serde::de::Error::duplicate_field("dynamicFilter"));
17691 }
17692 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DynamicFilter)
17693;
17694 }
17695 GeneratedField::ProjectSet => {
17696 if node_body__.is_some() {
17697 return Err(serde::de::Error::duplicate_field("projectSet"));
17698 }
17699 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::ProjectSet)
17700;
17701 }
17702 GeneratedField::GroupTopN => {
17703 if node_body__.is_some() {
17704 return Err(serde::de::Error::duplicate_field("groupTopN"));
17705 }
17706 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GroupTopN)
17707;
17708 }
17709 GeneratedField::Sort => {
17710 if node_body__.is_some() {
17711 return Err(serde::de::Error::duplicate_field("sort"));
17712 }
17713 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sort)
17714;
17715 }
17716 GeneratedField::WatermarkFilter => {
17717 if node_body__.is_some() {
17718 return Err(serde::de::Error::duplicate_field("watermarkFilter"));
17719 }
17720 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::WatermarkFilter)
17721;
17722 }
17723 GeneratedField::Dml => {
17724 if node_body__.is_some() {
17725 return Err(serde::de::Error::duplicate_field("dml"));
17726 }
17727 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Dml)
17728;
17729 }
17730 GeneratedField::RowIdGen => {
17731 if node_body__.is_some() {
17732 return Err(serde::de::Error::duplicate_field("rowIdGen"));
17733 }
17734 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowIdGen)
17735;
17736 }
17737 GeneratedField::Now => {
17738 if node_body__.is_some() {
17739 return Err(serde::de::Error::duplicate_field("now"));
17740 }
17741 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Now)
17742;
17743 }
17744 GeneratedField::AppendOnlyGroupTopN => {
17745 if node_body__.is_some() {
17746 return Err(serde::de::Error::duplicate_field("appendOnlyGroupTopN"));
17747 }
17748 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyGroupTopN)
17749;
17750 }
17751 GeneratedField::TemporalJoin => {
17752 if node_body__.is_some() {
17753 return Err(serde::de::Error::duplicate_field("temporalJoin"));
17754 }
17755 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TemporalJoin)
17756;
17757 }
17758 GeneratedField::BarrierRecv => {
17759 if node_body__.is_some() {
17760 return Err(serde::de::Error::duplicate_field("barrierRecv"));
17761 }
17762 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BarrierRecv)
17763;
17764 }
17765 GeneratedField::Values => {
17766 if node_body__.is_some() {
17767 return Err(serde::de::Error::duplicate_field("values"));
17768 }
17769 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Values)
17770;
17771 }
17772 GeneratedField::AppendOnlyDedup => {
17773 if node_body__.is_some() {
17774 return Err(serde::de::Error::duplicate_field("appendOnlyDedup"));
17775 }
17776 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyDedup)
17777;
17778 }
17779 GeneratedField::NoOp => {
17780 if node_body__.is_some() {
17781 return Err(serde::de::Error::duplicate_field("noOp"));
17782 }
17783 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::NoOp)
17784;
17785 }
17786 GeneratedField::EowcOverWindow => {
17787 if node_body__.is_some() {
17788 return Err(serde::de::Error::duplicate_field("eowcOverWindow"));
17789 }
17790 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcOverWindow)
17791;
17792 }
17793 GeneratedField::OverWindow => {
17794 if node_body__.is_some() {
17795 return Err(serde::de::Error::duplicate_field("overWindow"));
17796 }
17797 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::OverWindow)
17798;
17799 }
17800 GeneratedField::StreamFsFetch => {
17801 if node_body__.is_some() {
17802 return Err(serde::de::Error::duplicate_field("streamFsFetch"));
17803 }
17804 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamFsFetch)
17805;
17806 }
17807 GeneratedField::StreamCdcScan => {
17808 if node_body__.is_some() {
17809 return Err(serde::de::Error::duplicate_field("streamCdcScan"));
17810 }
17811 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamCdcScan)
17812;
17813 }
17814 GeneratedField::CdcFilter => {
17815 if node_body__.is_some() {
17816 return Err(serde::de::Error::duplicate_field("cdcFilter"));
17817 }
17818 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CdcFilter)
17819;
17820 }
17821 GeneratedField::SourceBackfill => {
17822 if node_body__.is_some() {
17823 return Err(serde::de::Error::duplicate_field("sourceBackfill"));
17824 }
17825 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SourceBackfill)
17826;
17827 }
17828 GeneratedField::Changelog => {
17829 if node_body__.is_some() {
17830 return Err(serde::de::Error::duplicate_field("changelog"));
17831 }
17832 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Changelog)
17833;
17834 }
17835 GeneratedField::LocalApproxPercentile => {
17836 if node_body__.is_some() {
17837 return Err(serde::de::Error::duplicate_field("localApproxPercentile"));
17838 }
17839 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalApproxPercentile)
17840;
17841 }
17842 GeneratedField::GlobalApproxPercentile => {
17843 if node_body__.is_some() {
17844 return Err(serde::de::Error::duplicate_field("globalApproxPercentile"));
17845 }
17846 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GlobalApproxPercentile)
17847;
17848 }
17849 GeneratedField::RowMerge => {
17850 if node_body__.is_some() {
17851 return Err(serde::de::Error::duplicate_field("rowMerge"));
17852 }
17853 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowMerge)
17854;
17855 }
17856 GeneratedField::AsOfJoin => {
17857 if node_body__.is_some() {
17858 return Err(serde::de::Error::duplicate_field("asOfJoin"));
17859 }
17860 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AsOfJoin)
17861;
17862 }
17863 GeneratedField::SyncLogStore => {
17864 if node_body__.is_some() {
17865 return Err(serde::de::Error::duplicate_field("syncLogStore"));
17866 }
17867 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SyncLogStore)
17868;
17869 }
17870 GeneratedField::MaterializedExprs => {
17871 if node_body__.is_some() {
17872 return Err(serde::de::Error::duplicate_field("materializedExprs"));
17873 }
17874 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MaterializedExprs)
17875;
17876 }
17877 GeneratedField::VectorIndexWrite => {
17878 if node_body__.is_some() {
17879 return Err(serde::de::Error::duplicate_field("vectorIndexWrite"));
17880 }
17881 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexWrite)
17882;
17883 }
17884 GeneratedField::UpstreamSinkUnion => {
17885 if node_body__.is_some() {
17886 return Err(serde::de::Error::duplicate_field("upstreamSinkUnion"));
17887 }
17888 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::UpstreamSinkUnion)
17889;
17890 }
17891 GeneratedField::LocalityProvider => {
17892 if node_body__.is_some() {
17893 return Err(serde::de::Error::duplicate_field("localityProvider"));
17894 }
17895 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalityProvider)
17896;
17897 }
17898 GeneratedField::EowcGapFill => {
17899 if node_body__.is_some() {
17900 return Err(serde::de::Error::duplicate_field("eowcGapFill"));
17901 }
17902 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcGapFill)
17903;
17904 }
17905 GeneratedField::GapFill => {
17906 if node_body__.is_some() {
17907 return Err(serde::de::Error::duplicate_field("gapFill"));
17908 }
17909 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GapFill)
17910;
17911 }
17912 GeneratedField::VectorIndexLookupJoin => {
17913 if node_body__.is_some() {
17914 return Err(serde::de::Error::duplicate_field("vectorIndexLookupJoin"));
17915 }
17916 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexLookupJoin)
17917;
17918 }
17919 GeneratedField::IcebergWithPkIndexWriter => {
17920 if node_body__.is_some() {
17921 return Err(serde::de::Error::duplicate_field("icebergWithPkIndexWriter"));
17922 }
17923 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::IcebergWithPkIndexWriter)
17924;
17925 }
17926 GeneratedField::IcebergWithPkIndexPositionDeleteMerger => {
17927 if node_body__.is_some() {
17928 return Err(serde::de::Error::duplicate_field("icebergWithPkIndexPositionDeleteMerger"));
17929 }
17930 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::IcebergWithPkIndexPositionDeleteMerger)
17931;
17932 }
17933 GeneratedField::MatchRecognize => {
17934 if node_body__.is_some() {
17935 return Err(serde::de::Error::duplicate_field("matchRecognize"));
17936 }
17937 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MatchRecognize)
17938;
17939 }
17940 GeneratedField::CompactionResolver => {
17941 if node_body__.is_some() {
17942 return Err(serde::de::Error::duplicate_field("compactionResolver"));
17943 }
17944 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CompactionResolver)
17945;
17946 }
17947 }
17948 }
17949 Ok(StreamNode {
17950 operator_id: operator_id__.unwrap_or_default(),
17951 input: input__.unwrap_or_default(),
17952 stream_key: stream_key__.unwrap_or_default(),
17953 stream_kind: stream_kind__.unwrap_or_default(),
17954 identity: identity__.unwrap_or_default(),
17955 fields: fields__.unwrap_or_default(),
17956 node_body: node_body__,
17957 })
17958 }
17959 }
17960 deserializer.deserialize_struct("stream_plan.StreamNode", FIELDS, GeneratedVisitor)
17961 }
17962}
17963impl serde::Serialize for stream_node::StreamKind {
17964 #[allow(deprecated)]
17965 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17966 where
17967 S: serde::Serializer,
17968 {
17969 let variant = match self {
17970 Self::Retract => "STREAM_KIND_RETRACT",
17971 Self::AppendOnly => "STREAM_KIND_APPEND_ONLY",
17972 Self::Upsert => "STREAM_KIND_UPSERT",
17973 };
17974 serializer.serialize_str(variant)
17975 }
17976}
17977impl<'de> serde::Deserialize<'de> for stream_node::StreamKind {
17978 #[allow(deprecated)]
17979 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17980 where
17981 D: serde::Deserializer<'de>,
17982 {
17983 const FIELDS: &[&str] = &[
17984 "STREAM_KIND_RETRACT",
17985 "STREAM_KIND_APPEND_ONLY",
17986 "STREAM_KIND_UPSERT",
17987 ];
17988
17989 struct GeneratedVisitor;
17990
17991 impl serde::de::Visitor<'_> for GeneratedVisitor {
17992 type Value = stream_node::StreamKind;
17993
17994 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17995 write!(formatter, "expected one of: {:?}", &FIELDS)
17996 }
17997
17998 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17999 where
18000 E: serde::de::Error,
18001 {
18002 i32::try_from(v)
18003 .ok()
18004 .and_then(|x| x.try_into().ok())
18005 .ok_or_else(|| {
18006 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
18007 })
18008 }
18009
18010 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
18011 where
18012 E: serde::de::Error,
18013 {
18014 i32::try_from(v)
18015 .ok()
18016 .and_then(|x| x.try_into().ok())
18017 .ok_or_else(|| {
18018 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
18019 })
18020 }
18021
18022 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
18023 where
18024 E: serde::de::Error,
18025 {
18026 match value {
18027 "STREAM_KIND_RETRACT" => Ok(stream_node::StreamKind::Retract),
18028 "STREAM_KIND_APPEND_ONLY" => Ok(stream_node::StreamKind::AppendOnly),
18029 "STREAM_KIND_UPSERT" => Ok(stream_node::StreamKind::Upsert),
18030 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
18031 }
18032 }
18033 }
18034 deserializer.deserialize_any(GeneratedVisitor)
18035 }
18036}
18037impl serde::Serialize for StreamScanNode {
18038 #[allow(deprecated)]
18039 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18040 where
18041 S: serde::Serializer,
18042 {
18043 use serde::ser::SerializeStruct;
18044 let mut len = 0;
18045 if self.table_id != 0 {
18046 len += 1;
18047 }
18048 if !self.upstream_column_ids.is_empty() {
18049 len += 1;
18050 }
18051 if !self.output_indices.is_empty() {
18052 len += 1;
18053 }
18054 if self.stream_scan_type != 0 {
18055 len += 1;
18056 }
18057 if self.state_table.is_some() {
18058 len += 1;
18059 }
18060 if self.table_desc.is_some() {
18061 len += 1;
18062 }
18063 if self.rate_limit.is_some() {
18064 len += 1;
18065 }
18066 if self.snapshot_read_barrier_interval != 0 {
18067 len += 1;
18068 }
18069 if self.arrangement_table.is_some() {
18070 len += 1;
18071 }
18072 if self.snapshot_backfill_epoch.is_some() {
18073 len += 1;
18074 }
18075 if self.pk_scan_range.is_some() {
18076 len += 1;
18077 }
18078 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamScanNode", len)?;
18079 if self.table_id != 0 {
18080 struct_ser.serialize_field("tableId", &self.table_id)?;
18081 }
18082 if !self.upstream_column_ids.is_empty() {
18083 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
18084 }
18085 if !self.output_indices.is_empty() {
18086 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
18087 }
18088 if self.stream_scan_type != 0 {
18089 let v = StreamScanType::try_from(self.stream_scan_type)
18090 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_scan_type)))?;
18091 struct_ser.serialize_field("streamScanType", &v)?;
18092 }
18093 if let Some(v) = self.state_table.as_ref() {
18094 struct_ser.serialize_field("stateTable", v)?;
18095 }
18096 if let Some(v) = self.table_desc.as_ref() {
18097 struct_ser.serialize_field("tableDesc", v)?;
18098 }
18099 if let Some(v) = self.rate_limit.as_ref() {
18100 struct_ser.serialize_field("rateLimit", v)?;
18101 }
18102 if self.snapshot_read_barrier_interval != 0 {
18103 struct_ser.serialize_field("snapshotReadBarrierInterval", &self.snapshot_read_barrier_interval)?;
18104 }
18105 if let Some(v) = self.arrangement_table.as_ref() {
18106 struct_ser.serialize_field("arrangementTable", v)?;
18107 }
18108 if let Some(v) = self.snapshot_backfill_epoch.as_ref() {
18109 #[allow(clippy::needless_borrow)]
18110 #[allow(clippy::needless_borrows_for_generic_args)]
18111 struct_ser.serialize_field("snapshotBackfillEpoch", ToString::to_string(&v).as_str())?;
18112 }
18113 if let Some(v) = self.pk_scan_range.as_ref() {
18114 struct_ser.serialize_field("pkScanRange", v)?;
18115 }
18116 struct_ser.end()
18117 }
18118}
18119impl<'de> serde::Deserialize<'de> for StreamScanNode {
18120 #[allow(deprecated)]
18121 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18122 where
18123 D: serde::Deserializer<'de>,
18124 {
18125 const FIELDS: &[&str] = &[
18126 "table_id",
18127 "tableId",
18128 "upstream_column_ids",
18129 "upstreamColumnIds",
18130 "output_indices",
18131 "outputIndices",
18132 "stream_scan_type",
18133 "streamScanType",
18134 "state_table",
18135 "stateTable",
18136 "table_desc",
18137 "tableDesc",
18138 "rate_limit",
18139 "rateLimit",
18140 "snapshot_read_barrier_interval",
18141 "snapshotReadBarrierInterval",
18142 "arrangement_table",
18143 "arrangementTable",
18144 "snapshot_backfill_epoch",
18145 "snapshotBackfillEpoch",
18146 "pk_scan_range",
18147 "pkScanRange",
18148 ];
18149
18150 #[allow(clippy::enum_variant_names)]
18151 enum GeneratedField {
18152 TableId,
18153 UpstreamColumnIds,
18154 OutputIndices,
18155 StreamScanType,
18156 StateTable,
18157 TableDesc,
18158 RateLimit,
18159 SnapshotReadBarrierInterval,
18160 ArrangementTable,
18161 SnapshotBackfillEpoch,
18162 PkScanRange,
18163 }
18164 impl<'de> serde::Deserialize<'de> for GeneratedField {
18165 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18166 where
18167 D: serde::Deserializer<'de>,
18168 {
18169 struct GeneratedVisitor;
18170
18171 impl serde::de::Visitor<'_> for GeneratedVisitor {
18172 type Value = GeneratedField;
18173
18174 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18175 write!(formatter, "expected one of: {:?}", &FIELDS)
18176 }
18177
18178 #[allow(unused_variables)]
18179 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18180 where
18181 E: serde::de::Error,
18182 {
18183 match value {
18184 "tableId" | "table_id" => Ok(GeneratedField::TableId),
18185 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
18186 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
18187 "streamScanType" | "stream_scan_type" => Ok(GeneratedField::StreamScanType),
18188 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
18189 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
18190 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
18191 "snapshotReadBarrierInterval" | "snapshot_read_barrier_interval" => Ok(GeneratedField::SnapshotReadBarrierInterval),
18192 "arrangementTable" | "arrangement_table" => Ok(GeneratedField::ArrangementTable),
18193 "snapshotBackfillEpoch" | "snapshot_backfill_epoch" => Ok(GeneratedField::SnapshotBackfillEpoch),
18194 "pkScanRange" | "pk_scan_range" => Ok(GeneratedField::PkScanRange),
18195 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18196 }
18197 }
18198 }
18199 deserializer.deserialize_identifier(GeneratedVisitor)
18200 }
18201 }
18202 struct GeneratedVisitor;
18203 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18204 type Value = StreamScanNode;
18205
18206 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18207 formatter.write_str("struct stream_plan.StreamScanNode")
18208 }
18209
18210 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamScanNode, V::Error>
18211 where
18212 V: serde::de::MapAccess<'de>,
18213 {
18214 let mut table_id__ = None;
18215 let mut upstream_column_ids__ = None;
18216 let mut output_indices__ = None;
18217 let mut stream_scan_type__ = None;
18218 let mut state_table__ = None;
18219 let mut table_desc__ = None;
18220 let mut rate_limit__ = None;
18221 let mut snapshot_read_barrier_interval__ = None;
18222 let mut arrangement_table__ = None;
18223 let mut snapshot_backfill_epoch__ = None;
18224 let mut pk_scan_range__ = None;
18225 while let Some(k) = map_.next_key()? {
18226 match k {
18227 GeneratedField::TableId => {
18228 if table_id__.is_some() {
18229 return Err(serde::de::Error::duplicate_field("tableId"));
18230 }
18231 table_id__ =
18232 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18233 ;
18234 }
18235 GeneratedField::UpstreamColumnIds => {
18236 if upstream_column_ids__.is_some() {
18237 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
18238 }
18239 upstream_column_ids__ =
18240 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
18241 .into_iter().map(|x| x.0).collect())
18242 ;
18243 }
18244 GeneratedField::OutputIndices => {
18245 if output_indices__.is_some() {
18246 return Err(serde::de::Error::duplicate_field("outputIndices"));
18247 }
18248 output_indices__ =
18249 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
18250 .into_iter().map(|x| x.0).collect())
18251 ;
18252 }
18253 GeneratedField::StreamScanType => {
18254 if stream_scan_type__.is_some() {
18255 return Err(serde::de::Error::duplicate_field("streamScanType"));
18256 }
18257 stream_scan_type__ = Some(map_.next_value::<StreamScanType>()? as i32);
18258 }
18259 GeneratedField::StateTable => {
18260 if state_table__.is_some() {
18261 return Err(serde::de::Error::duplicate_field("stateTable"));
18262 }
18263 state_table__ = map_.next_value()?;
18264 }
18265 GeneratedField::TableDesc => {
18266 if table_desc__.is_some() {
18267 return Err(serde::de::Error::duplicate_field("tableDesc"));
18268 }
18269 table_desc__ = map_.next_value()?;
18270 }
18271 GeneratedField::RateLimit => {
18272 if rate_limit__.is_some() {
18273 return Err(serde::de::Error::duplicate_field("rateLimit"));
18274 }
18275 rate_limit__ =
18276 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18277 ;
18278 }
18279 GeneratedField::SnapshotReadBarrierInterval => {
18280 if snapshot_read_barrier_interval__.is_some() {
18281 return Err(serde::de::Error::duplicate_field("snapshotReadBarrierInterval"));
18282 }
18283 snapshot_read_barrier_interval__ =
18284 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18285 ;
18286 }
18287 GeneratedField::ArrangementTable => {
18288 if arrangement_table__.is_some() {
18289 return Err(serde::de::Error::duplicate_field("arrangementTable"));
18290 }
18291 arrangement_table__ = map_.next_value()?;
18292 }
18293 GeneratedField::SnapshotBackfillEpoch => {
18294 if snapshot_backfill_epoch__.is_some() {
18295 return Err(serde::de::Error::duplicate_field("snapshotBackfillEpoch"));
18296 }
18297 snapshot_backfill_epoch__ =
18298 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18299 ;
18300 }
18301 GeneratedField::PkScanRange => {
18302 if pk_scan_range__.is_some() {
18303 return Err(serde::de::Error::duplicate_field("pkScanRange"));
18304 }
18305 pk_scan_range__ = map_.next_value()?;
18306 }
18307 }
18308 }
18309 Ok(StreamScanNode {
18310 table_id: table_id__.unwrap_or_default(),
18311 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
18312 output_indices: output_indices__.unwrap_or_default(),
18313 stream_scan_type: stream_scan_type__.unwrap_or_default(),
18314 state_table: state_table__,
18315 table_desc: table_desc__,
18316 rate_limit: rate_limit__,
18317 snapshot_read_barrier_interval: snapshot_read_barrier_interval__.unwrap_or_default(),
18318 arrangement_table: arrangement_table__,
18319 snapshot_backfill_epoch: snapshot_backfill_epoch__,
18320 pk_scan_range: pk_scan_range__,
18321 })
18322 }
18323 }
18324 deserializer.deserialize_struct("stream_plan.StreamScanNode", FIELDS, GeneratedVisitor)
18325 }
18326}
18327impl serde::Serialize for StreamScanType {
18328 #[allow(deprecated)]
18329 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18330 where
18331 S: serde::Serializer,
18332 {
18333 let variant = match self {
18334 Self::Unspecified => "STREAM_SCAN_TYPE_UNSPECIFIED",
18335 Self::Chain => "STREAM_SCAN_TYPE_CHAIN",
18336 Self::Rearrange => "STREAM_SCAN_TYPE_REARRANGE",
18337 Self::Backfill => "STREAM_SCAN_TYPE_BACKFILL",
18338 Self::UpstreamOnly => "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
18339 Self::ArrangementBackfill => "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
18340 Self::SnapshotBackfill => "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
18341 Self::CrossDbSnapshotBackfill => "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
18342 };
18343 serializer.serialize_str(variant)
18344 }
18345}
18346impl<'de> serde::Deserialize<'de> for StreamScanType {
18347 #[allow(deprecated)]
18348 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18349 where
18350 D: serde::Deserializer<'de>,
18351 {
18352 const FIELDS: &[&str] = &[
18353 "STREAM_SCAN_TYPE_UNSPECIFIED",
18354 "STREAM_SCAN_TYPE_CHAIN",
18355 "STREAM_SCAN_TYPE_REARRANGE",
18356 "STREAM_SCAN_TYPE_BACKFILL",
18357 "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
18358 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
18359 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
18360 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
18361 ];
18362
18363 struct GeneratedVisitor;
18364
18365 impl serde::de::Visitor<'_> for GeneratedVisitor {
18366 type Value = StreamScanType;
18367
18368 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18369 write!(formatter, "expected one of: {:?}", &FIELDS)
18370 }
18371
18372 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
18373 where
18374 E: serde::de::Error,
18375 {
18376 i32::try_from(v)
18377 .ok()
18378 .and_then(|x| x.try_into().ok())
18379 .ok_or_else(|| {
18380 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
18381 })
18382 }
18383
18384 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
18385 where
18386 E: serde::de::Error,
18387 {
18388 i32::try_from(v)
18389 .ok()
18390 .and_then(|x| x.try_into().ok())
18391 .ok_or_else(|| {
18392 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
18393 })
18394 }
18395
18396 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
18397 where
18398 E: serde::de::Error,
18399 {
18400 match value {
18401 "STREAM_SCAN_TYPE_UNSPECIFIED" => Ok(StreamScanType::Unspecified),
18402 "STREAM_SCAN_TYPE_CHAIN" => Ok(StreamScanType::Chain),
18403 "STREAM_SCAN_TYPE_REARRANGE" => Ok(StreamScanType::Rearrange),
18404 "STREAM_SCAN_TYPE_BACKFILL" => Ok(StreamScanType::Backfill),
18405 "STREAM_SCAN_TYPE_UPSTREAM_ONLY" => Ok(StreamScanType::UpstreamOnly),
18406 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL" => Ok(StreamScanType::ArrangementBackfill),
18407 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL" => Ok(StreamScanType::SnapshotBackfill),
18408 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL" => Ok(StreamScanType::CrossDbSnapshotBackfill),
18409 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
18410 }
18411 }
18412 }
18413 deserializer.deserialize_any(GeneratedVisitor)
18414 }
18415}
18416impl serde::Serialize for StreamSource {
18417 #[allow(deprecated)]
18418 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18419 where
18420 S: serde::Serializer,
18421 {
18422 use serde::ser::SerializeStruct;
18423 let mut len = 0;
18424 if self.source_id != 0 {
18425 len += 1;
18426 }
18427 if self.state_table.is_some() {
18428 len += 1;
18429 }
18430 if self.row_id_index.is_some() {
18431 len += 1;
18432 }
18433 if !self.columns.is_empty() {
18434 len += 1;
18435 }
18436 if !self.with_properties.is_empty() {
18437 len += 1;
18438 }
18439 if self.info.is_some() {
18440 len += 1;
18441 }
18442 if !self.source_name.is_empty() {
18443 len += 1;
18444 }
18445 if self.rate_limit.is_some() {
18446 len += 1;
18447 }
18448 if !self.secret_refs.is_empty() {
18449 len += 1;
18450 }
18451 if self.downstream_columns.is_some() {
18452 len += 1;
18453 }
18454 if self.refresh_mode.is_some() {
18455 len += 1;
18456 }
18457 if self.associated_table_id.is_some() {
18458 len += 1;
18459 }
18460 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamSource", len)?;
18461 if self.source_id != 0 {
18462 struct_ser.serialize_field("sourceId", &self.source_id)?;
18463 }
18464 if let Some(v) = self.state_table.as_ref() {
18465 struct_ser.serialize_field("stateTable", v)?;
18466 }
18467 if let Some(v) = self.row_id_index.as_ref() {
18468 struct_ser.serialize_field("rowIdIndex", v)?;
18469 }
18470 if !self.columns.is_empty() {
18471 struct_ser.serialize_field("columns", &self.columns)?;
18472 }
18473 if !self.with_properties.is_empty() {
18474 struct_ser.serialize_field("withProperties", &self.with_properties)?;
18475 }
18476 if let Some(v) = self.info.as_ref() {
18477 struct_ser.serialize_field("info", v)?;
18478 }
18479 if !self.source_name.is_empty() {
18480 struct_ser.serialize_field("sourceName", &self.source_name)?;
18481 }
18482 if let Some(v) = self.rate_limit.as_ref() {
18483 struct_ser.serialize_field("rateLimit", v)?;
18484 }
18485 if !self.secret_refs.is_empty() {
18486 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
18487 }
18488 if let Some(v) = self.downstream_columns.as_ref() {
18489 struct_ser.serialize_field("downstreamColumns", v)?;
18490 }
18491 if let Some(v) = self.refresh_mode.as_ref() {
18492 struct_ser.serialize_field("refreshMode", v)?;
18493 }
18494 if let Some(v) = self.associated_table_id.as_ref() {
18495 struct_ser.serialize_field("associatedTableId", v)?;
18496 }
18497 struct_ser.end()
18498 }
18499}
18500impl<'de> serde::Deserialize<'de> for StreamSource {
18501 #[allow(deprecated)]
18502 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18503 where
18504 D: serde::Deserializer<'de>,
18505 {
18506 const FIELDS: &[&str] = &[
18507 "source_id",
18508 "sourceId",
18509 "state_table",
18510 "stateTable",
18511 "row_id_index",
18512 "rowIdIndex",
18513 "columns",
18514 "with_properties",
18515 "withProperties",
18516 "info",
18517 "source_name",
18518 "sourceName",
18519 "rate_limit",
18520 "rateLimit",
18521 "secret_refs",
18522 "secretRefs",
18523 "downstream_columns",
18524 "downstreamColumns",
18525 "refresh_mode",
18526 "refreshMode",
18527 "associated_table_id",
18528 "associatedTableId",
18529 ];
18530
18531 #[allow(clippy::enum_variant_names)]
18532 enum GeneratedField {
18533 SourceId,
18534 StateTable,
18535 RowIdIndex,
18536 Columns,
18537 WithProperties,
18538 Info,
18539 SourceName,
18540 RateLimit,
18541 SecretRefs,
18542 DownstreamColumns,
18543 RefreshMode,
18544 AssociatedTableId,
18545 }
18546 impl<'de> serde::Deserialize<'de> for GeneratedField {
18547 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18548 where
18549 D: serde::Deserializer<'de>,
18550 {
18551 struct GeneratedVisitor;
18552
18553 impl serde::de::Visitor<'_> for GeneratedVisitor {
18554 type Value = GeneratedField;
18555
18556 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18557 write!(formatter, "expected one of: {:?}", &FIELDS)
18558 }
18559
18560 #[allow(unused_variables)]
18561 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18562 where
18563 E: serde::de::Error,
18564 {
18565 match value {
18566 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
18567 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
18568 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
18569 "columns" => Ok(GeneratedField::Columns),
18570 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
18571 "info" => Ok(GeneratedField::Info),
18572 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
18573 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
18574 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
18575 "downstreamColumns" | "downstream_columns" => Ok(GeneratedField::DownstreamColumns),
18576 "refreshMode" | "refresh_mode" => Ok(GeneratedField::RefreshMode),
18577 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
18578 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18579 }
18580 }
18581 }
18582 deserializer.deserialize_identifier(GeneratedVisitor)
18583 }
18584 }
18585 struct GeneratedVisitor;
18586 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18587 type Value = StreamSource;
18588
18589 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18590 formatter.write_str("struct stream_plan.StreamSource")
18591 }
18592
18593 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSource, V::Error>
18594 where
18595 V: serde::de::MapAccess<'de>,
18596 {
18597 let mut source_id__ = None;
18598 let mut state_table__ = None;
18599 let mut row_id_index__ = None;
18600 let mut columns__ = None;
18601 let mut with_properties__ = None;
18602 let mut info__ = None;
18603 let mut source_name__ = None;
18604 let mut rate_limit__ = None;
18605 let mut secret_refs__ = None;
18606 let mut downstream_columns__ = None;
18607 let mut refresh_mode__ = None;
18608 let mut associated_table_id__ = None;
18609 while let Some(k) = map_.next_key()? {
18610 match k {
18611 GeneratedField::SourceId => {
18612 if source_id__.is_some() {
18613 return Err(serde::de::Error::duplicate_field("sourceId"));
18614 }
18615 source_id__ =
18616 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18617 ;
18618 }
18619 GeneratedField::StateTable => {
18620 if state_table__.is_some() {
18621 return Err(serde::de::Error::duplicate_field("stateTable"));
18622 }
18623 state_table__ = map_.next_value()?;
18624 }
18625 GeneratedField::RowIdIndex => {
18626 if row_id_index__.is_some() {
18627 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
18628 }
18629 row_id_index__ =
18630 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18631 ;
18632 }
18633 GeneratedField::Columns => {
18634 if columns__.is_some() {
18635 return Err(serde::de::Error::duplicate_field("columns"));
18636 }
18637 columns__ = Some(map_.next_value()?);
18638 }
18639 GeneratedField::WithProperties => {
18640 if with_properties__.is_some() {
18641 return Err(serde::de::Error::duplicate_field("withProperties"));
18642 }
18643 with_properties__ = Some(
18644 map_.next_value::<std::collections::BTreeMap<_, _>>()?
18645 );
18646 }
18647 GeneratedField::Info => {
18648 if info__.is_some() {
18649 return Err(serde::de::Error::duplicate_field("info"));
18650 }
18651 info__ = map_.next_value()?;
18652 }
18653 GeneratedField::SourceName => {
18654 if source_name__.is_some() {
18655 return Err(serde::de::Error::duplicate_field("sourceName"));
18656 }
18657 source_name__ = Some(map_.next_value()?);
18658 }
18659 GeneratedField::RateLimit => {
18660 if rate_limit__.is_some() {
18661 return Err(serde::de::Error::duplicate_field("rateLimit"));
18662 }
18663 rate_limit__ =
18664 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18665 ;
18666 }
18667 GeneratedField::SecretRefs => {
18668 if secret_refs__.is_some() {
18669 return Err(serde::de::Error::duplicate_field("secretRefs"));
18670 }
18671 secret_refs__ = Some(
18672 map_.next_value::<std::collections::BTreeMap<_, _>>()?
18673 );
18674 }
18675 GeneratedField::DownstreamColumns => {
18676 if downstream_columns__.is_some() {
18677 return Err(serde::de::Error::duplicate_field("downstreamColumns"));
18678 }
18679 downstream_columns__ = map_.next_value()?;
18680 }
18681 GeneratedField::RefreshMode => {
18682 if refresh_mode__.is_some() {
18683 return Err(serde::de::Error::duplicate_field("refreshMode"));
18684 }
18685 refresh_mode__ = map_.next_value()?;
18686 }
18687 GeneratedField::AssociatedTableId => {
18688 if associated_table_id__.is_some() {
18689 return Err(serde::de::Error::duplicate_field("associatedTableId"));
18690 }
18691 associated_table_id__ =
18692 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18693 ;
18694 }
18695 }
18696 }
18697 Ok(StreamSource {
18698 source_id: source_id__.unwrap_or_default(),
18699 state_table: state_table__,
18700 row_id_index: row_id_index__,
18701 columns: columns__.unwrap_or_default(),
18702 with_properties: with_properties__.unwrap_or_default(),
18703 info: info__,
18704 source_name: source_name__.unwrap_or_default(),
18705 rate_limit: rate_limit__,
18706 secret_refs: secret_refs__.unwrap_or_default(),
18707 downstream_columns: downstream_columns__,
18708 refresh_mode: refresh_mode__,
18709 associated_table_id: associated_table_id__,
18710 })
18711 }
18712 }
18713 deserializer.deserialize_struct("stream_plan.StreamSource", FIELDS, GeneratedVisitor)
18714 }
18715}
18716impl serde::Serialize for SubscriptionUpstreamInfo {
18717 #[allow(deprecated)]
18718 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18719 where
18720 S: serde::Serializer,
18721 {
18722 use serde::ser::SerializeStruct;
18723 let mut len = 0;
18724 if self.subscriber_id != 0 {
18725 len += 1;
18726 }
18727 if self.upstream_mv_table_id != 0 {
18728 len += 1;
18729 }
18730 let mut struct_ser = serializer.serialize_struct("stream_plan.SubscriptionUpstreamInfo", len)?;
18731 if self.subscriber_id != 0 {
18732 struct_ser.serialize_field("subscriberId", &self.subscriber_id)?;
18733 }
18734 if self.upstream_mv_table_id != 0 {
18735 struct_ser.serialize_field("upstreamMvTableId", &self.upstream_mv_table_id)?;
18736 }
18737 struct_ser.end()
18738 }
18739}
18740impl<'de> serde::Deserialize<'de> for SubscriptionUpstreamInfo {
18741 #[allow(deprecated)]
18742 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18743 where
18744 D: serde::Deserializer<'de>,
18745 {
18746 const FIELDS: &[&str] = &[
18747 "subscriber_id",
18748 "subscriberId",
18749 "upstream_mv_table_id",
18750 "upstreamMvTableId",
18751 ];
18752
18753 #[allow(clippy::enum_variant_names)]
18754 enum GeneratedField {
18755 SubscriberId,
18756 UpstreamMvTableId,
18757 }
18758 impl<'de> serde::Deserialize<'de> for GeneratedField {
18759 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18760 where
18761 D: serde::Deserializer<'de>,
18762 {
18763 struct GeneratedVisitor;
18764
18765 impl serde::de::Visitor<'_> for GeneratedVisitor {
18766 type Value = GeneratedField;
18767
18768 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18769 write!(formatter, "expected one of: {:?}", &FIELDS)
18770 }
18771
18772 #[allow(unused_variables)]
18773 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18774 where
18775 E: serde::de::Error,
18776 {
18777 match value {
18778 "subscriberId" | "subscriber_id" => Ok(GeneratedField::SubscriberId),
18779 "upstreamMvTableId" | "upstream_mv_table_id" => Ok(GeneratedField::UpstreamMvTableId),
18780 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18781 }
18782 }
18783 }
18784 deserializer.deserialize_identifier(GeneratedVisitor)
18785 }
18786 }
18787 struct GeneratedVisitor;
18788 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18789 type Value = SubscriptionUpstreamInfo;
18790
18791 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18792 formatter.write_str("struct stream_plan.SubscriptionUpstreamInfo")
18793 }
18794
18795 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscriptionUpstreamInfo, V::Error>
18796 where
18797 V: serde::de::MapAccess<'de>,
18798 {
18799 let mut subscriber_id__ = None;
18800 let mut upstream_mv_table_id__ = None;
18801 while let Some(k) = map_.next_key()? {
18802 match k {
18803 GeneratedField::SubscriberId => {
18804 if subscriber_id__.is_some() {
18805 return Err(serde::de::Error::duplicate_field("subscriberId"));
18806 }
18807 subscriber_id__ =
18808 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18809 ;
18810 }
18811 GeneratedField::UpstreamMvTableId => {
18812 if upstream_mv_table_id__.is_some() {
18813 return Err(serde::de::Error::duplicate_field("upstreamMvTableId"));
18814 }
18815 upstream_mv_table_id__ =
18816 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18817 ;
18818 }
18819 }
18820 }
18821 Ok(SubscriptionUpstreamInfo {
18822 subscriber_id: subscriber_id__.unwrap_or_default(),
18823 upstream_mv_table_id: upstream_mv_table_id__.unwrap_or_default(),
18824 })
18825 }
18826 }
18827 deserializer.deserialize_struct("stream_plan.SubscriptionUpstreamInfo", FIELDS, GeneratedVisitor)
18828 }
18829}
18830impl serde::Serialize for SyncLogStoreNode {
18831 #[allow(deprecated)]
18832 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18833 where
18834 S: serde::Serializer,
18835 {
18836 use serde::ser::SerializeStruct;
18837 let mut len = 0;
18838 if self.log_store_table.is_some() {
18839 len += 1;
18840 }
18841 if self.pause_duration_ms.is_some() {
18842 len += 1;
18843 }
18844 if self.buffer_size.is_some() {
18845 len += 1;
18846 }
18847 if self.aligned {
18848 len += 1;
18849 }
18850 let mut struct_ser = serializer.serialize_struct("stream_plan.SyncLogStoreNode", len)?;
18851 if let Some(v) = self.log_store_table.as_ref() {
18852 struct_ser.serialize_field("logStoreTable", v)?;
18853 }
18854 if let Some(v) = self.pause_duration_ms.as_ref() {
18855 struct_ser.serialize_field("pauseDurationMs", v)?;
18856 }
18857 if let Some(v) = self.buffer_size.as_ref() {
18858 struct_ser.serialize_field("bufferSize", v)?;
18859 }
18860 if self.aligned {
18861 struct_ser.serialize_field("aligned", &self.aligned)?;
18862 }
18863 struct_ser.end()
18864 }
18865}
18866impl<'de> serde::Deserialize<'de> for SyncLogStoreNode {
18867 #[allow(deprecated)]
18868 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18869 where
18870 D: serde::Deserializer<'de>,
18871 {
18872 const FIELDS: &[&str] = &[
18873 "log_store_table",
18874 "logStoreTable",
18875 "pause_duration_ms",
18876 "pauseDurationMs",
18877 "buffer_size",
18878 "bufferSize",
18879 "aligned",
18880 ];
18881
18882 #[allow(clippy::enum_variant_names)]
18883 enum GeneratedField {
18884 LogStoreTable,
18885 PauseDurationMs,
18886 BufferSize,
18887 Aligned,
18888 }
18889 impl<'de> serde::Deserialize<'de> for GeneratedField {
18890 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18891 where
18892 D: serde::Deserializer<'de>,
18893 {
18894 struct GeneratedVisitor;
18895
18896 impl serde::de::Visitor<'_> for GeneratedVisitor {
18897 type Value = GeneratedField;
18898
18899 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18900 write!(formatter, "expected one of: {:?}", &FIELDS)
18901 }
18902
18903 #[allow(unused_variables)]
18904 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18905 where
18906 E: serde::de::Error,
18907 {
18908 match value {
18909 "logStoreTable" | "log_store_table" => Ok(GeneratedField::LogStoreTable),
18910 "pauseDurationMs" | "pause_duration_ms" => Ok(GeneratedField::PauseDurationMs),
18911 "bufferSize" | "buffer_size" => Ok(GeneratedField::BufferSize),
18912 "aligned" => Ok(GeneratedField::Aligned),
18913 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18914 }
18915 }
18916 }
18917 deserializer.deserialize_identifier(GeneratedVisitor)
18918 }
18919 }
18920 struct GeneratedVisitor;
18921 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18922 type Value = SyncLogStoreNode;
18923
18924 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18925 formatter.write_str("struct stream_plan.SyncLogStoreNode")
18926 }
18927
18928 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SyncLogStoreNode, V::Error>
18929 where
18930 V: serde::de::MapAccess<'de>,
18931 {
18932 let mut log_store_table__ = None;
18933 let mut pause_duration_ms__ = None;
18934 let mut buffer_size__ = None;
18935 let mut aligned__ = None;
18936 while let Some(k) = map_.next_key()? {
18937 match k {
18938 GeneratedField::LogStoreTable => {
18939 if log_store_table__.is_some() {
18940 return Err(serde::de::Error::duplicate_field("logStoreTable"));
18941 }
18942 log_store_table__ = map_.next_value()?;
18943 }
18944 GeneratedField::PauseDurationMs => {
18945 if pause_duration_ms__.is_some() {
18946 return Err(serde::de::Error::duplicate_field("pauseDurationMs"));
18947 }
18948 pause_duration_ms__ =
18949 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18950 ;
18951 }
18952 GeneratedField::BufferSize => {
18953 if buffer_size__.is_some() {
18954 return Err(serde::de::Error::duplicate_field("bufferSize"));
18955 }
18956 buffer_size__ =
18957 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18958 ;
18959 }
18960 GeneratedField::Aligned => {
18961 if aligned__.is_some() {
18962 return Err(serde::de::Error::duplicate_field("aligned"));
18963 }
18964 aligned__ = Some(map_.next_value()?);
18965 }
18966 }
18967 }
18968 Ok(SyncLogStoreNode {
18969 log_store_table: log_store_table__,
18970 pause_duration_ms: pause_duration_ms__,
18971 buffer_size: buffer_size__,
18972 aligned: aligned__.unwrap_or_default(),
18973 })
18974 }
18975 }
18976 deserializer.deserialize_struct("stream_plan.SyncLogStoreNode", FIELDS, GeneratedVisitor)
18977 }
18978}
18979impl serde::Serialize for TemporalJoinNode {
18980 #[allow(deprecated)]
18981 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18982 where
18983 S: serde::Serializer,
18984 {
18985 use serde::ser::SerializeStruct;
18986 let mut len = 0;
18987 if self.join_type != 0 {
18988 len += 1;
18989 }
18990 if !self.left_key.is_empty() {
18991 len += 1;
18992 }
18993 if !self.right_key.is_empty() {
18994 len += 1;
18995 }
18996 if !self.null_safe.is_empty() {
18997 len += 1;
18998 }
18999 if self.condition.is_some() {
19000 len += 1;
19001 }
19002 if !self.output_indices.is_empty() {
19003 len += 1;
19004 }
19005 if self.table_desc.is_some() {
19006 len += 1;
19007 }
19008 if !self.table_output_indices.is_empty() {
19009 len += 1;
19010 }
19011 if self.memo_table.is_some() {
19012 len += 1;
19013 }
19014 if self.is_nested_loop {
19015 len += 1;
19016 }
19017 if self.is_broadcast {
19018 len += 1;
19019 }
19020 let mut struct_ser = serializer.serialize_struct("stream_plan.TemporalJoinNode", len)?;
19021 if self.join_type != 0 {
19022 let v = super::plan_common::JoinType::try_from(self.join_type)
19023 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
19024 struct_ser.serialize_field("joinType", &v)?;
19025 }
19026 if !self.left_key.is_empty() {
19027 struct_ser.serialize_field("leftKey", &self.left_key)?;
19028 }
19029 if !self.right_key.is_empty() {
19030 struct_ser.serialize_field("rightKey", &self.right_key)?;
19031 }
19032 if !self.null_safe.is_empty() {
19033 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
19034 }
19035 if let Some(v) = self.condition.as_ref() {
19036 struct_ser.serialize_field("condition", v)?;
19037 }
19038 if !self.output_indices.is_empty() {
19039 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
19040 }
19041 if let Some(v) = self.table_desc.as_ref() {
19042 struct_ser.serialize_field("tableDesc", v)?;
19043 }
19044 if !self.table_output_indices.is_empty() {
19045 struct_ser.serialize_field("tableOutputIndices", &self.table_output_indices)?;
19046 }
19047 if let Some(v) = self.memo_table.as_ref() {
19048 struct_ser.serialize_field("memoTable", v)?;
19049 }
19050 if self.is_nested_loop {
19051 struct_ser.serialize_field("isNestedLoop", &self.is_nested_loop)?;
19052 }
19053 if self.is_broadcast {
19054 struct_ser.serialize_field("isBroadcast", &self.is_broadcast)?;
19055 }
19056 struct_ser.end()
19057 }
19058}
19059impl<'de> serde::Deserialize<'de> for TemporalJoinNode {
19060 #[allow(deprecated)]
19061 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19062 where
19063 D: serde::Deserializer<'de>,
19064 {
19065 const FIELDS: &[&str] = &[
19066 "join_type",
19067 "joinType",
19068 "left_key",
19069 "leftKey",
19070 "right_key",
19071 "rightKey",
19072 "null_safe",
19073 "nullSafe",
19074 "condition",
19075 "output_indices",
19076 "outputIndices",
19077 "table_desc",
19078 "tableDesc",
19079 "table_output_indices",
19080 "tableOutputIndices",
19081 "memo_table",
19082 "memoTable",
19083 "is_nested_loop",
19084 "isNestedLoop",
19085 "is_broadcast",
19086 "isBroadcast",
19087 ];
19088
19089 #[allow(clippy::enum_variant_names)]
19090 enum GeneratedField {
19091 JoinType,
19092 LeftKey,
19093 RightKey,
19094 NullSafe,
19095 Condition,
19096 OutputIndices,
19097 TableDesc,
19098 TableOutputIndices,
19099 MemoTable,
19100 IsNestedLoop,
19101 IsBroadcast,
19102 }
19103 impl<'de> serde::Deserialize<'de> for GeneratedField {
19104 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19105 where
19106 D: serde::Deserializer<'de>,
19107 {
19108 struct GeneratedVisitor;
19109
19110 impl serde::de::Visitor<'_> for GeneratedVisitor {
19111 type Value = GeneratedField;
19112
19113 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19114 write!(formatter, "expected one of: {:?}", &FIELDS)
19115 }
19116
19117 #[allow(unused_variables)]
19118 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19119 where
19120 E: serde::de::Error,
19121 {
19122 match value {
19123 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
19124 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
19125 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
19126 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
19127 "condition" => Ok(GeneratedField::Condition),
19128 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
19129 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
19130 "tableOutputIndices" | "table_output_indices" => Ok(GeneratedField::TableOutputIndices),
19131 "memoTable" | "memo_table" => Ok(GeneratedField::MemoTable),
19132 "isNestedLoop" | "is_nested_loop" => Ok(GeneratedField::IsNestedLoop),
19133 "isBroadcast" | "is_broadcast" => Ok(GeneratedField::IsBroadcast),
19134 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19135 }
19136 }
19137 }
19138 deserializer.deserialize_identifier(GeneratedVisitor)
19139 }
19140 }
19141 struct GeneratedVisitor;
19142 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19143 type Value = TemporalJoinNode;
19144
19145 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19146 formatter.write_str("struct stream_plan.TemporalJoinNode")
19147 }
19148
19149 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TemporalJoinNode, V::Error>
19150 where
19151 V: serde::de::MapAccess<'de>,
19152 {
19153 let mut join_type__ = None;
19154 let mut left_key__ = None;
19155 let mut right_key__ = None;
19156 let mut null_safe__ = None;
19157 let mut condition__ = None;
19158 let mut output_indices__ = None;
19159 let mut table_desc__ = None;
19160 let mut table_output_indices__ = None;
19161 let mut memo_table__ = None;
19162 let mut is_nested_loop__ = None;
19163 let mut is_broadcast__ = None;
19164 while let Some(k) = map_.next_key()? {
19165 match k {
19166 GeneratedField::JoinType => {
19167 if join_type__.is_some() {
19168 return Err(serde::de::Error::duplicate_field("joinType"));
19169 }
19170 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
19171 }
19172 GeneratedField::LeftKey => {
19173 if left_key__.is_some() {
19174 return Err(serde::de::Error::duplicate_field("leftKey"));
19175 }
19176 left_key__ =
19177 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
19178 .into_iter().map(|x| x.0).collect())
19179 ;
19180 }
19181 GeneratedField::RightKey => {
19182 if right_key__.is_some() {
19183 return Err(serde::de::Error::duplicate_field("rightKey"));
19184 }
19185 right_key__ =
19186 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
19187 .into_iter().map(|x| x.0).collect())
19188 ;
19189 }
19190 GeneratedField::NullSafe => {
19191 if null_safe__.is_some() {
19192 return Err(serde::de::Error::duplicate_field("nullSafe"));
19193 }
19194 null_safe__ = Some(map_.next_value()?);
19195 }
19196 GeneratedField::Condition => {
19197 if condition__.is_some() {
19198 return Err(serde::de::Error::duplicate_field("condition"));
19199 }
19200 condition__ = map_.next_value()?;
19201 }
19202 GeneratedField::OutputIndices => {
19203 if output_indices__.is_some() {
19204 return Err(serde::de::Error::duplicate_field("outputIndices"));
19205 }
19206 output_indices__ =
19207 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
19208 .into_iter().map(|x| x.0).collect())
19209 ;
19210 }
19211 GeneratedField::TableDesc => {
19212 if table_desc__.is_some() {
19213 return Err(serde::de::Error::duplicate_field("tableDesc"));
19214 }
19215 table_desc__ = map_.next_value()?;
19216 }
19217 GeneratedField::TableOutputIndices => {
19218 if table_output_indices__.is_some() {
19219 return Err(serde::de::Error::duplicate_field("tableOutputIndices"));
19220 }
19221 table_output_indices__ =
19222 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
19223 .into_iter().map(|x| x.0).collect())
19224 ;
19225 }
19226 GeneratedField::MemoTable => {
19227 if memo_table__.is_some() {
19228 return Err(serde::de::Error::duplicate_field("memoTable"));
19229 }
19230 memo_table__ = map_.next_value()?;
19231 }
19232 GeneratedField::IsNestedLoop => {
19233 if is_nested_loop__.is_some() {
19234 return Err(serde::de::Error::duplicate_field("isNestedLoop"));
19235 }
19236 is_nested_loop__ = Some(map_.next_value()?);
19237 }
19238 GeneratedField::IsBroadcast => {
19239 if is_broadcast__.is_some() {
19240 return Err(serde::de::Error::duplicate_field("isBroadcast"));
19241 }
19242 is_broadcast__ = Some(map_.next_value()?);
19243 }
19244 }
19245 }
19246 Ok(TemporalJoinNode {
19247 join_type: join_type__.unwrap_or_default(),
19248 left_key: left_key__.unwrap_or_default(),
19249 right_key: right_key__.unwrap_or_default(),
19250 null_safe: null_safe__.unwrap_or_default(),
19251 condition: condition__,
19252 output_indices: output_indices__.unwrap_or_default(),
19253 table_desc: table_desc__,
19254 table_output_indices: table_output_indices__.unwrap_or_default(),
19255 memo_table: memo_table__,
19256 is_nested_loop: is_nested_loop__.unwrap_or_default(),
19257 is_broadcast: is_broadcast__.unwrap_or_default(),
19258 })
19259 }
19260 }
19261 deserializer.deserialize_struct("stream_plan.TemporalJoinNode", FIELDS, GeneratedVisitor)
19262 }
19263}
19264impl serde::Serialize for ThrottleMutation {
19265 #[allow(deprecated)]
19266 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19267 where
19268 S: serde::Serializer,
19269 {
19270 use serde::ser::SerializeStruct;
19271 let mut len = 0;
19272 if !self.fragment_throttle.is_empty() {
19273 len += 1;
19274 }
19275 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation", len)?;
19276 if !self.fragment_throttle.is_empty() {
19277 struct_ser.serialize_field("fragmentThrottle", &self.fragment_throttle)?;
19278 }
19279 struct_ser.end()
19280 }
19281}
19282impl<'de> serde::Deserialize<'de> for ThrottleMutation {
19283 #[allow(deprecated)]
19284 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19285 where
19286 D: serde::Deserializer<'de>,
19287 {
19288 const FIELDS: &[&str] = &[
19289 "fragment_throttle",
19290 "fragmentThrottle",
19291 ];
19292
19293 #[allow(clippy::enum_variant_names)]
19294 enum GeneratedField {
19295 FragmentThrottle,
19296 }
19297 impl<'de> serde::Deserialize<'de> for GeneratedField {
19298 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19299 where
19300 D: serde::Deserializer<'de>,
19301 {
19302 struct GeneratedVisitor;
19303
19304 impl serde::de::Visitor<'_> for GeneratedVisitor {
19305 type Value = GeneratedField;
19306
19307 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19308 write!(formatter, "expected one of: {:?}", &FIELDS)
19309 }
19310
19311 #[allow(unused_variables)]
19312 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19313 where
19314 E: serde::de::Error,
19315 {
19316 match value {
19317 "fragmentThrottle" | "fragment_throttle" => Ok(GeneratedField::FragmentThrottle),
19318 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19319 }
19320 }
19321 }
19322 deserializer.deserialize_identifier(GeneratedVisitor)
19323 }
19324 }
19325 struct GeneratedVisitor;
19326 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19327 type Value = ThrottleMutation;
19328
19329 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19330 formatter.write_str("struct stream_plan.ThrottleMutation")
19331 }
19332
19333 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ThrottleMutation, V::Error>
19334 where
19335 V: serde::de::MapAccess<'de>,
19336 {
19337 let mut fragment_throttle__ = None;
19338 while let Some(k) = map_.next_key()? {
19339 match k {
19340 GeneratedField::FragmentThrottle => {
19341 if fragment_throttle__.is_some() {
19342 return Err(serde::de::Error::duplicate_field("fragmentThrottle"));
19343 }
19344 fragment_throttle__ = Some(
19345 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
19346 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
19347 );
19348 }
19349 }
19350 }
19351 Ok(ThrottleMutation {
19352 fragment_throttle: fragment_throttle__.unwrap_or_default(),
19353 })
19354 }
19355 }
19356 deserializer.deserialize_struct("stream_plan.ThrottleMutation", FIELDS, GeneratedVisitor)
19357 }
19358}
19359impl serde::Serialize for throttle_mutation::ThrottleConfig {
19360 #[allow(deprecated)]
19361 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19362 where
19363 S: serde::Serializer,
19364 {
19365 use serde::ser::SerializeStruct;
19366 let mut len = 0;
19367 if self.rate_limit.is_some() {
19368 len += 1;
19369 }
19370 if self.throttle_type != 0 {
19371 len += 1;
19372 }
19373 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation.ThrottleConfig", len)?;
19374 if let Some(v) = self.rate_limit.as_ref() {
19375 struct_ser.serialize_field("rateLimit", v)?;
19376 }
19377 if self.throttle_type != 0 {
19378 let v = super::common::ThrottleType::try_from(self.throttle_type)
19379 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.throttle_type)))?;
19380 struct_ser.serialize_field("throttleType", &v)?;
19381 }
19382 struct_ser.end()
19383 }
19384}
19385impl<'de> serde::Deserialize<'de> for throttle_mutation::ThrottleConfig {
19386 #[allow(deprecated)]
19387 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19388 where
19389 D: serde::Deserializer<'de>,
19390 {
19391 const FIELDS: &[&str] = &[
19392 "rate_limit",
19393 "rateLimit",
19394 "throttle_type",
19395 "throttleType",
19396 ];
19397
19398 #[allow(clippy::enum_variant_names)]
19399 enum GeneratedField {
19400 RateLimit,
19401 ThrottleType,
19402 }
19403 impl<'de> serde::Deserialize<'de> for GeneratedField {
19404 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19405 where
19406 D: serde::Deserializer<'de>,
19407 {
19408 struct GeneratedVisitor;
19409
19410 impl serde::de::Visitor<'_> for GeneratedVisitor {
19411 type Value = GeneratedField;
19412
19413 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19414 write!(formatter, "expected one of: {:?}", &FIELDS)
19415 }
19416
19417 #[allow(unused_variables)]
19418 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19419 where
19420 E: serde::de::Error,
19421 {
19422 match value {
19423 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
19424 "throttleType" | "throttle_type" => Ok(GeneratedField::ThrottleType),
19425 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19426 }
19427 }
19428 }
19429 deserializer.deserialize_identifier(GeneratedVisitor)
19430 }
19431 }
19432 struct GeneratedVisitor;
19433 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19434 type Value = throttle_mutation::ThrottleConfig;
19435
19436 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19437 formatter.write_str("struct stream_plan.ThrottleMutation.ThrottleConfig")
19438 }
19439
19440 fn visit_map<V>(self, mut map_: V) -> std::result::Result<throttle_mutation::ThrottleConfig, V::Error>
19441 where
19442 V: serde::de::MapAccess<'de>,
19443 {
19444 let mut rate_limit__ = None;
19445 let mut throttle_type__ = None;
19446 while let Some(k) = map_.next_key()? {
19447 match k {
19448 GeneratedField::RateLimit => {
19449 if rate_limit__.is_some() {
19450 return Err(serde::de::Error::duplicate_field("rateLimit"));
19451 }
19452 rate_limit__ =
19453 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
19454 ;
19455 }
19456 GeneratedField::ThrottleType => {
19457 if throttle_type__.is_some() {
19458 return Err(serde::de::Error::duplicate_field("throttleType"));
19459 }
19460 throttle_type__ = Some(map_.next_value::<super::common::ThrottleType>()? as i32);
19461 }
19462 }
19463 }
19464 Ok(throttle_mutation::ThrottleConfig {
19465 rate_limit: rate_limit__,
19466 throttle_type: throttle_type__.unwrap_or_default(),
19467 })
19468 }
19469 }
19470 deserializer.deserialize_struct("stream_plan.ThrottleMutation.ThrottleConfig", FIELDS, GeneratedVisitor)
19471 }
19472}
19473impl serde::Serialize for TopNNode {
19474 #[allow(deprecated)]
19475 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19476 where
19477 S: serde::Serializer,
19478 {
19479 use serde::ser::SerializeStruct;
19480 let mut len = 0;
19481 if self.limit != 0 {
19482 len += 1;
19483 }
19484 if self.offset != 0 {
19485 len += 1;
19486 }
19487 if self.table.is_some() {
19488 len += 1;
19489 }
19490 if !self.order_by.is_empty() {
19491 len += 1;
19492 }
19493 if self.with_ties {
19494 len += 1;
19495 }
19496 let mut struct_ser = serializer.serialize_struct("stream_plan.TopNNode", len)?;
19497 if self.limit != 0 {
19498 #[allow(clippy::needless_borrow)]
19499 #[allow(clippy::needless_borrows_for_generic_args)]
19500 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
19501 }
19502 if self.offset != 0 {
19503 #[allow(clippy::needless_borrow)]
19504 #[allow(clippy::needless_borrows_for_generic_args)]
19505 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
19506 }
19507 if let Some(v) = self.table.as_ref() {
19508 struct_ser.serialize_field("table", v)?;
19509 }
19510 if !self.order_by.is_empty() {
19511 struct_ser.serialize_field("orderBy", &self.order_by)?;
19512 }
19513 if self.with_ties {
19514 struct_ser.serialize_field("withTies", &self.with_ties)?;
19515 }
19516 struct_ser.end()
19517 }
19518}
19519impl<'de> serde::Deserialize<'de> for TopNNode {
19520 #[allow(deprecated)]
19521 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19522 where
19523 D: serde::Deserializer<'de>,
19524 {
19525 const FIELDS: &[&str] = &[
19526 "limit",
19527 "offset",
19528 "table",
19529 "order_by",
19530 "orderBy",
19531 "with_ties",
19532 "withTies",
19533 ];
19534
19535 #[allow(clippy::enum_variant_names)]
19536 enum GeneratedField {
19537 Limit,
19538 Offset,
19539 Table,
19540 OrderBy,
19541 WithTies,
19542 }
19543 impl<'de> serde::Deserialize<'de> for GeneratedField {
19544 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19545 where
19546 D: serde::Deserializer<'de>,
19547 {
19548 struct GeneratedVisitor;
19549
19550 impl serde::de::Visitor<'_> for GeneratedVisitor {
19551 type Value = GeneratedField;
19552
19553 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19554 write!(formatter, "expected one of: {:?}", &FIELDS)
19555 }
19556
19557 #[allow(unused_variables)]
19558 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19559 where
19560 E: serde::de::Error,
19561 {
19562 match value {
19563 "limit" => Ok(GeneratedField::Limit),
19564 "offset" => Ok(GeneratedField::Offset),
19565 "table" => Ok(GeneratedField::Table),
19566 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
19567 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
19568 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19569 }
19570 }
19571 }
19572 deserializer.deserialize_identifier(GeneratedVisitor)
19573 }
19574 }
19575 struct GeneratedVisitor;
19576 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19577 type Value = TopNNode;
19578
19579 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19580 formatter.write_str("struct stream_plan.TopNNode")
19581 }
19582
19583 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
19584 where
19585 V: serde::de::MapAccess<'de>,
19586 {
19587 let mut limit__ = None;
19588 let mut offset__ = None;
19589 let mut table__ = None;
19590 let mut order_by__ = None;
19591 let mut with_ties__ = None;
19592 while let Some(k) = map_.next_key()? {
19593 match k {
19594 GeneratedField::Limit => {
19595 if limit__.is_some() {
19596 return Err(serde::de::Error::duplicate_field("limit"));
19597 }
19598 limit__ =
19599 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
19600 ;
19601 }
19602 GeneratedField::Offset => {
19603 if offset__.is_some() {
19604 return Err(serde::de::Error::duplicate_field("offset"));
19605 }
19606 offset__ =
19607 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
19608 ;
19609 }
19610 GeneratedField::Table => {
19611 if table__.is_some() {
19612 return Err(serde::de::Error::duplicate_field("table"));
19613 }
19614 table__ = map_.next_value()?;
19615 }
19616 GeneratedField::OrderBy => {
19617 if order_by__.is_some() {
19618 return Err(serde::de::Error::duplicate_field("orderBy"));
19619 }
19620 order_by__ = Some(map_.next_value()?);
19621 }
19622 GeneratedField::WithTies => {
19623 if with_ties__.is_some() {
19624 return Err(serde::de::Error::duplicate_field("withTies"));
19625 }
19626 with_ties__ = Some(map_.next_value()?);
19627 }
19628 }
19629 }
19630 Ok(TopNNode {
19631 limit: limit__.unwrap_or_default(),
19632 offset: offset__.unwrap_or_default(),
19633 table: table__,
19634 order_by: order_by__.unwrap_or_default(),
19635 with_ties: with_ties__.unwrap_or_default(),
19636 })
19637 }
19638 }
19639 deserializer.deserialize_struct("stream_plan.TopNNode", FIELDS, GeneratedVisitor)
19640 }
19641}
19642impl serde::Serialize for UnionNode {
19643 #[allow(deprecated)]
19644 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19645 where
19646 S: serde::Serializer,
19647 {
19648 use serde::ser::SerializeStruct;
19649 let len = 0;
19650 let struct_ser = serializer.serialize_struct("stream_plan.UnionNode", len)?;
19651 struct_ser.end()
19652 }
19653}
19654impl<'de> serde::Deserialize<'de> for UnionNode {
19655 #[allow(deprecated)]
19656 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19657 where
19658 D: serde::Deserializer<'de>,
19659 {
19660 const FIELDS: &[&str] = &[
19661 ];
19662
19663 #[allow(clippy::enum_variant_names)]
19664 enum GeneratedField {
19665 }
19666 impl<'de> serde::Deserialize<'de> for GeneratedField {
19667 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19668 where
19669 D: serde::Deserializer<'de>,
19670 {
19671 struct GeneratedVisitor;
19672
19673 impl serde::de::Visitor<'_> for GeneratedVisitor {
19674 type Value = GeneratedField;
19675
19676 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19677 write!(formatter, "expected one of: {:?}", &FIELDS)
19678 }
19679
19680 #[allow(unused_variables)]
19681 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19682 where
19683 E: serde::de::Error,
19684 {
19685 Err(serde::de::Error::unknown_field(value, FIELDS))
19686 }
19687 }
19688 deserializer.deserialize_identifier(GeneratedVisitor)
19689 }
19690 }
19691 struct GeneratedVisitor;
19692 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19693 type Value = UnionNode;
19694
19695 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19696 formatter.write_str("struct stream_plan.UnionNode")
19697 }
19698
19699 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
19700 where
19701 V: serde::de::MapAccess<'de>,
19702 {
19703 while map_.next_key::<GeneratedField>()?.is_some() {
19704 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
19705 }
19706 Ok(UnionNode {
19707 })
19708 }
19709 }
19710 deserializer.deserialize_struct("stream_plan.UnionNode", FIELDS, GeneratedVisitor)
19711 }
19712}
19713impl serde::Serialize for UpdateMutation {
19714 #[allow(deprecated)]
19715 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19716 where
19717 S: serde::Serializer,
19718 {
19719 use serde::ser::SerializeStruct;
19720 let mut len = 0;
19721 if !self.dispatcher_update.is_empty() {
19722 len += 1;
19723 }
19724 if !self.merge_update.is_empty() {
19725 len += 1;
19726 }
19727 if !self.actor_vnode_bitmap_update.is_empty() {
19728 len += 1;
19729 }
19730 if !self.dropped_actors.is_empty() {
19731 len += 1;
19732 }
19733 if !self.actor_splits.is_empty() {
19734 len += 1;
19735 }
19736 if !self.actor_new_dispatchers.is_empty() {
19737 len += 1;
19738 }
19739 if self.actor_cdc_table_snapshot_splits.is_some() {
19740 len += 1;
19741 }
19742 if !self.sink_schema_change.is_empty() {
19743 len += 1;
19744 }
19745 if !self.subscriptions_to_drop.is_empty() {
19746 len += 1;
19747 }
19748 if self.iceberg_pk_index_compaction.is_some() {
19749 len += 1;
19750 }
19751 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation", len)?;
19752 if !self.dispatcher_update.is_empty() {
19753 struct_ser.serialize_field("dispatcherUpdate", &self.dispatcher_update)?;
19754 }
19755 if !self.merge_update.is_empty() {
19756 struct_ser.serialize_field("mergeUpdate", &self.merge_update)?;
19757 }
19758 if !self.actor_vnode_bitmap_update.is_empty() {
19759 struct_ser.serialize_field("actorVnodeBitmapUpdate", &self.actor_vnode_bitmap_update)?;
19760 }
19761 if !self.dropped_actors.is_empty() {
19762 struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
19763 }
19764 if !self.actor_splits.is_empty() {
19765 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
19766 }
19767 if !self.actor_new_dispatchers.is_empty() {
19768 struct_ser.serialize_field("actorNewDispatchers", &self.actor_new_dispatchers)?;
19769 }
19770 if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
19771 struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
19772 }
19773 if !self.sink_schema_change.is_empty() {
19774 struct_ser.serialize_field("sinkSchemaChange", &self.sink_schema_change)?;
19775 }
19776 if !self.subscriptions_to_drop.is_empty() {
19777 struct_ser.serialize_field("subscriptionsToDrop", &self.subscriptions_to_drop)?;
19778 }
19779 if let Some(v) = self.iceberg_pk_index_compaction.as_ref() {
19780 struct_ser.serialize_field("icebergPkIndexCompaction", v)?;
19781 }
19782 struct_ser.end()
19783 }
19784}
19785impl<'de> serde::Deserialize<'de> for UpdateMutation {
19786 #[allow(deprecated)]
19787 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19788 where
19789 D: serde::Deserializer<'de>,
19790 {
19791 const FIELDS: &[&str] = &[
19792 "dispatcher_update",
19793 "dispatcherUpdate",
19794 "merge_update",
19795 "mergeUpdate",
19796 "actor_vnode_bitmap_update",
19797 "actorVnodeBitmapUpdate",
19798 "dropped_actors",
19799 "droppedActors",
19800 "actor_splits",
19801 "actorSplits",
19802 "actor_new_dispatchers",
19803 "actorNewDispatchers",
19804 "actor_cdc_table_snapshot_splits",
19805 "actorCdcTableSnapshotSplits",
19806 "sink_schema_change",
19807 "sinkSchemaChange",
19808 "subscriptions_to_drop",
19809 "subscriptionsToDrop",
19810 "iceberg_pk_index_compaction",
19811 "icebergPkIndexCompaction",
19812 ];
19813
19814 #[allow(clippy::enum_variant_names)]
19815 enum GeneratedField {
19816 DispatcherUpdate,
19817 MergeUpdate,
19818 ActorVnodeBitmapUpdate,
19819 DroppedActors,
19820 ActorSplits,
19821 ActorNewDispatchers,
19822 ActorCdcTableSnapshotSplits,
19823 SinkSchemaChange,
19824 SubscriptionsToDrop,
19825 IcebergPkIndexCompaction,
19826 }
19827 impl<'de> serde::Deserialize<'de> for GeneratedField {
19828 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19829 where
19830 D: serde::Deserializer<'de>,
19831 {
19832 struct GeneratedVisitor;
19833
19834 impl serde::de::Visitor<'_> for GeneratedVisitor {
19835 type Value = GeneratedField;
19836
19837 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19838 write!(formatter, "expected one of: {:?}", &FIELDS)
19839 }
19840
19841 #[allow(unused_variables)]
19842 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19843 where
19844 E: serde::de::Error,
19845 {
19846 match value {
19847 "dispatcherUpdate" | "dispatcher_update" => Ok(GeneratedField::DispatcherUpdate),
19848 "mergeUpdate" | "merge_update" => Ok(GeneratedField::MergeUpdate),
19849 "actorVnodeBitmapUpdate" | "actor_vnode_bitmap_update" => Ok(GeneratedField::ActorVnodeBitmapUpdate),
19850 "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
19851 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
19852 "actorNewDispatchers" | "actor_new_dispatchers" => Ok(GeneratedField::ActorNewDispatchers),
19853 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
19854 "sinkSchemaChange" | "sink_schema_change" => Ok(GeneratedField::SinkSchemaChange),
19855 "subscriptionsToDrop" | "subscriptions_to_drop" => Ok(GeneratedField::SubscriptionsToDrop),
19856 "icebergPkIndexCompaction" | "iceberg_pk_index_compaction" => Ok(GeneratedField::IcebergPkIndexCompaction),
19857 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19858 }
19859 }
19860 }
19861 deserializer.deserialize_identifier(GeneratedVisitor)
19862 }
19863 }
19864 struct GeneratedVisitor;
19865 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19866 type Value = UpdateMutation;
19867
19868 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19869 formatter.write_str("struct stream_plan.UpdateMutation")
19870 }
19871
19872 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateMutation, V::Error>
19873 where
19874 V: serde::de::MapAccess<'de>,
19875 {
19876 let mut dispatcher_update__ = None;
19877 let mut merge_update__ = None;
19878 let mut actor_vnode_bitmap_update__ = None;
19879 let mut dropped_actors__ = None;
19880 let mut actor_splits__ = None;
19881 let mut actor_new_dispatchers__ = None;
19882 let mut actor_cdc_table_snapshot_splits__ = None;
19883 let mut sink_schema_change__ = None;
19884 let mut subscriptions_to_drop__ = None;
19885 let mut iceberg_pk_index_compaction__ = None;
19886 while let Some(k) = map_.next_key()? {
19887 match k {
19888 GeneratedField::DispatcherUpdate => {
19889 if dispatcher_update__.is_some() {
19890 return Err(serde::de::Error::duplicate_field("dispatcherUpdate"));
19891 }
19892 dispatcher_update__ = Some(map_.next_value()?);
19893 }
19894 GeneratedField::MergeUpdate => {
19895 if merge_update__.is_some() {
19896 return Err(serde::de::Error::duplicate_field("mergeUpdate"));
19897 }
19898 merge_update__ = Some(map_.next_value()?);
19899 }
19900 GeneratedField::ActorVnodeBitmapUpdate => {
19901 if actor_vnode_bitmap_update__.is_some() {
19902 return Err(serde::de::Error::duplicate_field("actorVnodeBitmapUpdate"));
19903 }
19904 actor_vnode_bitmap_update__ = Some(
19905 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
19906 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
19907 );
19908 }
19909 GeneratedField::DroppedActors => {
19910 if dropped_actors__.is_some() {
19911 return Err(serde::de::Error::duplicate_field("droppedActors"));
19912 }
19913 dropped_actors__ =
19914 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
19915 .into_iter().map(|x| x.0).collect())
19916 ;
19917 }
19918 GeneratedField::ActorSplits => {
19919 if actor_splits__.is_some() {
19920 return Err(serde::de::Error::duplicate_field("actorSplits"));
19921 }
19922 actor_splits__ = Some(
19923 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
19924 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
19925 );
19926 }
19927 GeneratedField::ActorNewDispatchers => {
19928 if actor_new_dispatchers__.is_some() {
19929 return Err(serde::de::Error::duplicate_field("actorNewDispatchers"));
19930 }
19931 actor_new_dispatchers__ = Some(
19932 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
19933 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
19934 );
19935 }
19936 GeneratedField::ActorCdcTableSnapshotSplits => {
19937 if actor_cdc_table_snapshot_splits__.is_some() {
19938 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
19939 }
19940 actor_cdc_table_snapshot_splits__ = map_.next_value()?;
19941 }
19942 GeneratedField::SinkSchemaChange => {
19943 if sink_schema_change__.is_some() {
19944 return Err(serde::de::Error::duplicate_field("sinkSchemaChange"));
19945 }
19946 sink_schema_change__ = Some(
19947 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
19948 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
19949 );
19950 }
19951 GeneratedField::SubscriptionsToDrop => {
19952 if subscriptions_to_drop__.is_some() {
19953 return Err(serde::de::Error::duplicate_field("subscriptionsToDrop"));
19954 }
19955 subscriptions_to_drop__ = Some(map_.next_value()?);
19956 }
19957 GeneratedField::IcebergPkIndexCompaction => {
19958 if iceberg_pk_index_compaction__.is_some() {
19959 return Err(serde::de::Error::duplicate_field("icebergPkIndexCompaction"));
19960 }
19961 iceberg_pk_index_compaction__ = map_.next_value()?;
19962 }
19963 }
19964 }
19965 Ok(UpdateMutation {
19966 dispatcher_update: dispatcher_update__.unwrap_or_default(),
19967 merge_update: merge_update__.unwrap_or_default(),
19968 actor_vnode_bitmap_update: actor_vnode_bitmap_update__.unwrap_or_default(),
19969 dropped_actors: dropped_actors__.unwrap_or_default(),
19970 actor_splits: actor_splits__.unwrap_or_default(),
19971 actor_new_dispatchers: actor_new_dispatchers__.unwrap_or_default(),
19972 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
19973 sink_schema_change: sink_schema_change__.unwrap_or_default(),
19974 subscriptions_to_drop: subscriptions_to_drop__.unwrap_or_default(),
19975 iceberg_pk_index_compaction: iceberg_pk_index_compaction__,
19976 })
19977 }
19978 }
19979 deserializer.deserialize_struct("stream_plan.UpdateMutation", FIELDS, GeneratedVisitor)
19980 }
19981}
19982impl serde::Serialize for update_mutation::DispatcherUpdate {
19983 #[allow(deprecated)]
19984 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19985 where
19986 S: serde::Serializer,
19987 {
19988 use serde::ser::SerializeStruct;
19989 let mut len = 0;
19990 if self.actor_id != 0 {
19991 len += 1;
19992 }
19993 if self.dispatcher_id != 0 {
19994 len += 1;
19995 }
19996 if self.hash_mapping.is_some() {
19997 len += 1;
19998 }
19999 if !self.added_downstream_actor_id.is_empty() {
20000 len += 1;
20001 }
20002 if !self.removed_downstream_actor_id.is_empty() {
20003 len += 1;
20004 }
20005 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", len)?;
20006 if self.actor_id != 0 {
20007 struct_ser.serialize_field("actorId", &self.actor_id)?;
20008 }
20009 if self.dispatcher_id != 0 {
20010 struct_ser.serialize_field("dispatcherId", &self.dispatcher_id)?;
20011 }
20012 if let Some(v) = self.hash_mapping.as_ref() {
20013 struct_ser.serialize_field("hashMapping", v)?;
20014 }
20015 if !self.added_downstream_actor_id.is_empty() {
20016 struct_ser.serialize_field("addedDownstreamActorId", &self.added_downstream_actor_id)?;
20017 }
20018 if !self.removed_downstream_actor_id.is_empty() {
20019 struct_ser.serialize_field("removedDownstreamActorId", &self.removed_downstream_actor_id)?;
20020 }
20021 struct_ser.end()
20022 }
20023}
20024impl<'de> serde::Deserialize<'de> for update_mutation::DispatcherUpdate {
20025 #[allow(deprecated)]
20026 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20027 where
20028 D: serde::Deserializer<'de>,
20029 {
20030 const FIELDS: &[&str] = &[
20031 "actor_id",
20032 "actorId",
20033 "dispatcher_id",
20034 "dispatcherId",
20035 "hash_mapping",
20036 "hashMapping",
20037 "added_downstream_actor_id",
20038 "addedDownstreamActorId",
20039 "removed_downstream_actor_id",
20040 "removedDownstreamActorId",
20041 ];
20042
20043 #[allow(clippy::enum_variant_names)]
20044 enum GeneratedField {
20045 ActorId,
20046 DispatcherId,
20047 HashMapping,
20048 AddedDownstreamActorId,
20049 RemovedDownstreamActorId,
20050 }
20051 impl<'de> serde::Deserialize<'de> for GeneratedField {
20052 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20053 where
20054 D: serde::Deserializer<'de>,
20055 {
20056 struct GeneratedVisitor;
20057
20058 impl serde::de::Visitor<'_> for GeneratedVisitor {
20059 type Value = GeneratedField;
20060
20061 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20062 write!(formatter, "expected one of: {:?}", &FIELDS)
20063 }
20064
20065 #[allow(unused_variables)]
20066 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20067 where
20068 E: serde::de::Error,
20069 {
20070 match value {
20071 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
20072 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
20073 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
20074 "addedDownstreamActorId" | "added_downstream_actor_id" => Ok(GeneratedField::AddedDownstreamActorId),
20075 "removedDownstreamActorId" | "removed_downstream_actor_id" => Ok(GeneratedField::RemovedDownstreamActorId),
20076 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20077 }
20078 }
20079 }
20080 deserializer.deserialize_identifier(GeneratedVisitor)
20081 }
20082 }
20083 struct GeneratedVisitor;
20084 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20085 type Value = update_mutation::DispatcherUpdate;
20086
20087 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20088 formatter.write_str("struct stream_plan.UpdateMutation.DispatcherUpdate")
20089 }
20090
20091 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::DispatcherUpdate, V::Error>
20092 where
20093 V: serde::de::MapAccess<'de>,
20094 {
20095 let mut actor_id__ = None;
20096 let mut dispatcher_id__ = None;
20097 let mut hash_mapping__ = None;
20098 let mut added_downstream_actor_id__ = None;
20099 let mut removed_downstream_actor_id__ = None;
20100 while let Some(k) = map_.next_key()? {
20101 match k {
20102 GeneratedField::ActorId => {
20103 if actor_id__.is_some() {
20104 return Err(serde::de::Error::duplicate_field("actorId"));
20105 }
20106 actor_id__ =
20107 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
20108 ;
20109 }
20110 GeneratedField::DispatcherId => {
20111 if dispatcher_id__.is_some() {
20112 return Err(serde::de::Error::duplicate_field("dispatcherId"));
20113 }
20114 dispatcher_id__ =
20115 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
20116 ;
20117 }
20118 GeneratedField::HashMapping => {
20119 if hash_mapping__.is_some() {
20120 return Err(serde::de::Error::duplicate_field("hashMapping"));
20121 }
20122 hash_mapping__ = map_.next_value()?;
20123 }
20124 GeneratedField::AddedDownstreamActorId => {
20125 if added_downstream_actor_id__.is_some() {
20126 return Err(serde::de::Error::duplicate_field("addedDownstreamActorId"));
20127 }
20128 added_downstream_actor_id__ =
20129 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
20130 .into_iter().map(|x| x.0).collect())
20131 ;
20132 }
20133 GeneratedField::RemovedDownstreamActorId => {
20134 if removed_downstream_actor_id__.is_some() {
20135 return Err(serde::de::Error::duplicate_field("removedDownstreamActorId"));
20136 }
20137 removed_downstream_actor_id__ =
20138 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
20139 .into_iter().map(|x| x.0).collect())
20140 ;
20141 }
20142 }
20143 }
20144 Ok(update_mutation::DispatcherUpdate {
20145 actor_id: actor_id__.unwrap_or_default(),
20146 dispatcher_id: dispatcher_id__.unwrap_or_default(),
20147 hash_mapping: hash_mapping__,
20148 added_downstream_actor_id: added_downstream_actor_id__.unwrap_or_default(),
20149 removed_downstream_actor_id: removed_downstream_actor_id__.unwrap_or_default(),
20150 })
20151 }
20152 }
20153 deserializer.deserialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", FIELDS, GeneratedVisitor)
20154 }
20155}
20156impl serde::Serialize for update_mutation::MergeUpdate {
20157 #[allow(deprecated)]
20158 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20159 where
20160 S: serde::Serializer,
20161 {
20162 use serde::ser::SerializeStruct;
20163 let mut len = 0;
20164 if self.actor_id != 0 {
20165 len += 1;
20166 }
20167 if self.upstream_fragment_id != 0 {
20168 len += 1;
20169 }
20170 if self.new_upstream_fragment_id.is_some() {
20171 len += 1;
20172 }
20173 if !self.added_upstream_actors.is_empty() {
20174 len += 1;
20175 }
20176 if !self.removed_upstream_actor_id.is_empty() {
20177 len += 1;
20178 }
20179 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.MergeUpdate", len)?;
20180 if self.actor_id != 0 {
20181 struct_ser.serialize_field("actorId", &self.actor_id)?;
20182 }
20183 if self.upstream_fragment_id != 0 {
20184 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
20185 }
20186 if let Some(v) = self.new_upstream_fragment_id.as_ref() {
20187 struct_ser.serialize_field("newUpstreamFragmentId", v)?;
20188 }
20189 if !self.added_upstream_actors.is_empty() {
20190 struct_ser.serialize_field("addedUpstreamActors", &self.added_upstream_actors)?;
20191 }
20192 if !self.removed_upstream_actor_id.is_empty() {
20193 struct_ser.serialize_field("removedUpstreamActorId", &self.removed_upstream_actor_id)?;
20194 }
20195 struct_ser.end()
20196 }
20197}
20198impl<'de> serde::Deserialize<'de> for update_mutation::MergeUpdate {
20199 #[allow(deprecated)]
20200 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20201 where
20202 D: serde::Deserializer<'de>,
20203 {
20204 const FIELDS: &[&str] = &[
20205 "actor_id",
20206 "actorId",
20207 "upstream_fragment_id",
20208 "upstreamFragmentId",
20209 "new_upstream_fragment_id",
20210 "newUpstreamFragmentId",
20211 "added_upstream_actors",
20212 "addedUpstreamActors",
20213 "removed_upstream_actor_id",
20214 "removedUpstreamActorId",
20215 ];
20216
20217 #[allow(clippy::enum_variant_names)]
20218 enum GeneratedField {
20219 ActorId,
20220 UpstreamFragmentId,
20221 NewUpstreamFragmentId,
20222 AddedUpstreamActors,
20223 RemovedUpstreamActorId,
20224 }
20225 impl<'de> serde::Deserialize<'de> for GeneratedField {
20226 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20227 where
20228 D: serde::Deserializer<'de>,
20229 {
20230 struct GeneratedVisitor;
20231
20232 impl serde::de::Visitor<'_> for GeneratedVisitor {
20233 type Value = GeneratedField;
20234
20235 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20236 write!(formatter, "expected one of: {:?}", &FIELDS)
20237 }
20238
20239 #[allow(unused_variables)]
20240 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20241 where
20242 E: serde::de::Error,
20243 {
20244 match value {
20245 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
20246 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
20247 "newUpstreamFragmentId" | "new_upstream_fragment_id" => Ok(GeneratedField::NewUpstreamFragmentId),
20248 "addedUpstreamActors" | "added_upstream_actors" => Ok(GeneratedField::AddedUpstreamActors),
20249 "removedUpstreamActorId" | "removed_upstream_actor_id" => Ok(GeneratedField::RemovedUpstreamActorId),
20250 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20251 }
20252 }
20253 }
20254 deserializer.deserialize_identifier(GeneratedVisitor)
20255 }
20256 }
20257 struct GeneratedVisitor;
20258 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20259 type Value = update_mutation::MergeUpdate;
20260
20261 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20262 formatter.write_str("struct stream_plan.UpdateMutation.MergeUpdate")
20263 }
20264
20265 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::MergeUpdate, V::Error>
20266 where
20267 V: serde::de::MapAccess<'de>,
20268 {
20269 let mut actor_id__ = None;
20270 let mut upstream_fragment_id__ = None;
20271 let mut new_upstream_fragment_id__ = None;
20272 let mut added_upstream_actors__ = None;
20273 let mut removed_upstream_actor_id__ = None;
20274 while let Some(k) = map_.next_key()? {
20275 match k {
20276 GeneratedField::ActorId => {
20277 if actor_id__.is_some() {
20278 return Err(serde::de::Error::duplicate_field("actorId"));
20279 }
20280 actor_id__ =
20281 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
20282 ;
20283 }
20284 GeneratedField::UpstreamFragmentId => {
20285 if upstream_fragment_id__.is_some() {
20286 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
20287 }
20288 upstream_fragment_id__ =
20289 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
20290 ;
20291 }
20292 GeneratedField::NewUpstreamFragmentId => {
20293 if new_upstream_fragment_id__.is_some() {
20294 return Err(serde::de::Error::duplicate_field("newUpstreamFragmentId"));
20295 }
20296 new_upstream_fragment_id__ =
20297 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
20298 ;
20299 }
20300 GeneratedField::AddedUpstreamActors => {
20301 if added_upstream_actors__.is_some() {
20302 return Err(serde::de::Error::duplicate_field("addedUpstreamActors"));
20303 }
20304 added_upstream_actors__ = Some(map_.next_value()?);
20305 }
20306 GeneratedField::RemovedUpstreamActorId => {
20307 if removed_upstream_actor_id__.is_some() {
20308 return Err(serde::de::Error::duplicate_field("removedUpstreamActorId"));
20309 }
20310 removed_upstream_actor_id__ =
20311 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
20312 .into_iter().map(|x| x.0).collect())
20313 ;
20314 }
20315 }
20316 }
20317 Ok(update_mutation::MergeUpdate {
20318 actor_id: actor_id__.unwrap_or_default(),
20319 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
20320 new_upstream_fragment_id: new_upstream_fragment_id__,
20321 added_upstream_actors: added_upstream_actors__.unwrap_or_default(),
20322 removed_upstream_actor_id: removed_upstream_actor_id__.unwrap_or_default(),
20323 })
20324 }
20325 }
20326 deserializer.deserialize_struct("stream_plan.UpdateMutation.MergeUpdate", FIELDS, GeneratedVisitor)
20327 }
20328}
20329impl serde::Serialize for UpstreamSinkInfo {
20330 #[allow(deprecated)]
20331 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20332 where
20333 S: serde::Serializer,
20334 {
20335 use serde::ser::SerializeStruct;
20336 let mut len = 0;
20337 if self.upstream_fragment_id != 0 {
20338 len += 1;
20339 }
20340 if !self.sink_output_schema.is_empty() {
20341 len += 1;
20342 }
20343 if !self.project_exprs.is_empty() {
20344 len += 1;
20345 }
20346 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkInfo", len)?;
20347 if self.upstream_fragment_id != 0 {
20348 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
20349 }
20350 if !self.sink_output_schema.is_empty() {
20351 struct_ser.serialize_field("sinkOutputSchema", &self.sink_output_schema)?;
20352 }
20353 if !self.project_exprs.is_empty() {
20354 struct_ser.serialize_field("projectExprs", &self.project_exprs)?;
20355 }
20356 struct_ser.end()
20357 }
20358}
20359impl<'de> serde::Deserialize<'de> for UpstreamSinkInfo {
20360 #[allow(deprecated)]
20361 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20362 where
20363 D: serde::Deserializer<'de>,
20364 {
20365 const FIELDS: &[&str] = &[
20366 "upstream_fragment_id",
20367 "upstreamFragmentId",
20368 "sink_output_schema",
20369 "sinkOutputSchema",
20370 "project_exprs",
20371 "projectExprs",
20372 ];
20373
20374 #[allow(clippy::enum_variant_names)]
20375 enum GeneratedField {
20376 UpstreamFragmentId,
20377 SinkOutputSchema,
20378 ProjectExprs,
20379 }
20380 impl<'de> serde::Deserialize<'de> for GeneratedField {
20381 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20382 where
20383 D: serde::Deserializer<'de>,
20384 {
20385 struct GeneratedVisitor;
20386
20387 impl serde::de::Visitor<'_> for GeneratedVisitor {
20388 type Value = GeneratedField;
20389
20390 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20391 write!(formatter, "expected one of: {:?}", &FIELDS)
20392 }
20393
20394 #[allow(unused_variables)]
20395 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20396 where
20397 E: serde::de::Error,
20398 {
20399 match value {
20400 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
20401 "sinkOutputSchema" | "sink_output_schema" => Ok(GeneratedField::SinkOutputSchema),
20402 "projectExprs" | "project_exprs" => Ok(GeneratedField::ProjectExprs),
20403 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20404 }
20405 }
20406 }
20407 deserializer.deserialize_identifier(GeneratedVisitor)
20408 }
20409 }
20410 struct GeneratedVisitor;
20411 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20412 type Value = UpstreamSinkInfo;
20413
20414 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20415 formatter.write_str("struct stream_plan.UpstreamSinkInfo")
20416 }
20417
20418 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkInfo, V::Error>
20419 where
20420 V: serde::de::MapAccess<'de>,
20421 {
20422 let mut upstream_fragment_id__ = None;
20423 let mut sink_output_schema__ = None;
20424 let mut project_exprs__ = None;
20425 while let Some(k) = map_.next_key()? {
20426 match k {
20427 GeneratedField::UpstreamFragmentId => {
20428 if upstream_fragment_id__.is_some() {
20429 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
20430 }
20431 upstream_fragment_id__ =
20432 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
20433 ;
20434 }
20435 GeneratedField::SinkOutputSchema => {
20436 if sink_output_schema__.is_some() {
20437 return Err(serde::de::Error::duplicate_field("sinkOutputSchema"));
20438 }
20439 sink_output_schema__ = Some(map_.next_value()?);
20440 }
20441 GeneratedField::ProjectExprs => {
20442 if project_exprs__.is_some() {
20443 return Err(serde::de::Error::duplicate_field("projectExprs"));
20444 }
20445 project_exprs__ = Some(map_.next_value()?);
20446 }
20447 }
20448 }
20449 Ok(UpstreamSinkInfo {
20450 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
20451 sink_output_schema: sink_output_schema__.unwrap_or_default(),
20452 project_exprs: project_exprs__.unwrap_or_default(),
20453 })
20454 }
20455 }
20456 deserializer.deserialize_struct("stream_plan.UpstreamSinkInfo", FIELDS, GeneratedVisitor)
20457 }
20458}
20459impl serde::Serialize for UpstreamSinkUnionNode {
20460 #[allow(deprecated)]
20461 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20462 where
20463 S: serde::Serializer,
20464 {
20465 use serde::ser::SerializeStruct;
20466 let mut len = 0;
20467 if !self.init_upstreams.is_empty() {
20468 len += 1;
20469 }
20470 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkUnionNode", len)?;
20471 if !self.init_upstreams.is_empty() {
20472 struct_ser.serialize_field("initUpstreams", &self.init_upstreams)?;
20473 }
20474 struct_ser.end()
20475 }
20476}
20477impl<'de> serde::Deserialize<'de> for UpstreamSinkUnionNode {
20478 #[allow(deprecated)]
20479 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20480 where
20481 D: serde::Deserializer<'de>,
20482 {
20483 const FIELDS: &[&str] = &[
20484 "init_upstreams",
20485 "initUpstreams",
20486 ];
20487
20488 #[allow(clippy::enum_variant_names)]
20489 enum GeneratedField {
20490 InitUpstreams,
20491 }
20492 impl<'de> serde::Deserialize<'de> for GeneratedField {
20493 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20494 where
20495 D: serde::Deserializer<'de>,
20496 {
20497 struct GeneratedVisitor;
20498
20499 impl serde::de::Visitor<'_> for GeneratedVisitor {
20500 type Value = GeneratedField;
20501
20502 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20503 write!(formatter, "expected one of: {:?}", &FIELDS)
20504 }
20505
20506 #[allow(unused_variables)]
20507 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20508 where
20509 E: serde::de::Error,
20510 {
20511 match value {
20512 "initUpstreams" | "init_upstreams" => Ok(GeneratedField::InitUpstreams),
20513 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20514 }
20515 }
20516 }
20517 deserializer.deserialize_identifier(GeneratedVisitor)
20518 }
20519 }
20520 struct GeneratedVisitor;
20521 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20522 type Value = UpstreamSinkUnionNode;
20523
20524 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20525 formatter.write_str("struct stream_plan.UpstreamSinkUnionNode")
20526 }
20527
20528 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkUnionNode, V::Error>
20529 where
20530 V: serde::de::MapAccess<'de>,
20531 {
20532 let mut init_upstreams__ = None;
20533 while let Some(k) = map_.next_key()? {
20534 match k {
20535 GeneratedField::InitUpstreams => {
20536 if init_upstreams__.is_some() {
20537 return Err(serde::de::Error::duplicate_field("initUpstreams"));
20538 }
20539 init_upstreams__ = Some(map_.next_value()?);
20540 }
20541 }
20542 }
20543 Ok(UpstreamSinkUnionNode {
20544 init_upstreams: init_upstreams__.unwrap_or_default(),
20545 })
20546 }
20547 }
20548 deserializer.deserialize_struct("stream_plan.UpstreamSinkUnionNode", FIELDS, GeneratedVisitor)
20549 }
20550}
20551impl serde::Serialize for ValuesNode {
20552 #[allow(deprecated)]
20553 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20554 where
20555 S: serde::Serializer,
20556 {
20557 use serde::ser::SerializeStruct;
20558 let mut len = 0;
20559 if !self.tuples.is_empty() {
20560 len += 1;
20561 }
20562 if !self.fields.is_empty() {
20563 len += 1;
20564 }
20565 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode", len)?;
20566 if !self.tuples.is_empty() {
20567 struct_ser.serialize_field("tuples", &self.tuples)?;
20568 }
20569 if !self.fields.is_empty() {
20570 struct_ser.serialize_field("fields", &self.fields)?;
20571 }
20572 struct_ser.end()
20573 }
20574}
20575impl<'de> serde::Deserialize<'de> for ValuesNode {
20576 #[allow(deprecated)]
20577 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20578 where
20579 D: serde::Deserializer<'de>,
20580 {
20581 const FIELDS: &[&str] = &[
20582 "tuples",
20583 "fields",
20584 ];
20585
20586 #[allow(clippy::enum_variant_names)]
20587 enum GeneratedField {
20588 Tuples,
20589 Fields,
20590 }
20591 impl<'de> serde::Deserialize<'de> for GeneratedField {
20592 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20593 where
20594 D: serde::Deserializer<'de>,
20595 {
20596 struct GeneratedVisitor;
20597
20598 impl serde::de::Visitor<'_> for GeneratedVisitor {
20599 type Value = GeneratedField;
20600
20601 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20602 write!(formatter, "expected one of: {:?}", &FIELDS)
20603 }
20604
20605 #[allow(unused_variables)]
20606 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20607 where
20608 E: serde::de::Error,
20609 {
20610 match value {
20611 "tuples" => Ok(GeneratedField::Tuples),
20612 "fields" => Ok(GeneratedField::Fields),
20613 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20614 }
20615 }
20616 }
20617 deserializer.deserialize_identifier(GeneratedVisitor)
20618 }
20619 }
20620 struct GeneratedVisitor;
20621 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20622 type Value = ValuesNode;
20623
20624 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20625 formatter.write_str("struct stream_plan.ValuesNode")
20626 }
20627
20628 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
20629 where
20630 V: serde::de::MapAccess<'de>,
20631 {
20632 let mut tuples__ = None;
20633 let mut fields__ = None;
20634 while let Some(k) = map_.next_key()? {
20635 match k {
20636 GeneratedField::Tuples => {
20637 if tuples__.is_some() {
20638 return Err(serde::de::Error::duplicate_field("tuples"));
20639 }
20640 tuples__ = Some(map_.next_value()?);
20641 }
20642 GeneratedField::Fields => {
20643 if fields__.is_some() {
20644 return Err(serde::de::Error::duplicate_field("fields"));
20645 }
20646 fields__ = Some(map_.next_value()?);
20647 }
20648 }
20649 }
20650 Ok(ValuesNode {
20651 tuples: tuples__.unwrap_or_default(),
20652 fields: fields__.unwrap_or_default(),
20653 })
20654 }
20655 }
20656 deserializer.deserialize_struct("stream_plan.ValuesNode", FIELDS, GeneratedVisitor)
20657 }
20658}
20659impl serde::Serialize for values_node::ExprTuple {
20660 #[allow(deprecated)]
20661 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20662 where
20663 S: serde::Serializer,
20664 {
20665 use serde::ser::SerializeStruct;
20666 let mut len = 0;
20667 if !self.cells.is_empty() {
20668 len += 1;
20669 }
20670 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode.ExprTuple", len)?;
20671 if !self.cells.is_empty() {
20672 struct_ser.serialize_field("cells", &self.cells)?;
20673 }
20674 struct_ser.end()
20675 }
20676}
20677impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
20678 #[allow(deprecated)]
20679 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20680 where
20681 D: serde::Deserializer<'de>,
20682 {
20683 const FIELDS: &[&str] = &[
20684 "cells",
20685 ];
20686
20687 #[allow(clippy::enum_variant_names)]
20688 enum GeneratedField {
20689 Cells,
20690 }
20691 impl<'de> serde::Deserialize<'de> for GeneratedField {
20692 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20693 where
20694 D: serde::Deserializer<'de>,
20695 {
20696 struct GeneratedVisitor;
20697
20698 impl serde::de::Visitor<'_> for GeneratedVisitor {
20699 type Value = GeneratedField;
20700
20701 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20702 write!(formatter, "expected one of: {:?}", &FIELDS)
20703 }
20704
20705 #[allow(unused_variables)]
20706 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20707 where
20708 E: serde::de::Error,
20709 {
20710 match value {
20711 "cells" => Ok(GeneratedField::Cells),
20712 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20713 }
20714 }
20715 }
20716 deserializer.deserialize_identifier(GeneratedVisitor)
20717 }
20718 }
20719 struct GeneratedVisitor;
20720 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20721 type Value = values_node::ExprTuple;
20722
20723 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20724 formatter.write_str("struct stream_plan.ValuesNode.ExprTuple")
20725 }
20726
20727 fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
20728 where
20729 V: serde::de::MapAccess<'de>,
20730 {
20731 let mut cells__ = None;
20732 while let Some(k) = map_.next_key()? {
20733 match k {
20734 GeneratedField::Cells => {
20735 if cells__.is_some() {
20736 return Err(serde::de::Error::duplicate_field("cells"));
20737 }
20738 cells__ = Some(map_.next_value()?);
20739 }
20740 }
20741 }
20742 Ok(values_node::ExprTuple {
20743 cells: cells__.unwrap_or_default(),
20744 })
20745 }
20746 }
20747 deserializer.deserialize_struct("stream_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
20748 }
20749}
20750impl serde::Serialize for VectorIndexLookupJoinNode {
20751 #[allow(deprecated)]
20752 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20753 where
20754 S: serde::Serializer,
20755 {
20756 use serde::ser::SerializeStruct;
20757 let mut len = 0;
20758 if self.reader_desc.is_some() {
20759 len += 1;
20760 }
20761 if self.vector_column_idx != 0 {
20762 len += 1;
20763 }
20764 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexLookupJoinNode", len)?;
20765 if let Some(v) = self.reader_desc.as_ref() {
20766 struct_ser.serialize_field("readerDesc", v)?;
20767 }
20768 if self.vector_column_idx != 0 {
20769 struct_ser.serialize_field("vectorColumnIdx", &self.vector_column_idx)?;
20770 }
20771 struct_ser.end()
20772 }
20773}
20774impl<'de> serde::Deserialize<'de> for VectorIndexLookupJoinNode {
20775 #[allow(deprecated)]
20776 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20777 where
20778 D: serde::Deserializer<'de>,
20779 {
20780 const FIELDS: &[&str] = &[
20781 "reader_desc",
20782 "readerDesc",
20783 "vector_column_idx",
20784 "vectorColumnIdx",
20785 ];
20786
20787 #[allow(clippy::enum_variant_names)]
20788 enum GeneratedField {
20789 ReaderDesc,
20790 VectorColumnIdx,
20791 }
20792 impl<'de> serde::Deserialize<'de> for GeneratedField {
20793 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20794 where
20795 D: serde::Deserializer<'de>,
20796 {
20797 struct GeneratedVisitor;
20798
20799 impl serde::de::Visitor<'_> for GeneratedVisitor {
20800 type Value = GeneratedField;
20801
20802 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20803 write!(formatter, "expected one of: {:?}", &FIELDS)
20804 }
20805
20806 #[allow(unused_variables)]
20807 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20808 where
20809 E: serde::de::Error,
20810 {
20811 match value {
20812 "readerDesc" | "reader_desc" => Ok(GeneratedField::ReaderDesc),
20813 "vectorColumnIdx" | "vector_column_idx" => Ok(GeneratedField::VectorColumnIdx),
20814 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20815 }
20816 }
20817 }
20818 deserializer.deserialize_identifier(GeneratedVisitor)
20819 }
20820 }
20821 struct GeneratedVisitor;
20822 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20823 type Value = VectorIndexLookupJoinNode;
20824
20825 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20826 formatter.write_str("struct stream_plan.VectorIndexLookupJoinNode")
20827 }
20828
20829 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexLookupJoinNode, V::Error>
20830 where
20831 V: serde::de::MapAccess<'de>,
20832 {
20833 let mut reader_desc__ = None;
20834 let mut vector_column_idx__ = None;
20835 while let Some(k) = map_.next_key()? {
20836 match k {
20837 GeneratedField::ReaderDesc => {
20838 if reader_desc__.is_some() {
20839 return Err(serde::de::Error::duplicate_field("readerDesc"));
20840 }
20841 reader_desc__ = map_.next_value()?;
20842 }
20843 GeneratedField::VectorColumnIdx => {
20844 if vector_column_idx__.is_some() {
20845 return Err(serde::de::Error::duplicate_field("vectorColumnIdx"));
20846 }
20847 vector_column_idx__ =
20848 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
20849 ;
20850 }
20851 }
20852 }
20853 Ok(VectorIndexLookupJoinNode {
20854 reader_desc: reader_desc__,
20855 vector_column_idx: vector_column_idx__.unwrap_or_default(),
20856 })
20857 }
20858 }
20859 deserializer.deserialize_struct("stream_plan.VectorIndexLookupJoinNode", FIELDS, GeneratedVisitor)
20860 }
20861}
20862impl serde::Serialize for VectorIndexWriteNode {
20863 #[allow(deprecated)]
20864 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20865 where
20866 S: serde::Serializer,
20867 {
20868 use serde::ser::SerializeStruct;
20869 let mut len = 0;
20870 if self.table.is_some() {
20871 len += 1;
20872 }
20873 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexWriteNode", len)?;
20874 if let Some(v) = self.table.as_ref() {
20875 struct_ser.serialize_field("table", v)?;
20876 }
20877 struct_ser.end()
20878 }
20879}
20880impl<'de> serde::Deserialize<'de> for VectorIndexWriteNode {
20881 #[allow(deprecated)]
20882 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20883 where
20884 D: serde::Deserializer<'de>,
20885 {
20886 const FIELDS: &[&str] = &[
20887 "table",
20888 ];
20889
20890 #[allow(clippy::enum_variant_names)]
20891 enum GeneratedField {
20892 Table,
20893 }
20894 impl<'de> serde::Deserialize<'de> for GeneratedField {
20895 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20896 where
20897 D: serde::Deserializer<'de>,
20898 {
20899 struct GeneratedVisitor;
20900
20901 impl serde::de::Visitor<'_> for GeneratedVisitor {
20902 type Value = GeneratedField;
20903
20904 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20905 write!(formatter, "expected one of: {:?}", &FIELDS)
20906 }
20907
20908 #[allow(unused_variables)]
20909 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20910 where
20911 E: serde::de::Error,
20912 {
20913 match value {
20914 "table" => Ok(GeneratedField::Table),
20915 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20916 }
20917 }
20918 }
20919 deserializer.deserialize_identifier(GeneratedVisitor)
20920 }
20921 }
20922 struct GeneratedVisitor;
20923 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20924 type Value = VectorIndexWriteNode;
20925
20926 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20927 formatter.write_str("struct stream_plan.VectorIndexWriteNode")
20928 }
20929
20930 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexWriteNode, V::Error>
20931 where
20932 V: serde::de::MapAccess<'de>,
20933 {
20934 let mut table__ = None;
20935 while let Some(k) = map_.next_key()? {
20936 match k {
20937 GeneratedField::Table => {
20938 if table__.is_some() {
20939 return Err(serde::de::Error::duplicate_field("table"));
20940 }
20941 table__ = map_.next_value()?;
20942 }
20943 }
20944 }
20945 Ok(VectorIndexWriteNode {
20946 table: table__,
20947 })
20948 }
20949 }
20950 deserializer.deserialize_struct("stream_plan.VectorIndexWriteNode", FIELDS, GeneratedVisitor)
20951 }
20952}
20953impl serde::Serialize for Watermark {
20954 #[allow(deprecated)]
20955 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20956 where
20957 S: serde::Serializer,
20958 {
20959 use serde::ser::SerializeStruct;
20960 let mut len = 0;
20961 if self.column.is_some() {
20962 len += 1;
20963 }
20964 if self.val.is_some() {
20965 len += 1;
20966 }
20967 let mut struct_ser = serializer.serialize_struct("stream_plan.Watermark", len)?;
20968 if let Some(v) = self.column.as_ref() {
20969 struct_ser.serialize_field("column", v)?;
20970 }
20971 if let Some(v) = self.val.as_ref() {
20972 struct_ser.serialize_field("val", v)?;
20973 }
20974 struct_ser.end()
20975 }
20976}
20977impl<'de> serde::Deserialize<'de> for Watermark {
20978 #[allow(deprecated)]
20979 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20980 where
20981 D: serde::Deserializer<'de>,
20982 {
20983 const FIELDS: &[&str] = &[
20984 "column",
20985 "val",
20986 ];
20987
20988 #[allow(clippy::enum_variant_names)]
20989 enum GeneratedField {
20990 Column,
20991 Val,
20992 }
20993 impl<'de> serde::Deserialize<'de> for GeneratedField {
20994 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20995 where
20996 D: serde::Deserializer<'de>,
20997 {
20998 struct GeneratedVisitor;
20999
21000 impl serde::de::Visitor<'_> for GeneratedVisitor {
21001 type Value = GeneratedField;
21002
21003 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
21004 write!(formatter, "expected one of: {:?}", &FIELDS)
21005 }
21006
21007 #[allow(unused_variables)]
21008 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
21009 where
21010 E: serde::de::Error,
21011 {
21012 match value {
21013 "column" => Ok(GeneratedField::Column),
21014 "val" => Ok(GeneratedField::Val),
21015 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
21016 }
21017 }
21018 }
21019 deserializer.deserialize_identifier(GeneratedVisitor)
21020 }
21021 }
21022 struct GeneratedVisitor;
21023 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
21024 type Value = Watermark;
21025
21026 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
21027 formatter.write_str("struct stream_plan.Watermark")
21028 }
21029
21030 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Watermark, V::Error>
21031 where
21032 V: serde::de::MapAccess<'de>,
21033 {
21034 let mut column__ = None;
21035 let mut val__ = None;
21036 while let Some(k) = map_.next_key()? {
21037 match k {
21038 GeneratedField::Column => {
21039 if column__.is_some() {
21040 return Err(serde::de::Error::duplicate_field("column"));
21041 }
21042 column__ = map_.next_value()?;
21043 }
21044 GeneratedField::Val => {
21045 if val__.is_some() {
21046 return Err(serde::de::Error::duplicate_field("val"));
21047 }
21048 val__ = map_.next_value()?;
21049 }
21050 }
21051 }
21052 Ok(Watermark {
21053 column: column__,
21054 val: val__,
21055 })
21056 }
21057 }
21058 deserializer.deserialize_struct("stream_plan.Watermark", FIELDS, GeneratedVisitor)
21059 }
21060}
21061impl serde::Serialize for WatermarkFilterNode {
21062 #[allow(deprecated)]
21063 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
21064 where
21065 S: serde::Serializer,
21066 {
21067 use serde::ser::SerializeStruct;
21068 let mut len = 0;
21069 if !self.watermark_descs.is_empty() {
21070 len += 1;
21071 }
21072 if !self.tables.is_empty() {
21073 len += 1;
21074 }
21075 let mut struct_ser = serializer.serialize_struct("stream_plan.WatermarkFilterNode", len)?;
21076 if !self.watermark_descs.is_empty() {
21077 struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
21078 }
21079 if !self.tables.is_empty() {
21080 struct_ser.serialize_field("tables", &self.tables)?;
21081 }
21082 struct_ser.end()
21083 }
21084}
21085impl<'de> serde::Deserialize<'de> for WatermarkFilterNode {
21086 #[allow(deprecated)]
21087 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
21088 where
21089 D: serde::Deserializer<'de>,
21090 {
21091 const FIELDS: &[&str] = &[
21092 "watermark_descs",
21093 "watermarkDescs",
21094 "tables",
21095 ];
21096
21097 #[allow(clippy::enum_variant_names)]
21098 enum GeneratedField {
21099 WatermarkDescs,
21100 Tables,
21101 }
21102 impl<'de> serde::Deserialize<'de> for GeneratedField {
21103 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
21104 where
21105 D: serde::Deserializer<'de>,
21106 {
21107 struct GeneratedVisitor;
21108
21109 impl serde::de::Visitor<'_> for GeneratedVisitor {
21110 type Value = GeneratedField;
21111
21112 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
21113 write!(formatter, "expected one of: {:?}", &FIELDS)
21114 }
21115
21116 #[allow(unused_variables)]
21117 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
21118 where
21119 E: serde::de::Error,
21120 {
21121 match value {
21122 "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
21123 "tables" => Ok(GeneratedField::Tables),
21124 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
21125 }
21126 }
21127 }
21128 deserializer.deserialize_identifier(GeneratedVisitor)
21129 }
21130 }
21131 struct GeneratedVisitor;
21132 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
21133 type Value = WatermarkFilterNode;
21134
21135 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
21136 formatter.write_str("struct stream_plan.WatermarkFilterNode")
21137 }
21138
21139 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkFilterNode, V::Error>
21140 where
21141 V: serde::de::MapAccess<'de>,
21142 {
21143 let mut watermark_descs__ = None;
21144 let mut tables__ = None;
21145 while let Some(k) = map_.next_key()? {
21146 match k {
21147 GeneratedField::WatermarkDescs => {
21148 if watermark_descs__.is_some() {
21149 return Err(serde::de::Error::duplicate_field("watermarkDescs"));
21150 }
21151 watermark_descs__ = Some(map_.next_value()?);
21152 }
21153 GeneratedField::Tables => {
21154 if tables__.is_some() {
21155 return Err(serde::de::Error::duplicate_field("tables"));
21156 }
21157 tables__ = Some(map_.next_value()?);
21158 }
21159 }
21160 }
21161 Ok(WatermarkFilterNode {
21162 watermark_descs: watermark_descs__.unwrap_or_default(),
21163 tables: tables__.unwrap_or_default(),
21164 })
21165 }
21166 }
21167 deserializer.deserialize_struct("stream_plan.WatermarkFilterNode", FIELDS, GeneratedVisitor)
21168 }
21169}