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 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalityProviderNode", len)?;
8540 if !self.locality_columns.is_empty() {
8541 struct_ser.serialize_field("localityColumns", &self.locality_columns)?;
8542 }
8543 if let Some(v) = self.state_table.as_ref() {
8544 struct_ser.serialize_field("stateTable", v)?;
8545 }
8546 if let Some(v) = self.progress_table.as_ref() {
8547 struct_ser.serialize_field("progressTable", v)?;
8548 }
8549 if let Some(v) = self.rate_limit.as_ref() {
8550 struct_ser.serialize_field("rateLimit", v)?;
8551 }
8552 struct_ser.end()
8553 }
8554}
8555impl<'de> serde::Deserialize<'de> for LocalityProviderNode {
8556 #[allow(deprecated)]
8557 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8558 where
8559 D: serde::Deserializer<'de>,
8560 {
8561 const FIELDS: &[&str] = &[
8562 "locality_columns",
8563 "localityColumns",
8564 "state_table",
8565 "stateTable",
8566 "progress_table",
8567 "progressTable",
8568 "rate_limit",
8569 "rateLimit",
8570 ];
8571
8572 #[allow(clippy::enum_variant_names)]
8573 enum GeneratedField {
8574 LocalityColumns,
8575 StateTable,
8576 ProgressTable,
8577 RateLimit,
8578 }
8579 impl<'de> serde::Deserialize<'de> for GeneratedField {
8580 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8581 where
8582 D: serde::Deserializer<'de>,
8583 {
8584 struct GeneratedVisitor;
8585
8586 impl serde::de::Visitor<'_> for GeneratedVisitor {
8587 type Value = GeneratedField;
8588
8589 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8590 write!(formatter, "expected one of: {:?}", &FIELDS)
8591 }
8592
8593 #[allow(unused_variables)]
8594 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8595 where
8596 E: serde::de::Error,
8597 {
8598 match value {
8599 "localityColumns" | "locality_columns" => Ok(GeneratedField::LocalityColumns),
8600 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
8601 "progressTable" | "progress_table" => Ok(GeneratedField::ProgressTable),
8602 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
8603 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8604 }
8605 }
8606 }
8607 deserializer.deserialize_identifier(GeneratedVisitor)
8608 }
8609 }
8610 struct GeneratedVisitor;
8611 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8612 type Value = LocalityProviderNode;
8613
8614 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8615 formatter.write_str("struct stream_plan.LocalityProviderNode")
8616 }
8617
8618 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalityProviderNode, V::Error>
8619 where
8620 V: serde::de::MapAccess<'de>,
8621 {
8622 let mut locality_columns__ = None;
8623 let mut state_table__ = None;
8624 let mut progress_table__ = None;
8625 let mut rate_limit__ = None;
8626 while let Some(k) = map_.next_key()? {
8627 match k {
8628 GeneratedField::LocalityColumns => {
8629 if locality_columns__.is_some() {
8630 return Err(serde::de::Error::duplicate_field("localityColumns"));
8631 }
8632 locality_columns__ =
8633 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8634 .into_iter().map(|x| x.0).collect())
8635 ;
8636 }
8637 GeneratedField::StateTable => {
8638 if state_table__.is_some() {
8639 return Err(serde::de::Error::duplicate_field("stateTable"));
8640 }
8641 state_table__ = map_.next_value()?;
8642 }
8643 GeneratedField::ProgressTable => {
8644 if progress_table__.is_some() {
8645 return Err(serde::de::Error::duplicate_field("progressTable"));
8646 }
8647 progress_table__ = map_.next_value()?;
8648 }
8649 GeneratedField::RateLimit => {
8650 if rate_limit__.is_some() {
8651 return Err(serde::de::Error::duplicate_field("rateLimit"));
8652 }
8653 rate_limit__ =
8654 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
8655 ;
8656 }
8657 }
8658 }
8659 Ok(LocalityProviderNode {
8660 locality_columns: locality_columns__.unwrap_or_default(),
8661 state_table: state_table__,
8662 progress_table: progress_table__,
8663 rate_limit: rate_limit__,
8664 })
8665 }
8666 }
8667 deserializer.deserialize_struct("stream_plan.LocalityProviderNode", FIELDS, GeneratedVisitor)
8668 }
8669}
8670impl serde::Serialize for LookupNode {
8671 #[allow(deprecated)]
8672 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8673 where
8674 S: serde::Serializer,
8675 {
8676 use serde::ser::SerializeStruct;
8677 let mut len = 0;
8678 if !self.arrange_key.is_empty() {
8679 len += 1;
8680 }
8681 if !self.stream_key.is_empty() {
8682 len += 1;
8683 }
8684 if self.use_current_epoch {
8685 len += 1;
8686 }
8687 if !self.column_mapping.is_empty() {
8688 len += 1;
8689 }
8690 if self.arrangement_table_info.is_some() {
8691 len += 1;
8692 }
8693 if self.arrangement_table_id.is_some() {
8694 len += 1;
8695 }
8696 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupNode", len)?;
8697 if !self.arrange_key.is_empty() {
8698 struct_ser.serialize_field("arrangeKey", &self.arrange_key)?;
8699 }
8700 if !self.stream_key.is_empty() {
8701 struct_ser.serialize_field("streamKey", &self.stream_key)?;
8702 }
8703 if self.use_current_epoch {
8704 struct_ser.serialize_field("useCurrentEpoch", &self.use_current_epoch)?;
8705 }
8706 if !self.column_mapping.is_empty() {
8707 struct_ser.serialize_field("columnMapping", &self.column_mapping)?;
8708 }
8709 if let Some(v) = self.arrangement_table_info.as_ref() {
8710 struct_ser.serialize_field("arrangementTableInfo", v)?;
8711 }
8712 if let Some(v) = self.arrangement_table_id.as_ref() {
8713 match v {
8714 lookup_node::ArrangementTableId::TableId(v) => {
8715 struct_ser.serialize_field("tableId", v)?;
8716 }
8717 lookup_node::ArrangementTableId::IndexId(v) => {
8718 struct_ser.serialize_field("indexId", v)?;
8719 }
8720 }
8721 }
8722 struct_ser.end()
8723 }
8724}
8725impl<'de> serde::Deserialize<'de> for LookupNode {
8726 #[allow(deprecated)]
8727 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8728 where
8729 D: serde::Deserializer<'de>,
8730 {
8731 const FIELDS: &[&str] = &[
8732 "arrange_key",
8733 "arrangeKey",
8734 "stream_key",
8735 "streamKey",
8736 "use_current_epoch",
8737 "useCurrentEpoch",
8738 "column_mapping",
8739 "columnMapping",
8740 "arrangement_table_info",
8741 "arrangementTableInfo",
8742 "table_id",
8743 "tableId",
8744 "index_id",
8745 "indexId",
8746 ];
8747
8748 #[allow(clippy::enum_variant_names)]
8749 enum GeneratedField {
8750 ArrangeKey,
8751 StreamKey,
8752 UseCurrentEpoch,
8753 ColumnMapping,
8754 ArrangementTableInfo,
8755 TableId,
8756 IndexId,
8757 }
8758 impl<'de> serde::Deserialize<'de> for GeneratedField {
8759 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8760 where
8761 D: serde::Deserializer<'de>,
8762 {
8763 struct GeneratedVisitor;
8764
8765 impl serde::de::Visitor<'_> for GeneratedVisitor {
8766 type Value = GeneratedField;
8767
8768 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8769 write!(formatter, "expected one of: {:?}", &FIELDS)
8770 }
8771
8772 #[allow(unused_variables)]
8773 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8774 where
8775 E: serde::de::Error,
8776 {
8777 match value {
8778 "arrangeKey" | "arrange_key" => Ok(GeneratedField::ArrangeKey),
8779 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
8780 "useCurrentEpoch" | "use_current_epoch" => Ok(GeneratedField::UseCurrentEpoch),
8781 "columnMapping" | "column_mapping" => Ok(GeneratedField::ColumnMapping),
8782 "arrangementTableInfo" | "arrangement_table_info" => Ok(GeneratedField::ArrangementTableInfo),
8783 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8784 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
8785 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8786 }
8787 }
8788 }
8789 deserializer.deserialize_identifier(GeneratedVisitor)
8790 }
8791 }
8792 struct GeneratedVisitor;
8793 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8794 type Value = LookupNode;
8795
8796 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8797 formatter.write_str("struct stream_plan.LookupNode")
8798 }
8799
8800 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupNode, V::Error>
8801 where
8802 V: serde::de::MapAccess<'de>,
8803 {
8804 let mut arrange_key__ = None;
8805 let mut stream_key__ = None;
8806 let mut use_current_epoch__ = None;
8807 let mut column_mapping__ = None;
8808 let mut arrangement_table_info__ = None;
8809 let mut arrangement_table_id__ = None;
8810 while let Some(k) = map_.next_key()? {
8811 match k {
8812 GeneratedField::ArrangeKey => {
8813 if arrange_key__.is_some() {
8814 return Err(serde::de::Error::duplicate_field("arrangeKey"));
8815 }
8816 arrange_key__ =
8817 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8818 .into_iter().map(|x| x.0).collect())
8819 ;
8820 }
8821 GeneratedField::StreamKey => {
8822 if stream_key__.is_some() {
8823 return Err(serde::de::Error::duplicate_field("streamKey"));
8824 }
8825 stream_key__ =
8826 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8827 .into_iter().map(|x| x.0).collect())
8828 ;
8829 }
8830 GeneratedField::UseCurrentEpoch => {
8831 if use_current_epoch__.is_some() {
8832 return Err(serde::de::Error::duplicate_field("useCurrentEpoch"));
8833 }
8834 use_current_epoch__ = Some(map_.next_value()?);
8835 }
8836 GeneratedField::ColumnMapping => {
8837 if column_mapping__.is_some() {
8838 return Err(serde::de::Error::duplicate_field("columnMapping"));
8839 }
8840 column_mapping__ =
8841 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8842 .into_iter().map(|x| x.0).collect())
8843 ;
8844 }
8845 GeneratedField::ArrangementTableInfo => {
8846 if arrangement_table_info__.is_some() {
8847 return Err(serde::de::Error::duplicate_field("arrangementTableInfo"));
8848 }
8849 arrangement_table_info__ = map_.next_value()?;
8850 }
8851 GeneratedField::TableId => {
8852 if arrangement_table_id__.is_some() {
8853 return Err(serde::de::Error::duplicate_field("tableId"));
8854 }
8855 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::TableId(x.0));
8856 }
8857 GeneratedField::IndexId => {
8858 if arrangement_table_id__.is_some() {
8859 return Err(serde::de::Error::duplicate_field("indexId"));
8860 }
8861 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::IndexId(x.0));
8862 }
8863 }
8864 }
8865 Ok(LookupNode {
8866 arrange_key: arrange_key__.unwrap_or_default(),
8867 stream_key: stream_key__.unwrap_or_default(),
8868 use_current_epoch: use_current_epoch__.unwrap_or_default(),
8869 column_mapping: column_mapping__.unwrap_or_default(),
8870 arrangement_table_info: arrangement_table_info__,
8871 arrangement_table_id: arrangement_table_id__,
8872 })
8873 }
8874 }
8875 deserializer.deserialize_struct("stream_plan.LookupNode", FIELDS, GeneratedVisitor)
8876 }
8877}
8878impl serde::Serialize for LookupUnionNode {
8879 #[allow(deprecated)]
8880 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8881 where
8882 S: serde::Serializer,
8883 {
8884 use serde::ser::SerializeStruct;
8885 let mut len = 0;
8886 if !self.order.is_empty() {
8887 len += 1;
8888 }
8889 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupUnionNode", len)?;
8890 if !self.order.is_empty() {
8891 struct_ser.serialize_field("order", &self.order)?;
8892 }
8893 struct_ser.end()
8894 }
8895}
8896impl<'de> serde::Deserialize<'de> for LookupUnionNode {
8897 #[allow(deprecated)]
8898 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8899 where
8900 D: serde::Deserializer<'de>,
8901 {
8902 const FIELDS: &[&str] = &[
8903 "order",
8904 ];
8905
8906 #[allow(clippy::enum_variant_names)]
8907 enum GeneratedField {
8908 Order,
8909 }
8910 impl<'de> serde::Deserialize<'de> for GeneratedField {
8911 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8912 where
8913 D: serde::Deserializer<'de>,
8914 {
8915 struct GeneratedVisitor;
8916
8917 impl serde::de::Visitor<'_> for GeneratedVisitor {
8918 type Value = GeneratedField;
8919
8920 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8921 write!(formatter, "expected one of: {:?}", &FIELDS)
8922 }
8923
8924 #[allow(unused_variables)]
8925 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8926 where
8927 E: serde::de::Error,
8928 {
8929 match value {
8930 "order" => Ok(GeneratedField::Order),
8931 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8932 }
8933 }
8934 }
8935 deserializer.deserialize_identifier(GeneratedVisitor)
8936 }
8937 }
8938 struct GeneratedVisitor;
8939 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8940 type Value = LookupUnionNode;
8941
8942 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8943 formatter.write_str("struct stream_plan.LookupUnionNode")
8944 }
8945
8946 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupUnionNode, V::Error>
8947 where
8948 V: serde::de::MapAccess<'de>,
8949 {
8950 let mut order__ = None;
8951 while let Some(k) = map_.next_key()? {
8952 match k {
8953 GeneratedField::Order => {
8954 if order__.is_some() {
8955 return Err(serde::de::Error::duplicate_field("order"));
8956 }
8957 order__ =
8958 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8959 .into_iter().map(|x| x.0).collect())
8960 ;
8961 }
8962 }
8963 }
8964 Ok(LookupUnionNode {
8965 order: order__.unwrap_or_default(),
8966 })
8967 }
8968 }
8969 deserializer.deserialize_struct("stream_plan.LookupUnionNode", FIELDS, GeneratedVisitor)
8970 }
8971}
8972impl serde::Serialize for MatchRecognizeAfterMatchSkip {
8973 #[allow(deprecated)]
8974 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8975 where
8976 S: serde::Serializer,
8977 {
8978 use serde::ser::SerializeStruct;
8979 let mut len = 0;
8980 if self.mode != 0 {
8981 len += 1;
8982 }
8983 if self.target.is_some() {
8984 len += 1;
8985 }
8986 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeAfterMatchSkip", len)?;
8987 if self.mode != 0 {
8988 let v = match_recognize_after_match_skip::Mode::try_from(self.mode)
8989 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.mode)))?;
8990 struct_ser.serialize_field("mode", &v)?;
8991 }
8992 if let Some(v) = self.target.as_ref() {
8993 struct_ser.serialize_field("target", v)?;
8994 }
8995 struct_ser.end()
8996 }
8997}
8998impl<'de> serde::Deserialize<'de> for MatchRecognizeAfterMatchSkip {
8999 #[allow(deprecated)]
9000 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9001 where
9002 D: serde::Deserializer<'de>,
9003 {
9004 const FIELDS: &[&str] = &[
9005 "mode",
9006 "target",
9007 ];
9008
9009 #[allow(clippy::enum_variant_names)]
9010 enum GeneratedField {
9011 Mode,
9012 Target,
9013 }
9014 impl<'de> serde::Deserialize<'de> for GeneratedField {
9015 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9016 where
9017 D: serde::Deserializer<'de>,
9018 {
9019 struct GeneratedVisitor;
9020
9021 impl serde::de::Visitor<'_> for GeneratedVisitor {
9022 type Value = GeneratedField;
9023
9024 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9025 write!(formatter, "expected one of: {:?}", &FIELDS)
9026 }
9027
9028 #[allow(unused_variables)]
9029 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9030 where
9031 E: serde::de::Error,
9032 {
9033 match value {
9034 "mode" => Ok(GeneratedField::Mode),
9035 "target" => Ok(GeneratedField::Target),
9036 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9037 }
9038 }
9039 }
9040 deserializer.deserialize_identifier(GeneratedVisitor)
9041 }
9042 }
9043 struct GeneratedVisitor;
9044 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9045 type Value = MatchRecognizeAfterMatchSkip;
9046
9047 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9048 formatter.write_str("struct stream_plan.MatchRecognizeAfterMatchSkip")
9049 }
9050
9051 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeAfterMatchSkip, V::Error>
9052 where
9053 V: serde::de::MapAccess<'de>,
9054 {
9055 let mut mode__ = None;
9056 let mut target__ = None;
9057 while let Some(k) = map_.next_key()? {
9058 match k {
9059 GeneratedField::Mode => {
9060 if mode__.is_some() {
9061 return Err(serde::de::Error::duplicate_field("mode"));
9062 }
9063 mode__ = Some(map_.next_value::<match_recognize_after_match_skip::Mode>()? as i32);
9064 }
9065 GeneratedField::Target => {
9066 if target__.is_some() {
9067 return Err(serde::de::Error::duplicate_field("target"));
9068 }
9069 target__ = map_.next_value()?;
9070 }
9071 }
9072 }
9073 Ok(MatchRecognizeAfterMatchSkip {
9074 mode: mode__.unwrap_or_default(),
9075 target: target__,
9076 })
9077 }
9078 }
9079 deserializer.deserialize_struct("stream_plan.MatchRecognizeAfterMatchSkip", FIELDS, GeneratedVisitor)
9080 }
9081}
9082impl serde::Serialize for match_recognize_after_match_skip::Mode {
9083 #[allow(deprecated)]
9084 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9085 where
9086 S: serde::Serializer,
9087 {
9088 let variant = match self {
9089 Self::Unspecified => "MODE_UNSPECIFIED",
9090 Self::PastLastRow => "MODE_PAST_LAST_ROW",
9091 Self::ToNextRow => "MODE_TO_NEXT_ROW",
9092 Self::ToFirst => "MODE_TO_FIRST",
9093 Self::ToLast => "MODE_TO_LAST",
9094 };
9095 serializer.serialize_str(variant)
9096 }
9097}
9098impl<'de> serde::Deserialize<'de> for match_recognize_after_match_skip::Mode {
9099 #[allow(deprecated)]
9100 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9101 where
9102 D: serde::Deserializer<'de>,
9103 {
9104 const FIELDS: &[&str] = &[
9105 "MODE_UNSPECIFIED",
9106 "MODE_PAST_LAST_ROW",
9107 "MODE_TO_NEXT_ROW",
9108 "MODE_TO_FIRST",
9109 "MODE_TO_LAST",
9110 ];
9111
9112 struct GeneratedVisitor;
9113
9114 impl serde::de::Visitor<'_> for GeneratedVisitor {
9115 type Value = match_recognize_after_match_skip::Mode;
9116
9117 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9118 write!(formatter, "expected one of: {:?}", &FIELDS)
9119 }
9120
9121 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9122 where
9123 E: serde::de::Error,
9124 {
9125 i32::try_from(v)
9126 .ok()
9127 .and_then(|x| x.try_into().ok())
9128 .ok_or_else(|| {
9129 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9130 })
9131 }
9132
9133 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9134 where
9135 E: serde::de::Error,
9136 {
9137 i32::try_from(v)
9138 .ok()
9139 .and_then(|x| x.try_into().ok())
9140 .ok_or_else(|| {
9141 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9142 })
9143 }
9144
9145 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9146 where
9147 E: serde::de::Error,
9148 {
9149 match value {
9150 "MODE_UNSPECIFIED" => Ok(match_recognize_after_match_skip::Mode::Unspecified),
9151 "MODE_PAST_LAST_ROW" => Ok(match_recognize_after_match_skip::Mode::PastLastRow),
9152 "MODE_TO_NEXT_ROW" => Ok(match_recognize_after_match_skip::Mode::ToNextRow),
9153 "MODE_TO_FIRST" => Ok(match_recognize_after_match_skip::Mode::ToFirst),
9154 "MODE_TO_LAST" => Ok(match_recognize_after_match_skip::Mode::ToLast),
9155 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9156 }
9157 }
9158 }
9159 deserializer.deserialize_any(GeneratedVisitor)
9160 }
9161}
9162impl serde::Serialize for MatchRecognizeDefine {
9163 #[allow(deprecated)]
9164 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9165 where
9166 S: serde::Serializer,
9167 {
9168 use serde::ser::SerializeStruct;
9169 let mut len = 0;
9170 if !self.symbol.is_empty() {
9171 len += 1;
9172 }
9173 if self.condition.is_some() {
9174 len += 1;
9175 }
9176 if !self.slots.is_empty() {
9177 len += 1;
9178 }
9179 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeDefine", len)?;
9180 if !self.symbol.is_empty() {
9181 struct_ser.serialize_field("symbol", &self.symbol)?;
9182 }
9183 if let Some(v) = self.condition.as_ref() {
9184 struct_ser.serialize_field("condition", v)?;
9185 }
9186 if !self.slots.is_empty() {
9187 struct_ser.serialize_field("slots", &self.slots)?;
9188 }
9189 struct_ser.end()
9190 }
9191}
9192impl<'de> serde::Deserialize<'de> for MatchRecognizeDefine {
9193 #[allow(deprecated)]
9194 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9195 where
9196 D: serde::Deserializer<'de>,
9197 {
9198 const FIELDS: &[&str] = &[
9199 "symbol",
9200 "condition",
9201 "slots",
9202 ];
9203
9204 #[allow(clippy::enum_variant_names)]
9205 enum GeneratedField {
9206 Symbol,
9207 Condition,
9208 Slots,
9209 }
9210 impl<'de> serde::Deserialize<'de> for GeneratedField {
9211 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9212 where
9213 D: serde::Deserializer<'de>,
9214 {
9215 struct GeneratedVisitor;
9216
9217 impl serde::de::Visitor<'_> for GeneratedVisitor {
9218 type Value = GeneratedField;
9219
9220 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9221 write!(formatter, "expected one of: {:?}", &FIELDS)
9222 }
9223
9224 #[allow(unused_variables)]
9225 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9226 where
9227 E: serde::de::Error,
9228 {
9229 match value {
9230 "symbol" => Ok(GeneratedField::Symbol),
9231 "condition" => Ok(GeneratedField::Condition),
9232 "slots" => Ok(GeneratedField::Slots),
9233 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9234 }
9235 }
9236 }
9237 deserializer.deserialize_identifier(GeneratedVisitor)
9238 }
9239 }
9240 struct GeneratedVisitor;
9241 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9242 type Value = MatchRecognizeDefine;
9243
9244 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9245 formatter.write_str("struct stream_plan.MatchRecognizeDefine")
9246 }
9247
9248 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeDefine, V::Error>
9249 where
9250 V: serde::de::MapAccess<'de>,
9251 {
9252 let mut symbol__ = None;
9253 let mut condition__ = None;
9254 let mut slots__ = None;
9255 while let Some(k) = map_.next_key()? {
9256 match k {
9257 GeneratedField::Symbol => {
9258 if symbol__.is_some() {
9259 return Err(serde::de::Error::duplicate_field("symbol"));
9260 }
9261 symbol__ = Some(map_.next_value()?);
9262 }
9263 GeneratedField::Condition => {
9264 if condition__.is_some() {
9265 return Err(serde::de::Error::duplicate_field("condition"));
9266 }
9267 condition__ = map_.next_value()?;
9268 }
9269 GeneratedField::Slots => {
9270 if slots__.is_some() {
9271 return Err(serde::de::Error::duplicate_field("slots"));
9272 }
9273 slots__ = Some(map_.next_value()?);
9274 }
9275 }
9276 }
9277 Ok(MatchRecognizeDefine {
9278 symbol: symbol__.unwrap_or_default(),
9279 condition: condition__,
9280 slots: slots__.unwrap_or_default(),
9281 })
9282 }
9283 }
9284 deserializer.deserialize_struct("stream_plan.MatchRecognizeDefine", FIELDS, GeneratedVisitor)
9285 }
9286}
9287impl serde::Serialize for MatchRecognizeDefineSlot {
9288 #[allow(deprecated)]
9289 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9290 where
9291 S: serde::Serializer,
9292 {
9293 use serde::ser::SerializeStruct;
9294 let mut len = 0;
9295 if self.kind != 0 {
9296 len += 1;
9297 }
9298 if !self.vars.is_empty() {
9299 len += 1;
9300 }
9301 if self.col_idx != 0 {
9302 len += 1;
9303 }
9304 if self.offset != 0 {
9305 len += 1;
9306 }
9307 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeDefineSlot", len)?;
9308 if self.kind != 0 {
9309 let v = match_recognize_define_slot::Kind::try_from(self.kind)
9310 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
9311 struct_ser.serialize_field("kind", &v)?;
9312 }
9313 if !self.vars.is_empty() {
9314 struct_ser.serialize_field("vars", &self.vars)?;
9315 }
9316 if self.col_idx != 0 {
9317 struct_ser.serialize_field("colIdx", &self.col_idx)?;
9318 }
9319 if self.offset != 0 {
9320 struct_ser.serialize_field("offset", &self.offset)?;
9321 }
9322 struct_ser.end()
9323 }
9324}
9325impl<'de> serde::Deserialize<'de> for MatchRecognizeDefineSlot {
9326 #[allow(deprecated)]
9327 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9328 where
9329 D: serde::Deserializer<'de>,
9330 {
9331 const FIELDS: &[&str] = &[
9332 "kind",
9333 "vars",
9334 "col_idx",
9335 "colIdx",
9336 "offset",
9337 ];
9338
9339 #[allow(clippy::enum_variant_names)]
9340 enum GeneratedField {
9341 Kind,
9342 Vars,
9343 ColIdx,
9344 Offset,
9345 }
9346 impl<'de> serde::Deserialize<'de> for GeneratedField {
9347 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9348 where
9349 D: serde::Deserializer<'de>,
9350 {
9351 struct GeneratedVisitor;
9352
9353 impl serde::de::Visitor<'_> for GeneratedVisitor {
9354 type Value = GeneratedField;
9355
9356 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9357 write!(formatter, "expected one of: {:?}", &FIELDS)
9358 }
9359
9360 #[allow(unused_variables)]
9361 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9362 where
9363 E: serde::de::Error,
9364 {
9365 match value {
9366 "kind" => Ok(GeneratedField::Kind),
9367 "vars" => Ok(GeneratedField::Vars),
9368 "colIdx" | "col_idx" => Ok(GeneratedField::ColIdx),
9369 "offset" => Ok(GeneratedField::Offset),
9370 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9371 }
9372 }
9373 }
9374 deserializer.deserialize_identifier(GeneratedVisitor)
9375 }
9376 }
9377 struct GeneratedVisitor;
9378 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9379 type Value = MatchRecognizeDefineSlot;
9380
9381 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9382 formatter.write_str("struct stream_plan.MatchRecognizeDefineSlot")
9383 }
9384
9385 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeDefineSlot, V::Error>
9386 where
9387 V: serde::de::MapAccess<'de>,
9388 {
9389 let mut kind__ = None;
9390 let mut vars__ = None;
9391 let mut col_idx__ = None;
9392 let mut offset__ = None;
9393 while let Some(k) = map_.next_key()? {
9394 match k {
9395 GeneratedField::Kind => {
9396 if kind__.is_some() {
9397 return Err(serde::de::Error::duplicate_field("kind"));
9398 }
9399 kind__ = Some(map_.next_value::<match_recognize_define_slot::Kind>()? as i32);
9400 }
9401 GeneratedField::Vars => {
9402 if vars__.is_some() {
9403 return Err(serde::de::Error::duplicate_field("vars"));
9404 }
9405 vars__ = Some(map_.next_value()?);
9406 }
9407 GeneratedField::ColIdx => {
9408 if col_idx__.is_some() {
9409 return Err(serde::de::Error::duplicate_field("colIdx"));
9410 }
9411 col_idx__ =
9412 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9413 ;
9414 }
9415 GeneratedField::Offset => {
9416 if offset__.is_some() {
9417 return Err(serde::de::Error::duplicate_field("offset"));
9418 }
9419 offset__ =
9420 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9421 ;
9422 }
9423 }
9424 }
9425 Ok(MatchRecognizeDefineSlot {
9426 kind: kind__.unwrap_or_default(),
9427 vars: vars__.unwrap_or_default(),
9428 col_idx: col_idx__.unwrap_or_default(),
9429 offset: offset__.unwrap_or_default(),
9430 })
9431 }
9432 }
9433 deserializer.deserialize_struct("stream_plan.MatchRecognizeDefineSlot", FIELDS, GeneratedVisitor)
9434 }
9435}
9436impl serde::Serialize for match_recognize_define_slot::Kind {
9437 #[allow(deprecated)]
9438 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9439 where
9440 S: serde::Serializer,
9441 {
9442 let variant = match self {
9443 Self::Unspecified => "KIND_UNSPECIFIED",
9444 Self::SelfCol => "KIND_SELF_COL",
9445 Self::Prev => "KIND_PREV",
9446 Self::Next => "KIND_NEXT",
9447 Self::RunningFirst => "KIND_RUNNING_FIRST",
9448 Self::RunningLast => "KIND_RUNNING_LAST",
9449 };
9450 serializer.serialize_str(variant)
9451 }
9452}
9453impl<'de> serde::Deserialize<'de> for match_recognize_define_slot::Kind {
9454 #[allow(deprecated)]
9455 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9456 where
9457 D: serde::Deserializer<'de>,
9458 {
9459 const FIELDS: &[&str] = &[
9460 "KIND_UNSPECIFIED",
9461 "KIND_SELF_COL",
9462 "KIND_PREV",
9463 "KIND_NEXT",
9464 "KIND_RUNNING_FIRST",
9465 "KIND_RUNNING_LAST",
9466 ];
9467
9468 struct GeneratedVisitor;
9469
9470 impl serde::de::Visitor<'_> for GeneratedVisitor {
9471 type Value = match_recognize_define_slot::Kind;
9472
9473 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9474 write!(formatter, "expected one of: {:?}", &FIELDS)
9475 }
9476
9477 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9478 where
9479 E: serde::de::Error,
9480 {
9481 i32::try_from(v)
9482 .ok()
9483 .and_then(|x| x.try_into().ok())
9484 .ok_or_else(|| {
9485 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9486 })
9487 }
9488
9489 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9490 where
9491 E: serde::de::Error,
9492 {
9493 i32::try_from(v)
9494 .ok()
9495 .and_then(|x| x.try_into().ok())
9496 .ok_or_else(|| {
9497 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9498 })
9499 }
9500
9501 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9502 where
9503 E: serde::de::Error,
9504 {
9505 match value {
9506 "KIND_UNSPECIFIED" => Ok(match_recognize_define_slot::Kind::Unspecified),
9507 "KIND_SELF_COL" => Ok(match_recognize_define_slot::Kind::SelfCol),
9508 "KIND_PREV" => Ok(match_recognize_define_slot::Kind::Prev),
9509 "KIND_NEXT" => Ok(match_recognize_define_slot::Kind::Next),
9510 "KIND_RUNNING_FIRST" => Ok(match_recognize_define_slot::Kind::RunningFirst),
9511 "KIND_RUNNING_LAST" => Ok(match_recognize_define_slot::Kind::RunningLast),
9512 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9513 }
9514 }
9515 }
9516 deserializer.deserialize_any(GeneratedVisitor)
9517 }
9518}
9519impl serde::Serialize for MatchRecognizeInputMode {
9520 #[allow(deprecated)]
9521 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9522 where
9523 S: serde::Serializer,
9524 {
9525 let variant = match self {
9526 Self::Unspecified => "MATCH_RECOGNIZE_INPUT_MODE_UNSPECIFIED",
9527 Self::EventTime => "MATCH_RECOGNIZE_INPUT_MODE_EVENT_TIME",
9528 Self::ProcessingTime => "MATCH_RECOGNIZE_INPUT_MODE_PROCESSING_TIME",
9529 };
9530 serializer.serialize_str(variant)
9531 }
9532}
9533impl<'de> serde::Deserialize<'de> for MatchRecognizeInputMode {
9534 #[allow(deprecated)]
9535 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9536 where
9537 D: serde::Deserializer<'de>,
9538 {
9539 const FIELDS: &[&str] = &[
9540 "MATCH_RECOGNIZE_INPUT_MODE_UNSPECIFIED",
9541 "MATCH_RECOGNIZE_INPUT_MODE_EVENT_TIME",
9542 "MATCH_RECOGNIZE_INPUT_MODE_PROCESSING_TIME",
9543 ];
9544
9545 struct GeneratedVisitor;
9546
9547 impl serde::de::Visitor<'_> for GeneratedVisitor {
9548 type Value = MatchRecognizeInputMode;
9549
9550 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9551 write!(formatter, "expected one of: {:?}", &FIELDS)
9552 }
9553
9554 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9555 where
9556 E: serde::de::Error,
9557 {
9558 i32::try_from(v)
9559 .ok()
9560 .and_then(|x| x.try_into().ok())
9561 .ok_or_else(|| {
9562 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9563 })
9564 }
9565
9566 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9567 where
9568 E: serde::de::Error,
9569 {
9570 i32::try_from(v)
9571 .ok()
9572 .and_then(|x| x.try_into().ok())
9573 .ok_or_else(|| {
9574 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9575 })
9576 }
9577
9578 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9579 where
9580 E: serde::de::Error,
9581 {
9582 match value {
9583 "MATCH_RECOGNIZE_INPUT_MODE_UNSPECIFIED" => Ok(MatchRecognizeInputMode::Unspecified),
9584 "MATCH_RECOGNIZE_INPUT_MODE_EVENT_TIME" => Ok(MatchRecognizeInputMode::EventTime),
9585 "MATCH_RECOGNIZE_INPUT_MODE_PROCESSING_TIME" => Ok(MatchRecognizeInputMode::ProcessingTime),
9586 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9587 }
9588 }
9589 }
9590 deserializer.deserialize_any(GeneratedVisitor)
9591 }
9592}
9593impl serde::Serialize for MatchRecognizeMeasure {
9594 #[allow(deprecated)]
9595 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9596 where
9597 S: serde::Serializer,
9598 {
9599 use serde::ser::SerializeStruct;
9600 let mut len = 0;
9601 if self.expr.is_some() {
9602 len += 1;
9603 }
9604 if !self.name.is_empty() {
9605 len += 1;
9606 }
9607 if !self.slots.is_empty() {
9608 len += 1;
9609 }
9610 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeMeasure", len)?;
9611 if let Some(v) = self.expr.as_ref() {
9612 struct_ser.serialize_field("expr", v)?;
9613 }
9614 if !self.name.is_empty() {
9615 struct_ser.serialize_field("name", &self.name)?;
9616 }
9617 if !self.slots.is_empty() {
9618 struct_ser.serialize_field("slots", &self.slots)?;
9619 }
9620 struct_ser.end()
9621 }
9622}
9623impl<'de> serde::Deserialize<'de> for MatchRecognizeMeasure {
9624 #[allow(deprecated)]
9625 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9626 where
9627 D: serde::Deserializer<'de>,
9628 {
9629 const FIELDS: &[&str] = &[
9630 "expr",
9631 "name",
9632 "slots",
9633 ];
9634
9635 #[allow(clippy::enum_variant_names)]
9636 enum GeneratedField {
9637 Expr,
9638 Name,
9639 Slots,
9640 }
9641 impl<'de> serde::Deserialize<'de> for GeneratedField {
9642 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9643 where
9644 D: serde::Deserializer<'de>,
9645 {
9646 struct GeneratedVisitor;
9647
9648 impl serde::de::Visitor<'_> for GeneratedVisitor {
9649 type Value = GeneratedField;
9650
9651 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9652 write!(formatter, "expected one of: {:?}", &FIELDS)
9653 }
9654
9655 #[allow(unused_variables)]
9656 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9657 where
9658 E: serde::de::Error,
9659 {
9660 match value {
9661 "expr" => Ok(GeneratedField::Expr),
9662 "name" => Ok(GeneratedField::Name),
9663 "slots" => Ok(GeneratedField::Slots),
9664 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9665 }
9666 }
9667 }
9668 deserializer.deserialize_identifier(GeneratedVisitor)
9669 }
9670 }
9671 struct GeneratedVisitor;
9672 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9673 type Value = MatchRecognizeMeasure;
9674
9675 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9676 formatter.write_str("struct stream_plan.MatchRecognizeMeasure")
9677 }
9678
9679 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeMeasure, V::Error>
9680 where
9681 V: serde::de::MapAccess<'de>,
9682 {
9683 let mut expr__ = None;
9684 let mut name__ = None;
9685 let mut slots__ = None;
9686 while let Some(k) = map_.next_key()? {
9687 match k {
9688 GeneratedField::Expr => {
9689 if expr__.is_some() {
9690 return Err(serde::de::Error::duplicate_field("expr"));
9691 }
9692 expr__ = map_.next_value()?;
9693 }
9694 GeneratedField::Name => {
9695 if name__.is_some() {
9696 return Err(serde::de::Error::duplicate_field("name"));
9697 }
9698 name__ = Some(map_.next_value()?);
9699 }
9700 GeneratedField::Slots => {
9701 if slots__.is_some() {
9702 return Err(serde::de::Error::duplicate_field("slots"));
9703 }
9704 slots__ = Some(map_.next_value()?);
9705 }
9706 }
9707 }
9708 Ok(MatchRecognizeMeasure {
9709 expr: expr__,
9710 name: name__.unwrap_or_default(),
9711 slots: slots__.unwrap_or_default(),
9712 })
9713 }
9714 }
9715 deserializer.deserialize_struct("stream_plan.MatchRecognizeMeasure", FIELDS, GeneratedVisitor)
9716 }
9717}
9718impl serde::Serialize for MatchRecognizeMeasureSlot {
9719 #[allow(deprecated)]
9720 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9721 where
9722 S: serde::Serializer,
9723 {
9724 use serde::ser::SerializeStruct;
9725 let mut len = 0;
9726 if self.kind != 0 {
9727 len += 1;
9728 }
9729 if !self.vars.is_empty() {
9730 len += 1;
9731 }
9732 if self.col_idx != 0 {
9733 len += 1;
9734 }
9735 if self.data_type.is_some() {
9736 len += 1;
9737 }
9738 if self.agg_call.is_some() {
9739 len += 1;
9740 }
9741 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeMeasureSlot", len)?;
9742 if self.kind != 0 {
9743 let v = match_recognize_measure_slot::Kind::try_from(self.kind)
9744 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
9745 struct_ser.serialize_field("kind", &v)?;
9746 }
9747 if !self.vars.is_empty() {
9748 struct_ser.serialize_field("vars", &self.vars)?;
9749 }
9750 if self.col_idx != 0 {
9751 struct_ser.serialize_field("colIdx", &self.col_idx)?;
9752 }
9753 if let Some(v) = self.data_type.as_ref() {
9754 struct_ser.serialize_field("dataType", v)?;
9755 }
9756 if let Some(v) = self.agg_call.as_ref() {
9757 struct_ser.serialize_field("aggCall", v)?;
9758 }
9759 struct_ser.end()
9760 }
9761}
9762impl<'de> serde::Deserialize<'de> for MatchRecognizeMeasureSlot {
9763 #[allow(deprecated)]
9764 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9765 where
9766 D: serde::Deserializer<'de>,
9767 {
9768 const FIELDS: &[&str] = &[
9769 "kind",
9770 "vars",
9771 "col_idx",
9772 "colIdx",
9773 "data_type",
9774 "dataType",
9775 "agg_call",
9776 "aggCall",
9777 ];
9778
9779 #[allow(clippy::enum_variant_names)]
9780 enum GeneratedField {
9781 Kind,
9782 Vars,
9783 ColIdx,
9784 DataType,
9785 AggCall,
9786 }
9787 impl<'de> serde::Deserialize<'de> for GeneratedField {
9788 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9789 where
9790 D: serde::Deserializer<'de>,
9791 {
9792 struct GeneratedVisitor;
9793
9794 impl serde::de::Visitor<'_> for GeneratedVisitor {
9795 type Value = GeneratedField;
9796
9797 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9798 write!(formatter, "expected one of: {:?}", &FIELDS)
9799 }
9800
9801 #[allow(unused_variables)]
9802 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9803 where
9804 E: serde::de::Error,
9805 {
9806 match value {
9807 "kind" => Ok(GeneratedField::Kind),
9808 "vars" => Ok(GeneratedField::Vars),
9809 "colIdx" | "col_idx" => Ok(GeneratedField::ColIdx),
9810 "dataType" | "data_type" => Ok(GeneratedField::DataType),
9811 "aggCall" | "agg_call" => Ok(GeneratedField::AggCall),
9812 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9813 }
9814 }
9815 }
9816 deserializer.deserialize_identifier(GeneratedVisitor)
9817 }
9818 }
9819 struct GeneratedVisitor;
9820 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9821 type Value = MatchRecognizeMeasureSlot;
9822
9823 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9824 formatter.write_str("struct stream_plan.MatchRecognizeMeasureSlot")
9825 }
9826
9827 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeMeasureSlot, V::Error>
9828 where
9829 V: serde::de::MapAccess<'de>,
9830 {
9831 let mut kind__ = None;
9832 let mut vars__ = None;
9833 let mut col_idx__ = None;
9834 let mut data_type__ = None;
9835 let mut agg_call__ = None;
9836 while let Some(k) = map_.next_key()? {
9837 match k {
9838 GeneratedField::Kind => {
9839 if kind__.is_some() {
9840 return Err(serde::de::Error::duplicate_field("kind"));
9841 }
9842 kind__ = Some(map_.next_value::<match_recognize_measure_slot::Kind>()? as i32);
9843 }
9844 GeneratedField::Vars => {
9845 if vars__.is_some() {
9846 return Err(serde::de::Error::duplicate_field("vars"));
9847 }
9848 vars__ = Some(map_.next_value()?);
9849 }
9850 GeneratedField::ColIdx => {
9851 if col_idx__.is_some() {
9852 return Err(serde::de::Error::duplicate_field("colIdx"));
9853 }
9854 col_idx__ =
9855 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9856 ;
9857 }
9858 GeneratedField::DataType => {
9859 if data_type__.is_some() {
9860 return Err(serde::de::Error::duplicate_field("dataType"));
9861 }
9862 data_type__ = map_.next_value()?;
9863 }
9864 GeneratedField::AggCall => {
9865 if agg_call__.is_some() {
9866 return Err(serde::de::Error::duplicate_field("aggCall"));
9867 }
9868 agg_call__ = map_.next_value()?;
9869 }
9870 }
9871 }
9872 Ok(MatchRecognizeMeasureSlot {
9873 kind: kind__.unwrap_or_default(),
9874 vars: vars__.unwrap_or_default(),
9875 col_idx: col_idx__.unwrap_or_default(),
9876 data_type: data_type__,
9877 agg_call: agg_call__,
9878 })
9879 }
9880 }
9881 deserializer.deserialize_struct("stream_plan.MatchRecognizeMeasureSlot", FIELDS, GeneratedVisitor)
9882 }
9883}
9884impl serde::Serialize for match_recognize_measure_slot::Kind {
9885 #[allow(deprecated)]
9886 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9887 where
9888 S: serde::Serializer,
9889 {
9890 let variant = match self {
9891 Self::Unspecified => "KIND_UNSPECIFIED",
9892 Self::Last => "KIND_LAST",
9893 Self::First => "KIND_FIRST",
9894 Self::Classifier => "KIND_CLASSIFIER",
9895 Self::CountStar => "KIND_COUNT_STAR",
9896 Self::Count => "KIND_COUNT",
9897 Self::Min => "KIND_MIN",
9898 Self::Max => "KIND_MAX",
9899 Self::Sum => "KIND_SUM",
9900 };
9901 serializer.serialize_str(variant)
9902 }
9903}
9904impl<'de> serde::Deserialize<'de> for match_recognize_measure_slot::Kind {
9905 #[allow(deprecated)]
9906 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9907 where
9908 D: serde::Deserializer<'de>,
9909 {
9910 const FIELDS: &[&str] = &[
9911 "KIND_UNSPECIFIED",
9912 "KIND_LAST",
9913 "KIND_FIRST",
9914 "KIND_CLASSIFIER",
9915 "KIND_COUNT_STAR",
9916 "KIND_COUNT",
9917 "KIND_MIN",
9918 "KIND_MAX",
9919 "KIND_SUM",
9920 ];
9921
9922 struct GeneratedVisitor;
9923
9924 impl serde::de::Visitor<'_> for GeneratedVisitor {
9925 type Value = match_recognize_measure_slot::Kind;
9926
9927 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9928 write!(formatter, "expected one of: {:?}", &FIELDS)
9929 }
9930
9931 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9932 where
9933 E: serde::de::Error,
9934 {
9935 i32::try_from(v)
9936 .ok()
9937 .and_then(|x| x.try_into().ok())
9938 .ok_or_else(|| {
9939 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9940 })
9941 }
9942
9943 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9944 where
9945 E: serde::de::Error,
9946 {
9947 i32::try_from(v)
9948 .ok()
9949 .and_then(|x| x.try_into().ok())
9950 .ok_or_else(|| {
9951 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9952 })
9953 }
9954
9955 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9956 where
9957 E: serde::de::Error,
9958 {
9959 match value {
9960 "KIND_UNSPECIFIED" => Ok(match_recognize_measure_slot::Kind::Unspecified),
9961 "KIND_LAST" => Ok(match_recognize_measure_slot::Kind::Last),
9962 "KIND_FIRST" => Ok(match_recognize_measure_slot::Kind::First),
9963 "KIND_CLASSIFIER" => Ok(match_recognize_measure_slot::Kind::Classifier),
9964 "KIND_COUNT_STAR" => Ok(match_recognize_measure_slot::Kind::CountStar),
9965 "KIND_COUNT" => Ok(match_recognize_measure_slot::Kind::Count),
9966 "KIND_MIN" => Ok(match_recognize_measure_slot::Kind::Min),
9967 "KIND_MAX" => Ok(match_recognize_measure_slot::Kind::Max),
9968 "KIND_SUM" => Ok(match_recognize_measure_slot::Kind::Sum),
9969 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9970 }
9971 }
9972 }
9973 deserializer.deserialize_any(GeneratedVisitor)
9974 }
9975}
9976impl serde::Serialize for MatchRecognizeNode {
9977 #[allow(deprecated)]
9978 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9979 where
9980 S: serde::Serializer,
9981 {
9982 use serde::ser::SerializeStruct;
9983 let mut len = 0;
9984 if !self.partition_by.is_empty() {
9985 len += 1;
9986 }
9987 if !self.order_by.is_empty() {
9988 len += 1;
9989 }
9990 if !self.measures.is_empty() {
9991 len += 1;
9992 }
9993 if !self.defines.is_empty() {
9994 len += 1;
9995 }
9996 if self.pattern_node.is_some() {
9997 len += 1;
9998 }
9999 if self.state_table.is_some() {
10000 len += 1;
10001 }
10002 if self.after_match_skip.is_some() {
10003 len += 1;
10004 }
10005 if self.within.is_some() {
10006 len += 1;
10007 }
10008 if self.within_deadline.is_some() {
10009 len += 1;
10010 }
10011 if self.input_mode != 0 {
10012 len += 1;
10013 }
10014 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeNode", len)?;
10015 if !self.partition_by.is_empty() {
10016 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
10017 }
10018 if !self.order_by.is_empty() {
10019 struct_ser.serialize_field("orderBy", &self.order_by)?;
10020 }
10021 if !self.measures.is_empty() {
10022 struct_ser.serialize_field("measures", &self.measures)?;
10023 }
10024 if !self.defines.is_empty() {
10025 struct_ser.serialize_field("defines", &self.defines)?;
10026 }
10027 if let Some(v) = self.pattern_node.as_ref() {
10028 struct_ser.serialize_field("patternNode", v)?;
10029 }
10030 if let Some(v) = self.state_table.as_ref() {
10031 struct_ser.serialize_field("stateTable", v)?;
10032 }
10033 if let Some(v) = self.after_match_skip.as_ref() {
10034 struct_ser.serialize_field("afterMatchSkip", v)?;
10035 }
10036 if let Some(v) = self.within.as_ref() {
10037 struct_ser.serialize_field("within", v)?;
10038 }
10039 if let Some(v) = self.within_deadline.as_ref() {
10040 struct_ser.serialize_field("withinDeadline", v)?;
10041 }
10042 if self.input_mode != 0 {
10043 let v = MatchRecognizeInputMode::try_from(self.input_mode)
10044 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.input_mode)))?;
10045 struct_ser.serialize_field("inputMode", &v)?;
10046 }
10047 struct_ser.end()
10048 }
10049}
10050impl<'de> serde::Deserialize<'de> for MatchRecognizeNode {
10051 #[allow(deprecated)]
10052 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10053 where
10054 D: serde::Deserializer<'de>,
10055 {
10056 const FIELDS: &[&str] = &[
10057 "partition_by",
10058 "partitionBy",
10059 "order_by",
10060 "orderBy",
10061 "measures",
10062 "defines",
10063 "pattern_node",
10064 "patternNode",
10065 "state_table",
10066 "stateTable",
10067 "after_match_skip",
10068 "afterMatchSkip",
10069 "within",
10070 "within_deadline",
10071 "withinDeadline",
10072 "input_mode",
10073 "inputMode",
10074 ];
10075
10076 #[allow(clippy::enum_variant_names)]
10077 enum GeneratedField {
10078 PartitionBy,
10079 OrderBy,
10080 Measures,
10081 Defines,
10082 PatternNode,
10083 StateTable,
10084 AfterMatchSkip,
10085 Within,
10086 WithinDeadline,
10087 InputMode,
10088 }
10089 impl<'de> serde::Deserialize<'de> for GeneratedField {
10090 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10091 where
10092 D: serde::Deserializer<'de>,
10093 {
10094 struct GeneratedVisitor;
10095
10096 impl serde::de::Visitor<'_> for GeneratedVisitor {
10097 type Value = GeneratedField;
10098
10099 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10100 write!(formatter, "expected one of: {:?}", &FIELDS)
10101 }
10102
10103 #[allow(unused_variables)]
10104 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10105 where
10106 E: serde::de::Error,
10107 {
10108 match value {
10109 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
10110 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
10111 "measures" => Ok(GeneratedField::Measures),
10112 "defines" => Ok(GeneratedField::Defines),
10113 "patternNode" | "pattern_node" => Ok(GeneratedField::PatternNode),
10114 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
10115 "afterMatchSkip" | "after_match_skip" => Ok(GeneratedField::AfterMatchSkip),
10116 "within" => Ok(GeneratedField::Within),
10117 "withinDeadline" | "within_deadline" => Ok(GeneratedField::WithinDeadline),
10118 "inputMode" | "input_mode" => Ok(GeneratedField::InputMode),
10119 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10120 }
10121 }
10122 }
10123 deserializer.deserialize_identifier(GeneratedVisitor)
10124 }
10125 }
10126 struct GeneratedVisitor;
10127 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10128 type Value = MatchRecognizeNode;
10129
10130 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10131 formatter.write_str("struct stream_plan.MatchRecognizeNode")
10132 }
10133
10134 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeNode, V::Error>
10135 where
10136 V: serde::de::MapAccess<'de>,
10137 {
10138 let mut partition_by__ = None;
10139 let mut order_by__ = None;
10140 let mut measures__ = None;
10141 let mut defines__ = None;
10142 let mut pattern_node__ = None;
10143 let mut state_table__ = None;
10144 let mut after_match_skip__ = None;
10145 let mut within__ = None;
10146 let mut within_deadline__ = None;
10147 let mut input_mode__ = None;
10148 while let Some(k) = map_.next_key()? {
10149 match k {
10150 GeneratedField::PartitionBy => {
10151 if partition_by__.is_some() {
10152 return Err(serde::de::Error::duplicate_field("partitionBy"));
10153 }
10154 partition_by__ =
10155 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10156 .into_iter().map(|x| x.0).collect())
10157 ;
10158 }
10159 GeneratedField::OrderBy => {
10160 if order_by__.is_some() {
10161 return Err(serde::de::Error::duplicate_field("orderBy"));
10162 }
10163 order_by__ = Some(map_.next_value()?);
10164 }
10165 GeneratedField::Measures => {
10166 if measures__.is_some() {
10167 return Err(serde::de::Error::duplicate_field("measures"));
10168 }
10169 measures__ = Some(map_.next_value()?);
10170 }
10171 GeneratedField::Defines => {
10172 if defines__.is_some() {
10173 return Err(serde::de::Error::duplicate_field("defines"));
10174 }
10175 defines__ = Some(map_.next_value()?);
10176 }
10177 GeneratedField::PatternNode => {
10178 if pattern_node__.is_some() {
10179 return Err(serde::de::Error::duplicate_field("patternNode"));
10180 }
10181 pattern_node__ = map_.next_value()?;
10182 }
10183 GeneratedField::StateTable => {
10184 if state_table__.is_some() {
10185 return Err(serde::de::Error::duplicate_field("stateTable"));
10186 }
10187 state_table__ = map_.next_value()?;
10188 }
10189 GeneratedField::AfterMatchSkip => {
10190 if after_match_skip__.is_some() {
10191 return Err(serde::de::Error::duplicate_field("afterMatchSkip"));
10192 }
10193 after_match_skip__ = map_.next_value()?;
10194 }
10195 GeneratedField::Within => {
10196 if within__.is_some() {
10197 return Err(serde::de::Error::duplicate_field("within"));
10198 }
10199 within__ = map_.next_value()?;
10200 }
10201 GeneratedField::WithinDeadline => {
10202 if within_deadline__.is_some() {
10203 return Err(serde::de::Error::duplicate_field("withinDeadline"));
10204 }
10205 within_deadline__ = map_.next_value()?;
10206 }
10207 GeneratedField::InputMode => {
10208 if input_mode__.is_some() {
10209 return Err(serde::de::Error::duplicate_field("inputMode"));
10210 }
10211 input_mode__ = Some(map_.next_value::<MatchRecognizeInputMode>()? as i32);
10212 }
10213 }
10214 }
10215 Ok(MatchRecognizeNode {
10216 partition_by: partition_by__.unwrap_or_default(),
10217 order_by: order_by__.unwrap_or_default(),
10218 measures: measures__.unwrap_or_default(),
10219 defines: defines__.unwrap_or_default(),
10220 pattern_node: pattern_node__,
10221 state_table: state_table__,
10222 after_match_skip: after_match_skip__,
10223 within: within__,
10224 within_deadline: within_deadline__,
10225 input_mode: input_mode__.unwrap_or_default(),
10226 })
10227 }
10228 }
10229 deserializer.deserialize_struct("stream_plan.MatchRecognizeNode", FIELDS, GeneratedVisitor)
10230 }
10231}
10232impl serde::Serialize for MatchRecognizePatternNode {
10233 #[allow(deprecated)]
10234 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10235 where
10236 S: serde::Serializer,
10237 {
10238 use serde::ser::SerializeStruct;
10239 let mut len = 0;
10240 if self.node.is_some() {
10241 len += 1;
10242 }
10243 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizePatternNode", len)?;
10244 if let Some(v) = self.node.as_ref() {
10245 match v {
10246 match_recognize_pattern_node::Node::Var(v) => {
10247 struct_ser.serialize_field("var", v)?;
10248 }
10249 match_recognize_pattern_node::Node::Concat(v) => {
10250 struct_ser.serialize_field("concat", v)?;
10251 }
10252 match_recognize_pattern_node::Node::Alternation(v) => {
10253 struct_ser.serialize_field("alternation", v)?;
10254 }
10255 match_recognize_pattern_node::Node::Quantified(v) => {
10256 struct_ser.serialize_field("quantified", v)?;
10257 }
10258 match_recognize_pattern_node::Node::Permute(v) => {
10259 struct_ser.serialize_field("permute", v)?;
10260 }
10261 }
10262 }
10263 struct_ser.end()
10264 }
10265}
10266impl<'de> serde::Deserialize<'de> for MatchRecognizePatternNode {
10267 #[allow(deprecated)]
10268 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10269 where
10270 D: serde::Deserializer<'de>,
10271 {
10272 const FIELDS: &[&str] = &[
10273 "var",
10274 "concat",
10275 "alternation",
10276 "quantified",
10277 "permute",
10278 ];
10279
10280 #[allow(clippy::enum_variant_names)]
10281 enum GeneratedField {
10282 Var,
10283 Concat,
10284 Alternation,
10285 Quantified,
10286 Permute,
10287 }
10288 impl<'de> serde::Deserialize<'de> for GeneratedField {
10289 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10290 where
10291 D: serde::Deserializer<'de>,
10292 {
10293 struct GeneratedVisitor;
10294
10295 impl serde::de::Visitor<'_> for GeneratedVisitor {
10296 type Value = GeneratedField;
10297
10298 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10299 write!(formatter, "expected one of: {:?}", &FIELDS)
10300 }
10301
10302 #[allow(unused_variables)]
10303 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10304 where
10305 E: serde::de::Error,
10306 {
10307 match value {
10308 "var" => Ok(GeneratedField::Var),
10309 "concat" => Ok(GeneratedField::Concat),
10310 "alternation" => Ok(GeneratedField::Alternation),
10311 "quantified" => Ok(GeneratedField::Quantified),
10312 "permute" => Ok(GeneratedField::Permute),
10313 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10314 }
10315 }
10316 }
10317 deserializer.deserialize_identifier(GeneratedVisitor)
10318 }
10319 }
10320 struct GeneratedVisitor;
10321 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10322 type Value = MatchRecognizePatternNode;
10323
10324 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10325 formatter.write_str("struct stream_plan.MatchRecognizePatternNode")
10326 }
10327
10328 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizePatternNode, V::Error>
10329 where
10330 V: serde::de::MapAccess<'de>,
10331 {
10332 let mut node__ = None;
10333 while let Some(k) = map_.next_key()? {
10334 match k {
10335 GeneratedField::Var => {
10336 if node__.is_some() {
10337 return Err(serde::de::Error::duplicate_field("var"));
10338 }
10339 node__ = map_.next_value::<::std::option::Option<_>>()?.map(match_recognize_pattern_node::Node::Var);
10340 }
10341 GeneratedField::Concat => {
10342 if node__.is_some() {
10343 return Err(serde::de::Error::duplicate_field("concat"));
10344 }
10345 node__ = map_.next_value::<::std::option::Option<_>>()?.map(match_recognize_pattern_node::Node::Concat)
10346;
10347 }
10348 GeneratedField::Alternation => {
10349 if node__.is_some() {
10350 return Err(serde::de::Error::duplicate_field("alternation"));
10351 }
10352 node__ = map_.next_value::<::std::option::Option<_>>()?.map(match_recognize_pattern_node::Node::Alternation)
10353;
10354 }
10355 GeneratedField::Quantified => {
10356 if node__.is_some() {
10357 return Err(serde::de::Error::duplicate_field("quantified"));
10358 }
10359 node__ = map_.next_value::<::std::option::Option<_>>()?.map(match_recognize_pattern_node::Node::Quantified)
10360;
10361 }
10362 GeneratedField::Permute => {
10363 if node__.is_some() {
10364 return Err(serde::de::Error::duplicate_field("permute"));
10365 }
10366 node__ = map_.next_value::<::std::option::Option<_>>()?.map(match_recognize_pattern_node::Node::Permute)
10367;
10368 }
10369 }
10370 }
10371 Ok(MatchRecognizePatternNode {
10372 node: node__,
10373 })
10374 }
10375 }
10376 deserializer.deserialize_struct("stream_plan.MatchRecognizePatternNode", FIELDS, GeneratedVisitor)
10377 }
10378}
10379impl serde::Serialize for MatchRecognizePatternSeq {
10380 #[allow(deprecated)]
10381 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10382 where
10383 S: serde::Serializer,
10384 {
10385 use serde::ser::SerializeStruct;
10386 let mut len = 0;
10387 if !self.patterns.is_empty() {
10388 len += 1;
10389 }
10390 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizePatternSeq", len)?;
10391 if !self.patterns.is_empty() {
10392 struct_ser.serialize_field("patterns", &self.patterns)?;
10393 }
10394 struct_ser.end()
10395 }
10396}
10397impl<'de> serde::Deserialize<'de> for MatchRecognizePatternSeq {
10398 #[allow(deprecated)]
10399 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10400 where
10401 D: serde::Deserializer<'de>,
10402 {
10403 const FIELDS: &[&str] = &[
10404 "patterns",
10405 ];
10406
10407 #[allow(clippy::enum_variant_names)]
10408 enum GeneratedField {
10409 Patterns,
10410 }
10411 impl<'de> serde::Deserialize<'de> for GeneratedField {
10412 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10413 where
10414 D: serde::Deserializer<'de>,
10415 {
10416 struct GeneratedVisitor;
10417
10418 impl serde::de::Visitor<'_> for GeneratedVisitor {
10419 type Value = GeneratedField;
10420
10421 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10422 write!(formatter, "expected one of: {:?}", &FIELDS)
10423 }
10424
10425 #[allow(unused_variables)]
10426 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10427 where
10428 E: serde::de::Error,
10429 {
10430 match value {
10431 "patterns" => Ok(GeneratedField::Patterns),
10432 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10433 }
10434 }
10435 }
10436 deserializer.deserialize_identifier(GeneratedVisitor)
10437 }
10438 }
10439 struct GeneratedVisitor;
10440 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10441 type Value = MatchRecognizePatternSeq;
10442
10443 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10444 formatter.write_str("struct stream_plan.MatchRecognizePatternSeq")
10445 }
10446
10447 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizePatternSeq, V::Error>
10448 where
10449 V: serde::de::MapAccess<'de>,
10450 {
10451 let mut patterns__ = None;
10452 while let Some(k) = map_.next_key()? {
10453 match k {
10454 GeneratedField::Patterns => {
10455 if patterns__.is_some() {
10456 return Err(serde::de::Error::duplicate_field("patterns"));
10457 }
10458 patterns__ = Some(map_.next_value()?);
10459 }
10460 }
10461 }
10462 Ok(MatchRecognizePatternSeq {
10463 patterns: patterns__.unwrap_or_default(),
10464 })
10465 }
10466 }
10467 deserializer.deserialize_struct("stream_plan.MatchRecognizePatternSeq", FIELDS, GeneratedVisitor)
10468 }
10469}
10470impl serde::Serialize for MatchRecognizePermutePattern {
10471 #[allow(deprecated)]
10472 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10473 where
10474 S: serde::Serializer,
10475 {
10476 use serde::ser::SerializeStruct;
10477 let mut len = 0;
10478 if !self.vars.is_empty() {
10479 len += 1;
10480 }
10481 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizePermutePattern", len)?;
10482 if !self.vars.is_empty() {
10483 struct_ser.serialize_field("vars", &self.vars)?;
10484 }
10485 struct_ser.end()
10486 }
10487}
10488impl<'de> serde::Deserialize<'de> for MatchRecognizePermutePattern {
10489 #[allow(deprecated)]
10490 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10491 where
10492 D: serde::Deserializer<'de>,
10493 {
10494 const FIELDS: &[&str] = &[
10495 "vars",
10496 ];
10497
10498 #[allow(clippy::enum_variant_names)]
10499 enum GeneratedField {
10500 Vars,
10501 }
10502 impl<'de> serde::Deserialize<'de> for GeneratedField {
10503 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10504 where
10505 D: serde::Deserializer<'de>,
10506 {
10507 struct GeneratedVisitor;
10508
10509 impl serde::de::Visitor<'_> for GeneratedVisitor {
10510 type Value = GeneratedField;
10511
10512 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10513 write!(formatter, "expected one of: {:?}", &FIELDS)
10514 }
10515
10516 #[allow(unused_variables)]
10517 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10518 where
10519 E: serde::de::Error,
10520 {
10521 match value {
10522 "vars" => Ok(GeneratedField::Vars),
10523 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10524 }
10525 }
10526 }
10527 deserializer.deserialize_identifier(GeneratedVisitor)
10528 }
10529 }
10530 struct GeneratedVisitor;
10531 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10532 type Value = MatchRecognizePermutePattern;
10533
10534 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10535 formatter.write_str("struct stream_plan.MatchRecognizePermutePattern")
10536 }
10537
10538 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizePermutePattern, V::Error>
10539 where
10540 V: serde::de::MapAccess<'de>,
10541 {
10542 let mut vars__ = None;
10543 while let Some(k) = map_.next_key()? {
10544 match k {
10545 GeneratedField::Vars => {
10546 if vars__.is_some() {
10547 return Err(serde::de::Error::duplicate_field("vars"));
10548 }
10549 vars__ = Some(map_.next_value()?);
10550 }
10551 }
10552 }
10553 Ok(MatchRecognizePermutePattern {
10554 vars: vars__.unwrap_or_default(),
10555 })
10556 }
10557 }
10558 deserializer.deserialize_struct("stream_plan.MatchRecognizePermutePattern", FIELDS, GeneratedVisitor)
10559 }
10560}
10561impl serde::Serialize for MatchRecognizeQuantifiedPattern {
10562 #[allow(deprecated)]
10563 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10564 where
10565 S: serde::Serializer,
10566 {
10567 use serde::ser::SerializeStruct;
10568 let mut len = 0;
10569 if self.inner.is_some() {
10570 len += 1;
10571 }
10572 if self.quantifier.is_some() {
10573 len += 1;
10574 }
10575 if self.reluctant {
10576 len += 1;
10577 }
10578 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeQuantifiedPattern", len)?;
10579 if let Some(v) = self.inner.as_ref() {
10580 struct_ser.serialize_field("inner", v)?;
10581 }
10582 if let Some(v) = self.quantifier.as_ref() {
10583 struct_ser.serialize_field("quantifier", v)?;
10584 }
10585 if self.reluctant {
10586 struct_ser.serialize_field("reluctant", &self.reluctant)?;
10587 }
10588 struct_ser.end()
10589 }
10590}
10591impl<'de> serde::Deserialize<'de> for MatchRecognizeQuantifiedPattern {
10592 #[allow(deprecated)]
10593 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10594 where
10595 D: serde::Deserializer<'de>,
10596 {
10597 const FIELDS: &[&str] = &[
10598 "inner",
10599 "quantifier",
10600 "reluctant",
10601 ];
10602
10603 #[allow(clippy::enum_variant_names)]
10604 enum GeneratedField {
10605 Inner,
10606 Quantifier,
10607 Reluctant,
10608 }
10609 impl<'de> serde::Deserialize<'de> for GeneratedField {
10610 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10611 where
10612 D: serde::Deserializer<'de>,
10613 {
10614 struct GeneratedVisitor;
10615
10616 impl serde::de::Visitor<'_> for GeneratedVisitor {
10617 type Value = GeneratedField;
10618
10619 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10620 write!(formatter, "expected one of: {:?}", &FIELDS)
10621 }
10622
10623 #[allow(unused_variables)]
10624 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10625 where
10626 E: serde::de::Error,
10627 {
10628 match value {
10629 "inner" => Ok(GeneratedField::Inner),
10630 "quantifier" => Ok(GeneratedField::Quantifier),
10631 "reluctant" => Ok(GeneratedField::Reluctant),
10632 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10633 }
10634 }
10635 }
10636 deserializer.deserialize_identifier(GeneratedVisitor)
10637 }
10638 }
10639 struct GeneratedVisitor;
10640 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10641 type Value = MatchRecognizeQuantifiedPattern;
10642
10643 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10644 formatter.write_str("struct stream_plan.MatchRecognizeQuantifiedPattern")
10645 }
10646
10647 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeQuantifiedPattern, V::Error>
10648 where
10649 V: serde::de::MapAccess<'de>,
10650 {
10651 let mut inner__ = None;
10652 let mut quantifier__ = None;
10653 let mut reluctant__ = None;
10654 while let Some(k) = map_.next_key()? {
10655 match k {
10656 GeneratedField::Inner => {
10657 if inner__.is_some() {
10658 return Err(serde::de::Error::duplicate_field("inner"));
10659 }
10660 inner__ = map_.next_value()?;
10661 }
10662 GeneratedField::Quantifier => {
10663 if quantifier__.is_some() {
10664 return Err(serde::de::Error::duplicate_field("quantifier"));
10665 }
10666 quantifier__ = map_.next_value()?;
10667 }
10668 GeneratedField::Reluctant => {
10669 if reluctant__.is_some() {
10670 return Err(serde::de::Error::duplicate_field("reluctant"));
10671 }
10672 reluctant__ = Some(map_.next_value()?);
10673 }
10674 }
10675 }
10676 Ok(MatchRecognizeQuantifiedPattern {
10677 inner: inner__,
10678 quantifier: quantifier__,
10679 reluctant: reluctant__.unwrap_or_default(),
10680 })
10681 }
10682 }
10683 deserializer.deserialize_struct("stream_plan.MatchRecognizeQuantifiedPattern", FIELDS, GeneratedVisitor)
10684 }
10685}
10686impl serde::Serialize for MatchRecognizeQuantifier {
10687 #[allow(deprecated)]
10688 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10689 where
10690 S: serde::Serializer,
10691 {
10692 use serde::ser::SerializeStruct;
10693 let mut len = 0;
10694 if self.kind != 0 {
10695 len += 1;
10696 }
10697 if self.min != 0 {
10698 len += 1;
10699 }
10700 if self.max.is_some() {
10701 len += 1;
10702 }
10703 let mut struct_ser = serializer.serialize_struct("stream_plan.MatchRecognizeQuantifier", len)?;
10704 if self.kind != 0 {
10705 let v = match_recognize_quantifier::Kind::try_from(self.kind)
10706 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
10707 struct_ser.serialize_field("kind", &v)?;
10708 }
10709 if self.min != 0 {
10710 struct_ser.serialize_field("min", &self.min)?;
10711 }
10712 if let Some(v) = self.max.as_ref() {
10713 struct_ser.serialize_field("max", v)?;
10714 }
10715 struct_ser.end()
10716 }
10717}
10718impl<'de> serde::Deserialize<'de> for MatchRecognizeQuantifier {
10719 #[allow(deprecated)]
10720 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10721 where
10722 D: serde::Deserializer<'de>,
10723 {
10724 const FIELDS: &[&str] = &[
10725 "kind",
10726 "min",
10727 "max",
10728 ];
10729
10730 #[allow(clippy::enum_variant_names)]
10731 enum GeneratedField {
10732 Kind,
10733 Min,
10734 Max,
10735 }
10736 impl<'de> serde::Deserialize<'de> for GeneratedField {
10737 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10738 where
10739 D: serde::Deserializer<'de>,
10740 {
10741 struct GeneratedVisitor;
10742
10743 impl serde::de::Visitor<'_> for GeneratedVisitor {
10744 type Value = GeneratedField;
10745
10746 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10747 write!(formatter, "expected one of: {:?}", &FIELDS)
10748 }
10749
10750 #[allow(unused_variables)]
10751 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10752 where
10753 E: serde::de::Error,
10754 {
10755 match value {
10756 "kind" => Ok(GeneratedField::Kind),
10757 "min" => Ok(GeneratedField::Min),
10758 "max" => Ok(GeneratedField::Max),
10759 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10760 }
10761 }
10762 }
10763 deserializer.deserialize_identifier(GeneratedVisitor)
10764 }
10765 }
10766 struct GeneratedVisitor;
10767 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10768 type Value = MatchRecognizeQuantifier;
10769
10770 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10771 formatter.write_str("struct stream_plan.MatchRecognizeQuantifier")
10772 }
10773
10774 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MatchRecognizeQuantifier, V::Error>
10775 where
10776 V: serde::de::MapAccess<'de>,
10777 {
10778 let mut kind__ = None;
10779 let mut min__ = None;
10780 let mut max__ = None;
10781 while let Some(k) = map_.next_key()? {
10782 match k {
10783 GeneratedField::Kind => {
10784 if kind__.is_some() {
10785 return Err(serde::de::Error::duplicate_field("kind"));
10786 }
10787 kind__ = Some(map_.next_value::<match_recognize_quantifier::Kind>()? as i32);
10788 }
10789 GeneratedField::Min => {
10790 if min__.is_some() {
10791 return Err(serde::de::Error::duplicate_field("min"));
10792 }
10793 min__ =
10794 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10795 ;
10796 }
10797 GeneratedField::Max => {
10798 if max__.is_some() {
10799 return Err(serde::de::Error::duplicate_field("max"));
10800 }
10801 max__ =
10802 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10803 ;
10804 }
10805 }
10806 }
10807 Ok(MatchRecognizeQuantifier {
10808 kind: kind__.unwrap_or_default(),
10809 min: min__.unwrap_or_default(),
10810 max: max__,
10811 })
10812 }
10813 }
10814 deserializer.deserialize_struct("stream_plan.MatchRecognizeQuantifier", FIELDS, GeneratedVisitor)
10815 }
10816}
10817impl serde::Serialize for match_recognize_quantifier::Kind {
10818 #[allow(deprecated)]
10819 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10820 where
10821 S: serde::Serializer,
10822 {
10823 let variant = match self {
10824 Self::Unspecified => "KIND_UNSPECIFIED",
10825 Self::Star => "KIND_STAR",
10826 Self::Plus => "KIND_PLUS",
10827 Self::Question => "KIND_QUESTION",
10828 Self::Range => "KIND_RANGE",
10829 };
10830 serializer.serialize_str(variant)
10831 }
10832}
10833impl<'de> serde::Deserialize<'de> for match_recognize_quantifier::Kind {
10834 #[allow(deprecated)]
10835 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10836 where
10837 D: serde::Deserializer<'de>,
10838 {
10839 const FIELDS: &[&str] = &[
10840 "KIND_UNSPECIFIED",
10841 "KIND_STAR",
10842 "KIND_PLUS",
10843 "KIND_QUESTION",
10844 "KIND_RANGE",
10845 ];
10846
10847 struct GeneratedVisitor;
10848
10849 impl serde::de::Visitor<'_> for GeneratedVisitor {
10850 type Value = match_recognize_quantifier::Kind;
10851
10852 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10853 write!(formatter, "expected one of: {:?}", &FIELDS)
10854 }
10855
10856 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
10857 where
10858 E: serde::de::Error,
10859 {
10860 i32::try_from(v)
10861 .ok()
10862 .and_then(|x| x.try_into().ok())
10863 .ok_or_else(|| {
10864 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
10865 })
10866 }
10867
10868 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
10869 where
10870 E: serde::de::Error,
10871 {
10872 i32::try_from(v)
10873 .ok()
10874 .and_then(|x| x.try_into().ok())
10875 .ok_or_else(|| {
10876 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
10877 })
10878 }
10879
10880 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
10881 where
10882 E: serde::de::Error,
10883 {
10884 match value {
10885 "KIND_UNSPECIFIED" => Ok(match_recognize_quantifier::Kind::Unspecified),
10886 "KIND_STAR" => Ok(match_recognize_quantifier::Kind::Star),
10887 "KIND_PLUS" => Ok(match_recognize_quantifier::Kind::Plus),
10888 "KIND_QUESTION" => Ok(match_recognize_quantifier::Kind::Question),
10889 "KIND_RANGE" => Ok(match_recognize_quantifier::Kind::Range),
10890 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
10891 }
10892 }
10893 }
10894 deserializer.deserialize_any(GeneratedVisitor)
10895 }
10896}
10897impl serde::Serialize for MaterializeNode {
10898 #[allow(deprecated)]
10899 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10900 where
10901 S: serde::Serializer,
10902 {
10903 use serde::ser::SerializeStruct;
10904 let mut len = 0;
10905 if self.table_id != 0 {
10906 len += 1;
10907 }
10908 if !self.column_orders.is_empty() {
10909 len += 1;
10910 }
10911 if self.table.is_some() {
10912 len += 1;
10913 }
10914 if self.staging_table.is_some() {
10915 len += 1;
10916 }
10917 if self.refresh_progress_table.is_some() {
10918 len += 1;
10919 }
10920 if self.cleaned_by_ttl_watermark {
10921 len += 1;
10922 }
10923 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializeNode", len)?;
10924 if self.table_id != 0 {
10925 struct_ser.serialize_field("tableId", &self.table_id)?;
10926 }
10927 if !self.column_orders.is_empty() {
10928 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
10929 }
10930 if let Some(v) = self.table.as_ref() {
10931 struct_ser.serialize_field("table", v)?;
10932 }
10933 if let Some(v) = self.staging_table.as_ref() {
10934 struct_ser.serialize_field("stagingTable", v)?;
10935 }
10936 if let Some(v) = self.refresh_progress_table.as_ref() {
10937 struct_ser.serialize_field("refreshProgressTable", v)?;
10938 }
10939 if self.cleaned_by_ttl_watermark {
10940 struct_ser.serialize_field("cleanedByTtlWatermark", &self.cleaned_by_ttl_watermark)?;
10941 }
10942 struct_ser.end()
10943 }
10944}
10945impl<'de> serde::Deserialize<'de> for MaterializeNode {
10946 #[allow(deprecated)]
10947 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10948 where
10949 D: serde::Deserializer<'de>,
10950 {
10951 const FIELDS: &[&str] = &[
10952 "table_id",
10953 "tableId",
10954 "column_orders",
10955 "columnOrders",
10956 "table",
10957 "staging_table",
10958 "stagingTable",
10959 "refresh_progress_table",
10960 "refreshProgressTable",
10961 "cleaned_by_ttl_watermark",
10962 "cleanedByTtlWatermark",
10963 ];
10964
10965 #[allow(clippy::enum_variant_names)]
10966 enum GeneratedField {
10967 TableId,
10968 ColumnOrders,
10969 Table,
10970 StagingTable,
10971 RefreshProgressTable,
10972 CleanedByTtlWatermark,
10973 }
10974 impl<'de> serde::Deserialize<'de> for GeneratedField {
10975 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10976 where
10977 D: serde::Deserializer<'de>,
10978 {
10979 struct GeneratedVisitor;
10980
10981 impl serde::de::Visitor<'_> for GeneratedVisitor {
10982 type Value = GeneratedField;
10983
10984 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10985 write!(formatter, "expected one of: {:?}", &FIELDS)
10986 }
10987
10988 #[allow(unused_variables)]
10989 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10990 where
10991 E: serde::de::Error,
10992 {
10993 match value {
10994 "tableId" | "table_id" => Ok(GeneratedField::TableId),
10995 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
10996 "table" => Ok(GeneratedField::Table),
10997 "stagingTable" | "staging_table" => Ok(GeneratedField::StagingTable),
10998 "refreshProgressTable" | "refresh_progress_table" => Ok(GeneratedField::RefreshProgressTable),
10999 "cleanedByTtlWatermark" | "cleaned_by_ttl_watermark" => Ok(GeneratedField::CleanedByTtlWatermark),
11000 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11001 }
11002 }
11003 }
11004 deserializer.deserialize_identifier(GeneratedVisitor)
11005 }
11006 }
11007 struct GeneratedVisitor;
11008 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11009 type Value = MaterializeNode;
11010
11011 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11012 formatter.write_str("struct stream_plan.MaterializeNode")
11013 }
11014
11015 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializeNode, V::Error>
11016 where
11017 V: serde::de::MapAccess<'de>,
11018 {
11019 let mut table_id__ = None;
11020 let mut column_orders__ = None;
11021 let mut table__ = None;
11022 let mut staging_table__ = None;
11023 let mut refresh_progress_table__ = None;
11024 let mut cleaned_by_ttl_watermark__ = None;
11025 while let Some(k) = map_.next_key()? {
11026 match k {
11027 GeneratedField::TableId => {
11028 if table_id__.is_some() {
11029 return Err(serde::de::Error::duplicate_field("tableId"));
11030 }
11031 table_id__ =
11032 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11033 ;
11034 }
11035 GeneratedField::ColumnOrders => {
11036 if column_orders__.is_some() {
11037 return Err(serde::de::Error::duplicate_field("columnOrders"));
11038 }
11039 column_orders__ = Some(map_.next_value()?);
11040 }
11041 GeneratedField::Table => {
11042 if table__.is_some() {
11043 return Err(serde::de::Error::duplicate_field("table"));
11044 }
11045 table__ = map_.next_value()?;
11046 }
11047 GeneratedField::StagingTable => {
11048 if staging_table__.is_some() {
11049 return Err(serde::de::Error::duplicate_field("stagingTable"));
11050 }
11051 staging_table__ = map_.next_value()?;
11052 }
11053 GeneratedField::RefreshProgressTable => {
11054 if refresh_progress_table__.is_some() {
11055 return Err(serde::de::Error::duplicate_field("refreshProgressTable"));
11056 }
11057 refresh_progress_table__ = map_.next_value()?;
11058 }
11059 GeneratedField::CleanedByTtlWatermark => {
11060 if cleaned_by_ttl_watermark__.is_some() {
11061 return Err(serde::de::Error::duplicate_field("cleanedByTtlWatermark"));
11062 }
11063 cleaned_by_ttl_watermark__ = Some(map_.next_value()?);
11064 }
11065 }
11066 }
11067 Ok(MaterializeNode {
11068 table_id: table_id__.unwrap_or_default(),
11069 column_orders: column_orders__.unwrap_or_default(),
11070 table: table__,
11071 staging_table: staging_table__,
11072 refresh_progress_table: refresh_progress_table__,
11073 cleaned_by_ttl_watermark: cleaned_by_ttl_watermark__.unwrap_or_default(),
11074 })
11075 }
11076 }
11077 deserializer.deserialize_struct("stream_plan.MaterializeNode", FIELDS, GeneratedVisitor)
11078 }
11079}
11080impl serde::Serialize for MaterializedExprsNode {
11081 #[allow(deprecated)]
11082 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11083 where
11084 S: serde::Serializer,
11085 {
11086 use serde::ser::SerializeStruct;
11087 let mut len = 0;
11088 if !self.exprs.is_empty() {
11089 len += 1;
11090 }
11091 if self.state_table.is_some() {
11092 len += 1;
11093 }
11094 if self.state_clean_col_idx.is_some() {
11095 len += 1;
11096 }
11097 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializedExprsNode", len)?;
11098 if !self.exprs.is_empty() {
11099 struct_ser.serialize_field("exprs", &self.exprs)?;
11100 }
11101 if let Some(v) = self.state_table.as_ref() {
11102 struct_ser.serialize_field("stateTable", v)?;
11103 }
11104 if let Some(v) = self.state_clean_col_idx.as_ref() {
11105 struct_ser.serialize_field("stateCleanColIdx", v)?;
11106 }
11107 struct_ser.end()
11108 }
11109}
11110impl<'de> serde::Deserialize<'de> for MaterializedExprsNode {
11111 #[allow(deprecated)]
11112 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11113 where
11114 D: serde::Deserializer<'de>,
11115 {
11116 const FIELDS: &[&str] = &[
11117 "exprs",
11118 "state_table",
11119 "stateTable",
11120 "state_clean_col_idx",
11121 "stateCleanColIdx",
11122 ];
11123
11124 #[allow(clippy::enum_variant_names)]
11125 enum GeneratedField {
11126 Exprs,
11127 StateTable,
11128 StateCleanColIdx,
11129 }
11130 impl<'de> serde::Deserialize<'de> for GeneratedField {
11131 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11132 where
11133 D: serde::Deserializer<'de>,
11134 {
11135 struct GeneratedVisitor;
11136
11137 impl serde::de::Visitor<'_> for GeneratedVisitor {
11138 type Value = GeneratedField;
11139
11140 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11141 write!(formatter, "expected one of: {:?}", &FIELDS)
11142 }
11143
11144 #[allow(unused_variables)]
11145 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11146 where
11147 E: serde::de::Error,
11148 {
11149 match value {
11150 "exprs" => Ok(GeneratedField::Exprs),
11151 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11152 "stateCleanColIdx" | "state_clean_col_idx" => Ok(GeneratedField::StateCleanColIdx),
11153 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11154 }
11155 }
11156 }
11157 deserializer.deserialize_identifier(GeneratedVisitor)
11158 }
11159 }
11160 struct GeneratedVisitor;
11161 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11162 type Value = MaterializedExprsNode;
11163
11164 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11165 formatter.write_str("struct stream_plan.MaterializedExprsNode")
11166 }
11167
11168 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializedExprsNode, V::Error>
11169 where
11170 V: serde::de::MapAccess<'de>,
11171 {
11172 let mut exprs__ = None;
11173 let mut state_table__ = None;
11174 let mut state_clean_col_idx__ = None;
11175 while let Some(k) = map_.next_key()? {
11176 match k {
11177 GeneratedField::Exprs => {
11178 if exprs__.is_some() {
11179 return Err(serde::de::Error::duplicate_field("exprs"));
11180 }
11181 exprs__ = Some(map_.next_value()?);
11182 }
11183 GeneratedField::StateTable => {
11184 if state_table__.is_some() {
11185 return Err(serde::de::Error::duplicate_field("stateTable"));
11186 }
11187 state_table__ = map_.next_value()?;
11188 }
11189 GeneratedField::StateCleanColIdx => {
11190 if state_clean_col_idx__.is_some() {
11191 return Err(serde::de::Error::duplicate_field("stateCleanColIdx"));
11192 }
11193 state_clean_col_idx__ =
11194 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11195 ;
11196 }
11197 }
11198 }
11199 Ok(MaterializedExprsNode {
11200 exprs: exprs__.unwrap_or_default(),
11201 state_table: state_table__,
11202 state_clean_col_idx: state_clean_col_idx__,
11203 })
11204 }
11205 }
11206 deserializer.deserialize_struct("stream_plan.MaterializedExprsNode", FIELDS, GeneratedVisitor)
11207 }
11208}
11209impl serde::Serialize for MergeNode {
11210 #[allow(deprecated)]
11211 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11212 where
11213 S: serde::Serializer,
11214 {
11215 use serde::ser::SerializeStruct;
11216 let mut len = 0;
11217 if !self.upstream_actor_id.is_empty() {
11218 len += 1;
11219 }
11220 if self.upstream_fragment_id != 0 {
11221 len += 1;
11222 }
11223 if self.upstream_dispatcher_type != 0 {
11224 len += 1;
11225 }
11226 if !self.fields.is_empty() {
11227 len += 1;
11228 }
11229 if self.allow_empty_upstream {
11230 len += 1;
11231 }
11232 let mut struct_ser = serializer.serialize_struct("stream_plan.MergeNode", len)?;
11233 if !self.upstream_actor_id.is_empty() {
11234 struct_ser.serialize_field("upstreamActorId", &self.upstream_actor_id)?;
11235 }
11236 if self.upstream_fragment_id != 0 {
11237 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
11238 }
11239 if self.upstream_dispatcher_type != 0 {
11240 let v = DispatcherType::try_from(self.upstream_dispatcher_type)
11241 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.upstream_dispatcher_type)))?;
11242 struct_ser.serialize_field("upstreamDispatcherType", &v)?;
11243 }
11244 if !self.fields.is_empty() {
11245 struct_ser.serialize_field("fields", &self.fields)?;
11246 }
11247 if self.allow_empty_upstream {
11248 struct_ser.serialize_field("allowEmptyUpstream", &self.allow_empty_upstream)?;
11249 }
11250 struct_ser.end()
11251 }
11252}
11253impl<'de> serde::Deserialize<'de> for MergeNode {
11254 #[allow(deprecated)]
11255 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11256 where
11257 D: serde::Deserializer<'de>,
11258 {
11259 const FIELDS: &[&str] = &[
11260 "upstream_actor_id",
11261 "upstreamActorId",
11262 "upstream_fragment_id",
11263 "upstreamFragmentId",
11264 "upstream_dispatcher_type",
11265 "upstreamDispatcherType",
11266 "fields",
11267 "allow_empty_upstream",
11268 "allowEmptyUpstream",
11269 ];
11270
11271 #[allow(clippy::enum_variant_names)]
11272 enum GeneratedField {
11273 UpstreamActorId,
11274 UpstreamFragmentId,
11275 UpstreamDispatcherType,
11276 Fields,
11277 AllowEmptyUpstream,
11278 }
11279 impl<'de> serde::Deserialize<'de> for GeneratedField {
11280 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11281 where
11282 D: serde::Deserializer<'de>,
11283 {
11284 struct GeneratedVisitor;
11285
11286 impl serde::de::Visitor<'_> for GeneratedVisitor {
11287 type Value = GeneratedField;
11288
11289 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11290 write!(formatter, "expected one of: {:?}", &FIELDS)
11291 }
11292
11293 #[allow(unused_variables)]
11294 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11295 where
11296 E: serde::de::Error,
11297 {
11298 match value {
11299 "upstreamActorId" | "upstream_actor_id" => Ok(GeneratedField::UpstreamActorId),
11300 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
11301 "upstreamDispatcherType" | "upstream_dispatcher_type" => Ok(GeneratedField::UpstreamDispatcherType),
11302 "fields" => Ok(GeneratedField::Fields),
11303 "allowEmptyUpstream" | "allow_empty_upstream" => Ok(GeneratedField::AllowEmptyUpstream),
11304 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11305 }
11306 }
11307 }
11308 deserializer.deserialize_identifier(GeneratedVisitor)
11309 }
11310 }
11311 struct GeneratedVisitor;
11312 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11313 type Value = MergeNode;
11314
11315 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11316 formatter.write_str("struct stream_plan.MergeNode")
11317 }
11318
11319 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeNode, V::Error>
11320 where
11321 V: serde::de::MapAccess<'de>,
11322 {
11323 let mut upstream_actor_id__ = None;
11324 let mut upstream_fragment_id__ = None;
11325 let mut upstream_dispatcher_type__ = None;
11326 let mut fields__ = None;
11327 let mut allow_empty_upstream__ = None;
11328 while let Some(k) = map_.next_key()? {
11329 match k {
11330 GeneratedField::UpstreamActorId => {
11331 if upstream_actor_id__.is_some() {
11332 return Err(serde::de::Error::duplicate_field("upstreamActorId"));
11333 }
11334 upstream_actor_id__ =
11335 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11336 .into_iter().map(|x| x.0).collect())
11337 ;
11338 }
11339 GeneratedField::UpstreamFragmentId => {
11340 if upstream_fragment_id__.is_some() {
11341 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
11342 }
11343 upstream_fragment_id__ =
11344 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11345 ;
11346 }
11347 GeneratedField::UpstreamDispatcherType => {
11348 if upstream_dispatcher_type__.is_some() {
11349 return Err(serde::de::Error::duplicate_field("upstreamDispatcherType"));
11350 }
11351 upstream_dispatcher_type__ = Some(map_.next_value::<DispatcherType>()? as i32);
11352 }
11353 GeneratedField::Fields => {
11354 if fields__.is_some() {
11355 return Err(serde::de::Error::duplicate_field("fields"));
11356 }
11357 fields__ = Some(map_.next_value()?);
11358 }
11359 GeneratedField::AllowEmptyUpstream => {
11360 if allow_empty_upstream__.is_some() {
11361 return Err(serde::de::Error::duplicate_field("allowEmptyUpstream"));
11362 }
11363 allow_empty_upstream__ = Some(map_.next_value()?);
11364 }
11365 }
11366 }
11367 Ok(MergeNode {
11368 upstream_actor_id: upstream_actor_id__.unwrap_or_default(),
11369 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
11370 upstream_dispatcher_type: upstream_dispatcher_type__.unwrap_or_default(),
11371 fields: fields__.unwrap_or_default(),
11372 allow_empty_upstream: allow_empty_upstream__.unwrap_or_default(),
11373 })
11374 }
11375 }
11376 deserializer.deserialize_struct("stream_plan.MergeNode", FIELDS, GeneratedVisitor)
11377 }
11378}
11379impl serde::Serialize for NoOpNode {
11380 #[allow(deprecated)]
11381 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11382 where
11383 S: serde::Serializer,
11384 {
11385 use serde::ser::SerializeStruct;
11386 let len = 0;
11387 let struct_ser = serializer.serialize_struct("stream_plan.NoOpNode", len)?;
11388 struct_ser.end()
11389 }
11390}
11391impl<'de> serde::Deserialize<'de> for NoOpNode {
11392 #[allow(deprecated)]
11393 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11394 where
11395 D: serde::Deserializer<'de>,
11396 {
11397 const FIELDS: &[&str] = &[
11398 ];
11399
11400 #[allow(clippy::enum_variant_names)]
11401 enum GeneratedField {
11402 }
11403 impl<'de> serde::Deserialize<'de> for GeneratedField {
11404 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11405 where
11406 D: serde::Deserializer<'de>,
11407 {
11408 struct GeneratedVisitor;
11409
11410 impl serde::de::Visitor<'_> for GeneratedVisitor {
11411 type Value = GeneratedField;
11412
11413 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11414 write!(formatter, "expected one of: {:?}", &FIELDS)
11415 }
11416
11417 #[allow(unused_variables)]
11418 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11419 where
11420 E: serde::de::Error,
11421 {
11422 Err(serde::de::Error::unknown_field(value, FIELDS))
11423 }
11424 }
11425 deserializer.deserialize_identifier(GeneratedVisitor)
11426 }
11427 }
11428 struct GeneratedVisitor;
11429 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11430 type Value = NoOpNode;
11431
11432 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11433 formatter.write_str("struct stream_plan.NoOpNode")
11434 }
11435
11436 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NoOpNode, V::Error>
11437 where
11438 V: serde::de::MapAccess<'de>,
11439 {
11440 while map_.next_key::<GeneratedField>()?.is_some() {
11441 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11442 }
11443 Ok(NoOpNode {
11444 })
11445 }
11446 }
11447 deserializer.deserialize_struct("stream_plan.NoOpNode", FIELDS, GeneratedVisitor)
11448 }
11449}
11450impl serde::Serialize for NowModeGenerateSeries {
11451 #[allow(deprecated)]
11452 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11453 where
11454 S: serde::Serializer,
11455 {
11456 use serde::ser::SerializeStruct;
11457 let mut len = 0;
11458 if self.start_timestamp.is_some() {
11459 len += 1;
11460 }
11461 if self.interval.is_some() {
11462 len += 1;
11463 }
11464 let mut struct_ser = serializer.serialize_struct("stream_plan.NowModeGenerateSeries", len)?;
11465 if let Some(v) = self.start_timestamp.as_ref() {
11466 struct_ser.serialize_field("startTimestamp", v)?;
11467 }
11468 if let Some(v) = self.interval.as_ref() {
11469 struct_ser.serialize_field("interval", v)?;
11470 }
11471 struct_ser.end()
11472 }
11473}
11474impl<'de> serde::Deserialize<'de> for NowModeGenerateSeries {
11475 #[allow(deprecated)]
11476 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11477 where
11478 D: serde::Deserializer<'de>,
11479 {
11480 const FIELDS: &[&str] = &[
11481 "start_timestamp",
11482 "startTimestamp",
11483 "interval",
11484 ];
11485
11486 #[allow(clippy::enum_variant_names)]
11487 enum GeneratedField {
11488 StartTimestamp,
11489 Interval,
11490 }
11491 impl<'de> serde::Deserialize<'de> for GeneratedField {
11492 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11493 where
11494 D: serde::Deserializer<'de>,
11495 {
11496 struct GeneratedVisitor;
11497
11498 impl serde::de::Visitor<'_> for GeneratedVisitor {
11499 type Value = GeneratedField;
11500
11501 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11502 write!(formatter, "expected one of: {:?}", &FIELDS)
11503 }
11504
11505 #[allow(unused_variables)]
11506 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11507 where
11508 E: serde::de::Error,
11509 {
11510 match value {
11511 "startTimestamp" | "start_timestamp" => Ok(GeneratedField::StartTimestamp),
11512 "interval" => Ok(GeneratedField::Interval),
11513 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11514 }
11515 }
11516 }
11517 deserializer.deserialize_identifier(GeneratedVisitor)
11518 }
11519 }
11520 struct GeneratedVisitor;
11521 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11522 type Value = NowModeGenerateSeries;
11523
11524 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11525 formatter.write_str("struct stream_plan.NowModeGenerateSeries")
11526 }
11527
11528 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeGenerateSeries, V::Error>
11529 where
11530 V: serde::de::MapAccess<'de>,
11531 {
11532 let mut start_timestamp__ = None;
11533 let mut interval__ = None;
11534 while let Some(k) = map_.next_key()? {
11535 match k {
11536 GeneratedField::StartTimestamp => {
11537 if start_timestamp__.is_some() {
11538 return Err(serde::de::Error::duplicate_field("startTimestamp"));
11539 }
11540 start_timestamp__ = map_.next_value()?;
11541 }
11542 GeneratedField::Interval => {
11543 if interval__.is_some() {
11544 return Err(serde::de::Error::duplicate_field("interval"));
11545 }
11546 interval__ = map_.next_value()?;
11547 }
11548 }
11549 }
11550 Ok(NowModeGenerateSeries {
11551 start_timestamp: start_timestamp__,
11552 interval: interval__,
11553 })
11554 }
11555 }
11556 deserializer.deserialize_struct("stream_plan.NowModeGenerateSeries", FIELDS, GeneratedVisitor)
11557 }
11558}
11559impl serde::Serialize for NowModeUpdateCurrent {
11560 #[allow(deprecated)]
11561 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11562 where
11563 S: serde::Serializer,
11564 {
11565 use serde::ser::SerializeStruct;
11566 let len = 0;
11567 let struct_ser = serializer.serialize_struct("stream_plan.NowModeUpdateCurrent", len)?;
11568 struct_ser.end()
11569 }
11570}
11571impl<'de> serde::Deserialize<'de> for NowModeUpdateCurrent {
11572 #[allow(deprecated)]
11573 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11574 where
11575 D: serde::Deserializer<'de>,
11576 {
11577 const FIELDS: &[&str] = &[
11578 ];
11579
11580 #[allow(clippy::enum_variant_names)]
11581 enum GeneratedField {
11582 }
11583 impl<'de> serde::Deserialize<'de> for GeneratedField {
11584 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11585 where
11586 D: serde::Deserializer<'de>,
11587 {
11588 struct GeneratedVisitor;
11589
11590 impl serde::de::Visitor<'_> for GeneratedVisitor {
11591 type Value = GeneratedField;
11592
11593 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11594 write!(formatter, "expected one of: {:?}", &FIELDS)
11595 }
11596
11597 #[allow(unused_variables)]
11598 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11599 where
11600 E: serde::de::Error,
11601 {
11602 Err(serde::de::Error::unknown_field(value, FIELDS))
11603 }
11604 }
11605 deserializer.deserialize_identifier(GeneratedVisitor)
11606 }
11607 }
11608 struct GeneratedVisitor;
11609 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11610 type Value = NowModeUpdateCurrent;
11611
11612 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11613 formatter.write_str("struct stream_plan.NowModeUpdateCurrent")
11614 }
11615
11616 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeUpdateCurrent, V::Error>
11617 where
11618 V: serde::de::MapAccess<'de>,
11619 {
11620 while map_.next_key::<GeneratedField>()?.is_some() {
11621 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11622 }
11623 Ok(NowModeUpdateCurrent {
11624 })
11625 }
11626 }
11627 deserializer.deserialize_struct("stream_plan.NowModeUpdateCurrent", FIELDS, GeneratedVisitor)
11628 }
11629}
11630impl serde::Serialize for NowNode {
11631 #[allow(deprecated)]
11632 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11633 where
11634 S: serde::Serializer,
11635 {
11636 use serde::ser::SerializeStruct;
11637 let mut len = 0;
11638 if self.state_table.is_some() {
11639 len += 1;
11640 }
11641 if self.mode.is_some() {
11642 len += 1;
11643 }
11644 let mut struct_ser = serializer.serialize_struct("stream_plan.NowNode", len)?;
11645 if let Some(v) = self.state_table.as_ref() {
11646 struct_ser.serialize_field("stateTable", v)?;
11647 }
11648 if let Some(v) = self.mode.as_ref() {
11649 match v {
11650 now_node::Mode::UpdateCurrent(v) => {
11651 struct_ser.serialize_field("updateCurrent", v)?;
11652 }
11653 now_node::Mode::GenerateSeries(v) => {
11654 struct_ser.serialize_field("generateSeries", v)?;
11655 }
11656 }
11657 }
11658 struct_ser.end()
11659 }
11660}
11661impl<'de> serde::Deserialize<'de> for NowNode {
11662 #[allow(deprecated)]
11663 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11664 where
11665 D: serde::Deserializer<'de>,
11666 {
11667 const FIELDS: &[&str] = &[
11668 "state_table",
11669 "stateTable",
11670 "update_current",
11671 "updateCurrent",
11672 "generate_series",
11673 "generateSeries",
11674 ];
11675
11676 #[allow(clippy::enum_variant_names)]
11677 enum GeneratedField {
11678 StateTable,
11679 UpdateCurrent,
11680 GenerateSeries,
11681 }
11682 impl<'de> serde::Deserialize<'de> for GeneratedField {
11683 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11684 where
11685 D: serde::Deserializer<'de>,
11686 {
11687 struct GeneratedVisitor;
11688
11689 impl serde::de::Visitor<'_> for GeneratedVisitor {
11690 type Value = GeneratedField;
11691
11692 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11693 write!(formatter, "expected one of: {:?}", &FIELDS)
11694 }
11695
11696 #[allow(unused_variables)]
11697 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11698 where
11699 E: serde::de::Error,
11700 {
11701 match value {
11702 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11703 "updateCurrent" | "update_current" => Ok(GeneratedField::UpdateCurrent),
11704 "generateSeries" | "generate_series" => Ok(GeneratedField::GenerateSeries),
11705 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11706 }
11707 }
11708 }
11709 deserializer.deserialize_identifier(GeneratedVisitor)
11710 }
11711 }
11712 struct GeneratedVisitor;
11713 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11714 type Value = NowNode;
11715
11716 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11717 formatter.write_str("struct stream_plan.NowNode")
11718 }
11719
11720 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowNode, V::Error>
11721 where
11722 V: serde::de::MapAccess<'de>,
11723 {
11724 let mut state_table__ = None;
11725 let mut mode__ = None;
11726 while let Some(k) = map_.next_key()? {
11727 match k {
11728 GeneratedField::StateTable => {
11729 if state_table__.is_some() {
11730 return Err(serde::de::Error::duplicate_field("stateTable"));
11731 }
11732 state_table__ = map_.next_value()?;
11733 }
11734 GeneratedField::UpdateCurrent => {
11735 if mode__.is_some() {
11736 return Err(serde::de::Error::duplicate_field("updateCurrent"));
11737 }
11738 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::UpdateCurrent)
11739;
11740 }
11741 GeneratedField::GenerateSeries => {
11742 if mode__.is_some() {
11743 return Err(serde::de::Error::duplicate_field("generateSeries"));
11744 }
11745 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::GenerateSeries)
11746;
11747 }
11748 }
11749 }
11750 Ok(NowNode {
11751 state_table: state_table__,
11752 mode: mode__,
11753 })
11754 }
11755 }
11756 deserializer.deserialize_struct("stream_plan.NowNode", FIELDS, GeneratedVisitor)
11757 }
11758}
11759impl serde::Serialize for OverWindowCachePolicy {
11760 #[allow(deprecated)]
11761 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11762 where
11763 S: serde::Serializer,
11764 {
11765 let variant = match self {
11766 Self::Unspecified => "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
11767 Self::Full => "OVER_WINDOW_CACHE_POLICY_FULL",
11768 Self::Recent => "OVER_WINDOW_CACHE_POLICY_RECENT",
11769 Self::RecentFirstN => "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
11770 Self::RecentLastN => "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
11771 };
11772 serializer.serialize_str(variant)
11773 }
11774}
11775impl<'de> serde::Deserialize<'de> for OverWindowCachePolicy {
11776 #[allow(deprecated)]
11777 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11778 where
11779 D: serde::Deserializer<'de>,
11780 {
11781 const FIELDS: &[&str] = &[
11782 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
11783 "OVER_WINDOW_CACHE_POLICY_FULL",
11784 "OVER_WINDOW_CACHE_POLICY_RECENT",
11785 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
11786 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
11787 ];
11788
11789 struct GeneratedVisitor;
11790
11791 impl serde::de::Visitor<'_> for GeneratedVisitor {
11792 type Value = OverWindowCachePolicy;
11793
11794 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11795 write!(formatter, "expected one of: {:?}", &FIELDS)
11796 }
11797
11798 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
11799 where
11800 E: serde::de::Error,
11801 {
11802 i32::try_from(v)
11803 .ok()
11804 .and_then(|x| x.try_into().ok())
11805 .ok_or_else(|| {
11806 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
11807 })
11808 }
11809
11810 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
11811 where
11812 E: serde::de::Error,
11813 {
11814 i32::try_from(v)
11815 .ok()
11816 .and_then(|x| x.try_into().ok())
11817 .ok_or_else(|| {
11818 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
11819 })
11820 }
11821
11822 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
11823 where
11824 E: serde::de::Error,
11825 {
11826 match value {
11827 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED" => Ok(OverWindowCachePolicy::Unspecified),
11828 "OVER_WINDOW_CACHE_POLICY_FULL" => Ok(OverWindowCachePolicy::Full),
11829 "OVER_WINDOW_CACHE_POLICY_RECENT" => Ok(OverWindowCachePolicy::Recent),
11830 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N" => Ok(OverWindowCachePolicy::RecentFirstN),
11831 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N" => Ok(OverWindowCachePolicy::RecentLastN),
11832 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
11833 }
11834 }
11835 }
11836 deserializer.deserialize_any(GeneratedVisitor)
11837 }
11838}
11839impl serde::Serialize for OverWindowNode {
11840 #[allow(deprecated)]
11841 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11842 where
11843 S: serde::Serializer,
11844 {
11845 use serde::ser::SerializeStruct;
11846 let mut len = 0;
11847 if !self.calls.is_empty() {
11848 len += 1;
11849 }
11850 if !self.partition_by.is_empty() {
11851 len += 1;
11852 }
11853 if !self.order_by.is_empty() {
11854 len += 1;
11855 }
11856 if self.state_table.is_some() {
11857 len += 1;
11858 }
11859 if self.cache_policy != 0 {
11860 len += 1;
11861 }
11862 if self.enable_state_cleaning {
11863 len += 1;
11864 }
11865 let mut struct_ser = serializer.serialize_struct("stream_plan.OverWindowNode", len)?;
11866 if !self.calls.is_empty() {
11867 struct_ser.serialize_field("calls", &self.calls)?;
11868 }
11869 if !self.partition_by.is_empty() {
11870 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
11871 }
11872 if !self.order_by.is_empty() {
11873 struct_ser.serialize_field("orderBy", &self.order_by)?;
11874 }
11875 if let Some(v) = self.state_table.as_ref() {
11876 struct_ser.serialize_field("stateTable", v)?;
11877 }
11878 if self.cache_policy != 0 {
11879 let v = OverWindowCachePolicy::try_from(self.cache_policy)
11880 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cache_policy)))?;
11881 struct_ser.serialize_field("cachePolicy", &v)?;
11882 }
11883 if self.enable_state_cleaning {
11884 struct_ser.serialize_field("enableStateCleaning", &self.enable_state_cleaning)?;
11885 }
11886 struct_ser.end()
11887 }
11888}
11889impl<'de> serde::Deserialize<'de> for OverWindowNode {
11890 #[allow(deprecated)]
11891 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11892 where
11893 D: serde::Deserializer<'de>,
11894 {
11895 const FIELDS: &[&str] = &[
11896 "calls",
11897 "partition_by",
11898 "partitionBy",
11899 "order_by",
11900 "orderBy",
11901 "state_table",
11902 "stateTable",
11903 "cache_policy",
11904 "cachePolicy",
11905 "enable_state_cleaning",
11906 "enableStateCleaning",
11907 ];
11908
11909 #[allow(clippy::enum_variant_names)]
11910 enum GeneratedField {
11911 Calls,
11912 PartitionBy,
11913 OrderBy,
11914 StateTable,
11915 CachePolicy,
11916 EnableStateCleaning,
11917 }
11918 impl<'de> serde::Deserialize<'de> for GeneratedField {
11919 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11920 where
11921 D: serde::Deserializer<'de>,
11922 {
11923 struct GeneratedVisitor;
11924
11925 impl serde::de::Visitor<'_> for GeneratedVisitor {
11926 type Value = GeneratedField;
11927
11928 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11929 write!(formatter, "expected one of: {:?}", &FIELDS)
11930 }
11931
11932 #[allow(unused_variables)]
11933 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11934 where
11935 E: serde::de::Error,
11936 {
11937 match value {
11938 "calls" => Ok(GeneratedField::Calls),
11939 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
11940 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
11941 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11942 "cachePolicy" | "cache_policy" => Ok(GeneratedField::CachePolicy),
11943 "enableStateCleaning" | "enable_state_cleaning" => Ok(GeneratedField::EnableStateCleaning),
11944 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11945 }
11946 }
11947 }
11948 deserializer.deserialize_identifier(GeneratedVisitor)
11949 }
11950 }
11951 struct GeneratedVisitor;
11952 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11953 type Value = OverWindowNode;
11954
11955 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11956 formatter.write_str("struct stream_plan.OverWindowNode")
11957 }
11958
11959 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverWindowNode, V::Error>
11960 where
11961 V: serde::de::MapAccess<'de>,
11962 {
11963 let mut calls__ = None;
11964 let mut partition_by__ = None;
11965 let mut order_by__ = None;
11966 let mut state_table__ = None;
11967 let mut cache_policy__ = None;
11968 let mut enable_state_cleaning__ = None;
11969 while let Some(k) = map_.next_key()? {
11970 match k {
11971 GeneratedField::Calls => {
11972 if calls__.is_some() {
11973 return Err(serde::de::Error::duplicate_field("calls"));
11974 }
11975 calls__ = Some(map_.next_value()?);
11976 }
11977 GeneratedField::PartitionBy => {
11978 if partition_by__.is_some() {
11979 return Err(serde::de::Error::duplicate_field("partitionBy"));
11980 }
11981 partition_by__ =
11982 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11983 .into_iter().map(|x| x.0).collect())
11984 ;
11985 }
11986 GeneratedField::OrderBy => {
11987 if order_by__.is_some() {
11988 return Err(serde::de::Error::duplicate_field("orderBy"));
11989 }
11990 order_by__ = Some(map_.next_value()?);
11991 }
11992 GeneratedField::StateTable => {
11993 if state_table__.is_some() {
11994 return Err(serde::de::Error::duplicate_field("stateTable"));
11995 }
11996 state_table__ = map_.next_value()?;
11997 }
11998 GeneratedField::CachePolicy => {
11999 if cache_policy__.is_some() {
12000 return Err(serde::de::Error::duplicate_field("cachePolicy"));
12001 }
12002 cache_policy__ = Some(map_.next_value::<OverWindowCachePolicy>()? as i32);
12003 }
12004 GeneratedField::EnableStateCleaning => {
12005 if enable_state_cleaning__.is_some() {
12006 return Err(serde::de::Error::duplicate_field("enableStateCleaning"));
12007 }
12008 enable_state_cleaning__ = Some(map_.next_value()?);
12009 }
12010 }
12011 }
12012 Ok(OverWindowNode {
12013 calls: calls__.unwrap_or_default(),
12014 partition_by: partition_by__.unwrap_or_default(),
12015 order_by: order_by__.unwrap_or_default(),
12016 state_table: state_table__,
12017 cache_policy: cache_policy__.unwrap_or_default(),
12018 enable_state_cleaning: enable_state_cleaning__.unwrap_or_default(),
12019 })
12020 }
12021 }
12022 deserializer.deserialize_struct("stream_plan.OverWindowNode", FIELDS, GeneratedVisitor)
12023 }
12024}
12025impl serde::Serialize for PauseMutation {
12026 #[allow(deprecated)]
12027 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12028 where
12029 S: serde::Serializer,
12030 {
12031 use serde::ser::SerializeStruct;
12032 let len = 0;
12033 let struct_ser = serializer.serialize_struct("stream_plan.PauseMutation", len)?;
12034 struct_ser.end()
12035 }
12036}
12037impl<'de> serde::Deserialize<'de> for PauseMutation {
12038 #[allow(deprecated)]
12039 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12040 where
12041 D: serde::Deserializer<'de>,
12042 {
12043 const FIELDS: &[&str] = &[
12044 ];
12045
12046 #[allow(clippy::enum_variant_names)]
12047 enum GeneratedField {
12048 }
12049 impl<'de> serde::Deserialize<'de> for GeneratedField {
12050 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12051 where
12052 D: serde::Deserializer<'de>,
12053 {
12054 struct GeneratedVisitor;
12055
12056 impl serde::de::Visitor<'_> for GeneratedVisitor {
12057 type Value = GeneratedField;
12058
12059 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12060 write!(formatter, "expected one of: {:?}", &FIELDS)
12061 }
12062
12063 #[allow(unused_variables)]
12064 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12065 where
12066 E: serde::de::Error,
12067 {
12068 Err(serde::de::Error::unknown_field(value, FIELDS))
12069 }
12070 }
12071 deserializer.deserialize_identifier(GeneratedVisitor)
12072 }
12073 }
12074 struct GeneratedVisitor;
12075 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12076 type Value = PauseMutation;
12077
12078 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12079 formatter.write_str("struct stream_plan.PauseMutation")
12080 }
12081
12082 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseMutation, V::Error>
12083 where
12084 V: serde::de::MapAccess<'de>,
12085 {
12086 while map_.next_key::<GeneratedField>()?.is_some() {
12087 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12088 }
12089 Ok(PauseMutation {
12090 })
12091 }
12092 }
12093 deserializer.deserialize_struct("stream_plan.PauseMutation", FIELDS, GeneratedVisitor)
12094 }
12095}
12096impl serde::Serialize for ProjectNode {
12097 #[allow(deprecated)]
12098 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12099 where
12100 S: serde::Serializer,
12101 {
12102 use serde::ser::SerializeStruct;
12103 let mut len = 0;
12104 if !self.select_list.is_empty() {
12105 len += 1;
12106 }
12107 if !self.watermark_input_cols.is_empty() {
12108 len += 1;
12109 }
12110 if !self.watermark_output_cols.is_empty() {
12111 len += 1;
12112 }
12113 if !self.nondecreasing_exprs.is_empty() {
12114 len += 1;
12115 }
12116 if self.noop_update_hint {
12117 len += 1;
12118 }
12119 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectNode", len)?;
12120 if !self.select_list.is_empty() {
12121 struct_ser.serialize_field("selectList", &self.select_list)?;
12122 }
12123 if !self.watermark_input_cols.is_empty() {
12124 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
12125 }
12126 if !self.watermark_output_cols.is_empty() {
12127 struct_ser.serialize_field("watermarkOutputCols", &self.watermark_output_cols)?;
12128 }
12129 if !self.nondecreasing_exprs.is_empty() {
12130 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
12131 }
12132 if self.noop_update_hint {
12133 struct_ser.serialize_field("noopUpdateHint", &self.noop_update_hint)?;
12134 }
12135 struct_ser.end()
12136 }
12137}
12138impl<'de> serde::Deserialize<'de> for ProjectNode {
12139 #[allow(deprecated)]
12140 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12141 where
12142 D: serde::Deserializer<'de>,
12143 {
12144 const FIELDS: &[&str] = &[
12145 "select_list",
12146 "selectList",
12147 "watermark_input_cols",
12148 "watermarkInputCols",
12149 "watermark_output_cols",
12150 "watermarkOutputCols",
12151 "nondecreasing_exprs",
12152 "nondecreasingExprs",
12153 "noop_update_hint",
12154 "noopUpdateHint",
12155 ];
12156
12157 #[allow(clippy::enum_variant_names)]
12158 enum GeneratedField {
12159 SelectList,
12160 WatermarkInputCols,
12161 WatermarkOutputCols,
12162 NondecreasingExprs,
12163 NoopUpdateHint,
12164 }
12165 impl<'de> serde::Deserialize<'de> for GeneratedField {
12166 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12167 where
12168 D: serde::Deserializer<'de>,
12169 {
12170 struct GeneratedVisitor;
12171
12172 impl serde::de::Visitor<'_> for GeneratedVisitor {
12173 type Value = GeneratedField;
12174
12175 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12176 write!(formatter, "expected one of: {:?}", &FIELDS)
12177 }
12178
12179 #[allow(unused_variables)]
12180 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12181 where
12182 E: serde::de::Error,
12183 {
12184 match value {
12185 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
12186 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
12187 "watermarkOutputCols" | "watermark_output_cols" => Ok(GeneratedField::WatermarkOutputCols),
12188 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
12189 "noopUpdateHint" | "noop_update_hint" => Ok(GeneratedField::NoopUpdateHint),
12190 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12191 }
12192 }
12193 }
12194 deserializer.deserialize_identifier(GeneratedVisitor)
12195 }
12196 }
12197 struct GeneratedVisitor;
12198 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12199 type Value = ProjectNode;
12200
12201 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12202 formatter.write_str("struct stream_plan.ProjectNode")
12203 }
12204
12205 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
12206 where
12207 V: serde::de::MapAccess<'de>,
12208 {
12209 let mut select_list__ = None;
12210 let mut watermark_input_cols__ = None;
12211 let mut watermark_output_cols__ = None;
12212 let mut nondecreasing_exprs__ = None;
12213 let mut noop_update_hint__ = None;
12214 while let Some(k) = map_.next_key()? {
12215 match k {
12216 GeneratedField::SelectList => {
12217 if select_list__.is_some() {
12218 return Err(serde::de::Error::duplicate_field("selectList"));
12219 }
12220 select_list__ = Some(map_.next_value()?);
12221 }
12222 GeneratedField::WatermarkInputCols => {
12223 if watermark_input_cols__.is_some() {
12224 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
12225 }
12226 watermark_input_cols__ =
12227 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12228 .into_iter().map(|x| x.0).collect())
12229 ;
12230 }
12231 GeneratedField::WatermarkOutputCols => {
12232 if watermark_output_cols__.is_some() {
12233 return Err(serde::de::Error::duplicate_field("watermarkOutputCols"));
12234 }
12235 watermark_output_cols__ =
12236 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12237 .into_iter().map(|x| x.0).collect())
12238 ;
12239 }
12240 GeneratedField::NondecreasingExprs => {
12241 if nondecreasing_exprs__.is_some() {
12242 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
12243 }
12244 nondecreasing_exprs__ =
12245 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12246 .into_iter().map(|x| x.0).collect())
12247 ;
12248 }
12249 GeneratedField::NoopUpdateHint => {
12250 if noop_update_hint__.is_some() {
12251 return Err(serde::de::Error::duplicate_field("noopUpdateHint"));
12252 }
12253 noop_update_hint__ = Some(map_.next_value()?);
12254 }
12255 }
12256 }
12257 Ok(ProjectNode {
12258 select_list: select_list__.unwrap_or_default(),
12259 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
12260 watermark_output_cols: watermark_output_cols__.unwrap_or_default(),
12261 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
12262 noop_update_hint: noop_update_hint__.unwrap_or_default(),
12263 })
12264 }
12265 }
12266 deserializer.deserialize_struct("stream_plan.ProjectNode", FIELDS, GeneratedVisitor)
12267 }
12268}
12269impl serde::Serialize for ProjectSetNode {
12270 #[allow(deprecated)]
12271 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12272 where
12273 S: serde::Serializer,
12274 {
12275 use serde::ser::SerializeStruct;
12276 let mut len = 0;
12277 if !self.select_list.is_empty() {
12278 len += 1;
12279 }
12280 if !self.watermark_input_cols.is_empty() {
12281 len += 1;
12282 }
12283 if !self.watermark_expr_indices.is_empty() {
12284 len += 1;
12285 }
12286 if !self.nondecreasing_exprs.is_empty() {
12287 len += 1;
12288 }
12289 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectSetNode", len)?;
12290 if !self.select_list.is_empty() {
12291 struct_ser.serialize_field("selectList", &self.select_list)?;
12292 }
12293 if !self.watermark_input_cols.is_empty() {
12294 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
12295 }
12296 if !self.watermark_expr_indices.is_empty() {
12297 struct_ser.serialize_field("watermarkExprIndices", &self.watermark_expr_indices)?;
12298 }
12299 if !self.nondecreasing_exprs.is_empty() {
12300 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
12301 }
12302 struct_ser.end()
12303 }
12304}
12305impl<'de> serde::Deserialize<'de> for ProjectSetNode {
12306 #[allow(deprecated)]
12307 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12308 where
12309 D: serde::Deserializer<'de>,
12310 {
12311 const FIELDS: &[&str] = &[
12312 "select_list",
12313 "selectList",
12314 "watermark_input_cols",
12315 "watermarkInputCols",
12316 "watermark_expr_indices",
12317 "watermarkExprIndices",
12318 "nondecreasing_exprs",
12319 "nondecreasingExprs",
12320 ];
12321
12322 #[allow(clippy::enum_variant_names)]
12323 enum GeneratedField {
12324 SelectList,
12325 WatermarkInputCols,
12326 WatermarkExprIndices,
12327 NondecreasingExprs,
12328 }
12329 impl<'de> serde::Deserialize<'de> for GeneratedField {
12330 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12331 where
12332 D: serde::Deserializer<'de>,
12333 {
12334 struct GeneratedVisitor;
12335
12336 impl serde::de::Visitor<'_> for GeneratedVisitor {
12337 type Value = GeneratedField;
12338
12339 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12340 write!(formatter, "expected one of: {:?}", &FIELDS)
12341 }
12342
12343 #[allow(unused_variables)]
12344 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12345 where
12346 E: serde::de::Error,
12347 {
12348 match value {
12349 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
12350 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
12351 "watermarkExprIndices" | "watermark_expr_indices" => Ok(GeneratedField::WatermarkExprIndices),
12352 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
12353 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12354 }
12355 }
12356 }
12357 deserializer.deserialize_identifier(GeneratedVisitor)
12358 }
12359 }
12360 struct GeneratedVisitor;
12361 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12362 type Value = ProjectSetNode;
12363
12364 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12365 formatter.write_str("struct stream_plan.ProjectSetNode")
12366 }
12367
12368 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
12369 where
12370 V: serde::de::MapAccess<'de>,
12371 {
12372 let mut select_list__ = None;
12373 let mut watermark_input_cols__ = None;
12374 let mut watermark_expr_indices__ = None;
12375 let mut nondecreasing_exprs__ = None;
12376 while let Some(k) = map_.next_key()? {
12377 match k {
12378 GeneratedField::SelectList => {
12379 if select_list__.is_some() {
12380 return Err(serde::de::Error::duplicate_field("selectList"));
12381 }
12382 select_list__ = Some(map_.next_value()?);
12383 }
12384 GeneratedField::WatermarkInputCols => {
12385 if watermark_input_cols__.is_some() {
12386 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
12387 }
12388 watermark_input_cols__ =
12389 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12390 .into_iter().map(|x| x.0).collect())
12391 ;
12392 }
12393 GeneratedField::WatermarkExprIndices => {
12394 if watermark_expr_indices__.is_some() {
12395 return Err(serde::de::Error::duplicate_field("watermarkExprIndices"));
12396 }
12397 watermark_expr_indices__ =
12398 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12399 .into_iter().map(|x| x.0).collect())
12400 ;
12401 }
12402 GeneratedField::NondecreasingExprs => {
12403 if nondecreasing_exprs__.is_some() {
12404 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
12405 }
12406 nondecreasing_exprs__ =
12407 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12408 .into_iter().map(|x| x.0).collect())
12409 ;
12410 }
12411 }
12412 }
12413 Ok(ProjectSetNode {
12414 select_list: select_list__.unwrap_or_default(),
12415 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
12416 watermark_expr_indices: watermark_expr_indices__.unwrap_or_default(),
12417 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
12418 })
12419 }
12420 }
12421 deserializer.deserialize_struct("stream_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
12422 }
12423}
12424impl serde::Serialize for RefreshStartMutation {
12425 #[allow(deprecated)]
12426 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12427 where
12428 S: serde::Serializer,
12429 {
12430 use serde::ser::SerializeStruct;
12431 let mut len = 0;
12432 if self.table_id != 0 {
12433 len += 1;
12434 }
12435 if self.associated_source_id != 0 {
12436 len += 1;
12437 }
12438 let mut struct_ser = serializer.serialize_struct("stream_plan.RefreshStartMutation", len)?;
12439 if self.table_id != 0 {
12440 struct_ser.serialize_field("tableId", &self.table_id)?;
12441 }
12442 if self.associated_source_id != 0 {
12443 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
12444 }
12445 struct_ser.end()
12446 }
12447}
12448impl<'de> serde::Deserialize<'de> for RefreshStartMutation {
12449 #[allow(deprecated)]
12450 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12451 where
12452 D: serde::Deserializer<'de>,
12453 {
12454 const FIELDS: &[&str] = &[
12455 "table_id",
12456 "tableId",
12457 "associated_source_id",
12458 "associatedSourceId",
12459 ];
12460
12461 #[allow(clippy::enum_variant_names)]
12462 enum GeneratedField {
12463 TableId,
12464 AssociatedSourceId,
12465 }
12466 impl<'de> serde::Deserialize<'de> for GeneratedField {
12467 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12468 where
12469 D: serde::Deserializer<'de>,
12470 {
12471 struct GeneratedVisitor;
12472
12473 impl serde::de::Visitor<'_> for GeneratedVisitor {
12474 type Value = GeneratedField;
12475
12476 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12477 write!(formatter, "expected one of: {:?}", &FIELDS)
12478 }
12479
12480 #[allow(unused_variables)]
12481 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12482 where
12483 E: serde::de::Error,
12484 {
12485 match value {
12486 "tableId" | "table_id" => Ok(GeneratedField::TableId),
12487 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
12488 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12489 }
12490 }
12491 }
12492 deserializer.deserialize_identifier(GeneratedVisitor)
12493 }
12494 }
12495 struct GeneratedVisitor;
12496 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12497 type Value = RefreshStartMutation;
12498
12499 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12500 formatter.write_str("struct stream_plan.RefreshStartMutation")
12501 }
12502
12503 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshStartMutation, V::Error>
12504 where
12505 V: serde::de::MapAccess<'de>,
12506 {
12507 let mut table_id__ = None;
12508 let mut associated_source_id__ = None;
12509 while let Some(k) = map_.next_key()? {
12510 match k {
12511 GeneratedField::TableId => {
12512 if table_id__.is_some() {
12513 return Err(serde::de::Error::duplicate_field("tableId"));
12514 }
12515 table_id__ =
12516 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12517 ;
12518 }
12519 GeneratedField::AssociatedSourceId => {
12520 if associated_source_id__.is_some() {
12521 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
12522 }
12523 associated_source_id__ =
12524 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12525 ;
12526 }
12527 }
12528 }
12529 Ok(RefreshStartMutation {
12530 table_id: table_id__.unwrap_or_default(),
12531 associated_source_id: associated_source_id__.unwrap_or_default(),
12532 })
12533 }
12534 }
12535 deserializer.deserialize_struct("stream_plan.RefreshStartMutation", FIELDS, GeneratedVisitor)
12536 }
12537}
12538impl serde::Serialize for ResetSourceMutation {
12539 #[allow(deprecated)]
12540 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12541 where
12542 S: serde::Serializer,
12543 {
12544 use serde::ser::SerializeStruct;
12545 let mut len = 0;
12546 if self.source_id != 0 {
12547 len += 1;
12548 }
12549 let mut struct_ser = serializer.serialize_struct("stream_plan.ResetSourceMutation", len)?;
12550 if self.source_id != 0 {
12551 struct_ser.serialize_field("sourceId", &self.source_id)?;
12552 }
12553 struct_ser.end()
12554 }
12555}
12556impl<'de> serde::Deserialize<'de> for ResetSourceMutation {
12557 #[allow(deprecated)]
12558 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12559 where
12560 D: serde::Deserializer<'de>,
12561 {
12562 const FIELDS: &[&str] = &[
12563 "source_id",
12564 "sourceId",
12565 ];
12566
12567 #[allow(clippy::enum_variant_names)]
12568 enum GeneratedField {
12569 SourceId,
12570 }
12571 impl<'de> serde::Deserialize<'de> for GeneratedField {
12572 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12573 where
12574 D: serde::Deserializer<'de>,
12575 {
12576 struct GeneratedVisitor;
12577
12578 impl serde::de::Visitor<'_> for GeneratedVisitor {
12579 type Value = GeneratedField;
12580
12581 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12582 write!(formatter, "expected one of: {:?}", &FIELDS)
12583 }
12584
12585 #[allow(unused_variables)]
12586 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12587 where
12588 E: serde::de::Error,
12589 {
12590 match value {
12591 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
12592 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12593 }
12594 }
12595 }
12596 deserializer.deserialize_identifier(GeneratedVisitor)
12597 }
12598 }
12599 struct GeneratedVisitor;
12600 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12601 type Value = ResetSourceMutation;
12602
12603 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12604 formatter.write_str("struct stream_plan.ResetSourceMutation")
12605 }
12606
12607 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceMutation, V::Error>
12608 where
12609 V: serde::de::MapAccess<'de>,
12610 {
12611 let mut source_id__ = None;
12612 while let Some(k) = map_.next_key()? {
12613 match k {
12614 GeneratedField::SourceId => {
12615 if source_id__.is_some() {
12616 return Err(serde::de::Error::duplicate_field("sourceId"));
12617 }
12618 source_id__ =
12619 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12620 ;
12621 }
12622 }
12623 }
12624 Ok(ResetSourceMutation {
12625 source_id: source_id__.unwrap_or_default(),
12626 })
12627 }
12628 }
12629 deserializer.deserialize_struct("stream_plan.ResetSourceMutation", FIELDS, GeneratedVisitor)
12630 }
12631}
12632impl serde::Serialize for ResumeMutation {
12633 #[allow(deprecated)]
12634 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12635 where
12636 S: serde::Serializer,
12637 {
12638 use serde::ser::SerializeStruct;
12639 let len = 0;
12640 let struct_ser = serializer.serialize_struct("stream_plan.ResumeMutation", len)?;
12641 struct_ser.end()
12642 }
12643}
12644impl<'de> serde::Deserialize<'de> for ResumeMutation {
12645 #[allow(deprecated)]
12646 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12647 where
12648 D: serde::Deserializer<'de>,
12649 {
12650 const FIELDS: &[&str] = &[
12651 ];
12652
12653 #[allow(clippy::enum_variant_names)]
12654 enum GeneratedField {
12655 }
12656 impl<'de> serde::Deserialize<'de> for GeneratedField {
12657 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12658 where
12659 D: serde::Deserializer<'de>,
12660 {
12661 struct GeneratedVisitor;
12662
12663 impl serde::de::Visitor<'_> for GeneratedVisitor {
12664 type Value = GeneratedField;
12665
12666 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12667 write!(formatter, "expected one of: {:?}", &FIELDS)
12668 }
12669
12670 #[allow(unused_variables)]
12671 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12672 where
12673 E: serde::de::Error,
12674 {
12675 Err(serde::de::Error::unknown_field(value, FIELDS))
12676 }
12677 }
12678 deserializer.deserialize_identifier(GeneratedVisitor)
12679 }
12680 }
12681 struct GeneratedVisitor;
12682 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12683 type Value = ResumeMutation;
12684
12685 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12686 formatter.write_str("struct stream_plan.ResumeMutation")
12687 }
12688
12689 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeMutation, V::Error>
12690 where
12691 V: serde::de::MapAccess<'de>,
12692 {
12693 while map_.next_key::<GeneratedField>()?.is_some() {
12694 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12695 }
12696 Ok(ResumeMutation {
12697 })
12698 }
12699 }
12700 deserializer.deserialize_struct("stream_plan.ResumeMutation", FIELDS, GeneratedVisitor)
12701 }
12702}
12703impl serde::Serialize for RowIdGenNode {
12704 #[allow(deprecated)]
12705 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12706 where
12707 S: serde::Serializer,
12708 {
12709 use serde::ser::SerializeStruct;
12710 let mut len = 0;
12711 if self.row_id_index != 0 {
12712 len += 1;
12713 }
12714 let mut struct_ser = serializer.serialize_struct("stream_plan.RowIdGenNode", len)?;
12715 if self.row_id_index != 0 {
12716 #[allow(clippy::needless_borrow)]
12717 #[allow(clippy::needless_borrows_for_generic_args)]
12718 struct_ser.serialize_field("rowIdIndex", ToString::to_string(&self.row_id_index).as_str())?;
12719 }
12720 struct_ser.end()
12721 }
12722}
12723impl<'de> serde::Deserialize<'de> for RowIdGenNode {
12724 #[allow(deprecated)]
12725 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12726 where
12727 D: serde::Deserializer<'de>,
12728 {
12729 const FIELDS: &[&str] = &[
12730 "row_id_index",
12731 "rowIdIndex",
12732 ];
12733
12734 #[allow(clippy::enum_variant_names)]
12735 enum GeneratedField {
12736 RowIdIndex,
12737 }
12738 impl<'de> serde::Deserialize<'de> for GeneratedField {
12739 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12740 where
12741 D: serde::Deserializer<'de>,
12742 {
12743 struct GeneratedVisitor;
12744
12745 impl serde::de::Visitor<'_> for GeneratedVisitor {
12746 type Value = GeneratedField;
12747
12748 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12749 write!(formatter, "expected one of: {:?}", &FIELDS)
12750 }
12751
12752 #[allow(unused_variables)]
12753 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12754 where
12755 E: serde::de::Error,
12756 {
12757 match value {
12758 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
12759 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12760 }
12761 }
12762 }
12763 deserializer.deserialize_identifier(GeneratedVisitor)
12764 }
12765 }
12766 struct GeneratedVisitor;
12767 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12768 type Value = RowIdGenNode;
12769
12770 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12771 formatter.write_str("struct stream_plan.RowIdGenNode")
12772 }
12773
12774 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowIdGenNode, V::Error>
12775 where
12776 V: serde::de::MapAccess<'de>,
12777 {
12778 let mut row_id_index__ = None;
12779 while let Some(k) = map_.next_key()? {
12780 match k {
12781 GeneratedField::RowIdIndex => {
12782 if row_id_index__.is_some() {
12783 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
12784 }
12785 row_id_index__ =
12786 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12787 ;
12788 }
12789 }
12790 }
12791 Ok(RowIdGenNode {
12792 row_id_index: row_id_index__.unwrap_or_default(),
12793 })
12794 }
12795 }
12796 deserializer.deserialize_struct("stream_plan.RowIdGenNode", FIELDS, GeneratedVisitor)
12797 }
12798}
12799impl serde::Serialize for RowMergeNode {
12800 #[allow(deprecated)]
12801 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12802 where
12803 S: serde::Serializer,
12804 {
12805 use serde::ser::SerializeStruct;
12806 let mut len = 0;
12807 if self.lhs_mapping.is_some() {
12808 len += 1;
12809 }
12810 if self.rhs_mapping.is_some() {
12811 len += 1;
12812 }
12813 let mut struct_ser = serializer.serialize_struct("stream_plan.RowMergeNode", len)?;
12814 if let Some(v) = self.lhs_mapping.as_ref() {
12815 struct_ser.serialize_field("lhsMapping", v)?;
12816 }
12817 if let Some(v) = self.rhs_mapping.as_ref() {
12818 struct_ser.serialize_field("rhsMapping", v)?;
12819 }
12820 struct_ser.end()
12821 }
12822}
12823impl<'de> serde::Deserialize<'de> for RowMergeNode {
12824 #[allow(deprecated)]
12825 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12826 where
12827 D: serde::Deserializer<'de>,
12828 {
12829 const FIELDS: &[&str] = &[
12830 "lhs_mapping",
12831 "lhsMapping",
12832 "rhs_mapping",
12833 "rhsMapping",
12834 ];
12835
12836 #[allow(clippy::enum_variant_names)]
12837 enum GeneratedField {
12838 LhsMapping,
12839 RhsMapping,
12840 }
12841 impl<'de> serde::Deserialize<'de> for GeneratedField {
12842 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12843 where
12844 D: serde::Deserializer<'de>,
12845 {
12846 struct GeneratedVisitor;
12847
12848 impl serde::de::Visitor<'_> for GeneratedVisitor {
12849 type Value = GeneratedField;
12850
12851 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12852 write!(formatter, "expected one of: {:?}", &FIELDS)
12853 }
12854
12855 #[allow(unused_variables)]
12856 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12857 where
12858 E: serde::de::Error,
12859 {
12860 match value {
12861 "lhsMapping" | "lhs_mapping" => Ok(GeneratedField::LhsMapping),
12862 "rhsMapping" | "rhs_mapping" => Ok(GeneratedField::RhsMapping),
12863 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12864 }
12865 }
12866 }
12867 deserializer.deserialize_identifier(GeneratedVisitor)
12868 }
12869 }
12870 struct GeneratedVisitor;
12871 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12872 type Value = RowMergeNode;
12873
12874 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12875 formatter.write_str("struct stream_plan.RowMergeNode")
12876 }
12877
12878 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowMergeNode, V::Error>
12879 where
12880 V: serde::de::MapAccess<'de>,
12881 {
12882 let mut lhs_mapping__ = None;
12883 let mut rhs_mapping__ = None;
12884 while let Some(k) = map_.next_key()? {
12885 match k {
12886 GeneratedField::LhsMapping => {
12887 if lhs_mapping__.is_some() {
12888 return Err(serde::de::Error::duplicate_field("lhsMapping"));
12889 }
12890 lhs_mapping__ = map_.next_value()?;
12891 }
12892 GeneratedField::RhsMapping => {
12893 if rhs_mapping__.is_some() {
12894 return Err(serde::de::Error::duplicate_field("rhsMapping"));
12895 }
12896 rhs_mapping__ = map_.next_value()?;
12897 }
12898 }
12899 }
12900 Ok(RowMergeNode {
12901 lhs_mapping: lhs_mapping__,
12902 rhs_mapping: rhs_mapping__,
12903 })
12904 }
12905 }
12906 deserializer.deserialize_struct("stream_plan.RowMergeNode", FIELDS, GeneratedVisitor)
12907 }
12908}
12909impl serde::Serialize for SimpleAggNode {
12910 #[allow(deprecated)]
12911 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12912 where
12913 S: serde::Serializer,
12914 {
12915 use serde::ser::SerializeStruct;
12916 let mut len = 0;
12917 if !self.agg_calls.is_empty() {
12918 len += 1;
12919 }
12920 if !self.agg_call_states.is_empty() {
12921 len += 1;
12922 }
12923 if self.intermediate_state_table.is_some() {
12924 len += 1;
12925 }
12926 if self.is_append_only {
12927 len += 1;
12928 }
12929 if !self.distinct_dedup_tables.is_empty() {
12930 len += 1;
12931 }
12932 if self.row_count_index != 0 {
12933 len += 1;
12934 }
12935 if self.version != 0 {
12936 len += 1;
12937 }
12938 if self.must_output_per_barrier {
12939 len += 1;
12940 }
12941 let mut struct_ser = serializer.serialize_struct("stream_plan.SimpleAggNode", len)?;
12942 if !self.agg_calls.is_empty() {
12943 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
12944 }
12945 if !self.agg_call_states.is_empty() {
12946 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
12947 }
12948 if let Some(v) = self.intermediate_state_table.as_ref() {
12949 struct_ser.serialize_field("intermediateStateTable", v)?;
12950 }
12951 if self.is_append_only {
12952 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
12953 }
12954 if !self.distinct_dedup_tables.is_empty() {
12955 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
12956 }
12957 if self.row_count_index != 0 {
12958 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
12959 }
12960 if self.version != 0 {
12961 let v = AggNodeVersion::try_from(self.version)
12962 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
12963 struct_ser.serialize_field("version", &v)?;
12964 }
12965 if self.must_output_per_barrier {
12966 struct_ser.serialize_field("mustOutputPerBarrier", &self.must_output_per_barrier)?;
12967 }
12968 struct_ser.end()
12969 }
12970}
12971impl<'de> serde::Deserialize<'de> for SimpleAggNode {
12972 #[allow(deprecated)]
12973 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12974 where
12975 D: serde::Deserializer<'de>,
12976 {
12977 const FIELDS: &[&str] = &[
12978 "agg_calls",
12979 "aggCalls",
12980 "agg_call_states",
12981 "aggCallStates",
12982 "intermediate_state_table",
12983 "intermediateStateTable",
12984 "is_append_only",
12985 "isAppendOnly",
12986 "distinct_dedup_tables",
12987 "distinctDedupTables",
12988 "row_count_index",
12989 "rowCountIndex",
12990 "version",
12991 "must_output_per_barrier",
12992 "mustOutputPerBarrier",
12993 ];
12994
12995 #[allow(clippy::enum_variant_names)]
12996 enum GeneratedField {
12997 AggCalls,
12998 AggCallStates,
12999 IntermediateStateTable,
13000 IsAppendOnly,
13001 DistinctDedupTables,
13002 RowCountIndex,
13003 Version,
13004 MustOutputPerBarrier,
13005 }
13006 impl<'de> serde::Deserialize<'de> for GeneratedField {
13007 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13008 where
13009 D: serde::Deserializer<'de>,
13010 {
13011 struct GeneratedVisitor;
13012
13013 impl serde::de::Visitor<'_> for GeneratedVisitor {
13014 type Value = GeneratedField;
13015
13016 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13017 write!(formatter, "expected one of: {:?}", &FIELDS)
13018 }
13019
13020 #[allow(unused_variables)]
13021 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13022 where
13023 E: serde::de::Error,
13024 {
13025 match value {
13026 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
13027 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
13028 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
13029 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
13030 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
13031 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
13032 "version" => Ok(GeneratedField::Version),
13033 "mustOutputPerBarrier" | "must_output_per_barrier" => Ok(GeneratedField::MustOutputPerBarrier),
13034 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13035 }
13036 }
13037 }
13038 deserializer.deserialize_identifier(GeneratedVisitor)
13039 }
13040 }
13041 struct GeneratedVisitor;
13042 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13043 type Value = SimpleAggNode;
13044
13045 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13046 formatter.write_str("struct stream_plan.SimpleAggNode")
13047 }
13048
13049 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SimpleAggNode, V::Error>
13050 where
13051 V: serde::de::MapAccess<'de>,
13052 {
13053 let mut agg_calls__ = None;
13054 let mut agg_call_states__ = None;
13055 let mut intermediate_state_table__ = None;
13056 let mut is_append_only__ = None;
13057 let mut distinct_dedup_tables__ = None;
13058 let mut row_count_index__ = None;
13059 let mut version__ = None;
13060 let mut must_output_per_barrier__ = None;
13061 while let Some(k) = map_.next_key()? {
13062 match k {
13063 GeneratedField::AggCalls => {
13064 if agg_calls__.is_some() {
13065 return Err(serde::de::Error::duplicate_field("aggCalls"));
13066 }
13067 agg_calls__ = Some(map_.next_value()?);
13068 }
13069 GeneratedField::AggCallStates => {
13070 if agg_call_states__.is_some() {
13071 return Err(serde::de::Error::duplicate_field("aggCallStates"));
13072 }
13073 agg_call_states__ = Some(map_.next_value()?);
13074 }
13075 GeneratedField::IntermediateStateTable => {
13076 if intermediate_state_table__.is_some() {
13077 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
13078 }
13079 intermediate_state_table__ = map_.next_value()?;
13080 }
13081 GeneratedField::IsAppendOnly => {
13082 if is_append_only__.is_some() {
13083 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
13084 }
13085 is_append_only__ = Some(map_.next_value()?);
13086 }
13087 GeneratedField::DistinctDedupTables => {
13088 if distinct_dedup_tables__.is_some() {
13089 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
13090 }
13091 distinct_dedup_tables__ = Some(
13092 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
13093 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
13094 );
13095 }
13096 GeneratedField::RowCountIndex => {
13097 if row_count_index__.is_some() {
13098 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
13099 }
13100 row_count_index__ =
13101 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13102 ;
13103 }
13104 GeneratedField::Version => {
13105 if version__.is_some() {
13106 return Err(serde::de::Error::duplicate_field("version"));
13107 }
13108 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
13109 }
13110 GeneratedField::MustOutputPerBarrier => {
13111 if must_output_per_barrier__.is_some() {
13112 return Err(serde::de::Error::duplicate_field("mustOutputPerBarrier"));
13113 }
13114 must_output_per_barrier__ = Some(map_.next_value()?);
13115 }
13116 }
13117 }
13118 Ok(SimpleAggNode {
13119 agg_calls: agg_calls__.unwrap_or_default(),
13120 agg_call_states: agg_call_states__.unwrap_or_default(),
13121 intermediate_state_table: intermediate_state_table__,
13122 is_append_only: is_append_only__.unwrap_or_default(),
13123 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
13124 row_count_index: row_count_index__.unwrap_or_default(),
13125 version: version__.unwrap_or_default(),
13126 must_output_per_barrier: must_output_per_barrier__.unwrap_or_default(),
13127 })
13128 }
13129 }
13130 deserializer.deserialize_struct("stream_plan.SimpleAggNode", FIELDS, GeneratedVisitor)
13131 }
13132}
13133impl serde::Serialize for SinkAddColumnsOp {
13134 #[allow(deprecated)]
13135 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13136 where
13137 S: serde::Serializer,
13138 {
13139 use serde::ser::SerializeStruct;
13140 let mut len = 0;
13141 if !self.fields.is_empty() {
13142 len += 1;
13143 }
13144 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkAddColumnsOp", len)?;
13145 if !self.fields.is_empty() {
13146 struct_ser.serialize_field("fields", &self.fields)?;
13147 }
13148 struct_ser.end()
13149 }
13150}
13151impl<'de> serde::Deserialize<'de> for SinkAddColumnsOp {
13152 #[allow(deprecated)]
13153 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13154 where
13155 D: serde::Deserializer<'de>,
13156 {
13157 const FIELDS: &[&str] = &[
13158 "fields",
13159 ];
13160
13161 #[allow(clippy::enum_variant_names)]
13162 enum GeneratedField {
13163 Fields,
13164 }
13165 impl<'de> serde::Deserialize<'de> for GeneratedField {
13166 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13167 where
13168 D: serde::Deserializer<'de>,
13169 {
13170 struct GeneratedVisitor;
13171
13172 impl serde::de::Visitor<'_> for GeneratedVisitor {
13173 type Value = GeneratedField;
13174
13175 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13176 write!(formatter, "expected one of: {:?}", &FIELDS)
13177 }
13178
13179 #[allow(unused_variables)]
13180 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13181 where
13182 E: serde::de::Error,
13183 {
13184 match value {
13185 "fields" => Ok(GeneratedField::Fields),
13186 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13187 }
13188 }
13189 }
13190 deserializer.deserialize_identifier(GeneratedVisitor)
13191 }
13192 }
13193 struct GeneratedVisitor;
13194 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13195 type Value = SinkAddColumnsOp;
13196
13197 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13198 formatter.write_str("struct stream_plan.SinkAddColumnsOp")
13199 }
13200
13201 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkAddColumnsOp, V::Error>
13202 where
13203 V: serde::de::MapAccess<'de>,
13204 {
13205 let mut fields__ = None;
13206 while let Some(k) = map_.next_key()? {
13207 match k {
13208 GeneratedField::Fields => {
13209 if fields__.is_some() {
13210 return Err(serde::de::Error::duplicate_field("fields"));
13211 }
13212 fields__ = Some(map_.next_value()?);
13213 }
13214 }
13215 }
13216 Ok(SinkAddColumnsOp {
13217 fields: fields__.unwrap_or_default(),
13218 })
13219 }
13220 }
13221 deserializer.deserialize_struct("stream_plan.SinkAddColumnsOp", FIELDS, GeneratedVisitor)
13222 }
13223}
13224impl serde::Serialize for SinkDesc {
13225 #[allow(deprecated)]
13226 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13227 where
13228 S: serde::Serializer,
13229 {
13230 use serde::ser::SerializeStruct;
13231 let mut len = 0;
13232 if self.id != 0 {
13233 len += 1;
13234 }
13235 if !self.name.is_empty() {
13236 len += 1;
13237 }
13238 if !self.definition.is_empty() {
13239 len += 1;
13240 }
13241 if !self.plan_pk.is_empty() {
13242 len += 1;
13243 }
13244 if !self.downstream_pk.is_empty() {
13245 len += 1;
13246 }
13247 if !self.distribution_key.is_empty() {
13248 len += 1;
13249 }
13250 if !self.properties.is_empty() {
13251 len += 1;
13252 }
13253 if self.sink_type != 0 {
13254 len += 1;
13255 }
13256 if !self.column_catalogs.is_empty() {
13257 len += 1;
13258 }
13259 if !self.db_name.is_empty() {
13260 len += 1;
13261 }
13262 if !self.sink_from_name.is_empty() {
13263 len += 1;
13264 }
13265 if self.format_desc.is_some() {
13266 len += 1;
13267 }
13268 if self.target_table.is_some() {
13269 len += 1;
13270 }
13271 if self.extra_partition_col_idx.is_some() {
13272 len += 1;
13273 }
13274 if !self.secret_refs.is_empty() {
13275 len += 1;
13276 }
13277 if self.raw_ignore_delete {
13278 len += 1;
13279 }
13280 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDesc", len)?;
13281 if self.id != 0 {
13282 struct_ser.serialize_field("id", &self.id)?;
13283 }
13284 if !self.name.is_empty() {
13285 struct_ser.serialize_field("name", &self.name)?;
13286 }
13287 if !self.definition.is_empty() {
13288 struct_ser.serialize_field("definition", &self.definition)?;
13289 }
13290 if !self.plan_pk.is_empty() {
13291 struct_ser.serialize_field("planPk", &self.plan_pk)?;
13292 }
13293 if !self.downstream_pk.is_empty() {
13294 struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
13295 }
13296 if !self.distribution_key.is_empty() {
13297 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
13298 }
13299 if !self.properties.is_empty() {
13300 struct_ser.serialize_field("properties", &self.properties)?;
13301 }
13302 if self.sink_type != 0 {
13303 let v = super::catalog::SinkType::try_from(self.sink_type)
13304 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
13305 struct_ser.serialize_field("sinkType", &v)?;
13306 }
13307 if !self.column_catalogs.is_empty() {
13308 struct_ser.serialize_field("columnCatalogs", &self.column_catalogs)?;
13309 }
13310 if !self.db_name.is_empty() {
13311 struct_ser.serialize_field("dbName", &self.db_name)?;
13312 }
13313 if !self.sink_from_name.is_empty() {
13314 struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
13315 }
13316 if let Some(v) = self.format_desc.as_ref() {
13317 struct_ser.serialize_field("formatDesc", v)?;
13318 }
13319 if let Some(v) = self.target_table.as_ref() {
13320 struct_ser.serialize_field("targetTable", v)?;
13321 }
13322 if let Some(v) = self.extra_partition_col_idx.as_ref() {
13323 #[allow(clippy::needless_borrow)]
13324 #[allow(clippy::needless_borrows_for_generic_args)]
13325 struct_ser.serialize_field("extraPartitionColIdx", ToString::to_string(&v).as_str())?;
13326 }
13327 if !self.secret_refs.is_empty() {
13328 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
13329 }
13330 if self.raw_ignore_delete {
13331 struct_ser.serialize_field("rawIgnoreDelete", &self.raw_ignore_delete)?;
13332 }
13333 struct_ser.end()
13334 }
13335}
13336impl<'de> serde::Deserialize<'de> for SinkDesc {
13337 #[allow(deprecated)]
13338 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13339 where
13340 D: serde::Deserializer<'de>,
13341 {
13342 const FIELDS: &[&str] = &[
13343 "id",
13344 "name",
13345 "definition",
13346 "plan_pk",
13347 "planPk",
13348 "downstream_pk",
13349 "downstreamPk",
13350 "distribution_key",
13351 "distributionKey",
13352 "properties",
13353 "sink_type",
13354 "sinkType",
13355 "column_catalogs",
13356 "columnCatalogs",
13357 "db_name",
13358 "dbName",
13359 "sink_from_name",
13360 "sinkFromName",
13361 "format_desc",
13362 "formatDesc",
13363 "target_table",
13364 "targetTable",
13365 "extra_partition_col_idx",
13366 "extraPartitionColIdx",
13367 "secret_refs",
13368 "secretRefs",
13369 "raw_ignore_delete",
13370 "rawIgnoreDelete",
13371 ];
13372
13373 #[allow(clippy::enum_variant_names)]
13374 enum GeneratedField {
13375 Id,
13376 Name,
13377 Definition,
13378 PlanPk,
13379 DownstreamPk,
13380 DistributionKey,
13381 Properties,
13382 SinkType,
13383 ColumnCatalogs,
13384 DbName,
13385 SinkFromName,
13386 FormatDesc,
13387 TargetTable,
13388 ExtraPartitionColIdx,
13389 SecretRefs,
13390 RawIgnoreDelete,
13391 }
13392 impl<'de> serde::Deserialize<'de> for GeneratedField {
13393 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13394 where
13395 D: serde::Deserializer<'de>,
13396 {
13397 struct GeneratedVisitor;
13398
13399 impl serde::de::Visitor<'_> for GeneratedVisitor {
13400 type Value = GeneratedField;
13401
13402 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13403 write!(formatter, "expected one of: {:?}", &FIELDS)
13404 }
13405
13406 #[allow(unused_variables)]
13407 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13408 where
13409 E: serde::de::Error,
13410 {
13411 match value {
13412 "id" => Ok(GeneratedField::Id),
13413 "name" => Ok(GeneratedField::Name),
13414 "definition" => Ok(GeneratedField::Definition),
13415 "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
13416 "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
13417 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
13418 "properties" => Ok(GeneratedField::Properties),
13419 "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
13420 "columnCatalogs" | "column_catalogs" => Ok(GeneratedField::ColumnCatalogs),
13421 "dbName" | "db_name" => Ok(GeneratedField::DbName),
13422 "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
13423 "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
13424 "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
13425 "extraPartitionColIdx" | "extra_partition_col_idx" => Ok(GeneratedField::ExtraPartitionColIdx),
13426 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
13427 "rawIgnoreDelete" | "raw_ignore_delete" => Ok(GeneratedField::RawIgnoreDelete),
13428 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13429 }
13430 }
13431 }
13432 deserializer.deserialize_identifier(GeneratedVisitor)
13433 }
13434 }
13435 struct GeneratedVisitor;
13436 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13437 type Value = SinkDesc;
13438
13439 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13440 formatter.write_str("struct stream_plan.SinkDesc")
13441 }
13442
13443 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDesc, V::Error>
13444 where
13445 V: serde::de::MapAccess<'de>,
13446 {
13447 let mut id__ = None;
13448 let mut name__ = None;
13449 let mut definition__ = None;
13450 let mut plan_pk__ = None;
13451 let mut downstream_pk__ = None;
13452 let mut distribution_key__ = None;
13453 let mut properties__ = None;
13454 let mut sink_type__ = None;
13455 let mut column_catalogs__ = None;
13456 let mut db_name__ = None;
13457 let mut sink_from_name__ = None;
13458 let mut format_desc__ = None;
13459 let mut target_table__ = None;
13460 let mut extra_partition_col_idx__ = None;
13461 let mut secret_refs__ = None;
13462 let mut raw_ignore_delete__ = None;
13463 while let Some(k) = map_.next_key()? {
13464 match k {
13465 GeneratedField::Id => {
13466 if id__.is_some() {
13467 return Err(serde::de::Error::duplicate_field("id"));
13468 }
13469 id__ =
13470 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13471 ;
13472 }
13473 GeneratedField::Name => {
13474 if name__.is_some() {
13475 return Err(serde::de::Error::duplicate_field("name"));
13476 }
13477 name__ = Some(map_.next_value()?);
13478 }
13479 GeneratedField::Definition => {
13480 if definition__.is_some() {
13481 return Err(serde::de::Error::duplicate_field("definition"));
13482 }
13483 definition__ = Some(map_.next_value()?);
13484 }
13485 GeneratedField::PlanPk => {
13486 if plan_pk__.is_some() {
13487 return Err(serde::de::Error::duplicate_field("planPk"));
13488 }
13489 plan_pk__ = Some(map_.next_value()?);
13490 }
13491 GeneratedField::DownstreamPk => {
13492 if downstream_pk__.is_some() {
13493 return Err(serde::de::Error::duplicate_field("downstreamPk"));
13494 }
13495 downstream_pk__ =
13496 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13497 .into_iter().map(|x| x.0).collect())
13498 ;
13499 }
13500 GeneratedField::DistributionKey => {
13501 if distribution_key__.is_some() {
13502 return Err(serde::de::Error::duplicate_field("distributionKey"));
13503 }
13504 distribution_key__ =
13505 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13506 .into_iter().map(|x| x.0).collect())
13507 ;
13508 }
13509 GeneratedField::Properties => {
13510 if properties__.is_some() {
13511 return Err(serde::de::Error::duplicate_field("properties"));
13512 }
13513 properties__ = Some(
13514 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13515 );
13516 }
13517 GeneratedField::SinkType => {
13518 if sink_type__.is_some() {
13519 return Err(serde::de::Error::duplicate_field("sinkType"));
13520 }
13521 sink_type__ = Some(map_.next_value::<super::catalog::SinkType>()? as i32);
13522 }
13523 GeneratedField::ColumnCatalogs => {
13524 if column_catalogs__.is_some() {
13525 return Err(serde::de::Error::duplicate_field("columnCatalogs"));
13526 }
13527 column_catalogs__ = Some(map_.next_value()?);
13528 }
13529 GeneratedField::DbName => {
13530 if db_name__.is_some() {
13531 return Err(serde::de::Error::duplicate_field("dbName"));
13532 }
13533 db_name__ = Some(map_.next_value()?);
13534 }
13535 GeneratedField::SinkFromName => {
13536 if sink_from_name__.is_some() {
13537 return Err(serde::de::Error::duplicate_field("sinkFromName"));
13538 }
13539 sink_from_name__ = Some(map_.next_value()?);
13540 }
13541 GeneratedField::FormatDesc => {
13542 if format_desc__.is_some() {
13543 return Err(serde::de::Error::duplicate_field("formatDesc"));
13544 }
13545 format_desc__ = map_.next_value()?;
13546 }
13547 GeneratedField::TargetTable => {
13548 if target_table__.is_some() {
13549 return Err(serde::de::Error::duplicate_field("targetTable"));
13550 }
13551 target_table__ =
13552 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13553 ;
13554 }
13555 GeneratedField::ExtraPartitionColIdx => {
13556 if extra_partition_col_idx__.is_some() {
13557 return Err(serde::de::Error::duplicate_field("extraPartitionColIdx"));
13558 }
13559 extra_partition_col_idx__ =
13560 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13561 ;
13562 }
13563 GeneratedField::SecretRefs => {
13564 if secret_refs__.is_some() {
13565 return Err(serde::de::Error::duplicate_field("secretRefs"));
13566 }
13567 secret_refs__ = Some(
13568 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13569 );
13570 }
13571 GeneratedField::RawIgnoreDelete => {
13572 if raw_ignore_delete__.is_some() {
13573 return Err(serde::de::Error::duplicate_field("rawIgnoreDelete"));
13574 }
13575 raw_ignore_delete__ = Some(map_.next_value()?);
13576 }
13577 }
13578 }
13579 Ok(SinkDesc {
13580 id: id__.unwrap_or_default(),
13581 name: name__.unwrap_or_default(),
13582 definition: definition__.unwrap_or_default(),
13583 plan_pk: plan_pk__.unwrap_or_default(),
13584 downstream_pk: downstream_pk__.unwrap_or_default(),
13585 distribution_key: distribution_key__.unwrap_or_default(),
13586 properties: properties__.unwrap_or_default(),
13587 sink_type: sink_type__.unwrap_or_default(),
13588 column_catalogs: column_catalogs__.unwrap_or_default(),
13589 db_name: db_name__.unwrap_or_default(),
13590 sink_from_name: sink_from_name__.unwrap_or_default(),
13591 format_desc: format_desc__,
13592 target_table: target_table__,
13593 extra_partition_col_idx: extra_partition_col_idx__,
13594 secret_refs: secret_refs__.unwrap_or_default(),
13595 raw_ignore_delete: raw_ignore_delete__.unwrap_or_default(),
13596 })
13597 }
13598 }
13599 deserializer.deserialize_struct("stream_plan.SinkDesc", FIELDS, GeneratedVisitor)
13600 }
13601}
13602impl serde::Serialize for SinkDropColumnsOp {
13603 #[allow(deprecated)]
13604 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13605 where
13606 S: serde::Serializer,
13607 {
13608 use serde::ser::SerializeStruct;
13609 let mut len = 0;
13610 if !self.column_names.is_empty() {
13611 len += 1;
13612 }
13613 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDropColumnsOp", len)?;
13614 if !self.column_names.is_empty() {
13615 struct_ser.serialize_field("columnNames", &self.column_names)?;
13616 }
13617 struct_ser.end()
13618 }
13619}
13620impl<'de> serde::Deserialize<'de> for SinkDropColumnsOp {
13621 #[allow(deprecated)]
13622 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13623 where
13624 D: serde::Deserializer<'de>,
13625 {
13626 const FIELDS: &[&str] = &[
13627 "column_names",
13628 "columnNames",
13629 ];
13630
13631 #[allow(clippy::enum_variant_names)]
13632 enum GeneratedField {
13633 ColumnNames,
13634 }
13635 impl<'de> serde::Deserialize<'de> for GeneratedField {
13636 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13637 where
13638 D: serde::Deserializer<'de>,
13639 {
13640 struct GeneratedVisitor;
13641
13642 impl serde::de::Visitor<'_> for GeneratedVisitor {
13643 type Value = GeneratedField;
13644
13645 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13646 write!(formatter, "expected one of: {:?}", &FIELDS)
13647 }
13648
13649 #[allow(unused_variables)]
13650 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13651 where
13652 E: serde::de::Error,
13653 {
13654 match value {
13655 "columnNames" | "column_names" => Ok(GeneratedField::ColumnNames),
13656 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13657 }
13658 }
13659 }
13660 deserializer.deserialize_identifier(GeneratedVisitor)
13661 }
13662 }
13663 struct GeneratedVisitor;
13664 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13665 type Value = SinkDropColumnsOp;
13666
13667 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13668 formatter.write_str("struct stream_plan.SinkDropColumnsOp")
13669 }
13670
13671 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDropColumnsOp, V::Error>
13672 where
13673 V: serde::de::MapAccess<'de>,
13674 {
13675 let mut column_names__ = None;
13676 while let Some(k) = map_.next_key()? {
13677 match k {
13678 GeneratedField::ColumnNames => {
13679 if column_names__.is_some() {
13680 return Err(serde::de::Error::duplicate_field("columnNames"));
13681 }
13682 column_names__ = Some(map_.next_value()?);
13683 }
13684 }
13685 }
13686 Ok(SinkDropColumnsOp {
13687 column_names: column_names__.unwrap_or_default(),
13688 })
13689 }
13690 }
13691 deserializer.deserialize_struct("stream_plan.SinkDropColumnsOp", FIELDS, GeneratedVisitor)
13692 }
13693}
13694impl serde::Serialize for SinkLogStoreType {
13695 #[allow(deprecated)]
13696 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13697 where
13698 S: serde::Serializer,
13699 {
13700 let variant = match self {
13701 Self::Unspecified => "SINK_LOG_STORE_TYPE_UNSPECIFIED",
13702 Self::KvLogStore => "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
13703 Self::InMemoryLogStore => "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
13704 };
13705 serializer.serialize_str(variant)
13706 }
13707}
13708impl<'de> serde::Deserialize<'de> for SinkLogStoreType {
13709 #[allow(deprecated)]
13710 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13711 where
13712 D: serde::Deserializer<'de>,
13713 {
13714 const FIELDS: &[&str] = &[
13715 "SINK_LOG_STORE_TYPE_UNSPECIFIED",
13716 "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
13717 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
13718 ];
13719
13720 struct GeneratedVisitor;
13721
13722 impl serde::de::Visitor<'_> for GeneratedVisitor {
13723 type Value = SinkLogStoreType;
13724
13725 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13726 write!(formatter, "expected one of: {:?}", &FIELDS)
13727 }
13728
13729 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13730 where
13731 E: serde::de::Error,
13732 {
13733 i32::try_from(v)
13734 .ok()
13735 .and_then(|x| x.try_into().ok())
13736 .ok_or_else(|| {
13737 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13738 })
13739 }
13740
13741 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13742 where
13743 E: serde::de::Error,
13744 {
13745 i32::try_from(v)
13746 .ok()
13747 .and_then(|x| x.try_into().ok())
13748 .ok_or_else(|| {
13749 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13750 })
13751 }
13752
13753 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13754 where
13755 E: serde::de::Error,
13756 {
13757 match value {
13758 "SINK_LOG_STORE_TYPE_UNSPECIFIED" => Ok(SinkLogStoreType::Unspecified),
13759 "SINK_LOG_STORE_TYPE_KV_LOG_STORE" => Ok(SinkLogStoreType::KvLogStore),
13760 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE" => Ok(SinkLogStoreType::InMemoryLogStore),
13761 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13762 }
13763 }
13764 }
13765 deserializer.deserialize_any(GeneratedVisitor)
13766 }
13767}
13768impl serde::Serialize for SinkNode {
13769 #[allow(deprecated)]
13770 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13771 where
13772 S: serde::Serializer,
13773 {
13774 use serde::ser::SerializeStruct;
13775 let mut len = 0;
13776 if self.sink_desc.is_some() {
13777 len += 1;
13778 }
13779 if self.table.is_some() {
13780 len += 1;
13781 }
13782 if self.log_store_type != 0 {
13783 len += 1;
13784 }
13785 if self.rate_limit.is_some() {
13786 len += 1;
13787 }
13788 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkNode", len)?;
13789 if let Some(v) = self.sink_desc.as_ref() {
13790 struct_ser.serialize_field("sinkDesc", v)?;
13791 }
13792 if let Some(v) = self.table.as_ref() {
13793 struct_ser.serialize_field("table", v)?;
13794 }
13795 if self.log_store_type != 0 {
13796 let v = SinkLogStoreType::try_from(self.log_store_type)
13797 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.log_store_type)))?;
13798 struct_ser.serialize_field("logStoreType", &v)?;
13799 }
13800 if let Some(v) = self.rate_limit.as_ref() {
13801 struct_ser.serialize_field("rateLimit", v)?;
13802 }
13803 struct_ser.end()
13804 }
13805}
13806impl<'de> serde::Deserialize<'de> for SinkNode {
13807 #[allow(deprecated)]
13808 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13809 where
13810 D: serde::Deserializer<'de>,
13811 {
13812 const FIELDS: &[&str] = &[
13813 "sink_desc",
13814 "sinkDesc",
13815 "table",
13816 "log_store_type",
13817 "logStoreType",
13818 "rate_limit",
13819 "rateLimit",
13820 ];
13821
13822 #[allow(clippy::enum_variant_names)]
13823 enum GeneratedField {
13824 SinkDesc,
13825 Table,
13826 LogStoreType,
13827 RateLimit,
13828 }
13829 impl<'de> serde::Deserialize<'de> for GeneratedField {
13830 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13831 where
13832 D: serde::Deserializer<'de>,
13833 {
13834 struct GeneratedVisitor;
13835
13836 impl serde::de::Visitor<'_> for GeneratedVisitor {
13837 type Value = GeneratedField;
13838
13839 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13840 write!(formatter, "expected one of: {:?}", &FIELDS)
13841 }
13842
13843 #[allow(unused_variables)]
13844 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13845 where
13846 E: serde::de::Error,
13847 {
13848 match value {
13849 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
13850 "table" => Ok(GeneratedField::Table),
13851 "logStoreType" | "log_store_type" => Ok(GeneratedField::LogStoreType),
13852 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
13853 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13854 }
13855 }
13856 }
13857 deserializer.deserialize_identifier(GeneratedVisitor)
13858 }
13859 }
13860 struct GeneratedVisitor;
13861 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13862 type Value = SinkNode;
13863
13864 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13865 formatter.write_str("struct stream_plan.SinkNode")
13866 }
13867
13868 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkNode, V::Error>
13869 where
13870 V: serde::de::MapAccess<'de>,
13871 {
13872 let mut sink_desc__ = None;
13873 let mut table__ = None;
13874 let mut log_store_type__ = None;
13875 let mut rate_limit__ = None;
13876 while let Some(k) = map_.next_key()? {
13877 match k {
13878 GeneratedField::SinkDesc => {
13879 if sink_desc__.is_some() {
13880 return Err(serde::de::Error::duplicate_field("sinkDesc"));
13881 }
13882 sink_desc__ = map_.next_value()?;
13883 }
13884 GeneratedField::Table => {
13885 if table__.is_some() {
13886 return Err(serde::de::Error::duplicate_field("table"));
13887 }
13888 table__ = map_.next_value()?;
13889 }
13890 GeneratedField::LogStoreType => {
13891 if log_store_type__.is_some() {
13892 return Err(serde::de::Error::duplicate_field("logStoreType"));
13893 }
13894 log_store_type__ = Some(map_.next_value::<SinkLogStoreType>()? as i32);
13895 }
13896 GeneratedField::RateLimit => {
13897 if rate_limit__.is_some() {
13898 return Err(serde::de::Error::duplicate_field("rateLimit"));
13899 }
13900 rate_limit__ =
13901 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13902 ;
13903 }
13904 }
13905 }
13906 Ok(SinkNode {
13907 sink_desc: sink_desc__,
13908 table: table__,
13909 log_store_type: log_store_type__.unwrap_or_default(),
13910 rate_limit: rate_limit__,
13911 })
13912 }
13913 }
13914 deserializer.deserialize_struct("stream_plan.SinkNode", FIELDS, GeneratedVisitor)
13915 }
13916}
13917impl serde::Serialize for SinkSchemaChange {
13918 #[allow(deprecated)]
13919 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13920 where
13921 S: serde::Serializer,
13922 {
13923 use serde::ser::SerializeStruct;
13924 let mut len = 0;
13925 if !self.original_schema.is_empty() {
13926 len += 1;
13927 }
13928 if self.op.is_some() {
13929 len += 1;
13930 }
13931 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkSchemaChange", len)?;
13932 if !self.original_schema.is_empty() {
13933 struct_ser.serialize_field("originalSchema", &self.original_schema)?;
13934 }
13935 if let Some(v) = self.op.as_ref() {
13936 match v {
13937 sink_schema_change::Op::AddColumns(v) => {
13938 struct_ser.serialize_field("addColumns", v)?;
13939 }
13940 sink_schema_change::Op::DropColumns(v) => {
13941 struct_ser.serialize_field("dropColumns", v)?;
13942 }
13943 }
13944 }
13945 struct_ser.end()
13946 }
13947}
13948impl<'de> serde::Deserialize<'de> for SinkSchemaChange {
13949 #[allow(deprecated)]
13950 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13951 where
13952 D: serde::Deserializer<'de>,
13953 {
13954 const FIELDS: &[&str] = &[
13955 "original_schema",
13956 "originalSchema",
13957 "add_columns",
13958 "addColumns",
13959 "drop_columns",
13960 "dropColumns",
13961 ];
13962
13963 #[allow(clippy::enum_variant_names)]
13964 enum GeneratedField {
13965 OriginalSchema,
13966 AddColumns,
13967 DropColumns,
13968 }
13969 impl<'de> serde::Deserialize<'de> for GeneratedField {
13970 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13971 where
13972 D: serde::Deserializer<'de>,
13973 {
13974 struct GeneratedVisitor;
13975
13976 impl serde::de::Visitor<'_> for GeneratedVisitor {
13977 type Value = GeneratedField;
13978
13979 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13980 write!(formatter, "expected one of: {:?}", &FIELDS)
13981 }
13982
13983 #[allow(unused_variables)]
13984 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13985 where
13986 E: serde::de::Error,
13987 {
13988 match value {
13989 "originalSchema" | "original_schema" => Ok(GeneratedField::OriginalSchema),
13990 "addColumns" | "add_columns" => Ok(GeneratedField::AddColumns),
13991 "dropColumns" | "drop_columns" => Ok(GeneratedField::DropColumns),
13992 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13993 }
13994 }
13995 }
13996 deserializer.deserialize_identifier(GeneratedVisitor)
13997 }
13998 }
13999 struct GeneratedVisitor;
14000 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14001 type Value = SinkSchemaChange;
14002
14003 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14004 formatter.write_str("struct stream_plan.SinkSchemaChange")
14005 }
14006
14007 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkSchemaChange, V::Error>
14008 where
14009 V: serde::de::MapAccess<'de>,
14010 {
14011 let mut original_schema__ = None;
14012 let mut op__ = None;
14013 while let Some(k) = map_.next_key()? {
14014 match k {
14015 GeneratedField::OriginalSchema => {
14016 if original_schema__.is_some() {
14017 return Err(serde::de::Error::duplicate_field("originalSchema"));
14018 }
14019 original_schema__ = Some(map_.next_value()?);
14020 }
14021 GeneratedField::AddColumns => {
14022 if op__.is_some() {
14023 return Err(serde::de::Error::duplicate_field("addColumns"));
14024 }
14025 op__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_schema_change::Op::AddColumns)
14026;
14027 }
14028 GeneratedField::DropColumns => {
14029 if op__.is_some() {
14030 return Err(serde::de::Error::duplicate_field("dropColumns"));
14031 }
14032 op__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_schema_change::Op::DropColumns)
14033;
14034 }
14035 }
14036 }
14037 Ok(SinkSchemaChange {
14038 original_schema: original_schema__.unwrap_or_default(),
14039 op: op__,
14040 })
14041 }
14042 }
14043 deserializer.deserialize_struct("stream_plan.SinkSchemaChange", FIELDS, GeneratedVisitor)
14044 }
14045}
14046impl serde::Serialize for SortNode {
14047 #[allow(deprecated)]
14048 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14049 where
14050 S: serde::Serializer,
14051 {
14052 use serde::ser::SerializeStruct;
14053 let mut len = 0;
14054 if self.state_table.is_some() {
14055 len += 1;
14056 }
14057 if self.sort_column_index != 0 {
14058 len += 1;
14059 }
14060 let mut struct_ser = serializer.serialize_struct("stream_plan.SortNode", len)?;
14061 if let Some(v) = self.state_table.as_ref() {
14062 struct_ser.serialize_field("stateTable", v)?;
14063 }
14064 if self.sort_column_index != 0 {
14065 struct_ser.serialize_field("sortColumnIndex", &self.sort_column_index)?;
14066 }
14067 struct_ser.end()
14068 }
14069}
14070impl<'de> serde::Deserialize<'de> for SortNode {
14071 #[allow(deprecated)]
14072 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14073 where
14074 D: serde::Deserializer<'de>,
14075 {
14076 const FIELDS: &[&str] = &[
14077 "state_table",
14078 "stateTable",
14079 "sort_column_index",
14080 "sortColumnIndex",
14081 ];
14082
14083 #[allow(clippy::enum_variant_names)]
14084 enum GeneratedField {
14085 StateTable,
14086 SortColumnIndex,
14087 }
14088 impl<'de> serde::Deserialize<'de> for GeneratedField {
14089 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14090 where
14091 D: serde::Deserializer<'de>,
14092 {
14093 struct GeneratedVisitor;
14094
14095 impl serde::de::Visitor<'_> for GeneratedVisitor {
14096 type Value = GeneratedField;
14097
14098 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14099 write!(formatter, "expected one of: {:?}", &FIELDS)
14100 }
14101
14102 #[allow(unused_variables)]
14103 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14104 where
14105 E: serde::de::Error,
14106 {
14107 match value {
14108 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
14109 "sortColumnIndex" | "sort_column_index" => Ok(GeneratedField::SortColumnIndex),
14110 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14111 }
14112 }
14113 }
14114 deserializer.deserialize_identifier(GeneratedVisitor)
14115 }
14116 }
14117 struct GeneratedVisitor;
14118 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14119 type Value = SortNode;
14120
14121 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14122 formatter.write_str("struct stream_plan.SortNode")
14123 }
14124
14125 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
14126 where
14127 V: serde::de::MapAccess<'de>,
14128 {
14129 let mut state_table__ = None;
14130 let mut sort_column_index__ = None;
14131 while let Some(k) = map_.next_key()? {
14132 match k {
14133 GeneratedField::StateTable => {
14134 if state_table__.is_some() {
14135 return Err(serde::de::Error::duplicate_field("stateTable"));
14136 }
14137 state_table__ = map_.next_value()?;
14138 }
14139 GeneratedField::SortColumnIndex => {
14140 if sort_column_index__.is_some() {
14141 return Err(serde::de::Error::duplicate_field("sortColumnIndex"));
14142 }
14143 sort_column_index__ =
14144 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14145 ;
14146 }
14147 }
14148 }
14149 Ok(SortNode {
14150 state_table: state_table__,
14151 sort_column_index: sort_column_index__.unwrap_or_default(),
14152 })
14153 }
14154 }
14155 deserializer.deserialize_struct("stream_plan.SortNode", FIELDS, GeneratedVisitor)
14156 }
14157}
14158impl serde::Serialize for SourceBackfillNode {
14159 #[allow(deprecated)]
14160 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14161 where
14162 S: serde::Serializer,
14163 {
14164 use serde::ser::SerializeStruct;
14165 let mut len = 0;
14166 if self.upstream_source_id != 0 {
14167 len += 1;
14168 }
14169 if self.row_id_index.is_some() {
14170 len += 1;
14171 }
14172 if !self.columns.is_empty() {
14173 len += 1;
14174 }
14175 if self.info.is_some() {
14176 len += 1;
14177 }
14178 if !self.source_name.is_empty() {
14179 len += 1;
14180 }
14181 if !self.with_properties.is_empty() {
14182 len += 1;
14183 }
14184 if self.rate_limit.is_some() {
14185 len += 1;
14186 }
14187 if self.state_table.is_some() {
14188 len += 1;
14189 }
14190 if !self.secret_refs.is_empty() {
14191 len += 1;
14192 }
14193 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceBackfillNode", len)?;
14194 if self.upstream_source_id != 0 {
14195 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
14196 }
14197 if let Some(v) = self.row_id_index.as_ref() {
14198 struct_ser.serialize_field("rowIdIndex", v)?;
14199 }
14200 if !self.columns.is_empty() {
14201 struct_ser.serialize_field("columns", &self.columns)?;
14202 }
14203 if let Some(v) = self.info.as_ref() {
14204 struct_ser.serialize_field("info", v)?;
14205 }
14206 if !self.source_name.is_empty() {
14207 struct_ser.serialize_field("sourceName", &self.source_name)?;
14208 }
14209 if !self.with_properties.is_empty() {
14210 struct_ser.serialize_field("withProperties", &self.with_properties)?;
14211 }
14212 if let Some(v) = self.rate_limit.as_ref() {
14213 struct_ser.serialize_field("rateLimit", v)?;
14214 }
14215 if let Some(v) = self.state_table.as_ref() {
14216 struct_ser.serialize_field("stateTable", v)?;
14217 }
14218 if !self.secret_refs.is_empty() {
14219 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
14220 }
14221 struct_ser.end()
14222 }
14223}
14224impl<'de> serde::Deserialize<'de> for SourceBackfillNode {
14225 #[allow(deprecated)]
14226 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14227 where
14228 D: serde::Deserializer<'de>,
14229 {
14230 const FIELDS: &[&str] = &[
14231 "upstream_source_id",
14232 "upstreamSourceId",
14233 "row_id_index",
14234 "rowIdIndex",
14235 "columns",
14236 "info",
14237 "source_name",
14238 "sourceName",
14239 "with_properties",
14240 "withProperties",
14241 "rate_limit",
14242 "rateLimit",
14243 "state_table",
14244 "stateTable",
14245 "secret_refs",
14246 "secretRefs",
14247 ];
14248
14249 #[allow(clippy::enum_variant_names)]
14250 enum GeneratedField {
14251 UpstreamSourceId,
14252 RowIdIndex,
14253 Columns,
14254 Info,
14255 SourceName,
14256 WithProperties,
14257 RateLimit,
14258 StateTable,
14259 SecretRefs,
14260 }
14261 impl<'de> serde::Deserialize<'de> for GeneratedField {
14262 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14263 where
14264 D: serde::Deserializer<'de>,
14265 {
14266 struct GeneratedVisitor;
14267
14268 impl serde::de::Visitor<'_> for GeneratedVisitor {
14269 type Value = GeneratedField;
14270
14271 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14272 write!(formatter, "expected one of: {:?}", &FIELDS)
14273 }
14274
14275 #[allow(unused_variables)]
14276 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14277 where
14278 E: serde::de::Error,
14279 {
14280 match value {
14281 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
14282 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
14283 "columns" => Ok(GeneratedField::Columns),
14284 "info" => Ok(GeneratedField::Info),
14285 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
14286 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
14287 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
14288 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
14289 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
14290 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14291 }
14292 }
14293 }
14294 deserializer.deserialize_identifier(GeneratedVisitor)
14295 }
14296 }
14297 struct GeneratedVisitor;
14298 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14299 type Value = SourceBackfillNode;
14300
14301 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14302 formatter.write_str("struct stream_plan.SourceBackfillNode")
14303 }
14304
14305 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceBackfillNode, V::Error>
14306 where
14307 V: serde::de::MapAccess<'de>,
14308 {
14309 let mut upstream_source_id__ = None;
14310 let mut row_id_index__ = None;
14311 let mut columns__ = None;
14312 let mut info__ = None;
14313 let mut source_name__ = None;
14314 let mut with_properties__ = None;
14315 let mut rate_limit__ = None;
14316 let mut state_table__ = None;
14317 let mut secret_refs__ = None;
14318 while let Some(k) = map_.next_key()? {
14319 match k {
14320 GeneratedField::UpstreamSourceId => {
14321 if upstream_source_id__.is_some() {
14322 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
14323 }
14324 upstream_source_id__ =
14325 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14326 ;
14327 }
14328 GeneratedField::RowIdIndex => {
14329 if row_id_index__.is_some() {
14330 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
14331 }
14332 row_id_index__ =
14333 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14334 ;
14335 }
14336 GeneratedField::Columns => {
14337 if columns__.is_some() {
14338 return Err(serde::de::Error::duplicate_field("columns"));
14339 }
14340 columns__ = Some(map_.next_value()?);
14341 }
14342 GeneratedField::Info => {
14343 if info__.is_some() {
14344 return Err(serde::de::Error::duplicate_field("info"));
14345 }
14346 info__ = map_.next_value()?;
14347 }
14348 GeneratedField::SourceName => {
14349 if source_name__.is_some() {
14350 return Err(serde::de::Error::duplicate_field("sourceName"));
14351 }
14352 source_name__ = Some(map_.next_value()?);
14353 }
14354 GeneratedField::WithProperties => {
14355 if with_properties__.is_some() {
14356 return Err(serde::de::Error::duplicate_field("withProperties"));
14357 }
14358 with_properties__ = Some(
14359 map_.next_value::<std::collections::BTreeMap<_, _>>()?
14360 );
14361 }
14362 GeneratedField::RateLimit => {
14363 if rate_limit__.is_some() {
14364 return Err(serde::de::Error::duplicate_field("rateLimit"));
14365 }
14366 rate_limit__ =
14367 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14368 ;
14369 }
14370 GeneratedField::StateTable => {
14371 if state_table__.is_some() {
14372 return Err(serde::de::Error::duplicate_field("stateTable"));
14373 }
14374 state_table__ = map_.next_value()?;
14375 }
14376 GeneratedField::SecretRefs => {
14377 if secret_refs__.is_some() {
14378 return Err(serde::de::Error::duplicate_field("secretRefs"));
14379 }
14380 secret_refs__ = Some(
14381 map_.next_value::<std::collections::BTreeMap<_, _>>()?
14382 );
14383 }
14384 }
14385 }
14386 Ok(SourceBackfillNode {
14387 upstream_source_id: upstream_source_id__.unwrap_or_default(),
14388 row_id_index: row_id_index__,
14389 columns: columns__.unwrap_or_default(),
14390 info: info__,
14391 source_name: source_name__.unwrap_or_default(),
14392 with_properties: with_properties__.unwrap_or_default(),
14393 rate_limit: rate_limit__,
14394 state_table: state_table__,
14395 secret_refs: secret_refs__.unwrap_or_default(),
14396 })
14397 }
14398 }
14399 deserializer.deserialize_struct("stream_plan.SourceBackfillNode", FIELDS, GeneratedVisitor)
14400 }
14401}
14402impl serde::Serialize for SourceChangeSplitMutation {
14403 #[allow(deprecated)]
14404 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14405 where
14406 S: serde::Serializer,
14407 {
14408 use serde::ser::SerializeStruct;
14409 let mut len = 0;
14410 if !self.actor_splits.is_empty() {
14411 len += 1;
14412 }
14413 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceChangeSplitMutation", len)?;
14414 if !self.actor_splits.is_empty() {
14415 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
14416 }
14417 struct_ser.end()
14418 }
14419}
14420impl<'de> serde::Deserialize<'de> for SourceChangeSplitMutation {
14421 #[allow(deprecated)]
14422 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14423 where
14424 D: serde::Deserializer<'de>,
14425 {
14426 const FIELDS: &[&str] = &[
14427 "actor_splits",
14428 "actorSplits",
14429 ];
14430
14431 #[allow(clippy::enum_variant_names)]
14432 enum GeneratedField {
14433 ActorSplits,
14434 }
14435 impl<'de> serde::Deserialize<'de> for GeneratedField {
14436 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14437 where
14438 D: serde::Deserializer<'de>,
14439 {
14440 struct GeneratedVisitor;
14441
14442 impl serde::de::Visitor<'_> for GeneratedVisitor {
14443 type Value = GeneratedField;
14444
14445 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14446 write!(formatter, "expected one of: {:?}", &FIELDS)
14447 }
14448
14449 #[allow(unused_variables)]
14450 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14451 where
14452 E: serde::de::Error,
14453 {
14454 match value {
14455 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
14456 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14457 }
14458 }
14459 }
14460 deserializer.deserialize_identifier(GeneratedVisitor)
14461 }
14462 }
14463 struct GeneratedVisitor;
14464 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14465 type Value = SourceChangeSplitMutation;
14466
14467 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14468 formatter.write_str("struct stream_plan.SourceChangeSplitMutation")
14469 }
14470
14471 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceChangeSplitMutation, V::Error>
14472 where
14473 V: serde::de::MapAccess<'de>,
14474 {
14475 let mut actor_splits__ = None;
14476 while let Some(k) = map_.next_key()? {
14477 match k {
14478 GeneratedField::ActorSplits => {
14479 if actor_splits__.is_some() {
14480 return Err(serde::de::Error::duplicate_field("actorSplits"));
14481 }
14482 actor_splits__ = Some(
14483 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14484 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
14485 );
14486 }
14487 }
14488 }
14489 Ok(SourceChangeSplitMutation {
14490 actor_splits: actor_splits__.unwrap_or_default(),
14491 })
14492 }
14493 }
14494 deserializer.deserialize_struct("stream_plan.SourceChangeSplitMutation", FIELDS, GeneratedVisitor)
14495 }
14496}
14497impl serde::Serialize for SourceNode {
14498 #[allow(deprecated)]
14499 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14500 where
14501 S: serde::Serializer,
14502 {
14503 use serde::ser::SerializeStruct;
14504 let mut len = 0;
14505 if self.source_inner.is_some() {
14506 len += 1;
14507 }
14508 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceNode", len)?;
14509 if let Some(v) = self.source_inner.as_ref() {
14510 struct_ser.serialize_field("sourceInner", v)?;
14511 }
14512 struct_ser.end()
14513 }
14514}
14515impl<'de> serde::Deserialize<'de> for SourceNode {
14516 #[allow(deprecated)]
14517 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14518 where
14519 D: serde::Deserializer<'de>,
14520 {
14521 const FIELDS: &[&str] = &[
14522 "source_inner",
14523 "sourceInner",
14524 ];
14525
14526 #[allow(clippy::enum_variant_names)]
14527 enum GeneratedField {
14528 SourceInner,
14529 }
14530 impl<'de> serde::Deserialize<'de> for GeneratedField {
14531 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14532 where
14533 D: serde::Deserializer<'de>,
14534 {
14535 struct GeneratedVisitor;
14536
14537 impl serde::de::Visitor<'_> for GeneratedVisitor {
14538 type Value = GeneratedField;
14539
14540 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14541 write!(formatter, "expected one of: {:?}", &FIELDS)
14542 }
14543
14544 #[allow(unused_variables)]
14545 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14546 where
14547 E: serde::de::Error,
14548 {
14549 match value {
14550 "sourceInner" | "source_inner" => Ok(GeneratedField::SourceInner),
14551 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14552 }
14553 }
14554 }
14555 deserializer.deserialize_identifier(GeneratedVisitor)
14556 }
14557 }
14558 struct GeneratedVisitor;
14559 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14560 type Value = SourceNode;
14561
14562 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14563 formatter.write_str("struct stream_plan.SourceNode")
14564 }
14565
14566 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
14567 where
14568 V: serde::de::MapAccess<'de>,
14569 {
14570 let mut source_inner__ = None;
14571 while let Some(k) = map_.next_key()? {
14572 match k {
14573 GeneratedField::SourceInner => {
14574 if source_inner__.is_some() {
14575 return Err(serde::de::Error::duplicate_field("sourceInner"));
14576 }
14577 source_inner__ = map_.next_value()?;
14578 }
14579 }
14580 }
14581 Ok(SourceNode {
14582 source_inner: source_inner__,
14583 })
14584 }
14585 }
14586 deserializer.deserialize_struct("stream_plan.SourceNode", FIELDS, GeneratedVisitor)
14587 }
14588}
14589impl serde::Serialize for StartFragmentBackfillMutation {
14590 #[allow(deprecated)]
14591 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14592 where
14593 S: serde::Serializer,
14594 {
14595 use serde::ser::SerializeStruct;
14596 let mut len = 0;
14597 if !self.fragment_ids.is_empty() {
14598 len += 1;
14599 }
14600 let mut struct_ser = serializer.serialize_struct("stream_plan.StartFragmentBackfillMutation", len)?;
14601 if !self.fragment_ids.is_empty() {
14602 struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
14603 }
14604 struct_ser.end()
14605 }
14606}
14607impl<'de> serde::Deserialize<'de> for StartFragmentBackfillMutation {
14608 #[allow(deprecated)]
14609 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14610 where
14611 D: serde::Deserializer<'de>,
14612 {
14613 const FIELDS: &[&str] = &[
14614 "fragment_ids",
14615 "fragmentIds",
14616 ];
14617
14618 #[allow(clippy::enum_variant_names)]
14619 enum GeneratedField {
14620 FragmentIds,
14621 }
14622 impl<'de> serde::Deserialize<'de> for GeneratedField {
14623 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14624 where
14625 D: serde::Deserializer<'de>,
14626 {
14627 struct GeneratedVisitor;
14628
14629 impl serde::de::Visitor<'_> for GeneratedVisitor {
14630 type Value = GeneratedField;
14631
14632 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14633 write!(formatter, "expected one of: {:?}", &FIELDS)
14634 }
14635
14636 #[allow(unused_variables)]
14637 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14638 where
14639 E: serde::de::Error,
14640 {
14641 match value {
14642 "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
14643 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14644 }
14645 }
14646 }
14647 deserializer.deserialize_identifier(GeneratedVisitor)
14648 }
14649 }
14650 struct GeneratedVisitor;
14651 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14652 type Value = StartFragmentBackfillMutation;
14653
14654 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14655 formatter.write_str("struct stream_plan.StartFragmentBackfillMutation")
14656 }
14657
14658 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StartFragmentBackfillMutation, V::Error>
14659 where
14660 V: serde::de::MapAccess<'de>,
14661 {
14662 let mut fragment_ids__ = None;
14663 while let Some(k) = map_.next_key()? {
14664 match k {
14665 GeneratedField::FragmentIds => {
14666 if fragment_ids__.is_some() {
14667 return Err(serde::de::Error::duplicate_field("fragmentIds"));
14668 }
14669 fragment_ids__ =
14670 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14671 .into_iter().map(|x| x.0).collect())
14672 ;
14673 }
14674 }
14675 }
14676 Ok(StartFragmentBackfillMutation {
14677 fragment_ids: fragment_ids__.unwrap_or_default(),
14678 })
14679 }
14680 }
14681 deserializer.deserialize_struct("stream_plan.StartFragmentBackfillMutation", FIELDS, GeneratedVisitor)
14682 }
14683}
14684impl serde::Serialize for StopMutation {
14685 #[allow(deprecated)]
14686 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14687 where
14688 S: serde::Serializer,
14689 {
14690 use serde::ser::SerializeStruct;
14691 let mut len = 0;
14692 if !self.actors.is_empty() {
14693 len += 1;
14694 }
14695 if !self.dropped_sink_fragments.is_empty() {
14696 len += 1;
14697 }
14698 let mut struct_ser = serializer.serialize_struct("stream_plan.StopMutation", len)?;
14699 if !self.actors.is_empty() {
14700 struct_ser.serialize_field("actors", &self.actors)?;
14701 }
14702 if !self.dropped_sink_fragments.is_empty() {
14703 struct_ser.serialize_field("droppedSinkFragments", &self.dropped_sink_fragments)?;
14704 }
14705 struct_ser.end()
14706 }
14707}
14708impl<'de> serde::Deserialize<'de> for StopMutation {
14709 #[allow(deprecated)]
14710 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14711 where
14712 D: serde::Deserializer<'de>,
14713 {
14714 const FIELDS: &[&str] = &[
14715 "actors",
14716 "dropped_sink_fragments",
14717 "droppedSinkFragments",
14718 ];
14719
14720 #[allow(clippy::enum_variant_names)]
14721 enum GeneratedField {
14722 Actors,
14723 DroppedSinkFragments,
14724 }
14725 impl<'de> serde::Deserialize<'de> for GeneratedField {
14726 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14727 where
14728 D: serde::Deserializer<'de>,
14729 {
14730 struct GeneratedVisitor;
14731
14732 impl serde::de::Visitor<'_> for GeneratedVisitor {
14733 type Value = GeneratedField;
14734
14735 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14736 write!(formatter, "expected one of: {:?}", &FIELDS)
14737 }
14738
14739 #[allow(unused_variables)]
14740 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14741 where
14742 E: serde::de::Error,
14743 {
14744 match value {
14745 "actors" => Ok(GeneratedField::Actors),
14746 "droppedSinkFragments" | "dropped_sink_fragments" => Ok(GeneratedField::DroppedSinkFragments),
14747 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14748 }
14749 }
14750 }
14751 deserializer.deserialize_identifier(GeneratedVisitor)
14752 }
14753 }
14754 struct GeneratedVisitor;
14755 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14756 type Value = StopMutation;
14757
14758 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14759 formatter.write_str("struct stream_plan.StopMutation")
14760 }
14761
14762 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopMutation, V::Error>
14763 where
14764 V: serde::de::MapAccess<'de>,
14765 {
14766 let mut actors__ = None;
14767 let mut dropped_sink_fragments__ = None;
14768 while let Some(k) = map_.next_key()? {
14769 match k {
14770 GeneratedField::Actors => {
14771 if actors__.is_some() {
14772 return Err(serde::de::Error::duplicate_field("actors"));
14773 }
14774 actors__ =
14775 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14776 .into_iter().map(|x| x.0).collect())
14777 ;
14778 }
14779 GeneratedField::DroppedSinkFragments => {
14780 if dropped_sink_fragments__.is_some() {
14781 return Err(serde::de::Error::duplicate_field("droppedSinkFragments"));
14782 }
14783 dropped_sink_fragments__ =
14784 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14785 .into_iter().map(|x| x.0).collect())
14786 ;
14787 }
14788 }
14789 }
14790 Ok(StopMutation {
14791 actors: actors__.unwrap_or_default(),
14792 dropped_sink_fragments: dropped_sink_fragments__.unwrap_or_default(),
14793 })
14794 }
14795 }
14796 deserializer.deserialize_struct("stream_plan.StopMutation", FIELDS, GeneratedVisitor)
14797 }
14798}
14799impl serde::Serialize for StreamActor {
14800 #[allow(deprecated)]
14801 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14802 where
14803 S: serde::Serializer,
14804 {
14805 use serde::ser::SerializeStruct;
14806 let mut len = 0;
14807 if self.actor_id != 0 {
14808 len += 1;
14809 }
14810 if self.fragment_id != 0 {
14811 len += 1;
14812 }
14813 if !self.dispatcher.is_empty() {
14814 len += 1;
14815 }
14816 if self.vnode_bitmap.is_some() {
14817 len += 1;
14818 }
14819 if !self.mview_definition.is_empty() {
14820 len += 1;
14821 }
14822 if self.expr_context.is_some() {
14823 len += 1;
14824 }
14825 if !self.config_override.is_empty() {
14826 len += 1;
14827 }
14828 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamActor", len)?;
14829 if self.actor_id != 0 {
14830 struct_ser.serialize_field("actorId", &self.actor_id)?;
14831 }
14832 if self.fragment_id != 0 {
14833 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
14834 }
14835 if !self.dispatcher.is_empty() {
14836 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
14837 }
14838 if let Some(v) = self.vnode_bitmap.as_ref() {
14839 struct_ser.serialize_field("vnodeBitmap", v)?;
14840 }
14841 if !self.mview_definition.is_empty() {
14842 struct_ser.serialize_field("mviewDefinition", &self.mview_definition)?;
14843 }
14844 if let Some(v) = self.expr_context.as_ref() {
14845 struct_ser.serialize_field("exprContext", v)?;
14846 }
14847 if !self.config_override.is_empty() {
14848 struct_ser.serialize_field("configOverride", &self.config_override)?;
14849 }
14850 struct_ser.end()
14851 }
14852}
14853impl<'de> serde::Deserialize<'de> for StreamActor {
14854 #[allow(deprecated)]
14855 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14856 where
14857 D: serde::Deserializer<'de>,
14858 {
14859 const FIELDS: &[&str] = &[
14860 "actor_id",
14861 "actorId",
14862 "fragment_id",
14863 "fragmentId",
14864 "dispatcher",
14865 "vnode_bitmap",
14866 "vnodeBitmap",
14867 "mview_definition",
14868 "mviewDefinition",
14869 "expr_context",
14870 "exprContext",
14871 "config_override",
14872 "configOverride",
14873 ];
14874
14875 #[allow(clippy::enum_variant_names)]
14876 enum GeneratedField {
14877 ActorId,
14878 FragmentId,
14879 Dispatcher,
14880 VnodeBitmap,
14881 MviewDefinition,
14882 ExprContext,
14883 ConfigOverride,
14884 }
14885 impl<'de> serde::Deserialize<'de> for GeneratedField {
14886 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14887 where
14888 D: serde::Deserializer<'de>,
14889 {
14890 struct GeneratedVisitor;
14891
14892 impl serde::de::Visitor<'_> for GeneratedVisitor {
14893 type Value = GeneratedField;
14894
14895 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14896 write!(formatter, "expected one of: {:?}", &FIELDS)
14897 }
14898
14899 #[allow(unused_variables)]
14900 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14901 where
14902 E: serde::de::Error,
14903 {
14904 match value {
14905 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
14906 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
14907 "dispatcher" => Ok(GeneratedField::Dispatcher),
14908 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
14909 "mviewDefinition" | "mview_definition" => Ok(GeneratedField::MviewDefinition),
14910 "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
14911 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
14912 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14913 }
14914 }
14915 }
14916 deserializer.deserialize_identifier(GeneratedVisitor)
14917 }
14918 }
14919 struct GeneratedVisitor;
14920 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14921 type Value = StreamActor;
14922
14923 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14924 formatter.write_str("struct stream_plan.StreamActor")
14925 }
14926
14927 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamActor, V::Error>
14928 where
14929 V: serde::de::MapAccess<'de>,
14930 {
14931 let mut actor_id__ = None;
14932 let mut fragment_id__ = None;
14933 let mut dispatcher__ = None;
14934 let mut vnode_bitmap__ = None;
14935 let mut mview_definition__ = None;
14936 let mut expr_context__ = None;
14937 let mut config_override__ = None;
14938 while let Some(k) = map_.next_key()? {
14939 match k {
14940 GeneratedField::ActorId => {
14941 if actor_id__.is_some() {
14942 return Err(serde::de::Error::duplicate_field("actorId"));
14943 }
14944 actor_id__ =
14945 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14946 ;
14947 }
14948 GeneratedField::FragmentId => {
14949 if fragment_id__.is_some() {
14950 return Err(serde::de::Error::duplicate_field("fragmentId"));
14951 }
14952 fragment_id__ =
14953 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14954 ;
14955 }
14956 GeneratedField::Dispatcher => {
14957 if dispatcher__.is_some() {
14958 return Err(serde::de::Error::duplicate_field("dispatcher"));
14959 }
14960 dispatcher__ = Some(map_.next_value()?);
14961 }
14962 GeneratedField::VnodeBitmap => {
14963 if vnode_bitmap__.is_some() {
14964 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
14965 }
14966 vnode_bitmap__ = map_.next_value()?;
14967 }
14968 GeneratedField::MviewDefinition => {
14969 if mview_definition__.is_some() {
14970 return Err(serde::de::Error::duplicate_field("mviewDefinition"));
14971 }
14972 mview_definition__ = Some(map_.next_value()?);
14973 }
14974 GeneratedField::ExprContext => {
14975 if expr_context__.is_some() {
14976 return Err(serde::de::Error::duplicate_field("exprContext"));
14977 }
14978 expr_context__ = map_.next_value()?;
14979 }
14980 GeneratedField::ConfigOverride => {
14981 if config_override__.is_some() {
14982 return Err(serde::de::Error::duplicate_field("configOverride"));
14983 }
14984 config_override__ = Some(map_.next_value()?);
14985 }
14986 }
14987 }
14988 Ok(StreamActor {
14989 actor_id: actor_id__.unwrap_or_default(),
14990 fragment_id: fragment_id__.unwrap_or_default(),
14991 dispatcher: dispatcher__.unwrap_or_default(),
14992 vnode_bitmap: vnode_bitmap__,
14993 mview_definition: mview_definition__.unwrap_or_default(),
14994 expr_context: expr_context__,
14995 config_override: config_override__.unwrap_or_default(),
14996 })
14997 }
14998 }
14999 deserializer.deserialize_struct("stream_plan.StreamActor", FIELDS, GeneratedVisitor)
15000 }
15001}
15002impl serde::Serialize for StreamCdcScanNode {
15003 #[allow(deprecated)]
15004 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15005 where
15006 S: serde::Serializer,
15007 {
15008 use serde::ser::SerializeStruct;
15009 let mut len = 0;
15010 if self.table_id != 0 {
15011 len += 1;
15012 }
15013 if !self.upstream_column_ids.is_empty() {
15014 len += 1;
15015 }
15016 if !self.output_indices.is_empty() {
15017 len += 1;
15018 }
15019 if self.state_table.is_some() {
15020 len += 1;
15021 }
15022 if self.cdc_table_desc.is_some() {
15023 len += 1;
15024 }
15025 if self.rate_limit.is_some() {
15026 len += 1;
15027 }
15028 if self.disable_backfill {
15029 len += 1;
15030 }
15031 if self.options.is_some() {
15032 len += 1;
15033 }
15034 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanNode", len)?;
15035 if self.table_id != 0 {
15036 struct_ser.serialize_field("tableId", &self.table_id)?;
15037 }
15038 if !self.upstream_column_ids.is_empty() {
15039 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
15040 }
15041 if !self.output_indices.is_empty() {
15042 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
15043 }
15044 if let Some(v) = self.state_table.as_ref() {
15045 struct_ser.serialize_field("stateTable", v)?;
15046 }
15047 if let Some(v) = self.cdc_table_desc.as_ref() {
15048 struct_ser.serialize_field("cdcTableDesc", v)?;
15049 }
15050 if let Some(v) = self.rate_limit.as_ref() {
15051 struct_ser.serialize_field("rateLimit", v)?;
15052 }
15053 if self.disable_backfill {
15054 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
15055 }
15056 if let Some(v) = self.options.as_ref() {
15057 struct_ser.serialize_field("options", v)?;
15058 }
15059 struct_ser.end()
15060 }
15061}
15062impl<'de> serde::Deserialize<'de> for StreamCdcScanNode {
15063 #[allow(deprecated)]
15064 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15065 where
15066 D: serde::Deserializer<'de>,
15067 {
15068 const FIELDS: &[&str] = &[
15069 "table_id",
15070 "tableId",
15071 "upstream_column_ids",
15072 "upstreamColumnIds",
15073 "output_indices",
15074 "outputIndices",
15075 "state_table",
15076 "stateTable",
15077 "cdc_table_desc",
15078 "cdcTableDesc",
15079 "rate_limit",
15080 "rateLimit",
15081 "disable_backfill",
15082 "disableBackfill",
15083 "options",
15084 ];
15085
15086 #[allow(clippy::enum_variant_names)]
15087 enum GeneratedField {
15088 TableId,
15089 UpstreamColumnIds,
15090 OutputIndices,
15091 StateTable,
15092 CdcTableDesc,
15093 RateLimit,
15094 DisableBackfill,
15095 Options,
15096 }
15097 impl<'de> serde::Deserialize<'de> for GeneratedField {
15098 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15099 where
15100 D: serde::Deserializer<'de>,
15101 {
15102 struct GeneratedVisitor;
15103
15104 impl serde::de::Visitor<'_> for GeneratedVisitor {
15105 type Value = GeneratedField;
15106
15107 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15108 write!(formatter, "expected one of: {:?}", &FIELDS)
15109 }
15110
15111 #[allow(unused_variables)]
15112 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15113 where
15114 E: serde::de::Error,
15115 {
15116 match value {
15117 "tableId" | "table_id" => Ok(GeneratedField::TableId),
15118 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
15119 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
15120 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
15121 "cdcTableDesc" | "cdc_table_desc" => Ok(GeneratedField::CdcTableDesc),
15122 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
15123 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
15124 "options" => Ok(GeneratedField::Options),
15125 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15126 }
15127 }
15128 }
15129 deserializer.deserialize_identifier(GeneratedVisitor)
15130 }
15131 }
15132 struct GeneratedVisitor;
15133 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15134 type Value = StreamCdcScanNode;
15135
15136 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15137 formatter.write_str("struct stream_plan.StreamCdcScanNode")
15138 }
15139
15140 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanNode, V::Error>
15141 where
15142 V: serde::de::MapAccess<'de>,
15143 {
15144 let mut table_id__ = None;
15145 let mut upstream_column_ids__ = None;
15146 let mut output_indices__ = None;
15147 let mut state_table__ = None;
15148 let mut cdc_table_desc__ = None;
15149 let mut rate_limit__ = None;
15150 let mut disable_backfill__ = None;
15151 let mut options__ = None;
15152 while let Some(k) = map_.next_key()? {
15153 match k {
15154 GeneratedField::TableId => {
15155 if table_id__.is_some() {
15156 return Err(serde::de::Error::duplicate_field("tableId"));
15157 }
15158 table_id__ =
15159 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15160 ;
15161 }
15162 GeneratedField::UpstreamColumnIds => {
15163 if upstream_column_ids__.is_some() {
15164 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
15165 }
15166 upstream_column_ids__ =
15167 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15168 .into_iter().map(|x| x.0).collect())
15169 ;
15170 }
15171 GeneratedField::OutputIndices => {
15172 if output_indices__.is_some() {
15173 return Err(serde::de::Error::duplicate_field("outputIndices"));
15174 }
15175 output_indices__ =
15176 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15177 .into_iter().map(|x| x.0).collect())
15178 ;
15179 }
15180 GeneratedField::StateTable => {
15181 if state_table__.is_some() {
15182 return Err(serde::de::Error::duplicate_field("stateTable"));
15183 }
15184 state_table__ = map_.next_value()?;
15185 }
15186 GeneratedField::CdcTableDesc => {
15187 if cdc_table_desc__.is_some() {
15188 return Err(serde::de::Error::duplicate_field("cdcTableDesc"));
15189 }
15190 cdc_table_desc__ = map_.next_value()?;
15191 }
15192 GeneratedField::RateLimit => {
15193 if rate_limit__.is_some() {
15194 return Err(serde::de::Error::duplicate_field("rateLimit"));
15195 }
15196 rate_limit__ =
15197 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15198 ;
15199 }
15200 GeneratedField::DisableBackfill => {
15201 if disable_backfill__.is_some() {
15202 return Err(serde::de::Error::duplicate_field("disableBackfill"));
15203 }
15204 disable_backfill__ = Some(map_.next_value()?);
15205 }
15206 GeneratedField::Options => {
15207 if options__.is_some() {
15208 return Err(serde::de::Error::duplicate_field("options"));
15209 }
15210 options__ = map_.next_value()?;
15211 }
15212 }
15213 }
15214 Ok(StreamCdcScanNode {
15215 table_id: table_id__.unwrap_or_default(),
15216 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
15217 output_indices: output_indices__.unwrap_or_default(),
15218 state_table: state_table__,
15219 cdc_table_desc: cdc_table_desc__,
15220 rate_limit: rate_limit__,
15221 disable_backfill: disable_backfill__.unwrap_or_default(),
15222 options: options__,
15223 })
15224 }
15225 }
15226 deserializer.deserialize_struct("stream_plan.StreamCdcScanNode", FIELDS, GeneratedVisitor)
15227 }
15228}
15229impl serde::Serialize for StreamCdcScanOptions {
15230 #[allow(deprecated)]
15231 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15232 where
15233 S: serde::Serializer,
15234 {
15235 use serde::ser::SerializeStruct;
15236 let mut len = 0;
15237 if self.disable_backfill {
15238 len += 1;
15239 }
15240 if self.snapshot_barrier_interval != 0 {
15241 len += 1;
15242 }
15243 if self.snapshot_batch_size != 0 {
15244 len += 1;
15245 }
15246 if self.backfill_parallelism != 0 {
15247 len += 1;
15248 }
15249 if self.backfill_num_rows_per_split != 0 {
15250 len += 1;
15251 }
15252 if self.backfill_as_even_splits {
15253 len += 1;
15254 }
15255 if self.backfill_split_pk_column_index != 0 {
15256 len += 1;
15257 }
15258 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanOptions", len)?;
15259 if self.disable_backfill {
15260 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
15261 }
15262 if self.snapshot_barrier_interval != 0 {
15263 struct_ser.serialize_field("snapshotBarrierInterval", &self.snapshot_barrier_interval)?;
15264 }
15265 if self.snapshot_batch_size != 0 {
15266 struct_ser.serialize_field("snapshotBatchSize", &self.snapshot_batch_size)?;
15267 }
15268 if self.backfill_parallelism != 0 {
15269 struct_ser.serialize_field("backfillParallelism", &self.backfill_parallelism)?;
15270 }
15271 if self.backfill_num_rows_per_split != 0 {
15272 #[allow(clippy::needless_borrow)]
15273 #[allow(clippy::needless_borrows_for_generic_args)]
15274 struct_ser.serialize_field("backfillNumRowsPerSplit", ToString::to_string(&self.backfill_num_rows_per_split).as_str())?;
15275 }
15276 if self.backfill_as_even_splits {
15277 struct_ser.serialize_field("backfillAsEvenSplits", &self.backfill_as_even_splits)?;
15278 }
15279 if self.backfill_split_pk_column_index != 0 {
15280 struct_ser.serialize_field("backfillSplitPkColumnIndex", &self.backfill_split_pk_column_index)?;
15281 }
15282 struct_ser.end()
15283 }
15284}
15285impl<'de> serde::Deserialize<'de> for StreamCdcScanOptions {
15286 #[allow(deprecated)]
15287 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15288 where
15289 D: serde::Deserializer<'de>,
15290 {
15291 const FIELDS: &[&str] = &[
15292 "disable_backfill",
15293 "disableBackfill",
15294 "snapshot_barrier_interval",
15295 "snapshotBarrierInterval",
15296 "snapshot_batch_size",
15297 "snapshotBatchSize",
15298 "backfill_parallelism",
15299 "backfillParallelism",
15300 "backfill_num_rows_per_split",
15301 "backfillNumRowsPerSplit",
15302 "backfill_as_even_splits",
15303 "backfillAsEvenSplits",
15304 "backfill_split_pk_column_index",
15305 "backfillSplitPkColumnIndex",
15306 ];
15307
15308 #[allow(clippy::enum_variant_names)]
15309 enum GeneratedField {
15310 DisableBackfill,
15311 SnapshotBarrierInterval,
15312 SnapshotBatchSize,
15313 BackfillParallelism,
15314 BackfillNumRowsPerSplit,
15315 BackfillAsEvenSplits,
15316 BackfillSplitPkColumnIndex,
15317 }
15318 impl<'de> serde::Deserialize<'de> for GeneratedField {
15319 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15320 where
15321 D: serde::Deserializer<'de>,
15322 {
15323 struct GeneratedVisitor;
15324
15325 impl serde::de::Visitor<'_> for GeneratedVisitor {
15326 type Value = GeneratedField;
15327
15328 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15329 write!(formatter, "expected one of: {:?}", &FIELDS)
15330 }
15331
15332 #[allow(unused_variables)]
15333 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15334 where
15335 E: serde::de::Error,
15336 {
15337 match value {
15338 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
15339 "snapshotBarrierInterval" | "snapshot_barrier_interval" => Ok(GeneratedField::SnapshotBarrierInterval),
15340 "snapshotBatchSize" | "snapshot_batch_size" => Ok(GeneratedField::SnapshotBatchSize),
15341 "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
15342 "backfillNumRowsPerSplit" | "backfill_num_rows_per_split" => Ok(GeneratedField::BackfillNumRowsPerSplit),
15343 "backfillAsEvenSplits" | "backfill_as_even_splits" => Ok(GeneratedField::BackfillAsEvenSplits),
15344 "backfillSplitPkColumnIndex" | "backfill_split_pk_column_index" => Ok(GeneratedField::BackfillSplitPkColumnIndex),
15345 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15346 }
15347 }
15348 }
15349 deserializer.deserialize_identifier(GeneratedVisitor)
15350 }
15351 }
15352 struct GeneratedVisitor;
15353 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15354 type Value = StreamCdcScanOptions;
15355
15356 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15357 formatter.write_str("struct stream_plan.StreamCdcScanOptions")
15358 }
15359
15360 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanOptions, V::Error>
15361 where
15362 V: serde::de::MapAccess<'de>,
15363 {
15364 let mut disable_backfill__ = None;
15365 let mut snapshot_barrier_interval__ = None;
15366 let mut snapshot_batch_size__ = None;
15367 let mut backfill_parallelism__ = None;
15368 let mut backfill_num_rows_per_split__ = None;
15369 let mut backfill_as_even_splits__ = None;
15370 let mut backfill_split_pk_column_index__ = None;
15371 while let Some(k) = map_.next_key()? {
15372 match k {
15373 GeneratedField::DisableBackfill => {
15374 if disable_backfill__.is_some() {
15375 return Err(serde::de::Error::duplicate_field("disableBackfill"));
15376 }
15377 disable_backfill__ = Some(map_.next_value()?);
15378 }
15379 GeneratedField::SnapshotBarrierInterval => {
15380 if snapshot_barrier_interval__.is_some() {
15381 return Err(serde::de::Error::duplicate_field("snapshotBarrierInterval"));
15382 }
15383 snapshot_barrier_interval__ =
15384 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15385 ;
15386 }
15387 GeneratedField::SnapshotBatchSize => {
15388 if snapshot_batch_size__.is_some() {
15389 return Err(serde::de::Error::duplicate_field("snapshotBatchSize"));
15390 }
15391 snapshot_batch_size__ =
15392 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15393 ;
15394 }
15395 GeneratedField::BackfillParallelism => {
15396 if backfill_parallelism__.is_some() {
15397 return Err(serde::de::Error::duplicate_field("backfillParallelism"));
15398 }
15399 backfill_parallelism__ =
15400 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15401 ;
15402 }
15403 GeneratedField::BackfillNumRowsPerSplit => {
15404 if backfill_num_rows_per_split__.is_some() {
15405 return Err(serde::de::Error::duplicate_field("backfillNumRowsPerSplit"));
15406 }
15407 backfill_num_rows_per_split__ =
15408 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15409 ;
15410 }
15411 GeneratedField::BackfillAsEvenSplits => {
15412 if backfill_as_even_splits__.is_some() {
15413 return Err(serde::de::Error::duplicate_field("backfillAsEvenSplits"));
15414 }
15415 backfill_as_even_splits__ = Some(map_.next_value()?);
15416 }
15417 GeneratedField::BackfillSplitPkColumnIndex => {
15418 if backfill_split_pk_column_index__.is_some() {
15419 return Err(serde::de::Error::duplicate_field("backfillSplitPkColumnIndex"));
15420 }
15421 backfill_split_pk_column_index__ =
15422 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15423 ;
15424 }
15425 }
15426 }
15427 Ok(StreamCdcScanOptions {
15428 disable_backfill: disable_backfill__.unwrap_or_default(),
15429 snapshot_barrier_interval: snapshot_barrier_interval__.unwrap_or_default(),
15430 snapshot_batch_size: snapshot_batch_size__.unwrap_or_default(),
15431 backfill_parallelism: backfill_parallelism__.unwrap_or_default(),
15432 backfill_num_rows_per_split: backfill_num_rows_per_split__.unwrap_or_default(),
15433 backfill_as_even_splits: backfill_as_even_splits__.unwrap_or_default(),
15434 backfill_split_pk_column_index: backfill_split_pk_column_index__.unwrap_or_default(),
15435 })
15436 }
15437 }
15438 deserializer.deserialize_struct("stream_plan.StreamCdcScanOptions", FIELDS, GeneratedVisitor)
15439 }
15440}
15441impl serde::Serialize for StreamContext {
15442 #[allow(deprecated)]
15443 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15444 where
15445 S: serde::Serializer,
15446 {
15447 use serde::ser::SerializeStruct;
15448 let mut len = 0;
15449 if !self.timezone.is_empty() {
15450 len += 1;
15451 }
15452 if !self.config_override.is_empty() {
15453 len += 1;
15454 }
15455 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamContext", len)?;
15456 if !self.timezone.is_empty() {
15457 struct_ser.serialize_field("timezone", &self.timezone)?;
15458 }
15459 if !self.config_override.is_empty() {
15460 struct_ser.serialize_field("configOverride", &self.config_override)?;
15461 }
15462 struct_ser.end()
15463 }
15464}
15465impl<'de> serde::Deserialize<'de> for StreamContext {
15466 #[allow(deprecated)]
15467 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15468 where
15469 D: serde::Deserializer<'de>,
15470 {
15471 const FIELDS: &[&str] = &[
15472 "timezone",
15473 "config_override",
15474 "configOverride",
15475 ];
15476
15477 #[allow(clippy::enum_variant_names)]
15478 enum GeneratedField {
15479 Timezone,
15480 ConfigOverride,
15481 }
15482 impl<'de> serde::Deserialize<'de> for GeneratedField {
15483 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15484 where
15485 D: serde::Deserializer<'de>,
15486 {
15487 struct GeneratedVisitor;
15488
15489 impl serde::de::Visitor<'_> for GeneratedVisitor {
15490 type Value = GeneratedField;
15491
15492 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15493 write!(formatter, "expected one of: {:?}", &FIELDS)
15494 }
15495
15496 #[allow(unused_variables)]
15497 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15498 where
15499 E: serde::de::Error,
15500 {
15501 match value {
15502 "timezone" => Ok(GeneratedField::Timezone),
15503 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
15504 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15505 }
15506 }
15507 }
15508 deserializer.deserialize_identifier(GeneratedVisitor)
15509 }
15510 }
15511 struct GeneratedVisitor;
15512 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15513 type Value = StreamContext;
15514
15515 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15516 formatter.write_str("struct stream_plan.StreamContext")
15517 }
15518
15519 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamContext, V::Error>
15520 where
15521 V: serde::de::MapAccess<'de>,
15522 {
15523 let mut timezone__ = None;
15524 let mut config_override__ = None;
15525 while let Some(k) = map_.next_key()? {
15526 match k {
15527 GeneratedField::Timezone => {
15528 if timezone__.is_some() {
15529 return Err(serde::de::Error::duplicate_field("timezone"));
15530 }
15531 timezone__ = Some(map_.next_value()?);
15532 }
15533 GeneratedField::ConfigOverride => {
15534 if config_override__.is_some() {
15535 return Err(serde::de::Error::duplicate_field("configOverride"));
15536 }
15537 config_override__ = Some(map_.next_value()?);
15538 }
15539 }
15540 }
15541 Ok(StreamContext {
15542 timezone: timezone__.unwrap_or_default(),
15543 config_override: config_override__.unwrap_or_default(),
15544 })
15545 }
15546 }
15547 deserializer.deserialize_struct("stream_plan.StreamContext", FIELDS, GeneratedVisitor)
15548 }
15549}
15550impl serde::Serialize for StreamFragmentGraph {
15551 #[allow(deprecated)]
15552 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15553 where
15554 S: serde::Serializer,
15555 {
15556 use serde::ser::SerializeStruct;
15557 let mut len = 0;
15558 if !self.fragments.is_empty() {
15559 len += 1;
15560 }
15561 if !self.edges.is_empty() {
15562 len += 1;
15563 }
15564 if !self.dependent_table_ids.is_empty() {
15565 len += 1;
15566 }
15567 if self.table_ids_cnt != 0 {
15568 len += 1;
15569 }
15570 if self.ctx.is_some() {
15571 len += 1;
15572 }
15573 if self.parallelism.is_some() {
15574 len += 1;
15575 }
15576 if self.backfill_parallelism.is_some() {
15577 len += 1;
15578 }
15579 if !self.adaptive_parallelism_strategy.is_empty() {
15580 len += 1;
15581 }
15582 if !self.backfill_adaptive_parallelism_strategy.is_empty() {
15583 len += 1;
15584 }
15585 if self.max_parallelism != 0 {
15586 len += 1;
15587 }
15588 if self.backfill_order.is_some() {
15589 len += 1;
15590 }
15591 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph", len)?;
15592 if !self.fragments.is_empty() {
15593 struct_ser.serialize_field("fragments", &self.fragments)?;
15594 }
15595 if !self.edges.is_empty() {
15596 struct_ser.serialize_field("edges", &self.edges)?;
15597 }
15598 if !self.dependent_table_ids.is_empty() {
15599 struct_ser.serialize_field("dependentTableIds", &self.dependent_table_ids)?;
15600 }
15601 if self.table_ids_cnt != 0 {
15602 struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
15603 }
15604 if let Some(v) = self.ctx.as_ref() {
15605 struct_ser.serialize_field("ctx", v)?;
15606 }
15607 if let Some(v) = self.parallelism.as_ref() {
15608 struct_ser.serialize_field("parallelism", v)?;
15609 }
15610 if let Some(v) = self.backfill_parallelism.as_ref() {
15611 struct_ser.serialize_field("backfillParallelism", v)?;
15612 }
15613 if !self.adaptive_parallelism_strategy.is_empty() {
15614 struct_ser.serialize_field("adaptiveParallelismStrategy", &self.adaptive_parallelism_strategy)?;
15615 }
15616 if !self.backfill_adaptive_parallelism_strategy.is_empty() {
15617 struct_ser.serialize_field("backfillAdaptiveParallelismStrategy", &self.backfill_adaptive_parallelism_strategy)?;
15618 }
15619 if self.max_parallelism != 0 {
15620 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
15621 }
15622 if let Some(v) = self.backfill_order.as_ref() {
15623 struct_ser.serialize_field("backfillOrder", v)?;
15624 }
15625 struct_ser.end()
15626 }
15627}
15628impl<'de> serde::Deserialize<'de> for StreamFragmentGraph {
15629 #[allow(deprecated)]
15630 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15631 where
15632 D: serde::Deserializer<'de>,
15633 {
15634 const FIELDS: &[&str] = &[
15635 "fragments",
15636 "edges",
15637 "dependent_table_ids",
15638 "dependentTableIds",
15639 "table_ids_cnt",
15640 "tableIdsCnt",
15641 "ctx",
15642 "parallelism",
15643 "backfill_parallelism",
15644 "backfillParallelism",
15645 "adaptive_parallelism_strategy",
15646 "adaptiveParallelismStrategy",
15647 "backfill_adaptive_parallelism_strategy",
15648 "backfillAdaptiveParallelismStrategy",
15649 "max_parallelism",
15650 "maxParallelism",
15651 "backfill_order",
15652 "backfillOrder",
15653 ];
15654
15655 #[allow(clippy::enum_variant_names)]
15656 enum GeneratedField {
15657 Fragments,
15658 Edges,
15659 DependentTableIds,
15660 TableIdsCnt,
15661 Ctx,
15662 Parallelism,
15663 BackfillParallelism,
15664 AdaptiveParallelismStrategy,
15665 BackfillAdaptiveParallelismStrategy,
15666 MaxParallelism,
15667 BackfillOrder,
15668 }
15669 impl<'de> serde::Deserialize<'de> for GeneratedField {
15670 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15671 where
15672 D: serde::Deserializer<'de>,
15673 {
15674 struct GeneratedVisitor;
15675
15676 impl serde::de::Visitor<'_> for GeneratedVisitor {
15677 type Value = GeneratedField;
15678
15679 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15680 write!(formatter, "expected one of: {:?}", &FIELDS)
15681 }
15682
15683 #[allow(unused_variables)]
15684 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15685 where
15686 E: serde::de::Error,
15687 {
15688 match value {
15689 "fragments" => Ok(GeneratedField::Fragments),
15690 "edges" => Ok(GeneratedField::Edges),
15691 "dependentTableIds" | "dependent_table_ids" => Ok(GeneratedField::DependentTableIds),
15692 "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
15693 "ctx" => Ok(GeneratedField::Ctx),
15694 "parallelism" => Ok(GeneratedField::Parallelism),
15695 "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
15696 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
15697 "backfillAdaptiveParallelismStrategy" | "backfill_adaptive_parallelism_strategy" => Ok(GeneratedField::BackfillAdaptiveParallelismStrategy),
15698 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
15699 "backfillOrder" | "backfill_order" => Ok(GeneratedField::BackfillOrder),
15700 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15701 }
15702 }
15703 }
15704 deserializer.deserialize_identifier(GeneratedVisitor)
15705 }
15706 }
15707 struct GeneratedVisitor;
15708 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15709 type Value = StreamFragmentGraph;
15710
15711 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15712 formatter.write_str("struct stream_plan.StreamFragmentGraph")
15713 }
15714
15715 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFragmentGraph, V::Error>
15716 where
15717 V: serde::de::MapAccess<'de>,
15718 {
15719 let mut fragments__ = None;
15720 let mut edges__ = None;
15721 let mut dependent_table_ids__ = None;
15722 let mut table_ids_cnt__ = None;
15723 let mut ctx__ = None;
15724 let mut parallelism__ = None;
15725 let mut backfill_parallelism__ = None;
15726 let mut adaptive_parallelism_strategy__ = None;
15727 let mut backfill_adaptive_parallelism_strategy__ = None;
15728 let mut max_parallelism__ = None;
15729 let mut backfill_order__ = None;
15730 while let Some(k) = map_.next_key()? {
15731 match k {
15732 GeneratedField::Fragments => {
15733 if fragments__.is_some() {
15734 return Err(serde::de::Error::duplicate_field("fragments"));
15735 }
15736 fragments__ = Some(
15737 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15738 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
15739 );
15740 }
15741 GeneratedField::Edges => {
15742 if edges__.is_some() {
15743 return Err(serde::de::Error::duplicate_field("edges"));
15744 }
15745 edges__ = Some(map_.next_value()?);
15746 }
15747 GeneratedField::DependentTableIds => {
15748 if dependent_table_ids__.is_some() {
15749 return Err(serde::de::Error::duplicate_field("dependentTableIds"));
15750 }
15751 dependent_table_ids__ =
15752 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15753 .into_iter().map(|x| x.0).collect())
15754 ;
15755 }
15756 GeneratedField::TableIdsCnt => {
15757 if table_ids_cnt__.is_some() {
15758 return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
15759 }
15760 table_ids_cnt__ =
15761 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15762 ;
15763 }
15764 GeneratedField::Ctx => {
15765 if ctx__.is_some() {
15766 return Err(serde::de::Error::duplicate_field("ctx"));
15767 }
15768 ctx__ = map_.next_value()?;
15769 }
15770 GeneratedField::Parallelism => {
15771 if parallelism__.is_some() {
15772 return Err(serde::de::Error::duplicate_field("parallelism"));
15773 }
15774 parallelism__ = map_.next_value()?;
15775 }
15776 GeneratedField::BackfillParallelism => {
15777 if backfill_parallelism__.is_some() {
15778 return Err(serde::de::Error::duplicate_field("backfillParallelism"));
15779 }
15780 backfill_parallelism__ = map_.next_value()?;
15781 }
15782 GeneratedField::AdaptiveParallelismStrategy => {
15783 if adaptive_parallelism_strategy__.is_some() {
15784 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
15785 }
15786 adaptive_parallelism_strategy__ = Some(map_.next_value()?);
15787 }
15788 GeneratedField::BackfillAdaptiveParallelismStrategy => {
15789 if backfill_adaptive_parallelism_strategy__.is_some() {
15790 return Err(serde::de::Error::duplicate_field("backfillAdaptiveParallelismStrategy"));
15791 }
15792 backfill_adaptive_parallelism_strategy__ = Some(map_.next_value()?);
15793 }
15794 GeneratedField::MaxParallelism => {
15795 if max_parallelism__.is_some() {
15796 return Err(serde::de::Error::duplicate_field("maxParallelism"));
15797 }
15798 max_parallelism__ =
15799 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15800 ;
15801 }
15802 GeneratedField::BackfillOrder => {
15803 if backfill_order__.is_some() {
15804 return Err(serde::de::Error::duplicate_field("backfillOrder"));
15805 }
15806 backfill_order__ = map_.next_value()?;
15807 }
15808 }
15809 }
15810 Ok(StreamFragmentGraph {
15811 fragments: fragments__.unwrap_or_default(),
15812 edges: edges__.unwrap_or_default(),
15813 dependent_table_ids: dependent_table_ids__.unwrap_or_default(),
15814 table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
15815 ctx: ctx__,
15816 parallelism: parallelism__,
15817 backfill_parallelism: backfill_parallelism__,
15818 adaptive_parallelism_strategy: adaptive_parallelism_strategy__.unwrap_or_default(),
15819 backfill_adaptive_parallelism_strategy: backfill_adaptive_parallelism_strategy__.unwrap_or_default(),
15820 max_parallelism: max_parallelism__.unwrap_or_default(),
15821 backfill_order: backfill_order__,
15822 })
15823 }
15824 }
15825 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph", FIELDS, GeneratedVisitor)
15826 }
15827}
15828impl serde::Serialize for stream_fragment_graph::Parallelism {
15829 #[allow(deprecated)]
15830 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15831 where
15832 S: serde::Serializer,
15833 {
15834 use serde::ser::SerializeStruct;
15835 let mut len = 0;
15836 if self.parallelism != 0 {
15837 len += 1;
15838 }
15839 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.Parallelism", len)?;
15840 if self.parallelism != 0 {
15841 #[allow(clippy::needless_borrow)]
15842 #[allow(clippy::needless_borrows_for_generic_args)]
15843 struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
15844 }
15845 struct_ser.end()
15846 }
15847}
15848impl<'de> serde::Deserialize<'de> for stream_fragment_graph::Parallelism {
15849 #[allow(deprecated)]
15850 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15851 where
15852 D: serde::Deserializer<'de>,
15853 {
15854 const FIELDS: &[&str] = &[
15855 "parallelism",
15856 ];
15857
15858 #[allow(clippy::enum_variant_names)]
15859 enum GeneratedField {
15860 Parallelism,
15861 }
15862 impl<'de> serde::Deserialize<'de> for GeneratedField {
15863 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15864 where
15865 D: serde::Deserializer<'de>,
15866 {
15867 struct GeneratedVisitor;
15868
15869 impl serde::de::Visitor<'_> for GeneratedVisitor {
15870 type Value = GeneratedField;
15871
15872 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15873 write!(formatter, "expected one of: {:?}", &FIELDS)
15874 }
15875
15876 #[allow(unused_variables)]
15877 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15878 where
15879 E: serde::de::Error,
15880 {
15881 match value {
15882 "parallelism" => Ok(GeneratedField::Parallelism),
15883 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15884 }
15885 }
15886 }
15887 deserializer.deserialize_identifier(GeneratedVisitor)
15888 }
15889 }
15890 struct GeneratedVisitor;
15891 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15892 type Value = stream_fragment_graph::Parallelism;
15893
15894 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15895 formatter.write_str("struct stream_plan.StreamFragmentGraph.Parallelism")
15896 }
15897
15898 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::Parallelism, V::Error>
15899 where
15900 V: serde::de::MapAccess<'de>,
15901 {
15902 let mut parallelism__ = None;
15903 while let Some(k) = map_.next_key()? {
15904 match k {
15905 GeneratedField::Parallelism => {
15906 if parallelism__.is_some() {
15907 return Err(serde::de::Error::duplicate_field("parallelism"));
15908 }
15909 parallelism__ =
15910 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15911 ;
15912 }
15913 }
15914 }
15915 Ok(stream_fragment_graph::Parallelism {
15916 parallelism: parallelism__.unwrap_or_default(),
15917 })
15918 }
15919 }
15920 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.Parallelism", FIELDS, GeneratedVisitor)
15921 }
15922}
15923impl serde::Serialize for stream_fragment_graph::StreamFragment {
15924 #[allow(deprecated)]
15925 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15926 where
15927 S: serde::Serializer,
15928 {
15929 use serde::ser::SerializeStruct;
15930 let mut len = 0;
15931 if self.fragment_id != 0 {
15932 len += 1;
15933 }
15934 if self.node.is_some() {
15935 len += 1;
15936 }
15937 if self.fragment_type_mask != 0 {
15938 len += 1;
15939 }
15940 if self.requires_singleton {
15941 len += 1;
15942 }
15943 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", len)?;
15944 if self.fragment_id != 0 {
15945 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
15946 }
15947 if let Some(v) = self.node.as_ref() {
15948 struct_ser.serialize_field("node", v)?;
15949 }
15950 if self.fragment_type_mask != 0 {
15951 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
15952 }
15953 if self.requires_singleton {
15954 struct_ser.serialize_field("requiresSingleton", &self.requires_singleton)?;
15955 }
15956 struct_ser.end()
15957 }
15958}
15959impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragment {
15960 #[allow(deprecated)]
15961 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15962 where
15963 D: serde::Deserializer<'de>,
15964 {
15965 const FIELDS: &[&str] = &[
15966 "fragment_id",
15967 "fragmentId",
15968 "node",
15969 "fragment_type_mask",
15970 "fragmentTypeMask",
15971 "requires_singleton",
15972 "requiresSingleton",
15973 ];
15974
15975 #[allow(clippy::enum_variant_names)]
15976 enum GeneratedField {
15977 FragmentId,
15978 Node,
15979 FragmentTypeMask,
15980 RequiresSingleton,
15981 }
15982 impl<'de> serde::Deserialize<'de> for GeneratedField {
15983 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15984 where
15985 D: serde::Deserializer<'de>,
15986 {
15987 struct GeneratedVisitor;
15988
15989 impl serde::de::Visitor<'_> for GeneratedVisitor {
15990 type Value = GeneratedField;
15991
15992 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15993 write!(formatter, "expected one of: {:?}", &FIELDS)
15994 }
15995
15996 #[allow(unused_variables)]
15997 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15998 where
15999 E: serde::de::Error,
16000 {
16001 match value {
16002 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
16003 "node" => Ok(GeneratedField::Node),
16004 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
16005 "requiresSingleton" | "requires_singleton" => Ok(GeneratedField::RequiresSingleton),
16006 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16007 }
16008 }
16009 }
16010 deserializer.deserialize_identifier(GeneratedVisitor)
16011 }
16012 }
16013 struct GeneratedVisitor;
16014 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16015 type Value = stream_fragment_graph::StreamFragment;
16016
16017 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16018 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragment")
16019 }
16020
16021 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragment, V::Error>
16022 where
16023 V: serde::de::MapAccess<'de>,
16024 {
16025 let mut fragment_id__ = None;
16026 let mut node__ = None;
16027 let mut fragment_type_mask__ = None;
16028 let mut requires_singleton__ = None;
16029 while let Some(k) = map_.next_key()? {
16030 match k {
16031 GeneratedField::FragmentId => {
16032 if fragment_id__.is_some() {
16033 return Err(serde::de::Error::duplicate_field("fragmentId"));
16034 }
16035 fragment_id__ =
16036 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16037 ;
16038 }
16039 GeneratedField::Node => {
16040 if node__.is_some() {
16041 return Err(serde::de::Error::duplicate_field("node"));
16042 }
16043 node__ = map_.next_value()?;
16044 }
16045 GeneratedField::FragmentTypeMask => {
16046 if fragment_type_mask__.is_some() {
16047 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
16048 }
16049 fragment_type_mask__ =
16050 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16051 ;
16052 }
16053 GeneratedField::RequiresSingleton => {
16054 if requires_singleton__.is_some() {
16055 return Err(serde::de::Error::duplicate_field("requiresSingleton"));
16056 }
16057 requires_singleton__ = Some(map_.next_value()?);
16058 }
16059 }
16060 }
16061 Ok(stream_fragment_graph::StreamFragment {
16062 fragment_id: fragment_id__.unwrap_or_default(),
16063 node: node__,
16064 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
16065 requires_singleton: requires_singleton__.unwrap_or_default(),
16066 })
16067 }
16068 }
16069 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", FIELDS, GeneratedVisitor)
16070 }
16071}
16072impl serde::Serialize for stream_fragment_graph::StreamFragmentEdge {
16073 #[allow(deprecated)]
16074 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16075 where
16076 S: serde::Serializer,
16077 {
16078 use serde::ser::SerializeStruct;
16079 let mut len = 0;
16080 if self.dispatch_strategy.is_some() {
16081 len += 1;
16082 }
16083 if self.link_id != 0 {
16084 len += 1;
16085 }
16086 if self.upstream_id != 0 {
16087 len += 1;
16088 }
16089 if self.downstream_id != 0 {
16090 len += 1;
16091 }
16092 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", len)?;
16093 if let Some(v) = self.dispatch_strategy.as_ref() {
16094 struct_ser.serialize_field("dispatchStrategy", v)?;
16095 }
16096 if self.link_id != 0 {
16097 #[allow(clippy::needless_borrow)]
16098 #[allow(clippy::needless_borrows_for_generic_args)]
16099 struct_ser.serialize_field("linkId", ToString::to_string(&self.link_id).as_str())?;
16100 }
16101 if self.upstream_id != 0 {
16102 struct_ser.serialize_field("upstreamId", &self.upstream_id)?;
16103 }
16104 if self.downstream_id != 0 {
16105 struct_ser.serialize_field("downstreamId", &self.downstream_id)?;
16106 }
16107 struct_ser.end()
16108 }
16109}
16110impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragmentEdge {
16111 #[allow(deprecated)]
16112 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16113 where
16114 D: serde::Deserializer<'de>,
16115 {
16116 const FIELDS: &[&str] = &[
16117 "dispatch_strategy",
16118 "dispatchStrategy",
16119 "link_id",
16120 "linkId",
16121 "upstream_id",
16122 "upstreamId",
16123 "downstream_id",
16124 "downstreamId",
16125 ];
16126
16127 #[allow(clippy::enum_variant_names)]
16128 enum GeneratedField {
16129 DispatchStrategy,
16130 LinkId,
16131 UpstreamId,
16132 DownstreamId,
16133 }
16134 impl<'de> serde::Deserialize<'de> for GeneratedField {
16135 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16136 where
16137 D: serde::Deserializer<'de>,
16138 {
16139 struct GeneratedVisitor;
16140
16141 impl serde::de::Visitor<'_> for GeneratedVisitor {
16142 type Value = GeneratedField;
16143
16144 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16145 write!(formatter, "expected one of: {:?}", &FIELDS)
16146 }
16147
16148 #[allow(unused_variables)]
16149 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16150 where
16151 E: serde::de::Error,
16152 {
16153 match value {
16154 "dispatchStrategy" | "dispatch_strategy" => Ok(GeneratedField::DispatchStrategy),
16155 "linkId" | "link_id" => Ok(GeneratedField::LinkId),
16156 "upstreamId" | "upstream_id" => Ok(GeneratedField::UpstreamId),
16157 "downstreamId" | "downstream_id" => Ok(GeneratedField::DownstreamId),
16158 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16159 }
16160 }
16161 }
16162 deserializer.deserialize_identifier(GeneratedVisitor)
16163 }
16164 }
16165 struct GeneratedVisitor;
16166 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16167 type Value = stream_fragment_graph::StreamFragmentEdge;
16168
16169 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16170 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragmentEdge")
16171 }
16172
16173 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragmentEdge, V::Error>
16174 where
16175 V: serde::de::MapAccess<'de>,
16176 {
16177 let mut dispatch_strategy__ = None;
16178 let mut link_id__ = None;
16179 let mut upstream_id__ = None;
16180 let mut downstream_id__ = None;
16181 while let Some(k) = map_.next_key()? {
16182 match k {
16183 GeneratedField::DispatchStrategy => {
16184 if dispatch_strategy__.is_some() {
16185 return Err(serde::de::Error::duplicate_field("dispatchStrategy"));
16186 }
16187 dispatch_strategy__ = map_.next_value()?;
16188 }
16189 GeneratedField::LinkId => {
16190 if link_id__.is_some() {
16191 return Err(serde::de::Error::duplicate_field("linkId"));
16192 }
16193 link_id__ =
16194 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16195 ;
16196 }
16197 GeneratedField::UpstreamId => {
16198 if upstream_id__.is_some() {
16199 return Err(serde::de::Error::duplicate_field("upstreamId"));
16200 }
16201 upstream_id__ =
16202 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16203 ;
16204 }
16205 GeneratedField::DownstreamId => {
16206 if downstream_id__.is_some() {
16207 return Err(serde::de::Error::duplicate_field("downstreamId"));
16208 }
16209 downstream_id__ =
16210 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16211 ;
16212 }
16213 }
16214 }
16215 Ok(stream_fragment_graph::StreamFragmentEdge {
16216 dispatch_strategy: dispatch_strategy__,
16217 link_id: link_id__.unwrap_or_default(),
16218 upstream_id: upstream_id__.unwrap_or_default(),
16219 downstream_id: downstream_id__.unwrap_or_default(),
16220 })
16221 }
16222 }
16223 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", FIELDS, GeneratedVisitor)
16224 }
16225}
16226impl serde::Serialize for StreamFsFetch {
16227 #[allow(deprecated)]
16228 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16229 where
16230 S: serde::Serializer,
16231 {
16232 use serde::ser::SerializeStruct;
16233 let mut len = 0;
16234 if self.source_id != 0 {
16235 len += 1;
16236 }
16237 if self.state_table.is_some() {
16238 len += 1;
16239 }
16240 if self.row_id_index.is_some() {
16241 len += 1;
16242 }
16243 if !self.columns.is_empty() {
16244 len += 1;
16245 }
16246 if !self.with_properties.is_empty() {
16247 len += 1;
16248 }
16249 if self.info.is_some() {
16250 len += 1;
16251 }
16252 if !self.source_name.is_empty() {
16253 len += 1;
16254 }
16255 if self.rate_limit.is_some() {
16256 len += 1;
16257 }
16258 if !self.secret_refs.is_empty() {
16259 len += 1;
16260 }
16261 if self.refresh_mode.is_some() {
16262 len += 1;
16263 }
16264 if self.associated_table_id.is_some() {
16265 len += 1;
16266 }
16267 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetch", len)?;
16268 if self.source_id != 0 {
16269 struct_ser.serialize_field("sourceId", &self.source_id)?;
16270 }
16271 if let Some(v) = self.state_table.as_ref() {
16272 struct_ser.serialize_field("stateTable", v)?;
16273 }
16274 if let Some(v) = self.row_id_index.as_ref() {
16275 struct_ser.serialize_field("rowIdIndex", v)?;
16276 }
16277 if !self.columns.is_empty() {
16278 struct_ser.serialize_field("columns", &self.columns)?;
16279 }
16280 if !self.with_properties.is_empty() {
16281 struct_ser.serialize_field("withProperties", &self.with_properties)?;
16282 }
16283 if let Some(v) = self.info.as_ref() {
16284 struct_ser.serialize_field("info", v)?;
16285 }
16286 if !self.source_name.is_empty() {
16287 struct_ser.serialize_field("sourceName", &self.source_name)?;
16288 }
16289 if let Some(v) = self.rate_limit.as_ref() {
16290 struct_ser.serialize_field("rateLimit", v)?;
16291 }
16292 if !self.secret_refs.is_empty() {
16293 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
16294 }
16295 if let Some(v) = self.refresh_mode.as_ref() {
16296 struct_ser.serialize_field("refreshMode", v)?;
16297 }
16298 if let Some(v) = self.associated_table_id.as_ref() {
16299 struct_ser.serialize_field("associatedTableId", v)?;
16300 }
16301 struct_ser.end()
16302 }
16303}
16304impl<'de> serde::Deserialize<'de> for StreamFsFetch {
16305 #[allow(deprecated)]
16306 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16307 where
16308 D: serde::Deserializer<'de>,
16309 {
16310 const FIELDS: &[&str] = &[
16311 "source_id",
16312 "sourceId",
16313 "state_table",
16314 "stateTable",
16315 "row_id_index",
16316 "rowIdIndex",
16317 "columns",
16318 "with_properties",
16319 "withProperties",
16320 "info",
16321 "source_name",
16322 "sourceName",
16323 "rate_limit",
16324 "rateLimit",
16325 "secret_refs",
16326 "secretRefs",
16327 "refresh_mode",
16328 "refreshMode",
16329 "associated_table_id",
16330 "associatedTableId",
16331 ];
16332
16333 #[allow(clippy::enum_variant_names)]
16334 enum GeneratedField {
16335 SourceId,
16336 StateTable,
16337 RowIdIndex,
16338 Columns,
16339 WithProperties,
16340 Info,
16341 SourceName,
16342 RateLimit,
16343 SecretRefs,
16344 RefreshMode,
16345 AssociatedTableId,
16346 }
16347 impl<'de> serde::Deserialize<'de> for GeneratedField {
16348 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16349 where
16350 D: serde::Deserializer<'de>,
16351 {
16352 struct GeneratedVisitor;
16353
16354 impl serde::de::Visitor<'_> for GeneratedVisitor {
16355 type Value = GeneratedField;
16356
16357 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16358 write!(formatter, "expected one of: {:?}", &FIELDS)
16359 }
16360
16361 #[allow(unused_variables)]
16362 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16363 where
16364 E: serde::de::Error,
16365 {
16366 match value {
16367 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
16368 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
16369 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
16370 "columns" => Ok(GeneratedField::Columns),
16371 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
16372 "info" => Ok(GeneratedField::Info),
16373 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
16374 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
16375 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
16376 "refreshMode" | "refresh_mode" => Ok(GeneratedField::RefreshMode),
16377 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
16378 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16379 }
16380 }
16381 }
16382 deserializer.deserialize_identifier(GeneratedVisitor)
16383 }
16384 }
16385 struct GeneratedVisitor;
16386 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16387 type Value = StreamFsFetch;
16388
16389 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16390 formatter.write_str("struct stream_plan.StreamFsFetch")
16391 }
16392
16393 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetch, V::Error>
16394 where
16395 V: serde::de::MapAccess<'de>,
16396 {
16397 let mut source_id__ = None;
16398 let mut state_table__ = None;
16399 let mut row_id_index__ = None;
16400 let mut columns__ = None;
16401 let mut with_properties__ = None;
16402 let mut info__ = None;
16403 let mut source_name__ = None;
16404 let mut rate_limit__ = None;
16405 let mut secret_refs__ = None;
16406 let mut refresh_mode__ = None;
16407 let mut associated_table_id__ = None;
16408 while let Some(k) = map_.next_key()? {
16409 match k {
16410 GeneratedField::SourceId => {
16411 if source_id__.is_some() {
16412 return Err(serde::de::Error::duplicate_field("sourceId"));
16413 }
16414 source_id__ =
16415 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16416 ;
16417 }
16418 GeneratedField::StateTable => {
16419 if state_table__.is_some() {
16420 return Err(serde::de::Error::duplicate_field("stateTable"));
16421 }
16422 state_table__ = map_.next_value()?;
16423 }
16424 GeneratedField::RowIdIndex => {
16425 if row_id_index__.is_some() {
16426 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
16427 }
16428 row_id_index__ =
16429 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16430 ;
16431 }
16432 GeneratedField::Columns => {
16433 if columns__.is_some() {
16434 return Err(serde::de::Error::duplicate_field("columns"));
16435 }
16436 columns__ = Some(map_.next_value()?);
16437 }
16438 GeneratedField::WithProperties => {
16439 if with_properties__.is_some() {
16440 return Err(serde::de::Error::duplicate_field("withProperties"));
16441 }
16442 with_properties__ = Some(
16443 map_.next_value::<std::collections::BTreeMap<_, _>>()?
16444 );
16445 }
16446 GeneratedField::Info => {
16447 if info__.is_some() {
16448 return Err(serde::de::Error::duplicate_field("info"));
16449 }
16450 info__ = map_.next_value()?;
16451 }
16452 GeneratedField::SourceName => {
16453 if source_name__.is_some() {
16454 return Err(serde::de::Error::duplicate_field("sourceName"));
16455 }
16456 source_name__ = Some(map_.next_value()?);
16457 }
16458 GeneratedField::RateLimit => {
16459 if rate_limit__.is_some() {
16460 return Err(serde::de::Error::duplicate_field("rateLimit"));
16461 }
16462 rate_limit__ =
16463 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16464 ;
16465 }
16466 GeneratedField::SecretRefs => {
16467 if secret_refs__.is_some() {
16468 return Err(serde::de::Error::duplicate_field("secretRefs"));
16469 }
16470 secret_refs__ = Some(
16471 map_.next_value::<std::collections::BTreeMap<_, _>>()?
16472 );
16473 }
16474 GeneratedField::RefreshMode => {
16475 if refresh_mode__.is_some() {
16476 return Err(serde::de::Error::duplicate_field("refreshMode"));
16477 }
16478 refresh_mode__ = map_.next_value()?;
16479 }
16480 GeneratedField::AssociatedTableId => {
16481 if associated_table_id__.is_some() {
16482 return Err(serde::de::Error::duplicate_field("associatedTableId"));
16483 }
16484 associated_table_id__ =
16485 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16486 ;
16487 }
16488 }
16489 }
16490 Ok(StreamFsFetch {
16491 source_id: source_id__.unwrap_or_default(),
16492 state_table: state_table__,
16493 row_id_index: row_id_index__,
16494 columns: columns__.unwrap_or_default(),
16495 with_properties: with_properties__.unwrap_or_default(),
16496 info: info__,
16497 source_name: source_name__.unwrap_or_default(),
16498 rate_limit: rate_limit__,
16499 secret_refs: secret_refs__.unwrap_or_default(),
16500 refresh_mode: refresh_mode__,
16501 associated_table_id: associated_table_id__,
16502 })
16503 }
16504 }
16505 deserializer.deserialize_struct("stream_plan.StreamFsFetch", FIELDS, GeneratedVisitor)
16506 }
16507}
16508impl serde::Serialize for StreamFsFetchNode {
16509 #[allow(deprecated)]
16510 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16511 where
16512 S: serde::Serializer,
16513 {
16514 use serde::ser::SerializeStruct;
16515 let mut len = 0;
16516 if self.node_inner.is_some() {
16517 len += 1;
16518 }
16519 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetchNode", len)?;
16520 if let Some(v) = self.node_inner.as_ref() {
16521 struct_ser.serialize_field("nodeInner", v)?;
16522 }
16523 struct_ser.end()
16524 }
16525}
16526impl<'de> serde::Deserialize<'de> for StreamFsFetchNode {
16527 #[allow(deprecated)]
16528 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16529 where
16530 D: serde::Deserializer<'de>,
16531 {
16532 const FIELDS: &[&str] = &[
16533 "node_inner",
16534 "nodeInner",
16535 ];
16536
16537 #[allow(clippy::enum_variant_names)]
16538 enum GeneratedField {
16539 NodeInner,
16540 }
16541 impl<'de> serde::Deserialize<'de> for GeneratedField {
16542 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16543 where
16544 D: serde::Deserializer<'de>,
16545 {
16546 struct GeneratedVisitor;
16547
16548 impl serde::de::Visitor<'_> for GeneratedVisitor {
16549 type Value = GeneratedField;
16550
16551 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16552 write!(formatter, "expected one of: {:?}", &FIELDS)
16553 }
16554
16555 #[allow(unused_variables)]
16556 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16557 where
16558 E: serde::de::Error,
16559 {
16560 match value {
16561 "nodeInner" | "node_inner" => Ok(GeneratedField::NodeInner),
16562 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16563 }
16564 }
16565 }
16566 deserializer.deserialize_identifier(GeneratedVisitor)
16567 }
16568 }
16569 struct GeneratedVisitor;
16570 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16571 type Value = StreamFsFetchNode;
16572
16573 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16574 formatter.write_str("struct stream_plan.StreamFsFetchNode")
16575 }
16576
16577 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetchNode, V::Error>
16578 where
16579 V: serde::de::MapAccess<'de>,
16580 {
16581 let mut node_inner__ = None;
16582 while let Some(k) = map_.next_key()? {
16583 match k {
16584 GeneratedField::NodeInner => {
16585 if node_inner__.is_some() {
16586 return Err(serde::de::Error::duplicate_field("nodeInner"));
16587 }
16588 node_inner__ = map_.next_value()?;
16589 }
16590 }
16591 }
16592 Ok(StreamFsFetchNode {
16593 node_inner: node_inner__,
16594 })
16595 }
16596 }
16597 deserializer.deserialize_struct("stream_plan.StreamFsFetchNode", FIELDS, GeneratedVisitor)
16598 }
16599}
16600impl serde::Serialize for StreamMessage {
16601 #[allow(deprecated)]
16602 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16603 where
16604 S: serde::Serializer,
16605 {
16606 use serde::ser::SerializeStruct;
16607 let mut len = 0;
16608 if self.stream_message.is_some() {
16609 len += 1;
16610 }
16611 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessage", len)?;
16612 if let Some(v) = self.stream_message.as_ref() {
16613 match v {
16614 stream_message::StreamMessage::StreamChunk(v) => {
16615 struct_ser.serialize_field("streamChunk", v)?;
16616 }
16617 stream_message::StreamMessage::Barrier(v) => {
16618 struct_ser.serialize_field("barrier", v)?;
16619 }
16620 stream_message::StreamMessage::Watermark(v) => {
16621 struct_ser.serialize_field("watermark", v)?;
16622 }
16623 }
16624 }
16625 struct_ser.end()
16626 }
16627}
16628impl<'de> serde::Deserialize<'de> for StreamMessage {
16629 #[allow(deprecated)]
16630 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16631 where
16632 D: serde::Deserializer<'de>,
16633 {
16634 const FIELDS: &[&str] = &[
16635 "stream_chunk",
16636 "streamChunk",
16637 "barrier",
16638 "watermark",
16639 ];
16640
16641 #[allow(clippy::enum_variant_names)]
16642 enum GeneratedField {
16643 StreamChunk,
16644 Barrier,
16645 Watermark,
16646 }
16647 impl<'de> serde::Deserialize<'de> for GeneratedField {
16648 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16649 where
16650 D: serde::Deserializer<'de>,
16651 {
16652 struct GeneratedVisitor;
16653
16654 impl serde::de::Visitor<'_> for GeneratedVisitor {
16655 type Value = GeneratedField;
16656
16657 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16658 write!(formatter, "expected one of: {:?}", &FIELDS)
16659 }
16660
16661 #[allow(unused_variables)]
16662 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16663 where
16664 E: serde::de::Error,
16665 {
16666 match value {
16667 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
16668 "barrier" => Ok(GeneratedField::Barrier),
16669 "watermark" => Ok(GeneratedField::Watermark),
16670 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16671 }
16672 }
16673 }
16674 deserializer.deserialize_identifier(GeneratedVisitor)
16675 }
16676 }
16677 struct GeneratedVisitor;
16678 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16679 type Value = StreamMessage;
16680
16681 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16682 formatter.write_str("struct stream_plan.StreamMessage")
16683 }
16684
16685 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessage, V::Error>
16686 where
16687 V: serde::de::MapAccess<'de>,
16688 {
16689 let mut stream_message__ = None;
16690 while let Some(k) = map_.next_key()? {
16691 match k {
16692 GeneratedField::StreamChunk => {
16693 if stream_message__.is_some() {
16694 return Err(serde::de::Error::duplicate_field("streamChunk"));
16695 }
16696 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::StreamChunk)
16697;
16698 }
16699 GeneratedField::Barrier => {
16700 if stream_message__.is_some() {
16701 return Err(serde::de::Error::duplicate_field("barrier"));
16702 }
16703 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Barrier)
16704;
16705 }
16706 GeneratedField::Watermark => {
16707 if stream_message__.is_some() {
16708 return Err(serde::de::Error::duplicate_field("watermark"));
16709 }
16710 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Watermark)
16711;
16712 }
16713 }
16714 }
16715 Ok(StreamMessage {
16716 stream_message: stream_message__,
16717 })
16718 }
16719 }
16720 deserializer.deserialize_struct("stream_plan.StreamMessage", FIELDS, GeneratedVisitor)
16721 }
16722}
16723impl serde::Serialize for StreamMessageBatch {
16724 #[allow(deprecated)]
16725 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16726 where
16727 S: serde::Serializer,
16728 {
16729 use serde::ser::SerializeStruct;
16730 let mut len = 0;
16731 if self.stream_message_batch.is_some() {
16732 len += 1;
16733 }
16734 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch", len)?;
16735 if let Some(v) = self.stream_message_batch.as_ref() {
16736 match v {
16737 stream_message_batch::StreamMessageBatch::StreamChunk(v) => {
16738 struct_ser.serialize_field("streamChunk", v)?;
16739 }
16740 stream_message_batch::StreamMessageBatch::BarrierBatch(v) => {
16741 struct_ser.serialize_field("barrierBatch", v)?;
16742 }
16743 stream_message_batch::StreamMessageBatch::Watermark(v) => {
16744 struct_ser.serialize_field("watermark", v)?;
16745 }
16746 }
16747 }
16748 struct_ser.end()
16749 }
16750}
16751impl<'de> serde::Deserialize<'de> for StreamMessageBatch {
16752 #[allow(deprecated)]
16753 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16754 where
16755 D: serde::Deserializer<'de>,
16756 {
16757 const FIELDS: &[&str] = &[
16758 "stream_chunk",
16759 "streamChunk",
16760 "barrier_batch",
16761 "barrierBatch",
16762 "watermark",
16763 ];
16764
16765 #[allow(clippy::enum_variant_names)]
16766 enum GeneratedField {
16767 StreamChunk,
16768 BarrierBatch,
16769 Watermark,
16770 }
16771 impl<'de> serde::Deserialize<'de> for GeneratedField {
16772 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16773 where
16774 D: serde::Deserializer<'de>,
16775 {
16776 struct GeneratedVisitor;
16777
16778 impl serde::de::Visitor<'_> for GeneratedVisitor {
16779 type Value = GeneratedField;
16780
16781 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16782 write!(formatter, "expected one of: {:?}", &FIELDS)
16783 }
16784
16785 #[allow(unused_variables)]
16786 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16787 where
16788 E: serde::de::Error,
16789 {
16790 match value {
16791 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
16792 "barrierBatch" | "barrier_batch" => Ok(GeneratedField::BarrierBatch),
16793 "watermark" => Ok(GeneratedField::Watermark),
16794 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16795 }
16796 }
16797 }
16798 deserializer.deserialize_identifier(GeneratedVisitor)
16799 }
16800 }
16801 struct GeneratedVisitor;
16802 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16803 type Value = StreamMessageBatch;
16804
16805 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16806 formatter.write_str("struct stream_plan.StreamMessageBatch")
16807 }
16808
16809 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessageBatch, V::Error>
16810 where
16811 V: serde::de::MapAccess<'de>,
16812 {
16813 let mut stream_message_batch__ = None;
16814 while let Some(k) = map_.next_key()? {
16815 match k {
16816 GeneratedField::StreamChunk => {
16817 if stream_message_batch__.is_some() {
16818 return Err(serde::de::Error::duplicate_field("streamChunk"));
16819 }
16820 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::StreamChunk)
16821;
16822 }
16823 GeneratedField::BarrierBatch => {
16824 if stream_message_batch__.is_some() {
16825 return Err(serde::de::Error::duplicate_field("barrierBatch"));
16826 }
16827 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::BarrierBatch)
16828;
16829 }
16830 GeneratedField::Watermark => {
16831 if stream_message_batch__.is_some() {
16832 return Err(serde::de::Error::duplicate_field("watermark"));
16833 }
16834 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::Watermark)
16835;
16836 }
16837 }
16838 }
16839 Ok(StreamMessageBatch {
16840 stream_message_batch: stream_message_batch__,
16841 })
16842 }
16843 }
16844 deserializer.deserialize_struct("stream_plan.StreamMessageBatch", FIELDS, GeneratedVisitor)
16845 }
16846}
16847impl serde::Serialize for stream_message_batch::BarrierBatch {
16848 #[allow(deprecated)]
16849 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16850 where
16851 S: serde::Serializer,
16852 {
16853 use serde::ser::SerializeStruct;
16854 let mut len = 0;
16855 if !self.barriers.is_empty() {
16856 len += 1;
16857 }
16858 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", len)?;
16859 if !self.barriers.is_empty() {
16860 struct_ser.serialize_field("barriers", &self.barriers)?;
16861 }
16862 struct_ser.end()
16863 }
16864}
16865impl<'de> serde::Deserialize<'de> for stream_message_batch::BarrierBatch {
16866 #[allow(deprecated)]
16867 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16868 where
16869 D: serde::Deserializer<'de>,
16870 {
16871 const FIELDS: &[&str] = &[
16872 "barriers",
16873 ];
16874
16875 #[allow(clippy::enum_variant_names)]
16876 enum GeneratedField {
16877 Barriers,
16878 }
16879 impl<'de> serde::Deserialize<'de> for GeneratedField {
16880 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16881 where
16882 D: serde::Deserializer<'de>,
16883 {
16884 struct GeneratedVisitor;
16885
16886 impl serde::de::Visitor<'_> for GeneratedVisitor {
16887 type Value = GeneratedField;
16888
16889 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16890 write!(formatter, "expected one of: {:?}", &FIELDS)
16891 }
16892
16893 #[allow(unused_variables)]
16894 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16895 where
16896 E: serde::de::Error,
16897 {
16898 match value {
16899 "barriers" => Ok(GeneratedField::Barriers),
16900 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16901 }
16902 }
16903 }
16904 deserializer.deserialize_identifier(GeneratedVisitor)
16905 }
16906 }
16907 struct GeneratedVisitor;
16908 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16909 type Value = stream_message_batch::BarrierBatch;
16910
16911 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16912 formatter.write_str("struct stream_plan.StreamMessageBatch.BarrierBatch")
16913 }
16914
16915 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_message_batch::BarrierBatch, V::Error>
16916 where
16917 V: serde::de::MapAccess<'de>,
16918 {
16919 let mut barriers__ = None;
16920 while let Some(k) = map_.next_key()? {
16921 match k {
16922 GeneratedField::Barriers => {
16923 if barriers__.is_some() {
16924 return Err(serde::de::Error::duplicate_field("barriers"));
16925 }
16926 barriers__ = Some(map_.next_value()?);
16927 }
16928 }
16929 }
16930 Ok(stream_message_batch::BarrierBatch {
16931 barriers: barriers__.unwrap_or_default(),
16932 })
16933 }
16934 }
16935 deserializer.deserialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", FIELDS, GeneratedVisitor)
16936 }
16937}
16938impl serde::Serialize for StreamNode {
16939 #[allow(deprecated)]
16940 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16941 where
16942 S: serde::Serializer,
16943 {
16944 use serde::ser::SerializeStruct;
16945 let mut len = 0;
16946 if self.operator_id != 0 {
16947 len += 1;
16948 }
16949 if !self.input.is_empty() {
16950 len += 1;
16951 }
16952 if !self.stream_key.is_empty() {
16953 len += 1;
16954 }
16955 if self.stream_kind != 0 {
16956 len += 1;
16957 }
16958 if !self.identity.is_empty() {
16959 len += 1;
16960 }
16961 if !self.fields.is_empty() {
16962 len += 1;
16963 }
16964 if self.node_body.is_some() {
16965 len += 1;
16966 }
16967 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamNode", len)?;
16968 if self.operator_id != 0 {
16969 #[allow(clippy::needless_borrow)]
16970 #[allow(clippy::needless_borrows_for_generic_args)]
16971 struct_ser.serialize_field("operatorId", ToString::to_string(&self.operator_id).as_str())?;
16972 }
16973 if !self.input.is_empty() {
16974 struct_ser.serialize_field("input", &self.input)?;
16975 }
16976 if !self.stream_key.is_empty() {
16977 struct_ser.serialize_field("streamKey", &self.stream_key)?;
16978 }
16979 if self.stream_kind != 0 {
16980 let v = stream_node::StreamKind::try_from(self.stream_kind)
16981 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_kind)))?;
16982 struct_ser.serialize_field("streamKind", &v)?;
16983 }
16984 if !self.identity.is_empty() {
16985 struct_ser.serialize_field("identity", &self.identity)?;
16986 }
16987 if !self.fields.is_empty() {
16988 struct_ser.serialize_field("fields", &self.fields)?;
16989 }
16990 if let Some(v) = self.node_body.as_ref() {
16991 match v {
16992 stream_node::NodeBody::Source(v) => {
16993 struct_ser.serialize_field("source", v)?;
16994 }
16995 stream_node::NodeBody::Project(v) => {
16996 struct_ser.serialize_field("project", v)?;
16997 }
16998 stream_node::NodeBody::Filter(v) => {
16999 struct_ser.serialize_field("filter", v)?;
17000 }
17001 stream_node::NodeBody::Materialize(v) => {
17002 struct_ser.serialize_field("materialize", v)?;
17003 }
17004 stream_node::NodeBody::StatelessSimpleAgg(v) => {
17005 struct_ser.serialize_field("statelessSimpleAgg", v)?;
17006 }
17007 stream_node::NodeBody::SimpleAgg(v) => {
17008 struct_ser.serialize_field("simpleAgg", v)?;
17009 }
17010 stream_node::NodeBody::HashAgg(v) => {
17011 struct_ser.serialize_field("hashAgg", v)?;
17012 }
17013 stream_node::NodeBody::AppendOnlyTopN(v) => {
17014 struct_ser.serialize_field("appendOnlyTopN", v)?;
17015 }
17016 stream_node::NodeBody::HashJoin(v) => {
17017 struct_ser.serialize_field("hashJoin", v)?;
17018 }
17019 stream_node::NodeBody::TopN(v) => {
17020 struct_ser.serialize_field("topN", v)?;
17021 }
17022 stream_node::NodeBody::HopWindow(v) => {
17023 struct_ser.serialize_field("hopWindow", v)?;
17024 }
17025 stream_node::NodeBody::Merge(v) => {
17026 struct_ser.serialize_field("merge", v)?;
17027 }
17028 stream_node::NodeBody::Exchange(v) => {
17029 struct_ser.serialize_field("exchange", v)?;
17030 }
17031 stream_node::NodeBody::StreamScan(v) => {
17032 struct_ser.serialize_field("streamScan", v)?;
17033 }
17034 stream_node::NodeBody::BatchPlan(v) => {
17035 struct_ser.serialize_field("batchPlan", v)?;
17036 }
17037 stream_node::NodeBody::Lookup(v) => {
17038 struct_ser.serialize_field("lookup", v)?;
17039 }
17040 stream_node::NodeBody::Arrange(v) => {
17041 struct_ser.serialize_field("arrange", v)?;
17042 }
17043 stream_node::NodeBody::LookupUnion(v) => {
17044 struct_ser.serialize_field("lookupUnion", v)?;
17045 }
17046 stream_node::NodeBody::Union(v) => {
17047 struct_ser.serialize_field("union", v)?;
17048 }
17049 stream_node::NodeBody::DeltaIndexJoin(v) => {
17050 struct_ser.serialize_field("deltaIndexJoin", v)?;
17051 }
17052 stream_node::NodeBody::Sink(v) => {
17053 struct_ser.serialize_field("sink", v)?;
17054 }
17055 stream_node::NodeBody::Expand(v) => {
17056 struct_ser.serialize_field("expand", v)?;
17057 }
17058 stream_node::NodeBody::DynamicFilter(v) => {
17059 struct_ser.serialize_field("dynamicFilter", v)?;
17060 }
17061 stream_node::NodeBody::ProjectSet(v) => {
17062 struct_ser.serialize_field("projectSet", v)?;
17063 }
17064 stream_node::NodeBody::GroupTopN(v) => {
17065 struct_ser.serialize_field("groupTopN", v)?;
17066 }
17067 stream_node::NodeBody::Sort(v) => {
17068 struct_ser.serialize_field("sort", v)?;
17069 }
17070 stream_node::NodeBody::WatermarkFilter(v) => {
17071 struct_ser.serialize_field("watermarkFilter", v)?;
17072 }
17073 stream_node::NodeBody::Dml(v) => {
17074 struct_ser.serialize_field("dml", v)?;
17075 }
17076 stream_node::NodeBody::RowIdGen(v) => {
17077 struct_ser.serialize_field("rowIdGen", v)?;
17078 }
17079 stream_node::NodeBody::Now(v) => {
17080 struct_ser.serialize_field("now", v)?;
17081 }
17082 stream_node::NodeBody::AppendOnlyGroupTopN(v) => {
17083 struct_ser.serialize_field("appendOnlyGroupTopN", v)?;
17084 }
17085 stream_node::NodeBody::TemporalJoin(v) => {
17086 struct_ser.serialize_field("temporalJoin", v)?;
17087 }
17088 stream_node::NodeBody::BarrierRecv(v) => {
17089 struct_ser.serialize_field("barrierRecv", v)?;
17090 }
17091 stream_node::NodeBody::Values(v) => {
17092 struct_ser.serialize_field("values", v)?;
17093 }
17094 stream_node::NodeBody::AppendOnlyDedup(v) => {
17095 struct_ser.serialize_field("appendOnlyDedup", v)?;
17096 }
17097 stream_node::NodeBody::NoOp(v) => {
17098 struct_ser.serialize_field("noOp", v)?;
17099 }
17100 stream_node::NodeBody::EowcOverWindow(v) => {
17101 struct_ser.serialize_field("eowcOverWindow", v)?;
17102 }
17103 stream_node::NodeBody::OverWindow(v) => {
17104 struct_ser.serialize_field("overWindow", v)?;
17105 }
17106 stream_node::NodeBody::StreamFsFetch(v) => {
17107 struct_ser.serialize_field("streamFsFetch", v)?;
17108 }
17109 stream_node::NodeBody::StreamCdcScan(v) => {
17110 struct_ser.serialize_field("streamCdcScan", v)?;
17111 }
17112 stream_node::NodeBody::CdcFilter(v) => {
17113 struct_ser.serialize_field("cdcFilter", v)?;
17114 }
17115 stream_node::NodeBody::SourceBackfill(v) => {
17116 struct_ser.serialize_field("sourceBackfill", v)?;
17117 }
17118 stream_node::NodeBody::Changelog(v) => {
17119 struct_ser.serialize_field("changelog", v)?;
17120 }
17121 stream_node::NodeBody::LocalApproxPercentile(v) => {
17122 struct_ser.serialize_field("localApproxPercentile", v)?;
17123 }
17124 stream_node::NodeBody::GlobalApproxPercentile(v) => {
17125 struct_ser.serialize_field("globalApproxPercentile", v)?;
17126 }
17127 stream_node::NodeBody::RowMerge(v) => {
17128 struct_ser.serialize_field("rowMerge", v)?;
17129 }
17130 stream_node::NodeBody::AsOfJoin(v) => {
17131 struct_ser.serialize_field("asOfJoin", v)?;
17132 }
17133 stream_node::NodeBody::SyncLogStore(v) => {
17134 struct_ser.serialize_field("syncLogStore", v)?;
17135 }
17136 stream_node::NodeBody::MaterializedExprs(v) => {
17137 struct_ser.serialize_field("materializedExprs", v)?;
17138 }
17139 stream_node::NodeBody::VectorIndexWrite(v) => {
17140 struct_ser.serialize_field("vectorIndexWrite", v)?;
17141 }
17142 stream_node::NodeBody::UpstreamSinkUnion(v) => {
17143 struct_ser.serialize_field("upstreamSinkUnion", v)?;
17144 }
17145 stream_node::NodeBody::LocalityProvider(v) => {
17146 struct_ser.serialize_field("localityProvider", v)?;
17147 }
17148 stream_node::NodeBody::EowcGapFill(v) => {
17149 struct_ser.serialize_field("eowcGapFill", v)?;
17150 }
17151 stream_node::NodeBody::GapFill(v) => {
17152 struct_ser.serialize_field("gapFill", v)?;
17153 }
17154 stream_node::NodeBody::VectorIndexLookupJoin(v) => {
17155 struct_ser.serialize_field("vectorIndexLookupJoin", v)?;
17156 }
17157 stream_node::NodeBody::IcebergWithPkIndexWriter(v) => {
17158 struct_ser.serialize_field("icebergWithPkIndexWriter", v)?;
17159 }
17160 stream_node::NodeBody::IcebergWithPkIndexPositionDeleteMerger(v) => {
17161 struct_ser.serialize_field("icebergWithPkIndexPositionDeleteMerger", v)?;
17162 }
17163 stream_node::NodeBody::MatchRecognize(v) => {
17164 struct_ser.serialize_field("matchRecognize", v)?;
17165 }
17166 stream_node::NodeBody::CompactionResolver(v) => {
17167 struct_ser.serialize_field("compactionResolver", v)?;
17168 }
17169 }
17170 }
17171 struct_ser.end()
17172 }
17173}
17174impl<'de> serde::Deserialize<'de> for StreamNode {
17175 #[allow(deprecated)]
17176 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17177 where
17178 D: serde::Deserializer<'de>,
17179 {
17180 const FIELDS: &[&str] = &[
17181 "operator_id",
17182 "operatorId",
17183 "input",
17184 "stream_key",
17185 "streamKey",
17186 "stream_kind",
17187 "streamKind",
17188 "identity",
17189 "fields",
17190 "source",
17191 "project",
17192 "filter",
17193 "materialize",
17194 "stateless_simple_agg",
17195 "statelessSimpleAgg",
17196 "simple_agg",
17197 "simpleAgg",
17198 "hash_agg",
17199 "hashAgg",
17200 "append_only_top_n",
17201 "appendOnlyTopN",
17202 "hash_join",
17203 "hashJoin",
17204 "top_n",
17205 "topN",
17206 "hop_window",
17207 "hopWindow",
17208 "merge",
17209 "exchange",
17210 "stream_scan",
17211 "streamScan",
17212 "batch_plan",
17213 "batchPlan",
17214 "lookup",
17215 "arrange",
17216 "lookup_union",
17217 "lookupUnion",
17218 "union",
17219 "delta_index_join",
17220 "deltaIndexJoin",
17221 "sink",
17222 "expand",
17223 "dynamic_filter",
17224 "dynamicFilter",
17225 "project_set",
17226 "projectSet",
17227 "group_top_n",
17228 "groupTopN",
17229 "sort",
17230 "watermark_filter",
17231 "watermarkFilter",
17232 "dml",
17233 "row_id_gen",
17234 "rowIdGen",
17235 "now",
17236 "append_only_group_top_n",
17237 "appendOnlyGroupTopN",
17238 "temporal_join",
17239 "temporalJoin",
17240 "barrier_recv",
17241 "barrierRecv",
17242 "values",
17243 "append_only_dedup",
17244 "appendOnlyDedup",
17245 "no_op",
17246 "noOp",
17247 "eowc_over_window",
17248 "eowcOverWindow",
17249 "over_window",
17250 "overWindow",
17251 "stream_fs_fetch",
17252 "streamFsFetch",
17253 "stream_cdc_scan",
17254 "streamCdcScan",
17255 "cdc_filter",
17256 "cdcFilter",
17257 "source_backfill",
17258 "sourceBackfill",
17259 "changelog",
17260 "local_approx_percentile",
17261 "localApproxPercentile",
17262 "global_approx_percentile",
17263 "globalApproxPercentile",
17264 "row_merge",
17265 "rowMerge",
17266 "as_of_join",
17267 "asOfJoin",
17268 "sync_log_store",
17269 "syncLogStore",
17270 "materialized_exprs",
17271 "materializedExprs",
17272 "vector_index_write",
17273 "vectorIndexWrite",
17274 "upstream_sink_union",
17275 "upstreamSinkUnion",
17276 "locality_provider",
17277 "localityProvider",
17278 "eowc_gap_fill",
17279 "eowcGapFill",
17280 "gap_fill",
17281 "gapFill",
17282 "vector_index_lookup_join",
17283 "vectorIndexLookupJoin",
17284 "iceberg_with_pk_index_writer",
17285 "icebergWithPkIndexWriter",
17286 "iceberg_with_pk_index_position_delete_merger",
17287 "icebergWithPkIndexPositionDeleteMerger",
17288 "match_recognize",
17289 "matchRecognize",
17290 "compaction_resolver",
17291 "compactionResolver",
17292 ];
17293
17294 #[allow(clippy::enum_variant_names)]
17295 enum GeneratedField {
17296 OperatorId,
17297 Input,
17298 StreamKey,
17299 StreamKind,
17300 Identity,
17301 Fields,
17302 Source,
17303 Project,
17304 Filter,
17305 Materialize,
17306 StatelessSimpleAgg,
17307 SimpleAgg,
17308 HashAgg,
17309 AppendOnlyTopN,
17310 HashJoin,
17311 TopN,
17312 HopWindow,
17313 Merge,
17314 Exchange,
17315 StreamScan,
17316 BatchPlan,
17317 Lookup,
17318 Arrange,
17319 LookupUnion,
17320 Union,
17321 DeltaIndexJoin,
17322 Sink,
17323 Expand,
17324 DynamicFilter,
17325 ProjectSet,
17326 GroupTopN,
17327 Sort,
17328 WatermarkFilter,
17329 Dml,
17330 RowIdGen,
17331 Now,
17332 AppendOnlyGroupTopN,
17333 TemporalJoin,
17334 BarrierRecv,
17335 Values,
17336 AppendOnlyDedup,
17337 NoOp,
17338 EowcOverWindow,
17339 OverWindow,
17340 StreamFsFetch,
17341 StreamCdcScan,
17342 CdcFilter,
17343 SourceBackfill,
17344 Changelog,
17345 LocalApproxPercentile,
17346 GlobalApproxPercentile,
17347 RowMerge,
17348 AsOfJoin,
17349 SyncLogStore,
17350 MaterializedExprs,
17351 VectorIndexWrite,
17352 UpstreamSinkUnion,
17353 LocalityProvider,
17354 EowcGapFill,
17355 GapFill,
17356 VectorIndexLookupJoin,
17357 IcebergWithPkIndexWriter,
17358 IcebergWithPkIndexPositionDeleteMerger,
17359 MatchRecognize,
17360 CompactionResolver,
17361 }
17362 impl<'de> serde::Deserialize<'de> for GeneratedField {
17363 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17364 where
17365 D: serde::Deserializer<'de>,
17366 {
17367 struct GeneratedVisitor;
17368
17369 impl serde::de::Visitor<'_> for GeneratedVisitor {
17370 type Value = GeneratedField;
17371
17372 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17373 write!(formatter, "expected one of: {:?}", &FIELDS)
17374 }
17375
17376 #[allow(unused_variables)]
17377 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17378 where
17379 E: serde::de::Error,
17380 {
17381 match value {
17382 "operatorId" | "operator_id" => Ok(GeneratedField::OperatorId),
17383 "input" => Ok(GeneratedField::Input),
17384 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
17385 "streamKind" | "stream_kind" => Ok(GeneratedField::StreamKind),
17386 "identity" => Ok(GeneratedField::Identity),
17387 "fields" => Ok(GeneratedField::Fields),
17388 "source" => Ok(GeneratedField::Source),
17389 "project" => Ok(GeneratedField::Project),
17390 "filter" => Ok(GeneratedField::Filter),
17391 "materialize" => Ok(GeneratedField::Materialize),
17392 "statelessSimpleAgg" | "stateless_simple_agg" => Ok(GeneratedField::StatelessSimpleAgg),
17393 "simpleAgg" | "simple_agg" => Ok(GeneratedField::SimpleAgg),
17394 "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
17395 "appendOnlyTopN" | "append_only_top_n" => Ok(GeneratedField::AppendOnlyTopN),
17396 "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
17397 "topN" | "top_n" => Ok(GeneratedField::TopN),
17398 "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
17399 "merge" => Ok(GeneratedField::Merge),
17400 "exchange" => Ok(GeneratedField::Exchange),
17401 "streamScan" | "stream_scan" => Ok(GeneratedField::StreamScan),
17402 "batchPlan" | "batch_plan" => Ok(GeneratedField::BatchPlan),
17403 "lookup" => Ok(GeneratedField::Lookup),
17404 "arrange" => Ok(GeneratedField::Arrange),
17405 "lookupUnion" | "lookup_union" => Ok(GeneratedField::LookupUnion),
17406 "union" => Ok(GeneratedField::Union),
17407 "deltaIndexJoin" | "delta_index_join" => Ok(GeneratedField::DeltaIndexJoin),
17408 "sink" => Ok(GeneratedField::Sink),
17409 "expand" => Ok(GeneratedField::Expand),
17410 "dynamicFilter" | "dynamic_filter" => Ok(GeneratedField::DynamicFilter),
17411 "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
17412 "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
17413 "sort" => Ok(GeneratedField::Sort),
17414 "watermarkFilter" | "watermark_filter" => Ok(GeneratedField::WatermarkFilter),
17415 "dml" => Ok(GeneratedField::Dml),
17416 "rowIdGen" | "row_id_gen" => Ok(GeneratedField::RowIdGen),
17417 "now" => Ok(GeneratedField::Now),
17418 "appendOnlyGroupTopN" | "append_only_group_top_n" => Ok(GeneratedField::AppendOnlyGroupTopN),
17419 "temporalJoin" | "temporal_join" => Ok(GeneratedField::TemporalJoin),
17420 "barrierRecv" | "barrier_recv" => Ok(GeneratedField::BarrierRecv),
17421 "values" => Ok(GeneratedField::Values),
17422 "appendOnlyDedup" | "append_only_dedup" => Ok(GeneratedField::AppendOnlyDedup),
17423 "noOp" | "no_op" => Ok(GeneratedField::NoOp),
17424 "eowcOverWindow" | "eowc_over_window" => Ok(GeneratedField::EowcOverWindow),
17425 "overWindow" | "over_window" => Ok(GeneratedField::OverWindow),
17426 "streamFsFetch" | "stream_fs_fetch" => Ok(GeneratedField::StreamFsFetch),
17427 "streamCdcScan" | "stream_cdc_scan" => Ok(GeneratedField::StreamCdcScan),
17428 "cdcFilter" | "cdc_filter" => Ok(GeneratedField::CdcFilter),
17429 "sourceBackfill" | "source_backfill" => Ok(GeneratedField::SourceBackfill),
17430 "changelog" => Ok(GeneratedField::Changelog),
17431 "localApproxPercentile" | "local_approx_percentile" => Ok(GeneratedField::LocalApproxPercentile),
17432 "globalApproxPercentile" | "global_approx_percentile" => Ok(GeneratedField::GlobalApproxPercentile),
17433 "rowMerge" | "row_merge" => Ok(GeneratedField::RowMerge),
17434 "asOfJoin" | "as_of_join" => Ok(GeneratedField::AsOfJoin),
17435 "syncLogStore" | "sync_log_store" => Ok(GeneratedField::SyncLogStore),
17436 "materializedExprs" | "materialized_exprs" => Ok(GeneratedField::MaterializedExprs),
17437 "vectorIndexWrite" | "vector_index_write" => Ok(GeneratedField::VectorIndexWrite),
17438 "upstreamSinkUnion" | "upstream_sink_union" => Ok(GeneratedField::UpstreamSinkUnion),
17439 "localityProvider" | "locality_provider" => Ok(GeneratedField::LocalityProvider),
17440 "eowcGapFill" | "eowc_gap_fill" => Ok(GeneratedField::EowcGapFill),
17441 "gapFill" | "gap_fill" => Ok(GeneratedField::GapFill),
17442 "vectorIndexLookupJoin" | "vector_index_lookup_join" => Ok(GeneratedField::VectorIndexLookupJoin),
17443 "icebergWithPkIndexWriter" | "iceberg_with_pk_index_writer" => Ok(GeneratedField::IcebergWithPkIndexWriter),
17444 "icebergWithPkIndexPositionDeleteMerger" | "iceberg_with_pk_index_position_delete_merger" => Ok(GeneratedField::IcebergWithPkIndexPositionDeleteMerger),
17445 "matchRecognize" | "match_recognize" => Ok(GeneratedField::MatchRecognize),
17446 "compactionResolver" | "compaction_resolver" => Ok(GeneratedField::CompactionResolver),
17447 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17448 }
17449 }
17450 }
17451 deserializer.deserialize_identifier(GeneratedVisitor)
17452 }
17453 }
17454 struct GeneratedVisitor;
17455 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17456 type Value = StreamNode;
17457
17458 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17459 formatter.write_str("struct stream_plan.StreamNode")
17460 }
17461
17462 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamNode, V::Error>
17463 where
17464 V: serde::de::MapAccess<'de>,
17465 {
17466 let mut operator_id__ = None;
17467 let mut input__ = None;
17468 let mut stream_key__ = None;
17469 let mut stream_kind__ = None;
17470 let mut identity__ = None;
17471 let mut fields__ = None;
17472 let mut node_body__ = None;
17473 while let Some(k) = map_.next_key()? {
17474 match k {
17475 GeneratedField::OperatorId => {
17476 if operator_id__.is_some() {
17477 return Err(serde::de::Error::duplicate_field("operatorId"));
17478 }
17479 operator_id__ =
17480 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17481 ;
17482 }
17483 GeneratedField::Input => {
17484 if input__.is_some() {
17485 return Err(serde::de::Error::duplicate_field("input"));
17486 }
17487 input__ = Some(map_.next_value()?);
17488 }
17489 GeneratedField::StreamKey => {
17490 if stream_key__.is_some() {
17491 return Err(serde::de::Error::duplicate_field("streamKey"));
17492 }
17493 stream_key__ =
17494 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17495 .into_iter().map(|x| x.0).collect())
17496 ;
17497 }
17498 GeneratedField::StreamKind => {
17499 if stream_kind__.is_some() {
17500 return Err(serde::de::Error::duplicate_field("streamKind"));
17501 }
17502 stream_kind__ = Some(map_.next_value::<stream_node::StreamKind>()? as i32);
17503 }
17504 GeneratedField::Identity => {
17505 if identity__.is_some() {
17506 return Err(serde::de::Error::duplicate_field("identity"));
17507 }
17508 identity__ = Some(map_.next_value()?);
17509 }
17510 GeneratedField::Fields => {
17511 if fields__.is_some() {
17512 return Err(serde::de::Error::duplicate_field("fields"));
17513 }
17514 fields__ = Some(map_.next_value()?);
17515 }
17516 GeneratedField::Source => {
17517 if node_body__.is_some() {
17518 return Err(serde::de::Error::duplicate_field("source"));
17519 }
17520 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Source)
17521;
17522 }
17523 GeneratedField::Project => {
17524 if node_body__.is_some() {
17525 return Err(serde::de::Error::duplicate_field("project"));
17526 }
17527 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Project)
17528;
17529 }
17530 GeneratedField::Filter => {
17531 if node_body__.is_some() {
17532 return Err(serde::de::Error::duplicate_field("filter"));
17533 }
17534 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Filter)
17535;
17536 }
17537 GeneratedField::Materialize => {
17538 if node_body__.is_some() {
17539 return Err(serde::de::Error::duplicate_field("materialize"));
17540 }
17541 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Materialize)
17542;
17543 }
17544 GeneratedField::StatelessSimpleAgg => {
17545 if node_body__.is_some() {
17546 return Err(serde::de::Error::duplicate_field("statelessSimpleAgg"));
17547 }
17548 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StatelessSimpleAgg)
17549;
17550 }
17551 GeneratedField::SimpleAgg => {
17552 if node_body__.is_some() {
17553 return Err(serde::de::Error::duplicate_field("simpleAgg"));
17554 }
17555 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SimpleAgg)
17556;
17557 }
17558 GeneratedField::HashAgg => {
17559 if node_body__.is_some() {
17560 return Err(serde::de::Error::duplicate_field("hashAgg"));
17561 }
17562 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashAgg)
17563;
17564 }
17565 GeneratedField::AppendOnlyTopN => {
17566 if node_body__.is_some() {
17567 return Err(serde::de::Error::duplicate_field("appendOnlyTopN"));
17568 }
17569 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyTopN)
17570;
17571 }
17572 GeneratedField::HashJoin => {
17573 if node_body__.is_some() {
17574 return Err(serde::de::Error::duplicate_field("hashJoin"));
17575 }
17576 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashJoin)
17577;
17578 }
17579 GeneratedField::TopN => {
17580 if node_body__.is_some() {
17581 return Err(serde::de::Error::duplicate_field("topN"));
17582 }
17583 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TopN)
17584;
17585 }
17586 GeneratedField::HopWindow => {
17587 if node_body__.is_some() {
17588 return Err(serde::de::Error::duplicate_field("hopWindow"));
17589 }
17590 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HopWindow)
17591;
17592 }
17593 GeneratedField::Merge => {
17594 if node_body__.is_some() {
17595 return Err(serde::de::Error::duplicate_field("merge"));
17596 }
17597 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Merge)
17598;
17599 }
17600 GeneratedField::Exchange => {
17601 if node_body__.is_some() {
17602 return Err(serde::de::Error::duplicate_field("exchange"));
17603 }
17604 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Exchange)
17605;
17606 }
17607 GeneratedField::StreamScan => {
17608 if node_body__.is_some() {
17609 return Err(serde::de::Error::duplicate_field("streamScan"));
17610 }
17611 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamScan)
17612;
17613 }
17614 GeneratedField::BatchPlan => {
17615 if node_body__.is_some() {
17616 return Err(serde::de::Error::duplicate_field("batchPlan"));
17617 }
17618 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BatchPlan)
17619;
17620 }
17621 GeneratedField::Lookup => {
17622 if node_body__.is_some() {
17623 return Err(serde::de::Error::duplicate_field("lookup"));
17624 }
17625 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Lookup)
17626;
17627 }
17628 GeneratedField::Arrange => {
17629 if node_body__.is_some() {
17630 return Err(serde::de::Error::duplicate_field("arrange"));
17631 }
17632 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Arrange)
17633;
17634 }
17635 GeneratedField::LookupUnion => {
17636 if node_body__.is_some() {
17637 return Err(serde::de::Error::duplicate_field("lookupUnion"));
17638 }
17639 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LookupUnion)
17640;
17641 }
17642 GeneratedField::Union => {
17643 if node_body__.is_some() {
17644 return Err(serde::de::Error::duplicate_field("union"));
17645 }
17646 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Union)
17647;
17648 }
17649 GeneratedField::DeltaIndexJoin => {
17650 if node_body__.is_some() {
17651 return Err(serde::de::Error::duplicate_field("deltaIndexJoin"));
17652 }
17653 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DeltaIndexJoin)
17654;
17655 }
17656 GeneratedField::Sink => {
17657 if node_body__.is_some() {
17658 return Err(serde::de::Error::duplicate_field("sink"));
17659 }
17660 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sink)
17661;
17662 }
17663 GeneratedField::Expand => {
17664 if node_body__.is_some() {
17665 return Err(serde::de::Error::duplicate_field("expand"));
17666 }
17667 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Expand)
17668;
17669 }
17670 GeneratedField::DynamicFilter => {
17671 if node_body__.is_some() {
17672 return Err(serde::de::Error::duplicate_field("dynamicFilter"));
17673 }
17674 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DynamicFilter)
17675;
17676 }
17677 GeneratedField::ProjectSet => {
17678 if node_body__.is_some() {
17679 return Err(serde::de::Error::duplicate_field("projectSet"));
17680 }
17681 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::ProjectSet)
17682;
17683 }
17684 GeneratedField::GroupTopN => {
17685 if node_body__.is_some() {
17686 return Err(serde::de::Error::duplicate_field("groupTopN"));
17687 }
17688 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GroupTopN)
17689;
17690 }
17691 GeneratedField::Sort => {
17692 if node_body__.is_some() {
17693 return Err(serde::de::Error::duplicate_field("sort"));
17694 }
17695 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sort)
17696;
17697 }
17698 GeneratedField::WatermarkFilter => {
17699 if node_body__.is_some() {
17700 return Err(serde::de::Error::duplicate_field("watermarkFilter"));
17701 }
17702 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::WatermarkFilter)
17703;
17704 }
17705 GeneratedField::Dml => {
17706 if node_body__.is_some() {
17707 return Err(serde::de::Error::duplicate_field("dml"));
17708 }
17709 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Dml)
17710;
17711 }
17712 GeneratedField::RowIdGen => {
17713 if node_body__.is_some() {
17714 return Err(serde::de::Error::duplicate_field("rowIdGen"));
17715 }
17716 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowIdGen)
17717;
17718 }
17719 GeneratedField::Now => {
17720 if node_body__.is_some() {
17721 return Err(serde::de::Error::duplicate_field("now"));
17722 }
17723 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Now)
17724;
17725 }
17726 GeneratedField::AppendOnlyGroupTopN => {
17727 if node_body__.is_some() {
17728 return Err(serde::de::Error::duplicate_field("appendOnlyGroupTopN"));
17729 }
17730 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyGroupTopN)
17731;
17732 }
17733 GeneratedField::TemporalJoin => {
17734 if node_body__.is_some() {
17735 return Err(serde::de::Error::duplicate_field("temporalJoin"));
17736 }
17737 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TemporalJoin)
17738;
17739 }
17740 GeneratedField::BarrierRecv => {
17741 if node_body__.is_some() {
17742 return Err(serde::de::Error::duplicate_field("barrierRecv"));
17743 }
17744 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BarrierRecv)
17745;
17746 }
17747 GeneratedField::Values => {
17748 if node_body__.is_some() {
17749 return Err(serde::de::Error::duplicate_field("values"));
17750 }
17751 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Values)
17752;
17753 }
17754 GeneratedField::AppendOnlyDedup => {
17755 if node_body__.is_some() {
17756 return Err(serde::de::Error::duplicate_field("appendOnlyDedup"));
17757 }
17758 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyDedup)
17759;
17760 }
17761 GeneratedField::NoOp => {
17762 if node_body__.is_some() {
17763 return Err(serde::de::Error::duplicate_field("noOp"));
17764 }
17765 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::NoOp)
17766;
17767 }
17768 GeneratedField::EowcOverWindow => {
17769 if node_body__.is_some() {
17770 return Err(serde::de::Error::duplicate_field("eowcOverWindow"));
17771 }
17772 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcOverWindow)
17773;
17774 }
17775 GeneratedField::OverWindow => {
17776 if node_body__.is_some() {
17777 return Err(serde::de::Error::duplicate_field("overWindow"));
17778 }
17779 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::OverWindow)
17780;
17781 }
17782 GeneratedField::StreamFsFetch => {
17783 if node_body__.is_some() {
17784 return Err(serde::de::Error::duplicate_field("streamFsFetch"));
17785 }
17786 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamFsFetch)
17787;
17788 }
17789 GeneratedField::StreamCdcScan => {
17790 if node_body__.is_some() {
17791 return Err(serde::de::Error::duplicate_field("streamCdcScan"));
17792 }
17793 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamCdcScan)
17794;
17795 }
17796 GeneratedField::CdcFilter => {
17797 if node_body__.is_some() {
17798 return Err(serde::de::Error::duplicate_field("cdcFilter"));
17799 }
17800 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CdcFilter)
17801;
17802 }
17803 GeneratedField::SourceBackfill => {
17804 if node_body__.is_some() {
17805 return Err(serde::de::Error::duplicate_field("sourceBackfill"));
17806 }
17807 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SourceBackfill)
17808;
17809 }
17810 GeneratedField::Changelog => {
17811 if node_body__.is_some() {
17812 return Err(serde::de::Error::duplicate_field("changelog"));
17813 }
17814 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Changelog)
17815;
17816 }
17817 GeneratedField::LocalApproxPercentile => {
17818 if node_body__.is_some() {
17819 return Err(serde::de::Error::duplicate_field("localApproxPercentile"));
17820 }
17821 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalApproxPercentile)
17822;
17823 }
17824 GeneratedField::GlobalApproxPercentile => {
17825 if node_body__.is_some() {
17826 return Err(serde::de::Error::duplicate_field("globalApproxPercentile"));
17827 }
17828 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GlobalApproxPercentile)
17829;
17830 }
17831 GeneratedField::RowMerge => {
17832 if node_body__.is_some() {
17833 return Err(serde::de::Error::duplicate_field("rowMerge"));
17834 }
17835 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowMerge)
17836;
17837 }
17838 GeneratedField::AsOfJoin => {
17839 if node_body__.is_some() {
17840 return Err(serde::de::Error::duplicate_field("asOfJoin"));
17841 }
17842 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AsOfJoin)
17843;
17844 }
17845 GeneratedField::SyncLogStore => {
17846 if node_body__.is_some() {
17847 return Err(serde::de::Error::duplicate_field("syncLogStore"));
17848 }
17849 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SyncLogStore)
17850;
17851 }
17852 GeneratedField::MaterializedExprs => {
17853 if node_body__.is_some() {
17854 return Err(serde::de::Error::duplicate_field("materializedExprs"));
17855 }
17856 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MaterializedExprs)
17857;
17858 }
17859 GeneratedField::VectorIndexWrite => {
17860 if node_body__.is_some() {
17861 return Err(serde::de::Error::duplicate_field("vectorIndexWrite"));
17862 }
17863 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexWrite)
17864;
17865 }
17866 GeneratedField::UpstreamSinkUnion => {
17867 if node_body__.is_some() {
17868 return Err(serde::de::Error::duplicate_field("upstreamSinkUnion"));
17869 }
17870 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::UpstreamSinkUnion)
17871;
17872 }
17873 GeneratedField::LocalityProvider => {
17874 if node_body__.is_some() {
17875 return Err(serde::de::Error::duplicate_field("localityProvider"));
17876 }
17877 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalityProvider)
17878;
17879 }
17880 GeneratedField::EowcGapFill => {
17881 if node_body__.is_some() {
17882 return Err(serde::de::Error::duplicate_field("eowcGapFill"));
17883 }
17884 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcGapFill)
17885;
17886 }
17887 GeneratedField::GapFill => {
17888 if node_body__.is_some() {
17889 return Err(serde::de::Error::duplicate_field("gapFill"));
17890 }
17891 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GapFill)
17892;
17893 }
17894 GeneratedField::VectorIndexLookupJoin => {
17895 if node_body__.is_some() {
17896 return Err(serde::de::Error::duplicate_field("vectorIndexLookupJoin"));
17897 }
17898 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexLookupJoin)
17899;
17900 }
17901 GeneratedField::IcebergWithPkIndexWriter => {
17902 if node_body__.is_some() {
17903 return Err(serde::de::Error::duplicate_field("icebergWithPkIndexWriter"));
17904 }
17905 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::IcebergWithPkIndexWriter)
17906;
17907 }
17908 GeneratedField::IcebergWithPkIndexPositionDeleteMerger => {
17909 if node_body__.is_some() {
17910 return Err(serde::de::Error::duplicate_field("icebergWithPkIndexPositionDeleteMerger"));
17911 }
17912 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::IcebergWithPkIndexPositionDeleteMerger)
17913;
17914 }
17915 GeneratedField::MatchRecognize => {
17916 if node_body__.is_some() {
17917 return Err(serde::de::Error::duplicate_field("matchRecognize"));
17918 }
17919 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MatchRecognize)
17920;
17921 }
17922 GeneratedField::CompactionResolver => {
17923 if node_body__.is_some() {
17924 return Err(serde::de::Error::duplicate_field("compactionResolver"));
17925 }
17926 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CompactionResolver)
17927;
17928 }
17929 }
17930 }
17931 Ok(StreamNode {
17932 operator_id: operator_id__.unwrap_or_default(),
17933 input: input__.unwrap_or_default(),
17934 stream_key: stream_key__.unwrap_or_default(),
17935 stream_kind: stream_kind__.unwrap_or_default(),
17936 identity: identity__.unwrap_or_default(),
17937 fields: fields__.unwrap_or_default(),
17938 node_body: node_body__,
17939 })
17940 }
17941 }
17942 deserializer.deserialize_struct("stream_plan.StreamNode", FIELDS, GeneratedVisitor)
17943 }
17944}
17945impl serde::Serialize for stream_node::StreamKind {
17946 #[allow(deprecated)]
17947 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17948 where
17949 S: serde::Serializer,
17950 {
17951 let variant = match self {
17952 Self::Retract => "STREAM_KIND_RETRACT",
17953 Self::AppendOnly => "STREAM_KIND_APPEND_ONLY",
17954 Self::Upsert => "STREAM_KIND_UPSERT",
17955 };
17956 serializer.serialize_str(variant)
17957 }
17958}
17959impl<'de> serde::Deserialize<'de> for stream_node::StreamKind {
17960 #[allow(deprecated)]
17961 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17962 where
17963 D: serde::Deserializer<'de>,
17964 {
17965 const FIELDS: &[&str] = &[
17966 "STREAM_KIND_RETRACT",
17967 "STREAM_KIND_APPEND_ONLY",
17968 "STREAM_KIND_UPSERT",
17969 ];
17970
17971 struct GeneratedVisitor;
17972
17973 impl serde::de::Visitor<'_> for GeneratedVisitor {
17974 type Value = stream_node::StreamKind;
17975
17976 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17977 write!(formatter, "expected one of: {:?}", &FIELDS)
17978 }
17979
17980 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17981 where
17982 E: serde::de::Error,
17983 {
17984 i32::try_from(v)
17985 .ok()
17986 .and_then(|x| x.try_into().ok())
17987 .ok_or_else(|| {
17988 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17989 })
17990 }
17991
17992 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17993 where
17994 E: serde::de::Error,
17995 {
17996 i32::try_from(v)
17997 .ok()
17998 .and_then(|x| x.try_into().ok())
17999 .ok_or_else(|| {
18000 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
18001 })
18002 }
18003
18004 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
18005 where
18006 E: serde::de::Error,
18007 {
18008 match value {
18009 "STREAM_KIND_RETRACT" => Ok(stream_node::StreamKind::Retract),
18010 "STREAM_KIND_APPEND_ONLY" => Ok(stream_node::StreamKind::AppendOnly),
18011 "STREAM_KIND_UPSERT" => Ok(stream_node::StreamKind::Upsert),
18012 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
18013 }
18014 }
18015 }
18016 deserializer.deserialize_any(GeneratedVisitor)
18017 }
18018}
18019impl serde::Serialize for StreamScanNode {
18020 #[allow(deprecated)]
18021 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18022 where
18023 S: serde::Serializer,
18024 {
18025 use serde::ser::SerializeStruct;
18026 let mut len = 0;
18027 if self.table_id != 0 {
18028 len += 1;
18029 }
18030 if !self.upstream_column_ids.is_empty() {
18031 len += 1;
18032 }
18033 if !self.output_indices.is_empty() {
18034 len += 1;
18035 }
18036 if self.stream_scan_type != 0 {
18037 len += 1;
18038 }
18039 if self.state_table.is_some() {
18040 len += 1;
18041 }
18042 if self.table_desc.is_some() {
18043 len += 1;
18044 }
18045 if self.rate_limit.is_some() {
18046 len += 1;
18047 }
18048 if self.snapshot_read_barrier_interval != 0 {
18049 len += 1;
18050 }
18051 if self.arrangement_table.is_some() {
18052 len += 1;
18053 }
18054 if self.snapshot_backfill_epoch.is_some() {
18055 len += 1;
18056 }
18057 if self.pk_scan_range.is_some() {
18058 len += 1;
18059 }
18060 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamScanNode", len)?;
18061 if self.table_id != 0 {
18062 struct_ser.serialize_field("tableId", &self.table_id)?;
18063 }
18064 if !self.upstream_column_ids.is_empty() {
18065 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
18066 }
18067 if !self.output_indices.is_empty() {
18068 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
18069 }
18070 if self.stream_scan_type != 0 {
18071 let v = StreamScanType::try_from(self.stream_scan_type)
18072 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_scan_type)))?;
18073 struct_ser.serialize_field("streamScanType", &v)?;
18074 }
18075 if let Some(v) = self.state_table.as_ref() {
18076 struct_ser.serialize_field("stateTable", v)?;
18077 }
18078 if let Some(v) = self.table_desc.as_ref() {
18079 struct_ser.serialize_field("tableDesc", v)?;
18080 }
18081 if let Some(v) = self.rate_limit.as_ref() {
18082 struct_ser.serialize_field("rateLimit", v)?;
18083 }
18084 if self.snapshot_read_barrier_interval != 0 {
18085 struct_ser.serialize_field("snapshotReadBarrierInterval", &self.snapshot_read_barrier_interval)?;
18086 }
18087 if let Some(v) = self.arrangement_table.as_ref() {
18088 struct_ser.serialize_field("arrangementTable", v)?;
18089 }
18090 if let Some(v) = self.snapshot_backfill_epoch.as_ref() {
18091 #[allow(clippy::needless_borrow)]
18092 #[allow(clippy::needless_borrows_for_generic_args)]
18093 struct_ser.serialize_field("snapshotBackfillEpoch", ToString::to_string(&v).as_str())?;
18094 }
18095 if let Some(v) = self.pk_scan_range.as_ref() {
18096 struct_ser.serialize_field("pkScanRange", v)?;
18097 }
18098 struct_ser.end()
18099 }
18100}
18101impl<'de> serde::Deserialize<'de> for StreamScanNode {
18102 #[allow(deprecated)]
18103 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18104 where
18105 D: serde::Deserializer<'de>,
18106 {
18107 const FIELDS: &[&str] = &[
18108 "table_id",
18109 "tableId",
18110 "upstream_column_ids",
18111 "upstreamColumnIds",
18112 "output_indices",
18113 "outputIndices",
18114 "stream_scan_type",
18115 "streamScanType",
18116 "state_table",
18117 "stateTable",
18118 "table_desc",
18119 "tableDesc",
18120 "rate_limit",
18121 "rateLimit",
18122 "snapshot_read_barrier_interval",
18123 "snapshotReadBarrierInterval",
18124 "arrangement_table",
18125 "arrangementTable",
18126 "snapshot_backfill_epoch",
18127 "snapshotBackfillEpoch",
18128 "pk_scan_range",
18129 "pkScanRange",
18130 ];
18131
18132 #[allow(clippy::enum_variant_names)]
18133 enum GeneratedField {
18134 TableId,
18135 UpstreamColumnIds,
18136 OutputIndices,
18137 StreamScanType,
18138 StateTable,
18139 TableDesc,
18140 RateLimit,
18141 SnapshotReadBarrierInterval,
18142 ArrangementTable,
18143 SnapshotBackfillEpoch,
18144 PkScanRange,
18145 }
18146 impl<'de> serde::Deserialize<'de> for GeneratedField {
18147 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18148 where
18149 D: serde::Deserializer<'de>,
18150 {
18151 struct GeneratedVisitor;
18152
18153 impl serde::de::Visitor<'_> for GeneratedVisitor {
18154 type Value = GeneratedField;
18155
18156 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18157 write!(formatter, "expected one of: {:?}", &FIELDS)
18158 }
18159
18160 #[allow(unused_variables)]
18161 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18162 where
18163 E: serde::de::Error,
18164 {
18165 match value {
18166 "tableId" | "table_id" => Ok(GeneratedField::TableId),
18167 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
18168 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
18169 "streamScanType" | "stream_scan_type" => Ok(GeneratedField::StreamScanType),
18170 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
18171 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
18172 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
18173 "snapshotReadBarrierInterval" | "snapshot_read_barrier_interval" => Ok(GeneratedField::SnapshotReadBarrierInterval),
18174 "arrangementTable" | "arrangement_table" => Ok(GeneratedField::ArrangementTable),
18175 "snapshotBackfillEpoch" | "snapshot_backfill_epoch" => Ok(GeneratedField::SnapshotBackfillEpoch),
18176 "pkScanRange" | "pk_scan_range" => Ok(GeneratedField::PkScanRange),
18177 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18178 }
18179 }
18180 }
18181 deserializer.deserialize_identifier(GeneratedVisitor)
18182 }
18183 }
18184 struct GeneratedVisitor;
18185 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18186 type Value = StreamScanNode;
18187
18188 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18189 formatter.write_str("struct stream_plan.StreamScanNode")
18190 }
18191
18192 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamScanNode, V::Error>
18193 where
18194 V: serde::de::MapAccess<'de>,
18195 {
18196 let mut table_id__ = None;
18197 let mut upstream_column_ids__ = None;
18198 let mut output_indices__ = None;
18199 let mut stream_scan_type__ = None;
18200 let mut state_table__ = None;
18201 let mut table_desc__ = None;
18202 let mut rate_limit__ = None;
18203 let mut snapshot_read_barrier_interval__ = None;
18204 let mut arrangement_table__ = None;
18205 let mut snapshot_backfill_epoch__ = None;
18206 let mut pk_scan_range__ = None;
18207 while let Some(k) = map_.next_key()? {
18208 match k {
18209 GeneratedField::TableId => {
18210 if table_id__.is_some() {
18211 return Err(serde::de::Error::duplicate_field("tableId"));
18212 }
18213 table_id__ =
18214 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18215 ;
18216 }
18217 GeneratedField::UpstreamColumnIds => {
18218 if upstream_column_ids__.is_some() {
18219 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
18220 }
18221 upstream_column_ids__ =
18222 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
18223 .into_iter().map(|x| x.0).collect())
18224 ;
18225 }
18226 GeneratedField::OutputIndices => {
18227 if output_indices__.is_some() {
18228 return Err(serde::de::Error::duplicate_field("outputIndices"));
18229 }
18230 output_indices__ =
18231 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
18232 .into_iter().map(|x| x.0).collect())
18233 ;
18234 }
18235 GeneratedField::StreamScanType => {
18236 if stream_scan_type__.is_some() {
18237 return Err(serde::de::Error::duplicate_field("streamScanType"));
18238 }
18239 stream_scan_type__ = Some(map_.next_value::<StreamScanType>()? as i32);
18240 }
18241 GeneratedField::StateTable => {
18242 if state_table__.is_some() {
18243 return Err(serde::de::Error::duplicate_field("stateTable"));
18244 }
18245 state_table__ = map_.next_value()?;
18246 }
18247 GeneratedField::TableDesc => {
18248 if table_desc__.is_some() {
18249 return Err(serde::de::Error::duplicate_field("tableDesc"));
18250 }
18251 table_desc__ = map_.next_value()?;
18252 }
18253 GeneratedField::RateLimit => {
18254 if rate_limit__.is_some() {
18255 return Err(serde::de::Error::duplicate_field("rateLimit"));
18256 }
18257 rate_limit__ =
18258 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18259 ;
18260 }
18261 GeneratedField::SnapshotReadBarrierInterval => {
18262 if snapshot_read_barrier_interval__.is_some() {
18263 return Err(serde::de::Error::duplicate_field("snapshotReadBarrierInterval"));
18264 }
18265 snapshot_read_barrier_interval__ =
18266 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18267 ;
18268 }
18269 GeneratedField::ArrangementTable => {
18270 if arrangement_table__.is_some() {
18271 return Err(serde::de::Error::duplicate_field("arrangementTable"));
18272 }
18273 arrangement_table__ = map_.next_value()?;
18274 }
18275 GeneratedField::SnapshotBackfillEpoch => {
18276 if snapshot_backfill_epoch__.is_some() {
18277 return Err(serde::de::Error::duplicate_field("snapshotBackfillEpoch"));
18278 }
18279 snapshot_backfill_epoch__ =
18280 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18281 ;
18282 }
18283 GeneratedField::PkScanRange => {
18284 if pk_scan_range__.is_some() {
18285 return Err(serde::de::Error::duplicate_field("pkScanRange"));
18286 }
18287 pk_scan_range__ = map_.next_value()?;
18288 }
18289 }
18290 }
18291 Ok(StreamScanNode {
18292 table_id: table_id__.unwrap_or_default(),
18293 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
18294 output_indices: output_indices__.unwrap_or_default(),
18295 stream_scan_type: stream_scan_type__.unwrap_or_default(),
18296 state_table: state_table__,
18297 table_desc: table_desc__,
18298 rate_limit: rate_limit__,
18299 snapshot_read_barrier_interval: snapshot_read_barrier_interval__.unwrap_or_default(),
18300 arrangement_table: arrangement_table__,
18301 snapshot_backfill_epoch: snapshot_backfill_epoch__,
18302 pk_scan_range: pk_scan_range__,
18303 })
18304 }
18305 }
18306 deserializer.deserialize_struct("stream_plan.StreamScanNode", FIELDS, GeneratedVisitor)
18307 }
18308}
18309impl serde::Serialize for StreamScanType {
18310 #[allow(deprecated)]
18311 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18312 where
18313 S: serde::Serializer,
18314 {
18315 let variant = match self {
18316 Self::Unspecified => "STREAM_SCAN_TYPE_UNSPECIFIED",
18317 Self::Chain => "STREAM_SCAN_TYPE_CHAIN",
18318 Self::Rearrange => "STREAM_SCAN_TYPE_REARRANGE",
18319 Self::Backfill => "STREAM_SCAN_TYPE_BACKFILL",
18320 Self::UpstreamOnly => "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
18321 Self::ArrangementBackfill => "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
18322 Self::SnapshotBackfill => "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
18323 Self::CrossDbSnapshotBackfill => "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
18324 };
18325 serializer.serialize_str(variant)
18326 }
18327}
18328impl<'de> serde::Deserialize<'de> for StreamScanType {
18329 #[allow(deprecated)]
18330 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18331 where
18332 D: serde::Deserializer<'de>,
18333 {
18334 const FIELDS: &[&str] = &[
18335 "STREAM_SCAN_TYPE_UNSPECIFIED",
18336 "STREAM_SCAN_TYPE_CHAIN",
18337 "STREAM_SCAN_TYPE_REARRANGE",
18338 "STREAM_SCAN_TYPE_BACKFILL",
18339 "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
18340 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
18341 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
18342 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
18343 ];
18344
18345 struct GeneratedVisitor;
18346
18347 impl serde::de::Visitor<'_> for GeneratedVisitor {
18348 type Value = StreamScanType;
18349
18350 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18351 write!(formatter, "expected one of: {:?}", &FIELDS)
18352 }
18353
18354 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
18355 where
18356 E: serde::de::Error,
18357 {
18358 i32::try_from(v)
18359 .ok()
18360 .and_then(|x| x.try_into().ok())
18361 .ok_or_else(|| {
18362 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
18363 })
18364 }
18365
18366 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
18367 where
18368 E: serde::de::Error,
18369 {
18370 i32::try_from(v)
18371 .ok()
18372 .and_then(|x| x.try_into().ok())
18373 .ok_or_else(|| {
18374 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
18375 })
18376 }
18377
18378 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
18379 where
18380 E: serde::de::Error,
18381 {
18382 match value {
18383 "STREAM_SCAN_TYPE_UNSPECIFIED" => Ok(StreamScanType::Unspecified),
18384 "STREAM_SCAN_TYPE_CHAIN" => Ok(StreamScanType::Chain),
18385 "STREAM_SCAN_TYPE_REARRANGE" => Ok(StreamScanType::Rearrange),
18386 "STREAM_SCAN_TYPE_BACKFILL" => Ok(StreamScanType::Backfill),
18387 "STREAM_SCAN_TYPE_UPSTREAM_ONLY" => Ok(StreamScanType::UpstreamOnly),
18388 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL" => Ok(StreamScanType::ArrangementBackfill),
18389 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL" => Ok(StreamScanType::SnapshotBackfill),
18390 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL" => Ok(StreamScanType::CrossDbSnapshotBackfill),
18391 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
18392 }
18393 }
18394 }
18395 deserializer.deserialize_any(GeneratedVisitor)
18396 }
18397}
18398impl serde::Serialize for StreamSource {
18399 #[allow(deprecated)]
18400 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18401 where
18402 S: serde::Serializer,
18403 {
18404 use serde::ser::SerializeStruct;
18405 let mut len = 0;
18406 if self.source_id != 0 {
18407 len += 1;
18408 }
18409 if self.state_table.is_some() {
18410 len += 1;
18411 }
18412 if self.row_id_index.is_some() {
18413 len += 1;
18414 }
18415 if !self.columns.is_empty() {
18416 len += 1;
18417 }
18418 if !self.with_properties.is_empty() {
18419 len += 1;
18420 }
18421 if self.info.is_some() {
18422 len += 1;
18423 }
18424 if !self.source_name.is_empty() {
18425 len += 1;
18426 }
18427 if self.rate_limit.is_some() {
18428 len += 1;
18429 }
18430 if !self.secret_refs.is_empty() {
18431 len += 1;
18432 }
18433 if self.downstream_columns.is_some() {
18434 len += 1;
18435 }
18436 if self.refresh_mode.is_some() {
18437 len += 1;
18438 }
18439 if self.associated_table_id.is_some() {
18440 len += 1;
18441 }
18442 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamSource", len)?;
18443 if self.source_id != 0 {
18444 struct_ser.serialize_field("sourceId", &self.source_id)?;
18445 }
18446 if let Some(v) = self.state_table.as_ref() {
18447 struct_ser.serialize_field("stateTable", v)?;
18448 }
18449 if let Some(v) = self.row_id_index.as_ref() {
18450 struct_ser.serialize_field("rowIdIndex", v)?;
18451 }
18452 if !self.columns.is_empty() {
18453 struct_ser.serialize_field("columns", &self.columns)?;
18454 }
18455 if !self.with_properties.is_empty() {
18456 struct_ser.serialize_field("withProperties", &self.with_properties)?;
18457 }
18458 if let Some(v) = self.info.as_ref() {
18459 struct_ser.serialize_field("info", v)?;
18460 }
18461 if !self.source_name.is_empty() {
18462 struct_ser.serialize_field("sourceName", &self.source_name)?;
18463 }
18464 if let Some(v) = self.rate_limit.as_ref() {
18465 struct_ser.serialize_field("rateLimit", v)?;
18466 }
18467 if !self.secret_refs.is_empty() {
18468 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
18469 }
18470 if let Some(v) = self.downstream_columns.as_ref() {
18471 struct_ser.serialize_field("downstreamColumns", v)?;
18472 }
18473 if let Some(v) = self.refresh_mode.as_ref() {
18474 struct_ser.serialize_field("refreshMode", v)?;
18475 }
18476 if let Some(v) = self.associated_table_id.as_ref() {
18477 struct_ser.serialize_field("associatedTableId", v)?;
18478 }
18479 struct_ser.end()
18480 }
18481}
18482impl<'de> serde::Deserialize<'de> for StreamSource {
18483 #[allow(deprecated)]
18484 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18485 where
18486 D: serde::Deserializer<'de>,
18487 {
18488 const FIELDS: &[&str] = &[
18489 "source_id",
18490 "sourceId",
18491 "state_table",
18492 "stateTable",
18493 "row_id_index",
18494 "rowIdIndex",
18495 "columns",
18496 "with_properties",
18497 "withProperties",
18498 "info",
18499 "source_name",
18500 "sourceName",
18501 "rate_limit",
18502 "rateLimit",
18503 "secret_refs",
18504 "secretRefs",
18505 "downstream_columns",
18506 "downstreamColumns",
18507 "refresh_mode",
18508 "refreshMode",
18509 "associated_table_id",
18510 "associatedTableId",
18511 ];
18512
18513 #[allow(clippy::enum_variant_names)]
18514 enum GeneratedField {
18515 SourceId,
18516 StateTable,
18517 RowIdIndex,
18518 Columns,
18519 WithProperties,
18520 Info,
18521 SourceName,
18522 RateLimit,
18523 SecretRefs,
18524 DownstreamColumns,
18525 RefreshMode,
18526 AssociatedTableId,
18527 }
18528 impl<'de> serde::Deserialize<'de> for GeneratedField {
18529 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18530 where
18531 D: serde::Deserializer<'de>,
18532 {
18533 struct GeneratedVisitor;
18534
18535 impl serde::de::Visitor<'_> for GeneratedVisitor {
18536 type Value = GeneratedField;
18537
18538 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18539 write!(formatter, "expected one of: {:?}", &FIELDS)
18540 }
18541
18542 #[allow(unused_variables)]
18543 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18544 where
18545 E: serde::de::Error,
18546 {
18547 match value {
18548 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
18549 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
18550 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
18551 "columns" => Ok(GeneratedField::Columns),
18552 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
18553 "info" => Ok(GeneratedField::Info),
18554 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
18555 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
18556 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
18557 "downstreamColumns" | "downstream_columns" => Ok(GeneratedField::DownstreamColumns),
18558 "refreshMode" | "refresh_mode" => Ok(GeneratedField::RefreshMode),
18559 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
18560 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18561 }
18562 }
18563 }
18564 deserializer.deserialize_identifier(GeneratedVisitor)
18565 }
18566 }
18567 struct GeneratedVisitor;
18568 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18569 type Value = StreamSource;
18570
18571 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18572 formatter.write_str("struct stream_plan.StreamSource")
18573 }
18574
18575 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSource, V::Error>
18576 where
18577 V: serde::de::MapAccess<'de>,
18578 {
18579 let mut source_id__ = None;
18580 let mut state_table__ = None;
18581 let mut row_id_index__ = None;
18582 let mut columns__ = None;
18583 let mut with_properties__ = None;
18584 let mut info__ = None;
18585 let mut source_name__ = None;
18586 let mut rate_limit__ = None;
18587 let mut secret_refs__ = None;
18588 let mut downstream_columns__ = None;
18589 let mut refresh_mode__ = None;
18590 let mut associated_table_id__ = None;
18591 while let Some(k) = map_.next_key()? {
18592 match k {
18593 GeneratedField::SourceId => {
18594 if source_id__.is_some() {
18595 return Err(serde::de::Error::duplicate_field("sourceId"));
18596 }
18597 source_id__ =
18598 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18599 ;
18600 }
18601 GeneratedField::StateTable => {
18602 if state_table__.is_some() {
18603 return Err(serde::de::Error::duplicate_field("stateTable"));
18604 }
18605 state_table__ = map_.next_value()?;
18606 }
18607 GeneratedField::RowIdIndex => {
18608 if row_id_index__.is_some() {
18609 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
18610 }
18611 row_id_index__ =
18612 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18613 ;
18614 }
18615 GeneratedField::Columns => {
18616 if columns__.is_some() {
18617 return Err(serde::de::Error::duplicate_field("columns"));
18618 }
18619 columns__ = Some(map_.next_value()?);
18620 }
18621 GeneratedField::WithProperties => {
18622 if with_properties__.is_some() {
18623 return Err(serde::de::Error::duplicate_field("withProperties"));
18624 }
18625 with_properties__ = Some(
18626 map_.next_value::<std::collections::BTreeMap<_, _>>()?
18627 );
18628 }
18629 GeneratedField::Info => {
18630 if info__.is_some() {
18631 return Err(serde::de::Error::duplicate_field("info"));
18632 }
18633 info__ = map_.next_value()?;
18634 }
18635 GeneratedField::SourceName => {
18636 if source_name__.is_some() {
18637 return Err(serde::de::Error::duplicate_field("sourceName"));
18638 }
18639 source_name__ = Some(map_.next_value()?);
18640 }
18641 GeneratedField::RateLimit => {
18642 if rate_limit__.is_some() {
18643 return Err(serde::de::Error::duplicate_field("rateLimit"));
18644 }
18645 rate_limit__ =
18646 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18647 ;
18648 }
18649 GeneratedField::SecretRefs => {
18650 if secret_refs__.is_some() {
18651 return Err(serde::de::Error::duplicate_field("secretRefs"));
18652 }
18653 secret_refs__ = Some(
18654 map_.next_value::<std::collections::BTreeMap<_, _>>()?
18655 );
18656 }
18657 GeneratedField::DownstreamColumns => {
18658 if downstream_columns__.is_some() {
18659 return Err(serde::de::Error::duplicate_field("downstreamColumns"));
18660 }
18661 downstream_columns__ = map_.next_value()?;
18662 }
18663 GeneratedField::RefreshMode => {
18664 if refresh_mode__.is_some() {
18665 return Err(serde::de::Error::duplicate_field("refreshMode"));
18666 }
18667 refresh_mode__ = map_.next_value()?;
18668 }
18669 GeneratedField::AssociatedTableId => {
18670 if associated_table_id__.is_some() {
18671 return Err(serde::de::Error::duplicate_field("associatedTableId"));
18672 }
18673 associated_table_id__ =
18674 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18675 ;
18676 }
18677 }
18678 }
18679 Ok(StreamSource {
18680 source_id: source_id__.unwrap_or_default(),
18681 state_table: state_table__,
18682 row_id_index: row_id_index__,
18683 columns: columns__.unwrap_or_default(),
18684 with_properties: with_properties__.unwrap_or_default(),
18685 info: info__,
18686 source_name: source_name__.unwrap_or_default(),
18687 rate_limit: rate_limit__,
18688 secret_refs: secret_refs__.unwrap_or_default(),
18689 downstream_columns: downstream_columns__,
18690 refresh_mode: refresh_mode__,
18691 associated_table_id: associated_table_id__,
18692 })
18693 }
18694 }
18695 deserializer.deserialize_struct("stream_plan.StreamSource", FIELDS, GeneratedVisitor)
18696 }
18697}
18698impl serde::Serialize for SubscriptionUpstreamInfo {
18699 #[allow(deprecated)]
18700 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18701 where
18702 S: serde::Serializer,
18703 {
18704 use serde::ser::SerializeStruct;
18705 let mut len = 0;
18706 if self.subscriber_id != 0 {
18707 len += 1;
18708 }
18709 if self.upstream_mv_table_id != 0 {
18710 len += 1;
18711 }
18712 let mut struct_ser = serializer.serialize_struct("stream_plan.SubscriptionUpstreamInfo", len)?;
18713 if self.subscriber_id != 0 {
18714 struct_ser.serialize_field("subscriberId", &self.subscriber_id)?;
18715 }
18716 if self.upstream_mv_table_id != 0 {
18717 struct_ser.serialize_field("upstreamMvTableId", &self.upstream_mv_table_id)?;
18718 }
18719 struct_ser.end()
18720 }
18721}
18722impl<'de> serde::Deserialize<'de> for SubscriptionUpstreamInfo {
18723 #[allow(deprecated)]
18724 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18725 where
18726 D: serde::Deserializer<'de>,
18727 {
18728 const FIELDS: &[&str] = &[
18729 "subscriber_id",
18730 "subscriberId",
18731 "upstream_mv_table_id",
18732 "upstreamMvTableId",
18733 ];
18734
18735 #[allow(clippy::enum_variant_names)]
18736 enum GeneratedField {
18737 SubscriberId,
18738 UpstreamMvTableId,
18739 }
18740 impl<'de> serde::Deserialize<'de> for GeneratedField {
18741 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18742 where
18743 D: serde::Deserializer<'de>,
18744 {
18745 struct GeneratedVisitor;
18746
18747 impl serde::de::Visitor<'_> for GeneratedVisitor {
18748 type Value = GeneratedField;
18749
18750 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18751 write!(formatter, "expected one of: {:?}", &FIELDS)
18752 }
18753
18754 #[allow(unused_variables)]
18755 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18756 where
18757 E: serde::de::Error,
18758 {
18759 match value {
18760 "subscriberId" | "subscriber_id" => Ok(GeneratedField::SubscriberId),
18761 "upstreamMvTableId" | "upstream_mv_table_id" => Ok(GeneratedField::UpstreamMvTableId),
18762 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18763 }
18764 }
18765 }
18766 deserializer.deserialize_identifier(GeneratedVisitor)
18767 }
18768 }
18769 struct GeneratedVisitor;
18770 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18771 type Value = SubscriptionUpstreamInfo;
18772
18773 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18774 formatter.write_str("struct stream_plan.SubscriptionUpstreamInfo")
18775 }
18776
18777 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscriptionUpstreamInfo, V::Error>
18778 where
18779 V: serde::de::MapAccess<'de>,
18780 {
18781 let mut subscriber_id__ = None;
18782 let mut upstream_mv_table_id__ = None;
18783 while let Some(k) = map_.next_key()? {
18784 match k {
18785 GeneratedField::SubscriberId => {
18786 if subscriber_id__.is_some() {
18787 return Err(serde::de::Error::duplicate_field("subscriberId"));
18788 }
18789 subscriber_id__ =
18790 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18791 ;
18792 }
18793 GeneratedField::UpstreamMvTableId => {
18794 if upstream_mv_table_id__.is_some() {
18795 return Err(serde::de::Error::duplicate_field("upstreamMvTableId"));
18796 }
18797 upstream_mv_table_id__ =
18798 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18799 ;
18800 }
18801 }
18802 }
18803 Ok(SubscriptionUpstreamInfo {
18804 subscriber_id: subscriber_id__.unwrap_or_default(),
18805 upstream_mv_table_id: upstream_mv_table_id__.unwrap_or_default(),
18806 })
18807 }
18808 }
18809 deserializer.deserialize_struct("stream_plan.SubscriptionUpstreamInfo", FIELDS, GeneratedVisitor)
18810 }
18811}
18812impl serde::Serialize for SyncLogStoreNode {
18813 #[allow(deprecated)]
18814 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18815 where
18816 S: serde::Serializer,
18817 {
18818 use serde::ser::SerializeStruct;
18819 let mut len = 0;
18820 if self.log_store_table.is_some() {
18821 len += 1;
18822 }
18823 if self.pause_duration_ms.is_some() {
18824 len += 1;
18825 }
18826 if self.buffer_size.is_some() {
18827 len += 1;
18828 }
18829 if self.aligned {
18830 len += 1;
18831 }
18832 let mut struct_ser = serializer.serialize_struct("stream_plan.SyncLogStoreNode", len)?;
18833 if let Some(v) = self.log_store_table.as_ref() {
18834 struct_ser.serialize_field("logStoreTable", v)?;
18835 }
18836 if let Some(v) = self.pause_duration_ms.as_ref() {
18837 struct_ser.serialize_field("pauseDurationMs", v)?;
18838 }
18839 if let Some(v) = self.buffer_size.as_ref() {
18840 struct_ser.serialize_field("bufferSize", v)?;
18841 }
18842 if self.aligned {
18843 struct_ser.serialize_field("aligned", &self.aligned)?;
18844 }
18845 struct_ser.end()
18846 }
18847}
18848impl<'de> serde::Deserialize<'de> for SyncLogStoreNode {
18849 #[allow(deprecated)]
18850 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18851 where
18852 D: serde::Deserializer<'de>,
18853 {
18854 const FIELDS: &[&str] = &[
18855 "log_store_table",
18856 "logStoreTable",
18857 "pause_duration_ms",
18858 "pauseDurationMs",
18859 "buffer_size",
18860 "bufferSize",
18861 "aligned",
18862 ];
18863
18864 #[allow(clippy::enum_variant_names)]
18865 enum GeneratedField {
18866 LogStoreTable,
18867 PauseDurationMs,
18868 BufferSize,
18869 Aligned,
18870 }
18871 impl<'de> serde::Deserialize<'de> for GeneratedField {
18872 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18873 where
18874 D: serde::Deserializer<'de>,
18875 {
18876 struct GeneratedVisitor;
18877
18878 impl serde::de::Visitor<'_> for GeneratedVisitor {
18879 type Value = GeneratedField;
18880
18881 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18882 write!(formatter, "expected one of: {:?}", &FIELDS)
18883 }
18884
18885 #[allow(unused_variables)]
18886 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18887 where
18888 E: serde::de::Error,
18889 {
18890 match value {
18891 "logStoreTable" | "log_store_table" => Ok(GeneratedField::LogStoreTable),
18892 "pauseDurationMs" | "pause_duration_ms" => Ok(GeneratedField::PauseDurationMs),
18893 "bufferSize" | "buffer_size" => Ok(GeneratedField::BufferSize),
18894 "aligned" => Ok(GeneratedField::Aligned),
18895 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18896 }
18897 }
18898 }
18899 deserializer.deserialize_identifier(GeneratedVisitor)
18900 }
18901 }
18902 struct GeneratedVisitor;
18903 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18904 type Value = SyncLogStoreNode;
18905
18906 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18907 formatter.write_str("struct stream_plan.SyncLogStoreNode")
18908 }
18909
18910 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SyncLogStoreNode, V::Error>
18911 where
18912 V: serde::de::MapAccess<'de>,
18913 {
18914 let mut log_store_table__ = None;
18915 let mut pause_duration_ms__ = None;
18916 let mut buffer_size__ = None;
18917 let mut aligned__ = None;
18918 while let Some(k) = map_.next_key()? {
18919 match k {
18920 GeneratedField::LogStoreTable => {
18921 if log_store_table__.is_some() {
18922 return Err(serde::de::Error::duplicate_field("logStoreTable"));
18923 }
18924 log_store_table__ = map_.next_value()?;
18925 }
18926 GeneratedField::PauseDurationMs => {
18927 if pause_duration_ms__.is_some() {
18928 return Err(serde::de::Error::duplicate_field("pauseDurationMs"));
18929 }
18930 pause_duration_ms__ =
18931 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18932 ;
18933 }
18934 GeneratedField::BufferSize => {
18935 if buffer_size__.is_some() {
18936 return Err(serde::de::Error::duplicate_field("bufferSize"));
18937 }
18938 buffer_size__ =
18939 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
18940 ;
18941 }
18942 GeneratedField::Aligned => {
18943 if aligned__.is_some() {
18944 return Err(serde::de::Error::duplicate_field("aligned"));
18945 }
18946 aligned__ = Some(map_.next_value()?);
18947 }
18948 }
18949 }
18950 Ok(SyncLogStoreNode {
18951 log_store_table: log_store_table__,
18952 pause_duration_ms: pause_duration_ms__,
18953 buffer_size: buffer_size__,
18954 aligned: aligned__.unwrap_or_default(),
18955 })
18956 }
18957 }
18958 deserializer.deserialize_struct("stream_plan.SyncLogStoreNode", FIELDS, GeneratedVisitor)
18959 }
18960}
18961impl serde::Serialize for TemporalJoinNode {
18962 #[allow(deprecated)]
18963 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18964 where
18965 S: serde::Serializer,
18966 {
18967 use serde::ser::SerializeStruct;
18968 let mut len = 0;
18969 if self.join_type != 0 {
18970 len += 1;
18971 }
18972 if !self.left_key.is_empty() {
18973 len += 1;
18974 }
18975 if !self.right_key.is_empty() {
18976 len += 1;
18977 }
18978 if !self.null_safe.is_empty() {
18979 len += 1;
18980 }
18981 if self.condition.is_some() {
18982 len += 1;
18983 }
18984 if !self.output_indices.is_empty() {
18985 len += 1;
18986 }
18987 if self.table_desc.is_some() {
18988 len += 1;
18989 }
18990 if !self.table_output_indices.is_empty() {
18991 len += 1;
18992 }
18993 if self.memo_table.is_some() {
18994 len += 1;
18995 }
18996 if self.is_nested_loop {
18997 len += 1;
18998 }
18999 if self.is_broadcast {
19000 len += 1;
19001 }
19002 let mut struct_ser = serializer.serialize_struct("stream_plan.TemporalJoinNode", len)?;
19003 if self.join_type != 0 {
19004 let v = super::plan_common::JoinType::try_from(self.join_type)
19005 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
19006 struct_ser.serialize_field("joinType", &v)?;
19007 }
19008 if !self.left_key.is_empty() {
19009 struct_ser.serialize_field("leftKey", &self.left_key)?;
19010 }
19011 if !self.right_key.is_empty() {
19012 struct_ser.serialize_field("rightKey", &self.right_key)?;
19013 }
19014 if !self.null_safe.is_empty() {
19015 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
19016 }
19017 if let Some(v) = self.condition.as_ref() {
19018 struct_ser.serialize_field("condition", v)?;
19019 }
19020 if !self.output_indices.is_empty() {
19021 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
19022 }
19023 if let Some(v) = self.table_desc.as_ref() {
19024 struct_ser.serialize_field("tableDesc", v)?;
19025 }
19026 if !self.table_output_indices.is_empty() {
19027 struct_ser.serialize_field("tableOutputIndices", &self.table_output_indices)?;
19028 }
19029 if let Some(v) = self.memo_table.as_ref() {
19030 struct_ser.serialize_field("memoTable", v)?;
19031 }
19032 if self.is_nested_loop {
19033 struct_ser.serialize_field("isNestedLoop", &self.is_nested_loop)?;
19034 }
19035 if self.is_broadcast {
19036 struct_ser.serialize_field("isBroadcast", &self.is_broadcast)?;
19037 }
19038 struct_ser.end()
19039 }
19040}
19041impl<'de> serde::Deserialize<'de> for TemporalJoinNode {
19042 #[allow(deprecated)]
19043 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19044 where
19045 D: serde::Deserializer<'de>,
19046 {
19047 const FIELDS: &[&str] = &[
19048 "join_type",
19049 "joinType",
19050 "left_key",
19051 "leftKey",
19052 "right_key",
19053 "rightKey",
19054 "null_safe",
19055 "nullSafe",
19056 "condition",
19057 "output_indices",
19058 "outputIndices",
19059 "table_desc",
19060 "tableDesc",
19061 "table_output_indices",
19062 "tableOutputIndices",
19063 "memo_table",
19064 "memoTable",
19065 "is_nested_loop",
19066 "isNestedLoop",
19067 "is_broadcast",
19068 "isBroadcast",
19069 ];
19070
19071 #[allow(clippy::enum_variant_names)]
19072 enum GeneratedField {
19073 JoinType,
19074 LeftKey,
19075 RightKey,
19076 NullSafe,
19077 Condition,
19078 OutputIndices,
19079 TableDesc,
19080 TableOutputIndices,
19081 MemoTable,
19082 IsNestedLoop,
19083 IsBroadcast,
19084 }
19085 impl<'de> serde::Deserialize<'de> for GeneratedField {
19086 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19087 where
19088 D: serde::Deserializer<'de>,
19089 {
19090 struct GeneratedVisitor;
19091
19092 impl serde::de::Visitor<'_> for GeneratedVisitor {
19093 type Value = GeneratedField;
19094
19095 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19096 write!(formatter, "expected one of: {:?}", &FIELDS)
19097 }
19098
19099 #[allow(unused_variables)]
19100 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19101 where
19102 E: serde::de::Error,
19103 {
19104 match value {
19105 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
19106 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
19107 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
19108 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
19109 "condition" => Ok(GeneratedField::Condition),
19110 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
19111 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
19112 "tableOutputIndices" | "table_output_indices" => Ok(GeneratedField::TableOutputIndices),
19113 "memoTable" | "memo_table" => Ok(GeneratedField::MemoTable),
19114 "isNestedLoop" | "is_nested_loop" => Ok(GeneratedField::IsNestedLoop),
19115 "isBroadcast" | "is_broadcast" => Ok(GeneratedField::IsBroadcast),
19116 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19117 }
19118 }
19119 }
19120 deserializer.deserialize_identifier(GeneratedVisitor)
19121 }
19122 }
19123 struct GeneratedVisitor;
19124 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19125 type Value = TemporalJoinNode;
19126
19127 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19128 formatter.write_str("struct stream_plan.TemporalJoinNode")
19129 }
19130
19131 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TemporalJoinNode, V::Error>
19132 where
19133 V: serde::de::MapAccess<'de>,
19134 {
19135 let mut join_type__ = None;
19136 let mut left_key__ = None;
19137 let mut right_key__ = None;
19138 let mut null_safe__ = None;
19139 let mut condition__ = None;
19140 let mut output_indices__ = None;
19141 let mut table_desc__ = None;
19142 let mut table_output_indices__ = None;
19143 let mut memo_table__ = None;
19144 let mut is_nested_loop__ = None;
19145 let mut is_broadcast__ = None;
19146 while let Some(k) = map_.next_key()? {
19147 match k {
19148 GeneratedField::JoinType => {
19149 if join_type__.is_some() {
19150 return Err(serde::de::Error::duplicate_field("joinType"));
19151 }
19152 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
19153 }
19154 GeneratedField::LeftKey => {
19155 if left_key__.is_some() {
19156 return Err(serde::de::Error::duplicate_field("leftKey"));
19157 }
19158 left_key__ =
19159 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
19160 .into_iter().map(|x| x.0).collect())
19161 ;
19162 }
19163 GeneratedField::RightKey => {
19164 if right_key__.is_some() {
19165 return Err(serde::de::Error::duplicate_field("rightKey"));
19166 }
19167 right_key__ =
19168 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
19169 .into_iter().map(|x| x.0).collect())
19170 ;
19171 }
19172 GeneratedField::NullSafe => {
19173 if null_safe__.is_some() {
19174 return Err(serde::de::Error::duplicate_field("nullSafe"));
19175 }
19176 null_safe__ = Some(map_.next_value()?);
19177 }
19178 GeneratedField::Condition => {
19179 if condition__.is_some() {
19180 return Err(serde::de::Error::duplicate_field("condition"));
19181 }
19182 condition__ = map_.next_value()?;
19183 }
19184 GeneratedField::OutputIndices => {
19185 if output_indices__.is_some() {
19186 return Err(serde::de::Error::duplicate_field("outputIndices"));
19187 }
19188 output_indices__ =
19189 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
19190 .into_iter().map(|x| x.0).collect())
19191 ;
19192 }
19193 GeneratedField::TableDesc => {
19194 if table_desc__.is_some() {
19195 return Err(serde::de::Error::duplicate_field("tableDesc"));
19196 }
19197 table_desc__ = map_.next_value()?;
19198 }
19199 GeneratedField::TableOutputIndices => {
19200 if table_output_indices__.is_some() {
19201 return Err(serde::de::Error::duplicate_field("tableOutputIndices"));
19202 }
19203 table_output_indices__ =
19204 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
19205 .into_iter().map(|x| x.0).collect())
19206 ;
19207 }
19208 GeneratedField::MemoTable => {
19209 if memo_table__.is_some() {
19210 return Err(serde::de::Error::duplicate_field("memoTable"));
19211 }
19212 memo_table__ = map_.next_value()?;
19213 }
19214 GeneratedField::IsNestedLoop => {
19215 if is_nested_loop__.is_some() {
19216 return Err(serde::de::Error::duplicate_field("isNestedLoop"));
19217 }
19218 is_nested_loop__ = Some(map_.next_value()?);
19219 }
19220 GeneratedField::IsBroadcast => {
19221 if is_broadcast__.is_some() {
19222 return Err(serde::de::Error::duplicate_field("isBroadcast"));
19223 }
19224 is_broadcast__ = Some(map_.next_value()?);
19225 }
19226 }
19227 }
19228 Ok(TemporalJoinNode {
19229 join_type: join_type__.unwrap_or_default(),
19230 left_key: left_key__.unwrap_or_default(),
19231 right_key: right_key__.unwrap_or_default(),
19232 null_safe: null_safe__.unwrap_or_default(),
19233 condition: condition__,
19234 output_indices: output_indices__.unwrap_or_default(),
19235 table_desc: table_desc__,
19236 table_output_indices: table_output_indices__.unwrap_or_default(),
19237 memo_table: memo_table__,
19238 is_nested_loop: is_nested_loop__.unwrap_or_default(),
19239 is_broadcast: is_broadcast__.unwrap_or_default(),
19240 })
19241 }
19242 }
19243 deserializer.deserialize_struct("stream_plan.TemporalJoinNode", FIELDS, GeneratedVisitor)
19244 }
19245}
19246impl serde::Serialize for ThrottleMutation {
19247 #[allow(deprecated)]
19248 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19249 where
19250 S: serde::Serializer,
19251 {
19252 use serde::ser::SerializeStruct;
19253 let mut len = 0;
19254 if !self.fragment_throttle.is_empty() {
19255 len += 1;
19256 }
19257 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation", len)?;
19258 if !self.fragment_throttle.is_empty() {
19259 struct_ser.serialize_field("fragmentThrottle", &self.fragment_throttle)?;
19260 }
19261 struct_ser.end()
19262 }
19263}
19264impl<'de> serde::Deserialize<'de> for ThrottleMutation {
19265 #[allow(deprecated)]
19266 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19267 where
19268 D: serde::Deserializer<'de>,
19269 {
19270 const FIELDS: &[&str] = &[
19271 "fragment_throttle",
19272 "fragmentThrottle",
19273 ];
19274
19275 #[allow(clippy::enum_variant_names)]
19276 enum GeneratedField {
19277 FragmentThrottle,
19278 }
19279 impl<'de> serde::Deserialize<'de> for GeneratedField {
19280 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19281 where
19282 D: serde::Deserializer<'de>,
19283 {
19284 struct GeneratedVisitor;
19285
19286 impl serde::de::Visitor<'_> for GeneratedVisitor {
19287 type Value = GeneratedField;
19288
19289 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19290 write!(formatter, "expected one of: {:?}", &FIELDS)
19291 }
19292
19293 #[allow(unused_variables)]
19294 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19295 where
19296 E: serde::de::Error,
19297 {
19298 match value {
19299 "fragmentThrottle" | "fragment_throttle" => Ok(GeneratedField::FragmentThrottle),
19300 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19301 }
19302 }
19303 }
19304 deserializer.deserialize_identifier(GeneratedVisitor)
19305 }
19306 }
19307 struct GeneratedVisitor;
19308 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19309 type Value = ThrottleMutation;
19310
19311 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19312 formatter.write_str("struct stream_plan.ThrottleMutation")
19313 }
19314
19315 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ThrottleMutation, V::Error>
19316 where
19317 V: serde::de::MapAccess<'de>,
19318 {
19319 let mut fragment_throttle__ = None;
19320 while let Some(k) = map_.next_key()? {
19321 match k {
19322 GeneratedField::FragmentThrottle => {
19323 if fragment_throttle__.is_some() {
19324 return Err(serde::de::Error::duplicate_field("fragmentThrottle"));
19325 }
19326 fragment_throttle__ = Some(
19327 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
19328 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
19329 );
19330 }
19331 }
19332 }
19333 Ok(ThrottleMutation {
19334 fragment_throttle: fragment_throttle__.unwrap_or_default(),
19335 })
19336 }
19337 }
19338 deserializer.deserialize_struct("stream_plan.ThrottleMutation", FIELDS, GeneratedVisitor)
19339 }
19340}
19341impl serde::Serialize for throttle_mutation::ThrottleConfig {
19342 #[allow(deprecated)]
19343 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19344 where
19345 S: serde::Serializer,
19346 {
19347 use serde::ser::SerializeStruct;
19348 let mut len = 0;
19349 if self.rate_limit.is_some() {
19350 len += 1;
19351 }
19352 if self.throttle_type != 0 {
19353 len += 1;
19354 }
19355 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation.ThrottleConfig", len)?;
19356 if let Some(v) = self.rate_limit.as_ref() {
19357 struct_ser.serialize_field("rateLimit", v)?;
19358 }
19359 if self.throttle_type != 0 {
19360 let v = super::common::ThrottleType::try_from(self.throttle_type)
19361 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.throttle_type)))?;
19362 struct_ser.serialize_field("throttleType", &v)?;
19363 }
19364 struct_ser.end()
19365 }
19366}
19367impl<'de> serde::Deserialize<'de> for throttle_mutation::ThrottleConfig {
19368 #[allow(deprecated)]
19369 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19370 where
19371 D: serde::Deserializer<'de>,
19372 {
19373 const FIELDS: &[&str] = &[
19374 "rate_limit",
19375 "rateLimit",
19376 "throttle_type",
19377 "throttleType",
19378 ];
19379
19380 #[allow(clippy::enum_variant_names)]
19381 enum GeneratedField {
19382 RateLimit,
19383 ThrottleType,
19384 }
19385 impl<'de> serde::Deserialize<'de> for GeneratedField {
19386 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19387 where
19388 D: serde::Deserializer<'de>,
19389 {
19390 struct GeneratedVisitor;
19391
19392 impl serde::de::Visitor<'_> for GeneratedVisitor {
19393 type Value = GeneratedField;
19394
19395 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19396 write!(formatter, "expected one of: {:?}", &FIELDS)
19397 }
19398
19399 #[allow(unused_variables)]
19400 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19401 where
19402 E: serde::de::Error,
19403 {
19404 match value {
19405 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
19406 "throttleType" | "throttle_type" => Ok(GeneratedField::ThrottleType),
19407 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19408 }
19409 }
19410 }
19411 deserializer.deserialize_identifier(GeneratedVisitor)
19412 }
19413 }
19414 struct GeneratedVisitor;
19415 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19416 type Value = throttle_mutation::ThrottleConfig;
19417
19418 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19419 formatter.write_str("struct stream_plan.ThrottleMutation.ThrottleConfig")
19420 }
19421
19422 fn visit_map<V>(self, mut map_: V) -> std::result::Result<throttle_mutation::ThrottleConfig, V::Error>
19423 where
19424 V: serde::de::MapAccess<'de>,
19425 {
19426 let mut rate_limit__ = None;
19427 let mut throttle_type__ = None;
19428 while let Some(k) = map_.next_key()? {
19429 match k {
19430 GeneratedField::RateLimit => {
19431 if rate_limit__.is_some() {
19432 return Err(serde::de::Error::duplicate_field("rateLimit"));
19433 }
19434 rate_limit__ =
19435 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
19436 ;
19437 }
19438 GeneratedField::ThrottleType => {
19439 if throttle_type__.is_some() {
19440 return Err(serde::de::Error::duplicate_field("throttleType"));
19441 }
19442 throttle_type__ = Some(map_.next_value::<super::common::ThrottleType>()? as i32);
19443 }
19444 }
19445 }
19446 Ok(throttle_mutation::ThrottleConfig {
19447 rate_limit: rate_limit__,
19448 throttle_type: throttle_type__.unwrap_or_default(),
19449 })
19450 }
19451 }
19452 deserializer.deserialize_struct("stream_plan.ThrottleMutation.ThrottleConfig", FIELDS, GeneratedVisitor)
19453 }
19454}
19455impl serde::Serialize for TopNNode {
19456 #[allow(deprecated)]
19457 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19458 where
19459 S: serde::Serializer,
19460 {
19461 use serde::ser::SerializeStruct;
19462 let mut len = 0;
19463 if self.limit != 0 {
19464 len += 1;
19465 }
19466 if self.offset != 0 {
19467 len += 1;
19468 }
19469 if self.table.is_some() {
19470 len += 1;
19471 }
19472 if !self.order_by.is_empty() {
19473 len += 1;
19474 }
19475 if self.with_ties {
19476 len += 1;
19477 }
19478 let mut struct_ser = serializer.serialize_struct("stream_plan.TopNNode", len)?;
19479 if self.limit != 0 {
19480 #[allow(clippy::needless_borrow)]
19481 #[allow(clippy::needless_borrows_for_generic_args)]
19482 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
19483 }
19484 if self.offset != 0 {
19485 #[allow(clippy::needless_borrow)]
19486 #[allow(clippy::needless_borrows_for_generic_args)]
19487 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
19488 }
19489 if let Some(v) = self.table.as_ref() {
19490 struct_ser.serialize_field("table", v)?;
19491 }
19492 if !self.order_by.is_empty() {
19493 struct_ser.serialize_field("orderBy", &self.order_by)?;
19494 }
19495 if self.with_ties {
19496 struct_ser.serialize_field("withTies", &self.with_ties)?;
19497 }
19498 struct_ser.end()
19499 }
19500}
19501impl<'de> serde::Deserialize<'de> for TopNNode {
19502 #[allow(deprecated)]
19503 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19504 where
19505 D: serde::Deserializer<'de>,
19506 {
19507 const FIELDS: &[&str] = &[
19508 "limit",
19509 "offset",
19510 "table",
19511 "order_by",
19512 "orderBy",
19513 "with_ties",
19514 "withTies",
19515 ];
19516
19517 #[allow(clippy::enum_variant_names)]
19518 enum GeneratedField {
19519 Limit,
19520 Offset,
19521 Table,
19522 OrderBy,
19523 WithTies,
19524 }
19525 impl<'de> serde::Deserialize<'de> for GeneratedField {
19526 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19527 where
19528 D: serde::Deserializer<'de>,
19529 {
19530 struct GeneratedVisitor;
19531
19532 impl serde::de::Visitor<'_> for GeneratedVisitor {
19533 type Value = GeneratedField;
19534
19535 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19536 write!(formatter, "expected one of: {:?}", &FIELDS)
19537 }
19538
19539 #[allow(unused_variables)]
19540 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19541 where
19542 E: serde::de::Error,
19543 {
19544 match value {
19545 "limit" => Ok(GeneratedField::Limit),
19546 "offset" => Ok(GeneratedField::Offset),
19547 "table" => Ok(GeneratedField::Table),
19548 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
19549 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
19550 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19551 }
19552 }
19553 }
19554 deserializer.deserialize_identifier(GeneratedVisitor)
19555 }
19556 }
19557 struct GeneratedVisitor;
19558 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19559 type Value = TopNNode;
19560
19561 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19562 formatter.write_str("struct stream_plan.TopNNode")
19563 }
19564
19565 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
19566 where
19567 V: serde::de::MapAccess<'de>,
19568 {
19569 let mut limit__ = None;
19570 let mut offset__ = None;
19571 let mut table__ = None;
19572 let mut order_by__ = None;
19573 let mut with_ties__ = None;
19574 while let Some(k) = map_.next_key()? {
19575 match k {
19576 GeneratedField::Limit => {
19577 if limit__.is_some() {
19578 return Err(serde::de::Error::duplicate_field("limit"));
19579 }
19580 limit__ =
19581 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
19582 ;
19583 }
19584 GeneratedField::Offset => {
19585 if offset__.is_some() {
19586 return Err(serde::de::Error::duplicate_field("offset"));
19587 }
19588 offset__ =
19589 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
19590 ;
19591 }
19592 GeneratedField::Table => {
19593 if table__.is_some() {
19594 return Err(serde::de::Error::duplicate_field("table"));
19595 }
19596 table__ = map_.next_value()?;
19597 }
19598 GeneratedField::OrderBy => {
19599 if order_by__.is_some() {
19600 return Err(serde::de::Error::duplicate_field("orderBy"));
19601 }
19602 order_by__ = Some(map_.next_value()?);
19603 }
19604 GeneratedField::WithTies => {
19605 if with_ties__.is_some() {
19606 return Err(serde::de::Error::duplicate_field("withTies"));
19607 }
19608 with_ties__ = Some(map_.next_value()?);
19609 }
19610 }
19611 }
19612 Ok(TopNNode {
19613 limit: limit__.unwrap_or_default(),
19614 offset: offset__.unwrap_or_default(),
19615 table: table__,
19616 order_by: order_by__.unwrap_or_default(),
19617 with_ties: with_ties__.unwrap_or_default(),
19618 })
19619 }
19620 }
19621 deserializer.deserialize_struct("stream_plan.TopNNode", FIELDS, GeneratedVisitor)
19622 }
19623}
19624impl serde::Serialize for UnionNode {
19625 #[allow(deprecated)]
19626 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19627 where
19628 S: serde::Serializer,
19629 {
19630 use serde::ser::SerializeStruct;
19631 let len = 0;
19632 let struct_ser = serializer.serialize_struct("stream_plan.UnionNode", len)?;
19633 struct_ser.end()
19634 }
19635}
19636impl<'de> serde::Deserialize<'de> for UnionNode {
19637 #[allow(deprecated)]
19638 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19639 where
19640 D: serde::Deserializer<'de>,
19641 {
19642 const FIELDS: &[&str] = &[
19643 ];
19644
19645 #[allow(clippy::enum_variant_names)]
19646 enum GeneratedField {
19647 }
19648 impl<'de> serde::Deserialize<'de> for GeneratedField {
19649 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19650 where
19651 D: serde::Deserializer<'de>,
19652 {
19653 struct GeneratedVisitor;
19654
19655 impl serde::de::Visitor<'_> for GeneratedVisitor {
19656 type Value = GeneratedField;
19657
19658 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19659 write!(formatter, "expected one of: {:?}", &FIELDS)
19660 }
19661
19662 #[allow(unused_variables)]
19663 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19664 where
19665 E: serde::de::Error,
19666 {
19667 Err(serde::de::Error::unknown_field(value, FIELDS))
19668 }
19669 }
19670 deserializer.deserialize_identifier(GeneratedVisitor)
19671 }
19672 }
19673 struct GeneratedVisitor;
19674 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19675 type Value = UnionNode;
19676
19677 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19678 formatter.write_str("struct stream_plan.UnionNode")
19679 }
19680
19681 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
19682 where
19683 V: serde::de::MapAccess<'de>,
19684 {
19685 while map_.next_key::<GeneratedField>()?.is_some() {
19686 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
19687 }
19688 Ok(UnionNode {
19689 })
19690 }
19691 }
19692 deserializer.deserialize_struct("stream_plan.UnionNode", FIELDS, GeneratedVisitor)
19693 }
19694}
19695impl serde::Serialize for UpdateMutation {
19696 #[allow(deprecated)]
19697 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19698 where
19699 S: serde::Serializer,
19700 {
19701 use serde::ser::SerializeStruct;
19702 let mut len = 0;
19703 if !self.dispatcher_update.is_empty() {
19704 len += 1;
19705 }
19706 if !self.merge_update.is_empty() {
19707 len += 1;
19708 }
19709 if !self.actor_vnode_bitmap_update.is_empty() {
19710 len += 1;
19711 }
19712 if !self.dropped_actors.is_empty() {
19713 len += 1;
19714 }
19715 if !self.actor_splits.is_empty() {
19716 len += 1;
19717 }
19718 if !self.actor_new_dispatchers.is_empty() {
19719 len += 1;
19720 }
19721 if self.actor_cdc_table_snapshot_splits.is_some() {
19722 len += 1;
19723 }
19724 if !self.sink_schema_change.is_empty() {
19725 len += 1;
19726 }
19727 if !self.subscriptions_to_drop.is_empty() {
19728 len += 1;
19729 }
19730 if self.iceberg_pk_index_compaction.is_some() {
19731 len += 1;
19732 }
19733 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation", len)?;
19734 if !self.dispatcher_update.is_empty() {
19735 struct_ser.serialize_field("dispatcherUpdate", &self.dispatcher_update)?;
19736 }
19737 if !self.merge_update.is_empty() {
19738 struct_ser.serialize_field("mergeUpdate", &self.merge_update)?;
19739 }
19740 if !self.actor_vnode_bitmap_update.is_empty() {
19741 struct_ser.serialize_field("actorVnodeBitmapUpdate", &self.actor_vnode_bitmap_update)?;
19742 }
19743 if !self.dropped_actors.is_empty() {
19744 struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
19745 }
19746 if !self.actor_splits.is_empty() {
19747 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
19748 }
19749 if !self.actor_new_dispatchers.is_empty() {
19750 struct_ser.serialize_field("actorNewDispatchers", &self.actor_new_dispatchers)?;
19751 }
19752 if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
19753 struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
19754 }
19755 if !self.sink_schema_change.is_empty() {
19756 struct_ser.serialize_field("sinkSchemaChange", &self.sink_schema_change)?;
19757 }
19758 if !self.subscriptions_to_drop.is_empty() {
19759 struct_ser.serialize_field("subscriptionsToDrop", &self.subscriptions_to_drop)?;
19760 }
19761 if let Some(v) = self.iceberg_pk_index_compaction.as_ref() {
19762 struct_ser.serialize_field("icebergPkIndexCompaction", v)?;
19763 }
19764 struct_ser.end()
19765 }
19766}
19767impl<'de> serde::Deserialize<'de> for UpdateMutation {
19768 #[allow(deprecated)]
19769 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19770 where
19771 D: serde::Deserializer<'de>,
19772 {
19773 const FIELDS: &[&str] = &[
19774 "dispatcher_update",
19775 "dispatcherUpdate",
19776 "merge_update",
19777 "mergeUpdate",
19778 "actor_vnode_bitmap_update",
19779 "actorVnodeBitmapUpdate",
19780 "dropped_actors",
19781 "droppedActors",
19782 "actor_splits",
19783 "actorSplits",
19784 "actor_new_dispatchers",
19785 "actorNewDispatchers",
19786 "actor_cdc_table_snapshot_splits",
19787 "actorCdcTableSnapshotSplits",
19788 "sink_schema_change",
19789 "sinkSchemaChange",
19790 "subscriptions_to_drop",
19791 "subscriptionsToDrop",
19792 "iceberg_pk_index_compaction",
19793 "icebergPkIndexCompaction",
19794 ];
19795
19796 #[allow(clippy::enum_variant_names)]
19797 enum GeneratedField {
19798 DispatcherUpdate,
19799 MergeUpdate,
19800 ActorVnodeBitmapUpdate,
19801 DroppedActors,
19802 ActorSplits,
19803 ActorNewDispatchers,
19804 ActorCdcTableSnapshotSplits,
19805 SinkSchemaChange,
19806 SubscriptionsToDrop,
19807 IcebergPkIndexCompaction,
19808 }
19809 impl<'de> serde::Deserialize<'de> for GeneratedField {
19810 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
19811 where
19812 D: serde::Deserializer<'de>,
19813 {
19814 struct GeneratedVisitor;
19815
19816 impl serde::de::Visitor<'_> for GeneratedVisitor {
19817 type Value = GeneratedField;
19818
19819 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19820 write!(formatter, "expected one of: {:?}", &FIELDS)
19821 }
19822
19823 #[allow(unused_variables)]
19824 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
19825 where
19826 E: serde::de::Error,
19827 {
19828 match value {
19829 "dispatcherUpdate" | "dispatcher_update" => Ok(GeneratedField::DispatcherUpdate),
19830 "mergeUpdate" | "merge_update" => Ok(GeneratedField::MergeUpdate),
19831 "actorVnodeBitmapUpdate" | "actor_vnode_bitmap_update" => Ok(GeneratedField::ActorVnodeBitmapUpdate),
19832 "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
19833 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
19834 "actorNewDispatchers" | "actor_new_dispatchers" => Ok(GeneratedField::ActorNewDispatchers),
19835 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
19836 "sinkSchemaChange" | "sink_schema_change" => Ok(GeneratedField::SinkSchemaChange),
19837 "subscriptionsToDrop" | "subscriptions_to_drop" => Ok(GeneratedField::SubscriptionsToDrop),
19838 "icebergPkIndexCompaction" | "iceberg_pk_index_compaction" => Ok(GeneratedField::IcebergPkIndexCompaction),
19839 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
19840 }
19841 }
19842 }
19843 deserializer.deserialize_identifier(GeneratedVisitor)
19844 }
19845 }
19846 struct GeneratedVisitor;
19847 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
19848 type Value = UpdateMutation;
19849
19850 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19851 formatter.write_str("struct stream_plan.UpdateMutation")
19852 }
19853
19854 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateMutation, V::Error>
19855 where
19856 V: serde::de::MapAccess<'de>,
19857 {
19858 let mut dispatcher_update__ = None;
19859 let mut merge_update__ = None;
19860 let mut actor_vnode_bitmap_update__ = None;
19861 let mut dropped_actors__ = None;
19862 let mut actor_splits__ = None;
19863 let mut actor_new_dispatchers__ = None;
19864 let mut actor_cdc_table_snapshot_splits__ = None;
19865 let mut sink_schema_change__ = None;
19866 let mut subscriptions_to_drop__ = None;
19867 let mut iceberg_pk_index_compaction__ = None;
19868 while let Some(k) = map_.next_key()? {
19869 match k {
19870 GeneratedField::DispatcherUpdate => {
19871 if dispatcher_update__.is_some() {
19872 return Err(serde::de::Error::duplicate_field("dispatcherUpdate"));
19873 }
19874 dispatcher_update__ = Some(map_.next_value()?);
19875 }
19876 GeneratedField::MergeUpdate => {
19877 if merge_update__.is_some() {
19878 return Err(serde::de::Error::duplicate_field("mergeUpdate"));
19879 }
19880 merge_update__ = Some(map_.next_value()?);
19881 }
19882 GeneratedField::ActorVnodeBitmapUpdate => {
19883 if actor_vnode_bitmap_update__.is_some() {
19884 return Err(serde::de::Error::duplicate_field("actorVnodeBitmapUpdate"));
19885 }
19886 actor_vnode_bitmap_update__ = Some(
19887 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
19888 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
19889 );
19890 }
19891 GeneratedField::DroppedActors => {
19892 if dropped_actors__.is_some() {
19893 return Err(serde::de::Error::duplicate_field("droppedActors"));
19894 }
19895 dropped_actors__ =
19896 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
19897 .into_iter().map(|x| x.0).collect())
19898 ;
19899 }
19900 GeneratedField::ActorSplits => {
19901 if actor_splits__.is_some() {
19902 return Err(serde::de::Error::duplicate_field("actorSplits"));
19903 }
19904 actor_splits__ = 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::ActorNewDispatchers => {
19910 if actor_new_dispatchers__.is_some() {
19911 return Err(serde::de::Error::duplicate_field("actorNewDispatchers"));
19912 }
19913 actor_new_dispatchers__ = Some(
19914 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
19915 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
19916 );
19917 }
19918 GeneratedField::ActorCdcTableSnapshotSplits => {
19919 if actor_cdc_table_snapshot_splits__.is_some() {
19920 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
19921 }
19922 actor_cdc_table_snapshot_splits__ = map_.next_value()?;
19923 }
19924 GeneratedField::SinkSchemaChange => {
19925 if sink_schema_change__.is_some() {
19926 return Err(serde::de::Error::duplicate_field("sinkSchemaChange"));
19927 }
19928 sink_schema_change__ = Some(
19929 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
19930 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
19931 );
19932 }
19933 GeneratedField::SubscriptionsToDrop => {
19934 if subscriptions_to_drop__.is_some() {
19935 return Err(serde::de::Error::duplicate_field("subscriptionsToDrop"));
19936 }
19937 subscriptions_to_drop__ = Some(map_.next_value()?);
19938 }
19939 GeneratedField::IcebergPkIndexCompaction => {
19940 if iceberg_pk_index_compaction__.is_some() {
19941 return Err(serde::de::Error::duplicate_field("icebergPkIndexCompaction"));
19942 }
19943 iceberg_pk_index_compaction__ = map_.next_value()?;
19944 }
19945 }
19946 }
19947 Ok(UpdateMutation {
19948 dispatcher_update: dispatcher_update__.unwrap_or_default(),
19949 merge_update: merge_update__.unwrap_or_default(),
19950 actor_vnode_bitmap_update: actor_vnode_bitmap_update__.unwrap_or_default(),
19951 dropped_actors: dropped_actors__.unwrap_or_default(),
19952 actor_splits: actor_splits__.unwrap_or_default(),
19953 actor_new_dispatchers: actor_new_dispatchers__.unwrap_or_default(),
19954 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
19955 sink_schema_change: sink_schema_change__.unwrap_or_default(),
19956 subscriptions_to_drop: subscriptions_to_drop__.unwrap_or_default(),
19957 iceberg_pk_index_compaction: iceberg_pk_index_compaction__,
19958 })
19959 }
19960 }
19961 deserializer.deserialize_struct("stream_plan.UpdateMutation", FIELDS, GeneratedVisitor)
19962 }
19963}
19964impl serde::Serialize for update_mutation::DispatcherUpdate {
19965 #[allow(deprecated)]
19966 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
19967 where
19968 S: serde::Serializer,
19969 {
19970 use serde::ser::SerializeStruct;
19971 let mut len = 0;
19972 if self.actor_id != 0 {
19973 len += 1;
19974 }
19975 if self.dispatcher_id != 0 {
19976 len += 1;
19977 }
19978 if self.hash_mapping.is_some() {
19979 len += 1;
19980 }
19981 if !self.added_downstream_actor_id.is_empty() {
19982 len += 1;
19983 }
19984 if !self.removed_downstream_actor_id.is_empty() {
19985 len += 1;
19986 }
19987 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", len)?;
19988 if self.actor_id != 0 {
19989 struct_ser.serialize_field("actorId", &self.actor_id)?;
19990 }
19991 if self.dispatcher_id != 0 {
19992 struct_ser.serialize_field("dispatcherId", &self.dispatcher_id)?;
19993 }
19994 if let Some(v) = self.hash_mapping.as_ref() {
19995 struct_ser.serialize_field("hashMapping", v)?;
19996 }
19997 if !self.added_downstream_actor_id.is_empty() {
19998 struct_ser.serialize_field("addedDownstreamActorId", &self.added_downstream_actor_id)?;
19999 }
20000 if !self.removed_downstream_actor_id.is_empty() {
20001 struct_ser.serialize_field("removedDownstreamActorId", &self.removed_downstream_actor_id)?;
20002 }
20003 struct_ser.end()
20004 }
20005}
20006impl<'de> serde::Deserialize<'de> for update_mutation::DispatcherUpdate {
20007 #[allow(deprecated)]
20008 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20009 where
20010 D: serde::Deserializer<'de>,
20011 {
20012 const FIELDS: &[&str] = &[
20013 "actor_id",
20014 "actorId",
20015 "dispatcher_id",
20016 "dispatcherId",
20017 "hash_mapping",
20018 "hashMapping",
20019 "added_downstream_actor_id",
20020 "addedDownstreamActorId",
20021 "removed_downstream_actor_id",
20022 "removedDownstreamActorId",
20023 ];
20024
20025 #[allow(clippy::enum_variant_names)]
20026 enum GeneratedField {
20027 ActorId,
20028 DispatcherId,
20029 HashMapping,
20030 AddedDownstreamActorId,
20031 RemovedDownstreamActorId,
20032 }
20033 impl<'de> serde::Deserialize<'de> for GeneratedField {
20034 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20035 where
20036 D: serde::Deserializer<'de>,
20037 {
20038 struct GeneratedVisitor;
20039
20040 impl serde::de::Visitor<'_> for GeneratedVisitor {
20041 type Value = GeneratedField;
20042
20043 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20044 write!(formatter, "expected one of: {:?}", &FIELDS)
20045 }
20046
20047 #[allow(unused_variables)]
20048 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20049 where
20050 E: serde::de::Error,
20051 {
20052 match value {
20053 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
20054 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
20055 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
20056 "addedDownstreamActorId" | "added_downstream_actor_id" => Ok(GeneratedField::AddedDownstreamActorId),
20057 "removedDownstreamActorId" | "removed_downstream_actor_id" => Ok(GeneratedField::RemovedDownstreamActorId),
20058 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20059 }
20060 }
20061 }
20062 deserializer.deserialize_identifier(GeneratedVisitor)
20063 }
20064 }
20065 struct GeneratedVisitor;
20066 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20067 type Value = update_mutation::DispatcherUpdate;
20068
20069 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20070 formatter.write_str("struct stream_plan.UpdateMutation.DispatcherUpdate")
20071 }
20072
20073 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::DispatcherUpdate, V::Error>
20074 where
20075 V: serde::de::MapAccess<'de>,
20076 {
20077 let mut actor_id__ = None;
20078 let mut dispatcher_id__ = None;
20079 let mut hash_mapping__ = None;
20080 let mut added_downstream_actor_id__ = None;
20081 let mut removed_downstream_actor_id__ = None;
20082 while let Some(k) = map_.next_key()? {
20083 match k {
20084 GeneratedField::ActorId => {
20085 if actor_id__.is_some() {
20086 return Err(serde::de::Error::duplicate_field("actorId"));
20087 }
20088 actor_id__ =
20089 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
20090 ;
20091 }
20092 GeneratedField::DispatcherId => {
20093 if dispatcher_id__.is_some() {
20094 return Err(serde::de::Error::duplicate_field("dispatcherId"));
20095 }
20096 dispatcher_id__ =
20097 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
20098 ;
20099 }
20100 GeneratedField::HashMapping => {
20101 if hash_mapping__.is_some() {
20102 return Err(serde::de::Error::duplicate_field("hashMapping"));
20103 }
20104 hash_mapping__ = map_.next_value()?;
20105 }
20106 GeneratedField::AddedDownstreamActorId => {
20107 if added_downstream_actor_id__.is_some() {
20108 return Err(serde::de::Error::duplicate_field("addedDownstreamActorId"));
20109 }
20110 added_downstream_actor_id__ =
20111 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
20112 .into_iter().map(|x| x.0).collect())
20113 ;
20114 }
20115 GeneratedField::RemovedDownstreamActorId => {
20116 if removed_downstream_actor_id__.is_some() {
20117 return Err(serde::de::Error::duplicate_field("removedDownstreamActorId"));
20118 }
20119 removed_downstream_actor_id__ =
20120 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
20121 .into_iter().map(|x| x.0).collect())
20122 ;
20123 }
20124 }
20125 }
20126 Ok(update_mutation::DispatcherUpdate {
20127 actor_id: actor_id__.unwrap_or_default(),
20128 dispatcher_id: dispatcher_id__.unwrap_or_default(),
20129 hash_mapping: hash_mapping__,
20130 added_downstream_actor_id: added_downstream_actor_id__.unwrap_or_default(),
20131 removed_downstream_actor_id: removed_downstream_actor_id__.unwrap_or_default(),
20132 })
20133 }
20134 }
20135 deserializer.deserialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", FIELDS, GeneratedVisitor)
20136 }
20137}
20138impl serde::Serialize for update_mutation::MergeUpdate {
20139 #[allow(deprecated)]
20140 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20141 where
20142 S: serde::Serializer,
20143 {
20144 use serde::ser::SerializeStruct;
20145 let mut len = 0;
20146 if self.actor_id != 0 {
20147 len += 1;
20148 }
20149 if self.upstream_fragment_id != 0 {
20150 len += 1;
20151 }
20152 if self.new_upstream_fragment_id.is_some() {
20153 len += 1;
20154 }
20155 if !self.added_upstream_actors.is_empty() {
20156 len += 1;
20157 }
20158 if !self.removed_upstream_actor_id.is_empty() {
20159 len += 1;
20160 }
20161 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.MergeUpdate", len)?;
20162 if self.actor_id != 0 {
20163 struct_ser.serialize_field("actorId", &self.actor_id)?;
20164 }
20165 if self.upstream_fragment_id != 0 {
20166 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
20167 }
20168 if let Some(v) = self.new_upstream_fragment_id.as_ref() {
20169 struct_ser.serialize_field("newUpstreamFragmentId", v)?;
20170 }
20171 if !self.added_upstream_actors.is_empty() {
20172 struct_ser.serialize_field("addedUpstreamActors", &self.added_upstream_actors)?;
20173 }
20174 if !self.removed_upstream_actor_id.is_empty() {
20175 struct_ser.serialize_field("removedUpstreamActorId", &self.removed_upstream_actor_id)?;
20176 }
20177 struct_ser.end()
20178 }
20179}
20180impl<'de> serde::Deserialize<'de> for update_mutation::MergeUpdate {
20181 #[allow(deprecated)]
20182 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20183 where
20184 D: serde::Deserializer<'de>,
20185 {
20186 const FIELDS: &[&str] = &[
20187 "actor_id",
20188 "actorId",
20189 "upstream_fragment_id",
20190 "upstreamFragmentId",
20191 "new_upstream_fragment_id",
20192 "newUpstreamFragmentId",
20193 "added_upstream_actors",
20194 "addedUpstreamActors",
20195 "removed_upstream_actor_id",
20196 "removedUpstreamActorId",
20197 ];
20198
20199 #[allow(clippy::enum_variant_names)]
20200 enum GeneratedField {
20201 ActorId,
20202 UpstreamFragmentId,
20203 NewUpstreamFragmentId,
20204 AddedUpstreamActors,
20205 RemovedUpstreamActorId,
20206 }
20207 impl<'de> serde::Deserialize<'de> for GeneratedField {
20208 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20209 where
20210 D: serde::Deserializer<'de>,
20211 {
20212 struct GeneratedVisitor;
20213
20214 impl serde::de::Visitor<'_> for GeneratedVisitor {
20215 type Value = GeneratedField;
20216
20217 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20218 write!(formatter, "expected one of: {:?}", &FIELDS)
20219 }
20220
20221 #[allow(unused_variables)]
20222 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20223 where
20224 E: serde::de::Error,
20225 {
20226 match value {
20227 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
20228 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
20229 "newUpstreamFragmentId" | "new_upstream_fragment_id" => Ok(GeneratedField::NewUpstreamFragmentId),
20230 "addedUpstreamActors" | "added_upstream_actors" => Ok(GeneratedField::AddedUpstreamActors),
20231 "removedUpstreamActorId" | "removed_upstream_actor_id" => Ok(GeneratedField::RemovedUpstreamActorId),
20232 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20233 }
20234 }
20235 }
20236 deserializer.deserialize_identifier(GeneratedVisitor)
20237 }
20238 }
20239 struct GeneratedVisitor;
20240 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20241 type Value = update_mutation::MergeUpdate;
20242
20243 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20244 formatter.write_str("struct stream_plan.UpdateMutation.MergeUpdate")
20245 }
20246
20247 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::MergeUpdate, V::Error>
20248 where
20249 V: serde::de::MapAccess<'de>,
20250 {
20251 let mut actor_id__ = None;
20252 let mut upstream_fragment_id__ = None;
20253 let mut new_upstream_fragment_id__ = None;
20254 let mut added_upstream_actors__ = None;
20255 let mut removed_upstream_actor_id__ = None;
20256 while let Some(k) = map_.next_key()? {
20257 match k {
20258 GeneratedField::ActorId => {
20259 if actor_id__.is_some() {
20260 return Err(serde::de::Error::duplicate_field("actorId"));
20261 }
20262 actor_id__ =
20263 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
20264 ;
20265 }
20266 GeneratedField::UpstreamFragmentId => {
20267 if upstream_fragment_id__.is_some() {
20268 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
20269 }
20270 upstream_fragment_id__ =
20271 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
20272 ;
20273 }
20274 GeneratedField::NewUpstreamFragmentId => {
20275 if new_upstream_fragment_id__.is_some() {
20276 return Err(serde::de::Error::duplicate_field("newUpstreamFragmentId"));
20277 }
20278 new_upstream_fragment_id__ =
20279 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
20280 ;
20281 }
20282 GeneratedField::AddedUpstreamActors => {
20283 if added_upstream_actors__.is_some() {
20284 return Err(serde::de::Error::duplicate_field("addedUpstreamActors"));
20285 }
20286 added_upstream_actors__ = Some(map_.next_value()?);
20287 }
20288 GeneratedField::RemovedUpstreamActorId => {
20289 if removed_upstream_actor_id__.is_some() {
20290 return Err(serde::de::Error::duplicate_field("removedUpstreamActorId"));
20291 }
20292 removed_upstream_actor_id__ =
20293 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
20294 .into_iter().map(|x| x.0).collect())
20295 ;
20296 }
20297 }
20298 }
20299 Ok(update_mutation::MergeUpdate {
20300 actor_id: actor_id__.unwrap_or_default(),
20301 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
20302 new_upstream_fragment_id: new_upstream_fragment_id__,
20303 added_upstream_actors: added_upstream_actors__.unwrap_or_default(),
20304 removed_upstream_actor_id: removed_upstream_actor_id__.unwrap_or_default(),
20305 })
20306 }
20307 }
20308 deserializer.deserialize_struct("stream_plan.UpdateMutation.MergeUpdate", FIELDS, GeneratedVisitor)
20309 }
20310}
20311impl serde::Serialize for UpstreamSinkInfo {
20312 #[allow(deprecated)]
20313 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20314 where
20315 S: serde::Serializer,
20316 {
20317 use serde::ser::SerializeStruct;
20318 let mut len = 0;
20319 if self.upstream_fragment_id != 0 {
20320 len += 1;
20321 }
20322 if !self.sink_output_schema.is_empty() {
20323 len += 1;
20324 }
20325 if !self.project_exprs.is_empty() {
20326 len += 1;
20327 }
20328 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkInfo", len)?;
20329 if self.upstream_fragment_id != 0 {
20330 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
20331 }
20332 if !self.sink_output_schema.is_empty() {
20333 struct_ser.serialize_field("sinkOutputSchema", &self.sink_output_schema)?;
20334 }
20335 if !self.project_exprs.is_empty() {
20336 struct_ser.serialize_field("projectExprs", &self.project_exprs)?;
20337 }
20338 struct_ser.end()
20339 }
20340}
20341impl<'de> serde::Deserialize<'de> for UpstreamSinkInfo {
20342 #[allow(deprecated)]
20343 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20344 where
20345 D: serde::Deserializer<'de>,
20346 {
20347 const FIELDS: &[&str] = &[
20348 "upstream_fragment_id",
20349 "upstreamFragmentId",
20350 "sink_output_schema",
20351 "sinkOutputSchema",
20352 "project_exprs",
20353 "projectExprs",
20354 ];
20355
20356 #[allow(clippy::enum_variant_names)]
20357 enum GeneratedField {
20358 UpstreamFragmentId,
20359 SinkOutputSchema,
20360 ProjectExprs,
20361 }
20362 impl<'de> serde::Deserialize<'de> for GeneratedField {
20363 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20364 where
20365 D: serde::Deserializer<'de>,
20366 {
20367 struct GeneratedVisitor;
20368
20369 impl serde::de::Visitor<'_> for GeneratedVisitor {
20370 type Value = GeneratedField;
20371
20372 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20373 write!(formatter, "expected one of: {:?}", &FIELDS)
20374 }
20375
20376 #[allow(unused_variables)]
20377 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20378 where
20379 E: serde::de::Error,
20380 {
20381 match value {
20382 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
20383 "sinkOutputSchema" | "sink_output_schema" => Ok(GeneratedField::SinkOutputSchema),
20384 "projectExprs" | "project_exprs" => Ok(GeneratedField::ProjectExprs),
20385 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20386 }
20387 }
20388 }
20389 deserializer.deserialize_identifier(GeneratedVisitor)
20390 }
20391 }
20392 struct GeneratedVisitor;
20393 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20394 type Value = UpstreamSinkInfo;
20395
20396 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20397 formatter.write_str("struct stream_plan.UpstreamSinkInfo")
20398 }
20399
20400 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkInfo, V::Error>
20401 where
20402 V: serde::de::MapAccess<'de>,
20403 {
20404 let mut upstream_fragment_id__ = None;
20405 let mut sink_output_schema__ = None;
20406 let mut project_exprs__ = None;
20407 while let Some(k) = map_.next_key()? {
20408 match k {
20409 GeneratedField::UpstreamFragmentId => {
20410 if upstream_fragment_id__.is_some() {
20411 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
20412 }
20413 upstream_fragment_id__ =
20414 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
20415 ;
20416 }
20417 GeneratedField::SinkOutputSchema => {
20418 if sink_output_schema__.is_some() {
20419 return Err(serde::de::Error::duplicate_field("sinkOutputSchema"));
20420 }
20421 sink_output_schema__ = Some(map_.next_value()?);
20422 }
20423 GeneratedField::ProjectExprs => {
20424 if project_exprs__.is_some() {
20425 return Err(serde::de::Error::duplicate_field("projectExprs"));
20426 }
20427 project_exprs__ = Some(map_.next_value()?);
20428 }
20429 }
20430 }
20431 Ok(UpstreamSinkInfo {
20432 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
20433 sink_output_schema: sink_output_schema__.unwrap_or_default(),
20434 project_exprs: project_exprs__.unwrap_or_default(),
20435 })
20436 }
20437 }
20438 deserializer.deserialize_struct("stream_plan.UpstreamSinkInfo", FIELDS, GeneratedVisitor)
20439 }
20440}
20441impl serde::Serialize for UpstreamSinkUnionNode {
20442 #[allow(deprecated)]
20443 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20444 where
20445 S: serde::Serializer,
20446 {
20447 use serde::ser::SerializeStruct;
20448 let mut len = 0;
20449 if !self.init_upstreams.is_empty() {
20450 len += 1;
20451 }
20452 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkUnionNode", len)?;
20453 if !self.init_upstreams.is_empty() {
20454 struct_ser.serialize_field("initUpstreams", &self.init_upstreams)?;
20455 }
20456 struct_ser.end()
20457 }
20458}
20459impl<'de> serde::Deserialize<'de> for UpstreamSinkUnionNode {
20460 #[allow(deprecated)]
20461 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20462 where
20463 D: serde::Deserializer<'de>,
20464 {
20465 const FIELDS: &[&str] = &[
20466 "init_upstreams",
20467 "initUpstreams",
20468 ];
20469
20470 #[allow(clippy::enum_variant_names)]
20471 enum GeneratedField {
20472 InitUpstreams,
20473 }
20474 impl<'de> serde::Deserialize<'de> for GeneratedField {
20475 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20476 where
20477 D: serde::Deserializer<'de>,
20478 {
20479 struct GeneratedVisitor;
20480
20481 impl serde::de::Visitor<'_> for GeneratedVisitor {
20482 type Value = GeneratedField;
20483
20484 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20485 write!(formatter, "expected one of: {:?}", &FIELDS)
20486 }
20487
20488 #[allow(unused_variables)]
20489 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20490 where
20491 E: serde::de::Error,
20492 {
20493 match value {
20494 "initUpstreams" | "init_upstreams" => Ok(GeneratedField::InitUpstreams),
20495 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20496 }
20497 }
20498 }
20499 deserializer.deserialize_identifier(GeneratedVisitor)
20500 }
20501 }
20502 struct GeneratedVisitor;
20503 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20504 type Value = UpstreamSinkUnionNode;
20505
20506 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20507 formatter.write_str("struct stream_plan.UpstreamSinkUnionNode")
20508 }
20509
20510 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkUnionNode, V::Error>
20511 where
20512 V: serde::de::MapAccess<'de>,
20513 {
20514 let mut init_upstreams__ = None;
20515 while let Some(k) = map_.next_key()? {
20516 match k {
20517 GeneratedField::InitUpstreams => {
20518 if init_upstreams__.is_some() {
20519 return Err(serde::de::Error::duplicate_field("initUpstreams"));
20520 }
20521 init_upstreams__ = Some(map_.next_value()?);
20522 }
20523 }
20524 }
20525 Ok(UpstreamSinkUnionNode {
20526 init_upstreams: init_upstreams__.unwrap_or_default(),
20527 })
20528 }
20529 }
20530 deserializer.deserialize_struct("stream_plan.UpstreamSinkUnionNode", FIELDS, GeneratedVisitor)
20531 }
20532}
20533impl serde::Serialize for ValuesNode {
20534 #[allow(deprecated)]
20535 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20536 where
20537 S: serde::Serializer,
20538 {
20539 use serde::ser::SerializeStruct;
20540 let mut len = 0;
20541 if !self.tuples.is_empty() {
20542 len += 1;
20543 }
20544 if !self.fields.is_empty() {
20545 len += 1;
20546 }
20547 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode", len)?;
20548 if !self.tuples.is_empty() {
20549 struct_ser.serialize_field("tuples", &self.tuples)?;
20550 }
20551 if !self.fields.is_empty() {
20552 struct_ser.serialize_field("fields", &self.fields)?;
20553 }
20554 struct_ser.end()
20555 }
20556}
20557impl<'de> serde::Deserialize<'de> for ValuesNode {
20558 #[allow(deprecated)]
20559 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20560 where
20561 D: serde::Deserializer<'de>,
20562 {
20563 const FIELDS: &[&str] = &[
20564 "tuples",
20565 "fields",
20566 ];
20567
20568 #[allow(clippy::enum_variant_names)]
20569 enum GeneratedField {
20570 Tuples,
20571 Fields,
20572 }
20573 impl<'de> serde::Deserialize<'de> for GeneratedField {
20574 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20575 where
20576 D: serde::Deserializer<'de>,
20577 {
20578 struct GeneratedVisitor;
20579
20580 impl serde::de::Visitor<'_> for GeneratedVisitor {
20581 type Value = GeneratedField;
20582
20583 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20584 write!(formatter, "expected one of: {:?}", &FIELDS)
20585 }
20586
20587 #[allow(unused_variables)]
20588 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20589 where
20590 E: serde::de::Error,
20591 {
20592 match value {
20593 "tuples" => Ok(GeneratedField::Tuples),
20594 "fields" => Ok(GeneratedField::Fields),
20595 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20596 }
20597 }
20598 }
20599 deserializer.deserialize_identifier(GeneratedVisitor)
20600 }
20601 }
20602 struct GeneratedVisitor;
20603 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20604 type Value = ValuesNode;
20605
20606 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20607 formatter.write_str("struct stream_plan.ValuesNode")
20608 }
20609
20610 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
20611 where
20612 V: serde::de::MapAccess<'de>,
20613 {
20614 let mut tuples__ = None;
20615 let mut fields__ = None;
20616 while let Some(k) = map_.next_key()? {
20617 match k {
20618 GeneratedField::Tuples => {
20619 if tuples__.is_some() {
20620 return Err(serde::de::Error::duplicate_field("tuples"));
20621 }
20622 tuples__ = Some(map_.next_value()?);
20623 }
20624 GeneratedField::Fields => {
20625 if fields__.is_some() {
20626 return Err(serde::de::Error::duplicate_field("fields"));
20627 }
20628 fields__ = Some(map_.next_value()?);
20629 }
20630 }
20631 }
20632 Ok(ValuesNode {
20633 tuples: tuples__.unwrap_or_default(),
20634 fields: fields__.unwrap_or_default(),
20635 })
20636 }
20637 }
20638 deserializer.deserialize_struct("stream_plan.ValuesNode", FIELDS, GeneratedVisitor)
20639 }
20640}
20641impl serde::Serialize for values_node::ExprTuple {
20642 #[allow(deprecated)]
20643 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20644 where
20645 S: serde::Serializer,
20646 {
20647 use serde::ser::SerializeStruct;
20648 let mut len = 0;
20649 if !self.cells.is_empty() {
20650 len += 1;
20651 }
20652 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode.ExprTuple", len)?;
20653 if !self.cells.is_empty() {
20654 struct_ser.serialize_field("cells", &self.cells)?;
20655 }
20656 struct_ser.end()
20657 }
20658}
20659impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
20660 #[allow(deprecated)]
20661 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20662 where
20663 D: serde::Deserializer<'de>,
20664 {
20665 const FIELDS: &[&str] = &[
20666 "cells",
20667 ];
20668
20669 #[allow(clippy::enum_variant_names)]
20670 enum GeneratedField {
20671 Cells,
20672 }
20673 impl<'de> serde::Deserialize<'de> for GeneratedField {
20674 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20675 where
20676 D: serde::Deserializer<'de>,
20677 {
20678 struct GeneratedVisitor;
20679
20680 impl serde::de::Visitor<'_> for GeneratedVisitor {
20681 type Value = GeneratedField;
20682
20683 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20684 write!(formatter, "expected one of: {:?}", &FIELDS)
20685 }
20686
20687 #[allow(unused_variables)]
20688 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20689 where
20690 E: serde::de::Error,
20691 {
20692 match value {
20693 "cells" => Ok(GeneratedField::Cells),
20694 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20695 }
20696 }
20697 }
20698 deserializer.deserialize_identifier(GeneratedVisitor)
20699 }
20700 }
20701 struct GeneratedVisitor;
20702 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20703 type Value = values_node::ExprTuple;
20704
20705 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20706 formatter.write_str("struct stream_plan.ValuesNode.ExprTuple")
20707 }
20708
20709 fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
20710 where
20711 V: serde::de::MapAccess<'de>,
20712 {
20713 let mut cells__ = None;
20714 while let Some(k) = map_.next_key()? {
20715 match k {
20716 GeneratedField::Cells => {
20717 if cells__.is_some() {
20718 return Err(serde::de::Error::duplicate_field("cells"));
20719 }
20720 cells__ = Some(map_.next_value()?);
20721 }
20722 }
20723 }
20724 Ok(values_node::ExprTuple {
20725 cells: cells__.unwrap_or_default(),
20726 })
20727 }
20728 }
20729 deserializer.deserialize_struct("stream_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
20730 }
20731}
20732impl serde::Serialize for VectorIndexLookupJoinNode {
20733 #[allow(deprecated)]
20734 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20735 where
20736 S: serde::Serializer,
20737 {
20738 use serde::ser::SerializeStruct;
20739 let mut len = 0;
20740 if self.reader_desc.is_some() {
20741 len += 1;
20742 }
20743 if self.vector_column_idx != 0 {
20744 len += 1;
20745 }
20746 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexLookupJoinNode", len)?;
20747 if let Some(v) = self.reader_desc.as_ref() {
20748 struct_ser.serialize_field("readerDesc", v)?;
20749 }
20750 if self.vector_column_idx != 0 {
20751 struct_ser.serialize_field("vectorColumnIdx", &self.vector_column_idx)?;
20752 }
20753 struct_ser.end()
20754 }
20755}
20756impl<'de> serde::Deserialize<'de> for VectorIndexLookupJoinNode {
20757 #[allow(deprecated)]
20758 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20759 where
20760 D: serde::Deserializer<'de>,
20761 {
20762 const FIELDS: &[&str] = &[
20763 "reader_desc",
20764 "readerDesc",
20765 "vector_column_idx",
20766 "vectorColumnIdx",
20767 ];
20768
20769 #[allow(clippy::enum_variant_names)]
20770 enum GeneratedField {
20771 ReaderDesc,
20772 VectorColumnIdx,
20773 }
20774 impl<'de> serde::Deserialize<'de> for GeneratedField {
20775 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20776 where
20777 D: serde::Deserializer<'de>,
20778 {
20779 struct GeneratedVisitor;
20780
20781 impl serde::de::Visitor<'_> for GeneratedVisitor {
20782 type Value = GeneratedField;
20783
20784 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20785 write!(formatter, "expected one of: {:?}", &FIELDS)
20786 }
20787
20788 #[allow(unused_variables)]
20789 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20790 where
20791 E: serde::de::Error,
20792 {
20793 match value {
20794 "readerDesc" | "reader_desc" => Ok(GeneratedField::ReaderDesc),
20795 "vectorColumnIdx" | "vector_column_idx" => Ok(GeneratedField::VectorColumnIdx),
20796 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20797 }
20798 }
20799 }
20800 deserializer.deserialize_identifier(GeneratedVisitor)
20801 }
20802 }
20803 struct GeneratedVisitor;
20804 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20805 type Value = VectorIndexLookupJoinNode;
20806
20807 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20808 formatter.write_str("struct stream_plan.VectorIndexLookupJoinNode")
20809 }
20810
20811 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexLookupJoinNode, V::Error>
20812 where
20813 V: serde::de::MapAccess<'de>,
20814 {
20815 let mut reader_desc__ = None;
20816 let mut vector_column_idx__ = None;
20817 while let Some(k) = map_.next_key()? {
20818 match k {
20819 GeneratedField::ReaderDesc => {
20820 if reader_desc__.is_some() {
20821 return Err(serde::de::Error::duplicate_field("readerDesc"));
20822 }
20823 reader_desc__ = map_.next_value()?;
20824 }
20825 GeneratedField::VectorColumnIdx => {
20826 if vector_column_idx__.is_some() {
20827 return Err(serde::de::Error::duplicate_field("vectorColumnIdx"));
20828 }
20829 vector_column_idx__ =
20830 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
20831 ;
20832 }
20833 }
20834 }
20835 Ok(VectorIndexLookupJoinNode {
20836 reader_desc: reader_desc__,
20837 vector_column_idx: vector_column_idx__.unwrap_or_default(),
20838 })
20839 }
20840 }
20841 deserializer.deserialize_struct("stream_plan.VectorIndexLookupJoinNode", FIELDS, GeneratedVisitor)
20842 }
20843}
20844impl serde::Serialize for VectorIndexWriteNode {
20845 #[allow(deprecated)]
20846 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20847 where
20848 S: serde::Serializer,
20849 {
20850 use serde::ser::SerializeStruct;
20851 let mut len = 0;
20852 if self.table.is_some() {
20853 len += 1;
20854 }
20855 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexWriteNode", len)?;
20856 if let Some(v) = self.table.as_ref() {
20857 struct_ser.serialize_field("table", v)?;
20858 }
20859 struct_ser.end()
20860 }
20861}
20862impl<'de> serde::Deserialize<'de> for VectorIndexWriteNode {
20863 #[allow(deprecated)]
20864 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20865 where
20866 D: serde::Deserializer<'de>,
20867 {
20868 const FIELDS: &[&str] = &[
20869 "table",
20870 ];
20871
20872 #[allow(clippy::enum_variant_names)]
20873 enum GeneratedField {
20874 Table,
20875 }
20876 impl<'de> serde::Deserialize<'de> for GeneratedField {
20877 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20878 where
20879 D: serde::Deserializer<'de>,
20880 {
20881 struct GeneratedVisitor;
20882
20883 impl serde::de::Visitor<'_> for GeneratedVisitor {
20884 type Value = GeneratedField;
20885
20886 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20887 write!(formatter, "expected one of: {:?}", &FIELDS)
20888 }
20889
20890 #[allow(unused_variables)]
20891 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20892 where
20893 E: serde::de::Error,
20894 {
20895 match value {
20896 "table" => Ok(GeneratedField::Table),
20897 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20898 }
20899 }
20900 }
20901 deserializer.deserialize_identifier(GeneratedVisitor)
20902 }
20903 }
20904 struct GeneratedVisitor;
20905 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
20906 type Value = VectorIndexWriteNode;
20907
20908 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20909 formatter.write_str("struct stream_plan.VectorIndexWriteNode")
20910 }
20911
20912 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexWriteNode, V::Error>
20913 where
20914 V: serde::de::MapAccess<'de>,
20915 {
20916 let mut table__ = None;
20917 while let Some(k) = map_.next_key()? {
20918 match k {
20919 GeneratedField::Table => {
20920 if table__.is_some() {
20921 return Err(serde::de::Error::duplicate_field("table"));
20922 }
20923 table__ = map_.next_value()?;
20924 }
20925 }
20926 }
20927 Ok(VectorIndexWriteNode {
20928 table: table__,
20929 })
20930 }
20931 }
20932 deserializer.deserialize_struct("stream_plan.VectorIndexWriteNode", FIELDS, GeneratedVisitor)
20933 }
20934}
20935impl serde::Serialize for Watermark {
20936 #[allow(deprecated)]
20937 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
20938 where
20939 S: serde::Serializer,
20940 {
20941 use serde::ser::SerializeStruct;
20942 let mut len = 0;
20943 if self.column.is_some() {
20944 len += 1;
20945 }
20946 if self.val.is_some() {
20947 len += 1;
20948 }
20949 let mut struct_ser = serializer.serialize_struct("stream_plan.Watermark", len)?;
20950 if let Some(v) = self.column.as_ref() {
20951 struct_ser.serialize_field("column", v)?;
20952 }
20953 if let Some(v) = self.val.as_ref() {
20954 struct_ser.serialize_field("val", v)?;
20955 }
20956 struct_ser.end()
20957 }
20958}
20959impl<'de> serde::Deserialize<'de> for Watermark {
20960 #[allow(deprecated)]
20961 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
20962 where
20963 D: serde::Deserializer<'de>,
20964 {
20965 const FIELDS: &[&str] = &[
20966 "column",
20967 "val",
20968 ];
20969
20970 #[allow(clippy::enum_variant_names)]
20971 enum GeneratedField {
20972 Column,
20973 Val,
20974 }
20975 impl<'de> serde::Deserialize<'de> for GeneratedField {
20976 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
20977 where
20978 D: serde::Deserializer<'de>,
20979 {
20980 struct GeneratedVisitor;
20981
20982 impl serde::de::Visitor<'_> for GeneratedVisitor {
20983 type Value = GeneratedField;
20984
20985 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
20986 write!(formatter, "expected one of: {:?}", &FIELDS)
20987 }
20988
20989 #[allow(unused_variables)]
20990 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
20991 where
20992 E: serde::de::Error,
20993 {
20994 match value {
20995 "column" => Ok(GeneratedField::Column),
20996 "val" => Ok(GeneratedField::Val),
20997 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
20998 }
20999 }
21000 }
21001 deserializer.deserialize_identifier(GeneratedVisitor)
21002 }
21003 }
21004 struct GeneratedVisitor;
21005 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
21006 type Value = Watermark;
21007
21008 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
21009 formatter.write_str("struct stream_plan.Watermark")
21010 }
21011
21012 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Watermark, V::Error>
21013 where
21014 V: serde::de::MapAccess<'de>,
21015 {
21016 let mut column__ = None;
21017 let mut val__ = None;
21018 while let Some(k) = map_.next_key()? {
21019 match k {
21020 GeneratedField::Column => {
21021 if column__.is_some() {
21022 return Err(serde::de::Error::duplicate_field("column"));
21023 }
21024 column__ = map_.next_value()?;
21025 }
21026 GeneratedField::Val => {
21027 if val__.is_some() {
21028 return Err(serde::de::Error::duplicate_field("val"));
21029 }
21030 val__ = map_.next_value()?;
21031 }
21032 }
21033 }
21034 Ok(Watermark {
21035 column: column__,
21036 val: val__,
21037 })
21038 }
21039 }
21040 deserializer.deserialize_struct("stream_plan.Watermark", FIELDS, GeneratedVisitor)
21041 }
21042}
21043impl serde::Serialize for WatermarkFilterNode {
21044 #[allow(deprecated)]
21045 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
21046 where
21047 S: serde::Serializer,
21048 {
21049 use serde::ser::SerializeStruct;
21050 let mut len = 0;
21051 if !self.watermark_descs.is_empty() {
21052 len += 1;
21053 }
21054 if !self.tables.is_empty() {
21055 len += 1;
21056 }
21057 let mut struct_ser = serializer.serialize_struct("stream_plan.WatermarkFilterNode", len)?;
21058 if !self.watermark_descs.is_empty() {
21059 struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
21060 }
21061 if !self.tables.is_empty() {
21062 struct_ser.serialize_field("tables", &self.tables)?;
21063 }
21064 struct_ser.end()
21065 }
21066}
21067impl<'de> serde::Deserialize<'de> for WatermarkFilterNode {
21068 #[allow(deprecated)]
21069 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
21070 where
21071 D: serde::Deserializer<'de>,
21072 {
21073 const FIELDS: &[&str] = &[
21074 "watermark_descs",
21075 "watermarkDescs",
21076 "tables",
21077 ];
21078
21079 #[allow(clippy::enum_variant_names)]
21080 enum GeneratedField {
21081 WatermarkDescs,
21082 Tables,
21083 }
21084 impl<'de> serde::Deserialize<'de> for GeneratedField {
21085 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
21086 where
21087 D: serde::Deserializer<'de>,
21088 {
21089 struct GeneratedVisitor;
21090
21091 impl serde::de::Visitor<'_> for GeneratedVisitor {
21092 type Value = GeneratedField;
21093
21094 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
21095 write!(formatter, "expected one of: {:?}", &FIELDS)
21096 }
21097
21098 #[allow(unused_variables)]
21099 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
21100 where
21101 E: serde::de::Error,
21102 {
21103 match value {
21104 "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
21105 "tables" => Ok(GeneratedField::Tables),
21106 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
21107 }
21108 }
21109 }
21110 deserializer.deserialize_identifier(GeneratedVisitor)
21111 }
21112 }
21113 struct GeneratedVisitor;
21114 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
21115 type Value = WatermarkFilterNode;
21116
21117 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
21118 formatter.write_str("struct stream_plan.WatermarkFilterNode")
21119 }
21120
21121 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkFilterNode, V::Error>
21122 where
21123 V: serde::de::MapAccess<'de>,
21124 {
21125 let mut watermark_descs__ = None;
21126 let mut tables__ = None;
21127 while let Some(k) = map_.next_key()? {
21128 match k {
21129 GeneratedField::WatermarkDescs => {
21130 if watermark_descs__.is_some() {
21131 return Err(serde::de::Error::duplicate_field("watermarkDescs"));
21132 }
21133 watermark_descs__ = Some(map_.next_value()?);
21134 }
21135 GeneratedField::Tables => {
21136 if tables__.is_some() {
21137 return Err(serde::de::Error::duplicate_field("tables"));
21138 }
21139 tables__ = Some(map_.next_value()?);
21140 }
21141 }
21142 }
21143 Ok(WatermarkFilterNode {
21144 watermark_descs: watermark_descs__.unwrap_or_default(),
21145 tables: tables__.unwrap_or_default(),
21146 })
21147 }
21148 }
21149 deserializer.deserialize_struct("stream_plan.WatermarkFilterNode", FIELDS, GeneratedVisitor)
21150 }
21151}