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 let mut struct_ser = serializer.serialize_struct("stream_plan.AddMutation", len)?;
152 if !self.actor_dispatchers.is_empty() {
153 struct_ser.serialize_field("actorDispatchers", &self.actor_dispatchers)?;
154 }
155 if !self.added_actors.is_empty() {
156 struct_ser.serialize_field("addedActors", &self.added_actors)?;
157 }
158 if !self.actor_splits.is_empty() {
159 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
160 }
161 if self.pause {
162 struct_ser.serialize_field("pause", &self.pause)?;
163 }
164 if !self.subscriptions_to_add.is_empty() {
165 struct_ser.serialize_field("subscriptionsToAdd", &self.subscriptions_to_add)?;
166 }
167 if !self.backfill_nodes_to_pause.is_empty() {
168 struct_ser.serialize_field("backfillNodesToPause", &self.backfill_nodes_to_pause)?;
169 }
170 if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
171 struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
172 }
173 if !self.new_upstream_sinks.is_empty() {
174 struct_ser.serialize_field("newUpstreamSinks", &self.new_upstream_sinks)?;
175 }
176 struct_ser.end()
177 }
178}
179impl<'de> serde::Deserialize<'de> for AddMutation {
180 #[allow(deprecated)]
181 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
182 where
183 D: serde::Deserializer<'de>,
184 {
185 const FIELDS: &[&str] = &[
186 "actor_dispatchers",
187 "actorDispatchers",
188 "added_actors",
189 "addedActors",
190 "actor_splits",
191 "actorSplits",
192 "pause",
193 "subscriptions_to_add",
194 "subscriptionsToAdd",
195 "backfill_nodes_to_pause",
196 "backfillNodesToPause",
197 "actor_cdc_table_snapshot_splits",
198 "actorCdcTableSnapshotSplits",
199 "new_upstream_sinks",
200 "newUpstreamSinks",
201 ];
202
203 #[allow(clippy::enum_variant_names)]
204 enum GeneratedField {
205 ActorDispatchers,
206 AddedActors,
207 ActorSplits,
208 Pause,
209 SubscriptionsToAdd,
210 BackfillNodesToPause,
211 ActorCdcTableSnapshotSplits,
212 NewUpstreamSinks,
213 }
214 impl<'de> serde::Deserialize<'de> for GeneratedField {
215 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
216 where
217 D: serde::Deserializer<'de>,
218 {
219 struct GeneratedVisitor;
220
221 impl serde::de::Visitor<'_> for GeneratedVisitor {
222 type Value = GeneratedField;
223
224 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
225 write!(formatter, "expected one of: {:?}", &FIELDS)
226 }
227
228 #[allow(unused_variables)]
229 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
230 where
231 E: serde::de::Error,
232 {
233 match value {
234 "actorDispatchers" | "actor_dispatchers" => Ok(GeneratedField::ActorDispatchers),
235 "addedActors" | "added_actors" => Ok(GeneratedField::AddedActors),
236 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
237 "pause" => Ok(GeneratedField::Pause),
238 "subscriptionsToAdd" | "subscriptions_to_add" => Ok(GeneratedField::SubscriptionsToAdd),
239 "backfillNodesToPause" | "backfill_nodes_to_pause" => Ok(GeneratedField::BackfillNodesToPause),
240 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
241 "newUpstreamSinks" | "new_upstream_sinks" => Ok(GeneratedField::NewUpstreamSinks),
242 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
243 }
244 }
245 }
246 deserializer.deserialize_identifier(GeneratedVisitor)
247 }
248 }
249 struct GeneratedVisitor;
250 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
251 type Value = AddMutation;
252
253 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
254 formatter.write_str("struct stream_plan.AddMutation")
255 }
256
257 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddMutation, V::Error>
258 where
259 V: serde::de::MapAccess<'de>,
260 {
261 let mut actor_dispatchers__ = None;
262 let mut added_actors__ = None;
263 let mut actor_splits__ = None;
264 let mut pause__ = None;
265 let mut subscriptions_to_add__ = None;
266 let mut backfill_nodes_to_pause__ = None;
267 let mut actor_cdc_table_snapshot_splits__ = None;
268 let mut new_upstream_sinks__ = None;
269 while let Some(k) = map_.next_key()? {
270 match k {
271 GeneratedField::ActorDispatchers => {
272 if actor_dispatchers__.is_some() {
273 return Err(serde::de::Error::duplicate_field("actorDispatchers"));
274 }
275 actor_dispatchers__ = Some(
276 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
277 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
278 );
279 }
280 GeneratedField::AddedActors => {
281 if added_actors__.is_some() {
282 return Err(serde::de::Error::duplicate_field("addedActors"));
283 }
284 added_actors__ =
285 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
286 .into_iter().map(|x| x.0).collect())
287 ;
288 }
289 GeneratedField::ActorSplits => {
290 if actor_splits__.is_some() {
291 return Err(serde::de::Error::duplicate_field("actorSplits"));
292 }
293 actor_splits__ = Some(
294 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
295 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
296 );
297 }
298 GeneratedField::Pause => {
299 if pause__.is_some() {
300 return Err(serde::de::Error::duplicate_field("pause"));
301 }
302 pause__ = Some(map_.next_value()?);
303 }
304 GeneratedField::SubscriptionsToAdd => {
305 if subscriptions_to_add__.is_some() {
306 return Err(serde::de::Error::duplicate_field("subscriptionsToAdd"));
307 }
308 subscriptions_to_add__ = Some(map_.next_value()?);
309 }
310 GeneratedField::BackfillNodesToPause => {
311 if backfill_nodes_to_pause__.is_some() {
312 return Err(serde::de::Error::duplicate_field("backfillNodesToPause"));
313 }
314 backfill_nodes_to_pause__ =
315 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
316 .into_iter().map(|x| x.0).collect())
317 ;
318 }
319 GeneratedField::ActorCdcTableSnapshotSplits => {
320 if actor_cdc_table_snapshot_splits__.is_some() {
321 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
322 }
323 actor_cdc_table_snapshot_splits__ = map_.next_value()?;
324 }
325 GeneratedField::NewUpstreamSinks => {
326 if new_upstream_sinks__.is_some() {
327 return Err(serde::de::Error::duplicate_field("newUpstreamSinks"));
328 }
329 new_upstream_sinks__ = Some(
330 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
331 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
332 );
333 }
334 }
335 }
336 Ok(AddMutation {
337 actor_dispatchers: actor_dispatchers__.unwrap_or_default(),
338 added_actors: added_actors__.unwrap_or_default(),
339 actor_splits: actor_splits__.unwrap_or_default(),
340 pause: pause__.unwrap_or_default(),
341 subscriptions_to_add: subscriptions_to_add__.unwrap_or_default(),
342 backfill_nodes_to_pause: backfill_nodes_to_pause__.unwrap_or_default(),
343 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
344 new_upstream_sinks: new_upstream_sinks__.unwrap_or_default(),
345 })
346 }
347 }
348 deserializer.deserialize_struct("stream_plan.AddMutation", FIELDS, GeneratedVisitor)
349 }
350}
351impl serde::Serialize for add_mutation::NewUpstreamSink {
352 #[allow(deprecated)]
353 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
354 where
355 S: serde::Serializer,
356 {
357 use serde::ser::SerializeStruct;
358 let mut len = 0;
359 if self.info.is_some() {
360 len += 1;
361 }
362 if !self.upstream_actors.is_empty() {
363 len += 1;
364 }
365 let mut struct_ser = serializer.serialize_struct("stream_plan.AddMutation.NewUpstreamSink", len)?;
366 if let Some(v) = self.info.as_ref() {
367 struct_ser.serialize_field("info", v)?;
368 }
369 if !self.upstream_actors.is_empty() {
370 struct_ser.serialize_field("upstreamActors", &self.upstream_actors)?;
371 }
372 struct_ser.end()
373 }
374}
375impl<'de> serde::Deserialize<'de> for add_mutation::NewUpstreamSink {
376 #[allow(deprecated)]
377 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
378 where
379 D: serde::Deserializer<'de>,
380 {
381 const FIELDS: &[&str] = &[
382 "info",
383 "upstream_actors",
384 "upstreamActors",
385 ];
386
387 #[allow(clippy::enum_variant_names)]
388 enum GeneratedField {
389 Info,
390 UpstreamActors,
391 }
392 impl<'de> serde::Deserialize<'de> for GeneratedField {
393 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
394 where
395 D: serde::Deserializer<'de>,
396 {
397 struct GeneratedVisitor;
398
399 impl serde::de::Visitor<'_> for GeneratedVisitor {
400 type Value = GeneratedField;
401
402 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
403 write!(formatter, "expected one of: {:?}", &FIELDS)
404 }
405
406 #[allow(unused_variables)]
407 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
408 where
409 E: serde::de::Error,
410 {
411 match value {
412 "info" => Ok(GeneratedField::Info),
413 "upstreamActors" | "upstream_actors" => Ok(GeneratedField::UpstreamActors),
414 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
415 }
416 }
417 }
418 deserializer.deserialize_identifier(GeneratedVisitor)
419 }
420 }
421 struct GeneratedVisitor;
422 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
423 type Value = add_mutation::NewUpstreamSink;
424
425 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
426 formatter.write_str("struct stream_plan.AddMutation.NewUpstreamSink")
427 }
428
429 fn visit_map<V>(self, mut map_: V) -> std::result::Result<add_mutation::NewUpstreamSink, V::Error>
430 where
431 V: serde::de::MapAccess<'de>,
432 {
433 let mut info__ = None;
434 let mut upstream_actors__ = None;
435 while let Some(k) = map_.next_key()? {
436 match k {
437 GeneratedField::Info => {
438 if info__.is_some() {
439 return Err(serde::de::Error::duplicate_field("info"));
440 }
441 info__ = map_.next_value()?;
442 }
443 GeneratedField::UpstreamActors => {
444 if upstream_actors__.is_some() {
445 return Err(serde::de::Error::duplicate_field("upstreamActors"));
446 }
447 upstream_actors__ = Some(map_.next_value()?);
448 }
449 }
450 }
451 Ok(add_mutation::NewUpstreamSink {
452 info: info__,
453 upstream_actors: upstream_actors__.unwrap_or_default(),
454 })
455 }
456 }
457 deserializer.deserialize_struct("stream_plan.AddMutation.NewUpstreamSink", FIELDS, GeneratedVisitor)
458 }
459}
460impl serde::Serialize for AggCallState {
461 #[allow(deprecated)]
462 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
463 where
464 S: serde::Serializer,
465 {
466 use serde::ser::SerializeStruct;
467 let mut len = 0;
468 if self.inner.is_some() {
469 len += 1;
470 }
471 let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState", len)?;
472 if let Some(v) = self.inner.as_ref() {
473 match v {
474 agg_call_state::Inner::ValueState(v) => {
475 struct_ser.serialize_field("valueState", v)?;
476 }
477 agg_call_state::Inner::MaterializedInputState(v) => {
478 struct_ser.serialize_field("materializedInputState", v)?;
479 }
480 }
481 }
482 struct_ser.end()
483 }
484}
485impl<'de> serde::Deserialize<'de> for AggCallState {
486 #[allow(deprecated)]
487 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
488 where
489 D: serde::Deserializer<'de>,
490 {
491 const FIELDS: &[&str] = &[
492 "value_state",
493 "valueState",
494 "materialized_input_state",
495 "materializedInputState",
496 ];
497
498 #[allow(clippy::enum_variant_names)]
499 enum GeneratedField {
500 ValueState,
501 MaterializedInputState,
502 }
503 impl<'de> serde::Deserialize<'de> for GeneratedField {
504 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
505 where
506 D: serde::Deserializer<'de>,
507 {
508 struct GeneratedVisitor;
509
510 impl serde::de::Visitor<'_> for GeneratedVisitor {
511 type Value = GeneratedField;
512
513 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
514 write!(formatter, "expected one of: {:?}", &FIELDS)
515 }
516
517 #[allow(unused_variables)]
518 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
519 where
520 E: serde::de::Error,
521 {
522 match value {
523 "valueState" | "value_state" => Ok(GeneratedField::ValueState),
524 "materializedInputState" | "materialized_input_state" => Ok(GeneratedField::MaterializedInputState),
525 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
526 }
527 }
528 }
529 deserializer.deserialize_identifier(GeneratedVisitor)
530 }
531 }
532 struct GeneratedVisitor;
533 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
534 type Value = AggCallState;
535
536 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
537 formatter.write_str("struct stream_plan.AggCallState")
538 }
539
540 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AggCallState, V::Error>
541 where
542 V: serde::de::MapAccess<'de>,
543 {
544 let mut inner__ = None;
545 while let Some(k) = map_.next_key()? {
546 match k {
547 GeneratedField::ValueState => {
548 if inner__.is_some() {
549 return Err(serde::de::Error::duplicate_field("valueState"));
550 }
551 inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::ValueState)
552;
553 }
554 GeneratedField::MaterializedInputState => {
555 if inner__.is_some() {
556 return Err(serde::de::Error::duplicate_field("materializedInputState"));
557 }
558 inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::MaterializedInputState)
559;
560 }
561 }
562 }
563 Ok(AggCallState {
564 inner: inner__,
565 })
566 }
567 }
568 deserializer.deserialize_struct("stream_plan.AggCallState", FIELDS, GeneratedVisitor)
569 }
570}
571impl serde::Serialize for agg_call_state::MaterializedInputState {
572 #[allow(deprecated)]
573 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
574 where
575 S: serde::Serializer,
576 {
577 use serde::ser::SerializeStruct;
578 let mut len = 0;
579 if self.table.is_some() {
580 len += 1;
581 }
582 if !self.included_upstream_indices.is_empty() {
583 len += 1;
584 }
585 if !self.table_value_indices.is_empty() {
586 len += 1;
587 }
588 if !self.order_columns.is_empty() {
589 len += 1;
590 }
591 let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState.MaterializedInputState", len)?;
592 if let Some(v) = self.table.as_ref() {
593 struct_ser.serialize_field("table", v)?;
594 }
595 if !self.included_upstream_indices.is_empty() {
596 struct_ser.serialize_field("includedUpstreamIndices", &self.included_upstream_indices)?;
597 }
598 if !self.table_value_indices.is_empty() {
599 struct_ser.serialize_field("tableValueIndices", &self.table_value_indices)?;
600 }
601 if !self.order_columns.is_empty() {
602 struct_ser.serialize_field("orderColumns", &self.order_columns)?;
603 }
604 struct_ser.end()
605 }
606}
607impl<'de> serde::Deserialize<'de> for agg_call_state::MaterializedInputState {
608 #[allow(deprecated)]
609 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
610 where
611 D: serde::Deserializer<'de>,
612 {
613 const FIELDS: &[&str] = &[
614 "table",
615 "included_upstream_indices",
616 "includedUpstreamIndices",
617 "table_value_indices",
618 "tableValueIndices",
619 "order_columns",
620 "orderColumns",
621 ];
622
623 #[allow(clippy::enum_variant_names)]
624 enum GeneratedField {
625 Table,
626 IncludedUpstreamIndices,
627 TableValueIndices,
628 OrderColumns,
629 }
630 impl<'de> serde::Deserialize<'de> for GeneratedField {
631 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
632 where
633 D: serde::Deserializer<'de>,
634 {
635 struct GeneratedVisitor;
636
637 impl serde::de::Visitor<'_> for GeneratedVisitor {
638 type Value = GeneratedField;
639
640 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
641 write!(formatter, "expected one of: {:?}", &FIELDS)
642 }
643
644 #[allow(unused_variables)]
645 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
646 where
647 E: serde::de::Error,
648 {
649 match value {
650 "table" => Ok(GeneratedField::Table),
651 "includedUpstreamIndices" | "included_upstream_indices" => Ok(GeneratedField::IncludedUpstreamIndices),
652 "tableValueIndices" | "table_value_indices" => Ok(GeneratedField::TableValueIndices),
653 "orderColumns" | "order_columns" => Ok(GeneratedField::OrderColumns),
654 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
655 }
656 }
657 }
658 deserializer.deserialize_identifier(GeneratedVisitor)
659 }
660 }
661 struct GeneratedVisitor;
662 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
663 type Value = agg_call_state::MaterializedInputState;
664
665 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
666 formatter.write_str("struct stream_plan.AggCallState.MaterializedInputState")
667 }
668
669 fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::MaterializedInputState, V::Error>
670 where
671 V: serde::de::MapAccess<'de>,
672 {
673 let mut table__ = None;
674 let mut included_upstream_indices__ = None;
675 let mut table_value_indices__ = None;
676 let mut order_columns__ = None;
677 while let Some(k) = map_.next_key()? {
678 match k {
679 GeneratedField::Table => {
680 if table__.is_some() {
681 return Err(serde::de::Error::duplicate_field("table"));
682 }
683 table__ = map_.next_value()?;
684 }
685 GeneratedField::IncludedUpstreamIndices => {
686 if included_upstream_indices__.is_some() {
687 return Err(serde::de::Error::duplicate_field("includedUpstreamIndices"));
688 }
689 included_upstream_indices__ =
690 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
691 .into_iter().map(|x| x.0).collect())
692 ;
693 }
694 GeneratedField::TableValueIndices => {
695 if table_value_indices__.is_some() {
696 return Err(serde::de::Error::duplicate_field("tableValueIndices"));
697 }
698 table_value_indices__ =
699 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
700 .into_iter().map(|x| x.0).collect())
701 ;
702 }
703 GeneratedField::OrderColumns => {
704 if order_columns__.is_some() {
705 return Err(serde::de::Error::duplicate_field("orderColumns"));
706 }
707 order_columns__ = Some(map_.next_value()?);
708 }
709 }
710 }
711 Ok(agg_call_state::MaterializedInputState {
712 table: table__,
713 included_upstream_indices: included_upstream_indices__.unwrap_or_default(),
714 table_value_indices: table_value_indices__.unwrap_or_default(),
715 order_columns: order_columns__.unwrap_or_default(),
716 })
717 }
718 }
719 deserializer.deserialize_struct("stream_plan.AggCallState.MaterializedInputState", FIELDS, GeneratedVisitor)
720 }
721}
722impl serde::Serialize for agg_call_state::ValueState {
723 #[allow(deprecated)]
724 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
725 where
726 S: serde::Serializer,
727 {
728 use serde::ser::SerializeStruct;
729 let len = 0;
730 let struct_ser = serializer.serialize_struct("stream_plan.AggCallState.ValueState", len)?;
731 struct_ser.end()
732 }
733}
734impl<'de> serde::Deserialize<'de> for agg_call_state::ValueState {
735 #[allow(deprecated)]
736 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
737 where
738 D: serde::Deserializer<'de>,
739 {
740 const FIELDS: &[&str] = &[
741 ];
742
743 #[allow(clippy::enum_variant_names)]
744 enum GeneratedField {
745 }
746 impl<'de> serde::Deserialize<'de> for GeneratedField {
747 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
748 where
749 D: serde::Deserializer<'de>,
750 {
751 struct GeneratedVisitor;
752
753 impl serde::de::Visitor<'_> for GeneratedVisitor {
754 type Value = GeneratedField;
755
756 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
757 write!(formatter, "expected one of: {:?}", &FIELDS)
758 }
759
760 #[allow(unused_variables)]
761 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
762 where
763 E: serde::de::Error,
764 {
765 Err(serde::de::Error::unknown_field(value, FIELDS))
766 }
767 }
768 deserializer.deserialize_identifier(GeneratedVisitor)
769 }
770 }
771 struct GeneratedVisitor;
772 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
773 type Value = agg_call_state::ValueState;
774
775 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
776 formatter.write_str("struct stream_plan.AggCallState.ValueState")
777 }
778
779 fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::ValueState, V::Error>
780 where
781 V: serde::de::MapAccess<'de>,
782 {
783 while map_.next_key::<GeneratedField>()?.is_some() {
784 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
785 }
786 Ok(agg_call_state::ValueState {
787 })
788 }
789 }
790 deserializer.deserialize_struct("stream_plan.AggCallState.ValueState", FIELDS, GeneratedVisitor)
791 }
792}
793impl serde::Serialize for AggNodeVersion {
794 #[allow(deprecated)]
795 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
796 where
797 S: serde::Serializer,
798 {
799 let variant = match self {
800 Self::Unspecified => "AGG_NODE_VERSION_UNSPECIFIED",
801 Self::Issue12140 => "AGG_NODE_VERSION_ISSUE_12140",
802 Self::Issue13465 => "AGG_NODE_VERSION_ISSUE_13465",
803 };
804 serializer.serialize_str(variant)
805 }
806}
807impl<'de> serde::Deserialize<'de> for AggNodeVersion {
808 #[allow(deprecated)]
809 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
810 where
811 D: serde::Deserializer<'de>,
812 {
813 const FIELDS: &[&str] = &[
814 "AGG_NODE_VERSION_UNSPECIFIED",
815 "AGG_NODE_VERSION_ISSUE_12140",
816 "AGG_NODE_VERSION_ISSUE_13465",
817 ];
818
819 struct GeneratedVisitor;
820
821 impl serde::de::Visitor<'_> for GeneratedVisitor {
822 type Value = AggNodeVersion;
823
824 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
825 write!(formatter, "expected one of: {:?}", &FIELDS)
826 }
827
828 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
829 where
830 E: serde::de::Error,
831 {
832 i32::try_from(v)
833 .ok()
834 .and_then(|x| x.try_into().ok())
835 .ok_or_else(|| {
836 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
837 })
838 }
839
840 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
841 where
842 E: serde::de::Error,
843 {
844 i32::try_from(v)
845 .ok()
846 .and_then(|x| x.try_into().ok())
847 .ok_or_else(|| {
848 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
849 })
850 }
851
852 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
853 where
854 E: serde::de::Error,
855 {
856 match value {
857 "AGG_NODE_VERSION_UNSPECIFIED" => Ok(AggNodeVersion::Unspecified),
858 "AGG_NODE_VERSION_ISSUE_12140" => Ok(AggNodeVersion::Issue12140),
859 "AGG_NODE_VERSION_ISSUE_13465" => Ok(AggNodeVersion::Issue13465),
860 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
861 }
862 }
863 }
864 deserializer.deserialize_any(GeneratedVisitor)
865 }
866}
867impl serde::Serialize for ArrangeNode {
868 #[allow(deprecated)]
869 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
870 where
871 S: serde::Serializer,
872 {
873 use serde::ser::SerializeStruct;
874 let mut len = 0;
875 if self.table_info.is_some() {
876 len += 1;
877 }
878 if !self.distribution_key.is_empty() {
879 len += 1;
880 }
881 if self.table.is_some() {
882 len += 1;
883 }
884 let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangeNode", len)?;
885 if let Some(v) = self.table_info.as_ref() {
886 struct_ser.serialize_field("tableInfo", v)?;
887 }
888 if !self.distribution_key.is_empty() {
889 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
890 }
891 if let Some(v) = self.table.as_ref() {
892 struct_ser.serialize_field("table", v)?;
893 }
894 struct_ser.end()
895 }
896}
897impl<'de> serde::Deserialize<'de> for ArrangeNode {
898 #[allow(deprecated)]
899 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
900 where
901 D: serde::Deserializer<'de>,
902 {
903 const FIELDS: &[&str] = &[
904 "table_info",
905 "tableInfo",
906 "distribution_key",
907 "distributionKey",
908 "table",
909 ];
910
911 #[allow(clippy::enum_variant_names)]
912 enum GeneratedField {
913 TableInfo,
914 DistributionKey,
915 Table,
916 }
917 impl<'de> serde::Deserialize<'de> for GeneratedField {
918 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
919 where
920 D: serde::Deserializer<'de>,
921 {
922 struct GeneratedVisitor;
923
924 impl serde::de::Visitor<'_> for GeneratedVisitor {
925 type Value = GeneratedField;
926
927 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
928 write!(formatter, "expected one of: {:?}", &FIELDS)
929 }
930
931 #[allow(unused_variables)]
932 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
933 where
934 E: serde::de::Error,
935 {
936 match value {
937 "tableInfo" | "table_info" => Ok(GeneratedField::TableInfo),
938 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
939 "table" => Ok(GeneratedField::Table),
940 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
941 }
942 }
943 }
944 deserializer.deserialize_identifier(GeneratedVisitor)
945 }
946 }
947 struct GeneratedVisitor;
948 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
949 type Value = ArrangeNode;
950
951 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
952 formatter.write_str("struct stream_plan.ArrangeNode")
953 }
954
955 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangeNode, V::Error>
956 where
957 V: serde::de::MapAccess<'de>,
958 {
959 let mut table_info__ = None;
960 let mut distribution_key__ = None;
961 let mut table__ = None;
962 while let Some(k) = map_.next_key()? {
963 match k {
964 GeneratedField::TableInfo => {
965 if table_info__.is_some() {
966 return Err(serde::de::Error::duplicate_field("tableInfo"));
967 }
968 table_info__ = map_.next_value()?;
969 }
970 GeneratedField::DistributionKey => {
971 if distribution_key__.is_some() {
972 return Err(serde::de::Error::duplicate_field("distributionKey"));
973 }
974 distribution_key__ =
975 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
976 .into_iter().map(|x| x.0).collect())
977 ;
978 }
979 GeneratedField::Table => {
980 if table__.is_some() {
981 return Err(serde::de::Error::duplicate_field("table"));
982 }
983 table__ = map_.next_value()?;
984 }
985 }
986 }
987 Ok(ArrangeNode {
988 table_info: table_info__,
989 distribution_key: distribution_key__.unwrap_or_default(),
990 table: table__,
991 })
992 }
993 }
994 deserializer.deserialize_struct("stream_plan.ArrangeNode", FIELDS, GeneratedVisitor)
995 }
996}
997impl serde::Serialize for ArrangementInfo {
998 #[allow(deprecated)]
999 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1000 where
1001 S: serde::Serializer,
1002 {
1003 use serde::ser::SerializeStruct;
1004 let mut len = 0;
1005 if !self.arrange_key_orders.is_empty() {
1006 len += 1;
1007 }
1008 if !self.column_descs.is_empty() {
1009 len += 1;
1010 }
1011 if self.table_desc.is_some() {
1012 len += 1;
1013 }
1014 if !self.output_col_idx.is_empty() {
1015 len += 1;
1016 }
1017 let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangementInfo", len)?;
1018 if !self.arrange_key_orders.is_empty() {
1019 struct_ser.serialize_field("arrangeKeyOrders", &self.arrange_key_orders)?;
1020 }
1021 if !self.column_descs.is_empty() {
1022 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
1023 }
1024 if let Some(v) = self.table_desc.as_ref() {
1025 struct_ser.serialize_field("tableDesc", v)?;
1026 }
1027 if !self.output_col_idx.is_empty() {
1028 struct_ser.serialize_field("outputColIdx", &self.output_col_idx)?;
1029 }
1030 struct_ser.end()
1031 }
1032}
1033impl<'de> serde::Deserialize<'de> for ArrangementInfo {
1034 #[allow(deprecated)]
1035 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1036 where
1037 D: serde::Deserializer<'de>,
1038 {
1039 const FIELDS: &[&str] = &[
1040 "arrange_key_orders",
1041 "arrangeKeyOrders",
1042 "column_descs",
1043 "columnDescs",
1044 "table_desc",
1045 "tableDesc",
1046 "output_col_idx",
1047 "outputColIdx",
1048 ];
1049
1050 #[allow(clippy::enum_variant_names)]
1051 enum GeneratedField {
1052 ArrangeKeyOrders,
1053 ColumnDescs,
1054 TableDesc,
1055 OutputColIdx,
1056 }
1057 impl<'de> serde::Deserialize<'de> for GeneratedField {
1058 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1059 where
1060 D: serde::Deserializer<'de>,
1061 {
1062 struct GeneratedVisitor;
1063
1064 impl serde::de::Visitor<'_> for GeneratedVisitor {
1065 type Value = GeneratedField;
1066
1067 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1068 write!(formatter, "expected one of: {:?}", &FIELDS)
1069 }
1070
1071 #[allow(unused_variables)]
1072 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1073 where
1074 E: serde::de::Error,
1075 {
1076 match value {
1077 "arrangeKeyOrders" | "arrange_key_orders" => Ok(GeneratedField::ArrangeKeyOrders),
1078 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
1079 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
1080 "outputColIdx" | "output_col_idx" => Ok(GeneratedField::OutputColIdx),
1081 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1082 }
1083 }
1084 }
1085 deserializer.deserialize_identifier(GeneratedVisitor)
1086 }
1087 }
1088 struct GeneratedVisitor;
1089 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1090 type Value = ArrangementInfo;
1091
1092 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1093 formatter.write_str("struct stream_plan.ArrangementInfo")
1094 }
1095
1096 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangementInfo, V::Error>
1097 where
1098 V: serde::de::MapAccess<'de>,
1099 {
1100 let mut arrange_key_orders__ = None;
1101 let mut column_descs__ = None;
1102 let mut table_desc__ = None;
1103 let mut output_col_idx__ = None;
1104 while let Some(k) = map_.next_key()? {
1105 match k {
1106 GeneratedField::ArrangeKeyOrders => {
1107 if arrange_key_orders__.is_some() {
1108 return Err(serde::de::Error::duplicate_field("arrangeKeyOrders"));
1109 }
1110 arrange_key_orders__ = Some(map_.next_value()?);
1111 }
1112 GeneratedField::ColumnDescs => {
1113 if column_descs__.is_some() {
1114 return Err(serde::de::Error::duplicate_field("columnDescs"));
1115 }
1116 column_descs__ = Some(map_.next_value()?);
1117 }
1118 GeneratedField::TableDesc => {
1119 if table_desc__.is_some() {
1120 return Err(serde::de::Error::duplicate_field("tableDesc"));
1121 }
1122 table_desc__ = map_.next_value()?;
1123 }
1124 GeneratedField::OutputColIdx => {
1125 if output_col_idx__.is_some() {
1126 return Err(serde::de::Error::duplicate_field("outputColIdx"));
1127 }
1128 output_col_idx__ =
1129 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1130 .into_iter().map(|x| x.0).collect())
1131 ;
1132 }
1133 }
1134 }
1135 Ok(ArrangementInfo {
1136 arrange_key_orders: arrange_key_orders__.unwrap_or_default(),
1137 column_descs: column_descs__.unwrap_or_default(),
1138 table_desc: table_desc__,
1139 output_col_idx: output_col_idx__.unwrap_or_default(),
1140 })
1141 }
1142 }
1143 deserializer.deserialize_struct("stream_plan.ArrangementInfo", FIELDS, GeneratedVisitor)
1144 }
1145}
1146impl serde::Serialize for AsOfJoinNode {
1147 #[allow(deprecated)]
1148 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1149 where
1150 S: serde::Serializer,
1151 {
1152 use serde::ser::SerializeStruct;
1153 let mut len = 0;
1154 if self.join_type != 0 {
1155 len += 1;
1156 }
1157 if !self.left_key.is_empty() {
1158 len += 1;
1159 }
1160 if !self.right_key.is_empty() {
1161 len += 1;
1162 }
1163 if self.left_table.is_some() {
1164 len += 1;
1165 }
1166 if self.right_table.is_some() {
1167 len += 1;
1168 }
1169 if !self.output_indices.is_empty() {
1170 len += 1;
1171 }
1172 if !self.left_deduped_input_pk_indices.is_empty() {
1173 len += 1;
1174 }
1175 if !self.right_deduped_input_pk_indices.is_empty() {
1176 len += 1;
1177 }
1178 if !self.null_safe.is_empty() {
1179 len += 1;
1180 }
1181 if self.asof_desc.is_some() {
1182 len += 1;
1183 }
1184 if self.join_encoding_type != 0 {
1185 len += 1;
1186 }
1187 if self.use_cache.is_some() {
1188 len += 1;
1189 }
1190 let mut struct_ser = serializer.serialize_struct("stream_plan.AsOfJoinNode", len)?;
1191 if self.join_type != 0 {
1192 let v = super::plan_common::AsOfJoinType::try_from(self.join_type)
1193 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
1194 struct_ser.serialize_field("joinType", &v)?;
1195 }
1196 if !self.left_key.is_empty() {
1197 struct_ser.serialize_field("leftKey", &self.left_key)?;
1198 }
1199 if !self.right_key.is_empty() {
1200 struct_ser.serialize_field("rightKey", &self.right_key)?;
1201 }
1202 if let Some(v) = self.left_table.as_ref() {
1203 struct_ser.serialize_field("leftTable", v)?;
1204 }
1205 if let Some(v) = self.right_table.as_ref() {
1206 struct_ser.serialize_field("rightTable", v)?;
1207 }
1208 if !self.output_indices.is_empty() {
1209 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
1210 }
1211 if !self.left_deduped_input_pk_indices.is_empty() {
1212 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
1213 }
1214 if !self.right_deduped_input_pk_indices.is_empty() {
1215 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
1216 }
1217 if !self.null_safe.is_empty() {
1218 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
1219 }
1220 if let Some(v) = self.asof_desc.as_ref() {
1221 struct_ser.serialize_field("asofDesc", v)?;
1222 }
1223 if self.join_encoding_type != 0 {
1224 let v = JoinEncodingType::try_from(self.join_encoding_type)
1225 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
1226 struct_ser.serialize_field("joinEncodingType", &v)?;
1227 }
1228 if let Some(v) = self.use_cache.as_ref() {
1229 struct_ser.serialize_field("useCache", v)?;
1230 }
1231 struct_ser.end()
1232 }
1233}
1234impl<'de> serde::Deserialize<'de> for AsOfJoinNode {
1235 #[allow(deprecated)]
1236 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1237 where
1238 D: serde::Deserializer<'de>,
1239 {
1240 const FIELDS: &[&str] = &[
1241 "join_type",
1242 "joinType",
1243 "left_key",
1244 "leftKey",
1245 "right_key",
1246 "rightKey",
1247 "left_table",
1248 "leftTable",
1249 "right_table",
1250 "rightTable",
1251 "output_indices",
1252 "outputIndices",
1253 "left_deduped_input_pk_indices",
1254 "leftDedupedInputPkIndices",
1255 "right_deduped_input_pk_indices",
1256 "rightDedupedInputPkIndices",
1257 "null_safe",
1258 "nullSafe",
1259 "asof_desc",
1260 "asofDesc",
1261 "join_encoding_type",
1262 "joinEncodingType",
1263 "use_cache",
1264 "useCache",
1265 ];
1266
1267 #[allow(clippy::enum_variant_names)]
1268 enum GeneratedField {
1269 JoinType,
1270 LeftKey,
1271 RightKey,
1272 LeftTable,
1273 RightTable,
1274 OutputIndices,
1275 LeftDedupedInputPkIndices,
1276 RightDedupedInputPkIndices,
1277 NullSafe,
1278 AsofDesc,
1279 JoinEncodingType,
1280 UseCache,
1281 }
1282 impl<'de> serde::Deserialize<'de> for GeneratedField {
1283 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1284 where
1285 D: serde::Deserializer<'de>,
1286 {
1287 struct GeneratedVisitor;
1288
1289 impl serde::de::Visitor<'_> for GeneratedVisitor {
1290 type Value = GeneratedField;
1291
1292 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1293 write!(formatter, "expected one of: {:?}", &FIELDS)
1294 }
1295
1296 #[allow(unused_variables)]
1297 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1298 where
1299 E: serde::de::Error,
1300 {
1301 match value {
1302 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
1303 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
1304 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
1305 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
1306 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
1307 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
1308 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
1309 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
1310 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
1311 "asofDesc" | "asof_desc" => Ok(GeneratedField::AsofDesc),
1312 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
1313 "useCache" | "use_cache" => Ok(GeneratedField::UseCache),
1314 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1315 }
1316 }
1317 }
1318 deserializer.deserialize_identifier(GeneratedVisitor)
1319 }
1320 }
1321 struct GeneratedVisitor;
1322 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1323 type Value = AsOfJoinNode;
1324
1325 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1326 formatter.write_str("struct stream_plan.AsOfJoinNode")
1327 }
1328
1329 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AsOfJoinNode, V::Error>
1330 where
1331 V: serde::de::MapAccess<'de>,
1332 {
1333 let mut join_type__ = None;
1334 let mut left_key__ = None;
1335 let mut right_key__ = None;
1336 let mut left_table__ = None;
1337 let mut right_table__ = None;
1338 let mut output_indices__ = None;
1339 let mut left_deduped_input_pk_indices__ = None;
1340 let mut right_deduped_input_pk_indices__ = None;
1341 let mut null_safe__ = None;
1342 let mut asof_desc__ = None;
1343 let mut join_encoding_type__ = None;
1344 let mut use_cache__ = None;
1345 while let Some(k) = map_.next_key()? {
1346 match k {
1347 GeneratedField::JoinType => {
1348 if join_type__.is_some() {
1349 return Err(serde::de::Error::duplicate_field("joinType"));
1350 }
1351 join_type__ = Some(map_.next_value::<super::plan_common::AsOfJoinType>()? as i32);
1352 }
1353 GeneratedField::LeftKey => {
1354 if left_key__.is_some() {
1355 return Err(serde::de::Error::duplicate_field("leftKey"));
1356 }
1357 left_key__ =
1358 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1359 .into_iter().map(|x| x.0).collect())
1360 ;
1361 }
1362 GeneratedField::RightKey => {
1363 if right_key__.is_some() {
1364 return Err(serde::de::Error::duplicate_field("rightKey"));
1365 }
1366 right_key__ =
1367 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1368 .into_iter().map(|x| x.0).collect())
1369 ;
1370 }
1371 GeneratedField::LeftTable => {
1372 if left_table__.is_some() {
1373 return Err(serde::de::Error::duplicate_field("leftTable"));
1374 }
1375 left_table__ = map_.next_value()?;
1376 }
1377 GeneratedField::RightTable => {
1378 if right_table__.is_some() {
1379 return Err(serde::de::Error::duplicate_field("rightTable"));
1380 }
1381 right_table__ = map_.next_value()?;
1382 }
1383 GeneratedField::OutputIndices => {
1384 if output_indices__.is_some() {
1385 return Err(serde::de::Error::duplicate_field("outputIndices"));
1386 }
1387 output_indices__ =
1388 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1389 .into_iter().map(|x| x.0).collect())
1390 ;
1391 }
1392 GeneratedField::LeftDedupedInputPkIndices => {
1393 if left_deduped_input_pk_indices__.is_some() {
1394 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
1395 }
1396 left_deduped_input_pk_indices__ =
1397 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1398 .into_iter().map(|x| x.0).collect())
1399 ;
1400 }
1401 GeneratedField::RightDedupedInputPkIndices => {
1402 if right_deduped_input_pk_indices__.is_some() {
1403 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
1404 }
1405 right_deduped_input_pk_indices__ =
1406 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1407 .into_iter().map(|x| x.0).collect())
1408 ;
1409 }
1410 GeneratedField::NullSafe => {
1411 if null_safe__.is_some() {
1412 return Err(serde::de::Error::duplicate_field("nullSafe"));
1413 }
1414 null_safe__ = Some(map_.next_value()?);
1415 }
1416 GeneratedField::AsofDesc => {
1417 if asof_desc__.is_some() {
1418 return Err(serde::de::Error::duplicate_field("asofDesc"));
1419 }
1420 asof_desc__ = map_.next_value()?;
1421 }
1422 GeneratedField::JoinEncodingType => {
1423 if join_encoding_type__.is_some() {
1424 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
1425 }
1426 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
1427 }
1428 GeneratedField::UseCache => {
1429 if use_cache__.is_some() {
1430 return Err(serde::de::Error::duplicate_field("useCache"));
1431 }
1432 use_cache__ = map_.next_value()?;
1433 }
1434 }
1435 }
1436 Ok(AsOfJoinNode {
1437 join_type: join_type__.unwrap_or_default(),
1438 left_key: left_key__.unwrap_or_default(),
1439 right_key: right_key__.unwrap_or_default(),
1440 left_table: left_table__,
1441 right_table: right_table__,
1442 output_indices: output_indices__.unwrap_or_default(),
1443 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
1444 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
1445 null_safe: null_safe__.unwrap_or_default(),
1446 asof_desc: asof_desc__,
1447 join_encoding_type: join_encoding_type__.unwrap_or_default(),
1448 use_cache: use_cache__,
1449 })
1450 }
1451 }
1452 deserializer.deserialize_struct("stream_plan.AsOfJoinNode", FIELDS, GeneratedVisitor)
1453 }
1454}
1455impl serde::Serialize for BackfillOrder {
1456 #[allow(deprecated)]
1457 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1458 where
1459 S: serde::Serializer,
1460 {
1461 use serde::ser::SerializeStruct;
1462 let mut len = 0;
1463 if !self.order.is_empty() {
1464 len += 1;
1465 }
1466 let mut struct_ser = serializer.serialize_struct("stream_plan.BackfillOrder", len)?;
1467 if !self.order.is_empty() {
1468 struct_ser.serialize_field("order", &self.order)?;
1469 }
1470 struct_ser.end()
1471 }
1472}
1473impl<'de> serde::Deserialize<'de> for BackfillOrder {
1474 #[allow(deprecated)]
1475 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1476 where
1477 D: serde::Deserializer<'de>,
1478 {
1479 const FIELDS: &[&str] = &[
1480 "order",
1481 ];
1482
1483 #[allow(clippy::enum_variant_names)]
1484 enum GeneratedField {
1485 Order,
1486 }
1487 impl<'de> serde::Deserialize<'de> for GeneratedField {
1488 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1489 where
1490 D: serde::Deserializer<'de>,
1491 {
1492 struct GeneratedVisitor;
1493
1494 impl serde::de::Visitor<'_> for GeneratedVisitor {
1495 type Value = GeneratedField;
1496
1497 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1498 write!(formatter, "expected one of: {:?}", &FIELDS)
1499 }
1500
1501 #[allow(unused_variables)]
1502 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1503 where
1504 E: serde::de::Error,
1505 {
1506 match value {
1507 "order" => Ok(GeneratedField::Order),
1508 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1509 }
1510 }
1511 }
1512 deserializer.deserialize_identifier(GeneratedVisitor)
1513 }
1514 }
1515 struct GeneratedVisitor;
1516 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1517 type Value = BackfillOrder;
1518
1519 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1520 formatter.write_str("struct stream_plan.BackfillOrder")
1521 }
1522
1523 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BackfillOrder, V::Error>
1524 where
1525 V: serde::de::MapAccess<'de>,
1526 {
1527 let mut order__ = None;
1528 while let Some(k) = map_.next_key()? {
1529 match k {
1530 GeneratedField::Order => {
1531 if order__.is_some() {
1532 return Err(serde::de::Error::duplicate_field("order"));
1533 }
1534 order__ = Some(
1535 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1536 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
1537 );
1538 }
1539 }
1540 }
1541 Ok(BackfillOrder {
1542 order: order__.unwrap_or_default(),
1543 })
1544 }
1545 }
1546 deserializer.deserialize_struct("stream_plan.BackfillOrder", FIELDS, GeneratedVisitor)
1547 }
1548}
1549impl serde::Serialize for Barrier {
1550 #[allow(deprecated)]
1551 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1552 where
1553 S: serde::Serializer,
1554 {
1555 use serde::ser::SerializeStruct;
1556 let mut len = 0;
1557 if self.epoch.is_some() {
1558 len += 1;
1559 }
1560 if self.mutation.is_some() {
1561 len += 1;
1562 }
1563 if !self.tracing_context.is_empty() {
1564 len += 1;
1565 }
1566 if self.kind != 0 {
1567 len += 1;
1568 }
1569 let mut struct_ser = serializer.serialize_struct("stream_plan.Barrier", len)?;
1570 if let Some(v) = self.epoch.as_ref() {
1571 struct_ser.serialize_field("epoch", v)?;
1572 }
1573 if let Some(v) = self.mutation.as_ref() {
1574 struct_ser.serialize_field("mutation", v)?;
1575 }
1576 if !self.tracing_context.is_empty() {
1577 struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
1578 }
1579 if self.kind != 0 {
1580 let v = barrier::BarrierKind::try_from(self.kind)
1581 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
1582 struct_ser.serialize_field("kind", &v)?;
1583 }
1584 struct_ser.end()
1585 }
1586}
1587impl<'de> serde::Deserialize<'de> for Barrier {
1588 #[allow(deprecated)]
1589 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1590 where
1591 D: serde::Deserializer<'de>,
1592 {
1593 const FIELDS: &[&str] = &[
1594 "epoch",
1595 "mutation",
1596 "tracing_context",
1597 "tracingContext",
1598 "kind",
1599 ];
1600
1601 #[allow(clippy::enum_variant_names)]
1602 enum GeneratedField {
1603 Epoch,
1604 Mutation,
1605 TracingContext,
1606 Kind,
1607 }
1608 impl<'de> serde::Deserialize<'de> for GeneratedField {
1609 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1610 where
1611 D: serde::Deserializer<'de>,
1612 {
1613 struct GeneratedVisitor;
1614
1615 impl serde::de::Visitor<'_> for GeneratedVisitor {
1616 type Value = GeneratedField;
1617
1618 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1619 write!(formatter, "expected one of: {:?}", &FIELDS)
1620 }
1621
1622 #[allow(unused_variables)]
1623 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1624 where
1625 E: serde::de::Error,
1626 {
1627 match value {
1628 "epoch" => Ok(GeneratedField::Epoch),
1629 "mutation" => Ok(GeneratedField::Mutation),
1630 "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
1631 "kind" => Ok(GeneratedField::Kind),
1632 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1633 }
1634 }
1635 }
1636 deserializer.deserialize_identifier(GeneratedVisitor)
1637 }
1638 }
1639 struct GeneratedVisitor;
1640 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1641 type Value = Barrier;
1642
1643 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1644 formatter.write_str("struct stream_plan.Barrier")
1645 }
1646
1647 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Barrier, V::Error>
1648 where
1649 V: serde::de::MapAccess<'de>,
1650 {
1651 let mut epoch__ = None;
1652 let mut mutation__ = None;
1653 let mut tracing_context__ = None;
1654 let mut kind__ = None;
1655 while let Some(k) = map_.next_key()? {
1656 match k {
1657 GeneratedField::Epoch => {
1658 if epoch__.is_some() {
1659 return Err(serde::de::Error::duplicate_field("epoch"));
1660 }
1661 epoch__ = map_.next_value()?;
1662 }
1663 GeneratedField::Mutation => {
1664 if mutation__.is_some() {
1665 return Err(serde::de::Error::duplicate_field("mutation"));
1666 }
1667 mutation__ = map_.next_value()?;
1668 }
1669 GeneratedField::TracingContext => {
1670 if tracing_context__.is_some() {
1671 return Err(serde::de::Error::duplicate_field("tracingContext"));
1672 }
1673 tracing_context__ = Some(
1674 map_.next_value::<std::collections::HashMap<_, _>>()?
1675 );
1676 }
1677 GeneratedField::Kind => {
1678 if kind__.is_some() {
1679 return Err(serde::de::Error::duplicate_field("kind"));
1680 }
1681 kind__ = Some(map_.next_value::<barrier::BarrierKind>()? as i32);
1682 }
1683 }
1684 }
1685 Ok(Barrier {
1686 epoch: epoch__,
1687 mutation: mutation__,
1688 tracing_context: tracing_context__.unwrap_or_default(),
1689 kind: kind__.unwrap_or_default(),
1690 })
1691 }
1692 }
1693 deserializer.deserialize_struct("stream_plan.Barrier", FIELDS, GeneratedVisitor)
1694 }
1695}
1696impl serde::Serialize for barrier::BarrierKind {
1697 #[allow(deprecated)]
1698 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1699 where
1700 S: serde::Serializer,
1701 {
1702 let variant = match self {
1703 Self::Unspecified => "BARRIER_KIND_UNSPECIFIED",
1704 Self::Initial => "BARRIER_KIND_INITIAL",
1705 Self::Barrier => "BARRIER_KIND_BARRIER",
1706 Self::Checkpoint => "BARRIER_KIND_CHECKPOINT",
1707 };
1708 serializer.serialize_str(variant)
1709 }
1710}
1711impl<'de> serde::Deserialize<'de> for barrier::BarrierKind {
1712 #[allow(deprecated)]
1713 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1714 where
1715 D: serde::Deserializer<'de>,
1716 {
1717 const FIELDS: &[&str] = &[
1718 "BARRIER_KIND_UNSPECIFIED",
1719 "BARRIER_KIND_INITIAL",
1720 "BARRIER_KIND_BARRIER",
1721 "BARRIER_KIND_CHECKPOINT",
1722 ];
1723
1724 struct GeneratedVisitor;
1725
1726 impl serde::de::Visitor<'_> for GeneratedVisitor {
1727 type Value = barrier::BarrierKind;
1728
1729 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1730 write!(formatter, "expected one of: {:?}", &FIELDS)
1731 }
1732
1733 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1734 where
1735 E: serde::de::Error,
1736 {
1737 i32::try_from(v)
1738 .ok()
1739 .and_then(|x| x.try_into().ok())
1740 .ok_or_else(|| {
1741 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1742 })
1743 }
1744
1745 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1746 where
1747 E: serde::de::Error,
1748 {
1749 i32::try_from(v)
1750 .ok()
1751 .and_then(|x| x.try_into().ok())
1752 .ok_or_else(|| {
1753 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1754 })
1755 }
1756
1757 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1758 where
1759 E: serde::de::Error,
1760 {
1761 match value {
1762 "BARRIER_KIND_UNSPECIFIED" => Ok(barrier::BarrierKind::Unspecified),
1763 "BARRIER_KIND_INITIAL" => Ok(barrier::BarrierKind::Initial),
1764 "BARRIER_KIND_BARRIER" => Ok(barrier::BarrierKind::Barrier),
1765 "BARRIER_KIND_CHECKPOINT" => Ok(barrier::BarrierKind::Checkpoint),
1766 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1767 }
1768 }
1769 }
1770 deserializer.deserialize_any(GeneratedVisitor)
1771 }
1772}
1773impl serde::Serialize for BarrierMutation {
1774 #[allow(deprecated)]
1775 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1776 where
1777 S: serde::Serializer,
1778 {
1779 use serde::ser::SerializeStruct;
1780 let mut len = 0;
1781 if self.mutation.is_some() {
1782 len += 1;
1783 }
1784 let mut struct_ser = serializer.serialize_struct("stream_plan.BarrierMutation", len)?;
1785 if let Some(v) = self.mutation.as_ref() {
1786 match v {
1787 barrier_mutation::Mutation::Add(v) => {
1788 struct_ser.serialize_field("add", v)?;
1789 }
1790 barrier_mutation::Mutation::Stop(v) => {
1791 struct_ser.serialize_field("stop", v)?;
1792 }
1793 barrier_mutation::Mutation::Update(v) => {
1794 struct_ser.serialize_field("update", v)?;
1795 }
1796 barrier_mutation::Mutation::Splits(v) => {
1797 struct_ser.serialize_field("splits", v)?;
1798 }
1799 barrier_mutation::Mutation::Pause(v) => {
1800 struct_ser.serialize_field("pause", v)?;
1801 }
1802 barrier_mutation::Mutation::Resume(v) => {
1803 struct_ser.serialize_field("resume", v)?;
1804 }
1805 barrier_mutation::Mutation::Throttle(v) => {
1806 struct_ser.serialize_field("throttle", v)?;
1807 }
1808 barrier_mutation::Mutation::DropSubscriptions(v) => {
1809 struct_ser.serialize_field("dropSubscriptions", v)?;
1810 }
1811 barrier_mutation::Mutation::ConnectorPropsChange(v) => {
1812 struct_ser.serialize_field("connectorPropsChange", v)?;
1813 }
1814 barrier_mutation::Mutation::StartFragmentBackfill(v) => {
1815 struct_ser.serialize_field("startFragmentBackfill", v)?;
1816 }
1817 barrier_mutation::Mutation::RefreshStart(v) => {
1818 struct_ser.serialize_field("refreshStart", v)?;
1819 }
1820 barrier_mutation::Mutation::LoadFinish(v) => {
1821 struct_ser.serialize_field("loadFinish", v)?;
1822 }
1823 barrier_mutation::Mutation::ListFinish(v) => {
1824 struct_ser.serialize_field("listFinish", v)?;
1825 }
1826 barrier_mutation::Mutation::ResetSource(v) => {
1827 struct_ser.serialize_field("resetSource", v)?;
1828 }
1829 barrier_mutation::Mutation::InjectSourceOffsets(v) => {
1830 struct_ser.serialize_field("injectSourceOffsets", v)?;
1831 }
1832 }
1833 }
1834 struct_ser.end()
1835 }
1836}
1837impl<'de> serde::Deserialize<'de> for BarrierMutation {
1838 #[allow(deprecated)]
1839 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1840 where
1841 D: serde::Deserializer<'de>,
1842 {
1843 const FIELDS: &[&str] = &[
1844 "add",
1845 "stop",
1846 "update",
1847 "splits",
1848 "pause",
1849 "resume",
1850 "throttle",
1851 "drop_subscriptions",
1852 "dropSubscriptions",
1853 "connector_props_change",
1854 "connectorPropsChange",
1855 "start_fragment_backfill",
1856 "startFragmentBackfill",
1857 "refresh_start",
1858 "refreshStart",
1859 "load_finish",
1860 "loadFinish",
1861 "list_finish",
1862 "listFinish",
1863 "reset_source",
1864 "resetSource",
1865 "inject_source_offsets",
1866 "injectSourceOffsets",
1867 ];
1868
1869 #[allow(clippy::enum_variant_names)]
1870 enum GeneratedField {
1871 Add,
1872 Stop,
1873 Update,
1874 Splits,
1875 Pause,
1876 Resume,
1877 Throttle,
1878 DropSubscriptions,
1879 ConnectorPropsChange,
1880 StartFragmentBackfill,
1881 RefreshStart,
1882 LoadFinish,
1883 ListFinish,
1884 ResetSource,
1885 InjectSourceOffsets,
1886 }
1887 impl<'de> serde::Deserialize<'de> for GeneratedField {
1888 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1889 where
1890 D: serde::Deserializer<'de>,
1891 {
1892 struct GeneratedVisitor;
1893
1894 impl serde::de::Visitor<'_> for GeneratedVisitor {
1895 type Value = GeneratedField;
1896
1897 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1898 write!(formatter, "expected one of: {:?}", &FIELDS)
1899 }
1900
1901 #[allow(unused_variables)]
1902 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1903 where
1904 E: serde::de::Error,
1905 {
1906 match value {
1907 "add" => Ok(GeneratedField::Add),
1908 "stop" => Ok(GeneratedField::Stop),
1909 "update" => Ok(GeneratedField::Update),
1910 "splits" => Ok(GeneratedField::Splits),
1911 "pause" => Ok(GeneratedField::Pause),
1912 "resume" => Ok(GeneratedField::Resume),
1913 "throttle" => Ok(GeneratedField::Throttle),
1914 "dropSubscriptions" | "drop_subscriptions" => Ok(GeneratedField::DropSubscriptions),
1915 "connectorPropsChange" | "connector_props_change" => Ok(GeneratedField::ConnectorPropsChange),
1916 "startFragmentBackfill" | "start_fragment_backfill" => Ok(GeneratedField::StartFragmentBackfill),
1917 "refreshStart" | "refresh_start" => Ok(GeneratedField::RefreshStart),
1918 "loadFinish" | "load_finish" => Ok(GeneratedField::LoadFinish),
1919 "listFinish" | "list_finish" => Ok(GeneratedField::ListFinish),
1920 "resetSource" | "reset_source" => Ok(GeneratedField::ResetSource),
1921 "injectSourceOffsets" | "inject_source_offsets" => Ok(GeneratedField::InjectSourceOffsets),
1922 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1923 }
1924 }
1925 }
1926 deserializer.deserialize_identifier(GeneratedVisitor)
1927 }
1928 }
1929 struct GeneratedVisitor;
1930 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1931 type Value = BarrierMutation;
1932
1933 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1934 formatter.write_str("struct stream_plan.BarrierMutation")
1935 }
1936
1937 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierMutation, V::Error>
1938 where
1939 V: serde::de::MapAccess<'de>,
1940 {
1941 let mut mutation__ = None;
1942 while let Some(k) = map_.next_key()? {
1943 match k {
1944 GeneratedField::Add => {
1945 if mutation__.is_some() {
1946 return Err(serde::de::Error::duplicate_field("add"));
1947 }
1948 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Add)
1949;
1950 }
1951 GeneratedField::Stop => {
1952 if mutation__.is_some() {
1953 return Err(serde::de::Error::duplicate_field("stop"));
1954 }
1955 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Stop)
1956;
1957 }
1958 GeneratedField::Update => {
1959 if mutation__.is_some() {
1960 return Err(serde::de::Error::duplicate_field("update"));
1961 }
1962 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Update)
1963;
1964 }
1965 GeneratedField::Splits => {
1966 if mutation__.is_some() {
1967 return Err(serde::de::Error::duplicate_field("splits"));
1968 }
1969 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Splits)
1970;
1971 }
1972 GeneratedField::Pause => {
1973 if mutation__.is_some() {
1974 return Err(serde::de::Error::duplicate_field("pause"));
1975 }
1976 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Pause)
1977;
1978 }
1979 GeneratedField::Resume => {
1980 if mutation__.is_some() {
1981 return Err(serde::de::Error::duplicate_field("resume"));
1982 }
1983 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Resume)
1984;
1985 }
1986 GeneratedField::Throttle => {
1987 if mutation__.is_some() {
1988 return Err(serde::de::Error::duplicate_field("throttle"));
1989 }
1990 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Throttle)
1991;
1992 }
1993 GeneratedField::DropSubscriptions => {
1994 if mutation__.is_some() {
1995 return Err(serde::de::Error::duplicate_field("dropSubscriptions"));
1996 }
1997 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::DropSubscriptions)
1998;
1999 }
2000 GeneratedField::ConnectorPropsChange => {
2001 if mutation__.is_some() {
2002 return Err(serde::de::Error::duplicate_field("connectorPropsChange"));
2003 }
2004 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ConnectorPropsChange)
2005;
2006 }
2007 GeneratedField::StartFragmentBackfill => {
2008 if mutation__.is_some() {
2009 return Err(serde::de::Error::duplicate_field("startFragmentBackfill"));
2010 }
2011 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::StartFragmentBackfill)
2012;
2013 }
2014 GeneratedField::RefreshStart => {
2015 if mutation__.is_some() {
2016 return Err(serde::de::Error::duplicate_field("refreshStart"));
2017 }
2018 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::RefreshStart)
2019;
2020 }
2021 GeneratedField::LoadFinish => {
2022 if mutation__.is_some() {
2023 return Err(serde::de::Error::duplicate_field("loadFinish"));
2024 }
2025 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::LoadFinish)
2026;
2027 }
2028 GeneratedField::ListFinish => {
2029 if mutation__.is_some() {
2030 return Err(serde::de::Error::duplicate_field("listFinish"));
2031 }
2032 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ListFinish)
2033;
2034 }
2035 GeneratedField::ResetSource => {
2036 if mutation__.is_some() {
2037 return Err(serde::de::Error::duplicate_field("resetSource"));
2038 }
2039 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ResetSource)
2040;
2041 }
2042 GeneratedField::InjectSourceOffsets => {
2043 if mutation__.is_some() {
2044 return Err(serde::de::Error::duplicate_field("injectSourceOffsets"));
2045 }
2046 mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::InjectSourceOffsets)
2047;
2048 }
2049 }
2050 }
2051 Ok(BarrierMutation {
2052 mutation: mutation__,
2053 })
2054 }
2055 }
2056 deserializer.deserialize_struct("stream_plan.BarrierMutation", FIELDS, GeneratedVisitor)
2057 }
2058}
2059impl serde::Serialize for BarrierRecvNode {
2060 #[allow(deprecated)]
2061 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2062 where
2063 S: serde::Serializer,
2064 {
2065 use serde::ser::SerializeStruct;
2066 let len = 0;
2067 let struct_ser = serializer.serialize_struct("stream_plan.BarrierRecvNode", len)?;
2068 struct_ser.end()
2069 }
2070}
2071impl<'de> serde::Deserialize<'de> for BarrierRecvNode {
2072 #[allow(deprecated)]
2073 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2074 where
2075 D: serde::Deserializer<'de>,
2076 {
2077 const FIELDS: &[&str] = &[
2078 ];
2079
2080 #[allow(clippy::enum_variant_names)]
2081 enum GeneratedField {
2082 }
2083 impl<'de> serde::Deserialize<'de> for GeneratedField {
2084 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2085 where
2086 D: serde::Deserializer<'de>,
2087 {
2088 struct GeneratedVisitor;
2089
2090 impl serde::de::Visitor<'_> for GeneratedVisitor {
2091 type Value = GeneratedField;
2092
2093 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2094 write!(formatter, "expected one of: {:?}", &FIELDS)
2095 }
2096
2097 #[allow(unused_variables)]
2098 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2099 where
2100 E: serde::de::Error,
2101 {
2102 Err(serde::de::Error::unknown_field(value, FIELDS))
2103 }
2104 }
2105 deserializer.deserialize_identifier(GeneratedVisitor)
2106 }
2107 }
2108 struct GeneratedVisitor;
2109 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2110 type Value = BarrierRecvNode;
2111
2112 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2113 formatter.write_str("struct stream_plan.BarrierRecvNode")
2114 }
2115
2116 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierRecvNode, V::Error>
2117 where
2118 V: serde::de::MapAccess<'de>,
2119 {
2120 while map_.next_key::<GeneratedField>()?.is_some() {
2121 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2122 }
2123 Ok(BarrierRecvNode {
2124 })
2125 }
2126 }
2127 deserializer.deserialize_struct("stream_plan.BarrierRecvNode", FIELDS, GeneratedVisitor)
2128 }
2129}
2130impl serde::Serialize for BatchPlanNode {
2131 #[allow(deprecated)]
2132 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2133 where
2134 S: serde::Serializer,
2135 {
2136 use serde::ser::SerializeStruct;
2137 let mut len = 0;
2138 if self.table_desc.is_some() {
2139 len += 1;
2140 }
2141 if !self.column_ids.is_empty() {
2142 len += 1;
2143 }
2144 let mut struct_ser = serializer.serialize_struct("stream_plan.BatchPlanNode", len)?;
2145 if let Some(v) = self.table_desc.as_ref() {
2146 struct_ser.serialize_field("tableDesc", v)?;
2147 }
2148 if !self.column_ids.is_empty() {
2149 struct_ser.serialize_field("columnIds", &self.column_ids)?;
2150 }
2151 struct_ser.end()
2152 }
2153}
2154impl<'de> serde::Deserialize<'de> for BatchPlanNode {
2155 #[allow(deprecated)]
2156 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2157 where
2158 D: serde::Deserializer<'de>,
2159 {
2160 const FIELDS: &[&str] = &[
2161 "table_desc",
2162 "tableDesc",
2163 "column_ids",
2164 "columnIds",
2165 ];
2166
2167 #[allow(clippy::enum_variant_names)]
2168 enum GeneratedField {
2169 TableDesc,
2170 ColumnIds,
2171 }
2172 impl<'de> serde::Deserialize<'de> for GeneratedField {
2173 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2174 where
2175 D: serde::Deserializer<'de>,
2176 {
2177 struct GeneratedVisitor;
2178
2179 impl serde::de::Visitor<'_> for GeneratedVisitor {
2180 type Value = GeneratedField;
2181
2182 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2183 write!(formatter, "expected one of: {:?}", &FIELDS)
2184 }
2185
2186 #[allow(unused_variables)]
2187 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2188 where
2189 E: serde::de::Error,
2190 {
2191 match value {
2192 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
2193 "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
2194 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2195 }
2196 }
2197 }
2198 deserializer.deserialize_identifier(GeneratedVisitor)
2199 }
2200 }
2201 struct GeneratedVisitor;
2202 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2203 type Value = BatchPlanNode;
2204
2205 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2206 formatter.write_str("struct stream_plan.BatchPlanNode")
2207 }
2208
2209 fn visit_map<V>(self, mut map_: V) -> std::result::Result<BatchPlanNode, V::Error>
2210 where
2211 V: serde::de::MapAccess<'de>,
2212 {
2213 let mut table_desc__ = None;
2214 let mut column_ids__ = None;
2215 while let Some(k) = map_.next_key()? {
2216 match k {
2217 GeneratedField::TableDesc => {
2218 if table_desc__.is_some() {
2219 return Err(serde::de::Error::duplicate_field("tableDesc"));
2220 }
2221 table_desc__ = map_.next_value()?;
2222 }
2223 GeneratedField::ColumnIds => {
2224 if column_ids__.is_some() {
2225 return Err(serde::de::Error::duplicate_field("columnIds"));
2226 }
2227 column_ids__ =
2228 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2229 .into_iter().map(|x| x.0).collect())
2230 ;
2231 }
2232 }
2233 }
2234 Ok(BatchPlanNode {
2235 table_desc: table_desc__,
2236 column_ids: column_ids__.unwrap_or_default(),
2237 })
2238 }
2239 }
2240 deserializer.deserialize_struct("stream_plan.BatchPlanNode", FIELDS, GeneratedVisitor)
2241 }
2242}
2243impl serde::Serialize for CdcFilterNode {
2244 #[allow(deprecated)]
2245 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2246 where
2247 S: serde::Serializer,
2248 {
2249 use serde::ser::SerializeStruct;
2250 let mut len = 0;
2251 if self.search_condition.is_some() {
2252 len += 1;
2253 }
2254 if self.upstream_source_id != 0 {
2255 len += 1;
2256 }
2257 let mut struct_ser = serializer.serialize_struct("stream_plan.CdcFilterNode", len)?;
2258 if let Some(v) = self.search_condition.as_ref() {
2259 struct_ser.serialize_field("searchCondition", v)?;
2260 }
2261 if self.upstream_source_id != 0 {
2262 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
2263 }
2264 struct_ser.end()
2265 }
2266}
2267impl<'de> serde::Deserialize<'de> for CdcFilterNode {
2268 #[allow(deprecated)]
2269 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2270 where
2271 D: serde::Deserializer<'de>,
2272 {
2273 const FIELDS: &[&str] = &[
2274 "search_condition",
2275 "searchCondition",
2276 "upstream_source_id",
2277 "upstreamSourceId",
2278 ];
2279
2280 #[allow(clippy::enum_variant_names)]
2281 enum GeneratedField {
2282 SearchCondition,
2283 UpstreamSourceId,
2284 }
2285 impl<'de> serde::Deserialize<'de> for GeneratedField {
2286 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2287 where
2288 D: serde::Deserializer<'de>,
2289 {
2290 struct GeneratedVisitor;
2291
2292 impl serde::de::Visitor<'_> for GeneratedVisitor {
2293 type Value = GeneratedField;
2294
2295 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2296 write!(formatter, "expected one of: {:?}", &FIELDS)
2297 }
2298
2299 #[allow(unused_variables)]
2300 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2301 where
2302 E: serde::de::Error,
2303 {
2304 match value {
2305 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
2306 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
2307 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2308 }
2309 }
2310 }
2311 deserializer.deserialize_identifier(GeneratedVisitor)
2312 }
2313 }
2314 struct GeneratedVisitor;
2315 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2316 type Value = CdcFilterNode;
2317
2318 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2319 formatter.write_str("struct stream_plan.CdcFilterNode")
2320 }
2321
2322 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcFilterNode, V::Error>
2323 where
2324 V: serde::de::MapAccess<'de>,
2325 {
2326 let mut search_condition__ = None;
2327 let mut upstream_source_id__ = None;
2328 while let Some(k) = map_.next_key()? {
2329 match k {
2330 GeneratedField::SearchCondition => {
2331 if search_condition__.is_some() {
2332 return Err(serde::de::Error::duplicate_field("searchCondition"));
2333 }
2334 search_condition__ = map_.next_value()?;
2335 }
2336 GeneratedField::UpstreamSourceId => {
2337 if upstream_source_id__.is_some() {
2338 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
2339 }
2340 upstream_source_id__ =
2341 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2342 ;
2343 }
2344 }
2345 }
2346 Ok(CdcFilterNode {
2347 search_condition: search_condition__,
2348 upstream_source_id: upstream_source_id__.unwrap_or_default(),
2349 })
2350 }
2351 }
2352 deserializer.deserialize_struct("stream_plan.CdcFilterNode", FIELDS, GeneratedVisitor)
2353 }
2354}
2355impl serde::Serialize for ChangeLogNode {
2356 #[allow(deprecated)]
2357 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2358 where
2359 S: serde::Serializer,
2360 {
2361 use serde::ser::SerializeStruct;
2362 let mut len = 0;
2363 if self.need_op {
2364 len += 1;
2365 }
2366 if !self.distribution_keys.is_empty() {
2367 len += 1;
2368 }
2369 let mut struct_ser = serializer.serialize_struct("stream_plan.ChangeLogNode", len)?;
2370 if self.need_op {
2371 struct_ser.serialize_field("needOp", &self.need_op)?;
2372 }
2373 if !self.distribution_keys.is_empty() {
2374 struct_ser.serialize_field("distributionKeys", &self.distribution_keys)?;
2375 }
2376 struct_ser.end()
2377 }
2378}
2379impl<'de> serde::Deserialize<'de> for ChangeLogNode {
2380 #[allow(deprecated)]
2381 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2382 where
2383 D: serde::Deserializer<'de>,
2384 {
2385 const FIELDS: &[&str] = &[
2386 "need_op",
2387 "needOp",
2388 "distribution_keys",
2389 "distributionKeys",
2390 ];
2391
2392 #[allow(clippy::enum_variant_names)]
2393 enum GeneratedField {
2394 NeedOp,
2395 DistributionKeys,
2396 }
2397 impl<'de> serde::Deserialize<'de> for GeneratedField {
2398 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2399 where
2400 D: serde::Deserializer<'de>,
2401 {
2402 struct GeneratedVisitor;
2403
2404 impl serde::de::Visitor<'_> for GeneratedVisitor {
2405 type Value = GeneratedField;
2406
2407 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2408 write!(formatter, "expected one of: {:?}", &FIELDS)
2409 }
2410
2411 #[allow(unused_variables)]
2412 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2413 where
2414 E: serde::de::Error,
2415 {
2416 match value {
2417 "needOp" | "need_op" => Ok(GeneratedField::NeedOp),
2418 "distributionKeys" | "distribution_keys" => Ok(GeneratedField::DistributionKeys),
2419 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2420 }
2421 }
2422 }
2423 deserializer.deserialize_identifier(GeneratedVisitor)
2424 }
2425 }
2426 struct GeneratedVisitor;
2427 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2428 type Value = ChangeLogNode;
2429
2430 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2431 formatter.write_str("struct stream_plan.ChangeLogNode")
2432 }
2433
2434 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ChangeLogNode, V::Error>
2435 where
2436 V: serde::de::MapAccess<'de>,
2437 {
2438 let mut need_op__ = None;
2439 let mut distribution_keys__ = None;
2440 while let Some(k) = map_.next_key()? {
2441 match k {
2442 GeneratedField::NeedOp => {
2443 if need_op__.is_some() {
2444 return Err(serde::de::Error::duplicate_field("needOp"));
2445 }
2446 need_op__ = Some(map_.next_value()?);
2447 }
2448 GeneratedField::DistributionKeys => {
2449 if distribution_keys__.is_some() {
2450 return Err(serde::de::Error::duplicate_field("distributionKeys"));
2451 }
2452 distribution_keys__ =
2453 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2454 .into_iter().map(|x| x.0).collect())
2455 ;
2456 }
2457 }
2458 }
2459 Ok(ChangeLogNode {
2460 need_op: need_op__.unwrap_or_default(),
2461 distribution_keys: distribution_keys__.unwrap_or_default(),
2462 })
2463 }
2464 }
2465 deserializer.deserialize_struct("stream_plan.ChangeLogNode", FIELDS, GeneratedVisitor)
2466 }
2467}
2468impl serde::Serialize for Columns {
2469 #[allow(deprecated)]
2470 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2471 where
2472 S: serde::Serializer,
2473 {
2474 use serde::ser::SerializeStruct;
2475 let mut len = 0;
2476 if !self.columns.is_empty() {
2477 len += 1;
2478 }
2479 let mut struct_ser = serializer.serialize_struct("stream_plan.Columns", len)?;
2480 if !self.columns.is_empty() {
2481 struct_ser.serialize_field("columns", &self.columns)?;
2482 }
2483 struct_ser.end()
2484 }
2485}
2486impl<'de> serde::Deserialize<'de> for Columns {
2487 #[allow(deprecated)]
2488 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2489 where
2490 D: serde::Deserializer<'de>,
2491 {
2492 const FIELDS: &[&str] = &[
2493 "columns",
2494 ];
2495
2496 #[allow(clippy::enum_variant_names)]
2497 enum GeneratedField {
2498 Columns,
2499 }
2500 impl<'de> serde::Deserialize<'de> for GeneratedField {
2501 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2502 where
2503 D: serde::Deserializer<'de>,
2504 {
2505 struct GeneratedVisitor;
2506
2507 impl serde::de::Visitor<'_> for GeneratedVisitor {
2508 type Value = GeneratedField;
2509
2510 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2511 write!(formatter, "expected one of: {:?}", &FIELDS)
2512 }
2513
2514 #[allow(unused_variables)]
2515 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2516 where
2517 E: serde::de::Error,
2518 {
2519 match value {
2520 "columns" => Ok(GeneratedField::Columns),
2521 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2522 }
2523 }
2524 }
2525 deserializer.deserialize_identifier(GeneratedVisitor)
2526 }
2527 }
2528 struct GeneratedVisitor;
2529 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2530 type Value = Columns;
2531
2532 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2533 formatter.write_str("struct stream_plan.Columns")
2534 }
2535
2536 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Columns, V::Error>
2537 where
2538 V: serde::de::MapAccess<'de>,
2539 {
2540 let mut columns__ = None;
2541 while let Some(k) = map_.next_key()? {
2542 match k {
2543 GeneratedField::Columns => {
2544 if columns__.is_some() {
2545 return Err(serde::de::Error::duplicate_field("columns"));
2546 }
2547 columns__ = Some(map_.next_value()?);
2548 }
2549 }
2550 }
2551 Ok(Columns {
2552 columns: columns__.unwrap_or_default(),
2553 })
2554 }
2555 }
2556 deserializer.deserialize_struct("stream_plan.Columns", FIELDS, GeneratedVisitor)
2557 }
2558}
2559impl serde::Serialize for ConnectorPropsChangeMutation {
2560 #[allow(deprecated)]
2561 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2562 where
2563 S: serde::Serializer,
2564 {
2565 use serde::ser::SerializeStruct;
2566 let mut len = 0;
2567 if !self.connector_props_infos.is_empty() {
2568 len += 1;
2569 }
2570 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation", len)?;
2571 if !self.connector_props_infos.is_empty() {
2572 struct_ser.serialize_field("connectorPropsInfos", &self.connector_props_infos)?;
2573 }
2574 struct_ser.end()
2575 }
2576}
2577impl<'de> serde::Deserialize<'de> for ConnectorPropsChangeMutation {
2578 #[allow(deprecated)]
2579 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2580 where
2581 D: serde::Deserializer<'de>,
2582 {
2583 const FIELDS: &[&str] = &[
2584 "connector_props_infos",
2585 "connectorPropsInfos",
2586 ];
2587
2588 #[allow(clippy::enum_variant_names)]
2589 enum GeneratedField {
2590 ConnectorPropsInfos,
2591 }
2592 impl<'de> serde::Deserialize<'de> for GeneratedField {
2593 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2594 where
2595 D: serde::Deserializer<'de>,
2596 {
2597 struct GeneratedVisitor;
2598
2599 impl serde::de::Visitor<'_> for GeneratedVisitor {
2600 type Value = GeneratedField;
2601
2602 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2603 write!(formatter, "expected one of: {:?}", &FIELDS)
2604 }
2605
2606 #[allow(unused_variables)]
2607 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2608 where
2609 E: serde::de::Error,
2610 {
2611 match value {
2612 "connectorPropsInfos" | "connector_props_infos" => Ok(GeneratedField::ConnectorPropsInfos),
2613 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2614 }
2615 }
2616 }
2617 deserializer.deserialize_identifier(GeneratedVisitor)
2618 }
2619 }
2620 struct GeneratedVisitor;
2621 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2622 type Value = ConnectorPropsChangeMutation;
2623
2624 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2625 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation")
2626 }
2627
2628 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectorPropsChangeMutation, V::Error>
2629 where
2630 V: serde::de::MapAccess<'de>,
2631 {
2632 let mut connector_props_infos__ = None;
2633 while let Some(k) = map_.next_key()? {
2634 match k {
2635 GeneratedField::ConnectorPropsInfos => {
2636 if connector_props_infos__.is_some() {
2637 return Err(serde::de::Error::duplicate_field("connectorPropsInfos"));
2638 }
2639 connector_props_infos__ = Some(
2640 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
2641 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
2642 );
2643 }
2644 }
2645 }
2646 Ok(ConnectorPropsChangeMutation {
2647 connector_props_infos: connector_props_infos__.unwrap_or_default(),
2648 })
2649 }
2650 }
2651 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation", FIELDS, GeneratedVisitor)
2652 }
2653}
2654impl serde::Serialize for connector_props_change_mutation::ConnectorPropsInfo {
2655 #[allow(deprecated)]
2656 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2657 where
2658 S: serde::Serializer,
2659 {
2660 use serde::ser::SerializeStruct;
2661 let mut len = 0;
2662 if !self.connector_props_info.is_empty() {
2663 len += 1;
2664 }
2665 let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", len)?;
2666 if !self.connector_props_info.is_empty() {
2667 struct_ser.serialize_field("connectorPropsInfo", &self.connector_props_info)?;
2668 }
2669 struct_ser.end()
2670 }
2671}
2672impl<'de> serde::Deserialize<'de> for connector_props_change_mutation::ConnectorPropsInfo {
2673 #[allow(deprecated)]
2674 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2675 where
2676 D: serde::Deserializer<'de>,
2677 {
2678 const FIELDS: &[&str] = &[
2679 "connector_props_info",
2680 "connectorPropsInfo",
2681 ];
2682
2683 #[allow(clippy::enum_variant_names)]
2684 enum GeneratedField {
2685 ConnectorPropsInfo,
2686 }
2687 impl<'de> serde::Deserialize<'de> for GeneratedField {
2688 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2689 where
2690 D: serde::Deserializer<'de>,
2691 {
2692 struct GeneratedVisitor;
2693
2694 impl serde::de::Visitor<'_> for GeneratedVisitor {
2695 type Value = GeneratedField;
2696
2697 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2698 write!(formatter, "expected one of: {:?}", &FIELDS)
2699 }
2700
2701 #[allow(unused_variables)]
2702 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2703 where
2704 E: serde::de::Error,
2705 {
2706 match value {
2707 "connectorPropsInfo" | "connector_props_info" => Ok(GeneratedField::ConnectorPropsInfo),
2708 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2709 }
2710 }
2711 }
2712 deserializer.deserialize_identifier(GeneratedVisitor)
2713 }
2714 }
2715 struct GeneratedVisitor;
2716 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2717 type Value = connector_props_change_mutation::ConnectorPropsInfo;
2718
2719 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2720 formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo")
2721 }
2722
2723 fn visit_map<V>(self, mut map_: V) -> std::result::Result<connector_props_change_mutation::ConnectorPropsInfo, V::Error>
2724 where
2725 V: serde::de::MapAccess<'de>,
2726 {
2727 let mut connector_props_info__ = None;
2728 while let Some(k) = map_.next_key()? {
2729 match k {
2730 GeneratedField::ConnectorPropsInfo => {
2731 if connector_props_info__.is_some() {
2732 return Err(serde::de::Error::duplicate_field("connectorPropsInfo"));
2733 }
2734 connector_props_info__ = Some(
2735 map_.next_value::<std::collections::HashMap<_, _>>()?
2736 );
2737 }
2738 }
2739 }
2740 Ok(connector_props_change_mutation::ConnectorPropsInfo {
2741 connector_props_info: connector_props_info__.unwrap_or_default(),
2742 })
2743 }
2744 }
2745 deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", FIELDS, GeneratedVisitor)
2746 }
2747}
2748impl serde::Serialize for DedupNode {
2749 #[allow(deprecated)]
2750 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2751 where
2752 S: serde::Serializer,
2753 {
2754 use serde::ser::SerializeStruct;
2755 let mut len = 0;
2756 if self.state_table.is_some() {
2757 len += 1;
2758 }
2759 if !self.dedup_column_indices.is_empty() {
2760 len += 1;
2761 }
2762 let mut struct_ser = serializer.serialize_struct("stream_plan.DedupNode", len)?;
2763 if let Some(v) = self.state_table.as_ref() {
2764 struct_ser.serialize_field("stateTable", v)?;
2765 }
2766 if !self.dedup_column_indices.is_empty() {
2767 struct_ser.serialize_field("dedupColumnIndices", &self.dedup_column_indices)?;
2768 }
2769 struct_ser.end()
2770 }
2771}
2772impl<'de> serde::Deserialize<'de> for DedupNode {
2773 #[allow(deprecated)]
2774 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2775 where
2776 D: serde::Deserializer<'de>,
2777 {
2778 const FIELDS: &[&str] = &[
2779 "state_table",
2780 "stateTable",
2781 "dedup_column_indices",
2782 "dedupColumnIndices",
2783 ];
2784
2785 #[allow(clippy::enum_variant_names)]
2786 enum GeneratedField {
2787 StateTable,
2788 DedupColumnIndices,
2789 }
2790 impl<'de> serde::Deserialize<'de> for GeneratedField {
2791 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2792 where
2793 D: serde::Deserializer<'de>,
2794 {
2795 struct GeneratedVisitor;
2796
2797 impl serde::de::Visitor<'_> for GeneratedVisitor {
2798 type Value = GeneratedField;
2799
2800 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2801 write!(formatter, "expected one of: {:?}", &FIELDS)
2802 }
2803
2804 #[allow(unused_variables)]
2805 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2806 where
2807 E: serde::de::Error,
2808 {
2809 match value {
2810 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
2811 "dedupColumnIndices" | "dedup_column_indices" => Ok(GeneratedField::DedupColumnIndices),
2812 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2813 }
2814 }
2815 }
2816 deserializer.deserialize_identifier(GeneratedVisitor)
2817 }
2818 }
2819 struct GeneratedVisitor;
2820 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2821 type Value = DedupNode;
2822
2823 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2824 formatter.write_str("struct stream_plan.DedupNode")
2825 }
2826
2827 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DedupNode, V::Error>
2828 where
2829 V: serde::de::MapAccess<'de>,
2830 {
2831 let mut state_table__ = None;
2832 let mut dedup_column_indices__ = None;
2833 while let Some(k) = map_.next_key()? {
2834 match k {
2835 GeneratedField::StateTable => {
2836 if state_table__.is_some() {
2837 return Err(serde::de::Error::duplicate_field("stateTable"));
2838 }
2839 state_table__ = map_.next_value()?;
2840 }
2841 GeneratedField::DedupColumnIndices => {
2842 if dedup_column_indices__.is_some() {
2843 return Err(serde::de::Error::duplicate_field("dedupColumnIndices"));
2844 }
2845 dedup_column_indices__ =
2846 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2847 .into_iter().map(|x| x.0).collect())
2848 ;
2849 }
2850 }
2851 }
2852 Ok(DedupNode {
2853 state_table: state_table__,
2854 dedup_column_indices: dedup_column_indices__.unwrap_or_default(),
2855 })
2856 }
2857 }
2858 deserializer.deserialize_struct("stream_plan.DedupNode", FIELDS, GeneratedVisitor)
2859 }
2860}
2861impl serde::Serialize for DeltaExpression {
2862 #[allow(deprecated)]
2863 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2864 where
2865 S: serde::Serializer,
2866 {
2867 use serde::ser::SerializeStruct;
2868 let mut len = 0;
2869 if self.delta_type != 0 {
2870 len += 1;
2871 }
2872 if self.delta.is_some() {
2873 len += 1;
2874 }
2875 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaExpression", len)?;
2876 if self.delta_type != 0 {
2877 let v = super::expr::expr_node::Type::try_from(self.delta_type)
2878 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.delta_type)))?;
2879 struct_ser.serialize_field("deltaType", &v)?;
2880 }
2881 if let Some(v) = self.delta.as_ref() {
2882 struct_ser.serialize_field("delta", v)?;
2883 }
2884 struct_ser.end()
2885 }
2886}
2887impl<'de> serde::Deserialize<'de> for DeltaExpression {
2888 #[allow(deprecated)]
2889 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2890 where
2891 D: serde::Deserializer<'de>,
2892 {
2893 const FIELDS: &[&str] = &[
2894 "delta_type",
2895 "deltaType",
2896 "delta",
2897 ];
2898
2899 #[allow(clippy::enum_variant_names)]
2900 enum GeneratedField {
2901 DeltaType,
2902 Delta,
2903 }
2904 impl<'de> serde::Deserialize<'de> for GeneratedField {
2905 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2906 where
2907 D: serde::Deserializer<'de>,
2908 {
2909 struct GeneratedVisitor;
2910
2911 impl serde::de::Visitor<'_> for GeneratedVisitor {
2912 type Value = GeneratedField;
2913
2914 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2915 write!(formatter, "expected one of: {:?}", &FIELDS)
2916 }
2917
2918 #[allow(unused_variables)]
2919 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2920 where
2921 E: serde::de::Error,
2922 {
2923 match value {
2924 "deltaType" | "delta_type" => Ok(GeneratedField::DeltaType),
2925 "delta" => Ok(GeneratedField::Delta),
2926 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2927 }
2928 }
2929 }
2930 deserializer.deserialize_identifier(GeneratedVisitor)
2931 }
2932 }
2933 struct GeneratedVisitor;
2934 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2935 type Value = DeltaExpression;
2936
2937 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2938 formatter.write_str("struct stream_plan.DeltaExpression")
2939 }
2940
2941 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaExpression, V::Error>
2942 where
2943 V: serde::de::MapAccess<'de>,
2944 {
2945 let mut delta_type__ = None;
2946 let mut delta__ = None;
2947 while let Some(k) = map_.next_key()? {
2948 match k {
2949 GeneratedField::DeltaType => {
2950 if delta_type__.is_some() {
2951 return Err(serde::de::Error::duplicate_field("deltaType"));
2952 }
2953 delta_type__ = Some(map_.next_value::<super::expr::expr_node::Type>()? as i32);
2954 }
2955 GeneratedField::Delta => {
2956 if delta__.is_some() {
2957 return Err(serde::de::Error::duplicate_field("delta"));
2958 }
2959 delta__ = map_.next_value()?;
2960 }
2961 }
2962 }
2963 Ok(DeltaExpression {
2964 delta_type: delta_type__.unwrap_or_default(),
2965 delta: delta__,
2966 })
2967 }
2968 }
2969 deserializer.deserialize_struct("stream_plan.DeltaExpression", FIELDS, GeneratedVisitor)
2970 }
2971}
2972impl serde::Serialize for DeltaIndexJoinNode {
2973 #[allow(deprecated)]
2974 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2975 where
2976 S: serde::Serializer,
2977 {
2978 use serde::ser::SerializeStruct;
2979 let mut len = 0;
2980 if self.join_type != 0 {
2981 len += 1;
2982 }
2983 if !self.left_key.is_empty() {
2984 len += 1;
2985 }
2986 if !self.right_key.is_empty() {
2987 len += 1;
2988 }
2989 if self.condition.is_some() {
2990 len += 1;
2991 }
2992 if self.left_table_id != 0 {
2993 len += 1;
2994 }
2995 if self.right_table_id != 0 {
2996 len += 1;
2997 }
2998 if self.left_info.is_some() {
2999 len += 1;
3000 }
3001 if self.right_info.is_some() {
3002 len += 1;
3003 }
3004 if !self.output_indices.is_empty() {
3005 len += 1;
3006 }
3007 let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaIndexJoinNode", len)?;
3008 if self.join_type != 0 {
3009 let v = super::plan_common::JoinType::try_from(self.join_type)
3010 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
3011 struct_ser.serialize_field("joinType", &v)?;
3012 }
3013 if !self.left_key.is_empty() {
3014 struct_ser.serialize_field("leftKey", &self.left_key)?;
3015 }
3016 if !self.right_key.is_empty() {
3017 struct_ser.serialize_field("rightKey", &self.right_key)?;
3018 }
3019 if let Some(v) = self.condition.as_ref() {
3020 struct_ser.serialize_field("condition", v)?;
3021 }
3022 if self.left_table_id != 0 {
3023 struct_ser.serialize_field("leftTableId", &self.left_table_id)?;
3024 }
3025 if self.right_table_id != 0 {
3026 struct_ser.serialize_field("rightTableId", &self.right_table_id)?;
3027 }
3028 if let Some(v) = self.left_info.as_ref() {
3029 struct_ser.serialize_field("leftInfo", v)?;
3030 }
3031 if let Some(v) = self.right_info.as_ref() {
3032 struct_ser.serialize_field("rightInfo", v)?;
3033 }
3034 if !self.output_indices.is_empty() {
3035 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
3036 }
3037 struct_ser.end()
3038 }
3039}
3040impl<'de> serde::Deserialize<'de> for DeltaIndexJoinNode {
3041 #[allow(deprecated)]
3042 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3043 where
3044 D: serde::Deserializer<'de>,
3045 {
3046 const FIELDS: &[&str] = &[
3047 "join_type",
3048 "joinType",
3049 "left_key",
3050 "leftKey",
3051 "right_key",
3052 "rightKey",
3053 "condition",
3054 "left_table_id",
3055 "leftTableId",
3056 "right_table_id",
3057 "rightTableId",
3058 "left_info",
3059 "leftInfo",
3060 "right_info",
3061 "rightInfo",
3062 "output_indices",
3063 "outputIndices",
3064 ];
3065
3066 #[allow(clippy::enum_variant_names)]
3067 enum GeneratedField {
3068 JoinType,
3069 LeftKey,
3070 RightKey,
3071 Condition,
3072 LeftTableId,
3073 RightTableId,
3074 LeftInfo,
3075 RightInfo,
3076 OutputIndices,
3077 }
3078 impl<'de> serde::Deserialize<'de> for GeneratedField {
3079 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3080 where
3081 D: serde::Deserializer<'de>,
3082 {
3083 struct GeneratedVisitor;
3084
3085 impl serde::de::Visitor<'_> for GeneratedVisitor {
3086 type Value = GeneratedField;
3087
3088 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3089 write!(formatter, "expected one of: {:?}", &FIELDS)
3090 }
3091
3092 #[allow(unused_variables)]
3093 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3094 where
3095 E: serde::de::Error,
3096 {
3097 match value {
3098 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
3099 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
3100 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
3101 "condition" => Ok(GeneratedField::Condition),
3102 "leftTableId" | "left_table_id" => Ok(GeneratedField::LeftTableId),
3103 "rightTableId" | "right_table_id" => Ok(GeneratedField::RightTableId),
3104 "leftInfo" | "left_info" => Ok(GeneratedField::LeftInfo),
3105 "rightInfo" | "right_info" => Ok(GeneratedField::RightInfo),
3106 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
3107 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3108 }
3109 }
3110 }
3111 deserializer.deserialize_identifier(GeneratedVisitor)
3112 }
3113 }
3114 struct GeneratedVisitor;
3115 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3116 type Value = DeltaIndexJoinNode;
3117
3118 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3119 formatter.write_str("struct stream_plan.DeltaIndexJoinNode")
3120 }
3121
3122 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaIndexJoinNode, V::Error>
3123 where
3124 V: serde::de::MapAccess<'de>,
3125 {
3126 let mut join_type__ = None;
3127 let mut left_key__ = None;
3128 let mut right_key__ = None;
3129 let mut condition__ = None;
3130 let mut left_table_id__ = None;
3131 let mut right_table_id__ = None;
3132 let mut left_info__ = None;
3133 let mut right_info__ = None;
3134 let mut output_indices__ = None;
3135 while let Some(k) = map_.next_key()? {
3136 match k {
3137 GeneratedField::JoinType => {
3138 if join_type__.is_some() {
3139 return Err(serde::de::Error::duplicate_field("joinType"));
3140 }
3141 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
3142 }
3143 GeneratedField::LeftKey => {
3144 if left_key__.is_some() {
3145 return Err(serde::de::Error::duplicate_field("leftKey"));
3146 }
3147 left_key__ =
3148 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3149 .into_iter().map(|x| x.0).collect())
3150 ;
3151 }
3152 GeneratedField::RightKey => {
3153 if right_key__.is_some() {
3154 return Err(serde::de::Error::duplicate_field("rightKey"));
3155 }
3156 right_key__ =
3157 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3158 .into_iter().map(|x| x.0).collect())
3159 ;
3160 }
3161 GeneratedField::Condition => {
3162 if condition__.is_some() {
3163 return Err(serde::de::Error::duplicate_field("condition"));
3164 }
3165 condition__ = map_.next_value()?;
3166 }
3167 GeneratedField::LeftTableId => {
3168 if left_table_id__.is_some() {
3169 return Err(serde::de::Error::duplicate_field("leftTableId"));
3170 }
3171 left_table_id__ =
3172 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3173 ;
3174 }
3175 GeneratedField::RightTableId => {
3176 if right_table_id__.is_some() {
3177 return Err(serde::de::Error::duplicate_field("rightTableId"));
3178 }
3179 right_table_id__ =
3180 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3181 ;
3182 }
3183 GeneratedField::LeftInfo => {
3184 if left_info__.is_some() {
3185 return Err(serde::de::Error::duplicate_field("leftInfo"));
3186 }
3187 left_info__ = map_.next_value()?;
3188 }
3189 GeneratedField::RightInfo => {
3190 if right_info__.is_some() {
3191 return Err(serde::de::Error::duplicate_field("rightInfo"));
3192 }
3193 right_info__ = map_.next_value()?;
3194 }
3195 GeneratedField::OutputIndices => {
3196 if output_indices__.is_some() {
3197 return Err(serde::de::Error::duplicate_field("outputIndices"));
3198 }
3199 output_indices__ =
3200 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3201 .into_iter().map(|x| x.0).collect())
3202 ;
3203 }
3204 }
3205 }
3206 Ok(DeltaIndexJoinNode {
3207 join_type: join_type__.unwrap_or_default(),
3208 left_key: left_key__.unwrap_or_default(),
3209 right_key: right_key__.unwrap_or_default(),
3210 condition: condition__,
3211 left_table_id: left_table_id__.unwrap_or_default(),
3212 right_table_id: right_table_id__.unwrap_or_default(),
3213 left_info: left_info__,
3214 right_info: right_info__,
3215 output_indices: output_indices__.unwrap_or_default(),
3216 })
3217 }
3218 }
3219 deserializer.deserialize_struct("stream_plan.DeltaIndexJoinNode", FIELDS, GeneratedVisitor)
3220 }
3221}
3222impl serde::Serialize for DispatchOutputMapping {
3223 #[allow(deprecated)]
3224 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3225 where
3226 S: serde::Serializer,
3227 {
3228 use serde::ser::SerializeStruct;
3229 let mut len = 0;
3230 if !self.indices.is_empty() {
3231 len += 1;
3232 }
3233 if !self.types.is_empty() {
3234 len += 1;
3235 }
3236 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping", len)?;
3237 if !self.indices.is_empty() {
3238 struct_ser.serialize_field("indices", &self.indices)?;
3239 }
3240 if !self.types.is_empty() {
3241 struct_ser.serialize_field("types", &self.types)?;
3242 }
3243 struct_ser.end()
3244 }
3245}
3246impl<'de> serde::Deserialize<'de> for DispatchOutputMapping {
3247 #[allow(deprecated)]
3248 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3249 where
3250 D: serde::Deserializer<'de>,
3251 {
3252 const FIELDS: &[&str] = &[
3253 "indices",
3254 "types",
3255 ];
3256
3257 #[allow(clippy::enum_variant_names)]
3258 enum GeneratedField {
3259 Indices,
3260 Types,
3261 }
3262 impl<'de> serde::Deserialize<'de> for GeneratedField {
3263 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3264 where
3265 D: serde::Deserializer<'de>,
3266 {
3267 struct GeneratedVisitor;
3268
3269 impl serde::de::Visitor<'_> for GeneratedVisitor {
3270 type Value = GeneratedField;
3271
3272 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3273 write!(formatter, "expected one of: {:?}", &FIELDS)
3274 }
3275
3276 #[allow(unused_variables)]
3277 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3278 where
3279 E: serde::de::Error,
3280 {
3281 match value {
3282 "indices" => Ok(GeneratedField::Indices),
3283 "types" => Ok(GeneratedField::Types),
3284 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3285 }
3286 }
3287 }
3288 deserializer.deserialize_identifier(GeneratedVisitor)
3289 }
3290 }
3291 struct GeneratedVisitor;
3292 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3293 type Value = DispatchOutputMapping;
3294
3295 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3296 formatter.write_str("struct stream_plan.DispatchOutputMapping")
3297 }
3298
3299 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchOutputMapping, V::Error>
3300 where
3301 V: serde::de::MapAccess<'de>,
3302 {
3303 let mut indices__ = None;
3304 let mut types__ = None;
3305 while let Some(k) = map_.next_key()? {
3306 match k {
3307 GeneratedField::Indices => {
3308 if indices__.is_some() {
3309 return Err(serde::de::Error::duplicate_field("indices"));
3310 }
3311 indices__ =
3312 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3313 .into_iter().map(|x| x.0).collect())
3314 ;
3315 }
3316 GeneratedField::Types => {
3317 if types__.is_some() {
3318 return Err(serde::de::Error::duplicate_field("types"));
3319 }
3320 types__ = Some(map_.next_value()?);
3321 }
3322 }
3323 }
3324 Ok(DispatchOutputMapping {
3325 indices: indices__.unwrap_or_default(),
3326 types: types__.unwrap_or_default(),
3327 })
3328 }
3329 }
3330 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping", FIELDS, GeneratedVisitor)
3331 }
3332}
3333impl serde::Serialize for dispatch_output_mapping::TypePair {
3334 #[allow(deprecated)]
3335 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3336 where
3337 S: serde::Serializer,
3338 {
3339 use serde::ser::SerializeStruct;
3340 let mut len = 0;
3341 if self.upstream.is_some() {
3342 len += 1;
3343 }
3344 if self.downstream.is_some() {
3345 len += 1;
3346 }
3347 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping.TypePair", len)?;
3348 if let Some(v) = self.upstream.as_ref() {
3349 struct_ser.serialize_field("upstream", v)?;
3350 }
3351 if let Some(v) = self.downstream.as_ref() {
3352 struct_ser.serialize_field("downstream", v)?;
3353 }
3354 struct_ser.end()
3355 }
3356}
3357impl<'de> serde::Deserialize<'de> for dispatch_output_mapping::TypePair {
3358 #[allow(deprecated)]
3359 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3360 where
3361 D: serde::Deserializer<'de>,
3362 {
3363 const FIELDS: &[&str] = &[
3364 "upstream",
3365 "downstream",
3366 ];
3367
3368 #[allow(clippy::enum_variant_names)]
3369 enum GeneratedField {
3370 Upstream,
3371 Downstream,
3372 }
3373 impl<'de> serde::Deserialize<'de> for GeneratedField {
3374 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3375 where
3376 D: serde::Deserializer<'de>,
3377 {
3378 struct GeneratedVisitor;
3379
3380 impl serde::de::Visitor<'_> for GeneratedVisitor {
3381 type Value = GeneratedField;
3382
3383 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3384 write!(formatter, "expected one of: {:?}", &FIELDS)
3385 }
3386
3387 #[allow(unused_variables)]
3388 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3389 where
3390 E: serde::de::Error,
3391 {
3392 match value {
3393 "upstream" => Ok(GeneratedField::Upstream),
3394 "downstream" => Ok(GeneratedField::Downstream),
3395 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3396 }
3397 }
3398 }
3399 deserializer.deserialize_identifier(GeneratedVisitor)
3400 }
3401 }
3402 struct GeneratedVisitor;
3403 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3404 type Value = dispatch_output_mapping::TypePair;
3405
3406 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3407 formatter.write_str("struct stream_plan.DispatchOutputMapping.TypePair")
3408 }
3409
3410 fn visit_map<V>(self, mut map_: V) -> std::result::Result<dispatch_output_mapping::TypePair, V::Error>
3411 where
3412 V: serde::de::MapAccess<'de>,
3413 {
3414 let mut upstream__ = None;
3415 let mut downstream__ = None;
3416 while let Some(k) = map_.next_key()? {
3417 match k {
3418 GeneratedField::Upstream => {
3419 if upstream__.is_some() {
3420 return Err(serde::de::Error::duplicate_field("upstream"));
3421 }
3422 upstream__ = map_.next_value()?;
3423 }
3424 GeneratedField::Downstream => {
3425 if downstream__.is_some() {
3426 return Err(serde::de::Error::duplicate_field("downstream"));
3427 }
3428 downstream__ = map_.next_value()?;
3429 }
3430 }
3431 }
3432 Ok(dispatch_output_mapping::TypePair {
3433 upstream: upstream__,
3434 downstream: downstream__,
3435 })
3436 }
3437 }
3438 deserializer.deserialize_struct("stream_plan.DispatchOutputMapping.TypePair", FIELDS, GeneratedVisitor)
3439 }
3440}
3441impl serde::Serialize for DispatchStrategy {
3442 #[allow(deprecated)]
3443 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3444 where
3445 S: serde::Serializer,
3446 {
3447 use serde::ser::SerializeStruct;
3448 let mut len = 0;
3449 if self.r#type != 0 {
3450 len += 1;
3451 }
3452 if !self.dist_key_indices.is_empty() {
3453 len += 1;
3454 }
3455 if self.output_mapping.is_some() {
3456 len += 1;
3457 }
3458 let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchStrategy", len)?;
3459 if self.r#type != 0 {
3460 let v = DispatcherType::try_from(self.r#type)
3461 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3462 struct_ser.serialize_field("type", &v)?;
3463 }
3464 if !self.dist_key_indices.is_empty() {
3465 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3466 }
3467 if let Some(v) = self.output_mapping.as_ref() {
3468 struct_ser.serialize_field("outputMapping", v)?;
3469 }
3470 struct_ser.end()
3471 }
3472}
3473impl<'de> serde::Deserialize<'de> for DispatchStrategy {
3474 #[allow(deprecated)]
3475 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3476 where
3477 D: serde::Deserializer<'de>,
3478 {
3479 const FIELDS: &[&str] = &[
3480 "type",
3481 "dist_key_indices",
3482 "distKeyIndices",
3483 "output_mapping",
3484 "outputMapping",
3485 ];
3486
3487 #[allow(clippy::enum_variant_names)]
3488 enum GeneratedField {
3489 Type,
3490 DistKeyIndices,
3491 OutputMapping,
3492 }
3493 impl<'de> serde::Deserialize<'de> for GeneratedField {
3494 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3495 where
3496 D: serde::Deserializer<'de>,
3497 {
3498 struct GeneratedVisitor;
3499
3500 impl serde::de::Visitor<'_> for GeneratedVisitor {
3501 type Value = GeneratedField;
3502
3503 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3504 write!(formatter, "expected one of: {:?}", &FIELDS)
3505 }
3506
3507 #[allow(unused_variables)]
3508 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3509 where
3510 E: serde::de::Error,
3511 {
3512 match value {
3513 "type" => Ok(GeneratedField::Type),
3514 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3515 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3516 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3517 }
3518 }
3519 }
3520 deserializer.deserialize_identifier(GeneratedVisitor)
3521 }
3522 }
3523 struct GeneratedVisitor;
3524 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3525 type Value = DispatchStrategy;
3526
3527 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3528 formatter.write_str("struct stream_plan.DispatchStrategy")
3529 }
3530
3531 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchStrategy, V::Error>
3532 where
3533 V: serde::de::MapAccess<'de>,
3534 {
3535 let mut r#type__ = None;
3536 let mut dist_key_indices__ = None;
3537 let mut output_mapping__ = None;
3538 while let Some(k) = map_.next_key()? {
3539 match k {
3540 GeneratedField::Type => {
3541 if r#type__.is_some() {
3542 return Err(serde::de::Error::duplicate_field("type"));
3543 }
3544 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3545 }
3546 GeneratedField::DistKeyIndices => {
3547 if dist_key_indices__.is_some() {
3548 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3549 }
3550 dist_key_indices__ =
3551 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3552 .into_iter().map(|x| x.0).collect())
3553 ;
3554 }
3555 GeneratedField::OutputMapping => {
3556 if output_mapping__.is_some() {
3557 return Err(serde::de::Error::duplicate_field("outputMapping"));
3558 }
3559 output_mapping__ = map_.next_value()?;
3560 }
3561 }
3562 }
3563 Ok(DispatchStrategy {
3564 r#type: r#type__.unwrap_or_default(),
3565 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3566 output_mapping: output_mapping__,
3567 })
3568 }
3569 }
3570 deserializer.deserialize_struct("stream_plan.DispatchStrategy", FIELDS, GeneratedVisitor)
3571 }
3572}
3573impl serde::Serialize for Dispatcher {
3574 #[allow(deprecated)]
3575 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3576 where
3577 S: serde::Serializer,
3578 {
3579 use serde::ser::SerializeStruct;
3580 let mut len = 0;
3581 if self.r#type != 0 {
3582 len += 1;
3583 }
3584 if !self.dist_key_indices.is_empty() {
3585 len += 1;
3586 }
3587 if self.output_mapping.is_some() {
3588 len += 1;
3589 }
3590 if self.hash_mapping.is_some() {
3591 len += 1;
3592 }
3593 if self.dispatcher_id != 0 {
3594 len += 1;
3595 }
3596 if !self.downstream_actor_id.is_empty() {
3597 len += 1;
3598 }
3599 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatcher", len)?;
3600 if self.r#type != 0 {
3601 let v = DispatcherType::try_from(self.r#type)
3602 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3603 struct_ser.serialize_field("type", &v)?;
3604 }
3605 if !self.dist_key_indices.is_empty() {
3606 struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3607 }
3608 if let Some(v) = self.output_mapping.as_ref() {
3609 struct_ser.serialize_field("outputMapping", v)?;
3610 }
3611 if let Some(v) = self.hash_mapping.as_ref() {
3612 struct_ser.serialize_field("hashMapping", v)?;
3613 }
3614 if self.dispatcher_id != 0 {
3615 struct_ser.serialize_field("dispatcherId", &self.dispatcher_id)?;
3616 }
3617 if !self.downstream_actor_id.is_empty() {
3618 struct_ser.serialize_field("downstreamActorId", &self.downstream_actor_id)?;
3619 }
3620 struct_ser.end()
3621 }
3622}
3623impl<'de> serde::Deserialize<'de> for Dispatcher {
3624 #[allow(deprecated)]
3625 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3626 where
3627 D: serde::Deserializer<'de>,
3628 {
3629 const FIELDS: &[&str] = &[
3630 "type",
3631 "dist_key_indices",
3632 "distKeyIndices",
3633 "output_mapping",
3634 "outputMapping",
3635 "hash_mapping",
3636 "hashMapping",
3637 "dispatcher_id",
3638 "dispatcherId",
3639 "downstream_actor_id",
3640 "downstreamActorId",
3641 ];
3642
3643 #[allow(clippy::enum_variant_names)]
3644 enum GeneratedField {
3645 Type,
3646 DistKeyIndices,
3647 OutputMapping,
3648 HashMapping,
3649 DispatcherId,
3650 DownstreamActorId,
3651 }
3652 impl<'de> serde::Deserialize<'de> for GeneratedField {
3653 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3654 where
3655 D: serde::Deserializer<'de>,
3656 {
3657 struct GeneratedVisitor;
3658
3659 impl serde::de::Visitor<'_> for GeneratedVisitor {
3660 type Value = GeneratedField;
3661
3662 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3663 write!(formatter, "expected one of: {:?}", &FIELDS)
3664 }
3665
3666 #[allow(unused_variables)]
3667 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3668 where
3669 E: serde::de::Error,
3670 {
3671 match value {
3672 "type" => Ok(GeneratedField::Type),
3673 "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3674 "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3675 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
3676 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
3677 "downstreamActorId" | "downstream_actor_id" => Ok(GeneratedField::DownstreamActorId),
3678 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3679 }
3680 }
3681 }
3682 deserializer.deserialize_identifier(GeneratedVisitor)
3683 }
3684 }
3685 struct GeneratedVisitor;
3686 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3687 type Value = Dispatcher;
3688
3689 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3690 formatter.write_str("struct stream_plan.Dispatcher")
3691 }
3692
3693 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatcher, V::Error>
3694 where
3695 V: serde::de::MapAccess<'de>,
3696 {
3697 let mut r#type__ = None;
3698 let mut dist_key_indices__ = None;
3699 let mut output_mapping__ = None;
3700 let mut hash_mapping__ = None;
3701 let mut dispatcher_id__ = None;
3702 let mut downstream_actor_id__ = None;
3703 while let Some(k) = map_.next_key()? {
3704 match k {
3705 GeneratedField::Type => {
3706 if r#type__.is_some() {
3707 return Err(serde::de::Error::duplicate_field("type"));
3708 }
3709 r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3710 }
3711 GeneratedField::DistKeyIndices => {
3712 if dist_key_indices__.is_some() {
3713 return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3714 }
3715 dist_key_indices__ =
3716 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3717 .into_iter().map(|x| x.0).collect())
3718 ;
3719 }
3720 GeneratedField::OutputMapping => {
3721 if output_mapping__.is_some() {
3722 return Err(serde::de::Error::duplicate_field("outputMapping"));
3723 }
3724 output_mapping__ = map_.next_value()?;
3725 }
3726 GeneratedField::HashMapping => {
3727 if hash_mapping__.is_some() {
3728 return Err(serde::de::Error::duplicate_field("hashMapping"));
3729 }
3730 hash_mapping__ = map_.next_value()?;
3731 }
3732 GeneratedField::DispatcherId => {
3733 if dispatcher_id__.is_some() {
3734 return Err(serde::de::Error::duplicate_field("dispatcherId"));
3735 }
3736 dispatcher_id__ =
3737 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3738 ;
3739 }
3740 GeneratedField::DownstreamActorId => {
3741 if downstream_actor_id__.is_some() {
3742 return Err(serde::de::Error::duplicate_field("downstreamActorId"));
3743 }
3744 downstream_actor_id__ =
3745 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3746 .into_iter().map(|x| x.0).collect())
3747 ;
3748 }
3749 }
3750 }
3751 Ok(Dispatcher {
3752 r#type: r#type__.unwrap_or_default(),
3753 dist_key_indices: dist_key_indices__.unwrap_or_default(),
3754 output_mapping: output_mapping__,
3755 hash_mapping: hash_mapping__,
3756 dispatcher_id: dispatcher_id__.unwrap_or_default(),
3757 downstream_actor_id: downstream_actor_id__.unwrap_or_default(),
3758 })
3759 }
3760 }
3761 deserializer.deserialize_struct("stream_plan.Dispatcher", FIELDS, GeneratedVisitor)
3762 }
3763}
3764impl serde::Serialize for DispatcherType {
3765 #[allow(deprecated)]
3766 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3767 where
3768 S: serde::Serializer,
3769 {
3770 let variant = match self {
3771 Self::Unspecified => "DISPATCHER_TYPE_UNSPECIFIED",
3772 Self::Hash => "DISPATCHER_TYPE_HASH",
3773 Self::Broadcast => "DISPATCHER_TYPE_BROADCAST",
3774 Self::Simple => "DISPATCHER_TYPE_SIMPLE",
3775 Self::NoShuffle => "DISPATCHER_TYPE_NO_SHUFFLE",
3776 };
3777 serializer.serialize_str(variant)
3778 }
3779}
3780impl<'de> serde::Deserialize<'de> for DispatcherType {
3781 #[allow(deprecated)]
3782 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3783 where
3784 D: serde::Deserializer<'de>,
3785 {
3786 const FIELDS: &[&str] = &[
3787 "DISPATCHER_TYPE_UNSPECIFIED",
3788 "DISPATCHER_TYPE_HASH",
3789 "DISPATCHER_TYPE_BROADCAST",
3790 "DISPATCHER_TYPE_SIMPLE",
3791 "DISPATCHER_TYPE_NO_SHUFFLE",
3792 ];
3793
3794 struct GeneratedVisitor;
3795
3796 impl serde::de::Visitor<'_> for GeneratedVisitor {
3797 type Value = DispatcherType;
3798
3799 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3800 write!(formatter, "expected one of: {:?}", &FIELDS)
3801 }
3802
3803 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3804 where
3805 E: serde::de::Error,
3806 {
3807 i32::try_from(v)
3808 .ok()
3809 .and_then(|x| x.try_into().ok())
3810 .ok_or_else(|| {
3811 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3812 })
3813 }
3814
3815 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3816 where
3817 E: serde::de::Error,
3818 {
3819 i32::try_from(v)
3820 .ok()
3821 .and_then(|x| x.try_into().ok())
3822 .ok_or_else(|| {
3823 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3824 })
3825 }
3826
3827 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3828 where
3829 E: serde::de::Error,
3830 {
3831 match value {
3832 "DISPATCHER_TYPE_UNSPECIFIED" => Ok(DispatcherType::Unspecified),
3833 "DISPATCHER_TYPE_HASH" => Ok(DispatcherType::Hash),
3834 "DISPATCHER_TYPE_BROADCAST" => Ok(DispatcherType::Broadcast),
3835 "DISPATCHER_TYPE_SIMPLE" => Ok(DispatcherType::Simple),
3836 "DISPATCHER_TYPE_NO_SHUFFLE" => Ok(DispatcherType::NoShuffle),
3837 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3838 }
3839 }
3840 }
3841 deserializer.deserialize_any(GeneratedVisitor)
3842 }
3843}
3844impl serde::Serialize for Dispatchers {
3845 #[allow(deprecated)]
3846 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3847 where
3848 S: serde::Serializer,
3849 {
3850 use serde::ser::SerializeStruct;
3851 let mut len = 0;
3852 if !self.dispatchers.is_empty() {
3853 len += 1;
3854 }
3855 let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatchers", len)?;
3856 if !self.dispatchers.is_empty() {
3857 struct_ser.serialize_field("dispatchers", &self.dispatchers)?;
3858 }
3859 struct_ser.end()
3860 }
3861}
3862impl<'de> serde::Deserialize<'de> for Dispatchers {
3863 #[allow(deprecated)]
3864 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3865 where
3866 D: serde::Deserializer<'de>,
3867 {
3868 const FIELDS: &[&str] = &[
3869 "dispatchers",
3870 ];
3871
3872 #[allow(clippy::enum_variant_names)]
3873 enum GeneratedField {
3874 Dispatchers,
3875 }
3876 impl<'de> serde::Deserialize<'de> for GeneratedField {
3877 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3878 where
3879 D: serde::Deserializer<'de>,
3880 {
3881 struct GeneratedVisitor;
3882
3883 impl serde::de::Visitor<'_> for GeneratedVisitor {
3884 type Value = GeneratedField;
3885
3886 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3887 write!(formatter, "expected one of: {:?}", &FIELDS)
3888 }
3889
3890 #[allow(unused_variables)]
3891 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3892 where
3893 E: serde::de::Error,
3894 {
3895 match value {
3896 "dispatchers" => Ok(GeneratedField::Dispatchers),
3897 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3898 }
3899 }
3900 }
3901 deserializer.deserialize_identifier(GeneratedVisitor)
3902 }
3903 }
3904 struct GeneratedVisitor;
3905 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3906 type Value = Dispatchers;
3907
3908 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3909 formatter.write_str("struct stream_plan.Dispatchers")
3910 }
3911
3912 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatchers, V::Error>
3913 where
3914 V: serde::de::MapAccess<'de>,
3915 {
3916 let mut dispatchers__ = None;
3917 while let Some(k) = map_.next_key()? {
3918 match k {
3919 GeneratedField::Dispatchers => {
3920 if dispatchers__.is_some() {
3921 return Err(serde::de::Error::duplicate_field("dispatchers"));
3922 }
3923 dispatchers__ = Some(map_.next_value()?);
3924 }
3925 }
3926 }
3927 Ok(Dispatchers {
3928 dispatchers: dispatchers__.unwrap_or_default(),
3929 })
3930 }
3931 }
3932 deserializer.deserialize_struct("stream_plan.Dispatchers", FIELDS, GeneratedVisitor)
3933 }
3934}
3935impl serde::Serialize for DmlNode {
3936 #[allow(deprecated)]
3937 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3938 where
3939 S: serde::Serializer,
3940 {
3941 use serde::ser::SerializeStruct;
3942 let mut len = 0;
3943 if self.table_id != 0 {
3944 len += 1;
3945 }
3946 if self.table_version_id != 0 {
3947 len += 1;
3948 }
3949 if !self.column_descs.is_empty() {
3950 len += 1;
3951 }
3952 if self.rate_limit.is_some() {
3953 len += 1;
3954 }
3955 let mut struct_ser = serializer.serialize_struct("stream_plan.DmlNode", len)?;
3956 if self.table_id != 0 {
3957 struct_ser.serialize_field("tableId", &self.table_id)?;
3958 }
3959 if self.table_version_id != 0 {
3960 #[allow(clippy::needless_borrow)]
3961 #[allow(clippy::needless_borrows_for_generic_args)]
3962 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
3963 }
3964 if !self.column_descs.is_empty() {
3965 struct_ser.serialize_field("columnDescs", &self.column_descs)?;
3966 }
3967 if let Some(v) = self.rate_limit.as_ref() {
3968 struct_ser.serialize_field("rateLimit", v)?;
3969 }
3970 struct_ser.end()
3971 }
3972}
3973impl<'de> serde::Deserialize<'de> for DmlNode {
3974 #[allow(deprecated)]
3975 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3976 where
3977 D: serde::Deserializer<'de>,
3978 {
3979 const FIELDS: &[&str] = &[
3980 "table_id",
3981 "tableId",
3982 "table_version_id",
3983 "tableVersionId",
3984 "column_descs",
3985 "columnDescs",
3986 "rate_limit",
3987 "rateLimit",
3988 ];
3989
3990 #[allow(clippy::enum_variant_names)]
3991 enum GeneratedField {
3992 TableId,
3993 TableVersionId,
3994 ColumnDescs,
3995 RateLimit,
3996 }
3997 impl<'de> serde::Deserialize<'de> for GeneratedField {
3998 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3999 where
4000 D: serde::Deserializer<'de>,
4001 {
4002 struct GeneratedVisitor;
4003
4004 impl serde::de::Visitor<'_> for GeneratedVisitor {
4005 type Value = GeneratedField;
4006
4007 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4008 write!(formatter, "expected one of: {:?}", &FIELDS)
4009 }
4010
4011 #[allow(unused_variables)]
4012 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4013 where
4014 E: serde::de::Error,
4015 {
4016 match value {
4017 "tableId" | "table_id" => Ok(GeneratedField::TableId),
4018 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
4019 "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
4020 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
4021 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4022 }
4023 }
4024 }
4025 deserializer.deserialize_identifier(GeneratedVisitor)
4026 }
4027 }
4028 struct GeneratedVisitor;
4029 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4030 type Value = DmlNode;
4031
4032 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4033 formatter.write_str("struct stream_plan.DmlNode")
4034 }
4035
4036 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DmlNode, V::Error>
4037 where
4038 V: serde::de::MapAccess<'de>,
4039 {
4040 let mut table_id__ = None;
4041 let mut table_version_id__ = None;
4042 let mut column_descs__ = None;
4043 let mut rate_limit__ = None;
4044 while let Some(k) = map_.next_key()? {
4045 match k {
4046 GeneratedField::TableId => {
4047 if table_id__.is_some() {
4048 return Err(serde::de::Error::duplicate_field("tableId"));
4049 }
4050 table_id__ =
4051 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4052 ;
4053 }
4054 GeneratedField::TableVersionId => {
4055 if table_version_id__.is_some() {
4056 return Err(serde::de::Error::duplicate_field("tableVersionId"));
4057 }
4058 table_version_id__ =
4059 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4060 ;
4061 }
4062 GeneratedField::ColumnDescs => {
4063 if column_descs__.is_some() {
4064 return Err(serde::de::Error::duplicate_field("columnDescs"));
4065 }
4066 column_descs__ = Some(map_.next_value()?);
4067 }
4068 GeneratedField::RateLimit => {
4069 if rate_limit__.is_some() {
4070 return Err(serde::de::Error::duplicate_field("rateLimit"));
4071 }
4072 rate_limit__ =
4073 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4074 ;
4075 }
4076 }
4077 }
4078 Ok(DmlNode {
4079 table_id: table_id__.unwrap_or_default(),
4080 table_version_id: table_version_id__.unwrap_or_default(),
4081 column_descs: column_descs__.unwrap_or_default(),
4082 rate_limit: rate_limit__,
4083 })
4084 }
4085 }
4086 deserializer.deserialize_struct("stream_plan.DmlNode", FIELDS, GeneratedVisitor)
4087 }
4088}
4089impl serde::Serialize for DropSubscriptionsMutation {
4090 #[allow(deprecated)]
4091 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4092 where
4093 S: serde::Serializer,
4094 {
4095 use serde::ser::SerializeStruct;
4096 let mut len = 0;
4097 if !self.info.is_empty() {
4098 len += 1;
4099 }
4100 let mut struct_ser = serializer.serialize_struct("stream_plan.DropSubscriptionsMutation", len)?;
4101 if !self.info.is_empty() {
4102 struct_ser.serialize_field("info", &self.info)?;
4103 }
4104 struct_ser.end()
4105 }
4106}
4107impl<'de> serde::Deserialize<'de> for DropSubscriptionsMutation {
4108 #[allow(deprecated)]
4109 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4110 where
4111 D: serde::Deserializer<'de>,
4112 {
4113 const FIELDS: &[&str] = &[
4114 "info",
4115 ];
4116
4117 #[allow(clippy::enum_variant_names)]
4118 enum GeneratedField {
4119 Info,
4120 }
4121 impl<'de> serde::Deserialize<'de> for GeneratedField {
4122 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4123 where
4124 D: serde::Deserializer<'de>,
4125 {
4126 struct GeneratedVisitor;
4127
4128 impl serde::de::Visitor<'_> for GeneratedVisitor {
4129 type Value = GeneratedField;
4130
4131 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4132 write!(formatter, "expected one of: {:?}", &FIELDS)
4133 }
4134
4135 #[allow(unused_variables)]
4136 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4137 where
4138 E: serde::de::Error,
4139 {
4140 match value {
4141 "info" => Ok(GeneratedField::Info),
4142 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4143 }
4144 }
4145 }
4146 deserializer.deserialize_identifier(GeneratedVisitor)
4147 }
4148 }
4149 struct GeneratedVisitor;
4150 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4151 type Value = DropSubscriptionsMutation;
4152
4153 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4154 formatter.write_str("struct stream_plan.DropSubscriptionsMutation")
4155 }
4156
4157 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionsMutation, V::Error>
4158 where
4159 V: serde::de::MapAccess<'de>,
4160 {
4161 let mut info__ = None;
4162 while let Some(k) = map_.next_key()? {
4163 match k {
4164 GeneratedField::Info => {
4165 if info__.is_some() {
4166 return Err(serde::de::Error::duplicate_field("info"));
4167 }
4168 info__ = Some(map_.next_value()?);
4169 }
4170 }
4171 }
4172 Ok(DropSubscriptionsMutation {
4173 info: info__.unwrap_or_default(),
4174 })
4175 }
4176 }
4177 deserializer.deserialize_struct("stream_plan.DropSubscriptionsMutation", FIELDS, GeneratedVisitor)
4178 }
4179}
4180impl serde::Serialize for DynamicFilterNode {
4181 #[allow(deprecated)]
4182 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4183 where
4184 S: serde::Serializer,
4185 {
4186 use serde::ser::SerializeStruct;
4187 let mut len = 0;
4188 if self.left_key != 0 {
4189 len += 1;
4190 }
4191 if self.condition.is_some() {
4192 len += 1;
4193 }
4194 if self.left_table.is_some() {
4195 len += 1;
4196 }
4197 if self.right_table.is_some() {
4198 len += 1;
4199 }
4200 if self.condition_always_relax {
4201 len += 1;
4202 }
4203 if self.cleaned_by_watermark {
4204 len += 1;
4205 }
4206 let mut struct_ser = serializer.serialize_struct("stream_plan.DynamicFilterNode", len)?;
4207 if self.left_key != 0 {
4208 struct_ser.serialize_field("leftKey", &self.left_key)?;
4209 }
4210 if let Some(v) = self.condition.as_ref() {
4211 struct_ser.serialize_field("condition", v)?;
4212 }
4213 if let Some(v) = self.left_table.as_ref() {
4214 struct_ser.serialize_field("leftTable", v)?;
4215 }
4216 if let Some(v) = self.right_table.as_ref() {
4217 struct_ser.serialize_field("rightTable", v)?;
4218 }
4219 if self.condition_always_relax {
4220 struct_ser.serialize_field("conditionAlwaysRelax", &self.condition_always_relax)?;
4221 }
4222 if self.cleaned_by_watermark {
4223 struct_ser.serialize_field("cleanedByWatermark", &self.cleaned_by_watermark)?;
4224 }
4225 struct_ser.end()
4226 }
4227}
4228impl<'de> serde::Deserialize<'de> for DynamicFilterNode {
4229 #[allow(deprecated)]
4230 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4231 where
4232 D: serde::Deserializer<'de>,
4233 {
4234 const FIELDS: &[&str] = &[
4235 "left_key",
4236 "leftKey",
4237 "condition",
4238 "left_table",
4239 "leftTable",
4240 "right_table",
4241 "rightTable",
4242 "condition_always_relax",
4243 "conditionAlwaysRelax",
4244 "cleaned_by_watermark",
4245 "cleanedByWatermark",
4246 ];
4247
4248 #[allow(clippy::enum_variant_names)]
4249 enum GeneratedField {
4250 LeftKey,
4251 Condition,
4252 LeftTable,
4253 RightTable,
4254 ConditionAlwaysRelax,
4255 CleanedByWatermark,
4256 }
4257 impl<'de> serde::Deserialize<'de> for GeneratedField {
4258 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4259 where
4260 D: serde::Deserializer<'de>,
4261 {
4262 struct GeneratedVisitor;
4263
4264 impl serde::de::Visitor<'_> for GeneratedVisitor {
4265 type Value = GeneratedField;
4266
4267 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4268 write!(formatter, "expected one of: {:?}", &FIELDS)
4269 }
4270
4271 #[allow(unused_variables)]
4272 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4273 where
4274 E: serde::de::Error,
4275 {
4276 match value {
4277 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
4278 "condition" => Ok(GeneratedField::Condition),
4279 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
4280 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
4281 "conditionAlwaysRelax" | "condition_always_relax" => Ok(GeneratedField::ConditionAlwaysRelax),
4282 "cleanedByWatermark" | "cleaned_by_watermark" => Ok(GeneratedField::CleanedByWatermark),
4283 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4284 }
4285 }
4286 }
4287 deserializer.deserialize_identifier(GeneratedVisitor)
4288 }
4289 }
4290 struct GeneratedVisitor;
4291 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4292 type Value = DynamicFilterNode;
4293
4294 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4295 formatter.write_str("struct stream_plan.DynamicFilterNode")
4296 }
4297
4298 fn visit_map<V>(self, mut map_: V) -> std::result::Result<DynamicFilterNode, V::Error>
4299 where
4300 V: serde::de::MapAccess<'de>,
4301 {
4302 let mut left_key__ = None;
4303 let mut condition__ = None;
4304 let mut left_table__ = None;
4305 let mut right_table__ = None;
4306 let mut condition_always_relax__ = None;
4307 let mut cleaned_by_watermark__ = None;
4308 while let Some(k) = map_.next_key()? {
4309 match k {
4310 GeneratedField::LeftKey => {
4311 if left_key__.is_some() {
4312 return Err(serde::de::Error::duplicate_field("leftKey"));
4313 }
4314 left_key__ =
4315 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4316 ;
4317 }
4318 GeneratedField::Condition => {
4319 if condition__.is_some() {
4320 return Err(serde::de::Error::duplicate_field("condition"));
4321 }
4322 condition__ = map_.next_value()?;
4323 }
4324 GeneratedField::LeftTable => {
4325 if left_table__.is_some() {
4326 return Err(serde::de::Error::duplicate_field("leftTable"));
4327 }
4328 left_table__ = map_.next_value()?;
4329 }
4330 GeneratedField::RightTable => {
4331 if right_table__.is_some() {
4332 return Err(serde::de::Error::duplicate_field("rightTable"));
4333 }
4334 right_table__ = map_.next_value()?;
4335 }
4336 GeneratedField::ConditionAlwaysRelax => {
4337 if condition_always_relax__.is_some() {
4338 return Err(serde::de::Error::duplicate_field("conditionAlwaysRelax"));
4339 }
4340 condition_always_relax__ = Some(map_.next_value()?);
4341 }
4342 GeneratedField::CleanedByWatermark => {
4343 if cleaned_by_watermark__.is_some() {
4344 return Err(serde::de::Error::duplicate_field("cleanedByWatermark"));
4345 }
4346 cleaned_by_watermark__ = Some(map_.next_value()?);
4347 }
4348 }
4349 }
4350 Ok(DynamicFilterNode {
4351 left_key: left_key__.unwrap_or_default(),
4352 condition: condition__,
4353 left_table: left_table__,
4354 right_table: right_table__,
4355 condition_always_relax: condition_always_relax__.unwrap_or_default(),
4356 cleaned_by_watermark: cleaned_by_watermark__.unwrap_or_default(),
4357 })
4358 }
4359 }
4360 deserializer.deserialize_struct("stream_plan.DynamicFilterNode", FIELDS, GeneratedVisitor)
4361 }
4362}
4363impl serde::Serialize for EowcGapFillNode {
4364 #[allow(deprecated)]
4365 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4366 where
4367 S: serde::Serializer,
4368 {
4369 use serde::ser::SerializeStruct;
4370 let mut len = 0;
4371 if self.time_column_index != 0 {
4372 len += 1;
4373 }
4374 if self.interval.is_some() {
4375 len += 1;
4376 }
4377 if !self.fill_columns.is_empty() {
4378 len += 1;
4379 }
4380 if !self.fill_strategies.is_empty() {
4381 len += 1;
4382 }
4383 if self.buffer_table.is_some() {
4384 len += 1;
4385 }
4386 if self.prev_row_table.is_some() {
4387 len += 1;
4388 }
4389 if !self.partition_by_indices.is_empty() {
4390 len += 1;
4391 }
4392 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcGapFillNode", len)?;
4393 if self.time_column_index != 0 {
4394 struct_ser.serialize_field("timeColumnIndex", &self.time_column_index)?;
4395 }
4396 if let Some(v) = self.interval.as_ref() {
4397 struct_ser.serialize_field("interval", v)?;
4398 }
4399 if !self.fill_columns.is_empty() {
4400 struct_ser.serialize_field("fillColumns", &self.fill_columns)?;
4401 }
4402 if !self.fill_strategies.is_empty() {
4403 struct_ser.serialize_field("fillStrategies", &self.fill_strategies)?;
4404 }
4405 if let Some(v) = self.buffer_table.as_ref() {
4406 struct_ser.serialize_field("bufferTable", v)?;
4407 }
4408 if let Some(v) = self.prev_row_table.as_ref() {
4409 struct_ser.serialize_field("prevRowTable", v)?;
4410 }
4411 if !self.partition_by_indices.is_empty() {
4412 struct_ser.serialize_field("partitionByIndices", &self.partition_by_indices)?;
4413 }
4414 struct_ser.end()
4415 }
4416}
4417impl<'de> serde::Deserialize<'de> for EowcGapFillNode {
4418 #[allow(deprecated)]
4419 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4420 where
4421 D: serde::Deserializer<'de>,
4422 {
4423 const FIELDS: &[&str] = &[
4424 "time_column_index",
4425 "timeColumnIndex",
4426 "interval",
4427 "fill_columns",
4428 "fillColumns",
4429 "fill_strategies",
4430 "fillStrategies",
4431 "buffer_table",
4432 "bufferTable",
4433 "prev_row_table",
4434 "prevRowTable",
4435 "partition_by_indices",
4436 "partitionByIndices",
4437 ];
4438
4439 #[allow(clippy::enum_variant_names)]
4440 enum GeneratedField {
4441 TimeColumnIndex,
4442 Interval,
4443 FillColumns,
4444 FillStrategies,
4445 BufferTable,
4446 PrevRowTable,
4447 PartitionByIndices,
4448 }
4449 impl<'de> serde::Deserialize<'de> for GeneratedField {
4450 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4451 where
4452 D: serde::Deserializer<'de>,
4453 {
4454 struct GeneratedVisitor;
4455
4456 impl serde::de::Visitor<'_> for GeneratedVisitor {
4457 type Value = GeneratedField;
4458
4459 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4460 write!(formatter, "expected one of: {:?}", &FIELDS)
4461 }
4462
4463 #[allow(unused_variables)]
4464 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4465 where
4466 E: serde::de::Error,
4467 {
4468 match value {
4469 "timeColumnIndex" | "time_column_index" => Ok(GeneratedField::TimeColumnIndex),
4470 "interval" => Ok(GeneratedField::Interval),
4471 "fillColumns" | "fill_columns" => Ok(GeneratedField::FillColumns),
4472 "fillStrategies" | "fill_strategies" => Ok(GeneratedField::FillStrategies),
4473 "bufferTable" | "buffer_table" => Ok(GeneratedField::BufferTable),
4474 "prevRowTable" | "prev_row_table" => Ok(GeneratedField::PrevRowTable),
4475 "partitionByIndices" | "partition_by_indices" => Ok(GeneratedField::PartitionByIndices),
4476 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4477 }
4478 }
4479 }
4480 deserializer.deserialize_identifier(GeneratedVisitor)
4481 }
4482 }
4483 struct GeneratedVisitor;
4484 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4485 type Value = EowcGapFillNode;
4486
4487 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4488 formatter.write_str("struct stream_plan.EowcGapFillNode")
4489 }
4490
4491 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcGapFillNode, V::Error>
4492 where
4493 V: serde::de::MapAccess<'de>,
4494 {
4495 let mut time_column_index__ = None;
4496 let mut interval__ = None;
4497 let mut fill_columns__ = None;
4498 let mut fill_strategies__ = None;
4499 let mut buffer_table__ = None;
4500 let mut prev_row_table__ = None;
4501 let mut partition_by_indices__ = None;
4502 while let Some(k) = map_.next_key()? {
4503 match k {
4504 GeneratedField::TimeColumnIndex => {
4505 if time_column_index__.is_some() {
4506 return Err(serde::de::Error::duplicate_field("timeColumnIndex"));
4507 }
4508 time_column_index__ =
4509 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4510 ;
4511 }
4512 GeneratedField::Interval => {
4513 if interval__.is_some() {
4514 return Err(serde::de::Error::duplicate_field("interval"));
4515 }
4516 interval__ = map_.next_value()?;
4517 }
4518 GeneratedField::FillColumns => {
4519 if fill_columns__.is_some() {
4520 return Err(serde::de::Error::duplicate_field("fillColumns"));
4521 }
4522 fill_columns__ =
4523 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4524 .into_iter().map(|x| x.0).collect())
4525 ;
4526 }
4527 GeneratedField::FillStrategies => {
4528 if fill_strategies__.is_some() {
4529 return Err(serde::de::Error::duplicate_field("fillStrategies"));
4530 }
4531 fill_strategies__ = Some(map_.next_value()?);
4532 }
4533 GeneratedField::BufferTable => {
4534 if buffer_table__.is_some() {
4535 return Err(serde::de::Error::duplicate_field("bufferTable"));
4536 }
4537 buffer_table__ = map_.next_value()?;
4538 }
4539 GeneratedField::PrevRowTable => {
4540 if prev_row_table__.is_some() {
4541 return Err(serde::de::Error::duplicate_field("prevRowTable"));
4542 }
4543 prev_row_table__ = map_.next_value()?;
4544 }
4545 GeneratedField::PartitionByIndices => {
4546 if partition_by_indices__.is_some() {
4547 return Err(serde::de::Error::duplicate_field("partitionByIndices"));
4548 }
4549 partition_by_indices__ =
4550 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4551 .into_iter().map(|x| x.0).collect())
4552 ;
4553 }
4554 }
4555 }
4556 Ok(EowcGapFillNode {
4557 time_column_index: time_column_index__.unwrap_or_default(),
4558 interval: interval__,
4559 fill_columns: fill_columns__.unwrap_or_default(),
4560 fill_strategies: fill_strategies__.unwrap_or_default(),
4561 buffer_table: buffer_table__,
4562 prev_row_table: prev_row_table__,
4563 partition_by_indices: partition_by_indices__.unwrap_or_default(),
4564 })
4565 }
4566 }
4567 deserializer.deserialize_struct("stream_plan.EowcGapFillNode", FIELDS, GeneratedVisitor)
4568 }
4569}
4570impl serde::Serialize for EowcOverWindowNode {
4571 #[allow(deprecated)]
4572 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4573 where
4574 S: serde::Serializer,
4575 {
4576 use serde::ser::SerializeStruct;
4577 let mut len = 0;
4578 if !self.calls.is_empty() {
4579 len += 1;
4580 }
4581 if !self.partition_by.is_empty() {
4582 len += 1;
4583 }
4584 if !self.order_by.is_empty() {
4585 len += 1;
4586 }
4587 if self.state_table.is_some() {
4588 len += 1;
4589 }
4590 if self.intermediate_state_table.is_some() {
4591 len += 1;
4592 }
4593 let mut struct_ser = serializer.serialize_struct("stream_plan.EowcOverWindowNode", len)?;
4594 if !self.calls.is_empty() {
4595 struct_ser.serialize_field("calls", &self.calls)?;
4596 }
4597 if !self.partition_by.is_empty() {
4598 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
4599 }
4600 if !self.order_by.is_empty() {
4601 struct_ser.serialize_field("orderBy", &self.order_by)?;
4602 }
4603 if let Some(v) = self.state_table.as_ref() {
4604 struct_ser.serialize_field("stateTable", v)?;
4605 }
4606 if let Some(v) = self.intermediate_state_table.as_ref() {
4607 struct_ser.serialize_field("intermediateStateTable", v)?;
4608 }
4609 struct_ser.end()
4610 }
4611}
4612impl<'de> serde::Deserialize<'de> for EowcOverWindowNode {
4613 #[allow(deprecated)]
4614 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4615 where
4616 D: serde::Deserializer<'de>,
4617 {
4618 const FIELDS: &[&str] = &[
4619 "calls",
4620 "partition_by",
4621 "partitionBy",
4622 "order_by",
4623 "orderBy",
4624 "state_table",
4625 "stateTable",
4626 "intermediate_state_table",
4627 "intermediateStateTable",
4628 ];
4629
4630 #[allow(clippy::enum_variant_names)]
4631 enum GeneratedField {
4632 Calls,
4633 PartitionBy,
4634 OrderBy,
4635 StateTable,
4636 IntermediateStateTable,
4637 }
4638 impl<'de> serde::Deserialize<'de> for GeneratedField {
4639 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4640 where
4641 D: serde::Deserializer<'de>,
4642 {
4643 struct GeneratedVisitor;
4644
4645 impl serde::de::Visitor<'_> for GeneratedVisitor {
4646 type Value = GeneratedField;
4647
4648 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4649 write!(formatter, "expected one of: {:?}", &FIELDS)
4650 }
4651
4652 #[allow(unused_variables)]
4653 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4654 where
4655 E: serde::de::Error,
4656 {
4657 match value {
4658 "calls" => Ok(GeneratedField::Calls),
4659 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
4660 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
4661 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
4662 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
4663 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4664 }
4665 }
4666 }
4667 deserializer.deserialize_identifier(GeneratedVisitor)
4668 }
4669 }
4670 struct GeneratedVisitor;
4671 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4672 type Value = EowcOverWindowNode;
4673
4674 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4675 formatter.write_str("struct stream_plan.EowcOverWindowNode")
4676 }
4677
4678 fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcOverWindowNode, V::Error>
4679 where
4680 V: serde::de::MapAccess<'de>,
4681 {
4682 let mut calls__ = None;
4683 let mut partition_by__ = None;
4684 let mut order_by__ = None;
4685 let mut state_table__ = None;
4686 let mut intermediate_state_table__ = None;
4687 while let Some(k) = map_.next_key()? {
4688 match k {
4689 GeneratedField::Calls => {
4690 if calls__.is_some() {
4691 return Err(serde::de::Error::duplicate_field("calls"));
4692 }
4693 calls__ = Some(map_.next_value()?);
4694 }
4695 GeneratedField::PartitionBy => {
4696 if partition_by__.is_some() {
4697 return Err(serde::de::Error::duplicate_field("partitionBy"));
4698 }
4699 partition_by__ =
4700 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4701 .into_iter().map(|x| x.0).collect())
4702 ;
4703 }
4704 GeneratedField::OrderBy => {
4705 if order_by__.is_some() {
4706 return Err(serde::de::Error::duplicate_field("orderBy"));
4707 }
4708 order_by__ = Some(map_.next_value()?);
4709 }
4710 GeneratedField::StateTable => {
4711 if state_table__.is_some() {
4712 return Err(serde::de::Error::duplicate_field("stateTable"));
4713 }
4714 state_table__ = map_.next_value()?;
4715 }
4716 GeneratedField::IntermediateStateTable => {
4717 if intermediate_state_table__.is_some() {
4718 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
4719 }
4720 intermediate_state_table__ = map_.next_value()?;
4721 }
4722 }
4723 }
4724 Ok(EowcOverWindowNode {
4725 calls: calls__.unwrap_or_default(),
4726 partition_by: partition_by__.unwrap_or_default(),
4727 order_by: order_by__.unwrap_or_default(),
4728 state_table: state_table__,
4729 intermediate_state_table: intermediate_state_table__,
4730 })
4731 }
4732 }
4733 deserializer.deserialize_struct("stream_plan.EowcOverWindowNode", FIELDS, GeneratedVisitor)
4734 }
4735}
4736impl serde::Serialize for ExchangeNode {
4737 #[allow(deprecated)]
4738 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4739 where
4740 S: serde::Serializer,
4741 {
4742 use serde::ser::SerializeStruct;
4743 let mut len = 0;
4744 if self.strategy.is_some() {
4745 len += 1;
4746 }
4747 let mut struct_ser = serializer.serialize_struct("stream_plan.ExchangeNode", len)?;
4748 if let Some(v) = self.strategy.as_ref() {
4749 struct_ser.serialize_field("strategy", v)?;
4750 }
4751 struct_ser.end()
4752 }
4753}
4754impl<'de> serde::Deserialize<'de> for ExchangeNode {
4755 #[allow(deprecated)]
4756 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4757 where
4758 D: serde::Deserializer<'de>,
4759 {
4760 const FIELDS: &[&str] = &[
4761 "strategy",
4762 ];
4763
4764 #[allow(clippy::enum_variant_names)]
4765 enum GeneratedField {
4766 Strategy,
4767 }
4768 impl<'de> serde::Deserialize<'de> for GeneratedField {
4769 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4770 where
4771 D: serde::Deserializer<'de>,
4772 {
4773 struct GeneratedVisitor;
4774
4775 impl serde::de::Visitor<'_> for GeneratedVisitor {
4776 type Value = GeneratedField;
4777
4778 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4779 write!(formatter, "expected one of: {:?}", &FIELDS)
4780 }
4781
4782 #[allow(unused_variables)]
4783 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4784 where
4785 E: serde::de::Error,
4786 {
4787 match value {
4788 "strategy" => Ok(GeneratedField::Strategy),
4789 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4790 }
4791 }
4792 }
4793 deserializer.deserialize_identifier(GeneratedVisitor)
4794 }
4795 }
4796 struct GeneratedVisitor;
4797 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4798 type Value = ExchangeNode;
4799
4800 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4801 formatter.write_str("struct stream_plan.ExchangeNode")
4802 }
4803
4804 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExchangeNode, V::Error>
4805 where
4806 V: serde::de::MapAccess<'de>,
4807 {
4808 let mut strategy__ = None;
4809 while let Some(k) = map_.next_key()? {
4810 match k {
4811 GeneratedField::Strategy => {
4812 if strategy__.is_some() {
4813 return Err(serde::de::Error::duplicate_field("strategy"));
4814 }
4815 strategy__ = map_.next_value()?;
4816 }
4817 }
4818 }
4819 Ok(ExchangeNode {
4820 strategy: strategy__,
4821 })
4822 }
4823 }
4824 deserializer.deserialize_struct("stream_plan.ExchangeNode", FIELDS, GeneratedVisitor)
4825 }
4826}
4827impl serde::Serialize for ExpandNode {
4828 #[allow(deprecated)]
4829 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4830 where
4831 S: serde::Serializer,
4832 {
4833 use serde::ser::SerializeStruct;
4834 let mut len = 0;
4835 if !self.column_subsets.is_empty() {
4836 len += 1;
4837 }
4838 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode", len)?;
4839 if !self.column_subsets.is_empty() {
4840 struct_ser.serialize_field("columnSubsets", &self.column_subsets)?;
4841 }
4842 struct_ser.end()
4843 }
4844}
4845impl<'de> serde::Deserialize<'de> for ExpandNode {
4846 #[allow(deprecated)]
4847 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4848 where
4849 D: serde::Deserializer<'de>,
4850 {
4851 const FIELDS: &[&str] = &[
4852 "column_subsets",
4853 "columnSubsets",
4854 ];
4855
4856 #[allow(clippy::enum_variant_names)]
4857 enum GeneratedField {
4858 ColumnSubsets,
4859 }
4860 impl<'de> serde::Deserialize<'de> for GeneratedField {
4861 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4862 where
4863 D: serde::Deserializer<'de>,
4864 {
4865 struct GeneratedVisitor;
4866
4867 impl serde::de::Visitor<'_> for GeneratedVisitor {
4868 type Value = GeneratedField;
4869
4870 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4871 write!(formatter, "expected one of: {:?}", &FIELDS)
4872 }
4873
4874 #[allow(unused_variables)]
4875 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4876 where
4877 E: serde::de::Error,
4878 {
4879 match value {
4880 "columnSubsets" | "column_subsets" => Ok(GeneratedField::ColumnSubsets),
4881 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4882 }
4883 }
4884 }
4885 deserializer.deserialize_identifier(GeneratedVisitor)
4886 }
4887 }
4888 struct GeneratedVisitor;
4889 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4890 type Value = ExpandNode;
4891
4892 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4893 formatter.write_str("struct stream_plan.ExpandNode")
4894 }
4895
4896 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpandNode, V::Error>
4897 where
4898 V: serde::de::MapAccess<'de>,
4899 {
4900 let mut column_subsets__ = None;
4901 while let Some(k) = map_.next_key()? {
4902 match k {
4903 GeneratedField::ColumnSubsets => {
4904 if column_subsets__.is_some() {
4905 return Err(serde::de::Error::duplicate_field("columnSubsets"));
4906 }
4907 column_subsets__ = Some(map_.next_value()?);
4908 }
4909 }
4910 }
4911 Ok(ExpandNode {
4912 column_subsets: column_subsets__.unwrap_or_default(),
4913 })
4914 }
4915 }
4916 deserializer.deserialize_struct("stream_plan.ExpandNode", FIELDS, GeneratedVisitor)
4917 }
4918}
4919impl serde::Serialize for expand_node::Subset {
4920 #[allow(deprecated)]
4921 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4922 where
4923 S: serde::Serializer,
4924 {
4925 use serde::ser::SerializeStruct;
4926 let mut len = 0;
4927 if !self.column_indices.is_empty() {
4928 len += 1;
4929 }
4930 let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode.Subset", len)?;
4931 if !self.column_indices.is_empty() {
4932 struct_ser.serialize_field("columnIndices", &self.column_indices)?;
4933 }
4934 struct_ser.end()
4935 }
4936}
4937impl<'de> serde::Deserialize<'de> for expand_node::Subset {
4938 #[allow(deprecated)]
4939 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4940 where
4941 D: serde::Deserializer<'de>,
4942 {
4943 const FIELDS: &[&str] = &[
4944 "column_indices",
4945 "columnIndices",
4946 ];
4947
4948 #[allow(clippy::enum_variant_names)]
4949 enum GeneratedField {
4950 ColumnIndices,
4951 }
4952 impl<'de> serde::Deserialize<'de> for GeneratedField {
4953 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4954 where
4955 D: serde::Deserializer<'de>,
4956 {
4957 struct GeneratedVisitor;
4958
4959 impl serde::de::Visitor<'_> for GeneratedVisitor {
4960 type Value = GeneratedField;
4961
4962 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4963 write!(formatter, "expected one of: {:?}", &FIELDS)
4964 }
4965
4966 #[allow(unused_variables)]
4967 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4968 where
4969 E: serde::de::Error,
4970 {
4971 match value {
4972 "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
4973 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4974 }
4975 }
4976 }
4977 deserializer.deserialize_identifier(GeneratedVisitor)
4978 }
4979 }
4980 struct GeneratedVisitor;
4981 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4982 type Value = expand_node::Subset;
4983
4984 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4985 formatter.write_str("struct stream_plan.ExpandNode.Subset")
4986 }
4987
4988 fn visit_map<V>(self, mut map_: V) -> std::result::Result<expand_node::Subset, V::Error>
4989 where
4990 V: serde::de::MapAccess<'de>,
4991 {
4992 let mut column_indices__ = None;
4993 while let Some(k) = map_.next_key()? {
4994 match k {
4995 GeneratedField::ColumnIndices => {
4996 if column_indices__.is_some() {
4997 return Err(serde::de::Error::duplicate_field("columnIndices"));
4998 }
4999 column_indices__ =
5000 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5001 .into_iter().map(|x| x.0).collect())
5002 ;
5003 }
5004 }
5005 }
5006 Ok(expand_node::Subset {
5007 column_indices: column_indices__.unwrap_or_default(),
5008 })
5009 }
5010 }
5011 deserializer.deserialize_struct("stream_plan.ExpandNode.Subset", FIELDS, GeneratedVisitor)
5012 }
5013}
5014impl serde::Serialize for FilterNode {
5015 #[allow(deprecated)]
5016 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5017 where
5018 S: serde::Serializer,
5019 {
5020 use serde::ser::SerializeStruct;
5021 let mut len = 0;
5022 if self.search_condition.is_some() {
5023 len += 1;
5024 }
5025 let mut struct_ser = serializer.serialize_struct("stream_plan.FilterNode", len)?;
5026 if let Some(v) = self.search_condition.as_ref() {
5027 struct_ser.serialize_field("searchCondition", v)?;
5028 }
5029 struct_ser.end()
5030 }
5031}
5032impl<'de> serde::Deserialize<'de> for FilterNode {
5033 #[allow(deprecated)]
5034 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5035 where
5036 D: serde::Deserializer<'de>,
5037 {
5038 const FIELDS: &[&str] = &[
5039 "search_condition",
5040 "searchCondition",
5041 ];
5042
5043 #[allow(clippy::enum_variant_names)]
5044 enum GeneratedField {
5045 SearchCondition,
5046 }
5047 impl<'de> serde::Deserialize<'de> for GeneratedField {
5048 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5049 where
5050 D: serde::Deserializer<'de>,
5051 {
5052 struct GeneratedVisitor;
5053
5054 impl serde::de::Visitor<'_> for GeneratedVisitor {
5055 type Value = GeneratedField;
5056
5057 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5058 write!(formatter, "expected one of: {:?}", &FIELDS)
5059 }
5060
5061 #[allow(unused_variables)]
5062 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5063 where
5064 E: serde::de::Error,
5065 {
5066 match value {
5067 "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
5068 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5069 }
5070 }
5071 }
5072 deserializer.deserialize_identifier(GeneratedVisitor)
5073 }
5074 }
5075 struct GeneratedVisitor;
5076 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5077 type Value = FilterNode;
5078
5079 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5080 formatter.write_str("struct stream_plan.FilterNode")
5081 }
5082
5083 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FilterNode, V::Error>
5084 where
5085 V: serde::de::MapAccess<'de>,
5086 {
5087 let mut search_condition__ = None;
5088 while let Some(k) = map_.next_key()? {
5089 match k {
5090 GeneratedField::SearchCondition => {
5091 if search_condition__.is_some() {
5092 return Err(serde::de::Error::duplicate_field("searchCondition"));
5093 }
5094 search_condition__ = map_.next_value()?;
5095 }
5096 }
5097 }
5098 Ok(FilterNode {
5099 search_condition: search_condition__,
5100 })
5101 }
5102 }
5103 deserializer.deserialize_struct("stream_plan.FilterNode", FIELDS, GeneratedVisitor)
5104 }
5105}
5106impl serde::Serialize for GapFillNode {
5107 #[allow(deprecated)]
5108 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5109 where
5110 S: serde::Serializer,
5111 {
5112 use serde::ser::SerializeStruct;
5113 let mut len = 0;
5114 if self.time_column_index != 0 {
5115 len += 1;
5116 }
5117 if self.interval.is_some() {
5118 len += 1;
5119 }
5120 if !self.fill_columns.is_empty() {
5121 len += 1;
5122 }
5123 if !self.fill_strategies.is_empty() {
5124 len += 1;
5125 }
5126 if self.state_table.is_some() {
5127 len += 1;
5128 }
5129 if !self.partition_by_indices.is_empty() {
5130 len += 1;
5131 }
5132 if !self.pointer_key_indices.is_empty() {
5133 len += 1;
5134 }
5135 let mut struct_ser = serializer.serialize_struct("stream_plan.GapFillNode", len)?;
5136 if self.time_column_index != 0 {
5137 struct_ser.serialize_field("timeColumnIndex", &self.time_column_index)?;
5138 }
5139 if let Some(v) = self.interval.as_ref() {
5140 struct_ser.serialize_field("interval", v)?;
5141 }
5142 if !self.fill_columns.is_empty() {
5143 struct_ser.serialize_field("fillColumns", &self.fill_columns)?;
5144 }
5145 if !self.fill_strategies.is_empty() {
5146 struct_ser.serialize_field("fillStrategies", &self.fill_strategies)?;
5147 }
5148 if let Some(v) = self.state_table.as_ref() {
5149 struct_ser.serialize_field("stateTable", v)?;
5150 }
5151 if !self.partition_by_indices.is_empty() {
5152 struct_ser.serialize_field("partitionByIndices", &self.partition_by_indices)?;
5153 }
5154 if !self.pointer_key_indices.is_empty() {
5155 struct_ser.serialize_field("pointerKeyIndices", &self.pointer_key_indices)?;
5156 }
5157 struct_ser.end()
5158 }
5159}
5160impl<'de> serde::Deserialize<'de> for GapFillNode {
5161 #[allow(deprecated)]
5162 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5163 where
5164 D: serde::Deserializer<'de>,
5165 {
5166 const FIELDS: &[&str] = &[
5167 "time_column_index",
5168 "timeColumnIndex",
5169 "interval",
5170 "fill_columns",
5171 "fillColumns",
5172 "fill_strategies",
5173 "fillStrategies",
5174 "state_table",
5175 "stateTable",
5176 "partition_by_indices",
5177 "partitionByIndices",
5178 "pointer_key_indices",
5179 "pointerKeyIndices",
5180 ];
5181
5182 #[allow(clippy::enum_variant_names)]
5183 enum GeneratedField {
5184 TimeColumnIndex,
5185 Interval,
5186 FillColumns,
5187 FillStrategies,
5188 StateTable,
5189 PartitionByIndices,
5190 PointerKeyIndices,
5191 }
5192 impl<'de> serde::Deserialize<'de> for GeneratedField {
5193 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5194 where
5195 D: serde::Deserializer<'de>,
5196 {
5197 struct GeneratedVisitor;
5198
5199 impl serde::de::Visitor<'_> for GeneratedVisitor {
5200 type Value = GeneratedField;
5201
5202 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5203 write!(formatter, "expected one of: {:?}", &FIELDS)
5204 }
5205
5206 #[allow(unused_variables)]
5207 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5208 where
5209 E: serde::de::Error,
5210 {
5211 match value {
5212 "timeColumnIndex" | "time_column_index" => Ok(GeneratedField::TimeColumnIndex),
5213 "interval" => Ok(GeneratedField::Interval),
5214 "fillColumns" | "fill_columns" => Ok(GeneratedField::FillColumns),
5215 "fillStrategies" | "fill_strategies" => Ok(GeneratedField::FillStrategies),
5216 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
5217 "partitionByIndices" | "partition_by_indices" => Ok(GeneratedField::PartitionByIndices),
5218 "pointerKeyIndices" | "pointer_key_indices" => Ok(GeneratedField::PointerKeyIndices),
5219 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5220 }
5221 }
5222 }
5223 deserializer.deserialize_identifier(GeneratedVisitor)
5224 }
5225 }
5226 struct GeneratedVisitor;
5227 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5228 type Value = GapFillNode;
5229
5230 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5231 formatter.write_str("struct stream_plan.GapFillNode")
5232 }
5233
5234 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GapFillNode, V::Error>
5235 where
5236 V: serde::de::MapAccess<'de>,
5237 {
5238 let mut time_column_index__ = None;
5239 let mut interval__ = None;
5240 let mut fill_columns__ = None;
5241 let mut fill_strategies__ = None;
5242 let mut state_table__ = None;
5243 let mut partition_by_indices__ = None;
5244 let mut pointer_key_indices__ = None;
5245 while let Some(k) = map_.next_key()? {
5246 match k {
5247 GeneratedField::TimeColumnIndex => {
5248 if time_column_index__.is_some() {
5249 return Err(serde::de::Error::duplicate_field("timeColumnIndex"));
5250 }
5251 time_column_index__ =
5252 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5253 ;
5254 }
5255 GeneratedField::Interval => {
5256 if interval__.is_some() {
5257 return Err(serde::de::Error::duplicate_field("interval"));
5258 }
5259 interval__ = map_.next_value()?;
5260 }
5261 GeneratedField::FillColumns => {
5262 if fill_columns__.is_some() {
5263 return Err(serde::de::Error::duplicate_field("fillColumns"));
5264 }
5265 fill_columns__ =
5266 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5267 .into_iter().map(|x| x.0).collect())
5268 ;
5269 }
5270 GeneratedField::FillStrategies => {
5271 if fill_strategies__.is_some() {
5272 return Err(serde::de::Error::duplicate_field("fillStrategies"));
5273 }
5274 fill_strategies__ = Some(map_.next_value()?);
5275 }
5276 GeneratedField::StateTable => {
5277 if state_table__.is_some() {
5278 return Err(serde::de::Error::duplicate_field("stateTable"));
5279 }
5280 state_table__ = map_.next_value()?;
5281 }
5282 GeneratedField::PartitionByIndices => {
5283 if partition_by_indices__.is_some() {
5284 return Err(serde::de::Error::duplicate_field("partitionByIndices"));
5285 }
5286 partition_by_indices__ =
5287 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5288 .into_iter().map(|x| x.0).collect())
5289 ;
5290 }
5291 GeneratedField::PointerKeyIndices => {
5292 if pointer_key_indices__.is_some() {
5293 return Err(serde::de::Error::duplicate_field("pointerKeyIndices"));
5294 }
5295 pointer_key_indices__ =
5296 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5297 .into_iter().map(|x| x.0).collect())
5298 ;
5299 }
5300 }
5301 }
5302 Ok(GapFillNode {
5303 time_column_index: time_column_index__.unwrap_or_default(),
5304 interval: interval__,
5305 fill_columns: fill_columns__.unwrap_or_default(),
5306 fill_strategies: fill_strategies__.unwrap_or_default(),
5307 state_table: state_table__,
5308 partition_by_indices: partition_by_indices__.unwrap_or_default(),
5309 pointer_key_indices: pointer_key_indices__.unwrap_or_default(),
5310 })
5311 }
5312 }
5313 deserializer.deserialize_struct("stream_plan.GapFillNode", FIELDS, GeneratedVisitor)
5314 }
5315}
5316impl serde::Serialize for GlobalApproxPercentileNode {
5317 #[allow(deprecated)]
5318 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5319 where
5320 S: serde::Serializer,
5321 {
5322 use serde::ser::SerializeStruct;
5323 let mut len = 0;
5324 if self.base != 0. {
5325 len += 1;
5326 }
5327 if self.quantile != 0. {
5328 len += 1;
5329 }
5330 if self.bucket_state_table.is_some() {
5331 len += 1;
5332 }
5333 if self.count_state_table.is_some() {
5334 len += 1;
5335 }
5336 let mut struct_ser = serializer.serialize_struct("stream_plan.GlobalApproxPercentileNode", len)?;
5337 if self.base != 0. {
5338 struct_ser.serialize_field("base", &self.base)?;
5339 }
5340 if self.quantile != 0. {
5341 struct_ser.serialize_field("quantile", &self.quantile)?;
5342 }
5343 if let Some(v) = self.bucket_state_table.as_ref() {
5344 struct_ser.serialize_field("bucketStateTable", v)?;
5345 }
5346 if let Some(v) = self.count_state_table.as_ref() {
5347 struct_ser.serialize_field("countStateTable", v)?;
5348 }
5349 struct_ser.end()
5350 }
5351}
5352impl<'de> serde::Deserialize<'de> for GlobalApproxPercentileNode {
5353 #[allow(deprecated)]
5354 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5355 where
5356 D: serde::Deserializer<'de>,
5357 {
5358 const FIELDS: &[&str] = &[
5359 "base",
5360 "quantile",
5361 "bucket_state_table",
5362 "bucketStateTable",
5363 "count_state_table",
5364 "countStateTable",
5365 ];
5366
5367 #[allow(clippy::enum_variant_names)]
5368 enum GeneratedField {
5369 Base,
5370 Quantile,
5371 BucketStateTable,
5372 CountStateTable,
5373 }
5374 impl<'de> serde::Deserialize<'de> for GeneratedField {
5375 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5376 where
5377 D: serde::Deserializer<'de>,
5378 {
5379 struct GeneratedVisitor;
5380
5381 impl serde::de::Visitor<'_> for GeneratedVisitor {
5382 type Value = GeneratedField;
5383
5384 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5385 write!(formatter, "expected one of: {:?}", &FIELDS)
5386 }
5387
5388 #[allow(unused_variables)]
5389 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5390 where
5391 E: serde::de::Error,
5392 {
5393 match value {
5394 "base" => Ok(GeneratedField::Base),
5395 "quantile" => Ok(GeneratedField::Quantile),
5396 "bucketStateTable" | "bucket_state_table" => Ok(GeneratedField::BucketStateTable),
5397 "countStateTable" | "count_state_table" => Ok(GeneratedField::CountStateTable),
5398 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5399 }
5400 }
5401 }
5402 deserializer.deserialize_identifier(GeneratedVisitor)
5403 }
5404 }
5405 struct GeneratedVisitor;
5406 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5407 type Value = GlobalApproxPercentileNode;
5408
5409 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5410 formatter.write_str("struct stream_plan.GlobalApproxPercentileNode")
5411 }
5412
5413 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GlobalApproxPercentileNode, V::Error>
5414 where
5415 V: serde::de::MapAccess<'de>,
5416 {
5417 let mut base__ = None;
5418 let mut quantile__ = None;
5419 let mut bucket_state_table__ = None;
5420 let mut count_state_table__ = None;
5421 while let Some(k) = map_.next_key()? {
5422 match k {
5423 GeneratedField::Base => {
5424 if base__.is_some() {
5425 return Err(serde::de::Error::duplicate_field("base"));
5426 }
5427 base__ =
5428 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5429 ;
5430 }
5431 GeneratedField::Quantile => {
5432 if quantile__.is_some() {
5433 return Err(serde::de::Error::duplicate_field("quantile"));
5434 }
5435 quantile__ =
5436 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5437 ;
5438 }
5439 GeneratedField::BucketStateTable => {
5440 if bucket_state_table__.is_some() {
5441 return Err(serde::de::Error::duplicate_field("bucketStateTable"));
5442 }
5443 bucket_state_table__ = map_.next_value()?;
5444 }
5445 GeneratedField::CountStateTable => {
5446 if count_state_table__.is_some() {
5447 return Err(serde::de::Error::duplicate_field("countStateTable"));
5448 }
5449 count_state_table__ = map_.next_value()?;
5450 }
5451 }
5452 }
5453 Ok(GlobalApproxPercentileNode {
5454 base: base__.unwrap_or_default(),
5455 quantile: quantile__.unwrap_or_default(),
5456 bucket_state_table: bucket_state_table__,
5457 count_state_table: count_state_table__,
5458 })
5459 }
5460 }
5461 deserializer.deserialize_struct("stream_plan.GlobalApproxPercentileNode", FIELDS, GeneratedVisitor)
5462 }
5463}
5464impl serde::Serialize for GroupTopNNode {
5465 #[allow(deprecated)]
5466 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5467 where
5468 S: serde::Serializer,
5469 {
5470 use serde::ser::SerializeStruct;
5471 let mut len = 0;
5472 if self.limit != 0 {
5473 len += 1;
5474 }
5475 if self.offset != 0 {
5476 len += 1;
5477 }
5478 if !self.group_key.is_empty() {
5479 len += 1;
5480 }
5481 if self.table.is_some() {
5482 len += 1;
5483 }
5484 if !self.order_by.is_empty() {
5485 len += 1;
5486 }
5487 if self.with_ties {
5488 len += 1;
5489 }
5490 let mut struct_ser = serializer.serialize_struct("stream_plan.GroupTopNNode", len)?;
5491 if self.limit != 0 {
5492 #[allow(clippy::needless_borrow)]
5493 #[allow(clippy::needless_borrows_for_generic_args)]
5494 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
5495 }
5496 if self.offset != 0 {
5497 #[allow(clippy::needless_borrow)]
5498 #[allow(clippy::needless_borrows_for_generic_args)]
5499 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
5500 }
5501 if !self.group_key.is_empty() {
5502 struct_ser.serialize_field("groupKey", &self.group_key)?;
5503 }
5504 if let Some(v) = self.table.as_ref() {
5505 struct_ser.serialize_field("table", v)?;
5506 }
5507 if !self.order_by.is_empty() {
5508 struct_ser.serialize_field("orderBy", &self.order_by)?;
5509 }
5510 if self.with_ties {
5511 struct_ser.serialize_field("withTies", &self.with_ties)?;
5512 }
5513 struct_ser.end()
5514 }
5515}
5516impl<'de> serde::Deserialize<'de> for GroupTopNNode {
5517 #[allow(deprecated)]
5518 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5519 where
5520 D: serde::Deserializer<'de>,
5521 {
5522 const FIELDS: &[&str] = &[
5523 "limit",
5524 "offset",
5525 "group_key",
5526 "groupKey",
5527 "table",
5528 "order_by",
5529 "orderBy",
5530 "with_ties",
5531 "withTies",
5532 ];
5533
5534 #[allow(clippy::enum_variant_names)]
5535 enum GeneratedField {
5536 Limit,
5537 Offset,
5538 GroupKey,
5539 Table,
5540 OrderBy,
5541 WithTies,
5542 }
5543 impl<'de> serde::Deserialize<'de> for GeneratedField {
5544 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5545 where
5546 D: serde::Deserializer<'de>,
5547 {
5548 struct GeneratedVisitor;
5549
5550 impl serde::de::Visitor<'_> for GeneratedVisitor {
5551 type Value = GeneratedField;
5552
5553 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5554 write!(formatter, "expected one of: {:?}", &FIELDS)
5555 }
5556
5557 #[allow(unused_variables)]
5558 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5559 where
5560 E: serde::de::Error,
5561 {
5562 match value {
5563 "limit" => Ok(GeneratedField::Limit),
5564 "offset" => Ok(GeneratedField::Offset),
5565 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5566 "table" => Ok(GeneratedField::Table),
5567 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
5568 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
5569 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5570 }
5571 }
5572 }
5573 deserializer.deserialize_identifier(GeneratedVisitor)
5574 }
5575 }
5576 struct GeneratedVisitor;
5577 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5578 type Value = GroupTopNNode;
5579
5580 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5581 formatter.write_str("struct stream_plan.GroupTopNNode")
5582 }
5583
5584 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupTopNNode, V::Error>
5585 where
5586 V: serde::de::MapAccess<'de>,
5587 {
5588 let mut limit__ = None;
5589 let mut offset__ = None;
5590 let mut group_key__ = None;
5591 let mut table__ = None;
5592 let mut order_by__ = None;
5593 let mut with_ties__ = None;
5594 while let Some(k) = map_.next_key()? {
5595 match k {
5596 GeneratedField::Limit => {
5597 if limit__.is_some() {
5598 return Err(serde::de::Error::duplicate_field("limit"));
5599 }
5600 limit__ =
5601 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5602 ;
5603 }
5604 GeneratedField::Offset => {
5605 if offset__.is_some() {
5606 return Err(serde::de::Error::duplicate_field("offset"));
5607 }
5608 offset__ =
5609 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5610 ;
5611 }
5612 GeneratedField::GroupKey => {
5613 if group_key__.is_some() {
5614 return Err(serde::de::Error::duplicate_field("groupKey"));
5615 }
5616 group_key__ =
5617 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5618 .into_iter().map(|x| x.0).collect())
5619 ;
5620 }
5621 GeneratedField::Table => {
5622 if table__.is_some() {
5623 return Err(serde::de::Error::duplicate_field("table"));
5624 }
5625 table__ = map_.next_value()?;
5626 }
5627 GeneratedField::OrderBy => {
5628 if order_by__.is_some() {
5629 return Err(serde::de::Error::duplicate_field("orderBy"));
5630 }
5631 order_by__ = Some(map_.next_value()?);
5632 }
5633 GeneratedField::WithTies => {
5634 if with_ties__.is_some() {
5635 return Err(serde::de::Error::duplicate_field("withTies"));
5636 }
5637 with_ties__ = Some(map_.next_value()?);
5638 }
5639 }
5640 }
5641 Ok(GroupTopNNode {
5642 limit: limit__.unwrap_or_default(),
5643 offset: offset__.unwrap_or_default(),
5644 group_key: group_key__.unwrap_or_default(),
5645 table: table__,
5646 order_by: order_by__.unwrap_or_default(),
5647 with_ties: with_ties__.unwrap_or_default(),
5648 })
5649 }
5650 }
5651 deserializer.deserialize_struct("stream_plan.GroupTopNNode", FIELDS, GeneratedVisitor)
5652 }
5653}
5654impl serde::Serialize for HashAggNode {
5655 #[allow(deprecated)]
5656 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5657 where
5658 S: serde::Serializer,
5659 {
5660 use serde::ser::SerializeStruct;
5661 let mut len = 0;
5662 if !self.group_key.is_empty() {
5663 len += 1;
5664 }
5665 if !self.agg_calls.is_empty() {
5666 len += 1;
5667 }
5668 if !self.agg_call_states.is_empty() {
5669 len += 1;
5670 }
5671 if self.intermediate_state_table.is_some() {
5672 len += 1;
5673 }
5674 if self.is_append_only {
5675 len += 1;
5676 }
5677 if !self.distinct_dedup_tables.is_empty() {
5678 len += 1;
5679 }
5680 if self.row_count_index != 0 {
5681 len += 1;
5682 }
5683 if self.emit_on_window_close {
5684 len += 1;
5685 }
5686 if self.version != 0 {
5687 len += 1;
5688 }
5689 let mut struct_ser = serializer.serialize_struct("stream_plan.HashAggNode", len)?;
5690 if !self.group_key.is_empty() {
5691 struct_ser.serialize_field("groupKey", &self.group_key)?;
5692 }
5693 if !self.agg_calls.is_empty() {
5694 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
5695 }
5696 if !self.agg_call_states.is_empty() {
5697 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
5698 }
5699 if let Some(v) = self.intermediate_state_table.as_ref() {
5700 struct_ser.serialize_field("intermediateStateTable", v)?;
5701 }
5702 if self.is_append_only {
5703 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5704 }
5705 if !self.distinct_dedup_tables.is_empty() {
5706 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
5707 }
5708 if self.row_count_index != 0 {
5709 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
5710 }
5711 if self.emit_on_window_close {
5712 struct_ser.serialize_field("emitOnWindowClose", &self.emit_on_window_close)?;
5713 }
5714 if self.version != 0 {
5715 let v = AggNodeVersion::try_from(self.version)
5716 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
5717 struct_ser.serialize_field("version", &v)?;
5718 }
5719 struct_ser.end()
5720 }
5721}
5722impl<'de> serde::Deserialize<'de> for HashAggNode {
5723 #[allow(deprecated)]
5724 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5725 where
5726 D: serde::Deserializer<'de>,
5727 {
5728 const FIELDS: &[&str] = &[
5729 "group_key",
5730 "groupKey",
5731 "agg_calls",
5732 "aggCalls",
5733 "agg_call_states",
5734 "aggCallStates",
5735 "intermediate_state_table",
5736 "intermediateStateTable",
5737 "is_append_only",
5738 "isAppendOnly",
5739 "distinct_dedup_tables",
5740 "distinctDedupTables",
5741 "row_count_index",
5742 "rowCountIndex",
5743 "emit_on_window_close",
5744 "emitOnWindowClose",
5745 "version",
5746 ];
5747
5748 #[allow(clippy::enum_variant_names)]
5749 enum GeneratedField {
5750 GroupKey,
5751 AggCalls,
5752 AggCallStates,
5753 IntermediateStateTable,
5754 IsAppendOnly,
5755 DistinctDedupTables,
5756 RowCountIndex,
5757 EmitOnWindowClose,
5758 Version,
5759 }
5760 impl<'de> serde::Deserialize<'de> for GeneratedField {
5761 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5762 where
5763 D: serde::Deserializer<'de>,
5764 {
5765 struct GeneratedVisitor;
5766
5767 impl serde::de::Visitor<'_> for GeneratedVisitor {
5768 type Value = GeneratedField;
5769
5770 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5771 write!(formatter, "expected one of: {:?}", &FIELDS)
5772 }
5773
5774 #[allow(unused_variables)]
5775 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5776 where
5777 E: serde::de::Error,
5778 {
5779 match value {
5780 "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5781 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
5782 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
5783 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
5784 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5785 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
5786 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
5787 "emitOnWindowClose" | "emit_on_window_close" => Ok(GeneratedField::EmitOnWindowClose),
5788 "version" => Ok(GeneratedField::Version),
5789 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5790 }
5791 }
5792 }
5793 deserializer.deserialize_identifier(GeneratedVisitor)
5794 }
5795 }
5796 struct GeneratedVisitor;
5797 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5798 type Value = HashAggNode;
5799
5800 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5801 formatter.write_str("struct stream_plan.HashAggNode")
5802 }
5803
5804 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashAggNode, V::Error>
5805 where
5806 V: serde::de::MapAccess<'de>,
5807 {
5808 let mut group_key__ = None;
5809 let mut agg_calls__ = None;
5810 let mut agg_call_states__ = None;
5811 let mut intermediate_state_table__ = None;
5812 let mut is_append_only__ = None;
5813 let mut distinct_dedup_tables__ = None;
5814 let mut row_count_index__ = None;
5815 let mut emit_on_window_close__ = None;
5816 let mut version__ = None;
5817 while let Some(k) = map_.next_key()? {
5818 match k {
5819 GeneratedField::GroupKey => {
5820 if group_key__.is_some() {
5821 return Err(serde::de::Error::duplicate_field("groupKey"));
5822 }
5823 group_key__ =
5824 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5825 .into_iter().map(|x| x.0).collect())
5826 ;
5827 }
5828 GeneratedField::AggCalls => {
5829 if agg_calls__.is_some() {
5830 return Err(serde::de::Error::duplicate_field("aggCalls"));
5831 }
5832 agg_calls__ = Some(map_.next_value()?);
5833 }
5834 GeneratedField::AggCallStates => {
5835 if agg_call_states__.is_some() {
5836 return Err(serde::de::Error::duplicate_field("aggCallStates"));
5837 }
5838 agg_call_states__ = Some(map_.next_value()?);
5839 }
5840 GeneratedField::IntermediateStateTable => {
5841 if intermediate_state_table__.is_some() {
5842 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
5843 }
5844 intermediate_state_table__ = map_.next_value()?;
5845 }
5846 GeneratedField::IsAppendOnly => {
5847 if is_append_only__.is_some() {
5848 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
5849 }
5850 is_append_only__ = Some(map_.next_value()?);
5851 }
5852 GeneratedField::DistinctDedupTables => {
5853 if distinct_dedup_tables__.is_some() {
5854 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
5855 }
5856 distinct_dedup_tables__ = Some(
5857 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5858 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
5859 );
5860 }
5861 GeneratedField::RowCountIndex => {
5862 if row_count_index__.is_some() {
5863 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
5864 }
5865 row_count_index__ =
5866 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5867 ;
5868 }
5869 GeneratedField::EmitOnWindowClose => {
5870 if emit_on_window_close__.is_some() {
5871 return Err(serde::de::Error::duplicate_field("emitOnWindowClose"));
5872 }
5873 emit_on_window_close__ = Some(map_.next_value()?);
5874 }
5875 GeneratedField::Version => {
5876 if version__.is_some() {
5877 return Err(serde::de::Error::duplicate_field("version"));
5878 }
5879 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
5880 }
5881 }
5882 }
5883 Ok(HashAggNode {
5884 group_key: group_key__.unwrap_or_default(),
5885 agg_calls: agg_calls__.unwrap_or_default(),
5886 agg_call_states: agg_call_states__.unwrap_or_default(),
5887 intermediate_state_table: intermediate_state_table__,
5888 is_append_only: is_append_only__.unwrap_or_default(),
5889 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
5890 row_count_index: row_count_index__.unwrap_or_default(),
5891 emit_on_window_close: emit_on_window_close__.unwrap_or_default(),
5892 version: version__.unwrap_or_default(),
5893 })
5894 }
5895 }
5896 deserializer.deserialize_struct("stream_plan.HashAggNode", FIELDS, GeneratedVisitor)
5897 }
5898}
5899impl serde::Serialize for HashJoinNode {
5900 #[allow(deprecated)]
5901 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5902 where
5903 S: serde::Serializer,
5904 {
5905 use serde::ser::SerializeStruct;
5906 let mut len = 0;
5907 if self.join_type != 0 {
5908 len += 1;
5909 }
5910 if !self.left_key.is_empty() {
5911 len += 1;
5912 }
5913 if !self.right_key.is_empty() {
5914 len += 1;
5915 }
5916 if self.condition.is_some() {
5917 len += 1;
5918 }
5919 if self.left_table.is_some() {
5920 len += 1;
5921 }
5922 if self.right_table.is_some() {
5923 len += 1;
5924 }
5925 if self.left_degree_table.is_some() {
5926 len += 1;
5927 }
5928 if self.right_degree_table.is_some() {
5929 len += 1;
5930 }
5931 if !self.output_indices.is_empty() {
5932 len += 1;
5933 }
5934 if !self.left_deduped_input_pk_indices.is_empty() {
5935 len += 1;
5936 }
5937 if !self.right_deduped_input_pk_indices.is_empty() {
5938 len += 1;
5939 }
5940 if !self.null_safe.is_empty() {
5941 len += 1;
5942 }
5943 if self.is_append_only {
5944 len += 1;
5945 }
5946 if self.join_encoding_type != 0 {
5947 len += 1;
5948 }
5949 if self.watermark_handle_desc.is_some() {
5950 len += 1;
5951 }
5952 let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinNode", len)?;
5953 if self.join_type != 0 {
5954 let v = super::plan_common::JoinType::try_from(self.join_type)
5955 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
5956 struct_ser.serialize_field("joinType", &v)?;
5957 }
5958 if !self.left_key.is_empty() {
5959 struct_ser.serialize_field("leftKey", &self.left_key)?;
5960 }
5961 if !self.right_key.is_empty() {
5962 struct_ser.serialize_field("rightKey", &self.right_key)?;
5963 }
5964 if let Some(v) = self.condition.as_ref() {
5965 struct_ser.serialize_field("condition", v)?;
5966 }
5967 if let Some(v) = self.left_table.as_ref() {
5968 struct_ser.serialize_field("leftTable", v)?;
5969 }
5970 if let Some(v) = self.right_table.as_ref() {
5971 struct_ser.serialize_field("rightTable", v)?;
5972 }
5973 if let Some(v) = self.left_degree_table.as_ref() {
5974 struct_ser.serialize_field("leftDegreeTable", v)?;
5975 }
5976 if let Some(v) = self.right_degree_table.as_ref() {
5977 struct_ser.serialize_field("rightDegreeTable", v)?;
5978 }
5979 if !self.output_indices.is_empty() {
5980 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
5981 }
5982 if !self.left_deduped_input_pk_indices.is_empty() {
5983 struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
5984 }
5985 if !self.right_deduped_input_pk_indices.is_empty() {
5986 struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
5987 }
5988 if !self.null_safe.is_empty() {
5989 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
5990 }
5991 if self.is_append_only {
5992 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5993 }
5994 if self.join_encoding_type != 0 {
5995 let v = JoinEncodingType::try_from(self.join_encoding_type)
5996 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
5997 struct_ser.serialize_field("joinEncodingType", &v)?;
5998 }
5999 if let Some(v) = self.watermark_handle_desc.as_ref() {
6000 struct_ser.serialize_field("watermarkHandleDesc", v)?;
6001 }
6002 struct_ser.end()
6003 }
6004}
6005impl<'de> serde::Deserialize<'de> for HashJoinNode {
6006 #[allow(deprecated)]
6007 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6008 where
6009 D: serde::Deserializer<'de>,
6010 {
6011 const FIELDS: &[&str] = &[
6012 "join_type",
6013 "joinType",
6014 "left_key",
6015 "leftKey",
6016 "right_key",
6017 "rightKey",
6018 "condition",
6019 "left_table",
6020 "leftTable",
6021 "right_table",
6022 "rightTable",
6023 "left_degree_table",
6024 "leftDegreeTable",
6025 "right_degree_table",
6026 "rightDegreeTable",
6027 "output_indices",
6028 "outputIndices",
6029 "left_deduped_input_pk_indices",
6030 "leftDedupedInputPkIndices",
6031 "right_deduped_input_pk_indices",
6032 "rightDedupedInputPkIndices",
6033 "null_safe",
6034 "nullSafe",
6035 "is_append_only",
6036 "isAppendOnly",
6037 "join_encoding_type",
6038 "joinEncodingType",
6039 "watermark_handle_desc",
6040 "watermarkHandleDesc",
6041 ];
6042
6043 #[allow(clippy::enum_variant_names)]
6044 enum GeneratedField {
6045 JoinType,
6046 LeftKey,
6047 RightKey,
6048 Condition,
6049 LeftTable,
6050 RightTable,
6051 LeftDegreeTable,
6052 RightDegreeTable,
6053 OutputIndices,
6054 LeftDedupedInputPkIndices,
6055 RightDedupedInputPkIndices,
6056 NullSafe,
6057 IsAppendOnly,
6058 JoinEncodingType,
6059 WatermarkHandleDesc,
6060 }
6061 impl<'de> serde::Deserialize<'de> for GeneratedField {
6062 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6063 where
6064 D: serde::Deserializer<'de>,
6065 {
6066 struct GeneratedVisitor;
6067
6068 impl serde::de::Visitor<'_> for GeneratedVisitor {
6069 type Value = GeneratedField;
6070
6071 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6072 write!(formatter, "expected one of: {:?}", &FIELDS)
6073 }
6074
6075 #[allow(unused_variables)]
6076 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6077 where
6078 E: serde::de::Error,
6079 {
6080 match value {
6081 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
6082 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
6083 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
6084 "condition" => Ok(GeneratedField::Condition),
6085 "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
6086 "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
6087 "leftDegreeTable" | "left_degree_table" => Ok(GeneratedField::LeftDegreeTable),
6088 "rightDegreeTable" | "right_degree_table" => Ok(GeneratedField::RightDegreeTable),
6089 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
6090 "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
6091 "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
6092 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
6093 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
6094 "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
6095 "watermarkHandleDesc" | "watermark_handle_desc" => Ok(GeneratedField::WatermarkHandleDesc),
6096 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6097 }
6098 }
6099 }
6100 deserializer.deserialize_identifier(GeneratedVisitor)
6101 }
6102 }
6103 struct GeneratedVisitor;
6104 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6105 type Value = HashJoinNode;
6106
6107 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6108 formatter.write_str("struct stream_plan.HashJoinNode")
6109 }
6110
6111 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinNode, V::Error>
6112 where
6113 V: serde::de::MapAccess<'de>,
6114 {
6115 let mut join_type__ = None;
6116 let mut left_key__ = None;
6117 let mut right_key__ = None;
6118 let mut condition__ = None;
6119 let mut left_table__ = None;
6120 let mut right_table__ = None;
6121 let mut left_degree_table__ = None;
6122 let mut right_degree_table__ = None;
6123 let mut output_indices__ = None;
6124 let mut left_deduped_input_pk_indices__ = None;
6125 let mut right_deduped_input_pk_indices__ = None;
6126 let mut null_safe__ = None;
6127 let mut is_append_only__ = None;
6128 let mut join_encoding_type__ = None;
6129 let mut watermark_handle_desc__ = None;
6130 while let Some(k) = map_.next_key()? {
6131 match k {
6132 GeneratedField::JoinType => {
6133 if join_type__.is_some() {
6134 return Err(serde::de::Error::duplicate_field("joinType"));
6135 }
6136 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
6137 }
6138 GeneratedField::LeftKey => {
6139 if left_key__.is_some() {
6140 return Err(serde::de::Error::duplicate_field("leftKey"));
6141 }
6142 left_key__ =
6143 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6144 .into_iter().map(|x| x.0).collect())
6145 ;
6146 }
6147 GeneratedField::RightKey => {
6148 if right_key__.is_some() {
6149 return Err(serde::de::Error::duplicate_field("rightKey"));
6150 }
6151 right_key__ =
6152 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6153 .into_iter().map(|x| x.0).collect())
6154 ;
6155 }
6156 GeneratedField::Condition => {
6157 if condition__.is_some() {
6158 return Err(serde::de::Error::duplicate_field("condition"));
6159 }
6160 condition__ = map_.next_value()?;
6161 }
6162 GeneratedField::LeftTable => {
6163 if left_table__.is_some() {
6164 return Err(serde::de::Error::duplicate_field("leftTable"));
6165 }
6166 left_table__ = map_.next_value()?;
6167 }
6168 GeneratedField::RightTable => {
6169 if right_table__.is_some() {
6170 return Err(serde::de::Error::duplicate_field("rightTable"));
6171 }
6172 right_table__ = map_.next_value()?;
6173 }
6174 GeneratedField::LeftDegreeTable => {
6175 if left_degree_table__.is_some() {
6176 return Err(serde::de::Error::duplicate_field("leftDegreeTable"));
6177 }
6178 left_degree_table__ = map_.next_value()?;
6179 }
6180 GeneratedField::RightDegreeTable => {
6181 if right_degree_table__.is_some() {
6182 return Err(serde::de::Error::duplicate_field("rightDegreeTable"));
6183 }
6184 right_degree_table__ = map_.next_value()?;
6185 }
6186 GeneratedField::OutputIndices => {
6187 if output_indices__.is_some() {
6188 return Err(serde::de::Error::duplicate_field("outputIndices"));
6189 }
6190 output_indices__ =
6191 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6192 .into_iter().map(|x| x.0).collect())
6193 ;
6194 }
6195 GeneratedField::LeftDedupedInputPkIndices => {
6196 if left_deduped_input_pk_indices__.is_some() {
6197 return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
6198 }
6199 left_deduped_input_pk_indices__ =
6200 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6201 .into_iter().map(|x| x.0).collect())
6202 ;
6203 }
6204 GeneratedField::RightDedupedInputPkIndices => {
6205 if right_deduped_input_pk_indices__.is_some() {
6206 return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
6207 }
6208 right_deduped_input_pk_indices__ =
6209 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6210 .into_iter().map(|x| x.0).collect())
6211 ;
6212 }
6213 GeneratedField::NullSafe => {
6214 if null_safe__.is_some() {
6215 return Err(serde::de::Error::duplicate_field("nullSafe"));
6216 }
6217 null_safe__ = Some(map_.next_value()?);
6218 }
6219 GeneratedField::IsAppendOnly => {
6220 if is_append_only__.is_some() {
6221 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
6222 }
6223 is_append_only__ = Some(map_.next_value()?);
6224 }
6225 GeneratedField::JoinEncodingType => {
6226 if join_encoding_type__.is_some() {
6227 return Err(serde::de::Error::duplicate_field("joinEncodingType"));
6228 }
6229 join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
6230 }
6231 GeneratedField::WatermarkHandleDesc => {
6232 if watermark_handle_desc__.is_some() {
6233 return Err(serde::de::Error::duplicate_field("watermarkHandleDesc"));
6234 }
6235 watermark_handle_desc__ = map_.next_value()?;
6236 }
6237 }
6238 }
6239 Ok(HashJoinNode {
6240 join_type: join_type__.unwrap_or_default(),
6241 left_key: left_key__.unwrap_or_default(),
6242 right_key: right_key__.unwrap_or_default(),
6243 condition: condition__,
6244 left_table: left_table__,
6245 right_table: right_table__,
6246 left_degree_table: left_degree_table__,
6247 right_degree_table: right_degree_table__,
6248 output_indices: output_indices__.unwrap_or_default(),
6249 left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
6250 right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
6251 null_safe: null_safe__.unwrap_or_default(),
6252 is_append_only: is_append_only__.unwrap_or_default(),
6253 join_encoding_type: join_encoding_type__.unwrap_or_default(),
6254 watermark_handle_desc: watermark_handle_desc__,
6255 })
6256 }
6257 }
6258 deserializer.deserialize_struct("stream_plan.HashJoinNode", FIELDS, GeneratedVisitor)
6259 }
6260}
6261impl serde::Serialize for HashJoinWatermarkHandleDesc {
6262 #[allow(deprecated)]
6263 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6264 where
6265 S: serde::Serializer,
6266 {
6267 use serde::ser::SerializeStruct;
6268 let mut len = 0;
6269 if !self.watermark_indices_in_jk.is_empty() {
6270 len += 1;
6271 }
6272 if !self.inequality_pairs.is_empty() {
6273 len += 1;
6274 }
6275 let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinWatermarkHandleDesc", len)?;
6276 if !self.watermark_indices_in_jk.is_empty() {
6277 struct_ser.serialize_field("watermarkIndicesInJk", &self.watermark_indices_in_jk)?;
6278 }
6279 if !self.inequality_pairs.is_empty() {
6280 struct_ser.serialize_field("inequalityPairs", &self.inequality_pairs)?;
6281 }
6282 struct_ser.end()
6283 }
6284}
6285impl<'de> serde::Deserialize<'de> for HashJoinWatermarkHandleDesc {
6286 #[allow(deprecated)]
6287 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6288 where
6289 D: serde::Deserializer<'de>,
6290 {
6291 const FIELDS: &[&str] = &[
6292 "watermark_indices_in_jk",
6293 "watermarkIndicesInJk",
6294 "inequality_pairs",
6295 "inequalityPairs",
6296 ];
6297
6298 #[allow(clippy::enum_variant_names)]
6299 enum GeneratedField {
6300 WatermarkIndicesInJk,
6301 InequalityPairs,
6302 }
6303 impl<'de> serde::Deserialize<'de> for GeneratedField {
6304 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6305 where
6306 D: serde::Deserializer<'de>,
6307 {
6308 struct GeneratedVisitor;
6309
6310 impl serde::de::Visitor<'_> for GeneratedVisitor {
6311 type Value = GeneratedField;
6312
6313 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6314 write!(formatter, "expected one of: {:?}", &FIELDS)
6315 }
6316
6317 #[allow(unused_variables)]
6318 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6319 where
6320 E: serde::de::Error,
6321 {
6322 match value {
6323 "watermarkIndicesInJk" | "watermark_indices_in_jk" => Ok(GeneratedField::WatermarkIndicesInJk),
6324 "inequalityPairs" | "inequality_pairs" => Ok(GeneratedField::InequalityPairs),
6325 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6326 }
6327 }
6328 }
6329 deserializer.deserialize_identifier(GeneratedVisitor)
6330 }
6331 }
6332 struct GeneratedVisitor;
6333 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6334 type Value = HashJoinWatermarkHandleDesc;
6335
6336 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6337 formatter.write_str("struct stream_plan.HashJoinWatermarkHandleDesc")
6338 }
6339
6340 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinWatermarkHandleDesc, V::Error>
6341 where
6342 V: serde::de::MapAccess<'de>,
6343 {
6344 let mut watermark_indices_in_jk__ = None;
6345 let mut inequality_pairs__ = None;
6346 while let Some(k) = map_.next_key()? {
6347 match k {
6348 GeneratedField::WatermarkIndicesInJk => {
6349 if watermark_indices_in_jk__.is_some() {
6350 return Err(serde::de::Error::duplicate_field("watermarkIndicesInJk"));
6351 }
6352 watermark_indices_in_jk__ = Some(map_.next_value()?);
6353 }
6354 GeneratedField::InequalityPairs => {
6355 if inequality_pairs__.is_some() {
6356 return Err(serde::de::Error::duplicate_field("inequalityPairs"));
6357 }
6358 inequality_pairs__ = Some(map_.next_value()?);
6359 }
6360 }
6361 }
6362 Ok(HashJoinWatermarkHandleDesc {
6363 watermark_indices_in_jk: watermark_indices_in_jk__.unwrap_or_default(),
6364 inequality_pairs: inequality_pairs__.unwrap_or_default(),
6365 })
6366 }
6367 }
6368 deserializer.deserialize_struct("stream_plan.HashJoinWatermarkHandleDesc", FIELDS, GeneratedVisitor)
6369 }
6370}
6371impl serde::Serialize for HopWindowNode {
6372 #[allow(deprecated)]
6373 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6374 where
6375 S: serde::Serializer,
6376 {
6377 use serde::ser::SerializeStruct;
6378 let mut len = 0;
6379 if self.time_col != 0 {
6380 len += 1;
6381 }
6382 if self.window_slide.is_some() {
6383 len += 1;
6384 }
6385 if self.window_size.is_some() {
6386 len += 1;
6387 }
6388 if !self.output_indices.is_empty() {
6389 len += 1;
6390 }
6391 if !self.window_start_exprs.is_empty() {
6392 len += 1;
6393 }
6394 if !self.window_end_exprs.is_empty() {
6395 len += 1;
6396 }
6397 let mut struct_ser = serializer.serialize_struct("stream_plan.HopWindowNode", len)?;
6398 if self.time_col != 0 {
6399 struct_ser.serialize_field("timeCol", &self.time_col)?;
6400 }
6401 if let Some(v) = self.window_slide.as_ref() {
6402 struct_ser.serialize_field("windowSlide", v)?;
6403 }
6404 if let Some(v) = self.window_size.as_ref() {
6405 struct_ser.serialize_field("windowSize", v)?;
6406 }
6407 if !self.output_indices.is_empty() {
6408 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
6409 }
6410 if !self.window_start_exprs.is_empty() {
6411 struct_ser.serialize_field("windowStartExprs", &self.window_start_exprs)?;
6412 }
6413 if !self.window_end_exprs.is_empty() {
6414 struct_ser.serialize_field("windowEndExprs", &self.window_end_exprs)?;
6415 }
6416 struct_ser.end()
6417 }
6418}
6419impl<'de> serde::Deserialize<'de> for HopWindowNode {
6420 #[allow(deprecated)]
6421 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6422 where
6423 D: serde::Deserializer<'de>,
6424 {
6425 const FIELDS: &[&str] = &[
6426 "time_col",
6427 "timeCol",
6428 "window_slide",
6429 "windowSlide",
6430 "window_size",
6431 "windowSize",
6432 "output_indices",
6433 "outputIndices",
6434 "window_start_exprs",
6435 "windowStartExprs",
6436 "window_end_exprs",
6437 "windowEndExprs",
6438 ];
6439
6440 #[allow(clippy::enum_variant_names)]
6441 enum GeneratedField {
6442 TimeCol,
6443 WindowSlide,
6444 WindowSize,
6445 OutputIndices,
6446 WindowStartExprs,
6447 WindowEndExprs,
6448 }
6449 impl<'de> serde::Deserialize<'de> for GeneratedField {
6450 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6451 where
6452 D: serde::Deserializer<'de>,
6453 {
6454 struct GeneratedVisitor;
6455
6456 impl serde::de::Visitor<'_> for GeneratedVisitor {
6457 type Value = GeneratedField;
6458
6459 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6460 write!(formatter, "expected one of: {:?}", &FIELDS)
6461 }
6462
6463 #[allow(unused_variables)]
6464 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6465 where
6466 E: serde::de::Error,
6467 {
6468 match value {
6469 "timeCol" | "time_col" => Ok(GeneratedField::TimeCol),
6470 "windowSlide" | "window_slide" => Ok(GeneratedField::WindowSlide),
6471 "windowSize" | "window_size" => Ok(GeneratedField::WindowSize),
6472 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
6473 "windowStartExprs" | "window_start_exprs" => Ok(GeneratedField::WindowStartExprs),
6474 "windowEndExprs" | "window_end_exprs" => Ok(GeneratedField::WindowEndExprs),
6475 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6476 }
6477 }
6478 }
6479 deserializer.deserialize_identifier(GeneratedVisitor)
6480 }
6481 }
6482 struct GeneratedVisitor;
6483 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6484 type Value = HopWindowNode;
6485
6486 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6487 formatter.write_str("struct stream_plan.HopWindowNode")
6488 }
6489
6490 fn visit_map<V>(self, mut map_: V) -> std::result::Result<HopWindowNode, V::Error>
6491 where
6492 V: serde::de::MapAccess<'de>,
6493 {
6494 let mut time_col__ = None;
6495 let mut window_slide__ = None;
6496 let mut window_size__ = None;
6497 let mut output_indices__ = None;
6498 let mut window_start_exprs__ = None;
6499 let mut window_end_exprs__ = None;
6500 while let Some(k) = map_.next_key()? {
6501 match k {
6502 GeneratedField::TimeCol => {
6503 if time_col__.is_some() {
6504 return Err(serde::de::Error::duplicate_field("timeCol"));
6505 }
6506 time_col__ =
6507 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6508 ;
6509 }
6510 GeneratedField::WindowSlide => {
6511 if window_slide__.is_some() {
6512 return Err(serde::de::Error::duplicate_field("windowSlide"));
6513 }
6514 window_slide__ = map_.next_value()?;
6515 }
6516 GeneratedField::WindowSize => {
6517 if window_size__.is_some() {
6518 return Err(serde::de::Error::duplicate_field("windowSize"));
6519 }
6520 window_size__ = map_.next_value()?;
6521 }
6522 GeneratedField::OutputIndices => {
6523 if output_indices__.is_some() {
6524 return Err(serde::de::Error::duplicate_field("outputIndices"));
6525 }
6526 output_indices__ =
6527 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6528 .into_iter().map(|x| x.0).collect())
6529 ;
6530 }
6531 GeneratedField::WindowStartExprs => {
6532 if window_start_exprs__.is_some() {
6533 return Err(serde::de::Error::duplicate_field("windowStartExprs"));
6534 }
6535 window_start_exprs__ = Some(map_.next_value()?);
6536 }
6537 GeneratedField::WindowEndExprs => {
6538 if window_end_exprs__.is_some() {
6539 return Err(serde::de::Error::duplicate_field("windowEndExprs"));
6540 }
6541 window_end_exprs__ = Some(map_.next_value()?);
6542 }
6543 }
6544 }
6545 Ok(HopWindowNode {
6546 time_col: time_col__.unwrap_or_default(),
6547 window_slide: window_slide__,
6548 window_size: window_size__,
6549 output_indices: output_indices__.unwrap_or_default(),
6550 window_start_exprs: window_start_exprs__.unwrap_or_default(),
6551 window_end_exprs: window_end_exprs__.unwrap_or_default(),
6552 })
6553 }
6554 }
6555 deserializer.deserialize_struct("stream_plan.HopWindowNode", FIELDS, GeneratedVisitor)
6556 }
6557}
6558impl serde::Serialize for IcebergWithPkIndexDvMergerNode {
6559 #[allow(deprecated)]
6560 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6561 where
6562 S: serde::Serializer,
6563 {
6564 use serde::ser::SerializeStruct;
6565 let mut len = 0;
6566 if self.sink_desc.is_some() {
6567 len += 1;
6568 }
6569 let mut struct_ser = serializer.serialize_struct("stream_plan.IcebergWithPkIndexDvMergerNode", len)?;
6570 if let Some(v) = self.sink_desc.as_ref() {
6571 struct_ser.serialize_field("sinkDesc", v)?;
6572 }
6573 struct_ser.end()
6574 }
6575}
6576impl<'de> serde::Deserialize<'de> for IcebergWithPkIndexDvMergerNode {
6577 #[allow(deprecated)]
6578 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6579 where
6580 D: serde::Deserializer<'de>,
6581 {
6582 const FIELDS: &[&str] = &[
6583 "sink_desc",
6584 "sinkDesc",
6585 ];
6586
6587 #[allow(clippy::enum_variant_names)]
6588 enum GeneratedField {
6589 SinkDesc,
6590 }
6591 impl<'de> serde::Deserialize<'de> for GeneratedField {
6592 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6593 where
6594 D: serde::Deserializer<'de>,
6595 {
6596 struct GeneratedVisitor;
6597
6598 impl serde::de::Visitor<'_> for GeneratedVisitor {
6599 type Value = GeneratedField;
6600
6601 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6602 write!(formatter, "expected one of: {:?}", &FIELDS)
6603 }
6604
6605 #[allow(unused_variables)]
6606 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6607 where
6608 E: serde::de::Error,
6609 {
6610 match value {
6611 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
6612 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6613 }
6614 }
6615 }
6616 deserializer.deserialize_identifier(GeneratedVisitor)
6617 }
6618 }
6619 struct GeneratedVisitor;
6620 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6621 type Value = IcebergWithPkIndexDvMergerNode;
6622
6623 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6624 formatter.write_str("struct stream_plan.IcebergWithPkIndexDvMergerNode")
6625 }
6626
6627 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IcebergWithPkIndexDvMergerNode, V::Error>
6628 where
6629 V: serde::de::MapAccess<'de>,
6630 {
6631 let mut sink_desc__ = None;
6632 while let Some(k) = map_.next_key()? {
6633 match k {
6634 GeneratedField::SinkDesc => {
6635 if sink_desc__.is_some() {
6636 return Err(serde::de::Error::duplicate_field("sinkDesc"));
6637 }
6638 sink_desc__ = map_.next_value()?;
6639 }
6640 }
6641 }
6642 Ok(IcebergWithPkIndexDvMergerNode {
6643 sink_desc: sink_desc__,
6644 })
6645 }
6646 }
6647 deserializer.deserialize_struct("stream_plan.IcebergWithPkIndexDvMergerNode", FIELDS, GeneratedVisitor)
6648 }
6649}
6650impl serde::Serialize for IcebergWithPkIndexWriterNode {
6651 #[allow(deprecated)]
6652 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6653 where
6654 S: serde::Serializer,
6655 {
6656 use serde::ser::SerializeStruct;
6657 let mut len = 0;
6658 if self.sink_desc.is_some() {
6659 len += 1;
6660 }
6661 if self.pk_index_table.is_some() {
6662 len += 1;
6663 }
6664 let mut struct_ser = serializer.serialize_struct("stream_plan.IcebergWithPkIndexWriterNode", len)?;
6665 if let Some(v) = self.sink_desc.as_ref() {
6666 struct_ser.serialize_field("sinkDesc", v)?;
6667 }
6668 if let Some(v) = self.pk_index_table.as_ref() {
6669 struct_ser.serialize_field("pkIndexTable", v)?;
6670 }
6671 struct_ser.end()
6672 }
6673}
6674impl<'de> serde::Deserialize<'de> for IcebergWithPkIndexWriterNode {
6675 #[allow(deprecated)]
6676 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6677 where
6678 D: serde::Deserializer<'de>,
6679 {
6680 const FIELDS: &[&str] = &[
6681 "sink_desc",
6682 "sinkDesc",
6683 "pk_index_table",
6684 "pkIndexTable",
6685 ];
6686
6687 #[allow(clippy::enum_variant_names)]
6688 enum GeneratedField {
6689 SinkDesc,
6690 PkIndexTable,
6691 }
6692 impl<'de> serde::Deserialize<'de> for GeneratedField {
6693 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6694 where
6695 D: serde::Deserializer<'de>,
6696 {
6697 struct GeneratedVisitor;
6698
6699 impl serde::de::Visitor<'_> for GeneratedVisitor {
6700 type Value = GeneratedField;
6701
6702 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6703 write!(formatter, "expected one of: {:?}", &FIELDS)
6704 }
6705
6706 #[allow(unused_variables)]
6707 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6708 where
6709 E: serde::de::Error,
6710 {
6711 match value {
6712 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
6713 "pkIndexTable" | "pk_index_table" => Ok(GeneratedField::PkIndexTable),
6714 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6715 }
6716 }
6717 }
6718 deserializer.deserialize_identifier(GeneratedVisitor)
6719 }
6720 }
6721 struct GeneratedVisitor;
6722 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6723 type Value = IcebergWithPkIndexWriterNode;
6724
6725 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6726 formatter.write_str("struct stream_plan.IcebergWithPkIndexWriterNode")
6727 }
6728
6729 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IcebergWithPkIndexWriterNode, V::Error>
6730 where
6731 V: serde::de::MapAccess<'de>,
6732 {
6733 let mut sink_desc__ = None;
6734 let mut pk_index_table__ = None;
6735 while let Some(k) = map_.next_key()? {
6736 match k {
6737 GeneratedField::SinkDesc => {
6738 if sink_desc__.is_some() {
6739 return Err(serde::de::Error::duplicate_field("sinkDesc"));
6740 }
6741 sink_desc__ = map_.next_value()?;
6742 }
6743 GeneratedField::PkIndexTable => {
6744 if pk_index_table__.is_some() {
6745 return Err(serde::de::Error::duplicate_field("pkIndexTable"));
6746 }
6747 pk_index_table__ = map_.next_value()?;
6748 }
6749 }
6750 }
6751 Ok(IcebergWithPkIndexWriterNode {
6752 sink_desc: sink_desc__,
6753 pk_index_table: pk_index_table__,
6754 })
6755 }
6756 }
6757 deserializer.deserialize_struct("stream_plan.IcebergWithPkIndexWriterNode", FIELDS, GeneratedVisitor)
6758 }
6759}
6760impl serde::Serialize for InequalityPair {
6761 #[allow(deprecated)]
6762 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6763 where
6764 S: serde::Serializer,
6765 {
6766 use serde::ser::SerializeStruct;
6767 let mut len = 0;
6768 if self.key_required_larger != 0 {
6769 len += 1;
6770 }
6771 if self.key_required_smaller != 0 {
6772 len += 1;
6773 }
6774 if self.clean_state {
6775 len += 1;
6776 }
6777 if self.delta_expression.is_some() {
6778 len += 1;
6779 }
6780 let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPair", len)?;
6781 if self.key_required_larger != 0 {
6782 struct_ser.serialize_field("keyRequiredLarger", &self.key_required_larger)?;
6783 }
6784 if self.key_required_smaller != 0 {
6785 struct_ser.serialize_field("keyRequiredSmaller", &self.key_required_smaller)?;
6786 }
6787 if self.clean_state {
6788 struct_ser.serialize_field("cleanState", &self.clean_state)?;
6789 }
6790 if let Some(v) = self.delta_expression.as_ref() {
6791 struct_ser.serialize_field("deltaExpression", v)?;
6792 }
6793 struct_ser.end()
6794 }
6795}
6796impl<'de> serde::Deserialize<'de> for InequalityPair {
6797 #[allow(deprecated)]
6798 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6799 where
6800 D: serde::Deserializer<'de>,
6801 {
6802 const FIELDS: &[&str] = &[
6803 "key_required_larger",
6804 "keyRequiredLarger",
6805 "key_required_smaller",
6806 "keyRequiredSmaller",
6807 "clean_state",
6808 "cleanState",
6809 "delta_expression",
6810 "deltaExpression",
6811 ];
6812
6813 #[allow(clippy::enum_variant_names)]
6814 enum GeneratedField {
6815 KeyRequiredLarger,
6816 KeyRequiredSmaller,
6817 CleanState,
6818 DeltaExpression,
6819 }
6820 impl<'de> serde::Deserialize<'de> for GeneratedField {
6821 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6822 where
6823 D: serde::Deserializer<'de>,
6824 {
6825 struct GeneratedVisitor;
6826
6827 impl serde::de::Visitor<'_> for GeneratedVisitor {
6828 type Value = GeneratedField;
6829
6830 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6831 write!(formatter, "expected one of: {:?}", &FIELDS)
6832 }
6833
6834 #[allow(unused_variables)]
6835 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6836 where
6837 E: serde::de::Error,
6838 {
6839 match value {
6840 "keyRequiredLarger" | "key_required_larger" => Ok(GeneratedField::KeyRequiredLarger),
6841 "keyRequiredSmaller" | "key_required_smaller" => Ok(GeneratedField::KeyRequiredSmaller),
6842 "cleanState" | "clean_state" => Ok(GeneratedField::CleanState),
6843 "deltaExpression" | "delta_expression" => Ok(GeneratedField::DeltaExpression),
6844 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6845 }
6846 }
6847 }
6848 deserializer.deserialize_identifier(GeneratedVisitor)
6849 }
6850 }
6851 struct GeneratedVisitor;
6852 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6853 type Value = InequalityPair;
6854
6855 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6856 formatter.write_str("struct stream_plan.InequalityPair")
6857 }
6858
6859 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPair, V::Error>
6860 where
6861 V: serde::de::MapAccess<'de>,
6862 {
6863 let mut key_required_larger__ = None;
6864 let mut key_required_smaller__ = None;
6865 let mut clean_state__ = None;
6866 let mut delta_expression__ = None;
6867 while let Some(k) = map_.next_key()? {
6868 match k {
6869 GeneratedField::KeyRequiredLarger => {
6870 if key_required_larger__.is_some() {
6871 return Err(serde::de::Error::duplicate_field("keyRequiredLarger"));
6872 }
6873 key_required_larger__ =
6874 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6875 ;
6876 }
6877 GeneratedField::KeyRequiredSmaller => {
6878 if key_required_smaller__.is_some() {
6879 return Err(serde::de::Error::duplicate_field("keyRequiredSmaller"));
6880 }
6881 key_required_smaller__ =
6882 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6883 ;
6884 }
6885 GeneratedField::CleanState => {
6886 if clean_state__.is_some() {
6887 return Err(serde::de::Error::duplicate_field("cleanState"));
6888 }
6889 clean_state__ = Some(map_.next_value()?);
6890 }
6891 GeneratedField::DeltaExpression => {
6892 if delta_expression__.is_some() {
6893 return Err(serde::de::Error::duplicate_field("deltaExpression"));
6894 }
6895 delta_expression__ = map_.next_value()?;
6896 }
6897 }
6898 }
6899 Ok(InequalityPair {
6900 key_required_larger: key_required_larger__.unwrap_or_default(),
6901 key_required_smaller: key_required_smaller__.unwrap_or_default(),
6902 clean_state: clean_state__.unwrap_or_default(),
6903 delta_expression: delta_expression__,
6904 })
6905 }
6906 }
6907 deserializer.deserialize_struct("stream_plan.InequalityPair", FIELDS, GeneratedVisitor)
6908 }
6909}
6910impl serde::Serialize for InequalityPairV2 {
6911 #[allow(deprecated)]
6912 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6913 where
6914 S: serde::Serializer,
6915 {
6916 use serde::ser::SerializeStruct;
6917 let mut len = 0;
6918 if self.left_idx != 0 {
6919 len += 1;
6920 }
6921 if self.right_idx != 0 {
6922 len += 1;
6923 }
6924 if self.clean_left_state {
6925 len += 1;
6926 }
6927 if self.clean_right_state {
6928 len += 1;
6929 }
6930 if self.op != 0 {
6931 len += 1;
6932 }
6933 let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPairV2", len)?;
6934 if self.left_idx != 0 {
6935 struct_ser.serialize_field("leftIdx", &self.left_idx)?;
6936 }
6937 if self.right_idx != 0 {
6938 struct_ser.serialize_field("rightIdx", &self.right_idx)?;
6939 }
6940 if self.clean_left_state {
6941 struct_ser.serialize_field("cleanLeftState", &self.clean_left_state)?;
6942 }
6943 if self.clean_right_state {
6944 struct_ser.serialize_field("cleanRightState", &self.clean_right_state)?;
6945 }
6946 if self.op != 0 {
6947 let v = InequalityType::try_from(self.op)
6948 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.op)))?;
6949 struct_ser.serialize_field("op", &v)?;
6950 }
6951 struct_ser.end()
6952 }
6953}
6954impl<'de> serde::Deserialize<'de> for InequalityPairV2 {
6955 #[allow(deprecated)]
6956 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6957 where
6958 D: serde::Deserializer<'de>,
6959 {
6960 const FIELDS: &[&str] = &[
6961 "left_idx",
6962 "leftIdx",
6963 "right_idx",
6964 "rightIdx",
6965 "clean_left_state",
6966 "cleanLeftState",
6967 "clean_right_state",
6968 "cleanRightState",
6969 "op",
6970 ];
6971
6972 #[allow(clippy::enum_variant_names)]
6973 enum GeneratedField {
6974 LeftIdx,
6975 RightIdx,
6976 CleanLeftState,
6977 CleanRightState,
6978 Op,
6979 }
6980 impl<'de> serde::Deserialize<'de> for GeneratedField {
6981 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6982 where
6983 D: serde::Deserializer<'de>,
6984 {
6985 struct GeneratedVisitor;
6986
6987 impl serde::de::Visitor<'_> for GeneratedVisitor {
6988 type Value = GeneratedField;
6989
6990 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6991 write!(formatter, "expected one of: {:?}", &FIELDS)
6992 }
6993
6994 #[allow(unused_variables)]
6995 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6996 where
6997 E: serde::de::Error,
6998 {
6999 match value {
7000 "leftIdx" | "left_idx" => Ok(GeneratedField::LeftIdx),
7001 "rightIdx" | "right_idx" => Ok(GeneratedField::RightIdx),
7002 "cleanLeftState" | "clean_left_state" => Ok(GeneratedField::CleanLeftState),
7003 "cleanRightState" | "clean_right_state" => Ok(GeneratedField::CleanRightState),
7004 "op" => Ok(GeneratedField::Op),
7005 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7006 }
7007 }
7008 }
7009 deserializer.deserialize_identifier(GeneratedVisitor)
7010 }
7011 }
7012 struct GeneratedVisitor;
7013 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7014 type Value = InequalityPairV2;
7015
7016 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7017 formatter.write_str("struct stream_plan.InequalityPairV2")
7018 }
7019
7020 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPairV2, V::Error>
7021 where
7022 V: serde::de::MapAccess<'de>,
7023 {
7024 let mut left_idx__ = None;
7025 let mut right_idx__ = None;
7026 let mut clean_left_state__ = None;
7027 let mut clean_right_state__ = None;
7028 let mut op__ = None;
7029 while let Some(k) = map_.next_key()? {
7030 match k {
7031 GeneratedField::LeftIdx => {
7032 if left_idx__.is_some() {
7033 return Err(serde::de::Error::duplicate_field("leftIdx"));
7034 }
7035 left_idx__ =
7036 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7037 ;
7038 }
7039 GeneratedField::RightIdx => {
7040 if right_idx__.is_some() {
7041 return Err(serde::de::Error::duplicate_field("rightIdx"));
7042 }
7043 right_idx__ =
7044 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7045 ;
7046 }
7047 GeneratedField::CleanLeftState => {
7048 if clean_left_state__.is_some() {
7049 return Err(serde::de::Error::duplicate_field("cleanLeftState"));
7050 }
7051 clean_left_state__ = Some(map_.next_value()?);
7052 }
7053 GeneratedField::CleanRightState => {
7054 if clean_right_state__.is_some() {
7055 return Err(serde::de::Error::duplicate_field("cleanRightState"));
7056 }
7057 clean_right_state__ = Some(map_.next_value()?);
7058 }
7059 GeneratedField::Op => {
7060 if op__.is_some() {
7061 return Err(serde::de::Error::duplicate_field("op"));
7062 }
7063 op__ = Some(map_.next_value::<InequalityType>()? as i32);
7064 }
7065 }
7066 }
7067 Ok(InequalityPairV2 {
7068 left_idx: left_idx__.unwrap_or_default(),
7069 right_idx: right_idx__.unwrap_or_default(),
7070 clean_left_state: clean_left_state__.unwrap_or_default(),
7071 clean_right_state: clean_right_state__.unwrap_or_default(),
7072 op: op__.unwrap_or_default(),
7073 })
7074 }
7075 }
7076 deserializer.deserialize_struct("stream_plan.InequalityPairV2", FIELDS, GeneratedVisitor)
7077 }
7078}
7079impl serde::Serialize for InequalityType {
7080 #[allow(deprecated)]
7081 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7082 where
7083 S: serde::Serializer,
7084 {
7085 let variant = match self {
7086 Self::Unspecified => "INEQUALITY_TYPE_UNSPECIFIED",
7087 Self::LessThan => "INEQUALITY_TYPE_LESS_THAN",
7088 Self::LessThanOrEqual => "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL",
7089 Self::GreaterThan => "INEQUALITY_TYPE_GREATER_THAN",
7090 Self::GreaterThanOrEqual => "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL",
7091 };
7092 serializer.serialize_str(variant)
7093 }
7094}
7095impl<'de> serde::Deserialize<'de> for InequalityType {
7096 #[allow(deprecated)]
7097 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7098 where
7099 D: serde::Deserializer<'de>,
7100 {
7101 const FIELDS: &[&str] = &[
7102 "INEQUALITY_TYPE_UNSPECIFIED",
7103 "INEQUALITY_TYPE_LESS_THAN",
7104 "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL",
7105 "INEQUALITY_TYPE_GREATER_THAN",
7106 "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL",
7107 ];
7108
7109 struct GeneratedVisitor;
7110
7111 impl serde::de::Visitor<'_> for GeneratedVisitor {
7112 type Value = InequalityType;
7113
7114 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7115 write!(formatter, "expected one of: {:?}", &FIELDS)
7116 }
7117
7118 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
7119 where
7120 E: serde::de::Error,
7121 {
7122 i32::try_from(v)
7123 .ok()
7124 .and_then(|x| x.try_into().ok())
7125 .ok_or_else(|| {
7126 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
7127 })
7128 }
7129
7130 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
7131 where
7132 E: serde::de::Error,
7133 {
7134 i32::try_from(v)
7135 .ok()
7136 .and_then(|x| x.try_into().ok())
7137 .ok_or_else(|| {
7138 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
7139 })
7140 }
7141
7142 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
7143 where
7144 E: serde::de::Error,
7145 {
7146 match value {
7147 "INEQUALITY_TYPE_UNSPECIFIED" => Ok(InequalityType::Unspecified),
7148 "INEQUALITY_TYPE_LESS_THAN" => Ok(InequalityType::LessThan),
7149 "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL" => Ok(InequalityType::LessThanOrEqual),
7150 "INEQUALITY_TYPE_GREATER_THAN" => Ok(InequalityType::GreaterThan),
7151 "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL" => Ok(InequalityType::GreaterThanOrEqual),
7152 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
7153 }
7154 }
7155 }
7156 deserializer.deserialize_any(GeneratedVisitor)
7157 }
7158}
7159impl serde::Serialize for InjectSourceOffsetsMutation {
7160 #[allow(deprecated)]
7161 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7162 where
7163 S: serde::Serializer,
7164 {
7165 use serde::ser::SerializeStruct;
7166 let mut len = 0;
7167 if self.source_id != 0 {
7168 len += 1;
7169 }
7170 if !self.split_offsets.is_empty() {
7171 len += 1;
7172 }
7173 let mut struct_ser = serializer.serialize_struct("stream_plan.InjectSourceOffsetsMutation", len)?;
7174 if self.source_id != 0 {
7175 struct_ser.serialize_field("sourceId", &self.source_id)?;
7176 }
7177 if !self.split_offsets.is_empty() {
7178 struct_ser.serialize_field("splitOffsets", &self.split_offsets)?;
7179 }
7180 struct_ser.end()
7181 }
7182}
7183impl<'de> serde::Deserialize<'de> for InjectSourceOffsetsMutation {
7184 #[allow(deprecated)]
7185 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7186 where
7187 D: serde::Deserializer<'de>,
7188 {
7189 const FIELDS: &[&str] = &[
7190 "source_id",
7191 "sourceId",
7192 "split_offsets",
7193 "splitOffsets",
7194 ];
7195
7196 #[allow(clippy::enum_variant_names)]
7197 enum GeneratedField {
7198 SourceId,
7199 SplitOffsets,
7200 }
7201 impl<'de> serde::Deserialize<'de> for GeneratedField {
7202 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7203 where
7204 D: serde::Deserializer<'de>,
7205 {
7206 struct GeneratedVisitor;
7207
7208 impl serde::de::Visitor<'_> for GeneratedVisitor {
7209 type Value = GeneratedField;
7210
7211 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7212 write!(formatter, "expected one of: {:?}", &FIELDS)
7213 }
7214
7215 #[allow(unused_variables)]
7216 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7217 where
7218 E: serde::de::Error,
7219 {
7220 match value {
7221 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
7222 "splitOffsets" | "split_offsets" => Ok(GeneratedField::SplitOffsets),
7223 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7224 }
7225 }
7226 }
7227 deserializer.deserialize_identifier(GeneratedVisitor)
7228 }
7229 }
7230 struct GeneratedVisitor;
7231 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7232 type Value = InjectSourceOffsetsMutation;
7233
7234 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7235 formatter.write_str("struct stream_plan.InjectSourceOffsetsMutation")
7236 }
7237
7238 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InjectSourceOffsetsMutation, V::Error>
7239 where
7240 V: serde::de::MapAccess<'de>,
7241 {
7242 let mut source_id__ = None;
7243 let mut split_offsets__ = None;
7244 while let Some(k) = map_.next_key()? {
7245 match k {
7246 GeneratedField::SourceId => {
7247 if source_id__.is_some() {
7248 return Err(serde::de::Error::duplicate_field("sourceId"));
7249 }
7250 source_id__ =
7251 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7252 ;
7253 }
7254 GeneratedField::SplitOffsets => {
7255 if split_offsets__.is_some() {
7256 return Err(serde::de::Error::duplicate_field("splitOffsets"));
7257 }
7258 split_offsets__ = Some(
7259 map_.next_value::<std::collections::HashMap<_, _>>()?
7260 );
7261 }
7262 }
7263 }
7264 Ok(InjectSourceOffsetsMutation {
7265 source_id: source_id__.unwrap_or_default(),
7266 split_offsets: split_offsets__.unwrap_or_default(),
7267 })
7268 }
7269 }
7270 deserializer.deserialize_struct("stream_plan.InjectSourceOffsetsMutation", FIELDS, GeneratedVisitor)
7271 }
7272}
7273impl serde::Serialize for JoinEncodingType {
7274 #[allow(deprecated)]
7275 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7276 where
7277 S: serde::Serializer,
7278 {
7279 let variant = match self {
7280 Self::Unspecified => "UNSPECIFIED",
7281 Self::MemoryOptimized => "MEMORY_OPTIMIZED",
7282 Self::CpuOptimized => "CPU_OPTIMIZED",
7283 };
7284 serializer.serialize_str(variant)
7285 }
7286}
7287impl<'de> serde::Deserialize<'de> for JoinEncodingType {
7288 #[allow(deprecated)]
7289 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7290 where
7291 D: serde::Deserializer<'de>,
7292 {
7293 const FIELDS: &[&str] = &[
7294 "UNSPECIFIED",
7295 "MEMORY_OPTIMIZED",
7296 "CPU_OPTIMIZED",
7297 ];
7298
7299 struct GeneratedVisitor;
7300
7301 impl serde::de::Visitor<'_> for GeneratedVisitor {
7302 type Value = JoinEncodingType;
7303
7304 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7305 write!(formatter, "expected one of: {:?}", &FIELDS)
7306 }
7307
7308 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
7309 where
7310 E: serde::de::Error,
7311 {
7312 i32::try_from(v)
7313 .ok()
7314 .and_then(|x| x.try_into().ok())
7315 .ok_or_else(|| {
7316 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
7317 })
7318 }
7319
7320 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
7321 where
7322 E: serde::de::Error,
7323 {
7324 i32::try_from(v)
7325 .ok()
7326 .and_then(|x| x.try_into().ok())
7327 .ok_or_else(|| {
7328 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
7329 })
7330 }
7331
7332 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
7333 where
7334 E: serde::de::Error,
7335 {
7336 match value {
7337 "UNSPECIFIED" => Ok(JoinEncodingType::Unspecified),
7338 "MEMORY_OPTIMIZED" => Ok(JoinEncodingType::MemoryOptimized),
7339 "CPU_OPTIMIZED" => Ok(JoinEncodingType::CpuOptimized),
7340 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
7341 }
7342 }
7343 }
7344 deserializer.deserialize_any(GeneratedVisitor)
7345 }
7346}
7347impl serde::Serialize for JoinKeyWatermarkIndex {
7348 #[allow(deprecated)]
7349 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7350 where
7351 S: serde::Serializer,
7352 {
7353 use serde::ser::SerializeStruct;
7354 let mut len = 0;
7355 if self.index != 0 {
7356 len += 1;
7357 }
7358 if self.do_state_cleaning {
7359 len += 1;
7360 }
7361 let mut struct_ser = serializer.serialize_struct("stream_plan.JoinKeyWatermarkIndex", len)?;
7362 if self.index != 0 {
7363 struct_ser.serialize_field("index", &self.index)?;
7364 }
7365 if self.do_state_cleaning {
7366 struct_ser.serialize_field("doStateCleaning", &self.do_state_cleaning)?;
7367 }
7368 struct_ser.end()
7369 }
7370}
7371impl<'de> serde::Deserialize<'de> for JoinKeyWatermarkIndex {
7372 #[allow(deprecated)]
7373 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7374 where
7375 D: serde::Deserializer<'de>,
7376 {
7377 const FIELDS: &[&str] = &[
7378 "index",
7379 "do_state_cleaning",
7380 "doStateCleaning",
7381 ];
7382
7383 #[allow(clippy::enum_variant_names)]
7384 enum GeneratedField {
7385 Index,
7386 DoStateCleaning,
7387 }
7388 impl<'de> serde::Deserialize<'de> for GeneratedField {
7389 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7390 where
7391 D: serde::Deserializer<'de>,
7392 {
7393 struct GeneratedVisitor;
7394
7395 impl serde::de::Visitor<'_> for GeneratedVisitor {
7396 type Value = GeneratedField;
7397
7398 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7399 write!(formatter, "expected one of: {:?}", &FIELDS)
7400 }
7401
7402 #[allow(unused_variables)]
7403 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7404 where
7405 E: serde::de::Error,
7406 {
7407 match value {
7408 "index" => Ok(GeneratedField::Index),
7409 "doStateCleaning" | "do_state_cleaning" => Ok(GeneratedField::DoStateCleaning),
7410 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7411 }
7412 }
7413 }
7414 deserializer.deserialize_identifier(GeneratedVisitor)
7415 }
7416 }
7417 struct GeneratedVisitor;
7418 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7419 type Value = JoinKeyWatermarkIndex;
7420
7421 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7422 formatter.write_str("struct stream_plan.JoinKeyWatermarkIndex")
7423 }
7424
7425 fn visit_map<V>(self, mut map_: V) -> std::result::Result<JoinKeyWatermarkIndex, V::Error>
7426 where
7427 V: serde::de::MapAccess<'de>,
7428 {
7429 let mut index__ = None;
7430 let mut do_state_cleaning__ = None;
7431 while let Some(k) = map_.next_key()? {
7432 match k {
7433 GeneratedField::Index => {
7434 if index__.is_some() {
7435 return Err(serde::de::Error::duplicate_field("index"));
7436 }
7437 index__ =
7438 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7439 ;
7440 }
7441 GeneratedField::DoStateCleaning => {
7442 if do_state_cleaning__.is_some() {
7443 return Err(serde::de::Error::duplicate_field("doStateCleaning"));
7444 }
7445 do_state_cleaning__ = Some(map_.next_value()?);
7446 }
7447 }
7448 }
7449 Ok(JoinKeyWatermarkIndex {
7450 index: index__.unwrap_or_default(),
7451 do_state_cleaning: do_state_cleaning__.unwrap_or_default(),
7452 })
7453 }
7454 }
7455 deserializer.deserialize_struct("stream_plan.JoinKeyWatermarkIndex", FIELDS, GeneratedVisitor)
7456 }
7457}
7458impl serde::Serialize for ListFinishMutation {
7459 #[allow(deprecated)]
7460 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7461 where
7462 S: serde::Serializer,
7463 {
7464 use serde::ser::SerializeStruct;
7465 let mut len = 0;
7466 if self.associated_source_id != 0 {
7467 len += 1;
7468 }
7469 let mut struct_ser = serializer.serialize_struct("stream_plan.ListFinishMutation", len)?;
7470 if self.associated_source_id != 0 {
7471 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
7472 }
7473 struct_ser.end()
7474 }
7475}
7476impl<'de> serde::Deserialize<'de> for ListFinishMutation {
7477 #[allow(deprecated)]
7478 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7479 where
7480 D: serde::Deserializer<'de>,
7481 {
7482 const FIELDS: &[&str] = &[
7483 "associated_source_id",
7484 "associatedSourceId",
7485 ];
7486
7487 #[allow(clippy::enum_variant_names)]
7488 enum GeneratedField {
7489 AssociatedSourceId,
7490 }
7491 impl<'de> serde::Deserialize<'de> for GeneratedField {
7492 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7493 where
7494 D: serde::Deserializer<'de>,
7495 {
7496 struct GeneratedVisitor;
7497
7498 impl serde::de::Visitor<'_> for GeneratedVisitor {
7499 type Value = GeneratedField;
7500
7501 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7502 write!(formatter, "expected one of: {:?}", &FIELDS)
7503 }
7504
7505 #[allow(unused_variables)]
7506 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7507 where
7508 E: serde::de::Error,
7509 {
7510 match value {
7511 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
7512 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7513 }
7514 }
7515 }
7516 deserializer.deserialize_identifier(GeneratedVisitor)
7517 }
7518 }
7519 struct GeneratedVisitor;
7520 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7521 type Value = ListFinishMutation;
7522
7523 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7524 formatter.write_str("struct stream_plan.ListFinishMutation")
7525 }
7526
7527 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFinishMutation, V::Error>
7528 where
7529 V: serde::de::MapAccess<'de>,
7530 {
7531 let mut associated_source_id__ = None;
7532 while let Some(k) = map_.next_key()? {
7533 match k {
7534 GeneratedField::AssociatedSourceId => {
7535 if associated_source_id__.is_some() {
7536 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
7537 }
7538 associated_source_id__ =
7539 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7540 ;
7541 }
7542 }
7543 }
7544 Ok(ListFinishMutation {
7545 associated_source_id: associated_source_id__.unwrap_or_default(),
7546 })
7547 }
7548 }
7549 deserializer.deserialize_struct("stream_plan.ListFinishMutation", FIELDS, GeneratedVisitor)
7550 }
7551}
7552impl serde::Serialize for LoadFinishMutation {
7553 #[allow(deprecated)]
7554 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7555 where
7556 S: serde::Serializer,
7557 {
7558 use serde::ser::SerializeStruct;
7559 let mut len = 0;
7560 if self.associated_source_id != 0 {
7561 len += 1;
7562 }
7563 let mut struct_ser = serializer.serialize_struct("stream_plan.LoadFinishMutation", len)?;
7564 if self.associated_source_id != 0 {
7565 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
7566 }
7567 struct_ser.end()
7568 }
7569}
7570impl<'de> serde::Deserialize<'de> for LoadFinishMutation {
7571 #[allow(deprecated)]
7572 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7573 where
7574 D: serde::Deserializer<'de>,
7575 {
7576 const FIELDS: &[&str] = &[
7577 "associated_source_id",
7578 "associatedSourceId",
7579 ];
7580
7581 #[allow(clippy::enum_variant_names)]
7582 enum GeneratedField {
7583 AssociatedSourceId,
7584 }
7585 impl<'de> serde::Deserialize<'de> for GeneratedField {
7586 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7587 where
7588 D: serde::Deserializer<'de>,
7589 {
7590 struct GeneratedVisitor;
7591
7592 impl serde::de::Visitor<'_> for GeneratedVisitor {
7593 type Value = GeneratedField;
7594
7595 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7596 write!(formatter, "expected one of: {:?}", &FIELDS)
7597 }
7598
7599 #[allow(unused_variables)]
7600 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7601 where
7602 E: serde::de::Error,
7603 {
7604 match value {
7605 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
7606 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7607 }
7608 }
7609 }
7610 deserializer.deserialize_identifier(GeneratedVisitor)
7611 }
7612 }
7613 struct GeneratedVisitor;
7614 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7615 type Value = LoadFinishMutation;
7616
7617 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7618 formatter.write_str("struct stream_plan.LoadFinishMutation")
7619 }
7620
7621 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LoadFinishMutation, V::Error>
7622 where
7623 V: serde::de::MapAccess<'de>,
7624 {
7625 let mut associated_source_id__ = None;
7626 while let Some(k) = map_.next_key()? {
7627 match k {
7628 GeneratedField::AssociatedSourceId => {
7629 if associated_source_id__.is_some() {
7630 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
7631 }
7632 associated_source_id__ =
7633 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7634 ;
7635 }
7636 }
7637 }
7638 Ok(LoadFinishMutation {
7639 associated_source_id: associated_source_id__.unwrap_or_default(),
7640 })
7641 }
7642 }
7643 deserializer.deserialize_struct("stream_plan.LoadFinishMutation", FIELDS, GeneratedVisitor)
7644 }
7645}
7646impl serde::Serialize for LocalApproxPercentileNode {
7647 #[allow(deprecated)]
7648 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7649 where
7650 S: serde::Serializer,
7651 {
7652 use serde::ser::SerializeStruct;
7653 let mut len = 0;
7654 if self.base != 0. {
7655 len += 1;
7656 }
7657 if self.percentile_index != 0 {
7658 len += 1;
7659 }
7660 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalApproxPercentileNode", len)?;
7661 if self.base != 0. {
7662 struct_ser.serialize_field("base", &self.base)?;
7663 }
7664 if self.percentile_index != 0 {
7665 struct_ser.serialize_field("percentileIndex", &self.percentile_index)?;
7666 }
7667 struct_ser.end()
7668 }
7669}
7670impl<'de> serde::Deserialize<'de> for LocalApproxPercentileNode {
7671 #[allow(deprecated)]
7672 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7673 where
7674 D: serde::Deserializer<'de>,
7675 {
7676 const FIELDS: &[&str] = &[
7677 "base",
7678 "percentile_index",
7679 "percentileIndex",
7680 ];
7681
7682 #[allow(clippy::enum_variant_names)]
7683 enum GeneratedField {
7684 Base,
7685 PercentileIndex,
7686 }
7687 impl<'de> serde::Deserialize<'de> for GeneratedField {
7688 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7689 where
7690 D: serde::Deserializer<'de>,
7691 {
7692 struct GeneratedVisitor;
7693
7694 impl serde::de::Visitor<'_> for GeneratedVisitor {
7695 type Value = GeneratedField;
7696
7697 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7698 write!(formatter, "expected one of: {:?}", &FIELDS)
7699 }
7700
7701 #[allow(unused_variables)]
7702 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7703 where
7704 E: serde::de::Error,
7705 {
7706 match value {
7707 "base" => Ok(GeneratedField::Base),
7708 "percentileIndex" | "percentile_index" => Ok(GeneratedField::PercentileIndex),
7709 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7710 }
7711 }
7712 }
7713 deserializer.deserialize_identifier(GeneratedVisitor)
7714 }
7715 }
7716 struct GeneratedVisitor;
7717 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7718 type Value = LocalApproxPercentileNode;
7719
7720 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7721 formatter.write_str("struct stream_plan.LocalApproxPercentileNode")
7722 }
7723
7724 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalApproxPercentileNode, V::Error>
7725 where
7726 V: serde::de::MapAccess<'de>,
7727 {
7728 let mut base__ = None;
7729 let mut percentile_index__ = None;
7730 while let Some(k) = map_.next_key()? {
7731 match k {
7732 GeneratedField::Base => {
7733 if base__.is_some() {
7734 return Err(serde::de::Error::duplicate_field("base"));
7735 }
7736 base__ =
7737 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7738 ;
7739 }
7740 GeneratedField::PercentileIndex => {
7741 if percentile_index__.is_some() {
7742 return Err(serde::de::Error::duplicate_field("percentileIndex"));
7743 }
7744 percentile_index__ =
7745 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7746 ;
7747 }
7748 }
7749 }
7750 Ok(LocalApproxPercentileNode {
7751 base: base__.unwrap_or_default(),
7752 percentile_index: percentile_index__.unwrap_or_default(),
7753 })
7754 }
7755 }
7756 deserializer.deserialize_struct("stream_plan.LocalApproxPercentileNode", FIELDS, GeneratedVisitor)
7757 }
7758}
7759impl serde::Serialize for LocalityProviderNode {
7760 #[allow(deprecated)]
7761 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7762 where
7763 S: serde::Serializer,
7764 {
7765 use serde::ser::SerializeStruct;
7766 let mut len = 0;
7767 if !self.locality_columns.is_empty() {
7768 len += 1;
7769 }
7770 if self.state_table.is_some() {
7771 len += 1;
7772 }
7773 if self.progress_table.is_some() {
7774 len += 1;
7775 }
7776 let mut struct_ser = serializer.serialize_struct("stream_plan.LocalityProviderNode", len)?;
7777 if !self.locality_columns.is_empty() {
7778 struct_ser.serialize_field("localityColumns", &self.locality_columns)?;
7779 }
7780 if let Some(v) = self.state_table.as_ref() {
7781 struct_ser.serialize_field("stateTable", v)?;
7782 }
7783 if let Some(v) = self.progress_table.as_ref() {
7784 struct_ser.serialize_field("progressTable", v)?;
7785 }
7786 struct_ser.end()
7787 }
7788}
7789impl<'de> serde::Deserialize<'de> for LocalityProviderNode {
7790 #[allow(deprecated)]
7791 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7792 where
7793 D: serde::Deserializer<'de>,
7794 {
7795 const FIELDS: &[&str] = &[
7796 "locality_columns",
7797 "localityColumns",
7798 "state_table",
7799 "stateTable",
7800 "progress_table",
7801 "progressTable",
7802 ];
7803
7804 #[allow(clippy::enum_variant_names)]
7805 enum GeneratedField {
7806 LocalityColumns,
7807 StateTable,
7808 ProgressTable,
7809 }
7810 impl<'de> serde::Deserialize<'de> for GeneratedField {
7811 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7812 where
7813 D: serde::Deserializer<'de>,
7814 {
7815 struct GeneratedVisitor;
7816
7817 impl serde::de::Visitor<'_> for GeneratedVisitor {
7818 type Value = GeneratedField;
7819
7820 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7821 write!(formatter, "expected one of: {:?}", &FIELDS)
7822 }
7823
7824 #[allow(unused_variables)]
7825 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7826 where
7827 E: serde::de::Error,
7828 {
7829 match value {
7830 "localityColumns" | "locality_columns" => Ok(GeneratedField::LocalityColumns),
7831 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7832 "progressTable" | "progress_table" => Ok(GeneratedField::ProgressTable),
7833 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7834 }
7835 }
7836 }
7837 deserializer.deserialize_identifier(GeneratedVisitor)
7838 }
7839 }
7840 struct GeneratedVisitor;
7841 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7842 type Value = LocalityProviderNode;
7843
7844 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7845 formatter.write_str("struct stream_plan.LocalityProviderNode")
7846 }
7847
7848 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalityProviderNode, V::Error>
7849 where
7850 V: serde::de::MapAccess<'de>,
7851 {
7852 let mut locality_columns__ = None;
7853 let mut state_table__ = None;
7854 let mut progress_table__ = None;
7855 while let Some(k) = map_.next_key()? {
7856 match k {
7857 GeneratedField::LocalityColumns => {
7858 if locality_columns__.is_some() {
7859 return Err(serde::de::Error::duplicate_field("localityColumns"));
7860 }
7861 locality_columns__ =
7862 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7863 .into_iter().map(|x| x.0).collect())
7864 ;
7865 }
7866 GeneratedField::StateTable => {
7867 if state_table__.is_some() {
7868 return Err(serde::de::Error::duplicate_field("stateTable"));
7869 }
7870 state_table__ = map_.next_value()?;
7871 }
7872 GeneratedField::ProgressTable => {
7873 if progress_table__.is_some() {
7874 return Err(serde::de::Error::duplicate_field("progressTable"));
7875 }
7876 progress_table__ = map_.next_value()?;
7877 }
7878 }
7879 }
7880 Ok(LocalityProviderNode {
7881 locality_columns: locality_columns__.unwrap_or_default(),
7882 state_table: state_table__,
7883 progress_table: progress_table__,
7884 })
7885 }
7886 }
7887 deserializer.deserialize_struct("stream_plan.LocalityProviderNode", FIELDS, GeneratedVisitor)
7888 }
7889}
7890impl serde::Serialize for LookupNode {
7891 #[allow(deprecated)]
7892 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7893 where
7894 S: serde::Serializer,
7895 {
7896 use serde::ser::SerializeStruct;
7897 let mut len = 0;
7898 if !self.arrange_key.is_empty() {
7899 len += 1;
7900 }
7901 if !self.stream_key.is_empty() {
7902 len += 1;
7903 }
7904 if self.use_current_epoch {
7905 len += 1;
7906 }
7907 if !self.column_mapping.is_empty() {
7908 len += 1;
7909 }
7910 if self.arrangement_table_info.is_some() {
7911 len += 1;
7912 }
7913 if self.arrangement_table_id.is_some() {
7914 len += 1;
7915 }
7916 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupNode", len)?;
7917 if !self.arrange_key.is_empty() {
7918 struct_ser.serialize_field("arrangeKey", &self.arrange_key)?;
7919 }
7920 if !self.stream_key.is_empty() {
7921 struct_ser.serialize_field("streamKey", &self.stream_key)?;
7922 }
7923 if self.use_current_epoch {
7924 struct_ser.serialize_field("useCurrentEpoch", &self.use_current_epoch)?;
7925 }
7926 if !self.column_mapping.is_empty() {
7927 struct_ser.serialize_field("columnMapping", &self.column_mapping)?;
7928 }
7929 if let Some(v) = self.arrangement_table_info.as_ref() {
7930 struct_ser.serialize_field("arrangementTableInfo", v)?;
7931 }
7932 if let Some(v) = self.arrangement_table_id.as_ref() {
7933 match v {
7934 lookup_node::ArrangementTableId::TableId(v) => {
7935 struct_ser.serialize_field("tableId", v)?;
7936 }
7937 lookup_node::ArrangementTableId::IndexId(v) => {
7938 struct_ser.serialize_field("indexId", v)?;
7939 }
7940 }
7941 }
7942 struct_ser.end()
7943 }
7944}
7945impl<'de> serde::Deserialize<'de> for LookupNode {
7946 #[allow(deprecated)]
7947 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7948 where
7949 D: serde::Deserializer<'de>,
7950 {
7951 const FIELDS: &[&str] = &[
7952 "arrange_key",
7953 "arrangeKey",
7954 "stream_key",
7955 "streamKey",
7956 "use_current_epoch",
7957 "useCurrentEpoch",
7958 "column_mapping",
7959 "columnMapping",
7960 "arrangement_table_info",
7961 "arrangementTableInfo",
7962 "table_id",
7963 "tableId",
7964 "index_id",
7965 "indexId",
7966 ];
7967
7968 #[allow(clippy::enum_variant_names)]
7969 enum GeneratedField {
7970 ArrangeKey,
7971 StreamKey,
7972 UseCurrentEpoch,
7973 ColumnMapping,
7974 ArrangementTableInfo,
7975 TableId,
7976 IndexId,
7977 }
7978 impl<'de> serde::Deserialize<'de> for GeneratedField {
7979 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7980 where
7981 D: serde::Deserializer<'de>,
7982 {
7983 struct GeneratedVisitor;
7984
7985 impl serde::de::Visitor<'_> for GeneratedVisitor {
7986 type Value = GeneratedField;
7987
7988 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7989 write!(formatter, "expected one of: {:?}", &FIELDS)
7990 }
7991
7992 #[allow(unused_variables)]
7993 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7994 where
7995 E: serde::de::Error,
7996 {
7997 match value {
7998 "arrangeKey" | "arrange_key" => Ok(GeneratedField::ArrangeKey),
7999 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
8000 "useCurrentEpoch" | "use_current_epoch" => Ok(GeneratedField::UseCurrentEpoch),
8001 "columnMapping" | "column_mapping" => Ok(GeneratedField::ColumnMapping),
8002 "arrangementTableInfo" | "arrangement_table_info" => Ok(GeneratedField::ArrangementTableInfo),
8003 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8004 "indexId" | "index_id" => Ok(GeneratedField::IndexId),
8005 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8006 }
8007 }
8008 }
8009 deserializer.deserialize_identifier(GeneratedVisitor)
8010 }
8011 }
8012 struct GeneratedVisitor;
8013 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8014 type Value = LookupNode;
8015
8016 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8017 formatter.write_str("struct stream_plan.LookupNode")
8018 }
8019
8020 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupNode, V::Error>
8021 where
8022 V: serde::de::MapAccess<'de>,
8023 {
8024 let mut arrange_key__ = None;
8025 let mut stream_key__ = None;
8026 let mut use_current_epoch__ = None;
8027 let mut column_mapping__ = None;
8028 let mut arrangement_table_info__ = None;
8029 let mut arrangement_table_id__ = None;
8030 while let Some(k) = map_.next_key()? {
8031 match k {
8032 GeneratedField::ArrangeKey => {
8033 if arrange_key__.is_some() {
8034 return Err(serde::de::Error::duplicate_field("arrangeKey"));
8035 }
8036 arrange_key__ =
8037 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8038 .into_iter().map(|x| x.0).collect())
8039 ;
8040 }
8041 GeneratedField::StreamKey => {
8042 if stream_key__.is_some() {
8043 return Err(serde::de::Error::duplicate_field("streamKey"));
8044 }
8045 stream_key__ =
8046 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8047 .into_iter().map(|x| x.0).collect())
8048 ;
8049 }
8050 GeneratedField::UseCurrentEpoch => {
8051 if use_current_epoch__.is_some() {
8052 return Err(serde::de::Error::duplicate_field("useCurrentEpoch"));
8053 }
8054 use_current_epoch__ = Some(map_.next_value()?);
8055 }
8056 GeneratedField::ColumnMapping => {
8057 if column_mapping__.is_some() {
8058 return Err(serde::de::Error::duplicate_field("columnMapping"));
8059 }
8060 column_mapping__ =
8061 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8062 .into_iter().map(|x| x.0).collect())
8063 ;
8064 }
8065 GeneratedField::ArrangementTableInfo => {
8066 if arrangement_table_info__.is_some() {
8067 return Err(serde::de::Error::duplicate_field("arrangementTableInfo"));
8068 }
8069 arrangement_table_info__ = map_.next_value()?;
8070 }
8071 GeneratedField::TableId => {
8072 if arrangement_table_id__.is_some() {
8073 return Err(serde::de::Error::duplicate_field("tableId"));
8074 }
8075 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::TableId(x.0));
8076 }
8077 GeneratedField::IndexId => {
8078 if arrangement_table_id__.is_some() {
8079 return Err(serde::de::Error::duplicate_field("indexId"));
8080 }
8081 arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::IndexId(x.0));
8082 }
8083 }
8084 }
8085 Ok(LookupNode {
8086 arrange_key: arrange_key__.unwrap_or_default(),
8087 stream_key: stream_key__.unwrap_or_default(),
8088 use_current_epoch: use_current_epoch__.unwrap_or_default(),
8089 column_mapping: column_mapping__.unwrap_or_default(),
8090 arrangement_table_info: arrangement_table_info__,
8091 arrangement_table_id: arrangement_table_id__,
8092 })
8093 }
8094 }
8095 deserializer.deserialize_struct("stream_plan.LookupNode", FIELDS, GeneratedVisitor)
8096 }
8097}
8098impl serde::Serialize for LookupUnionNode {
8099 #[allow(deprecated)]
8100 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8101 where
8102 S: serde::Serializer,
8103 {
8104 use serde::ser::SerializeStruct;
8105 let mut len = 0;
8106 if !self.order.is_empty() {
8107 len += 1;
8108 }
8109 let mut struct_ser = serializer.serialize_struct("stream_plan.LookupUnionNode", len)?;
8110 if !self.order.is_empty() {
8111 struct_ser.serialize_field("order", &self.order)?;
8112 }
8113 struct_ser.end()
8114 }
8115}
8116impl<'de> serde::Deserialize<'de> for LookupUnionNode {
8117 #[allow(deprecated)]
8118 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8119 where
8120 D: serde::Deserializer<'de>,
8121 {
8122 const FIELDS: &[&str] = &[
8123 "order",
8124 ];
8125
8126 #[allow(clippy::enum_variant_names)]
8127 enum GeneratedField {
8128 Order,
8129 }
8130 impl<'de> serde::Deserialize<'de> for GeneratedField {
8131 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8132 where
8133 D: serde::Deserializer<'de>,
8134 {
8135 struct GeneratedVisitor;
8136
8137 impl serde::de::Visitor<'_> for GeneratedVisitor {
8138 type Value = GeneratedField;
8139
8140 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8141 write!(formatter, "expected one of: {:?}", &FIELDS)
8142 }
8143
8144 #[allow(unused_variables)]
8145 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8146 where
8147 E: serde::de::Error,
8148 {
8149 match value {
8150 "order" => Ok(GeneratedField::Order),
8151 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8152 }
8153 }
8154 }
8155 deserializer.deserialize_identifier(GeneratedVisitor)
8156 }
8157 }
8158 struct GeneratedVisitor;
8159 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8160 type Value = LookupUnionNode;
8161
8162 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8163 formatter.write_str("struct stream_plan.LookupUnionNode")
8164 }
8165
8166 fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupUnionNode, V::Error>
8167 where
8168 V: serde::de::MapAccess<'de>,
8169 {
8170 let mut order__ = None;
8171 while let Some(k) = map_.next_key()? {
8172 match k {
8173 GeneratedField::Order => {
8174 if order__.is_some() {
8175 return Err(serde::de::Error::duplicate_field("order"));
8176 }
8177 order__ =
8178 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8179 .into_iter().map(|x| x.0).collect())
8180 ;
8181 }
8182 }
8183 }
8184 Ok(LookupUnionNode {
8185 order: order__.unwrap_or_default(),
8186 })
8187 }
8188 }
8189 deserializer.deserialize_struct("stream_plan.LookupUnionNode", FIELDS, GeneratedVisitor)
8190 }
8191}
8192impl serde::Serialize for MaterializeNode {
8193 #[allow(deprecated)]
8194 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8195 where
8196 S: serde::Serializer,
8197 {
8198 use serde::ser::SerializeStruct;
8199 let mut len = 0;
8200 if self.table_id != 0 {
8201 len += 1;
8202 }
8203 if !self.column_orders.is_empty() {
8204 len += 1;
8205 }
8206 if self.table.is_some() {
8207 len += 1;
8208 }
8209 if self.staging_table.is_some() {
8210 len += 1;
8211 }
8212 if self.refresh_progress_table.is_some() {
8213 len += 1;
8214 }
8215 if self.cleaned_by_ttl_watermark {
8216 len += 1;
8217 }
8218 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializeNode", len)?;
8219 if self.table_id != 0 {
8220 struct_ser.serialize_field("tableId", &self.table_id)?;
8221 }
8222 if !self.column_orders.is_empty() {
8223 struct_ser.serialize_field("columnOrders", &self.column_orders)?;
8224 }
8225 if let Some(v) = self.table.as_ref() {
8226 struct_ser.serialize_field("table", v)?;
8227 }
8228 if let Some(v) = self.staging_table.as_ref() {
8229 struct_ser.serialize_field("stagingTable", v)?;
8230 }
8231 if let Some(v) = self.refresh_progress_table.as_ref() {
8232 struct_ser.serialize_field("refreshProgressTable", v)?;
8233 }
8234 if self.cleaned_by_ttl_watermark {
8235 struct_ser.serialize_field("cleanedByTtlWatermark", &self.cleaned_by_ttl_watermark)?;
8236 }
8237 struct_ser.end()
8238 }
8239}
8240impl<'de> serde::Deserialize<'de> for MaterializeNode {
8241 #[allow(deprecated)]
8242 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8243 where
8244 D: serde::Deserializer<'de>,
8245 {
8246 const FIELDS: &[&str] = &[
8247 "table_id",
8248 "tableId",
8249 "column_orders",
8250 "columnOrders",
8251 "table",
8252 "staging_table",
8253 "stagingTable",
8254 "refresh_progress_table",
8255 "refreshProgressTable",
8256 "cleaned_by_ttl_watermark",
8257 "cleanedByTtlWatermark",
8258 ];
8259
8260 #[allow(clippy::enum_variant_names)]
8261 enum GeneratedField {
8262 TableId,
8263 ColumnOrders,
8264 Table,
8265 StagingTable,
8266 RefreshProgressTable,
8267 CleanedByTtlWatermark,
8268 }
8269 impl<'de> serde::Deserialize<'de> for GeneratedField {
8270 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8271 where
8272 D: serde::Deserializer<'de>,
8273 {
8274 struct GeneratedVisitor;
8275
8276 impl serde::de::Visitor<'_> for GeneratedVisitor {
8277 type Value = GeneratedField;
8278
8279 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8280 write!(formatter, "expected one of: {:?}", &FIELDS)
8281 }
8282
8283 #[allow(unused_variables)]
8284 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8285 where
8286 E: serde::de::Error,
8287 {
8288 match value {
8289 "tableId" | "table_id" => Ok(GeneratedField::TableId),
8290 "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
8291 "table" => Ok(GeneratedField::Table),
8292 "stagingTable" | "staging_table" => Ok(GeneratedField::StagingTable),
8293 "refreshProgressTable" | "refresh_progress_table" => Ok(GeneratedField::RefreshProgressTable),
8294 "cleanedByTtlWatermark" | "cleaned_by_ttl_watermark" => Ok(GeneratedField::CleanedByTtlWatermark),
8295 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8296 }
8297 }
8298 }
8299 deserializer.deserialize_identifier(GeneratedVisitor)
8300 }
8301 }
8302 struct GeneratedVisitor;
8303 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8304 type Value = MaterializeNode;
8305
8306 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8307 formatter.write_str("struct stream_plan.MaterializeNode")
8308 }
8309
8310 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializeNode, V::Error>
8311 where
8312 V: serde::de::MapAccess<'de>,
8313 {
8314 let mut table_id__ = None;
8315 let mut column_orders__ = None;
8316 let mut table__ = None;
8317 let mut staging_table__ = None;
8318 let mut refresh_progress_table__ = None;
8319 let mut cleaned_by_ttl_watermark__ = None;
8320 while let Some(k) = map_.next_key()? {
8321 match k {
8322 GeneratedField::TableId => {
8323 if table_id__.is_some() {
8324 return Err(serde::de::Error::duplicate_field("tableId"));
8325 }
8326 table_id__ =
8327 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8328 ;
8329 }
8330 GeneratedField::ColumnOrders => {
8331 if column_orders__.is_some() {
8332 return Err(serde::de::Error::duplicate_field("columnOrders"));
8333 }
8334 column_orders__ = Some(map_.next_value()?);
8335 }
8336 GeneratedField::Table => {
8337 if table__.is_some() {
8338 return Err(serde::de::Error::duplicate_field("table"));
8339 }
8340 table__ = map_.next_value()?;
8341 }
8342 GeneratedField::StagingTable => {
8343 if staging_table__.is_some() {
8344 return Err(serde::de::Error::duplicate_field("stagingTable"));
8345 }
8346 staging_table__ = map_.next_value()?;
8347 }
8348 GeneratedField::RefreshProgressTable => {
8349 if refresh_progress_table__.is_some() {
8350 return Err(serde::de::Error::duplicate_field("refreshProgressTable"));
8351 }
8352 refresh_progress_table__ = map_.next_value()?;
8353 }
8354 GeneratedField::CleanedByTtlWatermark => {
8355 if cleaned_by_ttl_watermark__.is_some() {
8356 return Err(serde::de::Error::duplicate_field("cleanedByTtlWatermark"));
8357 }
8358 cleaned_by_ttl_watermark__ = Some(map_.next_value()?);
8359 }
8360 }
8361 }
8362 Ok(MaterializeNode {
8363 table_id: table_id__.unwrap_or_default(),
8364 column_orders: column_orders__.unwrap_or_default(),
8365 table: table__,
8366 staging_table: staging_table__,
8367 refresh_progress_table: refresh_progress_table__,
8368 cleaned_by_ttl_watermark: cleaned_by_ttl_watermark__.unwrap_or_default(),
8369 })
8370 }
8371 }
8372 deserializer.deserialize_struct("stream_plan.MaterializeNode", FIELDS, GeneratedVisitor)
8373 }
8374}
8375impl serde::Serialize for MaterializedExprsNode {
8376 #[allow(deprecated)]
8377 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8378 where
8379 S: serde::Serializer,
8380 {
8381 use serde::ser::SerializeStruct;
8382 let mut len = 0;
8383 if !self.exprs.is_empty() {
8384 len += 1;
8385 }
8386 if self.state_table.is_some() {
8387 len += 1;
8388 }
8389 if self.state_clean_col_idx.is_some() {
8390 len += 1;
8391 }
8392 let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializedExprsNode", len)?;
8393 if !self.exprs.is_empty() {
8394 struct_ser.serialize_field("exprs", &self.exprs)?;
8395 }
8396 if let Some(v) = self.state_table.as_ref() {
8397 struct_ser.serialize_field("stateTable", v)?;
8398 }
8399 if let Some(v) = self.state_clean_col_idx.as_ref() {
8400 struct_ser.serialize_field("stateCleanColIdx", v)?;
8401 }
8402 struct_ser.end()
8403 }
8404}
8405impl<'de> serde::Deserialize<'de> for MaterializedExprsNode {
8406 #[allow(deprecated)]
8407 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8408 where
8409 D: serde::Deserializer<'de>,
8410 {
8411 const FIELDS: &[&str] = &[
8412 "exprs",
8413 "state_table",
8414 "stateTable",
8415 "state_clean_col_idx",
8416 "stateCleanColIdx",
8417 ];
8418
8419 #[allow(clippy::enum_variant_names)]
8420 enum GeneratedField {
8421 Exprs,
8422 StateTable,
8423 StateCleanColIdx,
8424 }
8425 impl<'de> serde::Deserialize<'de> for GeneratedField {
8426 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8427 where
8428 D: serde::Deserializer<'de>,
8429 {
8430 struct GeneratedVisitor;
8431
8432 impl serde::de::Visitor<'_> for GeneratedVisitor {
8433 type Value = GeneratedField;
8434
8435 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8436 write!(formatter, "expected one of: {:?}", &FIELDS)
8437 }
8438
8439 #[allow(unused_variables)]
8440 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8441 where
8442 E: serde::de::Error,
8443 {
8444 match value {
8445 "exprs" => Ok(GeneratedField::Exprs),
8446 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
8447 "stateCleanColIdx" | "state_clean_col_idx" => Ok(GeneratedField::StateCleanColIdx),
8448 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8449 }
8450 }
8451 }
8452 deserializer.deserialize_identifier(GeneratedVisitor)
8453 }
8454 }
8455 struct GeneratedVisitor;
8456 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8457 type Value = MaterializedExprsNode;
8458
8459 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8460 formatter.write_str("struct stream_plan.MaterializedExprsNode")
8461 }
8462
8463 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializedExprsNode, V::Error>
8464 where
8465 V: serde::de::MapAccess<'de>,
8466 {
8467 let mut exprs__ = None;
8468 let mut state_table__ = None;
8469 let mut state_clean_col_idx__ = None;
8470 while let Some(k) = map_.next_key()? {
8471 match k {
8472 GeneratedField::Exprs => {
8473 if exprs__.is_some() {
8474 return Err(serde::de::Error::duplicate_field("exprs"));
8475 }
8476 exprs__ = Some(map_.next_value()?);
8477 }
8478 GeneratedField::StateTable => {
8479 if state_table__.is_some() {
8480 return Err(serde::de::Error::duplicate_field("stateTable"));
8481 }
8482 state_table__ = map_.next_value()?;
8483 }
8484 GeneratedField::StateCleanColIdx => {
8485 if state_clean_col_idx__.is_some() {
8486 return Err(serde::de::Error::duplicate_field("stateCleanColIdx"));
8487 }
8488 state_clean_col_idx__ =
8489 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
8490 ;
8491 }
8492 }
8493 }
8494 Ok(MaterializedExprsNode {
8495 exprs: exprs__.unwrap_or_default(),
8496 state_table: state_table__,
8497 state_clean_col_idx: state_clean_col_idx__,
8498 })
8499 }
8500 }
8501 deserializer.deserialize_struct("stream_plan.MaterializedExprsNode", FIELDS, GeneratedVisitor)
8502 }
8503}
8504impl serde::Serialize for MergeNode {
8505 #[allow(deprecated)]
8506 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8507 where
8508 S: serde::Serializer,
8509 {
8510 use serde::ser::SerializeStruct;
8511 let mut len = 0;
8512 if !self.upstream_actor_id.is_empty() {
8513 len += 1;
8514 }
8515 if self.upstream_fragment_id != 0 {
8516 len += 1;
8517 }
8518 if self.upstream_dispatcher_type != 0 {
8519 len += 1;
8520 }
8521 if !self.fields.is_empty() {
8522 len += 1;
8523 }
8524 let mut struct_ser = serializer.serialize_struct("stream_plan.MergeNode", len)?;
8525 if !self.upstream_actor_id.is_empty() {
8526 struct_ser.serialize_field("upstreamActorId", &self.upstream_actor_id)?;
8527 }
8528 if self.upstream_fragment_id != 0 {
8529 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
8530 }
8531 if self.upstream_dispatcher_type != 0 {
8532 let v = DispatcherType::try_from(self.upstream_dispatcher_type)
8533 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.upstream_dispatcher_type)))?;
8534 struct_ser.serialize_field("upstreamDispatcherType", &v)?;
8535 }
8536 if !self.fields.is_empty() {
8537 struct_ser.serialize_field("fields", &self.fields)?;
8538 }
8539 struct_ser.end()
8540 }
8541}
8542impl<'de> serde::Deserialize<'de> for MergeNode {
8543 #[allow(deprecated)]
8544 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8545 where
8546 D: serde::Deserializer<'de>,
8547 {
8548 const FIELDS: &[&str] = &[
8549 "upstream_actor_id",
8550 "upstreamActorId",
8551 "upstream_fragment_id",
8552 "upstreamFragmentId",
8553 "upstream_dispatcher_type",
8554 "upstreamDispatcherType",
8555 "fields",
8556 ];
8557
8558 #[allow(clippy::enum_variant_names)]
8559 enum GeneratedField {
8560 UpstreamActorId,
8561 UpstreamFragmentId,
8562 UpstreamDispatcherType,
8563 Fields,
8564 }
8565 impl<'de> serde::Deserialize<'de> for GeneratedField {
8566 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8567 where
8568 D: serde::Deserializer<'de>,
8569 {
8570 struct GeneratedVisitor;
8571
8572 impl serde::de::Visitor<'_> for GeneratedVisitor {
8573 type Value = GeneratedField;
8574
8575 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8576 write!(formatter, "expected one of: {:?}", &FIELDS)
8577 }
8578
8579 #[allow(unused_variables)]
8580 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8581 where
8582 E: serde::de::Error,
8583 {
8584 match value {
8585 "upstreamActorId" | "upstream_actor_id" => Ok(GeneratedField::UpstreamActorId),
8586 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
8587 "upstreamDispatcherType" | "upstream_dispatcher_type" => Ok(GeneratedField::UpstreamDispatcherType),
8588 "fields" => Ok(GeneratedField::Fields),
8589 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8590 }
8591 }
8592 }
8593 deserializer.deserialize_identifier(GeneratedVisitor)
8594 }
8595 }
8596 struct GeneratedVisitor;
8597 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8598 type Value = MergeNode;
8599
8600 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8601 formatter.write_str("struct stream_plan.MergeNode")
8602 }
8603
8604 fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeNode, V::Error>
8605 where
8606 V: serde::de::MapAccess<'de>,
8607 {
8608 let mut upstream_actor_id__ = None;
8609 let mut upstream_fragment_id__ = None;
8610 let mut upstream_dispatcher_type__ = None;
8611 let mut fields__ = None;
8612 while let Some(k) = map_.next_key()? {
8613 match k {
8614 GeneratedField::UpstreamActorId => {
8615 if upstream_actor_id__.is_some() {
8616 return Err(serde::de::Error::duplicate_field("upstreamActorId"));
8617 }
8618 upstream_actor_id__ =
8619 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8620 .into_iter().map(|x| x.0).collect())
8621 ;
8622 }
8623 GeneratedField::UpstreamFragmentId => {
8624 if upstream_fragment_id__.is_some() {
8625 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
8626 }
8627 upstream_fragment_id__ =
8628 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8629 ;
8630 }
8631 GeneratedField::UpstreamDispatcherType => {
8632 if upstream_dispatcher_type__.is_some() {
8633 return Err(serde::de::Error::duplicate_field("upstreamDispatcherType"));
8634 }
8635 upstream_dispatcher_type__ = Some(map_.next_value::<DispatcherType>()? as i32);
8636 }
8637 GeneratedField::Fields => {
8638 if fields__.is_some() {
8639 return Err(serde::de::Error::duplicate_field("fields"));
8640 }
8641 fields__ = Some(map_.next_value()?);
8642 }
8643 }
8644 }
8645 Ok(MergeNode {
8646 upstream_actor_id: upstream_actor_id__.unwrap_or_default(),
8647 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
8648 upstream_dispatcher_type: upstream_dispatcher_type__.unwrap_or_default(),
8649 fields: fields__.unwrap_or_default(),
8650 })
8651 }
8652 }
8653 deserializer.deserialize_struct("stream_plan.MergeNode", FIELDS, GeneratedVisitor)
8654 }
8655}
8656impl serde::Serialize for NoOpNode {
8657 #[allow(deprecated)]
8658 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8659 where
8660 S: serde::Serializer,
8661 {
8662 use serde::ser::SerializeStruct;
8663 let len = 0;
8664 let struct_ser = serializer.serialize_struct("stream_plan.NoOpNode", len)?;
8665 struct_ser.end()
8666 }
8667}
8668impl<'de> serde::Deserialize<'de> for NoOpNode {
8669 #[allow(deprecated)]
8670 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8671 where
8672 D: serde::Deserializer<'de>,
8673 {
8674 const FIELDS: &[&str] = &[
8675 ];
8676
8677 #[allow(clippy::enum_variant_names)]
8678 enum GeneratedField {
8679 }
8680 impl<'de> serde::Deserialize<'de> for GeneratedField {
8681 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8682 where
8683 D: serde::Deserializer<'de>,
8684 {
8685 struct GeneratedVisitor;
8686
8687 impl serde::de::Visitor<'_> for GeneratedVisitor {
8688 type Value = GeneratedField;
8689
8690 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8691 write!(formatter, "expected one of: {:?}", &FIELDS)
8692 }
8693
8694 #[allow(unused_variables)]
8695 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8696 where
8697 E: serde::de::Error,
8698 {
8699 Err(serde::de::Error::unknown_field(value, FIELDS))
8700 }
8701 }
8702 deserializer.deserialize_identifier(GeneratedVisitor)
8703 }
8704 }
8705 struct GeneratedVisitor;
8706 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8707 type Value = NoOpNode;
8708
8709 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8710 formatter.write_str("struct stream_plan.NoOpNode")
8711 }
8712
8713 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NoOpNode, V::Error>
8714 where
8715 V: serde::de::MapAccess<'de>,
8716 {
8717 while map_.next_key::<GeneratedField>()?.is_some() {
8718 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8719 }
8720 Ok(NoOpNode {
8721 })
8722 }
8723 }
8724 deserializer.deserialize_struct("stream_plan.NoOpNode", FIELDS, GeneratedVisitor)
8725 }
8726}
8727impl serde::Serialize for NowModeGenerateSeries {
8728 #[allow(deprecated)]
8729 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8730 where
8731 S: serde::Serializer,
8732 {
8733 use serde::ser::SerializeStruct;
8734 let mut len = 0;
8735 if self.start_timestamp.is_some() {
8736 len += 1;
8737 }
8738 if self.interval.is_some() {
8739 len += 1;
8740 }
8741 let mut struct_ser = serializer.serialize_struct("stream_plan.NowModeGenerateSeries", len)?;
8742 if let Some(v) = self.start_timestamp.as_ref() {
8743 struct_ser.serialize_field("startTimestamp", v)?;
8744 }
8745 if let Some(v) = self.interval.as_ref() {
8746 struct_ser.serialize_field("interval", v)?;
8747 }
8748 struct_ser.end()
8749 }
8750}
8751impl<'de> serde::Deserialize<'de> for NowModeGenerateSeries {
8752 #[allow(deprecated)]
8753 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8754 where
8755 D: serde::Deserializer<'de>,
8756 {
8757 const FIELDS: &[&str] = &[
8758 "start_timestamp",
8759 "startTimestamp",
8760 "interval",
8761 ];
8762
8763 #[allow(clippy::enum_variant_names)]
8764 enum GeneratedField {
8765 StartTimestamp,
8766 Interval,
8767 }
8768 impl<'de> serde::Deserialize<'de> for GeneratedField {
8769 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8770 where
8771 D: serde::Deserializer<'de>,
8772 {
8773 struct GeneratedVisitor;
8774
8775 impl serde::de::Visitor<'_> for GeneratedVisitor {
8776 type Value = GeneratedField;
8777
8778 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8779 write!(formatter, "expected one of: {:?}", &FIELDS)
8780 }
8781
8782 #[allow(unused_variables)]
8783 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8784 where
8785 E: serde::de::Error,
8786 {
8787 match value {
8788 "startTimestamp" | "start_timestamp" => Ok(GeneratedField::StartTimestamp),
8789 "interval" => Ok(GeneratedField::Interval),
8790 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8791 }
8792 }
8793 }
8794 deserializer.deserialize_identifier(GeneratedVisitor)
8795 }
8796 }
8797 struct GeneratedVisitor;
8798 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8799 type Value = NowModeGenerateSeries;
8800
8801 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8802 formatter.write_str("struct stream_plan.NowModeGenerateSeries")
8803 }
8804
8805 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeGenerateSeries, V::Error>
8806 where
8807 V: serde::de::MapAccess<'de>,
8808 {
8809 let mut start_timestamp__ = None;
8810 let mut interval__ = None;
8811 while let Some(k) = map_.next_key()? {
8812 match k {
8813 GeneratedField::StartTimestamp => {
8814 if start_timestamp__.is_some() {
8815 return Err(serde::de::Error::duplicate_field("startTimestamp"));
8816 }
8817 start_timestamp__ = map_.next_value()?;
8818 }
8819 GeneratedField::Interval => {
8820 if interval__.is_some() {
8821 return Err(serde::de::Error::duplicate_field("interval"));
8822 }
8823 interval__ = map_.next_value()?;
8824 }
8825 }
8826 }
8827 Ok(NowModeGenerateSeries {
8828 start_timestamp: start_timestamp__,
8829 interval: interval__,
8830 })
8831 }
8832 }
8833 deserializer.deserialize_struct("stream_plan.NowModeGenerateSeries", FIELDS, GeneratedVisitor)
8834 }
8835}
8836impl serde::Serialize for NowModeUpdateCurrent {
8837 #[allow(deprecated)]
8838 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8839 where
8840 S: serde::Serializer,
8841 {
8842 use serde::ser::SerializeStruct;
8843 let len = 0;
8844 let struct_ser = serializer.serialize_struct("stream_plan.NowModeUpdateCurrent", len)?;
8845 struct_ser.end()
8846 }
8847}
8848impl<'de> serde::Deserialize<'de> for NowModeUpdateCurrent {
8849 #[allow(deprecated)]
8850 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8851 where
8852 D: serde::Deserializer<'de>,
8853 {
8854 const FIELDS: &[&str] = &[
8855 ];
8856
8857 #[allow(clippy::enum_variant_names)]
8858 enum GeneratedField {
8859 }
8860 impl<'de> serde::Deserialize<'de> for GeneratedField {
8861 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8862 where
8863 D: serde::Deserializer<'de>,
8864 {
8865 struct GeneratedVisitor;
8866
8867 impl serde::de::Visitor<'_> for GeneratedVisitor {
8868 type Value = GeneratedField;
8869
8870 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8871 write!(formatter, "expected one of: {:?}", &FIELDS)
8872 }
8873
8874 #[allow(unused_variables)]
8875 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8876 where
8877 E: serde::de::Error,
8878 {
8879 Err(serde::de::Error::unknown_field(value, FIELDS))
8880 }
8881 }
8882 deserializer.deserialize_identifier(GeneratedVisitor)
8883 }
8884 }
8885 struct GeneratedVisitor;
8886 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8887 type Value = NowModeUpdateCurrent;
8888
8889 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8890 formatter.write_str("struct stream_plan.NowModeUpdateCurrent")
8891 }
8892
8893 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeUpdateCurrent, V::Error>
8894 where
8895 V: serde::de::MapAccess<'de>,
8896 {
8897 while map_.next_key::<GeneratedField>()?.is_some() {
8898 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8899 }
8900 Ok(NowModeUpdateCurrent {
8901 })
8902 }
8903 }
8904 deserializer.deserialize_struct("stream_plan.NowModeUpdateCurrent", FIELDS, GeneratedVisitor)
8905 }
8906}
8907impl serde::Serialize for NowNode {
8908 #[allow(deprecated)]
8909 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8910 where
8911 S: serde::Serializer,
8912 {
8913 use serde::ser::SerializeStruct;
8914 let mut len = 0;
8915 if self.state_table.is_some() {
8916 len += 1;
8917 }
8918 if self.mode.is_some() {
8919 len += 1;
8920 }
8921 let mut struct_ser = serializer.serialize_struct("stream_plan.NowNode", len)?;
8922 if let Some(v) = self.state_table.as_ref() {
8923 struct_ser.serialize_field("stateTable", v)?;
8924 }
8925 if let Some(v) = self.mode.as_ref() {
8926 match v {
8927 now_node::Mode::UpdateCurrent(v) => {
8928 struct_ser.serialize_field("updateCurrent", v)?;
8929 }
8930 now_node::Mode::GenerateSeries(v) => {
8931 struct_ser.serialize_field("generateSeries", v)?;
8932 }
8933 }
8934 }
8935 struct_ser.end()
8936 }
8937}
8938impl<'de> serde::Deserialize<'de> for NowNode {
8939 #[allow(deprecated)]
8940 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8941 where
8942 D: serde::Deserializer<'de>,
8943 {
8944 const FIELDS: &[&str] = &[
8945 "state_table",
8946 "stateTable",
8947 "update_current",
8948 "updateCurrent",
8949 "generate_series",
8950 "generateSeries",
8951 ];
8952
8953 #[allow(clippy::enum_variant_names)]
8954 enum GeneratedField {
8955 StateTable,
8956 UpdateCurrent,
8957 GenerateSeries,
8958 }
8959 impl<'de> serde::Deserialize<'de> for GeneratedField {
8960 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8961 where
8962 D: serde::Deserializer<'de>,
8963 {
8964 struct GeneratedVisitor;
8965
8966 impl serde::de::Visitor<'_> for GeneratedVisitor {
8967 type Value = GeneratedField;
8968
8969 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8970 write!(formatter, "expected one of: {:?}", &FIELDS)
8971 }
8972
8973 #[allow(unused_variables)]
8974 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8975 where
8976 E: serde::de::Error,
8977 {
8978 match value {
8979 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
8980 "updateCurrent" | "update_current" => Ok(GeneratedField::UpdateCurrent),
8981 "generateSeries" | "generate_series" => Ok(GeneratedField::GenerateSeries),
8982 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8983 }
8984 }
8985 }
8986 deserializer.deserialize_identifier(GeneratedVisitor)
8987 }
8988 }
8989 struct GeneratedVisitor;
8990 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8991 type Value = NowNode;
8992
8993 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8994 formatter.write_str("struct stream_plan.NowNode")
8995 }
8996
8997 fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowNode, V::Error>
8998 where
8999 V: serde::de::MapAccess<'de>,
9000 {
9001 let mut state_table__ = None;
9002 let mut mode__ = None;
9003 while let Some(k) = map_.next_key()? {
9004 match k {
9005 GeneratedField::StateTable => {
9006 if state_table__.is_some() {
9007 return Err(serde::de::Error::duplicate_field("stateTable"));
9008 }
9009 state_table__ = map_.next_value()?;
9010 }
9011 GeneratedField::UpdateCurrent => {
9012 if mode__.is_some() {
9013 return Err(serde::de::Error::duplicate_field("updateCurrent"));
9014 }
9015 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::UpdateCurrent)
9016;
9017 }
9018 GeneratedField::GenerateSeries => {
9019 if mode__.is_some() {
9020 return Err(serde::de::Error::duplicate_field("generateSeries"));
9021 }
9022 mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::GenerateSeries)
9023;
9024 }
9025 }
9026 }
9027 Ok(NowNode {
9028 state_table: state_table__,
9029 mode: mode__,
9030 })
9031 }
9032 }
9033 deserializer.deserialize_struct("stream_plan.NowNode", FIELDS, GeneratedVisitor)
9034 }
9035}
9036impl serde::Serialize for OverWindowCachePolicy {
9037 #[allow(deprecated)]
9038 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9039 where
9040 S: serde::Serializer,
9041 {
9042 let variant = match self {
9043 Self::Unspecified => "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
9044 Self::Full => "OVER_WINDOW_CACHE_POLICY_FULL",
9045 Self::Recent => "OVER_WINDOW_CACHE_POLICY_RECENT",
9046 Self::RecentFirstN => "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
9047 Self::RecentLastN => "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
9048 };
9049 serializer.serialize_str(variant)
9050 }
9051}
9052impl<'de> serde::Deserialize<'de> for OverWindowCachePolicy {
9053 #[allow(deprecated)]
9054 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9055 where
9056 D: serde::Deserializer<'de>,
9057 {
9058 const FIELDS: &[&str] = &[
9059 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
9060 "OVER_WINDOW_CACHE_POLICY_FULL",
9061 "OVER_WINDOW_CACHE_POLICY_RECENT",
9062 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
9063 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
9064 ];
9065
9066 struct GeneratedVisitor;
9067
9068 impl serde::de::Visitor<'_> for GeneratedVisitor {
9069 type Value = OverWindowCachePolicy;
9070
9071 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9072 write!(formatter, "expected one of: {:?}", &FIELDS)
9073 }
9074
9075 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9076 where
9077 E: serde::de::Error,
9078 {
9079 i32::try_from(v)
9080 .ok()
9081 .and_then(|x| x.try_into().ok())
9082 .ok_or_else(|| {
9083 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9084 })
9085 }
9086
9087 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9088 where
9089 E: serde::de::Error,
9090 {
9091 i32::try_from(v)
9092 .ok()
9093 .and_then(|x| x.try_into().ok())
9094 .ok_or_else(|| {
9095 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9096 })
9097 }
9098
9099 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9100 where
9101 E: serde::de::Error,
9102 {
9103 match value {
9104 "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED" => Ok(OverWindowCachePolicy::Unspecified),
9105 "OVER_WINDOW_CACHE_POLICY_FULL" => Ok(OverWindowCachePolicy::Full),
9106 "OVER_WINDOW_CACHE_POLICY_RECENT" => Ok(OverWindowCachePolicy::Recent),
9107 "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N" => Ok(OverWindowCachePolicy::RecentFirstN),
9108 "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N" => Ok(OverWindowCachePolicy::RecentLastN),
9109 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9110 }
9111 }
9112 }
9113 deserializer.deserialize_any(GeneratedVisitor)
9114 }
9115}
9116impl serde::Serialize for OverWindowNode {
9117 #[allow(deprecated)]
9118 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9119 where
9120 S: serde::Serializer,
9121 {
9122 use serde::ser::SerializeStruct;
9123 let mut len = 0;
9124 if !self.calls.is_empty() {
9125 len += 1;
9126 }
9127 if !self.partition_by.is_empty() {
9128 len += 1;
9129 }
9130 if !self.order_by.is_empty() {
9131 len += 1;
9132 }
9133 if self.state_table.is_some() {
9134 len += 1;
9135 }
9136 if self.cache_policy != 0 {
9137 len += 1;
9138 }
9139 let mut struct_ser = serializer.serialize_struct("stream_plan.OverWindowNode", len)?;
9140 if !self.calls.is_empty() {
9141 struct_ser.serialize_field("calls", &self.calls)?;
9142 }
9143 if !self.partition_by.is_empty() {
9144 struct_ser.serialize_field("partitionBy", &self.partition_by)?;
9145 }
9146 if !self.order_by.is_empty() {
9147 struct_ser.serialize_field("orderBy", &self.order_by)?;
9148 }
9149 if let Some(v) = self.state_table.as_ref() {
9150 struct_ser.serialize_field("stateTable", v)?;
9151 }
9152 if self.cache_policy != 0 {
9153 let v = OverWindowCachePolicy::try_from(self.cache_policy)
9154 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cache_policy)))?;
9155 struct_ser.serialize_field("cachePolicy", &v)?;
9156 }
9157 struct_ser.end()
9158 }
9159}
9160impl<'de> serde::Deserialize<'de> for OverWindowNode {
9161 #[allow(deprecated)]
9162 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9163 where
9164 D: serde::Deserializer<'de>,
9165 {
9166 const FIELDS: &[&str] = &[
9167 "calls",
9168 "partition_by",
9169 "partitionBy",
9170 "order_by",
9171 "orderBy",
9172 "state_table",
9173 "stateTable",
9174 "cache_policy",
9175 "cachePolicy",
9176 ];
9177
9178 #[allow(clippy::enum_variant_names)]
9179 enum GeneratedField {
9180 Calls,
9181 PartitionBy,
9182 OrderBy,
9183 StateTable,
9184 CachePolicy,
9185 }
9186 impl<'de> serde::Deserialize<'de> for GeneratedField {
9187 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9188 where
9189 D: serde::Deserializer<'de>,
9190 {
9191 struct GeneratedVisitor;
9192
9193 impl serde::de::Visitor<'_> for GeneratedVisitor {
9194 type Value = GeneratedField;
9195
9196 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9197 write!(formatter, "expected one of: {:?}", &FIELDS)
9198 }
9199
9200 #[allow(unused_variables)]
9201 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9202 where
9203 E: serde::de::Error,
9204 {
9205 match value {
9206 "calls" => Ok(GeneratedField::Calls),
9207 "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
9208 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
9209 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9210 "cachePolicy" | "cache_policy" => Ok(GeneratedField::CachePolicy),
9211 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9212 }
9213 }
9214 }
9215 deserializer.deserialize_identifier(GeneratedVisitor)
9216 }
9217 }
9218 struct GeneratedVisitor;
9219 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9220 type Value = OverWindowNode;
9221
9222 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9223 formatter.write_str("struct stream_plan.OverWindowNode")
9224 }
9225
9226 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverWindowNode, V::Error>
9227 where
9228 V: serde::de::MapAccess<'de>,
9229 {
9230 let mut calls__ = None;
9231 let mut partition_by__ = None;
9232 let mut order_by__ = None;
9233 let mut state_table__ = None;
9234 let mut cache_policy__ = None;
9235 while let Some(k) = map_.next_key()? {
9236 match k {
9237 GeneratedField::Calls => {
9238 if calls__.is_some() {
9239 return Err(serde::de::Error::duplicate_field("calls"));
9240 }
9241 calls__ = Some(map_.next_value()?);
9242 }
9243 GeneratedField::PartitionBy => {
9244 if partition_by__.is_some() {
9245 return Err(serde::de::Error::duplicate_field("partitionBy"));
9246 }
9247 partition_by__ =
9248 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9249 .into_iter().map(|x| x.0).collect())
9250 ;
9251 }
9252 GeneratedField::OrderBy => {
9253 if order_by__.is_some() {
9254 return Err(serde::de::Error::duplicate_field("orderBy"));
9255 }
9256 order_by__ = Some(map_.next_value()?);
9257 }
9258 GeneratedField::StateTable => {
9259 if state_table__.is_some() {
9260 return Err(serde::de::Error::duplicate_field("stateTable"));
9261 }
9262 state_table__ = map_.next_value()?;
9263 }
9264 GeneratedField::CachePolicy => {
9265 if cache_policy__.is_some() {
9266 return Err(serde::de::Error::duplicate_field("cachePolicy"));
9267 }
9268 cache_policy__ = Some(map_.next_value::<OverWindowCachePolicy>()? as i32);
9269 }
9270 }
9271 }
9272 Ok(OverWindowNode {
9273 calls: calls__.unwrap_or_default(),
9274 partition_by: partition_by__.unwrap_or_default(),
9275 order_by: order_by__.unwrap_or_default(),
9276 state_table: state_table__,
9277 cache_policy: cache_policy__.unwrap_or_default(),
9278 })
9279 }
9280 }
9281 deserializer.deserialize_struct("stream_plan.OverWindowNode", FIELDS, GeneratedVisitor)
9282 }
9283}
9284impl serde::Serialize for PauseMutation {
9285 #[allow(deprecated)]
9286 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9287 where
9288 S: serde::Serializer,
9289 {
9290 use serde::ser::SerializeStruct;
9291 let len = 0;
9292 let struct_ser = serializer.serialize_struct("stream_plan.PauseMutation", len)?;
9293 struct_ser.end()
9294 }
9295}
9296impl<'de> serde::Deserialize<'de> for PauseMutation {
9297 #[allow(deprecated)]
9298 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9299 where
9300 D: serde::Deserializer<'de>,
9301 {
9302 const FIELDS: &[&str] = &[
9303 ];
9304
9305 #[allow(clippy::enum_variant_names)]
9306 enum GeneratedField {
9307 }
9308 impl<'de> serde::Deserialize<'de> for GeneratedField {
9309 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9310 where
9311 D: serde::Deserializer<'de>,
9312 {
9313 struct GeneratedVisitor;
9314
9315 impl serde::de::Visitor<'_> for GeneratedVisitor {
9316 type Value = GeneratedField;
9317
9318 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9319 write!(formatter, "expected one of: {:?}", &FIELDS)
9320 }
9321
9322 #[allow(unused_variables)]
9323 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9324 where
9325 E: serde::de::Error,
9326 {
9327 Err(serde::de::Error::unknown_field(value, FIELDS))
9328 }
9329 }
9330 deserializer.deserialize_identifier(GeneratedVisitor)
9331 }
9332 }
9333 struct GeneratedVisitor;
9334 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9335 type Value = PauseMutation;
9336
9337 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9338 formatter.write_str("struct stream_plan.PauseMutation")
9339 }
9340
9341 fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseMutation, V::Error>
9342 where
9343 V: serde::de::MapAccess<'de>,
9344 {
9345 while map_.next_key::<GeneratedField>()?.is_some() {
9346 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9347 }
9348 Ok(PauseMutation {
9349 })
9350 }
9351 }
9352 deserializer.deserialize_struct("stream_plan.PauseMutation", FIELDS, GeneratedVisitor)
9353 }
9354}
9355impl serde::Serialize for ProjectNode {
9356 #[allow(deprecated)]
9357 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9358 where
9359 S: serde::Serializer,
9360 {
9361 use serde::ser::SerializeStruct;
9362 let mut len = 0;
9363 if !self.select_list.is_empty() {
9364 len += 1;
9365 }
9366 if !self.watermark_input_cols.is_empty() {
9367 len += 1;
9368 }
9369 if !self.watermark_output_cols.is_empty() {
9370 len += 1;
9371 }
9372 if !self.nondecreasing_exprs.is_empty() {
9373 len += 1;
9374 }
9375 if self.noop_update_hint {
9376 len += 1;
9377 }
9378 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectNode", len)?;
9379 if !self.select_list.is_empty() {
9380 struct_ser.serialize_field("selectList", &self.select_list)?;
9381 }
9382 if !self.watermark_input_cols.is_empty() {
9383 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
9384 }
9385 if !self.watermark_output_cols.is_empty() {
9386 struct_ser.serialize_field("watermarkOutputCols", &self.watermark_output_cols)?;
9387 }
9388 if !self.nondecreasing_exprs.is_empty() {
9389 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
9390 }
9391 if self.noop_update_hint {
9392 struct_ser.serialize_field("noopUpdateHint", &self.noop_update_hint)?;
9393 }
9394 struct_ser.end()
9395 }
9396}
9397impl<'de> serde::Deserialize<'de> for ProjectNode {
9398 #[allow(deprecated)]
9399 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9400 where
9401 D: serde::Deserializer<'de>,
9402 {
9403 const FIELDS: &[&str] = &[
9404 "select_list",
9405 "selectList",
9406 "watermark_input_cols",
9407 "watermarkInputCols",
9408 "watermark_output_cols",
9409 "watermarkOutputCols",
9410 "nondecreasing_exprs",
9411 "nondecreasingExprs",
9412 "noop_update_hint",
9413 "noopUpdateHint",
9414 ];
9415
9416 #[allow(clippy::enum_variant_names)]
9417 enum GeneratedField {
9418 SelectList,
9419 WatermarkInputCols,
9420 WatermarkOutputCols,
9421 NondecreasingExprs,
9422 NoopUpdateHint,
9423 }
9424 impl<'de> serde::Deserialize<'de> for GeneratedField {
9425 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9426 where
9427 D: serde::Deserializer<'de>,
9428 {
9429 struct GeneratedVisitor;
9430
9431 impl serde::de::Visitor<'_> for GeneratedVisitor {
9432 type Value = GeneratedField;
9433
9434 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9435 write!(formatter, "expected one of: {:?}", &FIELDS)
9436 }
9437
9438 #[allow(unused_variables)]
9439 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9440 where
9441 E: serde::de::Error,
9442 {
9443 match value {
9444 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
9445 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
9446 "watermarkOutputCols" | "watermark_output_cols" => Ok(GeneratedField::WatermarkOutputCols),
9447 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
9448 "noopUpdateHint" | "noop_update_hint" => Ok(GeneratedField::NoopUpdateHint),
9449 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9450 }
9451 }
9452 }
9453 deserializer.deserialize_identifier(GeneratedVisitor)
9454 }
9455 }
9456 struct GeneratedVisitor;
9457 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9458 type Value = ProjectNode;
9459
9460 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9461 formatter.write_str("struct stream_plan.ProjectNode")
9462 }
9463
9464 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
9465 where
9466 V: serde::de::MapAccess<'de>,
9467 {
9468 let mut select_list__ = None;
9469 let mut watermark_input_cols__ = None;
9470 let mut watermark_output_cols__ = None;
9471 let mut nondecreasing_exprs__ = None;
9472 let mut noop_update_hint__ = None;
9473 while let Some(k) = map_.next_key()? {
9474 match k {
9475 GeneratedField::SelectList => {
9476 if select_list__.is_some() {
9477 return Err(serde::de::Error::duplicate_field("selectList"));
9478 }
9479 select_list__ = Some(map_.next_value()?);
9480 }
9481 GeneratedField::WatermarkInputCols => {
9482 if watermark_input_cols__.is_some() {
9483 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
9484 }
9485 watermark_input_cols__ =
9486 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9487 .into_iter().map(|x| x.0).collect())
9488 ;
9489 }
9490 GeneratedField::WatermarkOutputCols => {
9491 if watermark_output_cols__.is_some() {
9492 return Err(serde::de::Error::duplicate_field("watermarkOutputCols"));
9493 }
9494 watermark_output_cols__ =
9495 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9496 .into_iter().map(|x| x.0).collect())
9497 ;
9498 }
9499 GeneratedField::NondecreasingExprs => {
9500 if nondecreasing_exprs__.is_some() {
9501 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
9502 }
9503 nondecreasing_exprs__ =
9504 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9505 .into_iter().map(|x| x.0).collect())
9506 ;
9507 }
9508 GeneratedField::NoopUpdateHint => {
9509 if noop_update_hint__.is_some() {
9510 return Err(serde::de::Error::duplicate_field("noopUpdateHint"));
9511 }
9512 noop_update_hint__ = Some(map_.next_value()?);
9513 }
9514 }
9515 }
9516 Ok(ProjectNode {
9517 select_list: select_list__.unwrap_or_default(),
9518 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
9519 watermark_output_cols: watermark_output_cols__.unwrap_or_default(),
9520 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
9521 noop_update_hint: noop_update_hint__.unwrap_or_default(),
9522 })
9523 }
9524 }
9525 deserializer.deserialize_struct("stream_plan.ProjectNode", FIELDS, GeneratedVisitor)
9526 }
9527}
9528impl serde::Serialize for ProjectSetNode {
9529 #[allow(deprecated)]
9530 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9531 where
9532 S: serde::Serializer,
9533 {
9534 use serde::ser::SerializeStruct;
9535 let mut len = 0;
9536 if !self.select_list.is_empty() {
9537 len += 1;
9538 }
9539 if !self.watermark_input_cols.is_empty() {
9540 len += 1;
9541 }
9542 if !self.watermark_expr_indices.is_empty() {
9543 len += 1;
9544 }
9545 if !self.nondecreasing_exprs.is_empty() {
9546 len += 1;
9547 }
9548 let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectSetNode", len)?;
9549 if !self.select_list.is_empty() {
9550 struct_ser.serialize_field("selectList", &self.select_list)?;
9551 }
9552 if !self.watermark_input_cols.is_empty() {
9553 struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
9554 }
9555 if !self.watermark_expr_indices.is_empty() {
9556 struct_ser.serialize_field("watermarkExprIndices", &self.watermark_expr_indices)?;
9557 }
9558 if !self.nondecreasing_exprs.is_empty() {
9559 struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
9560 }
9561 struct_ser.end()
9562 }
9563}
9564impl<'de> serde::Deserialize<'de> for ProjectSetNode {
9565 #[allow(deprecated)]
9566 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9567 where
9568 D: serde::Deserializer<'de>,
9569 {
9570 const FIELDS: &[&str] = &[
9571 "select_list",
9572 "selectList",
9573 "watermark_input_cols",
9574 "watermarkInputCols",
9575 "watermark_expr_indices",
9576 "watermarkExprIndices",
9577 "nondecreasing_exprs",
9578 "nondecreasingExprs",
9579 ];
9580
9581 #[allow(clippy::enum_variant_names)]
9582 enum GeneratedField {
9583 SelectList,
9584 WatermarkInputCols,
9585 WatermarkExprIndices,
9586 NondecreasingExprs,
9587 }
9588 impl<'de> serde::Deserialize<'de> for GeneratedField {
9589 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9590 where
9591 D: serde::Deserializer<'de>,
9592 {
9593 struct GeneratedVisitor;
9594
9595 impl serde::de::Visitor<'_> for GeneratedVisitor {
9596 type Value = GeneratedField;
9597
9598 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9599 write!(formatter, "expected one of: {:?}", &FIELDS)
9600 }
9601
9602 #[allow(unused_variables)]
9603 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9604 where
9605 E: serde::de::Error,
9606 {
9607 match value {
9608 "selectList" | "select_list" => Ok(GeneratedField::SelectList),
9609 "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
9610 "watermarkExprIndices" | "watermark_expr_indices" => Ok(GeneratedField::WatermarkExprIndices),
9611 "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
9612 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9613 }
9614 }
9615 }
9616 deserializer.deserialize_identifier(GeneratedVisitor)
9617 }
9618 }
9619 struct GeneratedVisitor;
9620 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9621 type Value = ProjectSetNode;
9622
9623 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9624 formatter.write_str("struct stream_plan.ProjectSetNode")
9625 }
9626
9627 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
9628 where
9629 V: serde::de::MapAccess<'de>,
9630 {
9631 let mut select_list__ = None;
9632 let mut watermark_input_cols__ = None;
9633 let mut watermark_expr_indices__ = None;
9634 let mut nondecreasing_exprs__ = None;
9635 while let Some(k) = map_.next_key()? {
9636 match k {
9637 GeneratedField::SelectList => {
9638 if select_list__.is_some() {
9639 return Err(serde::de::Error::duplicate_field("selectList"));
9640 }
9641 select_list__ = Some(map_.next_value()?);
9642 }
9643 GeneratedField::WatermarkInputCols => {
9644 if watermark_input_cols__.is_some() {
9645 return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
9646 }
9647 watermark_input_cols__ =
9648 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9649 .into_iter().map(|x| x.0).collect())
9650 ;
9651 }
9652 GeneratedField::WatermarkExprIndices => {
9653 if watermark_expr_indices__.is_some() {
9654 return Err(serde::de::Error::duplicate_field("watermarkExprIndices"));
9655 }
9656 watermark_expr_indices__ =
9657 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9658 .into_iter().map(|x| x.0).collect())
9659 ;
9660 }
9661 GeneratedField::NondecreasingExprs => {
9662 if nondecreasing_exprs__.is_some() {
9663 return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
9664 }
9665 nondecreasing_exprs__ =
9666 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9667 .into_iter().map(|x| x.0).collect())
9668 ;
9669 }
9670 }
9671 }
9672 Ok(ProjectSetNode {
9673 select_list: select_list__.unwrap_or_default(),
9674 watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
9675 watermark_expr_indices: watermark_expr_indices__.unwrap_or_default(),
9676 nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
9677 })
9678 }
9679 }
9680 deserializer.deserialize_struct("stream_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
9681 }
9682}
9683impl serde::Serialize for RefreshStartMutation {
9684 #[allow(deprecated)]
9685 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9686 where
9687 S: serde::Serializer,
9688 {
9689 use serde::ser::SerializeStruct;
9690 let mut len = 0;
9691 if self.table_id != 0 {
9692 len += 1;
9693 }
9694 if self.associated_source_id != 0 {
9695 len += 1;
9696 }
9697 let mut struct_ser = serializer.serialize_struct("stream_plan.RefreshStartMutation", len)?;
9698 if self.table_id != 0 {
9699 struct_ser.serialize_field("tableId", &self.table_id)?;
9700 }
9701 if self.associated_source_id != 0 {
9702 struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
9703 }
9704 struct_ser.end()
9705 }
9706}
9707impl<'de> serde::Deserialize<'de> for RefreshStartMutation {
9708 #[allow(deprecated)]
9709 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9710 where
9711 D: serde::Deserializer<'de>,
9712 {
9713 const FIELDS: &[&str] = &[
9714 "table_id",
9715 "tableId",
9716 "associated_source_id",
9717 "associatedSourceId",
9718 ];
9719
9720 #[allow(clippy::enum_variant_names)]
9721 enum GeneratedField {
9722 TableId,
9723 AssociatedSourceId,
9724 }
9725 impl<'de> serde::Deserialize<'de> for GeneratedField {
9726 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9727 where
9728 D: serde::Deserializer<'de>,
9729 {
9730 struct GeneratedVisitor;
9731
9732 impl serde::de::Visitor<'_> for GeneratedVisitor {
9733 type Value = GeneratedField;
9734
9735 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9736 write!(formatter, "expected one of: {:?}", &FIELDS)
9737 }
9738
9739 #[allow(unused_variables)]
9740 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9741 where
9742 E: serde::de::Error,
9743 {
9744 match value {
9745 "tableId" | "table_id" => Ok(GeneratedField::TableId),
9746 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
9747 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9748 }
9749 }
9750 }
9751 deserializer.deserialize_identifier(GeneratedVisitor)
9752 }
9753 }
9754 struct GeneratedVisitor;
9755 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9756 type Value = RefreshStartMutation;
9757
9758 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9759 formatter.write_str("struct stream_plan.RefreshStartMutation")
9760 }
9761
9762 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshStartMutation, V::Error>
9763 where
9764 V: serde::de::MapAccess<'de>,
9765 {
9766 let mut table_id__ = None;
9767 let mut associated_source_id__ = None;
9768 while let Some(k) = map_.next_key()? {
9769 match k {
9770 GeneratedField::TableId => {
9771 if table_id__.is_some() {
9772 return Err(serde::de::Error::duplicate_field("tableId"));
9773 }
9774 table_id__ =
9775 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9776 ;
9777 }
9778 GeneratedField::AssociatedSourceId => {
9779 if associated_source_id__.is_some() {
9780 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
9781 }
9782 associated_source_id__ =
9783 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9784 ;
9785 }
9786 }
9787 }
9788 Ok(RefreshStartMutation {
9789 table_id: table_id__.unwrap_or_default(),
9790 associated_source_id: associated_source_id__.unwrap_or_default(),
9791 })
9792 }
9793 }
9794 deserializer.deserialize_struct("stream_plan.RefreshStartMutation", FIELDS, GeneratedVisitor)
9795 }
9796}
9797impl serde::Serialize for ResetSourceMutation {
9798 #[allow(deprecated)]
9799 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9800 where
9801 S: serde::Serializer,
9802 {
9803 use serde::ser::SerializeStruct;
9804 let mut len = 0;
9805 if self.source_id != 0 {
9806 len += 1;
9807 }
9808 let mut struct_ser = serializer.serialize_struct("stream_plan.ResetSourceMutation", len)?;
9809 if self.source_id != 0 {
9810 struct_ser.serialize_field("sourceId", &self.source_id)?;
9811 }
9812 struct_ser.end()
9813 }
9814}
9815impl<'de> serde::Deserialize<'de> for ResetSourceMutation {
9816 #[allow(deprecated)]
9817 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9818 where
9819 D: serde::Deserializer<'de>,
9820 {
9821 const FIELDS: &[&str] = &[
9822 "source_id",
9823 "sourceId",
9824 ];
9825
9826 #[allow(clippy::enum_variant_names)]
9827 enum GeneratedField {
9828 SourceId,
9829 }
9830 impl<'de> serde::Deserialize<'de> for GeneratedField {
9831 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9832 where
9833 D: serde::Deserializer<'de>,
9834 {
9835 struct GeneratedVisitor;
9836
9837 impl serde::de::Visitor<'_> for GeneratedVisitor {
9838 type Value = GeneratedField;
9839
9840 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9841 write!(formatter, "expected one of: {:?}", &FIELDS)
9842 }
9843
9844 #[allow(unused_variables)]
9845 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9846 where
9847 E: serde::de::Error,
9848 {
9849 match value {
9850 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
9851 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9852 }
9853 }
9854 }
9855 deserializer.deserialize_identifier(GeneratedVisitor)
9856 }
9857 }
9858 struct GeneratedVisitor;
9859 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9860 type Value = ResetSourceMutation;
9861
9862 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9863 formatter.write_str("struct stream_plan.ResetSourceMutation")
9864 }
9865
9866 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetSourceMutation, V::Error>
9867 where
9868 V: serde::de::MapAccess<'de>,
9869 {
9870 let mut source_id__ = None;
9871 while let Some(k) = map_.next_key()? {
9872 match k {
9873 GeneratedField::SourceId => {
9874 if source_id__.is_some() {
9875 return Err(serde::de::Error::duplicate_field("sourceId"));
9876 }
9877 source_id__ =
9878 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9879 ;
9880 }
9881 }
9882 }
9883 Ok(ResetSourceMutation {
9884 source_id: source_id__.unwrap_or_default(),
9885 })
9886 }
9887 }
9888 deserializer.deserialize_struct("stream_plan.ResetSourceMutation", FIELDS, GeneratedVisitor)
9889 }
9890}
9891impl serde::Serialize for ResumeMutation {
9892 #[allow(deprecated)]
9893 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9894 where
9895 S: serde::Serializer,
9896 {
9897 use serde::ser::SerializeStruct;
9898 let len = 0;
9899 let struct_ser = serializer.serialize_struct("stream_plan.ResumeMutation", len)?;
9900 struct_ser.end()
9901 }
9902}
9903impl<'de> serde::Deserialize<'de> for ResumeMutation {
9904 #[allow(deprecated)]
9905 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9906 where
9907 D: serde::Deserializer<'de>,
9908 {
9909 const FIELDS: &[&str] = &[
9910 ];
9911
9912 #[allow(clippy::enum_variant_names)]
9913 enum GeneratedField {
9914 }
9915 impl<'de> serde::Deserialize<'de> for GeneratedField {
9916 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9917 where
9918 D: serde::Deserializer<'de>,
9919 {
9920 struct GeneratedVisitor;
9921
9922 impl serde::de::Visitor<'_> for GeneratedVisitor {
9923 type Value = GeneratedField;
9924
9925 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9926 write!(formatter, "expected one of: {:?}", &FIELDS)
9927 }
9928
9929 #[allow(unused_variables)]
9930 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9931 where
9932 E: serde::de::Error,
9933 {
9934 Err(serde::de::Error::unknown_field(value, FIELDS))
9935 }
9936 }
9937 deserializer.deserialize_identifier(GeneratedVisitor)
9938 }
9939 }
9940 struct GeneratedVisitor;
9941 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9942 type Value = ResumeMutation;
9943
9944 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9945 formatter.write_str("struct stream_plan.ResumeMutation")
9946 }
9947
9948 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeMutation, V::Error>
9949 where
9950 V: serde::de::MapAccess<'de>,
9951 {
9952 while map_.next_key::<GeneratedField>()?.is_some() {
9953 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9954 }
9955 Ok(ResumeMutation {
9956 })
9957 }
9958 }
9959 deserializer.deserialize_struct("stream_plan.ResumeMutation", FIELDS, GeneratedVisitor)
9960 }
9961}
9962impl serde::Serialize for RowIdGenNode {
9963 #[allow(deprecated)]
9964 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9965 where
9966 S: serde::Serializer,
9967 {
9968 use serde::ser::SerializeStruct;
9969 let mut len = 0;
9970 if self.row_id_index != 0 {
9971 len += 1;
9972 }
9973 let mut struct_ser = serializer.serialize_struct("stream_plan.RowIdGenNode", len)?;
9974 if self.row_id_index != 0 {
9975 #[allow(clippy::needless_borrow)]
9976 #[allow(clippy::needless_borrows_for_generic_args)]
9977 struct_ser.serialize_field("rowIdIndex", ToString::to_string(&self.row_id_index).as_str())?;
9978 }
9979 struct_ser.end()
9980 }
9981}
9982impl<'de> serde::Deserialize<'de> for RowIdGenNode {
9983 #[allow(deprecated)]
9984 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9985 where
9986 D: serde::Deserializer<'de>,
9987 {
9988 const FIELDS: &[&str] = &[
9989 "row_id_index",
9990 "rowIdIndex",
9991 ];
9992
9993 #[allow(clippy::enum_variant_names)]
9994 enum GeneratedField {
9995 RowIdIndex,
9996 }
9997 impl<'de> serde::Deserialize<'de> for GeneratedField {
9998 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9999 where
10000 D: serde::Deserializer<'de>,
10001 {
10002 struct GeneratedVisitor;
10003
10004 impl serde::de::Visitor<'_> for GeneratedVisitor {
10005 type Value = GeneratedField;
10006
10007 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10008 write!(formatter, "expected one of: {:?}", &FIELDS)
10009 }
10010
10011 #[allow(unused_variables)]
10012 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10013 where
10014 E: serde::de::Error,
10015 {
10016 match value {
10017 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
10018 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10019 }
10020 }
10021 }
10022 deserializer.deserialize_identifier(GeneratedVisitor)
10023 }
10024 }
10025 struct GeneratedVisitor;
10026 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10027 type Value = RowIdGenNode;
10028
10029 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10030 formatter.write_str("struct stream_plan.RowIdGenNode")
10031 }
10032
10033 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowIdGenNode, V::Error>
10034 where
10035 V: serde::de::MapAccess<'de>,
10036 {
10037 let mut row_id_index__ = None;
10038 while let Some(k) = map_.next_key()? {
10039 match k {
10040 GeneratedField::RowIdIndex => {
10041 if row_id_index__.is_some() {
10042 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
10043 }
10044 row_id_index__ =
10045 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10046 ;
10047 }
10048 }
10049 }
10050 Ok(RowIdGenNode {
10051 row_id_index: row_id_index__.unwrap_or_default(),
10052 })
10053 }
10054 }
10055 deserializer.deserialize_struct("stream_plan.RowIdGenNode", FIELDS, GeneratedVisitor)
10056 }
10057}
10058impl serde::Serialize for RowMergeNode {
10059 #[allow(deprecated)]
10060 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10061 where
10062 S: serde::Serializer,
10063 {
10064 use serde::ser::SerializeStruct;
10065 let mut len = 0;
10066 if self.lhs_mapping.is_some() {
10067 len += 1;
10068 }
10069 if self.rhs_mapping.is_some() {
10070 len += 1;
10071 }
10072 let mut struct_ser = serializer.serialize_struct("stream_plan.RowMergeNode", len)?;
10073 if let Some(v) = self.lhs_mapping.as_ref() {
10074 struct_ser.serialize_field("lhsMapping", v)?;
10075 }
10076 if let Some(v) = self.rhs_mapping.as_ref() {
10077 struct_ser.serialize_field("rhsMapping", v)?;
10078 }
10079 struct_ser.end()
10080 }
10081}
10082impl<'de> serde::Deserialize<'de> for RowMergeNode {
10083 #[allow(deprecated)]
10084 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10085 where
10086 D: serde::Deserializer<'de>,
10087 {
10088 const FIELDS: &[&str] = &[
10089 "lhs_mapping",
10090 "lhsMapping",
10091 "rhs_mapping",
10092 "rhsMapping",
10093 ];
10094
10095 #[allow(clippy::enum_variant_names)]
10096 enum GeneratedField {
10097 LhsMapping,
10098 RhsMapping,
10099 }
10100 impl<'de> serde::Deserialize<'de> for GeneratedField {
10101 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10102 where
10103 D: serde::Deserializer<'de>,
10104 {
10105 struct GeneratedVisitor;
10106
10107 impl serde::de::Visitor<'_> for GeneratedVisitor {
10108 type Value = GeneratedField;
10109
10110 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10111 write!(formatter, "expected one of: {:?}", &FIELDS)
10112 }
10113
10114 #[allow(unused_variables)]
10115 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10116 where
10117 E: serde::de::Error,
10118 {
10119 match value {
10120 "lhsMapping" | "lhs_mapping" => Ok(GeneratedField::LhsMapping),
10121 "rhsMapping" | "rhs_mapping" => Ok(GeneratedField::RhsMapping),
10122 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10123 }
10124 }
10125 }
10126 deserializer.deserialize_identifier(GeneratedVisitor)
10127 }
10128 }
10129 struct GeneratedVisitor;
10130 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10131 type Value = RowMergeNode;
10132
10133 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10134 formatter.write_str("struct stream_plan.RowMergeNode")
10135 }
10136
10137 fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowMergeNode, V::Error>
10138 where
10139 V: serde::de::MapAccess<'de>,
10140 {
10141 let mut lhs_mapping__ = None;
10142 let mut rhs_mapping__ = None;
10143 while let Some(k) = map_.next_key()? {
10144 match k {
10145 GeneratedField::LhsMapping => {
10146 if lhs_mapping__.is_some() {
10147 return Err(serde::de::Error::duplicate_field("lhsMapping"));
10148 }
10149 lhs_mapping__ = map_.next_value()?;
10150 }
10151 GeneratedField::RhsMapping => {
10152 if rhs_mapping__.is_some() {
10153 return Err(serde::de::Error::duplicate_field("rhsMapping"));
10154 }
10155 rhs_mapping__ = map_.next_value()?;
10156 }
10157 }
10158 }
10159 Ok(RowMergeNode {
10160 lhs_mapping: lhs_mapping__,
10161 rhs_mapping: rhs_mapping__,
10162 })
10163 }
10164 }
10165 deserializer.deserialize_struct("stream_plan.RowMergeNode", FIELDS, GeneratedVisitor)
10166 }
10167}
10168impl serde::Serialize for SimpleAggNode {
10169 #[allow(deprecated)]
10170 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10171 where
10172 S: serde::Serializer,
10173 {
10174 use serde::ser::SerializeStruct;
10175 let mut len = 0;
10176 if !self.agg_calls.is_empty() {
10177 len += 1;
10178 }
10179 if !self.agg_call_states.is_empty() {
10180 len += 1;
10181 }
10182 if self.intermediate_state_table.is_some() {
10183 len += 1;
10184 }
10185 if self.is_append_only {
10186 len += 1;
10187 }
10188 if !self.distinct_dedup_tables.is_empty() {
10189 len += 1;
10190 }
10191 if self.row_count_index != 0 {
10192 len += 1;
10193 }
10194 if self.version != 0 {
10195 len += 1;
10196 }
10197 if self.must_output_per_barrier {
10198 len += 1;
10199 }
10200 let mut struct_ser = serializer.serialize_struct("stream_plan.SimpleAggNode", len)?;
10201 if !self.agg_calls.is_empty() {
10202 struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
10203 }
10204 if !self.agg_call_states.is_empty() {
10205 struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
10206 }
10207 if let Some(v) = self.intermediate_state_table.as_ref() {
10208 struct_ser.serialize_field("intermediateStateTable", v)?;
10209 }
10210 if self.is_append_only {
10211 struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
10212 }
10213 if !self.distinct_dedup_tables.is_empty() {
10214 struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
10215 }
10216 if self.row_count_index != 0 {
10217 struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
10218 }
10219 if self.version != 0 {
10220 let v = AggNodeVersion::try_from(self.version)
10221 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
10222 struct_ser.serialize_field("version", &v)?;
10223 }
10224 if self.must_output_per_barrier {
10225 struct_ser.serialize_field("mustOutputPerBarrier", &self.must_output_per_barrier)?;
10226 }
10227 struct_ser.end()
10228 }
10229}
10230impl<'de> serde::Deserialize<'de> for SimpleAggNode {
10231 #[allow(deprecated)]
10232 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10233 where
10234 D: serde::Deserializer<'de>,
10235 {
10236 const FIELDS: &[&str] = &[
10237 "agg_calls",
10238 "aggCalls",
10239 "agg_call_states",
10240 "aggCallStates",
10241 "intermediate_state_table",
10242 "intermediateStateTable",
10243 "is_append_only",
10244 "isAppendOnly",
10245 "distinct_dedup_tables",
10246 "distinctDedupTables",
10247 "row_count_index",
10248 "rowCountIndex",
10249 "version",
10250 "must_output_per_barrier",
10251 "mustOutputPerBarrier",
10252 ];
10253
10254 #[allow(clippy::enum_variant_names)]
10255 enum GeneratedField {
10256 AggCalls,
10257 AggCallStates,
10258 IntermediateStateTable,
10259 IsAppendOnly,
10260 DistinctDedupTables,
10261 RowCountIndex,
10262 Version,
10263 MustOutputPerBarrier,
10264 }
10265 impl<'de> serde::Deserialize<'de> for GeneratedField {
10266 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10267 where
10268 D: serde::Deserializer<'de>,
10269 {
10270 struct GeneratedVisitor;
10271
10272 impl serde::de::Visitor<'_> for GeneratedVisitor {
10273 type Value = GeneratedField;
10274
10275 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10276 write!(formatter, "expected one of: {:?}", &FIELDS)
10277 }
10278
10279 #[allow(unused_variables)]
10280 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10281 where
10282 E: serde::de::Error,
10283 {
10284 match value {
10285 "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
10286 "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
10287 "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
10288 "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
10289 "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
10290 "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
10291 "version" => Ok(GeneratedField::Version),
10292 "mustOutputPerBarrier" | "must_output_per_barrier" => Ok(GeneratedField::MustOutputPerBarrier),
10293 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10294 }
10295 }
10296 }
10297 deserializer.deserialize_identifier(GeneratedVisitor)
10298 }
10299 }
10300 struct GeneratedVisitor;
10301 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10302 type Value = SimpleAggNode;
10303
10304 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10305 formatter.write_str("struct stream_plan.SimpleAggNode")
10306 }
10307
10308 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SimpleAggNode, V::Error>
10309 where
10310 V: serde::de::MapAccess<'de>,
10311 {
10312 let mut agg_calls__ = None;
10313 let mut agg_call_states__ = None;
10314 let mut intermediate_state_table__ = None;
10315 let mut is_append_only__ = None;
10316 let mut distinct_dedup_tables__ = None;
10317 let mut row_count_index__ = None;
10318 let mut version__ = None;
10319 let mut must_output_per_barrier__ = None;
10320 while let Some(k) = map_.next_key()? {
10321 match k {
10322 GeneratedField::AggCalls => {
10323 if agg_calls__.is_some() {
10324 return Err(serde::de::Error::duplicate_field("aggCalls"));
10325 }
10326 agg_calls__ = Some(map_.next_value()?);
10327 }
10328 GeneratedField::AggCallStates => {
10329 if agg_call_states__.is_some() {
10330 return Err(serde::de::Error::duplicate_field("aggCallStates"));
10331 }
10332 agg_call_states__ = Some(map_.next_value()?);
10333 }
10334 GeneratedField::IntermediateStateTable => {
10335 if intermediate_state_table__.is_some() {
10336 return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
10337 }
10338 intermediate_state_table__ = map_.next_value()?;
10339 }
10340 GeneratedField::IsAppendOnly => {
10341 if is_append_only__.is_some() {
10342 return Err(serde::de::Error::duplicate_field("isAppendOnly"));
10343 }
10344 is_append_only__ = Some(map_.next_value()?);
10345 }
10346 GeneratedField::DistinctDedupTables => {
10347 if distinct_dedup_tables__.is_some() {
10348 return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
10349 }
10350 distinct_dedup_tables__ = Some(
10351 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10352 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
10353 );
10354 }
10355 GeneratedField::RowCountIndex => {
10356 if row_count_index__.is_some() {
10357 return Err(serde::de::Error::duplicate_field("rowCountIndex"));
10358 }
10359 row_count_index__ =
10360 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10361 ;
10362 }
10363 GeneratedField::Version => {
10364 if version__.is_some() {
10365 return Err(serde::de::Error::duplicate_field("version"));
10366 }
10367 version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
10368 }
10369 GeneratedField::MustOutputPerBarrier => {
10370 if must_output_per_barrier__.is_some() {
10371 return Err(serde::de::Error::duplicate_field("mustOutputPerBarrier"));
10372 }
10373 must_output_per_barrier__ = Some(map_.next_value()?);
10374 }
10375 }
10376 }
10377 Ok(SimpleAggNode {
10378 agg_calls: agg_calls__.unwrap_or_default(),
10379 agg_call_states: agg_call_states__.unwrap_or_default(),
10380 intermediate_state_table: intermediate_state_table__,
10381 is_append_only: is_append_only__.unwrap_or_default(),
10382 distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
10383 row_count_index: row_count_index__.unwrap_or_default(),
10384 version: version__.unwrap_or_default(),
10385 must_output_per_barrier: must_output_per_barrier__.unwrap_or_default(),
10386 })
10387 }
10388 }
10389 deserializer.deserialize_struct("stream_plan.SimpleAggNode", FIELDS, GeneratedVisitor)
10390 }
10391}
10392impl serde::Serialize for SinkAddColumnsOp {
10393 #[allow(deprecated)]
10394 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10395 where
10396 S: serde::Serializer,
10397 {
10398 use serde::ser::SerializeStruct;
10399 let mut len = 0;
10400 if !self.fields.is_empty() {
10401 len += 1;
10402 }
10403 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkAddColumnsOp", len)?;
10404 if !self.fields.is_empty() {
10405 struct_ser.serialize_field("fields", &self.fields)?;
10406 }
10407 struct_ser.end()
10408 }
10409}
10410impl<'de> serde::Deserialize<'de> for SinkAddColumnsOp {
10411 #[allow(deprecated)]
10412 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10413 where
10414 D: serde::Deserializer<'de>,
10415 {
10416 const FIELDS: &[&str] = &[
10417 "fields",
10418 ];
10419
10420 #[allow(clippy::enum_variant_names)]
10421 enum GeneratedField {
10422 Fields,
10423 }
10424 impl<'de> serde::Deserialize<'de> for GeneratedField {
10425 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10426 where
10427 D: serde::Deserializer<'de>,
10428 {
10429 struct GeneratedVisitor;
10430
10431 impl serde::de::Visitor<'_> for GeneratedVisitor {
10432 type Value = GeneratedField;
10433
10434 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10435 write!(formatter, "expected one of: {:?}", &FIELDS)
10436 }
10437
10438 #[allow(unused_variables)]
10439 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10440 where
10441 E: serde::de::Error,
10442 {
10443 match value {
10444 "fields" => Ok(GeneratedField::Fields),
10445 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10446 }
10447 }
10448 }
10449 deserializer.deserialize_identifier(GeneratedVisitor)
10450 }
10451 }
10452 struct GeneratedVisitor;
10453 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10454 type Value = SinkAddColumnsOp;
10455
10456 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10457 formatter.write_str("struct stream_plan.SinkAddColumnsOp")
10458 }
10459
10460 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkAddColumnsOp, V::Error>
10461 where
10462 V: serde::de::MapAccess<'de>,
10463 {
10464 let mut fields__ = None;
10465 while let Some(k) = map_.next_key()? {
10466 match k {
10467 GeneratedField::Fields => {
10468 if fields__.is_some() {
10469 return Err(serde::de::Error::duplicate_field("fields"));
10470 }
10471 fields__ = Some(map_.next_value()?);
10472 }
10473 }
10474 }
10475 Ok(SinkAddColumnsOp {
10476 fields: fields__.unwrap_or_default(),
10477 })
10478 }
10479 }
10480 deserializer.deserialize_struct("stream_plan.SinkAddColumnsOp", FIELDS, GeneratedVisitor)
10481 }
10482}
10483impl serde::Serialize for SinkDesc {
10484 #[allow(deprecated)]
10485 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10486 where
10487 S: serde::Serializer,
10488 {
10489 use serde::ser::SerializeStruct;
10490 let mut len = 0;
10491 if self.id != 0 {
10492 len += 1;
10493 }
10494 if !self.name.is_empty() {
10495 len += 1;
10496 }
10497 if !self.definition.is_empty() {
10498 len += 1;
10499 }
10500 if !self.plan_pk.is_empty() {
10501 len += 1;
10502 }
10503 if !self.downstream_pk.is_empty() {
10504 len += 1;
10505 }
10506 if !self.distribution_key.is_empty() {
10507 len += 1;
10508 }
10509 if !self.properties.is_empty() {
10510 len += 1;
10511 }
10512 if self.sink_type != 0 {
10513 len += 1;
10514 }
10515 if !self.column_catalogs.is_empty() {
10516 len += 1;
10517 }
10518 if !self.db_name.is_empty() {
10519 len += 1;
10520 }
10521 if !self.sink_from_name.is_empty() {
10522 len += 1;
10523 }
10524 if self.format_desc.is_some() {
10525 len += 1;
10526 }
10527 if self.target_table.is_some() {
10528 len += 1;
10529 }
10530 if self.extra_partition_col_idx.is_some() {
10531 len += 1;
10532 }
10533 if !self.secret_refs.is_empty() {
10534 len += 1;
10535 }
10536 if self.raw_ignore_delete {
10537 len += 1;
10538 }
10539 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDesc", len)?;
10540 if self.id != 0 {
10541 struct_ser.serialize_field("id", &self.id)?;
10542 }
10543 if !self.name.is_empty() {
10544 struct_ser.serialize_field("name", &self.name)?;
10545 }
10546 if !self.definition.is_empty() {
10547 struct_ser.serialize_field("definition", &self.definition)?;
10548 }
10549 if !self.plan_pk.is_empty() {
10550 struct_ser.serialize_field("planPk", &self.plan_pk)?;
10551 }
10552 if !self.downstream_pk.is_empty() {
10553 struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
10554 }
10555 if !self.distribution_key.is_empty() {
10556 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
10557 }
10558 if !self.properties.is_empty() {
10559 struct_ser.serialize_field("properties", &self.properties)?;
10560 }
10561 if self.sink_type != 0 {
10562 let v = super::catalog::SinkType::try_from(self.sink_type)
10563 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
10564 struct_ser.serialize_field("sinkType", &v)?;
10565 }
10566 if !self.column_catalogs.is_empty() {
10567 struct_ser.serialize_field("columnCatalogs", &self.column_catalogs)?;
10568 }
10569 if !self.db_name.is_empty() {
10570 struct_ser.serialize_field("dbName", &self.db_name)?;
10571 }
10572 if !self.sink_from_name.is_empty() {
10573 struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
10574 }
10575 if let Some(v) = self.format_desc.as_ref() {
10576 struct_ser.serialize_field("formatDesc", v)?;
10577 }
10578 if let Some(v) = self.target_table.as_ref() {
10579 struct_ser.serialize_field("targetTable", v)?;
10580 }
10581 if let Some(v) = self.extra_partition_col_idx.as_ref() {
10582 #[allow(clippy::needless_borrow)]
10583 #[allow(clippy::needless_borrows_for_generic_args)]
10584 struct_ser.serialize_field("extraPartitionColIdx", ToString::to_string(&v).as_str())?;
10585 }
10586 if !self.secret_refs.is_empty() {
10587 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
10588 }
10589 if self.raw_ignore_delete {
10590 struct_ser.serialize_field("rawIgnoreDelete", &self.raw_ignore_delete)?;
10591 }
10592 struct_ser.end()
10593 }
10594}
10595impl<'de> serde::Deserialize<'de> for SinkDesc {
10596 #[allow(deprecated)]
10597 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10598 where
10599 D: serde::Deserializer<'de>,
10600 {
10601 const FIELDS: &[&str] = &[
10602 "id",
10603 "name",
10604 "definition",
10605 "plan_pk",
10606 "planPk",
10607 "downstream_pk",
10608 "downstreamPk",
10609 "distribution_key",
10610 "distributionKey",
10611 "properties",
10612 "sink_type",
10613 "sinkType",
10614 "column_catalogs",
10615 "columnCatalogs",
10616 "db_name",
10617 "dbName",
10618 "sink_from_name",
10619 "sinkFromName",
10620 "format_desc",
10621 "formatDesc",
10622 "target_table",
10623 "targetTable",
10624 "extra_partition_col_idx",
10625 "extraPartitionColIdx",
10626 "secret_refs",
10627 "secretRefs",
10628 "raw_ignore_delete",
10629 "rawIgnoreDelete",
10630 ];
10631
10632 #[allow(clippy::enum_variant_names)]
10633 enum GeneratedField {
10634 Id,
10635 Name,
10636 Definition,
10637 PlanPk,
10638 DownstreamPk,
10639 DistributionKey,
10640 Properties,
10641 SinkType,
10642 ColumnCatalogs,
10643 DbName,
10644 SinkFromName,
10645 FormatDesc,
10646 TargetTable,
10647 ExtraPartitionColIdx,
10648 SecretRefs,
10649 RawIgnoreDelete,
10650 }
10651 impl<'de> serde::Deserialize<'de> for GeneratedField {
10652 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10653 where
10654 D: serde::Deserializer<'de>,
10655 {
10656 struct GeneratedVisitor;
10657
10658 impl serde::de::Visitor<'_> for GeneratedVisitor {
10659 type Value = GeneratedField;
10660
10661 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10662 write!(formatter, "expected one of: {:?}", &FIELDS)
10663 }
10664
10665 #[allow(unused_variables)]
10666 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10667 where
10668 E: serde::de::Error,
10669 {
10670 match value {
10671 "id" => Ok(GeneratedField::Id),
10672 "name" => Ok(GeneratedField::Name),
10673 "definition" => Ok(GeneratedField::Definition),
10674 "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
10675 "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
10676 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
10677 "properties" => Ok(GeneratedField::Properties),
10678 "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
10679 "columnCatalogs" | "column_catalogs" => Ok(GeneratedField::ColumnCatalogs),
10680 "dbName" | "db_name" => Ok(GeneratedField::DbName),
10681 "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
10682 "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
10683 "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
10684 "extraPartitionColIdx" | "extra_partition_col_idx" => Ok(GeneratedField::ExtraPartitionColIdx),
10685 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
10686 "rawIgnoreDelete" | "raw_ignore_delete" => Ok(GeneratedField::RawIgnoreDelete),
10687 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10688 }
10689 }
10690 }
10691 deserializer.deserialize_identifier(GeneratedVisitor)
10692 }
10693 }
10694 struct GeneratedVisitor;
10695 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10696 type Value = SinkDesc;
10697
10698 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10699 formatter.write_str("struct stream_plan.SinkDesc")
10700 }
10701
10702 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDesc, V::Error>
10703 where
10704 V: serde::de::MapAccess<'de>,
10705 {
10706 let mut id__ = None;
10707 let mut name__ = None;
10708 let mut definition__ = None;
10709 let mut plan_pk__ = None;
10710 let mut downstream_pk__ = None;
10711 let mut distribution_key__ = None;
10712 let mut properties__ = None;
10713 let mut sink_type__ = None;
10714 let mut column_catalogs__ = None;
10715 let mut db_name__ = None;
10716 let mut sink_from_name__ = None;
10717 let mut format_desc__ = None;
10718 let mut target_table__ = None;
10719 let mut extra_partition_col_idx__ = None;
10720 let mut secret_refs__ = None;
10721 let mut raw_ignore_delete__ = None;
10722 while let Some(k) = map_.next_key()? {
10723 match k {
10724 GeneratedField::Id => {
10725 if id__.is_some() {
10726 return Err(serde::de::Error::duplicate_field("id"));
10727 }
10728 id__ =
10729 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10730 ;
10731 }
10732 GeneratedField::Name => {
10733 if name__.is_some() {
10734 return Err(serde::de::Error::duplicate_field("name"));
10735 }
10736 name__ = Some(map_.next_value()?);
10737 }
10738 GeneratedField::Definition => {
10739 if definition__.is_some() {
10740 return Err(serde::de::Error::duplicate_field("definition"));
10741 }
10742 definition__ = Some(map_.next_value()?);
10743 }
10744 GeneratedField::PlanPk => {
10745 if plan_pk__.is_some() {
10746 return Err(serde::de::Error::duplicate_field("planPk"));
10747 }
10748 plan_pk__ = Some(map_.next_value()?);
10749 }
10750 GeneratedField::DownstreamPk => {
10751 if downstream_pk__.is_some() {
10752 return Err(serde::de::Error::duplicate_field("downstreamPk"));
10753 }
10754 downstream_pk__ =
10755 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10756 .into_iter().map(|x| x.0).collect())
10757 ;
10758 }
10759 GeneratedField::DistributionKey => {
10760 if distribution_key__.is_some() {
10761 return Err(serde::de::Error::duplicate_field("distributionKey"));
10762 }
10763 distribution_key__ =
10764 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10765 .into_iter().map(|x| x.0).collect())
10766 ;
10767 }
10768 GeneratedField::Properties => {
10769 if properties__.is_some() {
10770 return Err(serde::de::Error::duplicate_field("properties"));
10771 }
10772 properties__ = Some(
10773 map_.next_value::<std::collections::BTreeMap<_, _>>()?
10774 );
10775 }
10776 GeneratedField::SinkType => {
10777 if sink_type__.is_some() {
10778 return Err(serde::de::Error::duplicate_field("sinkType"));
10779 }
10780 sink_type__ = Some(map_.next_value::<super::catalog::SinkType>()? as i32);
10781 }
10782 GeneratedField::ColumnCatalogs => {
10783 if column_catalogs__.is_some() {
10784 return Err(serde::de::Error::duplicate_field("columnCatalogs"));
10785 }
10786 column_catalogs__ = Some(map_.next_value()?);
10787 }
10788 GeneratedField::DbName => {
10789 if db_name__.is_some() {
10790 return Err(serde::de::Error::duplicate_field("dbName"));
10791 }
10792 db_name__ = Some(map_.next_value()?);
10793 }
10794 GeneratedField::SinkFromName => {
10795 if sink_from_name__.is_some() {
10796 return Err(serde::de::Error::duplicate_field("sinkFromName"));
10797 }
10798 sink_from_name__ = Some(map_.next_value()?);
10799 }
10800 GeneratedField::FormatDesc => {
10801 if format_desc__.is_some() {
10802 return Err(serde::de::Error::duplicate_field("formatDesc"));
10803 }
10804 format_desc__ = map_.next_value()?;
10805 }
10806 GeneratedField::TargetTable => {
10807 if target_table__.is_some() {
10808 return Err(serde::de::Error::duplicate_field("targetTable"));
10809 }
10810 target_table__ =
10811 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10812 ;
10813 }
10814 GeneratedField::ExtraPartitionColIdx => {
10815 if extra_partition_col_idx__.is_some() {
10816 return Err(serde::de::Error::duplicate_field("extraPartitionColIdx"));
10817 }
10818 extra_partition_col_idx__ =
10819 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10820 ;
10821 }
10822 GeneratedField::SecretRefs => {
10823 if secret_refs__.is_some() {
10824 return Err(serde::de::Error::duplicate_field("secretRefs"));
10825 }
10826 secret_refs__ = Some(
10827 map_.next_value::<std::collections::BTreeMap<_, _>>()?
10828 );
10829 }
10830 GeneratedField::RawIgnoreDelete => {
10831 if raw_ignore_delete__.is_some() {
10832 return Err(serde::de::Error::duplicate_field("rawIgnoreDelete"));
10833 }
10834 raw_ignore_delete__ = Some(map_.next_value()?);
10835 }
10836 }
10837 }
10838 Ok(SinkDesc {
10839 id: id__.unwrap_or_default(),
10840 name: name__.unwrap_or_default(),
10841 definition: definition__.unwrap_or_default(),
10842 plan_pk: plan_pk__.unwrap_or_default(),
10843 downstream_pk: downstream_pk__.unwrap_or_default(),
10844 distribution_key: distribution_key__.unwrap_or_default(),
10845 properties: properties__.unwrap_or_default(),
10846 sink_type: sink_type__.unwrap_or_default(),
10847 column_catalogs: column_catalogs__.unwrap_or_default(),
10848 db_name: db_name__.unwrap_or_default(),
10849 sink_from_name: sink_from_name__.unwrap_or_default(),
10850 format_desc: format_desc__,
10851 target_table: target_table__,
10852 extra_partition_col_idx: extra_partition_col_idx__,
10853 secret_refs: secret_refs__.unwrap_or_default(),
10854 raw_ignore_delete: raw_ignore_delete__.unwrap_or_default(),
10855 })
10856 }
10857 }
10858 deserializer.deserialize_struct("stream_plan.SinkDesc", FIELDS, GeneratedVisitor)
10859 }
10860}
10861impl serde::Serialize for SinkDropColumnsOp {
10862 #[allow(deprecated)]
10863 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10864 where
10865 S: serde::Serializer,
10866 {
10867 use serde::ser::SerializeStruct;
10868 let mut len = 0;
10869 if !self.column_names.is_empty() {
10870 len += 1;
10871 }
10872 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDropColumnsOp", len)?;
10873 if !self.column_names.is_empty() {
10874 struct_ser.serialize_field("columnNames", &self.column_names)?;
10875 }
10876 struct_ser.end()
10877 }
10878}
10879impl<'de> serde::Deserialize<'de> for SinkDropColumnsOp {
10880 #[allow(deprecated)]
10881 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10882 where
10883 D: serde::Deserializer<'de>,
10884 {
10885 const FIELDS: &[&str] = &[
10886 "column_names",
10887 "columnNames",
10888 ];
10889
10890 #[allow(clippy::enum_variant_names)]
10891 enum GeneratedField {
10892 ColumnNames,
10893 }
10894 impl<'de> serde::Deserialize<'de> for GeneratedField {
10895 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10896 where
10897 D: serde::Deserializer<'de>,
10898 {
10899 struct GeneratedVisitor;
10900
10901 impl serde::de::Visitor<'_> for GeneratedVisitor {
10902 type Value = GeneratedField;
10903
10904 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10905 write!(formatter, "expected one of: {:?}", &FIELDS)
10906 }
10907
10908 #[allow(unused_variables)]
10909 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10910 where
10911 E: serde::de::Error,
10912 {
10913 match value {
10914 "columnNames" | "column_names" => Ok(GeneratedField::ColumnNames),
10915 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10916 }
10917 }
10918 }
10919 deserializer.deserialize_identifier(GeneratedVisitor)
10920 }
10921 }
10922 struct GeneratedVisitor;
10923 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10924 type Value = SinkDropColumnsOp;
10925
10926 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10927 formatter.write_str("struct stream_plan.SinkDropColumnsOp")
10928 }
10929
10930 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDropColumnsOp, V::Error>
10931 where
10932 V: serde::de::MapAccess<'de>,
10933 {
10934 let mut column_names__ = None;
10935 while let Some(k) = map_.next_key()? {
10936 match k {
10937 GeneratedField::ColumnNames => {
10938 if column_names__.is_some() {
10939 return Err(serde::de::Error::duplicate_field("columnNames"));
10940 }
10941 column_names__ = Some(map_.next_value()?);
10942 }
10943 }
10944 }
10945 Ok(SinkDropColumnsOp {
10946 column_names: column_names__.unwrap_or_default(),
10947 })
10948 }
10949 }
10950 deserializer.deserialize_struct("stream_plan.SinkDropColumnsOp", FIELDS, GeneratedVisitor)
10951 }
10952}
10953impl serde::Serialize for SinkLogStoreType {
10954 #[allow(deprecated)]
10955 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10956 where
10957 S: serde::Serializer,
10958 {
10959 let variant = match self {
10960 Self::Unspecified => "SINK_LOG_STORE_TYPE_UNSPECIFIED",
10961 Self::KvLogStore => "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
10962 Self::InMemoryLogStore => "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
10963 };
10964 serializer.serialize_str(variant)
10965 }
10966}
10967impl<'de> serde::Deserialize<'de> for SinkLogStoreType {
10968 #[allow(deprecated)]
10969 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10970 where
10971 D: serde::Deserializer<'de>,
10972 {
10973 const FIELDS: &[&str] = &[
10974 "SINK_LOG_STORE_TYPE_UNSPECIFIED",
10975 "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
10976 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
10977 ];
10978
10979 struct GeneratedVisitor;
10980
10981 impl serde::de::Visitor<'_> for GeneratedVisitor {
10982 type Value = SinkLogStoreType;
10983
10984 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10985 write!(formatter, "expected one of: {:?}", &FIELDS)
10986 }
10987
10988 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
10989 where
10990 E: serde::de::Error,
10991 {
10992 i32::try_from(v)
10993 .ok()
10994 .and_then(|x| x.try_into().ok())
10995 .ok_or_else(|| {
10996 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
10997 })
10998 }
10999
11000 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
11001 where
11002 E: serde::de::Error,
11003 {
11004 i32::try_from(v)
11005 .ok()
11006 .and_then(|x| x.try_into().ok())
11007 .ok_or_else(|| {
11008 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
11009 })
11010 }
11011
11012 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
11013 where
11014 E: serde::de::Error,
11015 {
11016 match value {
11017 "SINK_LOG_STORE_TYPE_UNSPECIFIED" => Ok(SinkLogStoreType::Unspecified),
11018 "SINK_LOG_STORE_TYPE_KV_LOG_STORE" => Ok(SinkLogStoreType::KvLogStore),
11019 "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE" => Ok(SinkLogStoreType::InMemoryLogStore),
11020 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
11021 }
11022 }
11023 }
11024 deserializer.deserialize_any(GeneratedVisitor)
11025 }
11026}
11027impl serde::Serialize for SinkNode {
11028 #[allow(deprecated)]
11029 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11030 where
11031 S: serde::Serializer,
11032 {
11033 use serde::ser::SerializeStruct;
11034 let mut len = 0;
11035 if self.sink_desc.is_some() {
11036 len += 1;
11037 }
11038 if self.table.is_some() {
11039 len += 1;
11040 }
11041 if self.log_store_type != 0 {
11042 len += 1;
11043 }
11044 if self.rate_limit.is_some() {
11045 len += 1;
11046 }
11047 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkNode", len)?;
11048 if let Some(v) = self.sink_desc.as_ref() {
11049 struct_ser.serialize_field("sinkDesc", v)?;
11050 }
11051 if let Some(v) = self.table.as_ref() {
11052 struct_ser.serialize_field("table", v)?;
11053 }
11054 if self.log_store_type != 0 {
11055 let v = SinkLogStoreType::try_from(self.log_store_type)
11056 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.log_store_type)))?;
11057 struct_ser.serialize_field("logStoreType", &v)?;
11058 }
11059 if let Some(v) = self.rate_limit.as_ref() {
11060 struct_ser.serialize_field("rateLimit", v)?;
11061 }
11062 struct_ser.end()
11063 }
11064}
11065impl<'de> serde::Deserialize<'de> for SinkNode {
11066 #[allow(deprecated)]
11067 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11068 where
11069 D: serde::Deserializer<'de>,
11070 {
11071 const FIELDS: &[&str] = &[
11072 "sink_desc",
11073 "sinkDesc",
11074 "table",
11075 "log_store_type",
11076 "logStoreType",
11077 "rate_limit",
11078 "rateLimit",
11079 ];
11080
11081 #[allow(clippy::enum_variant_names)]
11082 enum GeneratedField {
11083 SinkDesc,
11084 Table,
11085 LogStoreType,
11086 RateLimit,
11087 }
11088 impl<'de> serde::Deserialize<'de> for GeneratedField {
11089 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11090 where
11091 D: serde::Deserializer<'de>,
11092 {
11093 struct GeneratedVisitor;
11094
11095 impl serde::de::Visitor<'_> for GeneratedVisitor {
11096 type Value = GeneratedField;
11097
11098 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11099 write!(formatter, "expected one of: {:?}", &FIELDS)
11100 }
11101
11102 #[allow(unused_variables)]
11103 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11104 where
11105 E: serde::de::Error,
11106 {
11107 match value {
11108 "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
11109 "table" => Ok(GeneratedField::Table),
11110 "logStoreType" | "log_store_type" => Ok(GeneratedField::LogStoreType),
11111 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11112 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11113 }
11114 }
11115 }
11116 deserializer.deserialize_identifier(GeneratedVisitor)
11117 }
11118 }
11119 struct GeneratedVisitor;
11120 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11121 type Value = SinkNode;
11122
11123 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11124 formatter.write_str("struct stream_plan.SinkNode")
11125 }
11126
11127 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkNode, V::Error>
11128 where
11129 V: serde::de::MapAccess<'de>,
11130 {
11131 let mut sink_desc__ = None;
11132 let mut table__ = None;
11133 let mut log_store_type__ = None;
11134 let mut rate_limit__ = None;
11135 while let Some(k) = map_.next_key()? {
11136 match k {
11137 GeneratedField::SinkDesc => {
11138 if sink_desc__.is_some() {
11139 return Err(serde::de::Error::duplicate_field("sinkDesc"));
11140 }
11141 sink_desc__ = map_.next_value()?;
11142 }
11143 GeneratedField::Table => {
11144 if table__.is_some() {
11145 return Err(serde::de::Error::duplicate_field("table"));
11146 }
11147 table__ = map_.next_value()?;
11148 }
11149 GeneratedField::LogStoreType => {
11150 if log_store_type__.is_some() {
11151 return Err(serde::de::Error::duplicate_field("logStoreType"));
11152 }
11153 log_store_type__ = Some(map_.next_value::<SinkLogStoreType>()? as i32);
11154 }
11155 GeneratedField::RateLimit => {
11156 if rate_limit__.is_some() {
11157 return Err(serde::de::Error::duplicate_field("rateLimit"));
11158 }
11159 rate_limit__ =
11160 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11161 ;
11162 }
11163 }
11164 }
11165 Ok(SinkNode {
11166 sink_desc: sink_desc__,
11167 table: table__,
11168 log_store_type: log_store_type__.unwrap_or_default(),
11169 rate_limit: rate_limit__,
11170 })
11171 }
11172 }
11173 deserializer.deserialize_struct("stream_plan.SinkNode", FIELDS, GeneratedVisitor)
11174 }
11175}
11176impl serde::Serialize for SinkSchemaChange {
11177 #[allow(deprecated)]
11178 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11179 where
11180 S: serde::Serializer,
11181 {
11182 use serde::ser::SerializeStruct;
11183 let mut len = 0;
11184 if !self.original_schema.is_empty() {
11185 len += 1;
11186 }
11187 if self.op.is_some() {
11188 len += 1;
11189 }
11190 let mut struct_ser = serializer.serialize_struct("stream_plan.SinkSchemaChange", len)?;
11191 if !self.original_schema.is_empty() {
11192 struct_ser.serialize_field("originalSchema", &self.original_schema)?;
11193 }
11194 if let Some(v) = self.op.as_ref() {
11195 match v {
11196 sink_schema_change::Op::AddColumns(v) => {
11197 struct_ser.serialize_field("addColumns", v)?;
11198 }
11199 sink_schema_change::Op::DropColumns(v) => {
11200 struct_ser.serialize_field("dropColumns", v)?;
11201 }
11202 }
11203 }
11204 struct_ser.end()
11205 }
11206}
11207impl<'de> serde::Deserialize<'de> for SinkSchemaChange {
11208 #[allow(deprecated)]
11209 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11210 where
11211 D: serde::Deserializer<'de>,
11212 {
11213 const FIELDS: &[&str] = &[
11214 "original_schema",
11215 "originalSchema",
11216 "add_columns",
11217 "addColumns",
11218 "drop_columns",
11219 "dropColumns",
11220 ];
11221
11222 #[allow(clippy::enum_variant_names)]
11223 enum GeneratedField {
11224 OriginalSchema,
11225 AddColumns,
11226 DropColumns,
11227 }
11228 impl<'de> serde::Deserialize<'de> for GeneratedField {
11229 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11230 where
11231 D: serde::Deserializer<'de>,
11232 {
11233 struct GeneratedVisitor;
11234
11235 impl serde::de::Visitor<'_> for GeneratedVisitor {
11236 type Value = GeneratedField;
11237
11238 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11239 write!(formatter, "expected one of: {:?}", &FIELDS)
11240 }
11241
11242 #[allow(unused_variables)]
11243 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11244 where
11245 E: serde::de::Error,
11246 {
11247 match value {
11248 "originalSchema" | "original_schema" => Ok(GeneratedField::OriginalSchema),
11249 "addColumns" | "add_columns" => Ok(GeneratedField::AddColumns),
11250 "dropColumns" | "drop_columns" => Ok(GeneratedField::DropColumns),
11251 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11252 }
11253 }
11254 }
11255 deserializer.deserialize_identifier(GeneratedVisitor)
11256 }
11257 }
11258 struct GeneratedVisitor;
11259 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11260 type Value = SinkSchemaChange;
11261
11262 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11263 formatter.write_str("struct stream_plan.SinkSchemaChange")
11264 }
11265
11266 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkSchemaChange, V::Error>
11267 where
11268 V: serde::de::MapAccess<'de>,
11269 {
11270 let mut original_schema__ = None;
11271 let mut op__ = None;
11272 while let Some(k) = map_.next_key()? {
11273 match k {
11274 GeneratedField::OriginalSchema => {
11275 if original_schema__.is_some() {
11276 return Err(serde::de::Error::duplicate_field("originalSchema"));
11277 }
11278 original_schema__ = Some(map_.next_value()?);
11279 }
11280 GeneratedField::AddColumns => {
11281 if op__.is_some() {
11282 return Err(serde::de::Error::duplicate_field("addColumns"));
11283 }
11284 op__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_schema_change::Op::AddColumns)
11285;
11286 }
11287 GeneratedField::DropColumns => {
11288 if op__.is_some() {
11289 return Err(serde::de::Error::duplicate_field("dropColumns"));
11290 }
11291 op__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_schema_change::Op::DropColumns)
11292;
11293 }
11294 }
11295 }
11296 Ok(SinkSchemaChange {
11297 original_schema: original_schema__.unwrap_or_default(),
11298 op: op__,
11299 })
11300 }
11301 }
11302 deserializer.deserialize_struct("stream_plan.SinkSchemaChange", FIELDS, GeneratedVisitor)
11303 }
11304}
11305impl serde::Serialize for SortNode {
11306 #[allow(deprecated)]
11307 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11308 where
11309 S: serde::Serializer,
11310 {
11311 use serde::ser::SerializeStruct;
11312 let mut len = 0;
11313 if self.state_table.is_some() {
11314 len += 1;
11315 }
11316 if self.sort_column_index != 0 {
11317 len += 1;
11318 }
11319 let mut struct_ser = serializer.serialize_struct("stream_plan.SortNode", len)?;
11320 if let Some(v) = self.state_table.as_ref() {
11321 struct_ser.serialize_field("stateTable", v)?;
11322 }
11323 if self.sort_column_index != 0 {
11324 struct_ser.serialize_field("sortColumnIndex", &self.sort_column_index)?;
11325 }
11326 struct_ser.end()
11327 }
11328}
11329impl<'de> serde::Deserialize<'de> for SortNode {
11330 #[allow(deprecated)]
11331 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11332 where
11333 D: serde::Deserializer<'de>,
11334 {
11335 const FIELDS: &[&str] = &[
11336 "state_table",
11337 "stateTable",
11338 "sort_column_index",
11339 "sortColumnIndex",
11340 ];
11341
11342 #[allow(clippy::enum_variant_names)]
11343 enum GeneratedField {
11344 StateTable,
11345 SortColumnIndex,
11346 }
11347 impl<'de> serde::Deserialize<'de> for GeneratedField {
11348 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11349 where
11350 D: serde::Deserializer<'de>,
11351 {
11352 struct GeneratedVisitor;
11353
11354 impl serde::de::Visitor<'_> for GeneratedVisitor {
11355 type Value = GeneratedField;
11356
11357 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11358 write!(formatter, "expected one of: {:?}", &FIELDS)
11359 }
11360
11361 #[allow(unused_variables)]
11362 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11363 where
11364 E: serde::de::Error,
11365 {
11366 match value {
11367 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11368 "sortColumnIndex" | "sort_column_index" => Ok(GeneratedField::SortColumnIndex),
11369 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11370 }
11371 }
11372 }
11373 deserializer.deserialize_identifier(GeneratedVisitor)
11374 }
11375 }
11376 struct GeneratedVisitor;
11377 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11378 type Value = SortNode;
11379
11380 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11381 formatter.write_str("struct stream_plan.SortNode")
11382 }
11383
11384 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
11385 where
11386 V: serde::de::MapAccess<'de>,
11387 {
11388 let mut state_table__ = None;
11389 let mut sort_column_index__ = None;
11390 while let Some(k) = map_.next_key()? {
11391 match k {
11392 GeneratedField::StateTable => {
11393 if state_table__.is_some() {
11394 return Err(serde::de::Error::duplicate_field("stateTable"));
11395 }
11396 state_table__ = map_.next_value()?;
11397 }
11398 GeneratedField::SortColumnIndex => {
11399 if sort_column_index__.is_some() {
11400 return Err(serde::de::Error::duplicate_field("sortColumnIndex"));
11401 }
11402 sort_column_index__ =
11403 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11404 ;
11405 }
11406 }
11407 }
11408 Ok(SortNode {
11409 state_table: state_table__,
11410 sort_column_index: sort_column_index__.unwrap_or_default(),
11411 })
11412 }
11413 }
11414 deserializer.deserialize_struct("stream_plan.SortNode", FIELDS, GeneratedVisitor)
11415 }
11416}
11417impl serde::Serialize for SourceBackfillNode {
11418 #[allow(deprecated)]
11419 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11420 where
11421 S: serde::Serializer,
11422 {
11423 use serde::ser::SerializeStruct;
11424 let mut len = 0;
11425 if self.upstream_source_id != 0 {
11426 len += 1;
11427 }
11428 if self.row_id_index.is_some() {
11429 len += 1;
11430 }
11431 if !self.columns.is_empty() {
11432 len += 1;
11433 }
11434 if self.info.is_some() {
11435 len += 1;
11436 }
11437 if !self.source_name.is_empty() {
11438 len += 1;
11439 }
11440 if !self.with_properties.is_empty() {
11441 len += 1;
11442 }
11443 if self.rate_limit.is_some() {
11444 len += 1;
11445 }
11446 if self.state_table.is_some() {
11447 len += 1;
11448 }
11449 if !self.secret_refs.is_empty() {
11450 len += 1;
11451 }
11452 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceBackfillNode", len)?;
11453 if self.upstream_source_id != 0 {
11454 struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
11455 }
11456 if let Some(v) = self.row_id_index.as_ref() {
11457 struct_ser.serialize_field("rowIdIndex", v)?;
11458 }
11459 if !self.columns.is_empty() {
11460 struct_ser.serialize_field("columns", &self.columns)?;
11461 }
11462 if let Some(v) = self.info.as_ref() {
11463 struct_ser.serialize_field("info", v)?;
11464 }
11465 if !self.source_name.is_empty() {
11466 struct_ser.serialize_field("sourceName", &self.source_name)?;
11467 }
11468 if !self.with_properties.is_empty() {
11469 struct_ser.serialize_field("withProperties", &self.with_properties)?;
11470 }
11471 if let Some(v) = self.rate_limit.as_ref() {
11472 struct_ser.serialize_field("rateLimit", v)?;
11473 }
11474 if let Some(v) = self.state_table.as_ref() {
11475 struct_ser.serialize_field("stateTable", v)?;
11476 }
11477 if !self.secret_refs.is_empty() {
11478 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
11479 }
11480 struct_ser.end()
11481 }
11482}
11483impl<'de> serde::Deserialize<'de> for SourceBackfillNode {
11484 #[allow(deprecated)]
11485 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11486 where
11487 D: serde::Deserializer<'de>,
11488 {
11489 const FIELDS: &[&str] = &[
11490 "upstream_source_id",
11491 "upstreamSourceId",
11492 "row_id_index",
11493 "rowIdIndex",
11494 "columns",
11495 "info",
11496 "source_name",
11497 "sourceName",
11498 "with_properties",
11499 "withProperties",
11500 "rate_limit",
11501 "rateLimit",
11502 "state_table",
11503 "stateTable",
11504 "secret_refs",
11505 "secretRefs",
11506 ];
11507
11508 #[allow(clippy::enum_variant_names)]
11509 enum GeneratedField {
11510 UpstreamSourceId,
11511 RowIdIndex,
11512 Columns,
11513 Info,
11514 SourceName,
11515 WithProperties,
11516 RateLimit,
11517 StateTable,
11518 SecretRefs,
11519 }
11520 impl<'de> serde::Deserialize<'de> for GeneratedField {
11521 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11522 where
11523 D: serde::Deserializer<'de>,
11524 {
11525 struct GeneratedVisitor;
11526
11527 impl serde::de::Visitor<'_> for GeneratedVisitor {
11528 type Value = GeneratedField;
11529
11530 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11531 write!(formatter, "expected one of: {:?}", &FIELDS)
11532 }
11533
11534 #[allow(unused_variables)]
11535 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11536 where
11537 E: serde::de::Error,
11538 {
11539 match value {
11540 "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
11541 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
11542 "columns" => Ok(GeneratedField::Columns),
11543 "info" => Ok(GeneratedField::Info),
11544 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
11545 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
11546 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11547 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11548 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
11549 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11550 }
11551 }
11552 }
11553 deserializer.deserialize_identifier(GeneratedVisitor)
11554 }
11555 }
11556 struct GeneratedVisitor;
11557 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11558 type Value = SourceBackfillNode;
11559
11560 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11561 formatter.write_str("struct stream_plan.SourceBackfillNode")
11562 }
11563
11564 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceBackfillNode, V::Error>
11565 where
11566 V: serde::de::MapAccess<'de>,
11567 {
11568 let mut upstream_source_id__ = None;
11569 let mut row_id_index__ = None;
11570 let mut columns__ = None;
11571 let mut info__ = None;
11572 let mut source_name__ = None;
11573 let mut with_properties__ = None;
11574 let mut rate_limit__ = None;
11575 let mut state_table__ = None;
11576 let mut secret_refs__ = None;
11577 while let Some(k) = map_.next_key()? {
11578 match k {
11579 GeneratedField::UpstreamSourceId => {
11580 if upstream_source_id__.is_some() {
11581 return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
11582 }
11583 upstream_source_id__ =
11584 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11585 ;
11586 }
11587 GeneratedField::RowIdIndex => {
11588 if row_id_index__.is_some() {
11589 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
11590 }
11591 row_id_index__ =
11592 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11593 ;
11594 }
11595 GeneratedField::Columns => {
11596 if columns__.is_some() {
11597 return Err(serde::de::Error::duplicate_field("columns"));
11598 }
11599 columns__ = Some(map_.next_value()?);
11600 }
11601 GeneratedField::Info => {
11602 if info__.is_some() {
11603 return Err(serde::de::Error::duplicate_field("info"));
11604 }
11605 info__ = map_.next_value()?;
11606 }
11607 GeneratedField::SourceName => {
11608 if source_name__.is_some() {
11609 return Err(serde::de::Error::duplicate_field("sourceName"));
11610 }
11611 source_name__ = Some(map_.next_value()?);
11612 }
11613 GeneratedField::WithProperties => {
11614 if with_properties__.is_some() {
11615 return Err(serde::de::Error::duplicate_field("withProperties"));
11616 }
11617 with_properties__ = Some(
11618 map_.next_value::<std::collections::BTreeMap<_, _>>()?
11619 );
11620 }
11621 GeneratedField::RateLimit => {
11622 if rate_limit__.is_some() {
11623 return Err(serde::de::Error::duplicate_field("rateLimit"));
11624 }
11625 rate_limit__ =
11626 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11627 ;
11628 }
11629 GeneratedField::StateTable => {
11630 if state_table__.is_some() {
11631 return Err(serde::de::Error::duplicate_field("stateTable"));
11632 }
11633 state_table__ = map_.next_value()?;
11634 }
11635 GeneratedField::SecretRefs => {
11636 if secret_refs__.is_some() {
11637 return Err(serde::de::Error::duplicate_field("secretRefs"));
11638 }
11639 secret_refs__ = Some(
11640 map_.next_value::<std::collections::BTreeMap<_, _>>()?
11641 );
11642 }
11643 }
11644 }
11645 Ok(SourceBackfillNode {
11646 upstream_source_id: upstream_source_id__.unwrap_or_default(),
11647 row_id_index: row_id_index__,
11648 columns: columns__.unwrap_or_default(),
11649 info: info__,
11650 source_name: source_name__.unwrap_or_default(),
11651 with_properties: with_properties__.unwrap_or_default(),
11652 rate_limit: rate_limit__,
11653 state_table: state_table__,
11654 secret_refs: secret_refs__.unwrap_or_default(),
11655 })
11656 }
11657 }
11658 deserializer.deserialize_struct("stream_plan.SourceBackfillNode", FIELDS, GeneratedVisitor)
11659 }
11660}
11661impl serde::Serialize for SourceChangeSplitMutation {
11662 #[allow(deprecated)]
11663 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11664 where
11665 S: serde::Serializer,
11666 {
11667 use serde::ser::SerializeStruct;
11668 let mut len = 0;
11669 if !self.actor_splits.is_empty() {
11670 len += 1;
11671 }
11672 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceChangeSplitMutation", len)?;
11673 if !self.actor_splits.is_empty() {
11674 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
11675 }
11676 struct_ser.end()
11677 }
11678}
11679impl<'de> serde::Deserialize<'de> for SourceChangeSplitMutation {
11680 #[allow(deprecated)]
11681 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11682 where
11683 D: serde::Deserializer<'de>,
11684 {
11685 const FIELDS: &[&str] = &[
11686 "actor_splits",
11687 "actorSplits",
11688 ];
11689
11690 #[allow(clippy::enum_variant_names)]
11691 enum GeneratedField {
11692 ActorSplits,
11693 }
11694 impl<'de> serde::Deserialize<'de> for GeneratedField {
11695 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11696 where
11697 D: serde::Deserializer<'de>,
11698 {
11699 struct GeneratedVisitor;
11700
11701 impl serde::de::Visitor<'_> for GeneratedVisitor {
11702 type Value = GeneratedField;
11703
11704 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11705 write!(formatter, "expected one of: {:?}", &FIELDS)
11706 }
11707
11708 #[allow(unused_variables)]
11709 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11710 where
11711 E: serde::de::Error,
11712 {
11713 match value {
11714 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
11715 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11716 }
11717 }
11718 }
11719 deserializer.deserialize_identifier(GeneratedVisitor)
11720 }
11721 }
11722 struct GeneratedVisitor;
11723 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11724 type Value = SourceChangeSplitMutation;
11725
11726 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11727 formatter.write_str("struct stream_plan.SourceChangeSplitMutation")
11728 }
11729
11730 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceChangeSplitMutation, V::Error>
11731 where
11732 V: serde::de::MapAccess<'de>,
11733 {
11734 let mut actor_splits__ = None;
11735 while let Some(k) = map_.next_key()? {
11736 match k {
11737 GeneratedField::ActorSplits => {
11738 if actor_splits__.is_some() {
11739 return Err(serde::de::Error::duplicate_field("actorSplits"));
11740 }
11741 actor_splits__ = Some(
11742 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11743 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
11744 );
11745 }
11746 }
11747 }
11748 Ok(SourceChangeSplitMutation {
11749 actor_splits: actor_splits__.unwrap_or_default(),
11750 })
11751 }
11752 }
11753 deserializer.deserialize_struct("stream_plan.SourceChangeSplitMutation", FIELDS, GeneratedVisitor)
11754 }
11755}
11756impl serde::Serialize for SourceNode {
11757 #[allow(deprecated)]
11758 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11759 where
11760 S: serde::Serializer,
11761 {
11762 use serde::ser::SerializeStruct;
11763 let mut len = 0;
11764 if self.source_inner.is_some() {
11765 len += 1;
11766 }
11767 let mut struct_ser = serializer.serialize_struct("stream_plan.SourceNode", len)?;
11768 if let Some(v) = self.source_inner.as_ref() {
11769 struct_ser.serialize_field("sourceInner", v)?;
11770 }
11771 struct_ser.end()
11772 }
11773}
11774impl<'de> serde::Deserialize<'de> for SourceNode {
11775 #[allow(deprecated)]
11776 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11777 where
11778 D: serde::Deserializer<'de>,
11779 {
11780 const FIELDS: &[&str] = &[
11781 "source_inner",
11782 "sourceInner",
11783 ];
11784
11785 #[allow(clippy::enum_variant_names)]
11786 enum GeneratedField {
11787 SourceInner,
11788 }
11789 impl<'de> serde::Deserialize<'de> for GeneratedField {
11790 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11791 where
11792 D: serde::Deserializer<'de>,
11793 {
11794 struct GeneratedVisitor;
11795
11796 impl serde::de::Visitor<'_> for GeneratedVisitor {
11797 type Value = GeneratedField;
11798
11799 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11800 write!(formatter, "expected one of: {:?}", &FIELDS)
11801 }
11802
11803 #[allow(unused_variables)]
11804 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11805 where
11806 E: serde::de::Error,
11807 {
11808 match value {
11809 "sourceInner" | "source_inner" => Ok(GeneratedField::SourceInner),
11810 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11811 }
11812 }
11813 }
11814 deserializer.deserialize_identifier(GeneratedVisitor)
11815 }
11816 }
11817 struct GeneratedVisitor;
11818 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11819 type Value = SourceNode;
11820
11821 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11822 formatter.write_str("struct stream_plan.SourceNode")
11823 }
11824
11825 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
11826 where
11827 V: serde::de::MapAccess<'de>,
11828 {
11829 let mut source_inner__ = None;
11830 while let Some(k) = map_.next_key()? {
11831 match k {
11832 GeneratedField::SourceInner => {
11833 if source_inner__.is_some() {
11834 return Err(serde::de::Error::duplicate_field("sourceInner"));
11835 }
11836 source_inner__ = map_.next_value()?;
11837 }
11838 }
11839 }
11840 Ok(SourceNode {
11841 source_inner: source_inner__,
11842 })
11843 }
11844 }
11845 deserializer.deserialize_struct("stream_plan.SourceNode", FIELDS, GeneratedVisitor)
11846 }
11847}
11848impl serde::Serialize for StartFragmentBackfillMutation {
11849 #[allow(deprecated)]
11850 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11851 where
11852 S: serde::Serializer,
11853 {
11854 use serde::ser::SerializeStruct;
11855 let mut len = 0;
11856 if !self.fragment_ids.is_empty() {
11857 len += 1;
11858 }
11859 let mut struct_ser = serializer.serialize_struct("stream_plan.StartFragmentBackfillMutation", len)?;
11860 if !self.fragment_ids.is_empty() {
11861 struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
11862 }
11863 struct_ser.end()
11864 }
11865}
11866impl<'de> serde::Deserialize<'de> for StartFragmentBackfillMutation {
11867 #[allow(deprecated)]
11868 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11869 where
11870 D: serde::Deserializer<'de>,
11871 {
11872 const FIELDS: &[&str] = &[
11873 "fragment_ids",
11874 "fragmentIds",
11875 ];
11876
11877 #[allow(clippy::enum_variant_names)]
11878 enum GeneratedField {
11879 FragmentIds,
11880 }
11881 impl<'de> serde::Deserialize<'de> for GeneratedField {
11882 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11883 where
11884 D: serde::Deserializer<'de>,
11885 {
11886 struct GeneratedVisitor;
11887
11888 impl serde::de::Visitor<'_> for GeneratedVisitor {
11889 type Value = GeneratedField;
11890
11891 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11892 write!(formatter, "expected one of: {:?}", &FIELDS)
11893 }
11894
11895 #[allow(unused_variables)]
11896 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11897 where
11898 E: serde::de::Error,
11899 {
11900 match value {
11901 "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
11902 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11903 }
11904 }
11905 }
11906 deserializer.deserialize_identifier(GeneratedVisitor)
11907 }
11908 }
11909 struct GeneratedVisitor;
11910 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11911 type Value = StartFragmentBackfillMutation;
11912
11913 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11914 formatter.write_str("struct stream_plan.StartFragmentBackfillMutation")
11915 }
11916
11917 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StartFragmentBackfillMutation, V::Error>
11918 where
11919 V: serde::de::MapAccess<'de>,
11920 {
11921 let mut fragment_ids__ = None;
11922 while let Some(k) = map_.next_key()? {
11923 match k {
11924 GeneratedField::FragmentIds => {
11925 if fragment_ids__.is_some() {
11926 return Err(serde::de::Error::duplicate_field("fragmentIds"));
11927 }
11928 fragment_ids__ =
11929 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11930 .into_iter().map(|x| x.0).collect())
11931 ;
11932 }
11933 }
11934 }
11935 Ok(StartFragmentBackfillMutation {
11936 fragment_ids: fragment_ids__.unwrap_or_default(),
11937 })
11938 }
11939 }
11940 deserializer.deserialize_struct("stream_plan.StartFragmentBackfillMutation", FIELDS, GeneratedVisitor)
11941 }
11942}
11943impl serde::Serialize for StopMutation {
11944 #[allow(deprecated)]
11945 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11946 where
11947 S: serde::Serializer,
11948 {
11949 use serde::ser::SerializeStruct;
11950 let mut len = 0;
11951 if !self.actors.is_empty() {
11952 len += 1;
11953 }
11954 if !self.dropped_sink_fragments.is_empty() {
11955 len += 1;
11956 }
11957 let mut struct_ser = serializer.serialize_struct("stream_plan.StopMutation", len)?;
11958 if !self.actors.is_empty() {
11959 struct_ser.serialize_field("actors", &self.actors)?;
11960 }
11961 if !self.dropped_sink_fragments.is_empty() {
11962 struct_ser.serialize_field("droppedSinkFragments", &self.dropped_sink_fragments)?;
11963 }
11964 struct_ser.end()
11965 }
11966}
11967impl<'de> serde::Deserialize<'de> for StopMutation {
11968 #[allow(deprecated)]
11969 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11970 where
11971 D: serde::Deserializer<'de>,
11972 {
11973 const FIELDS: &[&str] = &[
11974 "actors",
11975 "dropped_sink_fragments",
11976 "droppedSinkFragments",
11977 ];
11978
11979 #[allow(clippy::enum_variant_names)]
11980 enum GeneratedField {
11981 Actors,
11982 DroppedSinkFragments,
11983 }
11984 impl<'de> serde::Deserialize<'de> for GeneratedField {
11985 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11986 where
11987 D: serde::Deserializer<'de>,
11988 {
11989 struct GeneratedVisitor;
11990
11991 impl serde::de::Visitor<'_> for GeneratedVisitor {
11992 type Value = GeneratedField;
11993
11994 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11995 write!(formatter, "expected one of: {:?}", &FIELDS)
11996 }
11997
11998 #[allow(unused_variables)]
11999 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12000 where
12001 E: serde::de::Error,
12002 {
12003 match value {
12004 "actors" => Ok(GeneratedField::Actors),
12005 "droppedSinkFragments" | "dropped_sink_fragments" => Ok(GeneratedField::DroppedSinkFragments),
12006 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12007 }
12008 }
12009 }
12010 deserializer.deserialize_identifier(GeneratedVisitor)
12011 }
12012 }
12013 struct GeneratedVisitor;
12014 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12015 type Value = StopMutation;
12016
12017 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12018 formatter.write_str("struct stream_plan.StopMutation")
12019 }
12020
12021 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopMutation, V::Error>
12022 where
12023 V: serde::de::MapAccess<'de>,
12024 {
12025 let mut actors__ = None;
12026 let mut dropped_sink_fragments__ = None;
12027 while let Some(k) = map_.next_key()? {
12028 match k {
12029 GeneratedField::Actors => {
12030 if actors__.is_some() {
12031 return Err(serde::de::Error::duplicate_field("actors"));
12032 }
12033 actors__ =
12034 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12035 .into_iter().map(|x| x.0).collect())
12036 ;
12037 }
12038 GeneratedField::DroppedSinkFragments => {
12039 if dropped_sink_fragments__.is_some() {
12040 return Err(serde::de::Error::duplicate_field("droppedSinkFragments"));
12041 }
12042 dropped_sink_fragments__ =
12043 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12044 .into_iter().map(|x| x.0).collect())
12045 ;
12046 }
12047 }
12048 }
12049 Ok(StopMutation {
12050 actors: actors__.unwrap_or_default(),
12051 dropped_sink_fragments: dropped_sink_fragments__.unwrap_or_default(),
12052 })
12053 }
12054 }
12055 deserializer.deserialize_struct("stream_plan.StopMutation", FIELDS, GeneratedVisitor)
12056 }
12057}
12058impl serde::Serialize for StreamActor {
12059 #[allow(deprecated)]
12060 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12061 where
12062 S: serde::Serializer,
12063 {
12064 use serde::ser::SerializeStruct;
12065 let mut len = 0;
12066 if self.actor_id != 0 {
12067 len += 1;
12068 }
12069 if self.fragment_id != 0 {
12070 len += 1;
12071 }
12072 if !self.dispatcher.is_empty() {
12073 len += 1;
12074 }
12075 if self.vnode_bitmap.is_some() {
12076 len += 1;
12077 }
12078 if !self.mview_definition.is_empty() {
12079 len += 1;
12080 }
12081 if self.expr_context.is_some() {
12082 len += 1;
12083 }
12084 if !self.config_override.is_empty() {
12085 len += 1;
12086 }
12087 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamActor", len)?;
12088 if self.actor_id != 0 {
12089 struct_ser.serialize_field("actorId", &self.actor_id)?;
12090 }
12091 if self.fragment_id != 0 {
12092 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
12093 }
12094 if !self.dispatcher.is_empty() {
12095 struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
12096 }
12097 if let Some(v) = self.vnode_bitmap.as_ref() {
12098 struct_ser.serialize_field("vnodeBitmap", v)?;
12099 }
12100 if !self.mview_definition.is_empty() {
12101 struct_ser.serialize_field("mviewDefinition", &self.mview_definition)?;
12102 }
12103 if let Some(v) = self.expr_context.as_ref() {
12104 struct_ser.serialize_field("exprContext", v)?;
12105 }
12106 if !self.config_override.is_empty() {
12107 struct_ser.serialize_field("configOverride", &self.config_override)?;
12108 }
12109 struct_ser.end()
12110 }
12111}
12112impl<'de> serde::Deserialize<'de> for StreamActor {
12113 #[allow(deprecated)]
12114 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12115 where
12116 D: serde::Deserializer<'de>,
12117 {
12118 const FIELDS: &[&str] = &[
12119 "actor_id",
12120 "actorId",
12121 "fragment_id",
12122 "fragmentId",
12123 "dispatcher",
12124 "vnode_bitmap",
12125 "vnodeBitmap",
12126 "mview_definition",
12127 "mviewDefinition",
12128 "expr_context",
12129 "exprContext",
12130 "config_override",
12131 "configOverride",
12132 ];
12133
12134 #[allow(clippy::enum_variant_names)]
12135 enum GeneratedField {
12136 ActorId,
12137 FragmentId,
12138 Dispatcher,
12139 VnodeBitmap,
12140 MviewDefinition,
12141 ExprContext,
12142 ConfigOverride,
12143 }
12144 impl<'de> serde::Deserialize<'de> for GeneratedField {
12145 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12146 where
12147 D: serde::Deserializer<'de>,
12148 {
12149 struct GeneratedVisitor;
12150
12151 impl serde::de::Visitor<'_> for GeneratedVisitor {
12152 type Value = GeneratedField;
12153
12154 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12155 write!(formatter, "expected one of: {:?}", &FIELDS)
12156 }
12157
12158 #[allow(unused_variables)]
12159 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12160 where
12161 E: serde::de::Error,
12162 {
12163 match value {
12164 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
12165 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
12166 "dispatcher" => Ok(GeneratedField::Dispatcher),
12167 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
12168 "mviewDefinition" | "mview_definition" => Ok(GeneratedField::MviewDefinition),
12169 "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
12170 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
12171 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12172 }
12173 }
12174 }
12175 deserializer.deserialize_identifier(GeneratedVisitor)
12176 }
12177 }
12178 struct GeneratedVisitor;
12179 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12180 type Value = StreamActor;
12181
12182 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12183 formatter.write_str("struct stream_plan.StreamActor")
12184 }
12185
12186 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamActor, V::Error>
12187 where
12188 V: serde::de::MapAccess<'de>,
12189 {
12190 let mut actor_id__ = None;
12191 let mut fragment_id__ = None;
12192 let mut dispatcher__ = None;
12193 let mut vnode_bitmap__ = None;
12194 let mut mview_definition__ = None;
12195 let mut expr_context__ = None;
12196 let mut config_override__ = None;
12197 while let Some(k) = map_.next_key()? {
12198 match k {
12199 GeneratedField::ActorId => {
12200 if actor_id__.is_some() {
12201 return Err(serde::de::Error::duplicate_field("actorId"));
12202 }
12203 actor_id__ =
12204 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12205 ;
12206 }
12207 GeneratedField::FragmentId => {
12208 if fragment_id__.is_some() {
12209 return Err(serde::de::Error::duplicate_field("fragmentId"));
12210 }
12211 fragment_id__ =
12212 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12213 ;
12214 }
12215 GeneratedField::Dispatcher => {
12216 if dispatcher__.is_some() {
12217 return Err(serde::de::Error::duplicate_field("dispatcher"));
12218 }
12219 dispatcher__ = Some(map_.next_value()?);
12220 }
12221 GeneratedField::VnodeBitmap => {
12222 if vnode_bitmap__.is_some() {
12223 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
12224 }
12225 vnode_bitmap__ = map_.next_value()?;
12226 }
12227 GeneratedField::MviewDefinition => {
12228 if mview_definition__.is_some() {
12229 return Err(serde::de::Error::duplicate_field("mviewDefinition"));
12230 }
12231 mview_definition__ = Some(map_.next_value()?);
12232 }
12233 GeneratedField::ExprContext => {
12234 if expr_context__.is_some() {
12235 return Err(serde::de::Error::duplicate_field("exprContext"));
12236 }
12237 expr_context__ = map_.next_value()?;
12238 }
12239 GeneratedField::ConfigOverride => {
12240 if config_override__.is_some() {
12241 return Err(serde::de::Error::duplicate_field("configOverride"));
12242 }
12243 config_override__ = Some(map_.next_value()?);
12244 }
12245 }
12246 }
12247 Ok(StreamActor {
12248 actor_id: actor_id__.unwrap_or_default(),
12249 fragment_id: fragment_id__.unwrap_or_default(),
12250 dispatcher: dispatcher__.unwrap_or_default(),
12251 vnode_bitmap: vnode_bitmap__,
12252 mview_definition: mview_definition__.unwrap_or_default(),
12253 expr_context: expr_context__,
12254 config_override: config_override__.unwrap_or_default(),
12255 })
12256 }
12257 }
12258 deserializer.deserialize_struct("stream_plan.StreamActor", FIELDS, GeneratedVisitor)
12259 }
12260}
12261impl serde::Serialize for StreamCdcScanNode {
12262 #[allow(deprecated)]
12263 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12264 where
12265 S: serde::Serializer,
12266 {
12267 use serde::ser::SerializeStruct;
12268 let mut len = 0;
12269 if self.table_id != 0 {
12270 len += 1;
12271 }
12272 if !self.upstream_column_ids.is_empty() {
12273 len += 1;
12274 }
12275 if !self.output_indices.is_empty() {
12276 len += 1;
12277 }
12278 if self.state_table.is_some() {
12279 len += 1;
12280 }
12281 if self.cdc_table_desc.is_some() {
12282 len += 1;
12283 }
12284 if self.rate_limit.is_some() {
12285 len += 1;
12286 }
12287 if self.disable_backfill {
12288 len += 1;
12289 }
12290 if self.options.is_some() {
12291 len += 1;
12292 }
12293 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanNode", len)?;
12294 if self.table_id != 0 {
12295 struct_ser.serialize_field("tableId", &self.table_id)?;
12296 }
12297 if !self.upstream_column_ids.is_empty() {
12298 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
12299 }
12300 if !self.output_indices.is_empty() {
12301 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
12302 }
12303 if let Some(v) = self.state_table.as_ref() {
12304 struct_ser.serialize_field("stateTable", v)?;
12305 }
12306 if let Some(v) = self.cdc_table_desc.as_ref() {
12307 struct_ser.serialize_field("cdcTableDesc", v)?;
12308 }
12309 if let Some(v) = self.rate_limit.as_ref() {
12310 struct_ser.serialize_field("rateLimit", v)?;
12311 }
12312 if self.disable_backfill {
12313 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
12314 }
12315 if let Some(v) = self.options.as_ref() {
12316 struct_ser.serialize_field("options", v)?;
12317 }
12318 struct_ser.end()
12319 }
12320}
12321impl<'de> serde::Deserialize<'de> for StreamCdcScanNode {
12322 #[allow(deprecated)]
12323 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12324 where
12325 D: serde::Deserializer<'de>,
12326 {
12327 const FIELDS: &[&str] = &[
12328 "table_id",
12329 "tableId",
12330 "upstream_column_ids",
12331 "upstreamColumnIds",
12332 "output_indices",
12333 "outputIndices",
12334 "state_table",
12335 "stateTable",
12336 "cdc_table_desc",
12337 "cdcTableDesc",
12338 "rate_limit",
12339 "rateLimit",
12340 "disable_backfill",
12341 "disableBackfill",
12342 "options",
12343 ];
12344
12345 #[allow(clippy::enum_variant_names)]
12346 enum GeneratedField {
12347 TableId,
12348 UpstreamColumnIds,
12349 OutputIndices,
12350 StateTable,
12351 CdcTableDesc,
12352 RateLimit,
12353 DisableBackfill,
12354 Options,
12355 }
12356 impl<'de> serde::Deserialize<'de> for GeneratedField {
12357 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12358 where
12359 D: serde::Deserializer<'de>,
12360 {
12361 struct GeneratedVisitor;
12362
12363 impl serde::de::Visitor<'_> for GeneratedVisitor {
12364 type Value = GeneratedField;
12365
12366 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12367 write!(formatter, "expected one of: {:?}", &FIELDS)
12368 }
12369
12370 #[allow(unused_variables)]
12371 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12372 where
12373 E: serde::de::Error,
12374 {
12375 match value {
12376 "tableId" | "table_id" => Ok(GeneratedField::TableId),
12377 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
12378 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
12379 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
12380 "cdcTableDesc" | "cdc_table_desc" => Ok(GeneratedField::CdcTableDesc),
12381 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
12382 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
12383 "options" => Ok(GeneratedField::Options),
12384 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12385 }
12386 }
12387 }
12388 deserializer.deserialize_identifier(GeneratedVisitor)
12389 }
12390 }
12391 struct GeneratedVisitor;
12392 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12393 type Value = StreamCdcScanNode;
12394
12395 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12396 formatter.write_str("struct stream_plan.StreamCdcScanNode")
12397 }
12398
12399 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanNode, V::Error>
12400 where
12401 V: serde::de::MapAccess<'de>,
12402 {
12403 let mut table_id__ = None;
12404 let mut upstream_column_ids__ = None;
12405 let mut output_indices__ = None;
12406 let mut state_table__ = None;
12407 let mut cdc_table_desc__ = None;
12408 let mut rate_limit__ = None;
12409 let mut disable_backfill__ = None;
12410 let mut options__ = None;
12411 while let Some(k) = map_.next_key()? {
12412 match k {
12413 GeneratedField::TableId => {
12414 if table_id__.is_some() {
12415 return Err(serde::de::Error::duplicate_field("tableId"));
12416 }
12417 table_id__ =
12418 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12419 ;
12420 }
12421 GeneratedField::UpstreamColumnIds => {
12422 if upstream_column_ids__.is_some() {
12423 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
12424 }
12425 upstream_column_ids__ =
12426 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12427 .into_iter().map(|x| x.0).collect())
12428 ;
12429 }
12430 GeneratedField::OutputIndices => {
12431 if output_indices__.is_some() {
12432 return Err(serde::de::Error::duplicate_field("outputIndices"));
12433 }
12434 output_indices__ =
12435 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12436 .into_iter().map(|x| x.0).collect())
12437 ;
12438 }
12439 GeneratedField::StateTable => {
12440 if state_table__.is_some() {
12441 return Err(serde::de::Error::duplicate_field("stateTable"));
12442 }
12443 state_table__ = map_.next_value()?;
12444 }
12445 GeneratedField::CdcTableDesc => {
12446 if cdc_table_desc__.is_some() {
12447 return Err(serde::de::Error::duplicate_field("cdcTableDesc"));
12448 }
12449 cdc_table_desc__ = map_.next_value()?;
12450 }
12451 GeneratedField::RateLimit => {
12452 if rate_limit__.is_some() {
12453 return Err(serde::de::Error::duplicate_field("rateLimit"));
12454 }
12455 rate_limit__ =
12456 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12457 ;
12458 }
12459 GeneratedField::DisableBackfill => {
12460 if disable_backfill__.is_some() {
12461 return Err(serde::de::Error::duplicate_field("disableBackfill"));
12462 }
12463 disable_backfill__ = Some(map_.next_value()?);
12464 }
12465 GeneratedField::Options => {
12466 if options__.is_some() {
12467 return Err(serde::de::Error::duplicate_field("options"));
12468 }
12469 options__ = map_.next_value()?;
12470 }
12471 }
12472 }
12473 Ok(StreamCdcScanNode {
12474 table_id: table_id__.unwrap_or_default(),
12475 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
12476 output_indices: output_indices__.unwrap_or_default(),
12477 state_table: state_table__,
12478 cdc_table_desc: cdc_table_desc__,
12479 rate_limit: rate_limit__,
12480 disable_backfill: disable_backfill__.unwrap_or_default(),
12481 options: options__,
12482 })
12483 }
12484 }
12485 deserializer.deserialize_struct("stream_plan.StreamCdcScanNode", FIELDS, GeneratedVisitor)
12486 }
12487}
12488impl serde::Serialize for StreamCdcScanOptions {
12489 #[allow(deprecated)]
12490 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12491 where
12492 S: serde::Serializer,
12493 {
12494 use serde::ser::SerializeStruct;
12495 let mut len = 0;
12496 if self.disable_backfill {
12497 len += 1;
12498 }
12499 if self.snapshot_barrier_interval != 0 {
12500 len += 1;
12501 }
12502 if self.snapshot_batch_size != 0 {
12503 len += 1;
12504 }
12505 if self.backfill_parallelism != 0 {
12506 len += 1;
12507 }
12508 if self.backfill_num_rows_per_split != 0 {
12509 len += 1;
12510 }
12511 if self.backfill_as_even_splits {
12512 len += 1;
12513 }
12514 if self.backfill_split_pk_column_index != 0 {
12515 len += 1;
12516 }
12517 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanOptions", len)?;
12518 if self.disable_backfill {
12519 struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
12520 }
12521 if self.snapshot_barrier_interval != 0 {
12522 struct_ser.serialize_field("snapshotBarrierInterval", &self.snapshot_barrier_interval)?;
12523 }
12524 if self.snapshot_batch_size != 0 {
12525 struct_ser.serialize_field("snapshotBatchSize", &self.snapshot_batch_size)?;
12526 }
12527 if self.backfill_parallelism != 0 {
12528 struct_ser.serialize_field("backfillParallelism", &self.backfill_parallelism)?;
12529 }
12530 if self.backfill_num_rows_per_split != 0 {
12531 #[allow(clippy::needless_borrow)]
12532 #[allow(clippy::needless_borrows_for_generic_args)]
12533 struct_ser.serialize_field("backfillNumRowsPerSplit", ToString::to_string(&self.backfill_num_rows_per_split).as_str())?;
12534 }
12535 if self.backfill_as_even_splits {
12536 struct_ser.serialize_field("backfillAsEvenSplits", &self.backfill_as_even_splits)?;
12537 }
12538 if self.backfill_split_pk_column_index != 0 {
12539 struct_ser.serialize_field("backfillSplitPkColumnIndex", &self.backfill_split_pk_column_index)?;
12540 }
12541 struct_ser.end()
12542 }
12543}
12544impl<'de> serde::Deserialize<'de> for StreamCdcScanOptions {
12545 #[allow(deprecated)]
12546 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12547 where
12548 D: serde::Deserializer<'de>,
12549 {
12550 const FIELDS: &[&str] = &[
12551 "disable_backfill",
12552 "disableBackfill",
12553 "snapshot_barrier_interval",
12554 "snapshotBarrierInterval",
12555 "snapshot_batch_size",
12556 "snapshotBatchSize",
12557 "backfill_parallelism",
12558 "backfillParallelism",
12559 "backfill_num_rows_per_split",
12560 "backfillNumRowsPerSplit",
12561 "backfill_as_even_splits",
12562 "backfillAsEvenSplits",
12563 "backfill_split_pk_column_index",
12564 "backfillSplitPkColumnIndex",
12565 ];
12566
12567 #[allow(clippy::enum_variant_names)]
12568 enum GeneratedField {
12569 DisableBackfill,
12570 SnapshotBarrierInterval,
12571 SnapshotBatchSize,
12572 BackfillParallelism,
12573 BackfillNumRowsPerSplit,
12574 BackfillAsEvenSplits,
12575 BackfillSplitPkColumnIndex,
12576 }
12577 impl<'de> serde::Deserialize<'de> for GeneratedField {
12578 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12579 where
12580 D: serde::Deserializer<'de>,
12581 {
12582 struct GeneratedVisitor;
12583
12584 impl serde::de::Visitor<'_> for GeneratedVisitor {
12585 type Value = GeneratedField;
12586
12587 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12588 write!(formatter, "expected one of: {:?}", &FIELDS)
12589 }
12590
12591 #[allow(unused_variables)]
12592 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12593 where
12594 E: serde::de::Error,
12595 {
12596 match value {
12597 "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
12598 "snapshotBarrierInterval" | "snapshot_barrier_interval" => Ok(GeneratedField::SnapshotBarrierInterval),
12599 "snapshotBatchSize" | "snapshot_batch_size" => Ok(GeneratedField::SnapshotBatchSize),
12600 "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
12601 "backfillNumRowsPerSplit" | "backfill_num_rows_per_split" => Ok(GeneratedField::BackfillNumRowsPerSplit),
12602 "backfillAsEvenSplits" | "backfill_as_even_splits" => Ok(GeneratedField::BackfillAsEvenSplits),
12603 "backfillSplitPkColumnIndex" | "backfill_split_pk_column_index" => Ok(GeneratedField::BackfillSplitPkColumnIndex),
12604 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12605 }
12606 }
12607 }
12608 deserializer.deserialize_identifier(GeneratedVisitor)
12609 }
12610 }
12611 struct GeneratedVisitor;
12612 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12613 type Value = StreamCdcScanOptions;
12614
12615 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12616 formatter.write_str("struct stream_plan.StreamCdcScanOptions")
12617 }
12618
12619 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanOptions, V::Error>
12620 where
12621 V: serde::de::MapAccess<'de>,
12622 {
12623 let mut disable_backfill__ = None;
12624 let mut snapshot_barrier_interval__ = None;
12625 let mut snapshot_batch_size__ = None;
12626 let mut backfill_parallelism__ = None;
12627 let mut backfill_num_rows_per_split__ = None;
12628 let mut backfill_as_even_splits__ = None;
12629 let mut backfill_split_pk_column_index__ = None;
12630 while let Some(k) = map_.next_key()? {
12631 match k {
12632 GeneratedField::DisableBackfill => {
12633 if disable_backfill__.is_some() {
12634 return Err(serde::de::Error::duplicate_field("disableBackfill"));
12635 }
12636 disable_backfill__ = Some(map_.next_value()?);
12637 }
12638 GeneratedField::SnapshotBarrierInterval => {
12639 if snapshot_barrier_interval__.is_some() {
12640 return Err(serde::de::Error::duplicate_field("snapshotBarrierInterval"));
12641 }
12642 snapshot_barrier_interval__ =
12643 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12644 ;
12645 }
12646 GeneratedField::SnapshotBatchSize => {
12647 if snapshot_batch_size__.is_some() {
12648 return Err(serde::de::Error::duplicate_field("snapshotBatchSize"));
12649 }
12650 snapshot_batch_size__ =
12651 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12652 ;
12653 }
12654 GeneratedField::BackfillParallelism => {
12655 if backfill_parallelism__.is_some() {
12656 return Err(serde::de::Error::duplicate_field("backfillParallelism"));
12657 }
12658 backfill_parallelism__ =
12659 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12660 ;
12661 }
12662 GeneratedField::BackfillNumRowsPerSplit => {
12663 if backfill_num_rows_per_split__.is_some() {
12664 return Err(serde::de::Error::duplicate_field("backfillNumRowsPerSplit"));
12665 }
12666 backfill_num_rows_per_split__ =
12667 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12668 ;
12669 }
12670 GeneratedField::BackfillAsEvenSplits => {
12671 if backfill_as_even_splits__.is_some() {
12672 return Err(serde::de::Error::duplicate_field("backfillAsEvenSplits"));
12673 }
12674 backfill_as_even_splits__ = Some(map_.next_value()?);
12675 }
12676 GeneratedField::BackfillSplitPkColumnIndex => {
12677 if backfill_split_pk_column_index__.is_some() {
12678 return Err(serde::de::Error::duplicate_field("backfillSplitPkColumnIndex"));
12679 }
12680 backfill_split_pk_column_index__ =
12681 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12682 ;
12683 }
12684 }
12685 }
12686 Ok(StreamCdcScanOptions {
12687 disable_backfill: disable_backfill__.unwrap_or_default(),
12688 snapshot_barrier_interval: snapshot_barrier_interval__.unwrap_or_default(),
12689 snapshot_batch_size: snapshot_batch_size__.unwrap_or_default(),
12690 backfill_parallelism: backfill_parallelism__.unwrap_or_default(),
12691 backfill_num_rows_per_split: backfill_num_rows_per_split__.unwrap_or_default(),
12692 backfill_as_even_splits: backfill_as_even_splits__.unwrap_or_default(),
12693 backfill_split_pk_column_index: backfill_split_pk_column_index__.unwrap_or_default(),
12694 })
12695 }
12696 }
12697 deserializer.deserialize_struct("stream_plan.StreamCdcScanOptions", FIELDS, GeneratedVisitor)
12698 }
12699}
12700impl serde::Serialize for StreamContext {
12701 #[allow(deprecated)]
12702 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12703 where
12704 S: serde::Serializer,
12705 {
12706 use serde::ser::SerializeStruct;
12707 let mut len = 0;
12708 if !self.timezone.is_empty() {
12709 len += 1;
12710 }
12711 if !self.config_override.is_empty() {
12712 len += 1;
12713 }
12714 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamContext", len)?;
12715 if !self.timezone.is_empty() {
12716 struct_ser.serialize_field("timezone", &self.timezone)?;
12717 }
12718 if !self.config_override.is_empty() {
12719 struct_ser.serialize_field("configOverride", &self.config_override)?;
12720 }
12721 struct_ser.end()
12722 }
12723}
12724impl<'de> serde::Deserialize<'de> for StreamContext {
12725 #[allow(deprecated)]
12726 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12727 where
12728 D: serde::Deserializer<'de>,
12729 {
12730 const FIELDS: &[&str] = &[
12731 "timezone",
12732 "config_override",
12733 "configOverride",
12734 ];
12735
12736 #[allow(clippy::enum_variant_names)]
12737 enum GeneratedField {
12738 Timezone,
12739 ConfigOverride,
12740 }
12741 impl<'de> serde::Deserialize<'de> for GeneratedField {
12742 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12743 where
12744 D: serde::Deserializer<'de>,
12745 {
12746 struct GeneratedVisitor;
12747
12748 impl serde::de::Visitor<'_> for GeneratedVisitor {
12749 type Value = GeneratedField;
12750
12751 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12752 write!(formatter, "expected one of: {:?}", &FIELDS)
12753 }
12754
12755 #[allow(unused_variables)]
12756 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12757 where
12758 E: serde::de::Error,
12759 {
12760 match value {
12761 "timezone" => Ok(GeneratedField::Timezone),
12762 "configOverride" | "config_override" => Ok(GeneratedField::ConfigOverride),
12763 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12764 }
12765 }
12766 }
12767 deserializer.deserialize_identifier(GeneratedVisitor)
12768 }
12769 }
12770 struct GeneratedVisitor;
12771 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12772 type Value = StreamContext;
12773
12774 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12775 formatter.write_str("struct stream_plan.StreamContext")
12776 }
12777
12778 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamContext, V::Error>
12779 where
12780 V: serde::de::MapAccess<'de>,
12781 {
12782 let mut timezone__ = None;
12783 let mut config_override__ = None;
12784 while let Some(k) = map_.next_key()? {
12785 match k {
12786 GeneratedField::Timezone => {
12787 if timezone__.is_some() {
12788 return Err(serde::de::Error::duplicate_field("timezone"));
12789 }
12790 timezone__ = Some(map_.next_value()?);
12791 }
12792 GeneratedField::ConfigOverride => {
12793 if config_override__.is_some() {
12794 return Err(serde::de::Error::duplicate_field("configOverride"));
12795 }
12796 config_override__ = Some(map_.next_value()?);
12797 }
12798 }
12799 }
12800 Ok(StreamContext {
12801 timezone: timezone__.unwrap_or_default(),
12802 config_override: config_override__.unwrap_or_default(),
12803 })
12804 }
12805 }
12806 deserializer.deserialize_struct("stream_plan.StreamContext", FIELDS, GeneratedVisitor)
12807 }
12808}
12809impl serde::Serialize for StreamFragmentGraph {
12810 #[allow(deprecated)]
12811 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12812 where
12813 S: serde::Serializer,
12814 {
12815 use serde::ser::SerializeStruct;
12816 let mut len = 0;
12817 if !self.fragments.is_empty() {
12818 len += 1;
12819 }
12820 if !self.edges.is_empty() {
12821 len += 1;
12822 }
12823 if !self.dependent_table_ids.is_empty() {
12824 len += 1;
12825 }
12826 if self.table_ids_cnt != 0 {
12827 len += 1;
12828 }
12829 if self.ctx.is_some() {
12830 len += 1;
12831 }
12832 if self.parallelism.is_some() {
12833 len += 1;
12834 }
12835 if self.backfill_parallelism.is_some() {
12836 len += 1;
12837 }
12838 if !self.adaptive_parallelism_strategy.is_empty() {
12839 len += 1;
12840 }
12841 if !self.backfill_adaptive_parallelism_strategy.is_empty() {
12842 len += 1;
12843 }
12844 if self.max_parallelism != 0 {
12845 len += 1;
12846 }
12847 if self.backfill_order.is_some() {
12848 len += 1;
12849 }
12850 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph", len)?;
12851 if !self.fragments.is_empty() {
12852 struct_ser.serialize_field("fragments", &self.fragments)?;
12853 }
12854 if !self.edges.is_empty() {
12855 struct_ser.serialize_field("edges", &self.edges)?;
12856 }
12857 if !self.dependent_table_ids.is_empty() {
12858 struct_ser.serialize_field("dependentTableIds", &self.dependent_table_ids)?;
12859 }
12860 if self.table_ids_cnt != 0 {
12861 struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
12862 }
12863 if let Some(v) = self.ctx.as_ref() {
12864 struct_ser.serialize_field("ctx", v)?;
12865 }
12866 if let Some(v) = self.parallelism.as_ref() {
12867 struct_ser.serialize_field("parallelism", v)?;
12868 }
12869 if let Some(v) = self.backfill_parallelism.as_ref() {
12870 struct_ser.serialize_field("backfillParallelism", v)?;
12871 }
12872 if !self.adaptive_parallelism_strategy.is_empty() {
12873 struct_ser.serialize_field("adaptiveParallelismStrategy", &self.adaptive_parallelism_strategy)?;
12874 }
12875 if !self.backfill_adaptive_parallelism_strategy.is_empty() {
12876 struct_ser.serialize_field("backfillAdaptiveParallelismStrategy", &self.backfill_adaptive_parallelism_strategy)?;
12877 }
12878 if self.max_parallelism != 0 {
12879 struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
12880 }
12881 if let Some(v) = self.backfill_order.as_ref() {
12882 struct_ser.serialize_field("backfillOrder", v)?;
12883 }
12884 struct_ser.end()
12885 }
12886}
12887impl<'de> serde::Deserialize<'de> for StreamFragmentGraph {
12888 #[allow(deprecated)]
12889 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12890 where
12891 D: serde::Deserializer<'de>,
12892 {
12893 const FIELDS: &[&str] = &[
12894 "fragments",
12895 "edges",
12896 "dependent_table_ids",
12897 "dependentTableIds",
12898 "table_ids_cnt",
12899 "tableIdsCnt",
12900 "ctx",
12901 "parallelism",
12902 "backfill_parallelism",
12903 "backfillParallelism",
12904 "adaptive_parallelism_strategy",
12905 "adaptiveParallelismStrategy",
12906 "backfill_adaptive_parallelism_strategy",
12907 "backfillAdaptiveParallelismStrategy",
12908 "max_parallelism",
12909 "maxParallelism",
12910 "backfill_order",
12911 "backfillOrder",
12912 ];
12913
12914 #[allow(clippy::enum_variant_names)]
12915 enum GeneratedField {
12916 Fragments,
12917 Edges,
12918 DependentTableIds,
12919 TableIdsCnt,
12920 Ctx,
12921 Parallelism,
12922 BackfillParallelism,
12923 AdaptiveParallelismStrategy,
12924 BackfillAdaptiveParallelismStrategy,
12925 MaxParallelism,
12926 BackfillOrder,
12927 }
12928 impl<'de> serde::Deserialize<'de> for GeneratedField {
12929 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12930 where
12931 D: serde::Deserializer<'de>,
12932 {
12933 struct GeneratedVisitor;
12934
12935 impl serde::de::Visitor<'_> for GeneratedVisitor {
12936 type Value = GeneratedField;
12937
12938 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12939 write!(formatter, "expected one of: {:?}", &FIELDS)
12940 }
12941
12942 #[allow(unused_variables)]
12943 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12944 where
12945 E: serde::de::Error,
12946 {
12947 match value {
12948 "fragments" => Ok(GeneratedField::Fragments),
12949 "edges" => Ok(GeneratedField::Edges),
12950 "dependentTableIds" | "dependent_table_ids" => Ok(GeneratedField::DependentTableIds),
12951 "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
12952 "ctx" => Ok(GeneratedField::Ctx),
12953 "parallelism" => Ok(GeneratedField::Parallelism),
12954 "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
12955 "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
12956 "backfillAdaptiveParallelismStrategy" | "backfill_adaptive_parallelism_strategy" => Ok(GeneratedField::BackfillAdaptiveParallelismStrategy),
12957 "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
12958 "backfillOrder" | "backfill_order" => Ok(GeneratedField::BackfillOrder),
12959 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12960 }
12961 }
12962 }
12963 deserializer.deserialize_identifier(GeneratedVisitor)
12964 }
12965 }
12966 struct GeneratedVisitor;
12967 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12968 type Value = StreamFragmentGraph;
12969
12970 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12971 formatter.write_str("struct stream_plan.StreamFragmentGraph")
12972 }
12973
12974 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFragmentGraph, V::Error>
12975 where
12976 V: serde::de::MapAccess<'de>,
12977 {
12978 let mut fragments__ = None;
12979 let mut edges__ = None;
12980 let mut dependent_table_ids__ = None;
12981 let mut table_ids_cnt__ = None;
12982 let mut ctx__ = None;
12983 let mut parallelism__ = None;
12984 let mut backfill_parallelism__ = None;
12985 let mut adaptive_parallelism_strategy__ = None;
12986 let mut backfill_adaptive_parallelism_strategy__ = None;
12987 let mut max_parallelism__ = None;
12988 let mut backfill_order__ = None;
12989 while let Some(k) = map_.next_key()? {
12990 match k {
12991 GeneratedField::Fragments => {
12992 if fragments__.is_some() {
12993 return Err(serde::de::Error::duplicate_field("fragments"));
12994 }
12995 fragments__ = Some(
12996 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
12997 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
12998 );
12999 }
13000 GeneratedField::Edges => {
13001 if edges__.is_some() {
13002 return Err(serde::de::Error::duplicate_field("edges"));
13003 }
13004 edges__ = Some(map_.next_value()?);
13005 }
13006 GeneratedField::DependentTableIds => {
13007 if dependent_table_ids__.is_some() {
13008 return Err(serde::de::Error::duplicate_field("dependentTableIds"));
13009 }
13010 dependent_table_ids__ =
13011 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13012 .into_iter().map(|x| x.0).collect())
13013 ;
13014 }
13015 GeneratedField::TableIdsCnt => {
13016 if table_ids_cnt__.is_some() {
13017 return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
13018 }
13019 table_ids_cnt__ =
13020 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13021 ;
13022 }
13023 GeneratedField::Ctx => {
13024 if ctx__.is_some() {
13025 return Err(serde::de::Error::duplicate_field("ctx"));
13026 }
13027 ctx__ = map_.next_value()?;
13028 }
13029 GeneratedField::Parallelism => {
13030 if parallelism__.is_some() {
13031 return Err(serde::de::Error::duplicate_field("parallelism"));
13032 }
13033 parallelism__ = map_.next_value()?;
13034 }
13035 GeneratedField::BackfillParallelism => {
13036 if backfill_parallelism__.is_some() {
13037 return Err(serde::de::Error::duplicate_field("backfillParallelism"));
13038 }
13039 backfill_parallelism__ = map_.next_value()?;
13040 }
13041 GeneratedField::AdaptiveParallelismStrategy => {
13042 if adaptive_parallelism_strategy__.is_some() {
13043 return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
13044 }
13045 adaptive_parallelism_strategy__ = Some(map_.next_value()?);
13046 }
13047 GeneratedField::BackfillAdaptiveParallelismStrategy => {
13048 if backfill_adaptive_parallelism_strategy__.is_some() {
13049 return Err(serde::de::Error::duplicate_field("backfillAdaptiveParallelismStrategy"));
13050 }
13051 backfill_adaptive_parallelism_strategy__ = Some(map_.next_value()?);
13052 }
13053 GeneratedField::MaxParallelism => {
13054 if max_parallelism__.is_some() {
13055 return Err(serde::de::Error::duplicate_field("maxParallelism"));
13056 }
13057 max_parallelism__ =
13058 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13059 ;
13060 }
13061 GeneratedField::BackfillOrder => {
13062 if backfill_order__.is_some() {
13063 return Err(serde::de::Error::duplicate_field("backfillOrder"));
13064 }
13065 backfill_order__ = map_.next_value()?;
13066 }
13067 }
13068 }
13069 Ok(StreamFragmentGraph {
13070 fragments: fragments__.unwrap_or_default(),
13071 edges: edges__.unwrap_or_default(),
13072 dependent_table_ids: dependent_table_ids__.unwrap_or_default(),
13073 table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
13074 ctx: ctx__,
13075 parallelism: parallelism__,
13076 backfill_parallelism: backfill_parallelism__,
13077 adaptive_parallelism_strategy: adaptive_parallelism_strategy__.unwrap_or_default(),
13078 backfill_adaptive_parallelism_strategy: backfill_adaptive_parallelism_strategy__.unwrap_or_default(),
13079 max_parallelism: max_parallelism__.unwrap_or_default(),
13080 backfill_order: backfill_order__,
13081 })
13082 }
13083 }
13084 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph", FIELDS, GeneratedVisitor)
13085 }
13086}
13087impl serde::Serialize for stream_fragment_graph::Parallelism {
13088 #[allow(deprecated)]
13089 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13090 where
13091 S: serde::Serializer,
13092 {
13093 use serde::ser::SerializeStruct;
13094 let mut len = 0;
13095 if self.parallelism != 0 {
13096 len += 1;
13097 }
13098 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.Parallelism", len)?;
13099 if self.parallelism != 0 {
13100 #[allow(clippy::needless_borrow)]
13101 #[allow(clippy::needless_borrows_for_generic_args)]
13102 struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
13103 }
13104 struct_ser.end()
13105 }
13106}
13107impl<'de> serde::Deserialize<'de> for stream_fragment_graph::Parallelism {
13108 #[allow(deprecated)]
13109 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13110 where
13111 D: serde::Deserializer<'de>,
13112 {
13113 const FIELDS: &[&str] = &[
13114 "parallelism",
13115 ];
13116
13117 #[allow(clippy::enum_variant_names)]
13118 enum GeneratedField {
13119 Parallelism,
13120 }
13121 impl<'de> serde::Deserialize<'de> for GeneratedField {
13122 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13123 where
13124 D: serde::Deserializer<'de>,
13125 {
13126 struct GeneratedVisitor;
13127
13128 impl serde::de::Visitor<'_> for GeneratedVisitor {
13129 type Value = GeneratedField;
13130
13131 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13132 write!(formatter, "expected one of: {:?}", &FIELDS)
13133 }
13134
13135 #[allow(unused_variables)]
13136 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13137 where
13138 E: serde::de::Error,
13139 {
13140 match value {
13141 "parallelism" => Ok(GeneratedField::Parallelism),
13142 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13143 }
13144 }
13145 }
13146 deserializer.deserialize_identifier(GeneratedVisitor)
13147 }
13148 }
13149 struct GeneratedVisitor;
13150 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13151 type Value = stream_fragment_graph::Parallelism;
13152
13153 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13154 formatter.write_str("struct stream_plan.StreamFragmentGraph.Parallelism")
13155 }
13156
13157 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::Parallelism, V::Error>
13158 where
13159 V: serde::de::MapAccess<'de>,
13160 {
13161 let mut parallelism__ = None;
13162 while let Some(k) = map_.next_key()? {
13163 match k {
13164 GeneratedField::Parallelism => {
13165 if parallelism__.is_some() {
13166 return Err(serde::de::Error::duplicate_field("parallelism"));
13167 }
13168 parallelism__ =
13169 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13170 ;
13171 }
13172 }
13173 }
13174 Ok(stream_fragment_graph::Parallelism {
13175 parallelism: parallelism__.unwrap_or_default(),
13176 })
13177 }
13178 }
13179 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.Parallelism", FIELDS, GeneratedVisitor)
13180 }
13181}
13182impl serde::Serialize for stream_fragment_graph::StreamFragment {
13183 #[allow(deprecated)]
13184 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13185 where
13186 S: serde::Serializer,
13187 {
13188 use serde::ser::SerializeStruct;
13189 let mut len = 0;
13190 if self.fragment_id != 0 {
13191 len += 1;
13192 }
13193 if self.node.is_some() {
13194 len += 1;
13195 }
13196 if self.fragment_type_mask != 0 {
13197 len += 1;
13198 }
13199 if self.requires_singleton {
13200 len += 1;
13201 }
13202 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", len)?;
13203 if self.fragment_id != 0 {
13204 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
13205 }
13206 if let Some(v) = self.node.as_ref() {
13207 struct_ser.serialize_field("node", v)?;
13208 }
13209 if self.fragment_type_mask != 0 {
13210 struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
13211 }
13212 if self.requires_singleton {
13213 struct_ser.serialize_field("requiresSingleton", &self.requires_singleton)?;
13214 }
13215 struct_ser.end()
13216 }
13217}
13218impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragment {
13219 #[allow(deprecated)]
13220 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13221 where
13222 D: serde::Deserializer<'de>,
13223 {
13224 const FIELDS: &[&str] = &[
13225 "fragment_id",
13226 "fragmentId",
13227 "node",
13228 "fragment_type_mask",
13229 "fragmentTypeMask",
13230 "requires_singleton",
13231 "requiresSingleton",
13232 ];
13233
13234 #[allow(clippy::enum_variant_names)]
13235 enum GeneratedField {
13236 FragmentId,
13237 Node,
13238 FragmentTypeMask,
13239 RequiresSingleton,
13240 }
13241 impl<'de> serde::Deserialize<'de> for GeneratedField {
13242 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13243 where
13244 D: serde::Deserializer<'de>,
13245 {
13246 struct GeneratedVisitor;
13247
13248 impl serde::de::Visitor<'_> for GeneratedVisitor {
13249 type Value = GeneratedField;
13250
13251 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13252 write!(formatter, "expected one of: {:?}", &FIELDS)
13253 }
13254
13255 #[allow(unused_variables)]
13256 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13257 where
13258 E: serde::de::Error,
13259 {
13260 match value {
13261 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
13262 "node" => Ok(GeneratedField::Node),
13263 "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
13264 "requiresSingleton" | "requires_singleton" => Ok(GeneratedField::RequiresSingleton),
13265 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13266 }
13267 }
13268 }
13269 deserializer.deserialize_identifier(GeneratedVisitor)
13270 }
13271 }
13272 struct GeneratedVisitor;
13273 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13274 type Value = stream_fragment_graph::StreamFragment;
13275
13276 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13277 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragment")
13278 }
13279
13280 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragment, V::Error>
13281 where
13282 V: serde::de::MapAccess<'de>,
13283 {
13284 let mut fragment_id__ = None;
13285 let mut node__ = None;
13286 let mut fragment_type_mask__ = None;
13287 let mut requires_singleton__ = None;
13288 while let Some(k) = map_.next_key()? {
13289 match k {
13290 GeneratedField::FragmentId => {
13291 if fragment_id__.is_some() {
13292 return Err(serde::de::Error::duplicate_field("fragmentId"));
13293 }
13294 fragment_id__ =
13295 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13296 ;
13297 }
13298 GeneratedField::Node => {
13299 if node__.is_some() {
13300 return Err(serde::de::Error::duplicate_field("node"));
13301 }
13302 node__ = map_.next_value()?;
13303 }
13304 GeneratedField::FragmentTypeMask => {
13305 if fragment_type_mask__.is_some() {
13306 return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
13307 }
13308 fragment_type_mask__ =
13309 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13310 ;
13311 }
13312 GeneratedField::RequiresSingleton => {
13313 if requires_singleton__.is_some() {
13314 return Err(serde::de::Error::duplicate_field("requiresSingleton"));
13315 }
13316 requires_singleton__ = Some(map_.next_value()?);
13317 }
13318 }
13319 }
13320 Ok(stream_fragment_graph::StreamFragment {
13321 fragment_id: fragment_id__.unwrap_or_default(),
13322 node: node__,
13323 fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
13324 requires_singleton: requires_singleton__.unwrap_or_default(),
13325 })
13326 }
13327 }
13328 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", FIELDS, GeneratedVisitor)
13329 }
13330}
13331impl serde::Serialize for stream_fragment_graph::StreamFragmentEdge {
13332 #[allow(deprecated)]
13333 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13334 where
13335 S: serde::Serializer,
13336 {
13337 use serde::ser::SerializeStruct;
13338 let mut len = 0;
13339 if self.dispatch_strategy.is_some() {
13340 len += 1;
13341 }
13342 if self.link_id != 0 {
13343 len += 1;
13344 }
13345 if self.upstream_id != 0 {
13346 len += 1;
13347 }
13348 if self.downstream_id != 0 {
13349 len += 1;
13350 }
13351 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", len)?;
13352 if let Some(v) = self.dispatch_strategy.as_ref() {
13353 struct_ser.serialize_field("dispatchStrategy", v)?;
13354 }
13355 if self.link_id != 0 {
13356 #[allow(clippy::needless_borrow)]
13357 #[allow(clippy::needless_borrows_for_generic_args)]
13358 struct_ser.serialize_field("linkId", ToString::to_string(&self.link_id).as_str())?;
13359 }
13360 if self.upstream_id != 0 {
13361 struct_ser.serialize_field("upstreamId", &self.upstream_id)?;
13362 }
13363 if self.downstream_id != 0 {
13364 struct_ser.serialize_field("downstreamId", &self.downstream_id)?;
13365 }
13366 struct_ser.end()
13367 }
13368}
13369impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragmentEdge {
13370 #[allow(deprecated)]
13371 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13372 where
13373 D: serde::Deserializer<'de>,
13374 {
13375 const FIELDS: &[&str] = &[
13376 "dispatch_strategy",
13377 "dispatchStrategy",
13378 "link_id",
13379 "linkId",
13380 "upstream_id",
13381 "upstreamId",
13382 "downstream_id",
13383 "downstreamId",
13384 ];
13385
13386 #[allow(clippy::enum_variant_names)]
13387 enum GeneratedField {
13388 DispatchStrategy,
13389 LinkId,
13390 UpstreamId,
13391 DownstreamId,
13392 }
13393 impl<'de> serde::Deserialize<'de> for GeneratedField {
13394 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13395 where
13396 D: serde::Deserializer<'de>,
13397 {
13398 struct GeneratedVisitor;
13399
13400 impl serde::de::Visitor<'_> for GeneratedVisitor {
13401 type Value = GeneratedField;
13402
13403 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13404 write!(formatter, "expected one of: {:?}", &FIELDS)
13405 }
13406
13407 #[allow(unused_variables)]
13408 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13409 where
13410 E: serde::de::Error,
13411 {
13412 match value {
13413 "dispatchStrategy" | "dispatch_strategy" => Ok(GeneratedField::DispatchStrategy),
13414 "linkId" | "link_id" => Ok(GeneratedField::LinkId),
13415 "upstreamId" | "upstream_id" => Ok(GeneratedField::UpstreamId),
13416 "downstreamId" | "downstream_id" => Ok(GeneratedField::DownstreamId),
13417 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13418 }
13419 }
13420 }
13421 deserializer.deserialize_identifier(GeneratedVisitor)
13422 }
13423 }
13424 struct GeneratedVisitor;
13425 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13426 type Value = stream_fragment_graph::StreamFragmentEdge;
13427
13428 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13429 formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragmentEdge")
13430 }
13431
13432 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragmentEdge, V::Error>
13433 where
13434 V: serde::de::MapAccess<'de>,
13435 {
13436 let mut dispatch_strategy__ = None;
13437 let mut link_id__ = None;
13438 let mut upstream_id__ = None;
13439 let mut downstream_id__ = None;
13440 while let Some(k) = map_.next_key()? {
13441 match k {
13442 GeneratedField::DispatchStrategy => {
13443 if dispatch_strategy__.is_some() {
13444 return Err(serde::de::Error::duplicate_field("dispatchStrategy"));
13445 }
13446 dispatch_strategy__ = map_.next_value()?;
13447 }
13448 GeneratedField::LinkId => {
13449 if link_id__.is_some() {
13450 return Err(serde::de::Error::duplicate_field("linkId"));
13451 }
13452 link_id__ =
13453 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13454 ;
13455 }
13456 GeneratedField::UpstreamId => {
13457 if upstream_id__.is_some() {
13458 return Err(serde::de::Error::duplicate_field("upstreamId"));
13459 }
13460 upstream_id__ =
13461 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13462 ;
13463 }
13464 GeneratedField::DownstreamId => {
13465 if downstream_id__.is_some() {
13466 return Err(serde::de::Error::duplicate_field("downstreamId"));
13467 }
13468 downstream_id__ =
13469 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13470 ;
13471 }
13472 }
13473 }
13474 Ok(stream_fragment_graph::StreamFragmentEdge {
13475 dispatch_strategy: dispatch_strategy__,
13476 link_id: link_id__.unwrap_or_default(),
13477 upstream_id: upstream_id__.unwrap_or_default(),
13478 downstream_id: downstream_id__.unwrap_or_default(),
13479 })
13480 }
13481 }
13482 deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", FIELDS, GeneratedVisitor)
13483 }
13484}
13485impl serde::Serialize for StreamFsFetch {
13486 #[allow(deprecated)]
13487 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13488 where
13489 S: serde::Serializer,
13490 {
13491 use serde::ser::SerializeStruct;
13492 let mut len = 0;
13493 if self.source_id != 0 {
13494 len += 1;
13495 }
13496 if self.state_table.is_some() {
13497 len += 1;
13498 }
13499 if self.row_id_index.is_some() {
13500 len += 1;
13501 }
13502 if !self.columns.is_empty() {
13503 len += 1;
13504 }
13505 if !self.with_properties.is_empty() {
13506 len += 1;
13507 }
13508 if self.info.is_some() {
13509 len += 1;
13510 }
13511 if !self.source_name.is_empty() {
13512 len += 1;
13513 }
13514 if self.rate_limit.is_some() {
13515 len += 1;
13516 }
13517 if !self.secret_refs.is_empty() {
13518 len += 1;
13519 }
13520 if self.refresh_mode.is_some() {
13521 len += 1;
13522 }
13523 if self.associated_table_id.is_some() {
13524 len += 1;
13525 }
13526 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetch", len)?;
13527 if self.source_id != 0 {
13528 struct_ser.serialize_field("sourceId", &self.source_id)?;
13529 }
13530 if let Some(v) = self.state_table.as_ref() {
13531 struct_ser.serialize_field("stateTable", v)?;
13532 }
13533 if let Some(v) = self.row_id_index.as_ref() {
13534 struct_ser.serialize_field("rowIdIndex", v)?;
13535 }
13536 if !self.columns.is_empty() {
13537 struct_ser.serialize_field("columns", &self.columns)?;
13538 }
13539 if !self.with_properties.is_empty() {
13540 struct_ser.serialize_field("withProperties", &self.with_properties)?;
13541 }
13542 if let Some(v) = self.info.as_ref() {
13543 struct_ser.serialize_field("info", v)?;
13544 }
13545 if !self.source_name.is_empty() {
13546 struct_ser.serialize_field("sourceName", &self.source_name)?;
13547 }
13548 if let Some(v) = self.rate_limit.as_ref() {
13549 struct_ser.serialize_field("rateLimit", v)?;
13550 }
13551 if !self.secret_refs.is_empty() {
13552 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
13553 }
13554 if let Some(v) = self.refresh_mode.as_ref() {
13555 struct_ser.serialize_field("refreshMode", v)?;
13556 }
13557 if let Some(v) = self.associated_table_id.as_ref() {
13558 struct_ser.serialize_field("associatedTableId", v)?;
13559 }
13560 struct_ser.end()
13561 }
13562}
13563impl<'de> serde::Deserialize<'de> for StreamFsFetch {
13564 #[allow(deprecated)]
13565 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13566 where
13567 D: serde::Deserializer<'de>,
13568 {
13569 const FIELDS: &[&str] = &[
13570 "source_id",
13571 "sourceId",
13572 "state_table",
13573 "stateTable",
13574 "row_id_index",
13575 "rowIdIndex",
13576 "columns",
13577 "with_properties",
13578 "withProperties",
13579 "info",
13580 "source_name",
13581 "sourceName",
13582 "rate_limit",
13583 "rateLimit",
13584 "secret_refs",
13585 "secretRefs",
13586 "refresh_mode",
13587 "refreshMode",
13588 "associated_table_id",
13589 "associatedTableId",
13590 ];
13591
13592 #[allow(clippy::enum_variant_names)]
13593 enum GeneratedField {
13594 SourceId,
13595 StateTable,
13596 RowIdIndex,
13597 Columns,
13598 WithProperties,
13599 Info,
13600 SourceName,
13601 RateLimit,
13602 SecretRefs,
13603 RefreshMode,
13604 AssociatedTableId,
13605 }
13606 impl<'de> serde::Deserialize<'de> for GeneratedField {
13607 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13608 where
13609 D: serde::Deserializer<'de>,
13610 {
13611 struct GeneratedVisitor;
13612
13613 impl serde::de::Visitor<'_> for GeneratedVisitor {
13614 type Value = GeneratedField;
13615
13616 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13617 write!(formatter, "expected one of: {:?}", &FIELDS)
13618 }
13619
13620 #[allow(unused_variables)]
13621 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13622 where
13623 E: serde::de::Error,
13624 {
13625 match value {
13626 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
13627 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
13628 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
13629 "columns" => Ok(GeneratedField::Columns),
13630 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
13631 "info" => Ok(GeneratedField::Info),
13632 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
13633 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
13634 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
13635 "refreshMode" | "refresh_mode" => Ok(GeneratedField::RefreshMode),
13636 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
13637 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13638 }
13639 }
13640 }
13641 deserializer.deserialize_identifier(GeneratedVisitor)
13642 }
13643 }
13644 struct GeneratedVisitor;
13645 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13646 type Value = StreamFsFetch;
13647
13648 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13649 formatter.write_str("struct stream_plan.StreamFsFetch")
13650 }
13651
13652 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetch, V::Error>
13653 where
13654 V: serde::de::MapAccess<'de>,
13655 {
13656 let mut source_id__ = None;
13657 let mut state_table__ = None;
13658 let mut row_id_index__ = None;
13659 let mut columns__ = None;
13660 let mut with_properties__ = None;
13661 let mut info__ = None;
13662 let mut source_name__ = None;
13663 let mut rate_limit__ = None;
13664 let mut secret_refs__ = None;
13665 let mut refresh_mode__ = None;
13666 let mut associated_table_id__ = None;
13667 while let Some(k) = map_.next_key()? {
13668 match k {
13669 GeneratedField::SourceId => {
13670 if source_id__.is_some() {
13671 return Err(serde::de::Error::duplicate_field("sourceId"));
13672 }
13673 source_id__ =
13674 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13675 ;
13676 }
13677 GeneratedField::StateTable => {
13678 if state_table__.is_some() {
13679 return Err(serde::de::Error::duplicate_field("stateTable"));
13680 }
13681 state_table__ = map_.next_value()?;
13682 }
13683 GeneratedField::RowIdIndex => {
13684 if row_id_index__.is_some() {
13685 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
13686 }
13687 row_id_index__ =
13688 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13689 ;
13690 }
13691 GeneratedField::Columns => {
13692 if columns__.is_some() {
13693 return Err(serde::de::Error::duplicate_field("columns"));
13694 }
13695 columns__ = Some(map_.next_value()?);
13696 }
13697 GeneratedField::WithProperties => {
13698 if with_properties__.is_some() {
13699 return Err(serde::de::Error::duplicate_field("withProperties"));
13700 }
13701 with_properties__ = Some(
13702 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13703 );
13704 }
13705 GeneratedField::Info => {
13706 if info__.is_some() {
13707 return Err(serde::de::Error::duplicate_field("info"));
13708 }
13709 info__ = map_.next_value()?;
13710 }
13711 GeneratedField::SourceName => {
13712 if source_name__.is_some() {
13713 return Err(serde::de::Error::duplicate_field("sourceName"));
13714 }
13715 source_name__ = Some(map_.next_value()?);
13716 }
13717 GeneratedField::RateLimit => {
13718 if rate_limit__.is_some() {
13719 return Err(serde::de::Error::duplicate_field("rateLimit"));
13720 }
13721 rate_limit__ =
13722 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13723 ;
13724 }
13725 GeneratedField::SecretRefs => {
13726 if secret_refs__.is_some() {
13727 return Err(serde::de::Error::duplicate_field("secretRefs"));
13728 }
13729 secret_refs__ = Some(
13730 map_.next_value::<std::collections::BTreeMap<_, _>>()?
13731 );
13732 }
13733 GeneratedField::RefreshMode => {
13734 if refresh_mode__.is_some() {
13735 return Err(serde::de::Error::duplicate_field("refreshMode"));
13736 }
13737 refresh_mode__ = map_.next_value()?;
13738 }
13739 GeneratedField::AssociatedTableId => {
13740 if associated_table_id__.is_some() {
13741 return Err(serde::de::Error::duplicate_field("associatedTableId"));
13742 }
13743 associated_table_id__ =
13744 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13745 ;
13746 }
13747 }
13748 }
13749 Ok(StreamFsFetch {
13750 source_id: source_id__.unwrap_or_default(),
13751 state_table: state_table__,
13752 row_id_index: row_id_index__,
13753 columns: columns__.unwrap_or_default(),
13754 with_properties: with_properties__.unwrap_or_default(),
13755 info: info__,
13756 source_name: source_name__.unwrap_or_default(),
13757 rate_limit: rate_limit__,
13758 secret_refs: secret_refs__.unwrap_or_default(),
13759 refresh_mode: refresh_mode__,
13760 associated_table_id: associated_table_id__,
13761 })
13762 }
13763 }
13764 deserializer.deserialize_struct("stream_plan.StreamFsFetch", FIELDS, GeneratedVisitor)
13765 }
13766}
13767impl serde::Serialize for StreamFsFetchNode {
13768 #[allow(deprecated)]
13769 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13770 where
13771 S: serde::Serializer,
13772 {
13773 use serde::ser::SerializeStruct;
13774 let mut len = 0;
13775 if self.node_inner.is_some() {
13776 len += 1;
13777 }
13778 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetchNode", len)?;
13779 if let Some(v) = self.node_inner.as_ref() {
13780 struct_ser.serialize_field("nodeInner", v)?;
13781 }
13782 struct_ser.end()
13783 }
13784}
13785impl<'de> serde::Deserialize<'de> for StreamFsFetchNode {
13786 #[allow(deprecated)]
13787 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13788 where
13789 D: serde::Deserializer<'de>,
13790 {
13791 const FIELDS: &[&str] = &[
13792 "node_inner",
13793 "nodeInner",
13794 ];
13795
13796 #[allow(clippy::enum_variant_names)]
13797 enum GeneratedField {
13798 NodeInner,
13799 }
13800 impl<'de> serde::Deserialize<'de> for GeneratedField {
13801 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13802 where
13803 D: serde::Deserializer<'de>,
13804 {
13805 struct GeneratedVisitor;
13806
13807 impl serde::de::Visitor<'_> for GeneratedVisitor {
13808 type Value = GeneratedField;
13809
13810 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13811 write!(formatter, "expected one of: {:?}", &FIELDS)
13812 }
13813
13814 #[allow(unused_variables)]
13815 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13816 where
13817 E: serde::de::Error,
13818 {
13819 match value {
13820 "nodeInner" | "node_inner" => Ok(GeneratedField::NodeInner),
13821 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13822 }
13823 }
13824 }
13825 deserializer.deserialize_identifier(GeneratedVisitor)
13826 }
13827 }
13828 struct GeneratedVisitor;
13829 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13830 type Value = StreamFsFetchNode;
13831
13832 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13833 formatter.write_str("struct stream_plan.StreamFsFetchNode")
13834 }
13835
13836 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetchNode, V::Error>
13837 where
13838 V: serde::de::MapAccess<'de>,
13839 {
13840 let mut node_inner__ = None;
13841 while let Some(k) = map_.next_key()? {
13842 match k {
13843 GeneratedField::NodeInner => {
13844 if node_inner__.is_some() {
13845 return Err(serde::de::Error::duplicate_field("nodeInner"));
13846 }
13847 node_inner__ = map_.next_value()?;
13848 }
13849 }
13850 }
13851 Ok(StreamFsFetchNode {
13852 node_inner: node_inner__,
13853 })
13854 }
13855 }
13856 deserializer.deserialize_struct("stream_plan.StreamFsFetchNode", FIELDS, GeneratedVisitor)
13857 }
13858}
13859impl serde::Serialize for StreamMessage {
13860 #[allow(deprecated)]
13861 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13862 where
13863 S: serde::Serializer,
13864 {
13865 use serde::ser::SerializeStruct;
13866 let mut len = 0;
13867 if self.stream_message.is_some() {
13868 len += 1;
13869 }
13870 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessage", len)?;
13871 if let Some(v) = self.stream_message.as_ref() {
13872 match v {
13873 stream_message::StreamMessage::StreamChunk(v) => {
13874 struct_ser.serialize_field("streamChunk", v)?;
13875 }
13876 stream_message::StreamMessage::Barrier(v) => {
13877 struct_ser.serialize_field("barrier", v)?;
13878 }
13879 stream_message::StreamMessage::Watermark(v) => {
13880 struct_ser.serialize_field("watermark", v)?;
13881 }
13882 }
13883 }
13884 struct_ser.end()
13885 }
13886}
13887impl<'de> serde::Deserialize<'de> for StreamMessage {
13888 #[allow(deprecated)]
13889 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13890 where
13891 D: serde::Deserializer<'de>,
13892 {
13893 const FIELDS: &[&str] = &[
13894 "stream_chunk",
13895 "streamChunk",
13896 "barrier",
13897 "watermark",
13898 ];
13899
13900 #[allow(clippy::enum_variant_names)]
13901 enum GeneratedField {
13902 StreamChunk,
13903 Barrier,
13904 Watermark,
13905 }
13906 impl<'de> serde::Deserialize<'de> for GeneratedField {
13907 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13908 where
13909 D: serde::Deserializer<'de>,
13910 {
13911 struct GeneratedVisitor;
13912
13913 impl serde::de::Visitor<'_> for GeneratedVisitor {
13914 type Value = GeneratedField;
13915
13916 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13917 write!(formatter, "expected one of: {:?}", &FIELDS)
13918 }
13919
13920 #[allow(unused_variables)]
13921 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13922 where
13923 E: serde::de::Error,
13924 {
13925 match value {
13926 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
13927 "barrier" => Ok(GeneratedField::Barrier),
13928 "watermark" => Ok(GeneratedField::Watermark),
13929 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13930 }
13931 }
13932 }
13933 deserializer.deserialize_identifier(GeneratedVisitor)
13934 }
13935 }
13936 struct GeneratedVisitor;
13937 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13938 type Value = StreamMessage;
13939
13940 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13941 formatter.write_str("struct stream_plan.StreamMessage")
13942 }
13943
13944 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessage, V::Error>
13945 where
13946 V: serde::de::MapAccess<'de>,
13947 {
13948 let mut stream_message__ = None;
13949 while let Some(k) = map_.next_key()? {
13950 match k {
13951 GeneratedField::StreamChunk => {
13952 if stream_message__.is_some() {
13953 return Err(serde::de::Error::duplicate_field("streamChunk"));
13954 }
13955 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::StreamChunk)
13956;
13957 }
13958 GeneratedField::Barrier => {
13959 if stream_message__.is_some() {
13960 return Err(serde::de::Error::duplicate_field("barrier"));
13961 }
13962 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Barrier)
13963;
13964 }
13965 GeneratedField::Watermark => {
13966 if stream_message__.is_some() {
13967 return Err(serde::de::Error::duplicate_field("watermark"));
13968 }
13969 stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Watermark)
13970;
13971 }
13972 }
13973 }
13974 Ok(StreamMessage {
13975 stream_message: stream_message__,
13976 })
13977 }
13978 }
13979 deserializer.deserialize_struct("stream_plan.StreamMessage", FIELDS, GeneratedVisitor)
13980 }
13981}
13982impl serde::Serialize for StreamMessageBatch {
13983 #[allow(deprecated)]
13984 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13985 where
13986 S: serde::Serializer,
13987 {
13988 use serde::ser::SerializeStruct;
13989 let mut len = 0;
13990 if self.stream_message_batch.is_some() {
13991 len += 1;
13992 }
13993 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch", len)?;
13994 if let Some(v) = self.stream_message_batch.as_ref() {
13995 match v {
13996 stream_message_batch::StreamMessageBatch::StreamChunk(v) => {
13997 struct_ser.serialize_field("streamChunk", v)?;
13998 }
13999 stream_message_batch::StreamMessageBatch::BarrierBatch(v) => {
14000 struct_ser.serialize_field("barrierBatch", v)?;
14001 }
14002 stream_message_batch::StreamMessageBatch::Watermark(v) => {
14003 struct_ser.serialize_field("watermark", v)?;
14004 }
14005 }
14006 }
14007 struct_ser.end()
14008 }
14009}
14010impl<'de> serde::Deserialize<'de> for StreamMessageBatch {
14011 #[allow(deprecated)]
14012 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14013 where
14014 D: serde::Deserializer<'de>,
14015 {
14016 const FIELDS: &[&str] = &[
14017 "stream_chunk",
14018 "streamChunk",
14019 "barrier_batch",
14020 "barrierBatch",
14021 "watermark",
14022 ];
14023
14024 #[allow(clippy::enum_variant_names)]
14025 enum GeneratedField {
14026 StreamChunk,
14027 BarrierBatch,
14028 Watermark,
14029 }
14030 impl<'de> serde::Deserialize<'de> for GeneratedField {
14031 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14032 where
14033 D: serde::Deserializer<'de>,
14034 {
14035 struct GeneratedVisitor;
14036
14037 impl serde::de::Visitor<'_> for GeneratedVisitor {
14038 type Value = GeneratedField;
14039
14040 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14041 write!(formatter, "expected one of: {:?}", &FIELDS)
14042 }
14043
14044 #[allow(unused_variables)]
14045 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14046 where
14047 E: serde::de::Error,
14048 {
14049 match value {
14050 "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
14051 "barrierBatch" | "barrier_batch" => Ok(GeneratedField::BarrierBatch),
14052 "watermark" => Ok(GeneratedField::Watermark),
14053 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14054 }
14055 }
14056 }
14057 deserializer.deserialize_identifier(GeneratedVisitor)
14058 }
14059 }
14060 struct GeneratedVisitor;
14061 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14062 type Value = StreamMessageBatch;
14063
14064 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14065 formatter.write_str("struct stream_plan.StreamMessageBatch")
14066 }
14067
14068 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessageBatch, V::Error>
14069 where
14070 V: serde::de::MapAccess<'de>,
14071 {
14072 let mut stream_message_batch__ = None;
14073 while let Some(k) = map_.next_key()? {
14074 match k {
14075 GeneratedField::StreamChunk => {
14076 if stream_message_batch__.is_some() {
14077 return Err(serde::de::Error::duplicate_field("streamChunk"));
14078 }
14079 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::StreamChunk)
14080;
14081 }
14082 GeneratedField::BarrierBatch => {
14083 if stream_message_batch__.is_some() {
14084 return Err(serde::de::Error::duplicate_field("barrierBatch"));
14085 }
14086 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::BarrierBatch)
14087;
14088 }
14089 GeneratedField::Watermark => {
14090 if stream_message_batch__.is_some() {
14091 return Err(serde::de::Error::duplicate_field("watermark"));
14092 }
14093 stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::Watermark)
14094;
14095 }
14096 }
14097 }
14098 Ok(StreamMessageBatch {
14099 stream_message_batch: stream_message_batch__,
14100 })
14101 }
14102 }
14103 deserializer.deserialize_struct("stream_plan.StreamMessageBatch", FIELDS, GeneratedVisitor)
14104 }
14105}
14106impl serde::Serialize for stream_message_batch::BarrierBatch {
14107 #[allow(deprecated)]
14108 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14109 where
14110 S: serde::Serializer,
14111 {
14112 use serde::ser::SerializeStruct;
14113 let mut len = 0;
14114 if !self.barriers.is_empty() {
14115 len += 1;
14116 }
14117 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", len)?;
14118 if !self.barriers.is_empty() {
14119 struct_ser.serialize_field("barriers", &self.barriers)?;
14120 }
14121 struct_ser.end()
14122 }
14123}
14124impl<'de> serde::Deserialize<'de> for stream_message_batch::BarrierBatch {
14125 #[allow(deprecated)]
14126 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14127 where
14128 D: serde::Deserializer<'de>,
14129 {
14130 const FIELDS: &[&str] = &[
14131 "barriers",
14132 ];
14133
14134 #[allow(clippy::enum_variant_names)]
14135 enum GeneratedField {
14136 Barriers,
14137 }
14138 impl<'de> serde::Deserialize<'de> for GeneratedField {
14139 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14140 where
14141 D: serde::Deserializer<'de>,
14142 {
14143 struct GeneratedVisitor;
14144
14145 impl serde::de::Visitor<'_> for GeneratedVisitor {
14146 type Value = GeneratedField;
14147
14148 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14149 write!(formatter, "expected one of: {:?}", &FIELDS)
14150 }
14151
14152 #[allow(unused_variables)]
14153 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14154 where
14155 E: serde::de::Error,
14156 {
14157 match value {
14158 "barriers" => Ok(GeneratedField::Barriers),
14159 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14160 }
14161 }
14162 }
14163 deserializer.deserialize_identifier(GeneratedVisitor)
14164 }
14165 }
14166 struct GeneratedVisitor;
14167 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14168 type Value = stream_message_batch::BarrierBatch;
14169
14170 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14171 formatter.write_str("struct stream_plan.StreamMessageBatch.BarrierBatch")
14172 }
14173
14174 fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_message_batch::BarrierBatch, V::Error>
14175 where
14176 V: serde::de::MapAccess<'de>,
14177 {
14178 let mut barriers__ = None;
14179 while let Some(k) = map_.next_key()? {
14180 match k {
14181 GeneratedField::Barriers => {
14182 if barriers__.is_some() {
14183 return Err(serde::de::Error::duplicate_field("barriers"));
14184 }
14185 barriers__ = Some(map_.next_value()?);
14186 }
14187 }
14188 }
14189 Ok(stream_message_batch::BarrierBatch {
14190 barriers: barriers__.unwrap_or_default(),
14191 })
14192 }
14193 }
14194 deserializer.deserialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", FIELDS, GeneratedVisitor)
14195 }
14196}
14197impl serde::Serialize for StreamNode {
14198 #[allow(deprecated)]
14199 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14200 where
14201 S: serde::Serializer,
14202 {
14203 use serde::ser::SerializeStruct;
14204 let mut len = 0;
14205 if self.operator_id != 0 {
14206 len += 1;
14207 }
14208 if !self.input.is_empty() {
14209 len += 1;
14210 }
14211 if !self.stream_key.is_empty() {
14212 len += 1;
14213 }
14214 if self.stream_kind != 0 {
14215 len += 1;
14216 }
14217 if !self.identity.is_empty() {
14218 len += 1;
14219 }
14220 if !self.fields.is_empty() {
14221 len += 1;
14222 }
14223 if self.node_body.is_some() {
14224 len += 1;
14225 }
14226 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamNode", len)?;
14227 if self.operator_id != 0 {
14228 #[allow(clippy::needless_borrow)]
14229 #[allow(clippy::needless_borrows_for_generic_args)]
14230 struct_ser.serialize_field("operatorId", ToString::to_string(&self.operator_id).as_str())?;
14231 }
14232 if !self.input.is_empty() {
14233 struct_ser.serialize_field("input", &self.input)?;
14234 }
14235 if !self.stream_key.is_empty() {
14236 struct_ser.serialize_field("streamKey", &self.stream_key)?;
14237 }
14238 if self.stream_kind != 0 {
14239 let v = stream_node::StreamKind::try_from(self.stream_kind)
14240 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_kind)))?;
14241 struct_ser.serialize_field("streamKind", &v)?;
14242 }
14243 if !self.identity.is_empty() {
14244 struct_ser.serialize_field("identity", &self.identity)?;
14245 }
14246 if !self.fields.is_empty() {
14247 struct_ser.serialize_field("fields", &self.fields)?;
14248 }
14249 if let Some(v) = self.node_body.as_ref() {
14250 match v {
14251 stream_node::NodeBody::Source(v) => {
14252 struct_ser.serialize_field("source", v)?;
14253 }
14254 stream_node::NodeBody::Project(v) => {
14255 struct_ser.serialize_field("project", v)?;
14256 }
14257 stream_node::NodeBody::Filter(v) => {
14258 struct_ser.serialize_field("filter", v)?;
14259 }
14260 stream_node::NodeBody::Materialize(v) => {
14261 struct_ser.serialize_field("materialize", v)?;
14262 }
14263 stream_node::NodeBody::StatelessSimpleAgg(v) => {
14264 struct_ser.serialize_field("statelessSimpleAgg", v)?;
14265 }
14266 stream_node::NodeBody::SimpleAgg(v) => {
14267 struct_ser.serialize_field("simpleAgg", v)?;
14268 }
14269 stream_node::NodeBody::HashAgg(v) => {
14270 struct_ser.serialize_field("hashAgg", v)?;
14271 }
14272 stream_node::NodeBody::AppendOnlyTopN(v) => {
14273 struct_ser.serialize_field("appendOnlyTopN", v)?;
14274 }
14275 stream_node::NodeBody::HashJoin(v) => {
14276 struct_ser.serialize_field("hashJoin", v)?;
14277 }
14278 stream_node::NodeBody::TopN(v) => {
14279 struct_ser.serialize_field("topN", v)?;
14280 }
14281 stream_node::NodeBody::HopWindow(v) => {
14282 struct_ser.serialize_field("hopWindow", v)?;
14283 }
14284 stream_node::NodeBody::Merge(v) => {
14285 struct_ser.serialize_field("merge", v)?;
14286 }
14287 stream_node::NodeBody::Exchange(v) => {
14288 struct_ser.serialize_field("exchange", v)?;
14289 }
14290 stream_node::NodeBody::StreamScan(v) => {
14291 struct_ser.serialize_field("streamScan", v)?;
14292 }
14293 stream_node::NodeBody::BatchPlan(v) => {
14294 struct_ser.serialize_field("batchPlan", v)?;
14295 }
14296 stream_node::NodeBody::Lookup(v) => {
14297 struct_ser.serialize_field("lookup", v)?;
14298 }
14299 stream_node::NodeBody::Arrange(v) => {
14300 struct_ser.serialize_field("arrange", v)?;
14301 }
14302 stream_node::NodeBody::LookupUnion(v) => {
14303 struct_ser.serialize_field("lookupUnion", v)?;
14304 }
14305 stream_node::NodeBody::Union(v) => {
14306 struct_ser.serialize_field("union", v)?;
14307 }
14308 stream_node::NodeBody::DeltaIndexJoin(v) => {
14309 struct_ser.serialize_field("deltaIndexJoin", v)?;
14310 }
14311 stream_node::NodeBody::Sink(v) => {
14312 struct_ser.serialize_field("sink", v)?;
14313 }
14314 stream_node::NodeBody::Expand(v) => {
14315 struct_ser.serialize_field("expand", v)?;
14316 }
14317 stream_node::NodeBody::DynamicFilter(v) => {
14318 struct_ser.serialize_field("dynamicFilter", v)?;
14319 }
14320 stream_node::NodeBody::ProjectSet(v) => {
14321 struct_ser.serialize_field("projectSet", v)?;
14322 }
14323 stream_node::NodeBody::GroupTopN(v) => {
14324 struct_ser.serialize_field("groupTopN", v)?;
14325 }
14326 stream_node::NodeBody::Sort(v) => {
14327 struct_ser.serialize_field("sort", v)?;
14328 }
14329 stream_node::NodeBody::WatermarkFilter(v) => {
14330 struct_ser.serialize_field("watermarkFilter", v)?;
14331 }
14332 stream_node::NodeBody::Dml(v) => {
14333 struct_ser.serialize_field("dml", v)?;
14334 }
14335 stream_node::NodeBody::RowIdGen(v) => {
14336 struct_ser.serialize_field("rowIdGen", v)?;
14337 }
14338 stream_node::NodeBody::Now(v) => {
14339 struct_ser.serialize_field("now", v)?;
14340 }
14341 stream_node::NodeBody::AppendOnlyGroupTopN(v) => {
14342 struct_ser.serialize_field("appendOnlyGroupTopN", v)?;
14343 }
14344 stream_node::NodeBody::TemporalJoin(v) => {
14345 struct_ser.serialize_field("temporalJoin", v)?;
14346 }
14347 stream_node::NodeBody::BarrierRecv(v) => {
14348 struct_ser.serialize_field("barrierRecv", v)?;
14349 }
14350 stream_node::NodeBody::Values(v) => {
14351 struct_ser.serialize_field("values", v)?;
14352 }
14353 stream_node::NodeBody::AppendOnlyDedup(v) => {
14354 struct_ser.serialize_field("appendOnlyDedup", v)?;
14355 }
14356 stream_node::NodeBody::NoOp(v) => {
14357 struct_ser.serialize_field("noOp", v)?;
14358 }
14359 stream_node::NodeBody::EowcOverWindow(v) => {
14360 struct_ser.serialize_field("eowcOverWindow", v)?;
14361 }
14362 stream_node::NodeBody::OverWindow(v) => {
14363 struct_ser.serialize_field("overWindow", v)?;
14364 }
14365 stream_node::NodeBody::StreamFsFetch(v) => {
14366 struct_ser.serialize_field("streamFsFetch", v)?;
14367 }
14368 stream_node::NodeBody::StreamCdcScan(v) => {
14369 struct_ser.serialize_field("streamCdcScan", v)?;
14370 }
14371 stream_node::NodeBody::CdcFilter(v) => {
14372 struct_ser.serialize_field("cdcFilter", v)?;
14373 }
14374 stream_node::NodeBody::SourceBackfill(v) => {
14375 struct_ser.serialize_field("sourceBackfill", v)?;
14376 }
14377 stream_node::NodeBody::Changelog(v) => {
14378 struct_ser.serialize_field("changelog", v)?;
14379 }
14380 stream_node::NodeBody::LocalApproxPercentile(v) => {
14381 struct_ser.serialize_field("localApproxPercentile", v)?;
14382 }
14383 stream_node::NodeBody::GlobalApproxPercentile(v) => {
14384 struct_ser.serialize_field("globalApproxPercentile", v)?;
14385 }
14386 stream_node::NodeBody::RowMerge(v) => {
14387 struct_ser.serialize_field("rowMerge", v)?;
14388 }
14389 stream_node::NodeBody::AsOfJoin(v) => {
14390 struct_ser.serialize_field("asOfJoin", v)?;
14391 }
14392 stream_node::NodeBody::SyncLogStore(v) => {
14393 struct_ser.serialize_field("syncLogStore", v)?;
14394 }
14395 stream_node::NodeBody::MaterializedExprs(v) => {
14396 struct_ser.serialize_field("materializedExprs", v)?;
14397 }
14398 stream_node::NodeBody::VectorIndexWrite(v) => {
14399 struct_ser.serialize_field("vectorIndexWrite", v)?;
14400 }
14401 stream_node::NodeBody::UpstreamSinkUnion(v) => {
14402 struct_ser.serialize_field("upstreamSinkUnion", v)?;
14403 }
14404 stream_node::NodeBody::LocalityProvider(v) => {
14405 struct_ser.serialize_field("localityProvider", v)?;
14406 }
14407 stream_node::NodeBody::EowcGapFill(v) => {
14408 struct_ser.serialize_field("eowcGapFill", v)?;
14409 }
14410 stream_node::NodeBody::GapFill(v) => {
14411 struct_ser.serialize_field("gapFill", v)?;
14412 }
14413 stream_node::NodeBody::VectorIndexLookupJoin(v) => {
14414 struct_ser.serialize_field("vectorIndexLookupJoin", v)?;
14415 }
14416 stream_node::NodeBody::IcebergWithPkIndexWriter(v) => {
14417 struct_ser.serialize_field("icebergWithPkIndexWriter", v)?;
14418 }
14419 stream_node::NodeBody::IcebergWithPkIndexDvMerger(v) => {
14420 struct_ser.serialize_field("icebergWithPkIndexDvMerger", v)?;
14421 }
14422 }
14423 }
14424 struct_ser.end()
14425 }
14426}
14427impl<'de> serde::Deserialize<'de> for StreamNode {
14428 #[allow(deprecated)]
14429 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14430 where
14431 D: serde::Deserializer<'de>,
14432 {
14433 const FIELDS: &[&str] = &[
14434 "operator_id",
14435 "operatorId",
14436 "input",
14437 "stream_key",
14438 "streamKey",
14439 "stream_kind",
14440 "streamKind",
14441 "identity",
14442 "fields",
14443 "source",
14444 "project",
14445 "filter",
14446 "materialize",
14447 "stateless_simple_agg",
14448 "statelessSimpleAgg",
14449 "simple_agg",
14450 "simpleAgg",
14451 "hash_agg",
14452 "hashAgg",
14453 "append_only_top_n",
14454 "appendOnlyTopN",
14455 "hash_join",
14456 "hashJoin",
14457 "top_n",
14458 "topN",
14459 "hop_window",
14460 "hopWindow",
14461 "merge",
14462 "exchange",
14463 "stream_scan",
14464 "streamScan",
14465 "batch_plan",
14466 "batchPlan",
14467 "lookup",
14468 "arrange",
14469 "lookup_union",
14470 "lookupUnion",
14471 "union",
14472 "delta_index_join",
14473 "deltaIndexJoin",
14474 "sink",
14475 "expand",
14476 "dynamic_filter",
14477 "dynamicFilter",
14478 "project_set",
14479 "projectSet",
14480 "group_top_n",
14481 "groupTopN",
14482 "sort",
14483 "watermark_filter",
14484 "watermarkFilter",
14485 "dml",
14486 "row_id_gen",
14487 "rowIdGen",
14488 "now",
14489 "append_only_group_top_n",
14490 "appendOnlyGroupTopN",
14491 "temporal_join",
14492 "temporalJoin",
14493 "barrier_recv",
14494 "barrierRecv",
14495 "values",
14496 "append_only_dedup",
14497 "appendOnlyDedup",
14498 "no_op",
14499 "noOp",
14500 "eowc_over_window",
14501 "eowcOverWindow",
14502 "over_window",
14503 "overWindow",
14504 "stream_fs_fetch",
14505 "streamFsFetch",
14506 "stream_cdc_scan",
14507 "streamCdcScan",
14508 "cdc_filter",
14509 "cdcFilter",
14510 "source_backfill",
14511 "sourceBackfill",
14512 "changelog",
14513 "local_approx_percentile",
14514 "localApproxPercentile",
14515 "global_approx_percentile",
14516 "globalApproxPercentile",
14517 "row_merge",
14518 "rowMerge",
14519 "as_of_join",
14520 "asOfJoin",
14521 "sync_log_store",
14522 "syncLogStore",
14523 "materialized_exprs",
14524 "materializedExprs",
14525 "vector_index_write",
14526 "vectorIndexWrite",
14527 "upstream_sink_union",
14528 "upstreamSinkUnion",
14529 "locality_provider",
14530 "localityProvider",
14531 "eowc_gap_fill",
14532 "eowcGapFill",
14533 "gap_fill",
14534 "gapFill",
14535 "vector_index_lookup_join",
14536 "vectorIndexLookupJoin",
14537 "iceberg_with_pk_index_writer",
14538 "icebergWithPkIndexWriter",
14539 "iceberg_with_pk_index_dv_merger",
14540 "icebergWithPkIndexDvMerger",
14541 ];
14542
14543 #[allow(clippy::enum_variant_names)]
14544 enum GeneratedField {
14545 OperatorId,
14546 Input,
14547 StreamKey,
14548 StreamKind,
14549 Identity,
14550 Fields,
14551 Source,
14552 Project,
14553 Filter,
14554 Materialize,
14555 StatelessSimpleAgg,
14556 SimpleAgg,
14557 HashAgg,
14558 AppendOnlyTopN,
14559 HashJoin,
14560 TopN,
14561 HopWindow,
14562 Merge,
14563 Exchange,
14564 StreamScan,
14565 BatchPlan,
14566 Lookup,
14567 Arrange,
14568 LookupUnion,
14569 Union,
14570 DeltaIndexJoin,
14571 Sink,
14572 Expand,
14573 DynamicFilter,
14574 ProjectSet,
14575 GroupTopN,
14576 Sort,
14577 WatermarkFilter,
14578 Dml,
14579 RowIdGen,
14580 Now,
14581 AppendOnlyGroupTopN,
14582 TemporalJoin,
14583 BarrierRecv,
14584 Values,
14585 AppendOnlyDedup,
14586 NoOp,
14587 EowcOverWindow,
14588 OverWindow,
14589 StreamFsFetch,
14590 StreamCdcScan,
14591 CdcFilter,
14592 SourceBackfill,
14593 Changelog,
14594 LocalApproxPercentile,
14595 GlobalApproxPercentile,
14596 RowMerge,
14597 AsOfJoin,
14598 SyncLogStore,
14599 MaterializedExprs,
14600 VectorIndexWrite,
14601 UpstreamSinkUnion,
14602 LocalityProvider,
14603 EowcGapFill,
14604 GapFill,
14605 VectorIndexLookupJoin,
14606 IcebergWithPkIndexWriter,
14607 IcebergWithPkIndexDvMerger,
14608 }
14609 impl<'de> serde::Deserialize<'de> for GeneratedField {
14610 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14611 where
14612 D: serde::Deserializer<'de>,
14613 {
14614 struct GeneratedVisitor;
14615
14616 impl serde::de::Visitor<'_> for GeneratedVisitor {
14617 type Value = GeneratedField;
14618
14619 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14620 write!(formatter, "expected one of: {:?}", &FIELDS)
14621 }
14622
14623 #[allow(unused_variables)]
14624 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14625 where
14626 E: serde::de::Error,
14627 {
14628 match value {
14629 "operatorId" | "operator_id" => Ok(GeneratedField::OperatorId),
14630 "input" => Ok(GeneratedField::Input),
14631 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
14632 "streamKind" | "stream_kind" => Ok(GeneratedField::StreamKind),
14633 "identity" => Ok(GeneratedField::Identity),
14634 "fields" => Ok(GeneratedField::Fields),
14635 "source" => Ok(GeneratedField::Source),
14636 "project" => Ok(GeneratedField::Project),
14637 "filter" => Ok(GeneratedField::Filter),
14638 "materialize" => Ok(GeneratedField::Materialize),
14639 "statelessSimpleAgg" | "stateless_simple_agg" => Ok(GeneratedField::StatelessSimpleAgg),
14640 "simpleAgg" | "simple_agg" => Ok(GeneratedField::SimpleAgg),
14641 "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
14642 "appendOnlyTopN" | "append_only_top_n" => Ok(GeneratedField::AppendOnlyTopN),
14643 "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
14644 "topN" | "top_n" => Ok(GeneratedField::TopN),
14645 "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
14646 "merge" => Ok(GeneratedField::Merge),
14647 "exchange" => Ok(GeneratedField::Exchange),
14648 "streamScan" | "stream_scan" => Ok(GeneratedField::StreamScan),
14649 "batchPlan" | "batch_plan" => Ok(GeneratedField::BatchPlan),
14650 "lookup" => Ok(GeneratedField::Lookup),
14651 "arrange" => Ok(GeneratedField::Arrange),
14652 "lookupUnion" | "lookup_union" => Ok(GeneratedField::LookupUnion),
14653 "union" => Ok(GeneratedField::Union),
14654 "deltaIndexJoin" | "delta_index_join" => Ok(GeneratedField::DeltaIndexJoin),
14655 "sink" => Ok(GeneratedField::Sink),
14656 "expand" => Ok(GeneratedField::Expand),
14657 "dynamicFilter" | "dynamic_filter" => Ok(GeneratedField::DynamicFilter),
14658 "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
14659 "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
14660 "sort" => Ok(GeneratedField::Sort),
14661 "watermarkFilter" | "watermark_filter" => Ok(GeneratedField::WatermarkFilter),
14662 "dml" => Ok(GeneratedField::Dml),
14663 "rowIdGen" | "row_id_gen" => Ok(GeneratedField::RowIdGen),
14664 "now" => Ok(GeneratedField::Now),
14665 "appendOnlyGroupTopN" | "append_only_group_top_n" => Ok(GeneratedField::AppendOnlyGroupTopN),
14666 "temporalJoin" | "temporal_join" => Ok(GeneratedField::TemporalJoin),
14667 "barrierRecv" | "barrier_recv" => Ok(GeneratedField::BarrierRecv),
14668 "values" => Ok(GeneratedField::Values),
14669 "appendOnlyDedup" | "append_only_dedup" => Ok(GeneratedField::AppendOnlyDedup),
14670 "noOp" | "no_op" => Ok(GeneratedField::NoOp),
14671 "eowcOverWindow" | "eowc_over_window" => Ok(GeneratedField::EowcOverWindow),
14672 "overWindow" | "over_window" => Ok(GeneratedField::OverWindow),
14673 "streamFsFetch" | "stream_fs_fetch" => Ok(GeneratedField::StreamFsFetch),
14674 "streamCdcScan" | "stream_cdc_scan" => Ok(GeneratedField::StreamCdcScan),
14675 "cdcFilter" | "cdc_filter" => Ok(GeneratedField::CdcFilter),
14676 "sourceBackfill" | "source_backfill" => Ok(GeneratedField::SourceBackfill),
14677 "changelog" => Ok(GeneratedField::Changelog),
14678 "localApproxPercentile" | "local_approx_percentile" => Ok(GeneratedField::LocalApproxPercentile),
14679 "globalApproxPercentile" | "global_approx_percentile" => Ok(GeneratedField::GlobalApproxPercentile),
14680 "rowMerge" | "row_merge" => Ok(GeneratedField::RowMerge),
14681 "asOfJoin" | "as_of_join" => Ok(GeneratedField::AsOfJoin),
14682 "syncLogStore" | "sync_log_store" => Ok(GeneratedField::SyncLogStore),
14683 "materializedExprs" | "materialized_exprs" => Ok(GeneratedField::MaterializedExprs),
14684 "vectorIndexWrite" | "vector_index_write" => Ok(GeneratedField::VectorIndexWrite),
14685 "upstreamSinkUnion" | "upstream_sink_union" => Ok(GeneratedField::UpstreamSinkUnion),
14686 "localityProvider" | "locality_provider" => Ok(GeneratedField::LocalityProvider),
14687 "eowcGapFill" | "eowc_gap_fill" => Ok(GeneratedField::EowcGapFill),
14688 "gapFill" | "gap_fill" => Ok(GeneratedField::GapFill),
14689 "vectorIndexLookupJoin" | "vector_index_lookup_join" => Ok(GeneratedField::VectorIndexLookupJoin),
14690 "icebergWithPkIndexWriter" | "iceberg_with_pk_index_writer" => Ok(GeneratedField::IcebergWithPkIndexWriter),
14691 "icebergWithPkIndexDvMerger" | "iceberg_with_pk_index_dv_merger" => Ok(GeneratedField::IcebergWithPkIndexDvMerger),
14692 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14693 }
14694 }
14695 }
14696 deserializer.deserialize_identifier(GeneratedVisitor)
14697 }
14698 }
14699 struct GeneratedVisitor;
14700 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14701 type Value = StreamNode;
14702
14703 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14704 formatter.write_str("struct stream_plan.StreamNode")
14705 }
14706
14707 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamNode, V::Error>
14708 where
14709 V: serde::de::MapAccess<'de>,
14710 {
14711 let mut operator_id__ = None;
14712 let mut input__ = None;
14713 let mut stream_key__ = None;
14714 let mut stream_kind__ = None;
14715 let mut identity__ = None;
14716 let mut fields__ = None;
14717 let mut node_body__ = None;
14718 while let Some(k) = map_.next_key()? {
14719 match k {
14720 GeneratedField::OperatorId => {
14721 if operator_id__.is_some() {
14722 return Err(serde::de::Error::duplicate_field("operatorId"));
14723 }
14724 operator_id__ =
14725 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14726 ;
14727 }
14728 GeneratedField::Input => {
14729 if input__.is_some() {
14730 return Err(serde::de::Error::duplicate_field("input"));
14731 }
14732 input__ = Some(map_.next_value()?);
14733 }
14734 GeneratedField::StreamKey => {
14735 if stream_key__.is_some() {
14736 return Err(serde::de::Error::duplicate_field("streamKey"));
14737 }
14738 stream_key__ =
14739 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14740 .into_iter().map(|x| x.0).collect())
14741 ;
14742 }
14743 GeneratedField::StreamKind => {
14744 if stream_kind__.is_some() {
14745 return Err(serde::de::Error::duplicate_field("streamKind"));
14746 }
14747 stream_kind__ = Some(map_.next_value::<stream_node::StreamKind>()? as i32);
14748 }
14749 GeneratedField::Identity => {
14750 if identity__.is_some() {
14751 return Err(serde::de::Error::duplicate_field("identity"));
14752 }
14753 identity__ = Some(map_.next_value()?);
14754 }
14755 GeneratedField::Fields => {
14756 if fields__.is_some() {
14757 return Err(serde::de::Error::duplicate_field("fields"));
14758 }
14759 fields__ = Some(map_.next_value()?);
14760 }
14761 GeneratedField::Source => {
14762 if node_body__.is_some() {
14763 return Err(serde::de::Error::duplicate_field("source"));
14764 }
14765 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Source)
14766;
14767 }
14768 GeneratedField::Project => {
14769 if node_body__.is_some() {
14770 return Err(serde::de::Error::duplicate_field("project"));
14771 }
14772 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Project)
14773;
14774 }
14775 GeneratedField::Filter => {
14776 if node_body__.is_some() {
14777 return Err(serde::de::Error::duplicate_field("filter"));
14778 }
14779 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Filter)
14780;
14781 }
14782 GeneratedField::Materialize => {
14783 if node_body__.is_some() {
14784 return Err(serde::de::Error::duplicate_field("materialize"));
14785 }
14786 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Materialize)
14787;
14788 }
14789 GeneratedField::StatelessSimpleAgg => {
14790 if node_body__.is_some() {
14791 return Err(serde::de::Error::duplicate_field("statelessSimpleAgg"));
14792 }
14793 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StatelessSimpleAgg)
14794;
14795 }
14796 GeneratedField::SimpleAgg => {
14797 if node_body__.is_some() {
14798 return Err(serde::de::Error::duplicate_field("simpleAgg"));
14799 }
14800 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SimpleAgg)
14801;
14802 }
14803 GeneratedField::HashAgg => {
14804 if node_body__.is_some() {
14805 return Err(serde::de::Error::duplicate_field("hashAgg"));
14806 }
14807 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashAgg)
14808;
14809 }
14810 GeneratedField::AppendOnlyTopN => {
14811 if node_body__.is_some() {
14812 return Err(serde::de::Error::duplicate_field("appendOnlyTopN"));
14813 }
14814 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyTopN)
14815;
14816 }
14817 GeneratedField::HashJoin => {
14818 if node_body__.is_some() {
14819 return Err(serde::de::Error::duplicate_field("hashJoin"));
14820 }
14821 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashJoin)
14822;
14823 }
14824 GeneratedField::TopN => {
14825 if node_body__.is_some() {
14826 return Err(serde::de::Error::duplicate_field("topN"));
14827 }
14828 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TopN)
14829;
14830 }
14831 GeneratedField::HopWindow => {
14832 if node_body__.is_some() {
14833 return Err(serde::de::Error::duplicate_field("hopWindow"));
14834 }
14835 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HopWindow)
14836;
14837 }
14838 GeneratedField::Merge => {
14839 if node_body__.is_some() {
14840 return Err(serde::de::Error::duplicate_field("merge"));
14841 }
14842 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Merge)
14843;
14844 }
14845 GeneratedField::Exchange => {
14846 if node_body__.is_some() {
14847 return Err(serde::de::Error::duplicate_field("exchange"));
14848 }
14849 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Exchange)
14850;
14851 }
14852 GeneratedField::StreamScan => {
14853 if node_body__.is_some() {
14854 return Err(serde::de::Error::duplicate_field("streamScan"));
14855 }
14856 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamScan)
14857;
14858 }
14859 GeneratedField::BatchPlan => {
14860 if node_body__.is_some() {
14861 return Err(serde::de::Error::duplicate_field("batchPlan"));
14862 }
14863 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BatchPlan)
14864;
14865 }
14866 GeneratedField::Lookup => {
14867 if node_body__.is_some() {
14868 return Err(serde::de::Error::duplicate_field("lookup"));
14869 }
14870 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Lookup)
14871;
14872 }
14873 GeneratedField::Arrange => {
14874 if node_body__.is_some() {
14875 return Err(serde::de::Error::duplicate_field("arrange"));
14876 }
14877 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Arrange)
14878;
14879 }
14880 GeneratedField::LookupUnion => {
14881 if node_body__.is_some() {
14882 return Err(serde::de::Error::duplicate_field("lookupUnion"));
14883 }
14884 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LookupUnion)
14885;
14886 }
14887 GeneratedField::Union => {
14888 if node_body__.is_some() {
14889 return Err(serde::de::Error::duplicate_field("union"));
14890 }
14891 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Union)
14892;
14893 }
14894 GeneratedField::DeltaIndexJoin => {
14895 if node_body__.is_some() {
14896 return Err(serde::de::Error::duplicate_field("deltaIndexJoin"));
14897 }
14898 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DeltaIndexJoin)
14899;
14900 }
14901 GeneratedField::Sink => {
14902 if node_body__.is_some() {
14903 return Err(serde::de::Error::duplicate_field("sink"));
14904 }
14905 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sink)
14906;
14907 }
14908 GeneratedField::Expand => {
14909 if node_body__.is_some() {
14910 return Err(serde::de::Error::duplicate_field("expand"));
14911 }
14912 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Expand)
14913;
14914 }
14915 GeneratedField::DynamicFilter => {
14916 if node_body__.is_some() {
14917 return Err(serde::de::Error::duplicate_field("dynamicFilter"));
14918 }
14919 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DynamicFilter)
14920;
14921 }
14922 GeneratedField::ProjectSet => {
14923 if node_body__.is_some() {
14924 return Err(serde::de::Error::duplicate_field("projectSet"));
14925 }
14926 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::ProjectSet)
14927;
14928 }
14929 GeneratedField::GroupTopN => {
14930 if node_body__.is_some() {
14931 return Err(serde::de::Error::duplicate_field("groupTopN"));
14932 }
14933 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GroupTopN)
14934;
14935 }
14936 GeneratedField::Sort => {
14937 if node_body__.is_some() {
14938 return Err(serde::de::Error::duplicate_field("sort"));
14939 }
14940 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sort)
14941;
14942 }
14943 GeneratedField::WatermarkFilter => {
14944 if node_body__.is_some() {
14945 return Err(serde::de::Error::duplicate_field("watermarkFilter"));
14946 }
14947 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::WatermarkFilter)
14948;
14949 }
14950 GeneratedField::Dml => {
14951 if node_body__.is_some() {
14952 return Err(serde::de::Error::duplicate_field("dml"));
14953 }
14954 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Dml)
14955;
14956 }
14957 GeneratedField::RowIdGen => {
14958 if node_body__.is_some() {
14959 return Err(serde::de::Error::duplicate_field("rowIdGen"));
14960 }
14961 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowIdGen)
14962;
14963 }
14964 GeneratedField::Now => {
14965 if node_body__.is_some() {
14966 return Err(serde::de::Error::duplicate_field("now"));
14967 }
14968 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Now)
14969;
14970 }
14971 GeneratedField::AppendOnlyGroupTopN => {
14972 if node_body__.is_some() {
14973 return Err(serde::de::Error::duplicate_field("appendOnlyGroupTopN"));
14974 }
14975 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyGroupTopN)
14976;
14977 }
14978 GeneratedField::TemporalJoin => {
14979 if node_body__.is_some() {
14980 return Err(serde::de::Error::duplicate_field("temporalJoin"));
14981 }
14982 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TemporalJoin)
14983;
14984 }
14985 GeneratedField::BarrierRecv => {
14986 if node_body__.is_some() {
14987 return Err(serde::de::Error::duplicate_field("barrierRecv"));
14988 }
14989 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BarrierRecv)
14990;
14991 }
14992 GeneratedField::Values => {
14993 if node_body__.is_some() {
14994 return Err(serde::de::Error::duplicate_field("values"));
14995 }
14996 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Values)
14997;
14998 }
14999 GeneratedField::AppendOnlyDedup => {
15000 if node_body__.is_some() {
15001 return Err(serde::de::Error::duplicate_field("appendOnlyDedup"));
15002 }
15003 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyDedup)
15004;
15005 }
15006 GeneratedField::NoOp => {
15007 if node_body__.is_some() {
15008 return Err(serde::de::Error::duplicate_field("noOp"));
15009 }
15010 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::NoOp)
15011;
15012 }
15013 GeneratedField::EowcOverWindow => {
15014 if node_body__.is_some() {
15015 return Err(serde::de::Error::duplicate_field("eowcOverWindow"));
15016 }
15017 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcOverWindow)
15018;
15019 }
15020 GeneratedField::OverWindow => {
15021 if node_body__.is_some() {
15022 return Err(serde::de::Error::duplicate_field("overWindow"));
15023 }
15024 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::OverWindow)
15025;
15026 }
15027 GeneratedField::StreamFsFetch => {
15028 if node_body__.is_some() {
15029 return Err(serde::de::Error::duplicate_field("streamFsFetch"));
15030 }
15031 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamFsFetch)
15032;
15033 }
15034 GeneratedField::StreamCdcScan => {
15035 if node_body__.is_some() {
15036 return Err(serde::de::Error::duplicate_field("streamCdcScan"));
15037 }
15038 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamCdcScan)
15039;
15040 }
15041 GeneratedField::CdcFilter => {
15042 if node_body__.is_some() {
15043 return Err(serde::de::Error::duplicate_field("cdcFilter"));
15044 }
15045 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CdcFilter)
15046;
15047 }
15048 GeneratedField::SourceBackfill => {
15049 if node_body__.is_some() {
15050 return Err(serde::de::Error::duplicate_field("sourceBackfill"));
15051 }
15052 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SourceBackfill)
15053;
15054 }
15055 GeneratedField::Changelog => {
15056 if node_body__.is_some() {
15057 return Err(serde::de::Error::duplicate_field("changelog"));
15058 }
15059 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Changelog)
15060;
15061 }
15062 GeneratedField::LocalApproxPercentile => {
15063 if node_body__.is_some() {
15064 return Err(serde::de::Error::duplicate_field("localApproxPercentile"));
15065 }
15066 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalApproxPercentile)
15067;
15068 }
15069 GeneratedField::GlobalApproxPercentile => {
15070 if node_body__.is_some() {
15071 return Err(serde::de::Error::duplicate_field("globalApproxPercentile"));
15072 }
15073 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GlobalApproxPercentile)
15074;
15075 }
15076 GeneratedField::RowMerge => {
15077 if node_body__.is_some() {
15078 return Err(serde::de::Error::duplicate_field("rowMerge"));
15079 }
15080 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowMerge)
15081;
15082 }
15083 GeneratedField::AsOfJoin => {
15084 if node_body__.is_some() {
15085 return Err(serde::de::Error::duplicate_field("asOfJoin"));
15086 }
15087 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AsOfJoin)
15088;
15089 }
15090 GeneratedField::SyncLogStore => {
15091 if node_body__.is_some() {
15092 return Err(serde::de::Error::duplicate_field("syncLogStore"));
15093 }
15094 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SyncLogStore)
15095;
15096 }
15097 GeneratedField::MaterializedExprs => {
15098 if node_body__.is_some() {
15099 return Err(serde::de::Error::duplicate_field("materializedExprs"));
15100 }
15101 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MaterializedExprs)
15102;
15103 }
15104 GeneratedField::VectorIndexWrite => {
15105 if node_body__.is_some() {
15106 return Err(serde::de::Error::duplicate_field("vectorIndexWrite"));
15107 }
15108 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexWrite)
15109;
15110 }
15111 GeneratedField::UpstreamSinkUnion => {
15112 if node_body__.is_some() {
15113 return Err(serde::de::Error::duplicate_field("upstreamSinkUnion"));
15114 }
15115 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::UpstreamSinkUnion)
15116;
15117 }
15118 GeneratedField::LocalityProvider => {
15119 if node_body__.is_some() {
15120 return Err(serde::de::Error::duplicate_field("localityProvider"));
15121 }
15122 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalityProvider)
15123;
15124 }
15125 GeneratedField::EowcGapFill => {
15126 if node_body__.is_some() {
15127 return Err(serde::de::Error::duplicate_field("eowcGapFill"));
15128 }
15129 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcGapFill)
15130;
15131 }
15132 GeneratedField::GapFill => {
15133 if node_body__.is_some() {
15134 return Err(serde::de::Error::duplicate_field("gapFill"));
15135 }
15136 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GapFill)
15137;
15138 }
15139 GeneratedField::VectorIndexLookupJoin => {
15140 if node_body__.is_some() {
15141 return Err(serde::de::Error::duplicate_field("vectorIndexLookupJoin"));
15142 }
15143 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexLookupJoin)
15144;
15145 }
15146 GeneratedField::IcebergWithPkIndexWriter => {
15147 if node_body__.is_some() {
15148 return Err(serde::de::Error::duplicate_field("icebergWithPkIndexWriter"));
15149 }
15150 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::IcebergWithPkIndexWriter)
15151;
15152 }
15153 GeneratedField::IcebergWithPkIndexDvMerger => {
15154 if node_body__.is_some() {
15155 return Err(serde::de::Error::duplicate_field("icebergWithPkIndexDvMerger"));
15156 }
15157 node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::IcebergWithPkIndexDvMerger)
15158;
15159 }
15160 }
15161 }
15162 Ok(StreamNode {
15163 operator_id: operator_id__.unwrap_or_default(),
15164 input: input__.unwrap_or_default(),
15165 stream_key: stream_key__.unwrap_or_default(),
15166 stream_kind: stream_kind__.unwrap_or_default(),
15167 identity: identity__.unwrap_or_default(),
15168 fields: fields__.unwrap_or_default(),
15169 node_body: node_body__,
15170 })
15171 }
15172 }
15173 deserializer.deserialize_struct("stream_plan.StreamNode", FIELDS, GeneratedVisitor)
15174 }
15175}
15176impl serde::Serialize for stream_node::StreamKind {
15177 #[allow(deprecated)]
15178 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15179 where
15180 S: serde::Serializer,
15181 {
15182 let variant = match self {
15183 Self::Retract => "STREAM_KIND_RETRACT",
15184 Self::AppendOnly => "STREAM_KIND_APPEND_ONLY",
15185 Self::Upsert => "STREAM_KIND_UPSERT",
15186 };
15187 serializer.serialize_str(variant)
15188 }
15189}
15190impl<'de> serde::Deserialize<'de> for stream_node::StreamKind {
15191 #[allow(deprecated)]
15192 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15193 where
15194 D: serde::Deserializer<'de>,
15195 {
15196 const FIELDS: &[&str] = &[
15197 "STREAM_KIND_RETRACT",
15198 "STREAM_KIND_APPEND_ONLY",
15199 "STREAM_KIND_UPSERT",
15200 ];
15201
15202 struct GeneratedVisitor;
15203
15204 impl serde::de::Visitor<'_> for GeneratedVisitor {
15205 type Value = stream_node::StreamKind;
15206
15207 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15208 write!(formatter, "expected one of: {:?}", &FIELDS)
15209 }
15210
15211 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15212 where
15213 E: serde::de::Error,
15214 {
15215 i32::try_from(v)
15216 .ok()
15217 .and_then(|x| x.try_into().ok())
15218 .ok_or_else(|| {
15219 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15220 })
15221 }
15222
15223 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15224 where
15225 E: serde::de::Error,
15226 {
15227 i32::try_from(v)
15228 .ok()
15229 .and_then(|x| x.try_into().ok())
15230 .ok_or_else(|| {
15231 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15232 })
15233 }
15234
15235 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15236 where
15237 E: serde::de::Error,
15238 {
15239 match value {
15240 "STREAM_KIND_RETRACT" => Ok(stream_node::StreamKind::Retract),
15241 "STREAM_KIND_APPEND_ONLY" => Ok(stream_node::StreamKind::AppendOnly),
15242 "STREAM_KIND_UPSERT" => Ok(stream_node::StreamKind::Upsert),
15243 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15244 }
15245 }
15246 }
15247 deserializer.deserialize_any(GeneratedVisitor)
15248 }
15249}
15250impl serde::Serialize for StreamScanNode {
15251 #[allow(deprecated)]
15252 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15253 where
15254 S: serde::Serializer,
15255 {
15256 use serde::ser::SerializeStruct;
15257 let mut len = 0;
15258 if self.table_id != 0 {
15259 len += 1;
15260 }
15261 if !self.upstream_column_ids.is_empty() {
15262 len += 1;
15263 }
15264 if !self.output_indices.is_empty() {
15265 len += 1;
15266 }
15267 if self.stream_scan_type != 0 {
15268 len += 1;
15269 }
15270 if self.state_table.is_some() {
15271 len += 1;
15272 }
15273 if self.table_desc.is_some() {
15274 len += 1;
15275 }
15276 if self.rate_limit.is_some() {
15277 len += 1;
15278 }
15279 if self.snapshot_read_barrier_interval != 0 {
15280 len += 1;
15281 }
15282 if self.arrangement_table.is_some() {
15283 len += 1;
15284 }
15285 if self.snapshot_backfill_epoch.is_some() {
15286 len += 1;
15287 }
15288 if self.pk_scan_range.is_some() {
15289 len += 1;
15290 }
15291 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamScanNode", len)?;
15292 if self.table_id != 0 {
15293 struct_ser.serialize_field("tableId", &self.table_id)?;
15294 }
15295 if !self.upstream_column_ids.is_empty() {
15296 struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
15297 }
15298 if !self.output_indices.is_empty() {
15299 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
15300 }
15301 if self.stream_scan_type != 0 {
15302 let v = StreamScanType::try_from(self.stream_scan_type)
15303 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_scan_type)))?;
15304 struct_ser.serialize_field("streamScanType", &v)?;
15305 }
15306 if let Some(v) = self.state_table.as_ref() {
15307 struct_ser.serialize_field("stateTable", v)?;
15308 }
15309 if let Some(v) = self.table_desc.as_ref() {
15310 struct_ser.serialize_field("tableDesc", v)?;
15311 }
15312 if let Some(v) = self.rate_limit.as_ref() {
15313 struct_ser.serialize_field("rateLimit", v)?;
15314 }
15315 if self.snapshot_read_barrier_interval != 0 {
15316 struct_ser.serialize_field("snapshotReadBarrierInterval", &self.snapshot_read_barrier_interval)?;
15317 }
15318 if let Some(v) = self.arrangement_table.as_ref() {
15319 struct_ser.serialize_field("arrangementTable", v)?;
15320 }
15321 if let Some(v) = self.snapshot_backfill_epoch.as_ref() {
15322 #[allow(clippy::needless_borrow)]
15323 #[allow(clippy::needless_borrows_for_generic_args)]
15324 struct_ser.serialize_field("snapshotBackfillEpoch", ToString::to_string(&v).as_str())?;
15325 }
15326 if let Some(v) = self.pk_scan_range.as_ref() {
15327 struct_ser.serialize_field("pkScanRange", v)?;
15328 }
15329 struct_ser.end()
15330 }
15331}
15332impl<'de> serde::Deserialize<'de> for StreamScanNode {
15333 #[allow(deprecated)]
15334 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15335 where
15336 D: serde::Deserializer<'de>,
15337 {
15338 const FIELDS: &[&str] = &[
15339 "table_id",
15340 "tableId",
15341 "upstream_column_ids",
15342 "upstreamColumnIds",
15343 "output_indices",
15344 "outputIndices",
15345 "stream_scan_type",
15346 "streamScanType",
15347 "state_table",
15348 "stateTable",
15349 "table_desc",
15350 "tableDesc",
15351 "rate_limit",
15352 "rateLimit",
15353 "snapshot_read_barrier_interval",
15354 "snapshotReadBarrierInterval",
15355 "arrangement_table",
15356 "arrangementTable",
15357 "snapshot_backfill_epoch",
15358 "snapshotBackfillEpoch",
15359 "pk_scan_range",
15360 "pkScanRange",
15361 ];
15362
15363 #[allow(clippy::enum_variant_names)]
15364 enum GeneratedField {
15365 TableId,
15366 UpstreamColumnIds,
15367 OutputIndices,
15368 StreamScanType,
15369 StateTable,
15370 TableDesc,
15371 RateLimit,
15372 SnapshotReadBarrierInterval,
15373 ArrangementTable,
15374 SnapshotBackfillEpoch,
15375 PkScanRange,
15376 }
15377 impl<'de> serde::Deserialize<'de> for GeneratedField {
15378 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15379 where
15380 D: serde::Deserializer<'de>,
15381 {
15382 struct GeneratedVisitor;
15383
15384 impl serde::de::Visitor<'_> for GeneratedVisitor {
15385 type Value = GeneratedField;
15386
15387 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15388 write!(formatter, "expected one of: {:?}", &FIELDS)
15389 }
15390
15391 #[allow(unused_variables)]
15392 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15393 where
15394 E: serde::de::Error,
15395 {
15396 match value {
15397 "tableId" | "table_id" => Ok(GeneratedField::TableId),
15398 "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
15399 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
15400 "streamScanType" | "stream_scan_type" => Ok(GeneratedField::StreamScanType),
15401 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
15402 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
15403 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
15404 "snapshotReadBarrierInterval" | "snapshot_read_barrier_interval" => Ok(GeneratedField::SnapshotReadBarrierInterval),
15405 "arrangementTable" | "arrangement_table" => Ok(GeneratedField::ArrangementTable),
15406 "snapshotBackfillEpoch" | "snapshot_backfill_epoch" => Ok(GeneratedField::SnapshotBackfillEpoch),
15407 "pkScanRange" | "pk_scan_range" => Ok(GeneratedField::PkScanRange),
15408 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15409 }
15410 }
15411 }
15412 deserializer.deserialize_identifier(GeneratedVisitor)
15413 }
15414 }
15415 struct GeneratedVisitor;
15416 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15417 type Value = StreamScanNode;
15418
15419 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15420 formatter.write_str("struct stream_plan.StreamScanNode")
15421 }
15422
15423 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamScanNode, V::Error>
15424 where
15425 V: serde::de::MapAccess<'de>,
15426 {
15427 let mut table_id__ = None;
15428 let mut upstream_column_ids__ = None;
15429 let mut output_indices__ = None;
15430 let mut stream_scan_type__ = None;
15431 let mut state_table__ = None;
15432 let mut table_desc__ = None;
15433 let mut rate_limit__ = None;
15434 let mut snapshot_read_barrier_interval__ = None;
15435 let mut arrangement_table__ = None;
15436 let mut snapshot_backfill_epoch__ = None;
15437 let mut pk_scan_range__ = None;
15438 while let Some(k) = map_.next_key()? {
15439 match k {
15440 GeneratedField::TableId => {
15441 if table_id__.is_some() {
15442 return Err(serde::de::Error::duplicate_field("tableId"));
15443 }
15444 table_id__ =
15445 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15446 ;
15447 }
15448 GeneratedField::UpstreamColumnIds => {
15449 if upstream_column_ids__.is_some() {
15450 return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
15451 }
15452 upstream_column_ids__ =
15453 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15454 .into_iter().map(|x| x.0).collect())
15455 ;
15456 }
15457 GeneratedField::OutputIndices => {
15458 if output_indices__.is_some() {
15459 return Err(serde::de::Error::duplicate_field("outputIndices"));
15460 }
15461 output_indices__ =
15462 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15463 .into_iter().map(|x| x.0).collect())
15464 ;
15465 }
15466 GeneratedField::StreamScanType => {
15467 if stream_scan_type__.is_some() {
15468 return Err(serde::de::Error::duplicate_field("streamScanType"));
15469 }
15470 stream_scan_type__ = Some(map_.next_value::<StreamScanType>()? as i32);
15471 }
15472 GeneratedField::StateTable => {
15473 if state_table__.is_some() {
15474 return Err(serde::de::Error::duplicate_field("stateTable"));
15475 }
15476 state_table__ = map_.next_value()?;
15477 }
15478 GeneratedField::TableDesc => {
15479 if table_desc__.is_some() {
15480 return Err(serde::de::Error::duplicate_field("tableDesc"));
15481 }
15482 table_desc__ = map_.next_value()?;
15483 }
15484 GeneratedField::RateLimit => {
15485 if rate_limit__.is_some() {
15486 return Err(serde::de::Error::duplicate_field("rateLimit"));
15487 }
15488 rate_limit__ =
15489 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15490 ;
15491 }
15492 GeneratedField::SnapshotReadBarrierInterval => {
15493 if snapshot_read_barrier_interval__.is_some() {
15494 return Err(serde::de::Error::duplicate_field("snapshotReadBarrierInterval"));
15495 }
15496 snapshot_read_barrier_interval__ =
15497 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15498 ;
15499 }
15500 GeneratedField::ArrangementTable => {
15501 if arrangement_table__.is_some() {
15502 return Err(serde::de::Error::duplicate_field("arrangementTable"));
15503 }
15504 arrangement_table__ = map_.next_value()?;
15505 }
15506 GeneratedField::SnapshotBackfillEpoch => {
15507 if snapshot_backfill_epoch__.is_some() {
15508 return Err(serde::de::Error::duplicate_field("snapshotBackfillEpoch"));
15509 }
15510 snapshot_backfill_epoch__ =
15511 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15512 ;
15513 }
15514 GeneratedField::PkScanRange => {
15515 if pk_scan_range__.is_some() {
15516 return Err(serde::de::Error::duplicate_field("pkScanRange"));
15517 }
15518 pk_scan_range__ = map_.next_value()?;
15519 }
15520 }
15521 }
15522 Ok(StreamScanNode {
15523 table_id: table_id__.unwrap_or_default(),
15524 upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
15525 output_indices: output_indices__.unwrap_or_default(),
15526 stream_scan_type: stream_scan_type__.unwrap_or_default(),
15527 state_table: state_table__,
15528 table_desc: table_desc__,
15529 rate_limit: rate_limit__,
15530 snapshot_read_barrier_interval: snapshot_read_barrier_interval__.unwrap_or_default(),
15531 arrangement_table: arrangement_table__,
15532 snapshot_backfill_epoch: snapshot_backfill_epoch__,
15533 pk_scan_range: pk_scan_range__,
15534 })
15535 }
15536 }
15537 deserializer.deserialize_struct("stream_plan.StreamScanNode", FIELDS, GeneratedVisitor)
15538 }
15539}
15540impl serde::Serialize for StreamScanType {
15541 #[allow(deprecated)]
15542 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15543 where
15544 S: serde::Serializer,
15545 {
15546 let variant = match self {
15547 Self::Unspecified => "STREAM_SCAN_TYPE_UNSPECIFIED",
15548 Self::Chain => "STREAM_SCAN_TYPE_CHAIN",
15549 Self::Rearrange => "STREAM_SCAN_TYPE_REARRANGE",
15550 Self::Backfill => "STREAM_SCAN_TYPE_BACKFILL",
15551 Self::UpstreamOnly => "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
15552 Self::ArrangementBackfill => "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
15553 Self::SnapshotBackfill => "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
15554 Self::CrossDbSnapshotBackfill => "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
15555 };
15556 serializer.serialize_str(variant)
15557 }
15558}
15559impl<'de> serde::Deserialize<'de> for StreamScanType {
15560 #[allow(deprecated)]
15561 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15562 where
15563 D: serde::Deserializer<'de>,
15564 {
15565 const FIELDS: &[&str] = &[
15566 "STREAM_SCAN_TYPE_UNSPECIFIED",
15567 "STREAM_SCAN_TYPE_CHAIN",
15568 "STREAM_SCAN_TYPE_REARRANGE",
15569 "STREAM_SCAN_TYPE_BACKFILL",
15570 "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
15571 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
15572 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
15573 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
15574 ];
15575
15576 struct GeneratedVisitor;
15577
15578 impl serde::de::Visitor<'_> for GeneratedVisitor {
15579 type Value = StreamScanType;
15580
15581 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15582 write!(formatter, "expected one of: {:?}", &FIELDS)
15583 }
15584
15585 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15586 where
15587 E: serde::de::Error,
15588 {
15589 i32::try_from(v)
15590 .ok()
15591 .and_then(|x| x.try_into().ok())
15592 .ok_or_else(|| {
15593 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15594 })
15595 }
15596
15597 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15598 where
15599 E: serde::de::Error,
15600 {
15601 i32::try_from(v)
15602 .ok()
15603 .and_then(|x| x.try_into().ok())
15604 .ok_or_else(|| {
15605 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15606 })
15607 }
15608
15609 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15610 where
15611 E: serde::de::Error,
15612 {
15613 match value {
15614 "STREAM_SCAN_TYPE_UNSPECIFIED" => Ok(StreamScanType::Unspecified),
15615 "STREAM_SCAN_TYPE_CHAIN" => Ok(StreamScanType::Chain),
15616 "STREAM_SCAN_TYPE_REARRANGE" => Ok(StreamScanType::Rearrange),
15617 "STREAM_SCAN_TYPE_BACKFILL" => Ok(StreamScanType::Backfill),
15618 "STREAM_SCAN_TYPE_UPSTREAM_ONLY" => Ok(StreamScanType::UpstreamOnly),
15619 "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL" => Ok(StreamScanType::ArrangementBackfill),
15620 "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL" => Ok(StreamScanType::SnapshotBackfill),
15621 "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL" => Ok(StreamScanType::CrossDbSnapshotBackfill),
15622 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15623 }
15624 }
15625 }
15626 deserializer.deserialize_any(GeneratedVisitor)
15627 }
15628}
15629impl serde::Serialize for StreamSource {
15630 #[allow(deprecated)]
15631 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15632 where
15633 S: serde::Serializer,
15634 {
15635 use serde::ser::SerializeStruct;
15636 let mut len = 0;
15637 if self.source_id != 0 {
15638 len += 1;
15639 }
15640 if self.state_table.is_some() {
15641 len += 1;
15642 }
15643 if self.row_id_index.is_some() {
15644 len += 1;
15645 }
15646 if !self.columns.is_empty() {
15647 len += 1;
15648 }
15649 if !self.with_properties.is_empty() {
15650 len += 1;
15651 }
15652 if self.info.is_some() {
15653 len += 1;
15654 }
15655 if !self.source_name.is_empty() {
15656 len += 1;
15657 }
15658 if self.rate_limit.is_some() {
15659 len += 1;
15660 }
15661 if !self.secret_refs.is_empty() {
15662 len += 1;
15663 }
15664 if self.downstream_columns.is_some() {
15665 len += 1;
15666 }
15667 if self.refresh_mode.is_some() {
15668 len += 1;
15669 }
15670 if self.associated_table_id.is_some() {
15671 len += 1;
15672 }
15673 let mut struct_ser = serializer.serialize_struct("stream_plan.StreamSource", len)?;
15674 if self.source_id != 0 {
15675 struct_ser.serialize_field("sourceId", &self.source_id)?;
15676 }
15677 if let Some(v) = self.state_table.as_ref() {
15678 struct_ser.serialize_field("stateTable", v)?;
15679 }
15680 if let Some(v) = self.row_id_index.as_ref() {
15681 struct_ser.serialize_field("rowIdIndex", v)?;
15682 }
15683 if !self.columns.is_empty() {
15684 struct_ser.serialize_field("columns", &self.columns)?;
15685 }
15686 if !self.with_properties.is_empty() {
15687 struct_ser.serialize_field("withProperties", &self.with_properties)?;
15688 }
15689 if let Some(v) = self.info.as_ref() {
15690 struct_ser.serialize_field("info", v)?;
15691 }
15692 if !self.source_name.is_empty() {
15693 struct_ser.serialize_field("sourceName", &self.source_name)?;
15694 }
15695 if let Some(v) = self.rate_limit.as_ref() {
15696 struct_ser.serialize_field("rateLimit", v)?;
15697 }
15698 if !self.secret_refs.is_empty() {
15699 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
15700 }
15701 if let Some(v) = self.downstream_columns.as_ref() {
15702 struct_ser.serialize_field("downstreamColumns", v)?;
15703 }
15704 if let Some(v) = self.refresh_mode.as_ref() {
15705 struct_ser.serialize_field("refreshMode", v)?;
15706 }
15707 if let Some(v) = self.associated_table_id.as_ref() {
15708 struct_ser.serialize_field("associatedTableId", v)?;
15709 }
15710 struct_ser.end()
15711 }
15712}
15713impl<'de> serde::Deserialize<'de> for StreamSource {
15714 #[allow(deprecated)]
15715 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15716 where
15717 D: serde::Deserializer<'de>,
15718 {
15719 const FIELDS: &[&str] = &[
15720 "source_id",
15721 "sourceId",
15722 "state_table",
15723 "stateTable",
15724 "row_id_index",
15725 "rowIdIndex",
15726 "columns",
15727 "with_properties",
15728 "withProperties",
15729 "info",
15730 "source_name",
15731 "sourceName",
15732 "rate_limit",
15733 "rateLimit",
15734 "secret_refs",
15735 "secretRefs",
15736 "downstream_columns",
15737 "downstreamColumns",
15738 "refresh_mode",
15739 "refreshMode",
15740 "associated_table_id",
15741 "associatedTableId",
15742 ];
15743
15744 #[allow(clippy::enum_variant_names)]
15745 enum GeneratedField {
15746 SourceId,
15747 StateTable,
15748 RowIdIndex,
15749 Columns,
15750 WithProperties,
15751 Info,
15752 SourceName,
15753 RateLimit,
15754 SecretRefs,
15755 DownstreamColumns,
15756 RefreshMode,
15757 AssociatedTableId,
15758 }
15759 impl<'de> serde::Deserialize<'de> for GeneratedField {
15760 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15761 where
15762 D: serde::Deserializer<'de>,
15763 {
15764 struct GeneratedVisitor;
15765
15766 impl serde::de::Visitor<'_> for GeneratedVisitor {
15767 type Value = GeneratedField;
15768
15769 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15770 write!(formatter, "expected one of: {:?}", &FIELDS)
15771 }
15772
15773 #[allow(unused_variables)]
15774 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15775 where
15776 E: serde::de::Error,
15777 {
15778 match value {
15779 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
15780 "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
15781 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
15782 "columns" => Ok(GeneratedField::Columns),
15783 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
15784 "info" => Ok(GeneratedField::Info),
15785 "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
15786 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
15787 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
15788 "downstreamColumns" | "downstream_columns" => Ok(GeneratedField::DownstreamColumns),
15789 "refreshMode" | "refresh_mode" => Ok(GeneratedField::RefreshMode),
15790 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
15791 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15792 }
15793 }
15794 }
15795 deserializer.deserialize_identifier(GeneratedVisitor)
15796 }
15797 }
15798 struct GeneratedVisitor;
15799 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15800 type Value = StreamSource;
15801
15802 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15803 formatter.write_str("struct stream_plan.StreamSource")
15804 }
15805
15806 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSource, V::Error>
15807 where
15808 V: serde::de::MapAccess<'de>,
15809 {
15810 let mut source_id__ = None;
15811 let mut state_table__ = None;
15812 let mut row_id_index__ = None;
15813 let mut columns__ = None;
15814 let mut with_properties__ = None;
15815 let mut info__ = None;
15816 let mut source_name__ = None;
15817 let mut rate_limit__ = None;
15818 let mut secret_refs__ = None;
15819 let mut downstream_columns__ = None;
15820 let mut refresh_mode__ = None;
15821 let mut associated_table_id__ = None;
15822 while let Some(k) = map_.next_key()? {
15823 match k {
15824 GeneratedField::SourceId => {
15825 if source_id__.is_some() {
15826 return Err(serde::de::Error::duplicate_field("sourceId"));
15827 }
15828 source_id__ =
15829 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15830 ;
15831 }
15832 GeneratedField::StateTable => {
15833 if state_table__.is_some() {
15834 return Err(serde::de::Error::duplicate_field("stateTable"));
15835 }
15836 state_table__ = map_.next_value()?;
15837 }
15838 GeneratedField::RowIdIndex => {
15839 if row_id_index__.is_some() {
15840 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
15841 }
15842 row_id_index__ =
15843 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15844 ;
15845 }
15846 GeneratedField::Columns => {
15847 if columns__.is_some() {
15848 return Err(serde::de::Error::duplicate_field("columns"));
15849 }
15850 columns__ = Some(map_.next_value()?);
15851 }
15852 GeneratedField::WithProperties => {
15853 if with_properties__.is_some() {
15854 return Err(serde::de::Error::duplicate_field("withProperties"));
15855 }
15856 with_properties__ = Some(
15857 map_.next_value::<std::collections::BTreeMap<_, _>>()?
15858 );
15859 }
15860 GeneratedField::Info => {
15861 if info__.is_some() {
15862 return Err(serde::de::Error::duplicate_field("info"));
15863 }
15864 info__ = map_.next_value()?;
15865 }
15866 GeneratedField::SourceName => {
15867 if source_name__.is_some() {
15868 return Err(serde::de::Error::duplicate_field("sourceName"));
15869 }
15870 source_name__ = Some(map_.next_value()?);
15871 }
15872 GeneratedField::RateLimit => {
15873 if rate_limit__.is_some() {
15874 return Err(serde::de::Error::duplicate_field("rateLimit"));
15875 }
15876 rate_limit__ =
15877 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15878 ;
15879 }
15880 GeneratedField::SecretRefs => {
15881 if secret_refs__.is_some() {
15882 return Err(serde::de::Error::duplicate_field("secretRefs"));
15883 }
15884 secret_refs__ = Some(
15885 map_.next_value::<std::collections::BTreeMap<_, _>>()?
15886 );
15887 }
15888 GeneratedField::DownstreamColumns => {
15889 if downstream_columns__.is_some() {
15890 return Err(serde::de::Error::duplicate_field("downstreamColumns"));
15891 }
15892 downstream_columns__ = map_.next_value()?;
15893 }
15894 GeneratedField::RefreshMode => {
15895 if refresh_mode__.is_some() {
15896 return Err(serde::de::Error::duplicate_field("refreshMode"));
15897 }
15898 refresh_mode__ = map_.next_value()?;
15899 }
15900 GeneratedField::AssociatedTableId => {
15901 if associated_table_id__.is_some() {
15902 return Err(serde::de::Error::duplicate_field("associatedTableId"));
15903 }
15904 associated_table_id__ =
15905 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15906 ;
15907 }
15908 }
15909 }
15910 Ok(StreamSource {
15911 source_id: source_id__.unwrap_or_default(),
15912 state_table: state_table__,
15913 row_id_index: row_id_index__,
15914 columns: columns__.unwrap_or_default(),
15915 with_properties: with_properties__.unwrap_or_default(),
15916 info: info__,
15917 source_name: source_name__.unwrap_or_default(),
15918 rate_limit: rate_limit__,
15919 secret_refs: secret_refs__.unwrap_or_default(),
15920 downstream_columns: downstream_columns__,
15921 refresh_mode: refresh_mode__,
15922 associated_table_id: associated_table_id__,
15923 })
15924 }
15925 }
15926 deserializer.deserialize_struct("stream_plan.StreamSource", FIELDS, GeneratedVisitor)
15927 }
15928}
15929impl serde::Serialize for SubscriptionUpstreamInfo {
15930 #[allow(deprecated)]
15931 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15932 where
15933 S: serde::Serializer,
15934 {
15935 use serde::ser::SerializeStruct;
15936 let mut len = 0;
15937 if self.subscriber_id != 0 {
15938 len += 1;
15939 }
15940 if self.upstream_mv_table_id != 0 {
15941 len += 1;
15942 }
15943 let mut struct_ser = serializer.serialize_struct("stream_plan.SubscriptionUpstreamInfo", len)?;
15944 if self.subscriber_id != 0 {
15945 struct_ser.serialize_field("subscriberId", &self.subscriber_id)?;
15946 }
15947 if self.upstream_mv_table_id != 0 {
15948 struct_ser.serialize_field("upstreamMvTableId", &self.upstream_mv_table_id)?;
15949 }
15950 struct_ser.end()
15951 }
15952}
15953impl<'de> serde::Deserialize<'de> for SubscriptionUpstreamInfo {
15954 #[allow(deprecated)]
15955 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15956 where
15957 D: serde::Deserializer<'de>,
15958 {
15959 const FIELDS: &[&str] = &[
15960 "subscriber_id",
15961 "subscriberId",
15962 "upstream_mv_table_id",
15963 "upstreamMvTableId",
15964 ];
15965
15966 #[allow(clippy::enum_variant_names)]
15967 enum GeneratedField {
15968 SubscriberId,
15969 UpstreamMvTableId,
15970 }
15971 impl<'de> serde::Deserialize<'de> for GeneratedField {
15972 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15973 where
15974 D: serde::Deserializer<'de>,
15975 {
15976 struct GeneratedVisitor;
15977
15978 impl serde::de::Visitor<'_> for GeneratedVisitor {
15979 type Value = GeneratedField;
15980
15981 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15982 write!(formatter, "expected one of: {:?}", &FIELDS)
15983 }
15984
15985 #[allow(unused_variables)]
15986 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15987 where
15988 E: serde::de::Error,
15989 {
15990 match value {
15991 "subscriberId" | "subscriber_id" => Ok(GeneratedField::SubscriberId),
15992 "upstreamMvTableId" | "upstream_mv_table_id" => Ok(GeneratedField::UpstreamMvTableId),
15993 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15994 }
15995 }
15996 }
15997 deserializer.deserialize_identifier(GeneratedVisitor)
15998 }
15999 }
16000 struct GeneratedVisitor;
16001 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16002 type Value = SubscriptionUpstreamInfo;
16003
16004 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16005 formatter.write_str("struct stream_plan.SubscriptionUpstreamInfo")
16006 }
16007
16008 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscriptionUpstreamInfo, V::Error>
16009 where
16010 V: serde::de::MapAccess<'de>,
16011 {
16012 let mut subscriber_id__ = None;
16013 let mut upstream_mv_table_id__ = None;
16014 while let Some(k) = map_.next_key()? {
16015 match k {
16016 GeneratedField::SubscriberId => {
16017 if subscriber_id__.is_some() {
16018 return Err(serde::de::Error::duplicate_field("subscriberId"));
16019 }
16020 subscriber_id__ =
16021 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16022 ;
16023 }
16024 GeneratedField::UpstreamMvTableId => {
16025 if upstream_mv_table_id__.is_some() {
16026 return Err(serde::de::Error::duplicate_field("upstreamMvTableId"));
16027 }
16028 upstream_mv_table_id__ =
16029 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16030 ;
16031 }
16032 }
16033 }
16034 Ok(SubscriptionUpstreamInfo {
16035 subscriber_id: subscriber_id__.unwrap_or_default(),
16036 upstream_mv_table_id: upstream_mv_table_id__.unwrap_or_default(),
16037 })
16038 }
16039 }
16040 deserializer.deserialize_struct("stream_plan.SubscriptionUpstreamInfo", FIELDS, GeneratedVisitor)
16041 }
16042}
16043impl serde::Serialize for SyncLogStoreNode {
16044 #[allow(deprecated)]
16045 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16046 where
16047 S: serde::Serializer,
16048 {
16049 use serde::ser::SerializeStruct;
16050 let mut len = 0;
16051 if self.log_store_table.is_some() {
16052 len += 1;
16053 }
16054 if self.pause_duration_ms.is_some() {
16055 len += 1;
16056 }
16057 if self.buffer_size.is_some() {
16058 len += 1;
16059 }
16060 if self.aligned {
16061 len += 1;
16062 }
16063 let mut struct_ser = serializer.serialize_struct("stream_plan.SyncLogStoreNode", len)?;
16064 if let Some(v) = self.log_store_table.as_ref() {
16065 struct_ser.serialize_field("logStoreTable", v)?;
16066 }
16067 if let Some(v) = self.pause_duration_ms.as_ref() {
16068 struct_ser.serialize_field("pauseDurationMs", v)?;
16069 }
16070 if let Some(v) = self.buffer_size.as_ref() {
16071 struct_ser.serialize_field("bufferSize", v)?;
16072 }
16073 if self.aligned {
16074 struct_ser.serialize_field("aligned", &self.aligned)?;
16075 }
16076 struct_ser.end()
16077 }
16078}
16079impl<'de> serde::Deserialize<'de> for SyncLogStoreNode {
16080 #[allow(deprecated)]
16081 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16082 where
16083 D: serde::Deserializer<'de>,
16084 {
16085 const FIELDS: &[&str] = &[
16086 "log_store_table",
16087 "logStoreTable",
16088 "pause_duration_ms",
16089 "pauseDurationMs",
16090 "buffer_size",
16091 "bufferSize",
16092 "aligned",
16093 ];
16094
16095 #[allow(clippy::enum_variant_names)]
16096 enum GeneratedField {
16097 LogStoreTable,
16098 PauseDurationMs,
16099 BufferSize,
16100 Aligned,
16101 }
16102 impl<'de> serde::Deserialize<'de> for GeneratedField {
16103 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16104 where
16105 D: serde::Deserializer<'de>,
16106 {
16107 struct GeneratedVisitor;
16108
16109 impl serde::de::Visitor<'_> for GeneratedVisitor {
16110 type Value = GeneratedField;
16111
16112 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16113 write!(formatter, "expected one of: {:?}", &FIELDS)
16114 }
16115
16116 #[allow(unused_variables)]
16117 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16118 where
16119 E: serde::de::Error,
16120 {
16121 match value {
16122 "logStoreTable" | "log_store_table" => Ok(GeneratedField::LogStoreTable),
16123 "pauseDurationMs" | "pause_duration_ms" => Ok(GeneratedField::PauseDurationMs),
16124 "bufferSize" | "buffer_size" => Ok(GeneratedField::BufferSize),
16125 "aligned" => Ok(GeneratedField::Aligned),
16126 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16127 }
16128 }
16129 }
16130 deserializer.deserialize_identifier(GeneratedVisitor)
16131 }
16132 }
16133 struct GeneratedVisitor;
16134 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16135 type Value = SyncLogStoreNode;
16136
16137 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16138 formatter.write_str("struct stream_plan.SyncLogStoreNode")
16139 }
16140
16141 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SyncLogStoreNode, V::Error>
16142 where
16143 V: serde::de::MapAccess<'de>,
16144 {
16145 let mut log_store_table__ = None;
16146 let mut pause_duration_ms__ = None;
16147 let mut buffer_size__ = None;
16148 let mut aligned__ = None;
16149 while let Some(k) = map_.next_key()? {
16150 match k {
16151 GeneratedField::LogStoreTable => {
16152 if log_store_table__.is_some() {
16153 return Err(serde::de::Error::duplicate_field("logStoreTable"));
16154 }
16155 log_store_table__ = map_.next_value()?;
16156 }
16157 GeneratedField::PauseDurationMs => {
16158 if pause_duration_ms__.is_some() {
16159 return Err(serde::de::Error::duplicate_field("pauseDurationMs"));
16160 }
16161 pause_duration_ms__ =
16162 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16163 ;
16164 }
16165 GeneratedField::BufferSize => {
16166 if buffer_size__.is_some() {
16167 return Err(serde::de::Error::duplicate_field("bufferSize"));
16168 }
16169 buffer_size__ =
16170 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16171 ;
16172 }
16173 GeneratedField::Aligned => {
16174 if aligned__.is_some() {
16175 return Err(serde::de::Error::duplicate_field("aligned"));
16176 }
16177 aligned__ = Some(map_.next_value()?);
16178 }
16179 }
16180 }
16181 Ok(SyncLogStoreNode {
16182 log_store_table: log_store_table__,
16183 pause_duration_ms: pause_duration_ms__,
16184 buffer_size: buffer_size__,
16185 aligned: aligned__.unwrap_or_default(),
16186 })
16187 }
16188 }
16189 deserializer.deserialize_struct("stream_plan.SyncLogStoreNode", FIELDS, GeneratedVisitor)
16190 }
16191}
16192impl serde::Serialize for TemporalJoinNode {
16193 #[allow(deprecated)]
16194 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16195 where
16196 S: serde::Serializer,
16197 {
16198 use serde::ser::SerializeStruct;
16199 let mut len = 0;
16200 if self.join_type != 0 {
16201 len += 1;
16202 }
16203 if !self.left_key.is_empty() {
16204 len += 1;
16205 }
16206 if !self.right_key.is_empty() {
16207 len += 1;
16208 }
16209 if !self.null_safe.is_empty() {
16210 len += 1;
16211 }
16212 if self.condition.is_some() {
16213 len += 1;
16214 }
16215 if !self.output_indices.is_empty() {
16216 len += 1;
16217 }
16218 if self.table_desc.is_some() {
16219 len += 1;
16220 }
16221 if !self.table_output_indices.is_empty() {
16222 len += 1;
16223 }
16224 if self.memo_table.is_some() {
16225 len += 1;
16226 }
16227 if self.is_nested_loop {
16228 len += 1;
16229 }
16230 let mut struct_ser = serializer.serialize_struct("stream_plan.TemporalJoinNode", len)?;
16231 if self.join_type != 0 {
16232 let v = super::plan_common::JoinType::try_from(self.join_type)
16233 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
16234 struct_ser.serialize_field("joinType", &v)?;
16235 }
16236 if !self.left_key.is_empty() {
16237 struct_ser.serialize_field("leftKey", &self.left_key)?;
16238 }
16239 if !self.right_key.is_empty() {
16240 struct_ser.serialize_field("rightKey", &self.right_key)?;
16241 }
16242 if !self.null_safe.is_empty() {
16243 struct_ser.serialize_field("nullSafe", &self.null_safe)?;
16244 }
16245 if let Some(v) = self.condition.as_ref() {
16246 struct_ser.serialize_field("condition", v)?;
16247 }
16248 if !self.output_indices.is_empty() {
16249 struct_ser.serialize_field("outputIndices", &self.output_indices)?;
16250 }
16251 if let Some(v) = self.table_desc.as_ref() {
16252 struct_ser.serialize_field("tableDesc", v)?;
16253 }
16254 if !self.table_output_indices.is_empty() {
16255 struct_ser.serialize_field("tableOutputIndices", &self.table_output_indices)?;
16256 }
16257 if let Some(v) = self.memo_table.as_ref() {
16258 struct_ser.serialize_field("memoTable", v)?;
16259 }
16260 if self.is_nested_loop {
16261 struct_ser.serialize_field("isNestedLoop", &self.is_nested_loop)?;
16262 }
16263 struct_ser.end()
16264 }
16265}
16266impl<'de> serde::Deserialize<'de> for TemporalJoinNode {
16267 #[allow(deprecated)]
16268 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16269 where
16270 D: serde::Deserializer<'de>,
16271 {
16272 const FIELDS: &[&str] = &[
16273 "join_type",
16274 "joinType",
16275 "left_key",
16276 "leftKey",
16277 "right_key",
16278 "rightKey",
16279 "null_safe",
16280 "nullSafe",
16281 "condition",
16282 "output_indices",
16283 "outputIndices",
16284 "table_desc",
16285 "tableDesc",
16286 "table_output_indices",
16287 "tableOutputIndices",
16288 "memo_table",
16289 "memoTable",
16290 "is_nested_loop",
16291 "isNestedLoop",
16292 ];
16293
16294 #[allow(clippy::enum_variant_names)]
16295 enum GeneratedField {
16296 JoinType,
16297 LeftKey,
16298 RightKey,
16299 NullSafe,
16300 Condition,
16301 OutputIndices,
16302 TableDesc,
16303 TableOutputIndices,
16304 MemoTable,
16305 IsNestedLoop,
16306 }
16307 impl<'de> serde::Deserialize<'de> for GeneratedField {
16308 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16309 where
16310 D: serde::Deserializer<'de>,
16311 {
16312 struct GeneratedVisitor;
16313
16314 impl serde::de::Visitor<'_> for GeneratedVisitor {
16315 type Value = GeneratedField;
16316
16317 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16318 write!(formatter, "expected one of: {:?}", &FIELDS)
16319 }
16320
16321 #[allow(unused_variables)]
16322 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16323 where
16324 E: serde::de::Error,
16325 {
16326 match value {
16327 "joinType" | "join_type" => Ok(GeneratedField::JoinType),
16328 "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
16329 "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
16330 "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
16331 "condition" => Ok(GeneratedField::Condition),
16332 "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
16333 "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
16334 "tableOutputIndices" | "table_output_indices" => Ok(GeneratedField::TableOutputIndices),
16335 "memoTable" | "memo_table" => Ok(GeneratedField::MemoTable),
16336 "isNestedLoop" | "is_nested_loop" => Ok(GeneratedField::IsNestedLoop),
16337 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16338 }
16339 }
16340 }
16341 deserializer.deserialize_identifier(GeneratedVisitor)
16342 }
16343 }
16344 struct GeneratedVisitor;
16345 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16346 type Value = TemporalJoinNode;
16347
16348 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16349 formatter.write_str("struct stream_plan.TemporalJoinNode")
16350 }
16351
16352 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TemporalJoinNode, V::Error>
16353 where
16354 V: serde::de::MapAccess<'de>,
16355 {
16356 let mut join_type__ = None;
16357 let mut left_key__ = None;
16358 let mut right_key__ = None;
16359 let mut null_safe__ = None;
16360 let mut condition__ = None;
16361 let mut output_indices__ = None;
16362 let mut table_desc__ = None;
16363 let mut table_output_indices__ = None;
16364 let mut memo_table__ = None;
16365 let mut is_nested_loop__ = None;
16366 while let Some(k) = map_.next_key()? {
16367 match k {
16368 GeneratedField::JoinType => {
16369 if join_type__.is_some() {
16370 return Err(serde::de::Error::duplicate_field("joinType"));
16371 }
16372 join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
16373 }
16374 GeneratedField::LeftKey => {
16375 if left_key__.is_some() {
16376 return Err(serde::de::Error::duplicate_field("leftKey"));
16377 }
16378 left_key__ =
16379 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16380 .into_iter().map(|x| x.0).collect())
16381 ;
16382 }
16383 GeneratedField::RightKey => {
16384 if right_key__.is_some() {
16385 return Err(serde::de::Error::duplicate_field("rightKey"));
16386 }
16387 right_key__ =
16388 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16389 .into_iter().map(|x| x.0).collect())
16390 ;
16391 }
16392 GeneratedField::NullSafe => {
16393 if null_safe__.is_some() {
16394 return Err(serde::de::Error::duplicate_field("nullSafe"));
16395 }
16396 null_safe__ = Some(map_.next_value()?);
16397 }
16398 GeneratedField::Condition => {
16399 if condition__.is_some() {
16400 return Err(serde::de::Error::duplicate_field("condition"));
16401 }
16402 condition__ = map_.next_value()?;
16403 }
16404 GeneratedField::OutputIndices => {
16405 if output_indices__.is_some() {
16406 return Err(serde::de::Error::duplicate_field("outputIndices"));
16407 }
16408 output_indices__ =
16409 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16410 .into_iter().map(|x| x.0).collect())
16411 ;
16412 }
16413 GeneratedField::TableDesc => {
16414 if table_desc__.is_some() {
16415 return Err(serde::de::Error::duplicate_field("tableDesc"));
16416 }
16417 table_desc__ = map_.next_value()?;
16418 }
16419 GeneratedField::TableOutputIndices => {
16420 if table_output_indices__.is_some() {
16421 return Err(serde::de::Error::duplicate_field("tableOutputIndices"));
16422 }
16423 table_output_indices__ =
16424 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16425 .into_iter().map(|x| x.0).collect())
16426 ;
16427 }
16428 GeneratedField::MemoTable => {
16429 if memo_table__.is_some() {
16430 return Err(serde::de::Error::duplicate_field("memoTable"));
16431 }
16432 memo_table__ = map_.next_value()?;
16433 }
16434 GeneratedField::IsNestedLoop => {
16435 if is_nested_loop__.is_some() {
16436 return Err(serde::de::Error::duplicate_field("isNestedLoop"));
16437 }
16438 is_nested_loop__ = Some(map_.next_value()?);
16439 }
16440 }
16441 }
16442 Ok(TemporalJoinNode {
16443 join_type: join_type__.unwrap_or_default(),
16444 left_key: left_key__.unwrap_or_default(),
16445 right_key: right_key__.unwrap_or_default(),
16446 null_safe: null_safe__.unwrap_or_default(),
16447 condition: condition__,
16448 output_indices: output_indices__.unwrap_or_default(),
16449 table_desc: table_desc__,
16450 table_output_indices: table_output_indices__.unwrap_or_default(),
16451 memo_table: memo_table__,
16452 is_nested_loop: is_nested_loop__.unwrap_or_default(),
16453 })
16454 }
16455 }
16456 deserializer.deserialize_struct("stream_plan.TemporalJoinNode", FIELDS, GeneratedVisitor)
16457 }
16458}
16459impl serde::Serialize for ThrottleMutation {
16460 #[allow(deprecated)]
16461 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16462 where
16463 S: serde::Serializer,
16464 {
16465 use serde::ser::SerializeStruct;
16466 let mut len = 0;
16467 if !self.fragment_throttle.is_empty() {
16468 len += 1;
16469 }
16470 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation", len)?;
16471 if !self.fragment_throttle.is_empty() {
16472 struct_ser.serialize_field("fragmentThrottle", &self.fragment_throttle)?;
16473 }
16474 struct_ser.end()
16475 }
16476}
16477impl<'de> serde::Deserialize<'de> for ThrottleMutation {
16478 #[allow(deprecated)]
16479 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16480 where
16481 D: serde::Deserializer<'de>,
16482 {
16483 const FIELDS: &[&str] = &[
16484 "fragment_throttle",
16485 "fragmentThrottle",
16486 ];
16487
16488 #[allow(clippy::enum_variant_names)]
16489 enum GeneratedField {
16490 FragmentThrottle,
16491 }
16492 impl<'de> serde::Deserialize<'de> for GeneratedField {
16493 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16494 where
16495 D: serde::Deserializer<'de>,
16496 {
16497 struct GeneratedVisitor;
16498
16499 impl serde::de::Visitor<'_> for GeneratedVisitor {
16500 type Value = GeneratedField;
16501
16502 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16503 write!(formatter, "expected one of: {:?}", &FIELDS)
16504 }
16505
16506 #[allow(unused_variables)]
16507 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16508 where
16509 E: serde::de::Error,
16510 {
16511 match value {
16512 "fragmentThrottle" | "fragment_throttle" => Ok(GeneratedField::FragmentThrottle),
16513 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16514 }
16515 }
16516 }
16517 deserializer.deserialize_identifier(GeneratedVisitor)
16518 }
16519 }
16520 struct GeneratedVisitor;
16521 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16522 type Value = ThrottleMutation;
16523
16524 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16525 formatter.write_str("struct stream_plan.ThrottleMutation")
16526 }
16527
16528 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ThrottleMutation, V::Error>
16529 where
16530 V: serde::de::MapAccess<'de>,
16531 {
16532 let mut fragment_throttle__ = None;
16533 while let Some(k) = map_.next_key()? {
16534 match k {
16535 GeneratedField::FragmentThrottle => {
16536 if fragment_throttle__.is_some() {
16537 return Err(serde::de::Error::duplicate_field("fragmentThrottle"));
16538 }
16539 fragment_throttle__ = Some(
16540 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
16541 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
16542 );
16543 }
16544 }
16545 }
16546 Ok(ThrottleMutation {
16547 fragment_throttle: fragment_throttle__.unwrap_or_default(),
16548 })
16549 }
16550 }
16551 deserializer.deserialize_struct("stream_plan.ThrottleMutation", FIELDS, GeneratedVisitor)
16552 }
16553}
16554impl serde::Serialize for throttle_mutation::ThrottleConfig {
16555 #[allow(deprecated)]
16556 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16557 where
16558 S: serde::Serializer,
16559 {
16560 use serde::ser::SerializeStruct;
16561 let mut len = 0;
16562 if self.rate_limit.is_some() {
16563 len += 1;
16564 }
16565 if self.throttle_type != 0 {
16566 len += 1;
16567 }
16568 let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation.ThrottleConfig", len)?;
16569 if let Some(v) = self.rate_limit.as_ref() {
16570 struct_ser.serialize_field("rateLimit", v)?;
16571 }
16572 if self.throttle_type != 0 {
16573 let v = super::common::ThrottleType::try_from(self.throttle_type)
16574 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.throttle_type)))?;
16575 struct_ser.serialize_field("throttleType", &v)?;
16576 }
16577 struct_ser.end()
16578 }
16579}
16580impl<'de> serde::Deserialize<'de> for throttle_mutation::ThrottleConfig {
16581 #[allow(deprecated)]
16582 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16583 where
16584 D: serde::Deserializer<'de>,
16585 {
16586 const FIELDS: &[&str] = &[
16587 "rate_limit",
16588 "rateLimit",
16589 "throttle_type",
16590 "throttleType",
16591 ];
16592
16593 #[allow(clippy::enum_variant_names)]
16594 enum GeneratedField {
16595 RateLimit,
16596 ThrottleType,
16597 }
16598 impl<'de> serde::Deserialize<'de> for GeneratedField {
16599 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16600 where
16601 D: serde::Deserializer<'de>,
16602 {
16603 struct GeneratedVisitor;
16604
16605 impl serde::de::Visitor<'_> for GeneratedVisitor {
16606 type Value = GeneratedField;
16607
16608 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16609 write!(formatter, "expected one of: {:?}", &FIELDS)
16610 }
16611
16612 #[allow(unused_variables)]
16613 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16614 where
16615 E: serde::de::Error,
16616 {
16617 match value {
16618 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
16619 "throttleType" | "throttle_type" => Ok(GeneratedField::ThrottleType),
16620 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16621 }
16622 }
16623 }
16624 deserializer.deserialize_identifier(GeneratedVisitor)
16625 }
16626 }
16627 struct GeneratedVisitor;
16628 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16629 type Value = throttle_mutation::ThrottleConfig;
16630
16631 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16632 formatter.write_str("struct stream_plan.ThrottleMutation.ThrottleConfig")
16633 }
16634
16635 fn visit_map<V>(self, mut map_: V) -> std::result::Result<throttle_mutation::ThrottleConfig, V::Error>
16636 where
16637 V: serde::de::MapAccess<'de>,
16638 {
16639 let mut rate_limit__ = None;
16640 let mut throttle_type__ = None;
16641 while let Some(k) = map_.next_key()? {
16642 match k {
16643 GeneratedField::RateLimit => {
16644 if rate_limit__.is_some() {
16645 return Err(serde::de::Error::duplicate_field("rateLimit"));
16646 }
16647 rate_limit__ =
16648 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16649 ;
16650 }
16651 GeneratedField::ThrottleType => {
16652 if throttle_type__.is_some() {
16653 return Err(serde::de::Error::duplicate_field("throttleType"));
16654 }
16655 throttle_type__ = Some(map_.next_value::<super::common::ThrottleType>()? as i32);
16656 }
16657 }
16658 }
16659 Ok(throttle_mutation::ThrottleConfig {
16660 rate_limit: rate_limit__,
16661 throttle_type: throttle_type__.unwrap_or_default(),
16662 })
16663 }
16664 }
16665 deserializer.deserialize_struct("stream_plan.ThrottleMutation.ThrottleConfig", FIELDS, GeneratedVisitor)
16666 }
16667}
16668impl serde::Serialize for TopNNode {
16669 #[allow(deprecated)]
16670 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16671 where
16672 S: serde::Serializer,
16673 {
16674 use serde::ser::SerializeStruct;
16675 let mut len = 0;
16676 if self.limit != 0 {
16677 len += 1;
16678 }
16679 if self.offset != 0 {
16680 len += 1;
16681 }
16682 if self.table.is_some() {
16683 len += 1;
16684 }
16685 if !self.order_by.is_empty() {
16686 len += 1;
16687 }
16688 if self.with_ties {
16689 len += 1;
16690 }
16691 let mut struct_ser = serializer.serialize_struct("stream_plan.TopNNode", len)?;
16692 if self.limit != 0 {
16693 #[allow(clippy::needless_borrow)]
16694 #[allow(clippy::needless_borrows_for_generic_args)]
16695 struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
16696 }
16697 if self.offset != 0 {
16698 #[allow(clippy::needless_borrow)]
16699 #[allow(clippy::needless_borrows_for_generic_args)]
16700 struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
16701 }
16702 if let Some(v) = self.table.as_ref() {
16703 struct_ser.serialize_field("table", v)?;
16704 }
16705 if !self.order_by.is_empty() {
16706 struct_ser.serialize_field("orderBy", &self.order_by)?;
16707 }
16708 if self.with_ties {
16709 struct_ser.serialize_field("withTies", &self.with_ties)?;
16710 }
16711 struct_ser.end()
16712 }
16713}
16714impl<'de> serde::Deserialize<'de> for TopNNode {
16715 #[allow(deprecated)]
16716 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16717 where
16718 D: serde::Deserializer<'de>,
16719 {
16720 const FIELDS: &[&str] = &[
16721 "limit",
16722 "offset",
16723 "table",
16724 "order_by",
16725 "orderBy",
16726 "with_ties",
16727 "withTies",
16728 ];
16729
16730 #[allow(clippy::enum_variant_names)]
16731 enum GeneratedField {
16732 Limit,
16733 Offset,
16734 Table,
16735 OrderBy,
16736 WithTies,
16737 }
16738 impl<'de> serde::Deserialize<'de> for GeneratedField {
16739 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16740 where
16741 D: serde::Deserializer<'de>,
16742 {
16743 struct GeneratedVisitor;
16744
16745 impl serde::de::Visitor<'_> for GeneratedVisitor {
16746 type Value = GeneratedField;
16747
16748 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16749 write!(formatter, "expected one of: {:?}", &FIELDS)
16750 }
16751
16752 #[allow(unused_variables)]
16753 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16754 where
16755 E: serde::de::Error,
16756 {
16757 match value {
16758 "limit" => Ok(GeneratedField::Limit),
16759 "offset" => Ok(GeneratedField::Offset),
16760 "table" => Ok(GeneratedField::Table),
16761 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
16762 "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
16763 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16764 }
16765 }
16766 }
16767 deserializer.deserialize_identifier(GeneratedVisitor)
16768 }
16769 }
16770 struct GeneratedVisitor;
16771 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16772 type Value = TopNNode;
16773
16774 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16775 formatter.write_str("struct stream_plan.TopNNode")
16776 }
16777
16778 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
16779 where
16780 V: serde::de::MapAccess<'de>,
16781 {
16782 let mut limit__ = None;
16783 let mut offset__ = None;
16784 let mut table__ = None;
16785 let mut order_by__ = None;
16786 let mut with_ties__ = None;
16787 while let Some(k) = map_.next_key()? {
16788 match k {
16789 GeneratedField::Limit => {
16790 if limit__.is_some() {
16791 return Err(serde::de::Error::duplicate_field("limit"));
16792 }
16793 limit__ =
16794 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16795 ;
16796 }
16797 GeneratedField::Offset => {
16798 if offset__.is_some() {
16799 return Err(serde::de::Error::duplicate_field("offset"));
16800 }
16801 offset__ =
16802 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16803 ;
16804 }
16805 GeneratedField::Table => {
16806 if table__.is_some() {
16807 return Err(serde::de::Error::duplicate_field("table"));
16808 }
16809 table__ = map_.next_value()?;
16810 }
16811 GeneratedField::OrderBy => {
16812 if order_by__.is_some() {
16813 return Err(serde::de::Error::duplicate_field("orderBy"));
16814 }
16815 order_by__ = Some(map_.next_value()?);
16816 }
16817 GeneratedField::WithTies => {
16818 if with_ties__.is_some() {
16819 return Err(serde::de::Error::duplicate_field("withTies"));
16820 }
16821 with_ties__ = Some(map_.next_value()?);
16822 }
16823 }
16824 }
16825 Ok(TopNNode {
16826 limit: limit__.unwrap_or_default(),
16827 offset: offset__.unwrap_or_default(),
16828 table: table__,
16829 order_by: order_by__.unwrap_or_default(),
16830 with_ties: with_ties__.unwrap_or_default(),
16831 })
16832 }
16833 }
16834 deserializer.deserialize_struct("stream_plan.TopNNode", FIELDS, GeneratedVisitor)
16835 }
16836}
16837impl serde::Serialize for UnionNode {
16838 #[allow(deprecated)]
16839 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16840 where
16841 S: serde::Serializer,
16842 {
16843 use serde::ser::SerializeStruct;
16844 let len = 0;
16845 let struct_ser = serializer.serialize_struct("stream_plan.UnionNode", len)?;
16846 struct_ser.end()
16847 }
16848}
16849impl<'de> serde::Deserialize<'de> for UnionNode {
16850 #[allow(deprecated)]
16851 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16852 where
16853 D: serde::Deserializer<'de>,
16854 {
16855 const FIELDS: &[&str] = &[
16856 ];
16857
16858 #[allow(clippy::enum_variant_names)]
16859 enum GeneratedField {
16860 }
16861 impl<'de> serde::Deserialize<'de> for GeneratedField {
16862 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16863 where
16864 D: serde::Deserializer<'de>,
16865 {
16866 struct GeneratedVisitor;
16867
16868 impl serde::de::Visitor<'_> for GeneratedVisitor {
16869 type Value = GeneratedField;
16870
16871 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16872 write!(formatter, "expected one of: {:?}", &FIELDS)
16873 }
16874
16875 #[allow(unused_variables)]
16876 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16877 where
16878 E: serde::de::Error,
16879 {
16880 Err(serde::de::Error::unknown_field(value, FIELDS))
16881 }
16882 }
16883 deserializer.deserialize_identifier(GeneratedVisitor)
16884 }
16885 }
16886 struct GeneratedVisitor;
16887 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16888 type Value = UnionNode;
16889
16890 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16891 formatter.write_str("struct stream_plan.UnionNode")
16892 }
16893
16894 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
16895 where
16896 V: serde::de::MapAccess<'de>,
16897 {
16898 while map_.next_key::<GeneratedField>()?.is_some() {
16899 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16900 }
16901 Ok(UnionNode {
16902 })
16903 }
16904 }
16905 deserializer.deserialize_struct("stream_plan.UnionNode", FIELDS, GeneratedVisitor)
16906 }
16907}
16908impl serde::Serialize for UpdateMutation {
16909 #[allow(deprecated)]
16910 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16911 where
16912 S: serde::Serializer,
16913 {
16914 use serde::ser::SerializeStruct;
16915 let mut len = 0;
16916 if !self.dispatcher_update.is_empty() {
16917 len += 1;
16918 }
16919 if !self.merge_update.is_empty() {
16920 len += 1;
16921 }
16922 if !self.actor_vnode_bitmap_update.is_empty() {
16923 len += 1;
16924 }
16925 if !self.dropped_actors.is_empty() {
16926 len += 1;
16927 }
16928 if !self.actor_splits.is_empty() {
16929 len += 1;
16930 }
16931 if !self.actor_new_dispatchers.is_empty() {
16932 len += 1;
16933 }
16934 if self.actor_cdc_table_snapshot_splits.is_some() {
16935 len += 1;
16936 }
16937 if !self.sink_schema_change.is_empty() {
16938 len += 1;
16939 }
16940 if !self.subscriptions_to_drop.is_empty() {
16941 len += 1;
16942 }
16943 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation", len)?;
16944 if !self.dispatcher_update.is_empty() {
16945 struct_ser.serialize_field("dispatcherUpdate", &self.dispatcher_update)?;
16946 }
16947 if !self.merge_update.is_empty() {
16948 struct_ser.serialize_field("mergeUpdate", &self.merge_update)?;
16949 }
16950 if !self.actor_vnode_bitmap_update.is_empty() {
16951 struct_ser.serialize_field("actorVnodeBitmapUpdate", &self.actor_vnode_bitmap_update)?;
16952 }
16953 if !self.dropped_actors.is_empty() {
16954 struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
16955 }
16956 if !self.actor_splits.is_empty() {
16957 struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
16958 }
16959 if !self.actor_new_dispatchers.is_empty() {
16960 struct_ser.serialize_field("actorNewDispatchers", &self.actor_new_dispatchers)?;
16961 }
16962 if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
16963 struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
16964 }
16965 if !self.sink_schema_change.is_empty() {
16966 struct_ser.serialize_field("sinkSchemaChange", &self.sink_schema_change)?;
16967 }
16968 if !self.subscriptions_to_drop.is_empty() {
16969 struct_ser.serialize_field("subscriptionsToDrop", &self.subscriptions_to_drop)?;
16970 }
16971 struct_ser.end()
16972 }
16973}
16974impl<'de> serde::Deserialize<'de> for UpdateMutation {
16975 #[allow(deprecated)]
16976 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16977 where
16978 D: serde::Deserializer<'de>,
16979 {
16980 const FIELDS: &[&str] = &[
16981 "dispatcher_update",
16982 "dispatcherUpdate",
16983 "merge_update",
16984 "mergeUpdate",
16985 "actor_vnode_bitmap_update",
16986 "actorVnodeBitmapUpdate",
16987 "dropped_actors",
16988 "droppedActors",
16989 "actor_splits",
16990 "actorSplits",
16991 "actor_new_dispatchers",
16992 "actorNewDispatchers",
16993 "actor_cdc_table_snapshot_splits",
16994 "actorCdcTableSnapshotSplits",
16995 "sink_schema_change",
16996 "sinkSchemaChange",
16997 "subscriptions_to_drop",
16998 "subscriptionsToDrop",
16999 ];
17000
17001 #[allow(clippy::enum_variant_names)]
17002 enum GeneratedField {
17003 DispatcherUpdate,
17004 MergeUpdate,
17005 ActorVnodeBitmapUpdate,
17006 DroppedActors,
17007 ActorSplits,
17008 ActorNewDispatchers,
17009 ActorCdcTableSnapshotSplits,
17010 SinkSchemaChange,
17011 SubscriptionsToDrop,
17012 }
17013 impl<'de> serde::Deserialize<'de> for GeneratedField {
17014 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17015 where
17016 D: serde::Deserializer<'de>,
17017 {
17018 struct GeneratedVisitor;
17019
17020 impl serde::de::Visitor<'_> for GeneratedVisitor {
17021 type Value = GeneratedField;
17022
17023 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17024 write!(formatter, "expected one of: {:?}", &FIELDS)
17025 }
17026
17027 #[allow(unused_variables)]
17028 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17029 where
17030 E: serde::de::Error,
17031 {
17032 match value {
17033 "dispatcherUpdate" | "dispatcher_update" => Ok(GeneratedField::DispatcherUpdate),
17034 "mergeUpdate" | "merge_update" => Ok(GeneratedField::MergeUpdate),
17035 "actorVnodeBitmapUpdate" | "actor_vnode_bitmap_update" => Ok(GeneratedField::ActorVnodeBitmapUpdate),
17036 "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
17037 "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
17038 "actorNewDispatchers" | "actor_new_dispatchers" => Ok(GeneratedField::ActorNewDispatchers),
17039 "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
17040 "sinkSchemaChange" | "sink_schema_change" => Ok(GeneratedField::SinkSchemaChange),
17041 "subscriptionsToDrop" | "subscriptions_to_drop" => Ok(GeneratedField::SubscriptionsToDrop),
17042 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17043 }
17044 }
17045 }
17046 deserializer.deserialize_identifier(GeneratedVisitor)
17047 }
17048 }
17049 struct GeneratedVisitor;
17050 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17051 type Value = UpdateMutation;
17052
17053 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17054 formatter.write_str("struct stream_plan.UpdateMutation")
17055 }
17056
17057 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateMutation, V::Error>
17058 where
17059 V: serde::de::MapAccess<'de>,
17060 {
17061 let mut dispatcher_update__ = None;
17062 let mut merge_update__ = None;
17063 let mut actor_vnode_bitmap_update__ = None;
17064 let mut dropped_actors__ = None;
17065 let mut actor_splits__ = None;
17066 let mut actor_new_dispatchers__ = None;
17067 let mut actor_cdc_table_snapshot_splits__ = None;
17068 let mut sink_schema_change__ = None;
17069 let mut subscriptions_to_drop__ = None;
17070 while let Some(k) = map_.next_key()? {
17071 match k {
17072 GeneratedField::DispatcherUpdate => {
17073 if dispatcher_update__.is_some() {
17074 return Err(serde::de::Error::duplicate_field("dispatcherUpdate"));
17075 }
17076 dispatcher_update__ = Some(map_.next_value()?);
17077 }
17078 GeneratedField::MergeUpdate => {
17079 if merge_update__.is_some() {
17080 return Err(serde::de::Error::duplicate_field("mergeUpdate"));
17081 }
17082 merge_update__ = Some(map_.next_value()?);
17083 }
17084 GeneratedField::ActorVnodeBitmapUpdate => {
17085 if actor_vnode_bitmap_update__.is_some() {
17086 return Err(serde::de::Error::duplicate_field("actorVnodeBitmapUpdate"));
17087 }
17088 actor_vnode_bitmap_update__ = Some(
17089 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
17090 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
17091 );
17092 }
17093 GeneratedField::DroppedActors => {
17094 if dropped_actors__.is_some() {
17095 return Err(serde::de::Error::duplicate_field("droppedActors"));
17096 }
17097 dropped_actors__ =
17098 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17099 .into_iter().map(|x| x.0).collect())
17100 ;
17101 }
17102 GeneratedField::ActorSplits => {
17103 if actor_splits__.is_some() {
17104 return Err(serde::de::Error::duplicate_field("actorSplits"));
17105 }
17106 actor_splits__ = Some(
17107 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
17108 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
17109 );
17110 }
17111 GeneratedField::ActorNewDispatchers => {
17112 if actor_new_dispatchers__.is_some() {
17113 return Err(serde::de::Error::duplicate_field("actorNewDispatchers"));
17114 }
17115 actor_new_dispatchers__ = Some(
17116 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
17117 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
17118 );
17119 }
17120 GeneratedField::ActorCdcTableSnapshotSplits => {
17121 if actor_cdc_table_snapshot_splits__.is_some() {
17122 return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
17123 }
17124 actor_cdc_table_snapshot_splits__ = map_.next_value()?;
17125 }
17126 GeneratedField::SinkSchemaChange => {
17127 if sink_schema_change__.is_some() {
17128 return Err(serde::de::Error::duplicate_field("sinkSchemaChange"));
17129 }
17130 sink_schema_change__ = Some(
17131 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
17132 .into_iter().map(|(k,v)| (k.0.into(), v)).collect()
17133 );
17134 }
17135 GeneratedField::SubscriptionsToDrop => {
17136 if subscriptions_to_drop__.is_some() {
17137 return Err(serde::de::Error::duplicate_field("subscriptionsToDrop"));
17138 }
17139 subscriptions_to_drop__ = Some(map_.next_value()?);
17140 }
17141 }
17142 }
17143 Ok(UpdateMutation {
17144 dispatcher_update: dispatcher_update__.unwrap_or_default(),
17145 merge_update: merge_update__.unwrap_or_default(),
17146 actor_vnode_bitmap_update: actor_vnode_bitmap_update__.unwrap_or_default(),
17147 dropped_actors: dropped_actors__.unwrap_or_default(),
17148 actor_splits: actor_splits__.unwrap_or_default(),
17149 actor_new_dispatchers: actor_new_dispatchers__.unwrap_or_default(),
17150 actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
17151 sink_schema_change: sink_schema_change__.unwrap_or_default(),
17152 subscriptions_to_drop: subscriptions_to_drop__.unwrap_or_default(),
17153 })
17154 }
17155 }
17156 deserializer.deserialize_struct("stream_plan.UpdateMutation", FIELDS, GeneratedVisitor)
17157 }
17158}
17159impl serde::Serialize for update_mutation::DispatcherUpdate {
17160 #[allow(deprecated)]
17161 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17162 where
17163 S: serde::Serializer,
17164 {
17165 use serde::ser::SerializeStruct;
17166 let mut len = 0;
17167 if self.actor_id != 0 {
17168 len += 1;
17169 }
17170 if self.dispatcher_id != 0 {
17171 len += 1;
17172 }
17173 if self.hash_mapping.is_some() {
17174 len += 1;
17175 }
17176 if !self.added_downstream_actor_id.is_empty() {
17177 len += 1;
17178 }
17179 if !self.removed_downstream_actor_id.is_empty() {
17180 len += 1;
17181 }
17182 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", len)?;
17183 if self.actor_id != 0 {
17184 struct_ser.serialize_field("actorId", &self.actor_id)?;
17185 }
17186 if self.dispatcher_id != 0 {
17187 struct_ser.serialize_field("dispatcherId", &self.dispatcher_id)?;
17188 }
17189 if let Some(v) = self.hash_mapping.as_ref() {
17190 struct_ser.serialize_field("hashMapping", v)?;
17191 }
17192 if !self.added_downstream_actor_id.is_empty() {
17193 struct_ser.serialize_field("addedDownstreamActorId", &self.added_downstream_actor_id)?;
17194 }
17195 if !self.removed_downstream_actor_id.is_empty() {
17196 struct_ser.serialize_field("removedDownstreamActorId", &self.removed_downstream_actor_id)?;
17197 }
17198 struct_ser.end()
17199 }
17200}
17201impl<'de> serde::Deserialize<'de> for update_mutation::DispatcherUpdate {
17202 #[allow(deprecated)]
17203 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17204 where
17205 D: serde::Deserializer<'de>,
17206 {
17207 const FIELDS: &[&str] = &[
17208 "actor_id",
17209 "actorId",
17210 "dispatcher_id",
17211 "dispatcherId",
17212 "hash_mapping",
17213 "hashMapping",
17214 "added_downstream_actor_id",
17215 "addedDownstreamActorId",
17216 "removed_downstream_actor_id",
17217 "removedDownstreamActorId",
17218 ];
17219
17220 #[allow(clippy::enum_variant_names)]
17221 enum GeneratedField {
17222 ActorId,
17223 DispatcherId,
17224 HashMapping,
17225 AddedDownstreamActorId,
17226 RemovedDownstreamActorId,
17227 }
17228 impl<'de> serde::Deserialize<'de> for GeneratedField {
17229 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17230 where
17231 D: serde::Deserializer<'de>,
17232 {
17233 struct GeneratedVisitor;
17234
17235 impl serde::de::Visitor<'_> for GeneratedVisitor {
17236 type Value = GeneratedField;
17237
17238 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17239 write!(formatter, "expected one of: {:?}", &FIELDS)
17240 }
17241
17242 #[allow(unused_variables)]
17243 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17244 where
17245 E: serde::de::Error,
17246 {
17247 match value {
17248 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
17249 "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
17250 "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
17251 "addedDownstreamActorId" | "added_downstream_actor_id" => Ok(GeneratedField::AddedDownstreamActorId),
17252 "removedDownstreamActorId" | "removed_downstream_actor_id" => Ok(GeneratedField::RemovedDownstreamActorId),
17253 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17254 }
17255 }
17256 }
17257 deserializer.deserialize_identifier(GeneratedVisitor)
17258 }
17259 }
17260 struct GeneratedVisitor;
17261 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17262 type Value = update_mutation::DispatcherUpdate;
17263
17264 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17265 formatter.write_str("struct stream_plan.UpdateMutation.DispatcherUpdate")
17266 }
17267
17268 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::DispatcherUpdate, V::Error>
17269 where
17270 V: serde::de::MapAccess<'de>,
17271 {
17272 let mut actor_id__ = None;
17273 let mut dispatcher_id__ = None;
17274 let mut hash_mapping__ = None;
17275 let mut added_downstream_actor_id__ = None;
17276 let mut removed_downstream_actor_id__ = None;
17277 while let Some(k) = map_.next_key()? {
17278 match k {
17279 GeneratedField::ActorId => {
17280 if actor_id__.is_some() {
17281 return Err(serde::de::Error::duplicate_field("actorId"));
17282 }
17283 actor_id__ =
17284 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17285 ;
17286 }
17287 GeneratedField::DispatcherId => {
17288 if dispatcher_id__.is_some() {
17289 return Err(serde::de::Error::duplicate_field("dispatcherId"));
17290 }
17291 dispatcher_id__ =
17292 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17293 ;
17294 }
17295 GeneratedField::HashMapping => {
17296 if hash_mapping__.is_some() {
17297 return Err(serde::de::Error::duplicate_field("hashMapping"));
17298 }
17299 hash_mapping__ = map_.next_value()?;
17300 }
17301 GeneratedField::AddedDownstreamActorId => {
17302 if added_downstream_actor_id__.is_some() {
17303 return Err(serde::de::Error::duplicate_field("addedDownstreamActorId"));
17304 }
17305 added_downstream_actor_id__ =
17306 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17307 .into_iter().map(|x| x.0).collect())
17308 ;
17309 }
17310 GeneratedField::RemovedDownstreamActorId => {
17311 if removed_downstream_actor_id__.is_some() {
17312 return Err(serde::de::Error::duplicate_field("removedDownstreamActorId"));
17313 }
17314 removed_downstream_actor_id__ =
17315 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17316 .into_iter().map(|x| x.0).collect())
17317 ;
17318 }
17319 }
17320 }
17321 Ok(update_mutation::DispatcherUpdate {
17322 actor_id: actor_id__.unwrap_or_default(),
17323 dispatcher_id: dispatcher_id__.unwrap_or_default(),
17324 hash_mapping: hash_mapping__,
17325 added_downstream_actor_id: added_downstream_actor_id__.unwrap_or_default(),
17326 removed_downstream_actor_id: removed_downstream_actor_id__.unwrap_or_default(),
17327 })
17328 }
17329 }
17330 deserializer.deserialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", FIELDS, GeneratedVisitor)
17331 }
17332}
17333impl serde::Serialize for update_mutation::MergeUpdate {
17334 #[allow(deprecated)]
17335 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17336 where
17337 S: serde::Serializer,
17338 {
17339 use serde::ser::SerializeStruct;
17340 let mut len = 0;
17341 if self.actor_id != 0 {
17342 len += 1;
17343 }
17344 if self.upstream_fragment_id != 0 {
17345 len += 1;
17346 }
17347 if self.new_upstream_fragment_id.is_some() {
17348 len += 1;
17349 }
17350 if !self.added_upstream_actors.is_empty() {
17351 len += 1;
17352 }
17353 if !self.removed_upstream_actor_id.is_empty() {
17354 len += 1;
17355 }
17356 let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.MergeUpdate", len)?;
17357 if self.actor_id != 0 {
17358 struct_ser.serialize_field("actorId", &self.actor_id)?;
17359 }
17360 if self.upstream_fragment_id != 0 {
17361 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
17362 }
17363 if let Some(v) = self.new_upstream_fragment_id.as_ref() {
17364 struct_ser.serialize_field("newUpstreamFragmentId", v)?;
17365 }
17366 if !self.added_upstream_actors.is_empty() {
17367 struct_ser.serialize_field("addedUpstreamActors", &self.added_upstream_actors)?;
17368 }
17369 if !self.removed_upstream_actor_id.is_empty() {
17370 struct_ser.serialize_field("removedUpstreamActorId", &self.removed_upstream_actor_id)?;
17371 }
17372 struct_ser.end()
17373 }
17374}
17375impl<'de> serde::Deserialize<'de> for update_mutation::MergeUpdate {
17376 #[allow(deprecated)]
17377 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17378 where
17379 D: serde::Deserializer<'de>,
17380 {
17381 const FIELDS: &[&str] = &[
17382 "actor_id",
17383 "actorId",
17384 "upstream_fragment_id",
17385 "upstreamFragmentId",
17386 "new_upstream_fragment_id",
17387 "newUpstreamFragmentId",
17388 "added_upstream_actors",
17389 "addedUpstreamActors",
17390 "removed_upstream_actor_id",
17391 "removedUpstreamActorId",
17392 ];
17393
17394 #[allow(clippy::enum_variant_names)]
17395 enum GeneratedField {
17396 ActorId,
17397 UpstreamFragmentId,
17398 NewUpstreamFragmentId,
17399 AddedUpstreamActors,
17400 RemovedUpstreamActorId,
17401 }
17402 impl<'de> serde::Deserialize<'de> for GeneratedField {
17403 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17404 where
17405 D: serde::Deserializer<'de>,
17406 {
17407 struct GeneratedVisitor;
17408
17409 impl serde::de::Visitor<'_> for GeneratedVisitor {
17410 type Value = GeneratedField;
17411
17412 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17413 write!(formatter, "expected one of: {:?}", &FIELDS)
17414 }
17415
17416 #[allow(unused_variables)]
17417 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17418 where
17419 E: serde::de::Error,
17420 {
17421 match value {
17422 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
17423 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
17424 "newUpstreamFragmentId" | "new_upstream_fragment_id" => Ok(GeneratedField::NewUpstreamFragmentId),
17425 "addedUpstreamActors" | "added_upstream_actors" => Ok(GeneratedField::AddedUpstreamActors),
17426 "removedUpstreamActorId" | "removed_upstream_actor_id" => Ok(GeneratedField::RemovedUpstreamActorId),
17427 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17428 }
17429 }
17430 }
17431 deserializer.deserialize_identifier(GeneratedVisitor)
17432 }
17433 }
17434 struct GeneratedVisitor;
17435 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17436 type Value = update_mutation::MergeUpdate;
17437
17438 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17439 formatter.write_str("struct stream_plan.UpdateMutation.MergeUpdate")
17440 }
17441
17442 fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::MergeUpdate, V::Error>
17443 where
17444 V: serde::de::MapAccess<'de>,
17445 {
17446 let mut actor_id__ = None;
17447 let mut upstream_fragment_id__ = None;
17448 let mut new_upstream_fragment_id__ = None;
17449 let mut added_upstream_actors__ = None;
17450 let mut removed_upstream_actor_id__ = None;
17451 while let Some(k) = map_.next_key()? {
17452 match k {
17453 GeneratedField::ActorId => {
17454 if actor_id__.is_some() {
17455 return Err(serde::de::Error::duplicate_field("actorId"));
17456 }
17457 actor_id__ =
17458 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17459 ;
17460 }
17461 GeneratedField::UpstreamFragmentId => {
17462 if upstream_fragment_id__.is_some() {
17463 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
17464 }
17465 upstream_fragment_id__ =
17466 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17467 ;
17468 }
17469 GeneratedField::NewUpstreamFragmentId => {
17470 if new_upstream_fragment_id__.is_some() {
17471 return Err(serde::de::Error::duplicate_field("newUpstreamFragmentId"));
17472 }
17473 new_upstream_fragment_id__ =
17474 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
17475 ;
17476 }
17477 GeneratedField::AddedUpstreamActors => {
17478 if added_upstream_actors__.is_some() {
17479 return Err(serde::de::Error::duplicate_field("addedUpstreamActors"));
17480 }
17481 added_upstream_actors__ = Some(map_.next_value()?);
17482 }
17483 GeneratedField::RemovedUpstreamActorId => {
17484 if removed_upstream_actor_id__.is_some() {
17485 return Err(serde::de::Error::duplicate_field("removedUpstreamActorId"));
17486 }
17487 removed_upstream_actor_id__ =
17488 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17489 .into_iter().map(|x| x.0).collect())
17490 ;
17491 }
17492 }
17493 }
17494 Ok(update_mutation::MergeUpdate {
17495 actor_id: actor_id__.unwrap_or_default(),
17496 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
17497 new_upstream_fragment_id: new_upstream_fragment_id__,
17498 added_upstream_actors: added_upstream_actors__.unwrap_or_default(),
17499 removed_upstream_actor_id: removed_upstream_actor_id__.unwrap_or_default(),
17500 })
17501 }
17502 }
17503 deserializer.deserialize_struct("stream_plan.UpdateMutation.MergeUpdate", FIELDS, GeneratedVisitor)
17504 }
17505}
17506impl serde::Serialize for UpstreamSinkInfo {
17507 #[allow(deprecated)]
17508 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17509 where
17510 S: serde::Serializer,
17511 {
17512 use serde::ser::SerializeStruct;
17513 let mut len = 0;
17514 if self.upstream_fragment_id != 0 {
17515 len += 1;
17516 }
17517 if !self.sink_output_schema.is_empty() {
17518 len += 1;
17519 }
17520 if !self.project_exprs.is_empty() {
17521 len += 1;
17522 }
17523 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkInfo", len)?;
17524 if self.upstream_fragment_id != 0 {
17525 struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
17526 }
17527 if !self.sink_output_schema.is_empty() {
17528 struct_ser.serialize_field("sinkOutputSchema", &self.sink_output_schema)?;
17529 }
17530 if !self.project_exprs.is_empty() {
17531 struct_ser.serialize_field("projectExprs", &self.project_exprs)?;
17532 }
17533 struct_ser.end()
17534 }
17535}
17536impl<'de> serde::Deserialize<'de> for UpstreamSinkInfo {
17537 #[allow(deprecated)]
17538 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17539 where
17540 D: serde::Deserializer<'de>,
17541 {
17542 const FIELDS: &[&str] = &[
17543 "upstream_fragment_id",
17544 "upstreamFragmentId",
17545 "sink_output_schema",
17546 "sinkOutputSchema",
17547 "project_exprs",
17548 "projectExprs",
17549 ];
17550
17551 #[allow(clippy::enum_variant_names)]
17552 enum GeneratedField {
17553 UpstreamFragmentId,
17554 SinkOutputSchema,
17555 ProjectExprs,
17556 }
17557 impl<'de> serde::Deserialize<'de> for GeneratedField {
17558 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17559 where
17560 D: serde::Deserializer<'de>,
17561 {
17562 struct GeneratedVisitor;
17563
17564 impl serde::de::Visitor<'_> for GeneratedVisitor {
17565 type Value = GeneratedField;
17566
17567 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17568 write!(formatter, "expected one of: {:?}", &FIELDS)
17569 }
17570
17571 #[allow(unused_variables)]
17572 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17573 where
17574 E: serde::de::Error,
17575 {
17576 match value {
17577 "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
17578 "sinkOutputSchema" | "sink_output_schema" => Ok(GeneratedField::SinkOutputSchema),
17579 "projectExprs" | "project_exprs" => Ok(GeneratedField::ProjectExprs),
17580 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17581 }
17582 }
17583 }
17584 deserializer.deserialize_identifier(GeneratedVisitor)
17585 }
17586 }
17587 struct GeneratedVisitor;
17588 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17589 type Value = UpstreamSinkInfo;
17590
17591 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17592 formatter.write_str("struct stream_plan.UpstreamSinkInfo")
17593 }
17594
17595 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkInfo, V::Error>
17596 where
17597 V: serde::de::MapAccess<'de>,
17598 {
17599 let mut upstream_fragment_id__ = None;
17600 let mut sink_output_schema__ = None;
17601 let mut project_exprs__ = None;
17602 while let Some(k) = map_.next_key()? {
17603 match k {
17604 GeneratedField::UpstreamFragmentId => {
17605 if upstream_fragment_id__.is_some() {
17606 return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
17607 }
17608 upstream_fragment_id__ =
17609 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17610 ;
17611 }
17612 GeneratedField::SinkOutputSchema => {
17613 if sink_output_schema__.is_some() {
17614 return Err(serde::de::Error::duplicate_field("sinkOutputSchema"));
17615 }
17616 sink_output_schema__ = Some(map_.next_value()?);
17617 }
17618 GeneratedField::ProjectExprs => {
17619 if project_exprs__.is_some() {
17620 return Err(serde::de::Error::duplicate_field("projectExprs"));
17621 }
17622 project_exprs__ = Some(map_.next_value()?);
17623 }
17624 }
17625 }
17626 Ok(UpstreamSinkInfo {
17627 upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
17628 sink_output_schema: sink_output_schema__.unwrap_or_default(),
17629 project_exprs: project_exprs__.unwrap_or_default(),
17630 })
17631 }
17632 }
17633 deserializer.deserialize_struct("stream_plan.UpstreamSinkInfo", FIELDS, GeneratedVisitor)
17634 }
17635}
17636impl serde::Serialize for UpstreamSinkUnionNode {
17637 #[allow(deprecated)]
17638 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17639 where
17640 S: serde::Serializer,
17641 {
17642 use serde::ser::SerializeStruct;
17643 let mut len = 0;
17644 if !self.init_upstreams.is_empty() {
17645 len += 1;
17646 }
17647 let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkUnionNode", len)?;
17648 if !self.init_upstreams.is_empty() {
17649 struct_ser.serialize_field("initUpstreams", &self.init_upstreams)?;
17650 }
17651 struct_ser.end()
17652 }
17653}
17654impl<'de> serde::Deserialize<'de> for UpstreamSinkUnionNode {
17655 #[allow(deprecated)]
17656 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17657 where
17658 D: serde::Deserializer<'de>,
17659 {
17660 const FIELDS: &[&str] = &[
17661 "init_upstreams",
17662 "initUpstreams",
17663 ];
17664
17665 #[allow(clippy::enum_variant_names)]
17666 enum GeneratedField {
17667 InitUpstreams,
17668 }
17669 impl<'de> serde::Deserialize<'de> for GeneratedField {
17670 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17671 where
17672 D: serde::Deserializer<'de>,
17673 {
17674 struct GeneratedVisitor;
17675
17676 impl serde::de::Visitor<'_> for GeneratedVisitor {
17677 type Value = GeneratedField;
17678
17679 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17680 write!(formatter, "expected one of: {:?}", &FIELDS)
17681 }
17682
17683 #[allow(unused_variables)]
17684 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17685 where
17686 E: serde::de::Error,
17687 {
17688 match value {
17689 "initUpstreams" | "init_upstreams" => Ok(GeneratedField::InitUpstreams),
17690 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17691 }
17692 }
17693 }
17694 deserializer.deserialize_identifier(GeneratedVisitor)
17695 }
17696 }
17697 struct GeneratedVisitor;
17698 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17699 type Value = UpstreamSinkUnionNode;
17700
17701 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17702 formatter.write_str("struct stream_plan.UpstreamSinkUnionNode")
17703 }
17704
17705 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkUnionNode, V::Error>
17706 where
17707 V: serde::de::MapAccess<'de>,
17708 {
17709 let mut init_upstreams__ = None;
17710 while let Some(k) = map_.next_key()? {
17711 match k {
17712 GeneratedField::InitUpstreams => {
17713 if init_upstreams__.is_some() {
17714 return Err(serde::de::Error::duplicate_field("initUpstreams"));
17715 }
17716 init_upstreams__ = Some(map_.next_value()?);
17717 }
17718 }
17719 }
17720 Ok(UpstreamSinkUnionNode {
17721 init_upstreams: init_upstreams__.unwrap_or_default(),
17722 })
17723 }
17724 }
17725 deserializer.deserialize_struct("stream_plan.UpstreamSinkUnionNode", FIELDS, GeneratedVisitor)
17726 }
17727}
17728impl serde::Serialize for ValuesNode {
17729 #[allow(deprecated)]
17730 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17731 where
17732 S: serde::Serializer,
17733 {
17734 use serde::ser::SerializeStruct;
17735 let mut len = 0;
17736 if !self.tuples.is_empty() {
17737 len += 1;
17738 }
17739 if !self.fields.is_empty() {
17740 len += 1;
17741 }
17742 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode", len)?;
17743 if !self.tuples.is_empty() {
17744 struct_ser.serialize_field("tuples", &self.tuples)?;
17745 }
17746 if !self.fields.is_empty() {
17747 struct_ser.serialize_field("fields", &self.fields)?;
17748 }
17749 struct_ser.end()
17750 }
17751}
17752impl<'de> serde::Deserialize<'de> for ValuesNode {
17753 #[allow(deprecated)]
17754 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17755 where
17756 D: serde::Deserializer<'de>,
17757 {
17758 const FIELDS: &[&str] = &[
17759 "tuples",
17760 "fields",
17761 ];
17762
17763 #[allow(clippy::enum_variant_names)]
17764 enum GeneratedField {
17765 Tuples,
17766 Fields,
17767 }
17768 impl<'de> serde::Deserialize<'de> for GeneratedField {
17769 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17770 where
17771 D: serde::Deserializer<'de>,
17772 {
17773 struct GeneratedVisitor;
17774
17775 impl serde::de::Visitor<'_> for GeneratedVisitor {
17776 type Value = GeneratedField;
17777
17778 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17779 write!(formatter, "expected one of: {:?}", &FIELDS)
17780 }
17781
17782 #[allow(unused_variables)]
17783 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17784 where
17785 E: serde::de::Error,
17786 {
17787 match value {
17788 "tuples" => Ok(GeneratedField::Tuples),
17789 "fields" => Ok(GeneratedField::Fields),
17790 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17791 }
17792 }
17793 }
17794 deserializer.deserialize_identifier(GeneratedVisitor)
17795 }
17796 }
17797 struct GeneratedVisitor;
17798 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17799 type Value = ValuesNode;
17800
17801 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17802 formatter.write_str("struct stream_plan.ValuesNode")
17803 }
17804
17805 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
17806 where
17807 V: serde::de::MapAccess<'de>,
17808 {
17809 let mut tuples__ = None;
17810 let mut fields__ = None;
17811 while let Some(k) = map_.next_key()? {
17812 match k {
17813 GeneratedField::Tuples => {
17814 if tuples__.is_some() {
17815 return Err(serde::de::Error::duplicate_field("tuples"));
17816 }
17817 tuples__ = Some(map_.next_value()?);
17818 }
17819 GeneratedField::Fields => {
17820 if fields__.is_some() {
17821 return Err(serde::de::Error::duplicate_field("fields"));
17822 }
17823 fields__ = Some(map_.next_value()?);
17824 }
17825 }
17826 }
17827 Ok(ValuesNode {
17828 tuples: tuples__.unwrap_or_default(),
17829 fields: fields__.unwrap_or_default(),
17830 })
17831 }
17832 }
17833 deserializer.deserialize_struct("stream_plan.ValuesNode", FIELDS, GeneratedVisitor)
17834 }
17835}
17836impl serde::Serialize for values_node::ExprTuple {
17837 #[allow(deprecated)]
17838 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17839 where
17840 S: serde::Serializer,
17841 {
17842 use serde::ser::SerializeStruct;
17843 let mut len = 0;
17844 if !self.cells.is_empty() {
17845 len += 1;
17846 }
17847 let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode.ExprTuple", len)?;
17848 if !self.cells.is_empty() {
17849 struct_ser.serialize_field("cells", &self.cells)?;
17850 }
17851 struct_ser.end()
17852 }
17853}
17854impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
17855 #[allow(deprecated)]
17856 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17857 where
17858 D: serde::Deserializer<'de>,
17859 {
17860 const FIELDS: &[&str] = &[
17861 "cells",
17862 ];
17863
17864 #[allow(clippy::enum_variant_names)]
17865 enum GeneratedField {
17866 Cells,
17867 }
17868 impl<'de> serde::Deserialize<'de> for GeneratedField {
17869 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17870 where
17871 D: serde::Deserializer<'de>,
17872 {
17873 struct GeneratedVisitor;
17874
17875 impl serde::de::Visitor<'_> for GeneratedVisitor {
17876 type Value = GeneratedField;
17877
17878 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17879 write!(formatter, "expected one of: {:?}", &FIELDS)
17880 }
17881
17882 #[allow(unused_variables)]
17883 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17884 where
17885 E: serde::de::Error,
17886 {
17887 match value {
17888 "cells" => Ok(GeneratedField::Cells),
17889 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17890 }
17891 }
17892 }
17893 deserializer.deserialize_identifier(GeneratedVisitor)
17894 }
17895 }
17896 struct GeneratedVisitor;
17897 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17898 type Value = values_node::ExprTuple;
17899
17900 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17901 formatter.write_str("struct stream_plan.ValuesNode.ExprTuple")
17902 }
17903
17904 fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
17905 where
17906 V: serde::de::MapAccess<'de>,
17907 {
17908 let mut cells__ = None;
17909 while let Some(k) = map_.next_key()? {
17910 match k {
17911 GeneratedField::Cells => {
17912 if cells__.is_some() {
17913 return Err(serde::de::Error::duplicate_field("cells"));
17914 }
17915 cells__ = Some(map_.next_value()?);
17916 }
17917 }
17918 }
17919 Ok(values_node::ExprTuple {
17920 cells: cells__.unwrap_or_default(),
17921 })
17922 }
17923 }
17924 deserializer.deserialize_struct("stream_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
17925 }
17926}
17927impl serde::Serialize for VectorIndexLookupJoinNode {
17928 #[allow(deprecated)]
17929 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17930 where
17931 S: serde::Serializer,
17932 {
17933 use serde::ser::SerializeStruct;
17934 let mut len = 0;
17935 if self.reader_desc.is_some() {
17936 len += 1;
17937 }
17938 if self.vector_column_idx != 0 {
17939 len += 1;
17940 }
17941 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexLookupJoinNode", len)?;
17942 if let Some(v) = self.reader_desc.as_ref() {
17943 struct_ser.serialize_field("readerDesc", v)?;
17944 }
17945 if self.vector_column_idx != 0 {
17946 struct_ser.serialize_field("vectorColumnIdx", &self.vector_column_idx)?;
17947 }
17948 struct_ser.end()
17949 }
17950}
17951impl<'de> serde::Deserialize<'de> for VectorIndexLookupJoinNode {
17952 #[allow(deprecated)]
17953 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17954 where
17955 D: serde::Deserializer<'de>,
17956 {
17957 const FIELDS: &[&str] = &[
17958 "reader_desc",
17959 "readerDesc",
17960 "vector_column_idx",
17961 "vectorColumnIdx",
17962 ];
17963
17964 #[allow(clippy::enum_variant_names)]
17965 enum GeneratedField {
17966 ReaderDesc,
17967 VectorColumnIdx,
17968 }
17969 impl<'de> serde::Deserialize<'de> for GeneratedField {
17970 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17971 where
17972 D: serde::Deserializer<'de>,
17973 {
17974 struct GeneratedVisitor;
17975
17976 impl serde::de::Visitor<'_> for GeneratedVisitor {
17977 type Value = GeneratedField;
17978
17979 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17980 write!(formatter, "expected one of: {:?}", &FIELDS)
17981 }
17982
17983 #[allow(unused_variables)]
17984 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17985 where
17986 E: serde::de::Error,
17987 {
17988 match value {
17989 "readerDesc" | "reader_desc" => Ok(GeneratedField::ReaderDesc),
17990 "vectorColumnIdx" | "vector_column_idx" => Ok(GeneratedField::VectorColumnIdx),
17991 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17992 }
17993 }
17994 }
17995 deserializer.deserialize_identifier(GeneratedVisitor)
17996 }
17997 }
17998 struct GeneratedVisitor;
17999 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18000 type Value = VectorIndexLookupJoinNode;
18001
18002 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18003 formatter.write_str("struct stream_plan.VectorIndexLookupJoinNode")
18004 }
18005
18006 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexLookupJoinNode, V::Error>
18007 where
18008 V: serde::de::MapAccess<'de>,
18009 {
18010 let mut reader_desc__ = None;
18011 let mut vector_column_idx__ = None;
18012 while let Some(k) = map_.next_key()? {
18013 match k {
18014 GeneratedField::ReaderDesc => {
18015 if reader_desc__.is_some() {
18016 return Err(serde::de::Error::duplicate_field("readerDesc"));
18017 }
18018 reader_desc__ = map_.next_value()?;
18019 }
18020 GeneratedField::VectorColumnIdx => {
18021 if vector_column_idx__.is_some() {
18022 return Err(serde::de::Error::duplicate_field("vectorColumnIdx"));
18023 }
18024 vector_column_idx__ =
18025 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
18026 ;
18027 }
18028 }
18029 }
18030 Ok(VectorIndexLookupJoinNode {
18031 reader_desc: reader_desc__,
18032 vector_column_idx: vector_column_idx__.unwrap_or_default(),
18033 })
18034 }
18035 }
18036 deserializer.deserialize_struct("stream_plan.VectorIndexLookupJoinNode", FIELDS, GeneratedVisitor)
18037 }
18038}
18039impl serde::Serialize for VectorIndexWriteNode {
18040 #[allow(deprecated)]
18041 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18042 where
18043 S: serde::Serializer,
18044 {
18045 use serde::ser::SerializeStruct;
18046 let mut len = 0;
18047 if self.table.is_some() {
18048 len += 1;
18049 }
18050 let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexWriteNode", len)?;
18051 if let Some(v) = self.table.as_ref() {
18052 struct_ser.serialize_field("table", v)?;
18053 }
18054 struct_ser.end()
18055 }
18056}
18057impl<'de> serde::Deserialize<'de> for VectorIndexWriteNode {
18058 #[allow(deprecated)]
18059 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18060 where
18061 D: serde::Deserializer<'de>,
18062 {
18063 const FIELDS: &[&str] = &[
18064 "table",
18065 ];
18066
18067 #[allow(clippy::enum_variant_names)]
18068 enum GeneratedField {
18069 Table,
18070 }
18071 impl<'de> serde::Deserialize<'de> for GeneratedField {
18072 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18073 where
18074 D: serde::Deserializer<'de>,
18075 {
18076 struct GeneratedVisitor;
18077
18078 impl serde::de::Visitor<'_> for GeneratedVisitor {
18079 type Value = GeneratedField;
18080
18081 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18082 write!(formatter, "expected one of: {:?}", &FIELDS)
18083 }
18084
18085 #[allow(unused_variables)]
18086 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18087 where
18088 E: serde::de::Error,
18089 {
18090 match value {
18091 "table" => Ok(GeneratedField::Table),
18092 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18093 }
18094 }
18095 }
18096 deserializer.deserialize_identifier(GeneratedVisitor)
18097 }
18098 }
18099 struct GeneratedVisitor;
18100 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18101 type Value = VectorIndexWriteNode;
18102
18103 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18104 formatter.write_str("struct stream_plan.VectorIndexWriteNode")
18105 }
18106
18107 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexWriteNode, V::Error>
18108 where
18109 V: serde::de::MapAccess<'de>,
18110 {
18111 let mut table__ = None;
18112 while let Some(k) = map_.next_key()? {
18113 match k {
18114 GeneratedField::Table => {
18115 if table__.is_some() {
18116 return Err(serde::de::Error::duplicate_field("table"));
18117 }
18118 table__ = map_.next_value()?;
18119 }
18120 }
18121 }
18122 Ok(VectorIndexWriteNode {
18123 table: table__,
18124 })
18125 }
18126 }
18127 deserializer.deserialize_struct("stream_plan.VectorIndexWriteNode", FIELDS, GeneratedVisitor)
18128 }
18129}
18130impl serde::Serialize for Watermark {
18131 #[allow(deprecated)]
18132 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18133 where
18134 S: serde::Serializer,
18135 {
18136 use serde::ser::SerializeStruct;
18137 let mut len = 0;
18138 if self.column.is_some() {
18139 len += 1;
18140 }
18141 if self.val.is_some() {
18142 len += 1;
18143 }
18144 let mut struct_ser = serializer.serialize_struct("stream_plan.Watermark", len)?;
18145 if let Some(v) = self.column.as_ref() {
18146 struct_ser.serialize_field("column", v)?;
18147 }
18148 if let Some(v) = self.val.as_ref() {
18149 struct_ser.serialize_field("val", v)?;
18150 }
18151 struct_ser.end()
18152 }
18153}
18154impl<'de> serde::Deserialize<'de> for Watermark {
18155 #[allow(deprecated)]
18156 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18157 where
18158 D: serde::Deserializer<'de>,
18159 {
18160 const FIELDS: &[&str] = &[
18161 "column",
18162 "val",
18163 ];
18164
18165 #[allow(clippy::enum_variant_names)]
18166 enum GeneratedField {
18167 Column,
18168 Val,
18169 }
18170 impl<'de> serde::Deserialize<'de> for GeneratedField {
18171 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18172 where
18173 D: serde::Deserializer<'de>,
18174 {
18175 struct GeneratedVisitor;
18176
18177 impl serde::de::Visitor<'_> for GeneratedVisitor {
18178 type Value = GeneratedField;
18179
18180 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18181 write!(formatter, "expected one of: {:?}", &FIELDS)
18182 }
18183
18184 #[allow(unused_variables)]
18185 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18186 where
18187 E: serde::de::Error,
18188 {
18189 match value {
18190 "column" => Ok(GeneratedField::Column),
18191 "val" => Ok(GeneratedField::Val),
18192 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18193 }
18194 }
18195 }
18196 deserializer.deserialize_identifier(GeneratedVisitor)
18197 }
18198 }
18199 struct GeneratedVisitor;
18200 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18201 type Value = Watermark;
18202
18203 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18204 formatter.write_str("struct stream_plan.Watermark")
18205 }
18206
18207 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Watermark, V::Error>
18208 where
18209 V: serde::de::MapAccess<'de>,
18210 {
18211 let mut column__ = None;
18212 let mut val__ = None;
18213 while let Some(k) = map_.next_key()? {
18214 match k {
18215 GeneratedField::Column => {
18216 if column__.is_some() {
18217 return Err(serde::de::Error::duplicate_field("column"));
18218 }
18219 column__ = map_.next_value()?;
18220 }
18221 GeneratedField::Val => {
18222 if val__.is_some() {
18223 return Err(serde::de::Error::duplicate_field("val"));
18224 }
18225 val__ = map_.next_value()?;
18226 }
18227 }
18228 }
18229 Ok(Watermark {
18230 column: column__,
18231 val: val__,
18232 })
18233 }
18234 }
18235 deserializer.deserialize_struct("stream_plan.Watermark", FIELDS, GeneratedVisitor)
18236 }
18237}
18238impl serde::Serialize for WatermarkFilterNode {
18239 #[allow(deprecated)]
18240 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18241 where
18242 S: serde::Serializer,
18243 {
18244 use serde::ser::SerializeStruct;
18245 let mut len = 0;
18246 if !self.watermark_descs.is_empty() {
18247 len += 1;
18248 }
18249 if !self.tables.is_empty() {
18250 len += 1;
18251 }
18252 let mut struct_ser = serializer.serialize_struct("stream_plan.WatermarkFilterNode", len)?;
18253 if !self.watermark_descs.is_empty() {
18254 struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
18255 }
18256 if !self.tables.is_empty() {
18257 struct_ser.serialize_field("tables", &self.tables)?;
18258 }
18259 struct_ser.end()
18260 }
18261}
18262impl<'de> serde::Deserialize<'de> for WatermarkFilterNode {
18263 #[allow(deprecated)]
18264 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18265 where
18266 D: serde::Deserializer<'de>,
18267 {
18268 const FIELDS: &[&str] = &[
18269 "watermark_descs",
18270 "watermarkDescs",
18271 "tables",
18272 ];
18273
18274 #[allow(clippy::enum_variant_names)]
18275 enum GeneratedField {
18276 WatermarkDescs,
18277 Tables,
18278 }
18279 impl<'de> serde::Deserialize<'de> for GeneratedField {
18280 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18281 where
18282 D: serde::Deserializer<'de>,
18283 {
18284 struct GeneratedVisitor;
18285
18286 impl serde::de::Visitor<'_> for GeneratedVisitor {
18287 type Value = GeneratedField;
18288
18289 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18290 write!(formatter, "expected one of: {:?}", &FIELDS)
18291 }
18292
18293 #[allow(unused_variables)]
18294 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18295 where
18296 E: serde::de::Error,
18297 {
18298 match value {
18299 "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
18300 "tables" => Ok(GeneratedField::Tables),
18301 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18302 }
18303 }
18304 }
18305 deserializer.deserialize_identifier(GeneratedVisitor)
18306 }
18307 }
18308 struct GeneratedVisitor;
18309 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18310 type Value = WatermarkFilterNode;
18311
18312 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18313 formatter.write_str("struct stream_plan.WatermarkFilterNode")
18314 }
18315
18316 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkFilterNode, V::Error>
18317 where
18318 V: serde::de::MapAccess<'de>,
18319 {
18320 let mut watermark_descs__ = None;
18321 let mut tables__ = None;
18322 while let Some(k) = map_.next_key()? {
18323 match k {
18324 GeneratedField::WatermarkDescs => {
18325 if watermark_descs__.is_some() {
18326 return Err(serde::de::Error::duplicate_field("watermarkDescs"));
18327 }
18328 watermark_descs__ = Some(map_.next_value()?);
18329 }
18330 GeneratedField::Tables => {
18331 if tables__.is_some() {
18332 return Err(serde::de::Error::duplicate_field("tables"));
18333 }
18334 tables__ = Some(map_.next_value()?);
18335 }
18336 }
18337 }
18338 Ok(WatermarkFilterNode {
18339 watermark_descs: watermark_descs__.unwrap_or_default(),
18340 tables: tables__.unwrap_or_default(),
18341 })
18342 }
18343 }
18344 deserializer.deserialize_struct("stream_plan.WatermarkFilterNode", FIELDS, GeneratedVisitor)
18345 }
18346}